Add system cron discovery and management; bump to 0.2.0 #1

Merged
mdaleo404 merged 1 commits from cron-fix into main 2026-09-26 07:48:04 +00:00
19 changed files with 1127 additions and 53 deletions
Showing only changes of commit 58d8d0f378 - Show all commits

No files matched your search

+12 -3
View File
@@ -65,6 +65,12 @@ Create a cron job:
$ schedls new cleanup --cron --cron-expr '0 4 * * 0' -- /usr/local/bin/cleanup $ schedls new cleanup --cron --cron-expr '0 4 * * 0' -- /usr/local/bin/cleanup
``` ```
Create a system cron drop-in as root (runs as `root` unless `--run-as` is given):
```console
$ sudo schedls new updates --cron --system --daily 03:00 -- /usr/local/bin/updates
```
Prefer to be guided? Add `-i`/`--interactive` to `new` or `edit` and any Prefer to be guided? Add `-i`/`--interactive` to `new` or `edit` and any
omitted field is prompted for. Flags you do pass become pre-filled defaults: omitted field is prompted for. Flags you do pass become pre-filled defaults:
@@ -73,9 +79,12 @@ $ schedls new backup -i
$ schedls edit backup -i $ schedls edit backup -i
``` ```
Interactive mode is line-based (no external editor or pager), requires a For `new`, the wizard asks for the scope (user or system) unless `--user` or
terminal, and cannot be combined with `--json`. The collected values are shown `--system` was given; a system cron job then asks which user it should run as
in the usual preview and still require confirmation before anything is written. (default `root`). Interactive mode is line-based (no external editor or pager),
requires a terminal, and cannot be combined with `--json`. The collected values
are shown in the usual preview and still require confirmation before anything
is written.
Inspect, change, disable, remove: Inspect, change, disable, remove:
+7 -4
View File
@@ -82,9 +82,9 @@ Plan
``` ```
The caller previews the plan, obtains confirmation, then calls `apply`. Plans The caller previews the plan, obtains confirmation, then calls `apply`. Plans
snapshot existing content so a failed step can be rolled back. Cron plans also snapshot existing content so a failed step can be rolled back. Cron plans
record the previous crontab text and re-check it at apply time to detect record the previous crontab text or drop-in content and re-check it at apply
concurrent edits. time to detect concurrent edits.
## Exit codes ## Exit codes
@@ -124,4 +124,7 @@ The schema version is `1`.
``` ```
Rules: no ANSI sequences; ISO 8601 timestamps with explicit offsets; stable Rules: no ANSI sequences; ISO 8601 timestamps with explicit offsets; stable
field names; missing data is `null`, never invented. field names; missing data is `null`, never invented. Jobs whose `backend` is
`cron` additionally carry a `cron` object (`expression`, `shell`, `mailto`,
`line`, `user`, `environment`), where `user` is the run-as account for system
entries and `null` for the current user's crontab.
+13
View File
@@ -63,12 +63,20 @@ systemd extras (persistent, jitter, accuracy, working directory, environment).
```console ```console
$ schedls new backup --timer --daily 02:00 --persistent -- /usr/local/bin/backup /srv/data $ schedls new backup --timer --daily 02:00 --persistent -- /usr/local/bin/backup /srv/data
$ schedls new cleanup --cron --cron-expr '0 4 * * 0' -- /usr/local/bin/cleanup $ schedls new cleanup --cron --cron-expr '0 4 * * 0' -- /usr/local/bin/cleanup
$ sudo schedls new updates --cron --system --daily 03:00 -- /usr/local/bin/updates
$ sudo schedls new report --cron --system --daily 04:00 --run-as www-data -- /usr/local/bin/report
$ schedls new backup -i $ schedls new backup -i
``` ```
Creates a scheduled job. `NAME` and a backend (`--timer` or `--cron`) are Creates a scheduled job. `NAME` and a backend (`--timer` or `--cron`) are
required unless `--interactive` is used. required unless `--interactive` is used.
Cron jobs are created for the current user's crontab. With `--system` (root
only) the job is created as an `/etc/cron.d/schedls-NAME` drop-in and runs as
`root` unless `--run-as USER` is given. System cron names may contain letters,
digits, `_` and `-` only, because cron ignores `cron.d` file names containing a
period. `--run-as` is valid only together with `--cron --system`.
The command to run is everything after `--`: The command to run is everything after `--`:
```console ```console
@@ -112,6 +120,8 @@ $ schedls rm backup --dry-run
``` ```
Removes a schedls-managed job and its files. Unmanaged jobs cannot be removed. Removes a schedls-managed job and its files. Unmanaged jobs cannot be removed.
For a system cron job this removes the `/etc/cron.d/schedls-NAME` drop-in and
refuses to touch anything whose markers no longer match.
### `enable NAME` / `disable NAME` ### `enable NAME` / `disable NAME`
@@ -257,6 +267,9 @@ $ schedls edit backup -i
``` ```
- Prompts use stdin only; no external editor or pager is ever launched. - Prompts use stdin only; no external editor or pager is ever launched.
- `new` asks for the scope (user or system) unless `--user`/`--system` was
given. Choosing system for a cron job also asks which user it should run as
(`--run-as`, default `root`).
- A terminal is required. With piped or redirected input, `schedls` exits `3` - A terminal is required. With piped or redirected input, `schedls` exits `3`
and asks you to pass flags instead. and asks you to pass flags instead.
- Interactive mode cannot be combined with `--json` (exit `2`). - Interactive mode cannot be combined with `--json` (exit `2`).
+59 -8
View File
@@ -1,11 +1,25 @@
# cron backend # cron backend
`schedls` reads and edits the **current user's crontab** through the `crontab` `schedls` reads every cron source visible to it:
utility. It never writes to `/var/spool/cron*` directly.
- the **current user's crontab**, through the `crontab` utility;
- **system crontabs**: `/etc/crontab`, `/etc/cron.d/*`;
- **periodic directories**: `/etc/cron.{hourly,daily,weekly,monthly}/*`;
- **other users' crontabs** (`/var/spool/cron/crontabs/*` on Debian-style
systems, `/var/spool/cron/*` elsewhere) when running as root.
Cron jobs are named after where they live: system entries are `<file>:<line>`,
periodic scripts are named after the script, spool entries are `<user>:<line>`,
and the current user's crontab entries are `cron-<line>`. Jobs created by
`schedls` are listed under their schedule name instead.
`schedls` writes either through the `crontab` utility (current user) or as an
`/etc/cron.d/schedls-<name>` drop-in (system, root only). It never writes to
`/var/spool/cron*` directly.
## Reading ## Reading
The crontab is read with `crontab -l` and parsed losslessly into lines: The user crontab is read with `crontab -l` and parsed losslessly into lines:
- blank lines; - blank lines;
- comments; - comments;
@@ -13,12 +27,18 @@ The crontab is read with `crontab -l` and parsed losslessly into lines:
- five-field entries and `@` nicknames; - five-field entries and `@` nicknames;
- `schedls:begin` / `schedls:end` managed-block markers. - `schedls:begin` / `schedls:end` managed-block markers.
System crontabs add a user field between the schedule and the command
(`min hour dom mon dow USER command`). Files in `/etc/cron.d` whose names
contain a period, and hidden files, are ignored because cron ignores them too.
Periodic directories only contribute executable, run-parts-style file names.
Every unrelated line is preserved exactly. `schedls` does not reformat, sort, Every unrelated line is preserved exactly. `schedls` does not reformat, sort,
normalize, or rewrite crontab content it did not create. normalize, or rewrite crontab content it did not create.
## Managed blocks ## Managed blocks
Jobs created by `schedls` live in a delimited block: Jobs created by `schedls` in the current user's crontab live in a delimited
block:
```cron ```cron
# schedls:begin name=backup # schedls:begin name=backup
@@ -29,6 +49,30 @@ Jobs created by `schedls` live in a delimited block:
If markers are malformed or a `begin` has no matching `end`, mutations refuse If markers are malformed or a `begin` has no matching `end`, mutations refuse
to proceed rather than guess. to proceed rather than guess.
## System drop-ins
A system cron job is a file named after the schedule:
```cron
# Managed by schedls
# schedls:begin name=backup
0 2 * * * root /usr/local/bin/backup /srv/data
# schedls:end name=backup
```
Only `/etc/cron.d/schedls-<name>` files carrying a matching managed block are
treated as managed. A `schedls-` prefixed file whose markers are missing or
malformed is listed as unmanaged (`schedls-<name>:<line>`) and cannot be
removed. Creating system jobs requires root and a trusted `/etc/cron.d`
directory: not a symlink, owned by root, and not group- or other-writable.
Removal deletes only the drop-in file, after re-checking that it still matches
the snapshot and markers. Cron picks up `/etc/cron.d` changes by itself, so no
daemon reload is issued.
Use `--run-as USER` to run a system job as another account (default `root`).
The interactive wizard (`schedls new -i`) asks for the scope, and choosing the
system scope for a cron job then prompts for the run-as user.
## Command rendering ## Command rendering
Cron executes command text through a shell. `schedls` keeps an argv internally Cron executes command text through a shell. `schedls` keeps an argv internally
@@ -56,11 +100,16 @@ shell mode from characters such as `|`, `>`, `&&` or `$()`.
## Installation and validation ## Installation and validation
When the local `crontab` supports syntax testing (`crontab -T`), the new When the local `crontab` supports syntax testing (`crontab -T`), a new user
crontab is validated before installation. The native `crontab` install remains crontab is validated before installation. The native `crontab` install remains
authoritative. The previous crontab text is retained and restored if authoritative. The previous crontab text is retained and restored if
installation fails or the crontab changed since the plan was prepared. installation fails or the crontab changed since the plan was prepared.
System drop-ins are validated when they are rendered and written atomically;
`crontab -T` only understands user-format crontabs, so it is not used for them.
A file written by `schedls` is re-read and its managed block verified before
the command reports success.
Capabilities are feature-detected, never assumed: Capabilities are feature-detected, never assumed:
```python ```python
@@ -85,6 +134,8 @@ command-line compatibility but have no effect on cron jobs; see
## Not yet supported ## Not yet supported
- system cron (`/etc/crontab`, `/etc/cron.d`, periodic directories); - editing cron jobs (user or system);
- editing existing cron jobs; - token-level updates of `/etc/crontab` (read-only, shared file);
- cross-user crontabs. - anacron (`/etc/anacrontab`);
- removing or editing periodic directory scripts;
- modifying other users' spool crontabs (read-only, root only).
+12 -4
View File
@@ -58,7 +58,11 @@ never uses it to build a filesystem path: unit names are always derived from
the validated job name (`schedls-<name>.timer` / `.service`). Generated unit the validated job name (`schedls-<name>.timer` / `.service`). Generated unit
names are re-validated before they are written to a temporary directory, so a names are re-validated before they are written to a temporary directory, so a
crafted unit cannot redirect writes or removals outside the trusted unit crafted unit cannot redirect writes or removals outside the trusted unit
directory. directory. System cron drop-ins follow the same rule: the path is always
`/etc/cron.d/schedls-<name>` from the validated schedule name, with letters,
digits, `_` and `-` only, and removal refuses any path that is not exactly the
expected one. System names never contain a period, because cron ignores
`cron.d` files with dots.
### Untrusted output ### Untrusted output
@@ -89,14 +93,18 @@ Configuration is treated as opaque data. Malformed `schedls` cron markers cause
mutation to fail closed rather than guess. Unknown crontab lines are preserved mutation to fail closed rather than guess. Unknown crontab lines are preserved
byte-for-byte. A systemd unit whose name starts with `schedls-` is only treated byte-for-byte. A systemd unit whose name starts with `schedls-` is only treated
as managed when its file carries the `# Managed by schedls` and `# Name:` as managed when its file carries the `# Managed by schedls` and `# Name:`
markers, so a same-named foreign unit is not modified. markers, so a same-named foreign unit is not modified. Likewise a
`/etc/cron.d/schedls-<name>` drop-in is only managed when its begin/end markers
match the file name; otherwise it is listed as unmanaged and left alone.
### Partial operations ### Partial operations
systemd creation writes both units, reloads the manager, and enables the timer; systemd creation writes both units, reloads the manager, and enables the timer;
if a later step fails, or the operation is interrupted, the previous state is if a later step fails, or the operation is interrupted, the previous state is
restored and a partially enabled timer is disabled again. Cron installs are restored and a partially enabled timer is disabled again. Cron installs are
validated first and restored from the previous crontab text on failure. validated first and restored from the previous crontab text on failure. System
cron drop-ins are written atomically and a failed multi-file apply restores or
removes whatever it had already written.
### Supply chain ### Supply chain
@@ -105,6 +113,6 @@ in CI.
## Availability, privacy ## Availability, privacy
`0.1.0` requires `systemd-analyze` to create or validate calendar expressions `0.2.0` requires `systemd-analyze` to create or validate calendar expressions
and refuses the operation if it is unavailable. `schedls` makes no network and refuses the operation if it is unavailable. `schedls` makes no network
requests and collects no telemetry. requests and collects no telemetry.
+1 -1
View File
@@ -1,6 +1,6 @@
[project] [project]
name = "schedls" name = "schedls"
version = "0.1.0" version = "0.2.0"
description = "Inspect and manage Linux scheduled jobs" description = "Inspect and manage Linux scheduled jobs"
authors = [ authors = [
{ name = "Marco D'Aleo", email = "marco@marcodaleo.com" } { name = "Marco D'Aleo", email = "marco@marcodaleo.com" }
+414 -21
View File
@@ -4,7 +4,9 @@ from __future__ import annotations
import contextlib import contextlib
import os import os
import pwd
import re import re
import stat
import tempfile import tempfile
from collections.abc import Sequence from collections.abc import Sequence
from dataclasses import dataclass, field from dataclasses import dataclass, field
@@ -28,10 +30,16 @@ from ..models import (
) )
from ..renderers import cron as renderer from ..renderers import cron as renderer
from ..runner import CommandRunner from ..runner import CommandRunner
from ..security import validate_name from ..security import (
atomic_write_text,
check_trusted_directory,
remove_file,
validate_name,
)
from .base import ( from .base import (
Capabilities, Capabilities,
CommandPlan, CommandPlan,
FileChange,
MutationResult, MutationResult,
Plan, Plan,
SchedulerBackend, SchedulerBackend,
@@ -42,6 +50,31 @@ _META_RE = re.compile(r"(?P<key>[A-Za-z_][A-Za-z0-9_]*)=(?P<value>\S+)")
_ENV_RE = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*\s*=") _ENV_RE = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*\s*=")
_NICKNAME_RE = re.compile(r"^@[A-Za-z]+") _NICKNAME_RE = re.compile(r"^@[A-Za-z]+")
_MANAGED_PREFIX = "schedls-"
_CRON_D_NAME_RE = re.compile(r"\A[A-Za-z0-9_-]+\Z")
@dataclass(frozen=True)
class CronPaths:
"""Filesystem locations of system cron sources (injectable for tests)."""
crontab: str = "/etc/crontab"
cron_d: str = "/etc/cron.d"
hourly: str = "/etc/cron.hourly"
daily: str = "/etc/cron.daily"
weekly: str = "/etc/cron.weekly"
monthly: str = "/etc/cron.monthly"
spool_crontabs: str = "/var/spool/cron/crontabs"
spool: str = "/var/spool/cron"
def periodic_dirs(self) -> dict[str, str]:
return {
"@hourly": self.hourly,
"@daily": self.daily,
"@weekly": self.weekly,
"@monthly": self.monthly,
}
@dataclass @dataclass
class CronCapabilities: class CronCapabilities:
@@ -58,6 +91,7 @@ class CrontabEntry:
name: str | None = None name: str | None = None
expression: str | None = None expression: str | None = None
command: str | None = None command: str | None = None
user: str | None = None
marker_name: str | None = None marker_name: str | None = None
extra: dict[str, str] = field(default_factory=dict) extra: dict[str, str] = field(default_factory=dict)
@@ -72,20 +106,26 @@ class ManagedBlock:
class CrontabDocument: class CrontabDocument:
"""An exact, line-preserving view of a crontab.""" """An exact, line-preserving view of a crontab.
def __init__(self, text: str) -> None: ``system=True`` parses system crontabs (``/etc/crontab``,
``/etc/cron.d/*``), whose entries carry a user field between the schedule
and the command.
"""
def __init__(self, text: str, *, system: bool = False) -> None:
self.had_trailing_newline = text.endswith("\n") if text else False self.had_trailing_newline = text.endswith("\n") if text else False
body = text[:-1] if self.had_trailing_newline else text body = text[:-1] if self.had_trailing_newline else text
self.lines: list[str] = body.split("\n") if body != "" else [] self.lines: list[str] = body.split("\n") if body != "" else []
self.system = system
self.entries: list[CrontabEntry] = [] self.entries: list[CrontabEntry] = []
self.warnings: list[str] = [] self.warnings: list[str] = []
self._blocks: dict[str, ManagedBlock] = {} self._blocks: dict[str, ManagedBlock] = {}
self._parse() self._parse()
@classmethod @classmethod
def parse(cls, text: str) -> CrontabDocument: def parse(cls, text: str, *, system: bool = False) -> CrontabDocument:
return cls(text) return cls(text, system=system)
@property @property
def text(self) -> str: def text(self) -> str:
@@ -161,10 +201,10 @@ class CrontabDocument:
return CrontabEntry(number, raw, "comment") return CrontabEntry(number, raw, "comment")
if _ENV_RE.match(stripped): if _ENV_RE.match(stripped):
return CrontabEntry(number, raw, "env") return CrontabEntry(number, raw, "env")
expression, command = _split_job(stripped) expression, command, user = _split_job(stripped, system=self.system)
if expression is None: if expression is None:
return CrontabEntry(number, raw, "comment") return CrontabEntry(number, raw, "comment")
return CrontabEntry(number, raw, "job", expression=expression, command=command) return CrontabEntry(number, raw, "job", expression=expression, command=command, user=user)
# -- queries -------------------------------------------------------------- # -- queries --------------------------------------------------------------
@@ -212,17 +252,26 @@ class CrontabDocument:
return "\n".join(keep) + "\n" return "\n".join(keep) + "\n"
def _split_job(stripped: str) -> tuple[str | None, str | None]: def _split_job(stripped: str, *, system: bool = False) -> tuple[str | None, str | None, str | None]:
nickname = _NICKNAME_RE.match(stripped) nickname = _NICKNAME_RE.match(stripped)
if nickname: if nickname:
rest = stripped[nickname.end() :].strip() rest = stripped[nickname.end() :].strip()
if not rest: if not rest:
return None, None return None, None, None
return nickname.group(0), rest if system:
parts = stripped.split(None, 5) parts = rest.split(None, 1)
if len(parts) < 6: if len(parts) < 2:
return None, None return None, None, None
return " ".join(parts[:5]), parts[5] return nickname.group(0), parts[1], parts[0]
return nickname.group(0), rest, None
maxsplit = 6 if system else 5
parts = stripped.split(None, maxsplit)
needed = maxsplit + 1
if len(parts) < needed:
return None, None, None
if system:
return " ".join(parts[:5]), parts[6], parts[5]
return " ".join(parts[:5]), parts[5], None
class CronBackend(SchedulerBackend): class CronBackend(SchedulerBackend):
@@ -235,18 +284,32 @@ class CronBackend(SchedulerBackend):
validation=True, validation=True,
) )
def __init__(self, runner: CommandRunner) -> None: def __init__(self, runner: CommandRunner, paths: CronPaths | None = None) -> None:
self.runner = runner self.runner = runner
self.paths = paths or CronPaths()
self._capabilities: CronCapabilities | None = None self._capabilities: CronCapabilities | None = None
def available(self) -> bool: def crontab_available(self) -> bool:
return self.runner.has("crontab") return self.runner.has("crontab")
def file_sources_available(self) -> bool:
candidates = (
self.paths.crontab,
self.paths.cron_d,
*self.paths.periodic_dirs().values(),
self.paths.spool_crontabs,
self.paths.spool,
)
return any(os.path.exists(path) for path in candidates)
def available(self) -> bool:
return self.crontab_available() or self.file_sources_available()
def capabilities_info(self) -> CronCapabilities: def capabilities_info(self) -> CronCapabilities:
if self._capabilities is not None: if self._capabilities is not None:
return self._capabilities return self._capabilities
info = CronCapabilities() info = CronCapabilities()
if self.available(): if self.crontab_available():
completed = self.runner.run(["crontab", "-V"], env_policy="identity", check=False) completed = self.runner.run(["crontab", "-V"], env_policy="identity", check=False)
output = (completed.stdout or completed.stderr).strip() output = (completed.stdout or completed.stderr).strip()
if completed.returncode != 0 or not output: if completed.returncode != 0 or not output:
@@ -289,8 +352,20 @@ class CronBackend(SchedulerBackend):
raise OperationalError("could not read the current user's crontab", hint=detail or None) raise OperationalError("could not read the current user's crontab", hint=detail or None)
return CrontabDocument(completed.stdout) return CrontabDocument(completed.stdout)
# -- discovery ------------------------------------------------------------
def discover(self, scopes: Sequence[Scope]) -> list[ScheduledJob]: def discover(self, scopes: Sequence[Scope]) -> list[ScheduledJob]:
if Scope.USER not in scopes or not self.available(): jobs: list[ScheduledJob] = []
if Scope.USER in scopes:
jobs.extend(self._discover_user_crontab())
jobs.extend(self._discover_spool_crontabs())
if Scope.SYSTEM in scopes:
jobs.extend(self._discover_system_crontabs())
jobs.extend(self._discover_periodic_directories())
return jobs
def _discover_user_crontab(self) -> list[ScheduledJob]:
if not self.crontab_available():
return [] return []
document = self.read() document = self.read()
jobs: list[ScheduledJob] = [] jobs: list[ScheduledJob] = []
@@ -337,13 +412,187 @@ class CronBackend(SchedulerBackend):
) )
return jobs return jobs
def _discover_system_crontabs(self) -> list[ScheduledJob]:
jobs: list[ScheduledJob] = []
jobs.extend(self._discover_system_file(self.paths.crontab, managed_drop_in=False))
for name in self._list_dir(self.paths.cron_d):
if not _CRON_D_NAME_RE.match(name):
continue
path = os.path.join(self.paths.cron_d, name)
jobs.extend(self._discover_system_file(path, managed_drop_in=True))
return jobs
def _discover_system_file(self, path: str, *, managed_drop_in: bool) -> list[ScheduledJob]:
text = _read_text(path)
if text is None:
return []
document = CrontabDocument(text, system=True)
base = os.path.basename(path)
blocks = document.managed_blocks()
managed_name: str | None = None
warnings: list[str] = []
if managed_drop_in and base.startswith(_MANAGED_PREFIX):
expected = base[len(_MANAGED_PREFIX) :]
if expected in blocks and not document.warnings:
managed_name = expected
else:
warnings.append(
f"{path} looks like a schedls drop-in but its managed block is missing or "
"malformed; treating its jobs as unmanaged."
)
elif blocks:
warnings.append(
f"{path} contains schedls block markers but is not a schedls-owned drop-in; "
"treating its jobs as unmanaged."
)
jobs: list[ScheduledJob] = []
managed_range: set[int] = set()
if managed_name is not None:
block = blocks[managed_name]
managed_range = set(range(block.begin_index, block.end_index + 1))
job_line = next((line for line in block.job_lines if line.kind == "job"), None)
jobs.append(
ScheduledJob(
name=managed_name,
backend=Backend.CRON,
scope=Scope.SYSTEM,
managed=True,
enabled=None,
schedule=Schedule(ScheduleKind.CRON, (job_line.expression or "") if job_line else ""),
command=Command(argv=(), raw=job_line.command if job_line else ""),
source=JobSource("system cron drop-in", path=path, line=block.begin_index),
cron=CronDetails(
expression=job_line.expression if job_line else None,
raw_line=job_line.raw if job_line else None,
line=block.begin_index,
user=job_line.user if job_line else None,
),
)
)
for entry in document.entries:
if entry.kind != "job" or entry.index in managed_range:
continue
jobs.append(
ScheduledJob(
name=f"{base}:{entry.index}",
backend=Backend.CRON,
scope=Scope.SYSTEM,
managed=False,
enabled=None,
schedule=Schedule(ScheduleKind.CRON, entry.expression or ""),
command=Command(argv=(), raw=entry.command or ""),
source=JobSource("system cron", path=path, line=entry.index),
cron=CronDetails(
expression=entry.expression,
raw_line=entry.raw,
line=entry.index,
user=entry.user,
),
warnings=tuple(warnings),
)
)
return jobs
def _discover_periodic_directories(self) -> list[ScheduledJob]:
jobs: list[ScheduledJob] = []
for expression, directory in self.paths.periodic_dirs().items():
for name in self._list_dir(directory):
if not _CRON_D_NAME_RE.match(name):
continue
path = os.path.join(directory, name)
try:
st = os.stat(path)
except OSError:
continue
if not stat.S_ISREG(st.st_mode) or not st.st_mode & 0o111:
continue
jobs.append(
ScheduledJob(
name=name,
backend=Backend.CRON,
scope=Scope.SYSTEM,
managed=False,
enabled=None,
schedule=Schedule(ScheduleKind.CRON, expression),
command=Command(argv=(), raw=path),
source=JobSource(f"{os.path.basename(directory)} (run-parts)", path=path, line=None),
cron=CronDetails(expression=expression, user="root"),
)
)
return jobs
def _discover_spool_crontabs(self) -> list[ScheduledJob]:
if os.geteuid() != 0:
return []
directory = self._spool_directory()
if directory is None:
return []
current_user = self._current_user()
jobs: list[ScheduledJob] = []
for name in self._list_dir(directory):
if name.startswith(".") or name == current_user:
continue
path = os.path.join(directory, name)
if not os.path.isfile(path):
continue
text = _read_text(path)
if text is None:
continue
document = CrontabDocument(text)
for entry in document.entries:
if entry.kind != "job":
continue
jobs.append(
ScheduledJob(
name=f"{name}:{entry.index}",
backend=Backend.CRON,
scope=Scope.USER,
managed=False,
enabled=None,
schedule=Schedule(ScheduleKind.CRON, entry.expression or ""),
command=Command(argv=(), raw=entry.command or ""),
source=JobSource(f"user crontab ({name})", path=path, line=entry.index),
cron=CronDetails(
expression=entry.expression,
raw_line=entry.raw,
line=entry.index,
user=name,
),
)
)
return jobs
def _spool_directory(self) -> str | None:
if os.path.isdir(self.paths.spool_crontabs):
return self.paths.spool_crontabs
if os.path.isdir(self.paths.spool):
return self.paths.spool
return None
@staticmethod
def _current_user() -> str:
try:
return pwd.getpwuid(os.geteuid()).pw_name
except KeyError:
return ""
@staticmethod
def _list_dir(directory: str) -> list[str]:
try:
return sorted(os.listdir(directory))
except OSError:
return []
# -- planning ------------------------------------------------------------- # -- planning -------------------------------------------------------------
def plan_create(self, spec: JobSpec) -> Plan: def plan_create(self, spec: JobSpec) -> Plan:
validate_name(spec.name) validate_name(spec.name)
if spec.scope is Scope.SYSTEM:
return self._plan_create_system(spec)
if spec.scope is not Scope.USER: if spec.scope is not Scope.USER:
raise SafetyRefusalError("system cron management is not supported.") raise SafetyRefusalError("unsupported cron scope.")
if not self.available(): if not self.crontab_available():
raise OperationalError("crontab is not available") raise OperationalError("crontab is not available")
expression = renderer.validate_expression(spec.cron_expression or "") expression = renderer.validate_expression(spec.cron_expression or "")
line = renderer.render_line(expression, spec.command) line = renderer.render_line(expression, spec.command)
@@ -360,6 +609,7 @@ class CronBackend(SchedulerBackend):
plan.commands = self._install_commands(new_text) plan.commands = self._install_commands(new_text)
plan.warnings.append("Cron executes command text through /bin/sh (or the crontab's configured SHELL).") plan.warnings.append("Cron executes command text through /bin/sh (or the crontab's configured SHELL).")
plan.payload = { plan.payload = {
"mode": "crontab",
"action": "create", "action": "create",
"name": spec.name, "name": spec.name,
"old_text": document.text, "old_text": document.text,
@@ -367,12 +617,55 @@ class CronBackend(SchedulerBackend):
} }
return plan return plan
def _plan_create_system(self, spec: JobSpec) -> Plan:
if os.geteuid() != 0:
raise SafetyRefusalError(
"creating a system cron job requires appropriate privileges.",
hint="Run the command under sudo yourself if that is your intention:\n sudo schedls new ... --system",
)
renderer.validate_system_name(spec.name)
directory = self.paths.cron_d
if not os.path.isdir(directory):
raise OperationalError(f"system cron directory does not exist: {directory}")
check_trusted_directory(directory, expected_uid=0)
expression = renderer.validate_expression(spec.cron_expression or "")
run_as = renderer.validate_run_as(spec.run_as or "root")
line = renderer.render_system_line(expression, spec.command, run_as)
content = renderer.render_system_file(spec.name, [line])
path = os.path.join(directory, f"{_MANAGED_PREFIX}{spec.name}")
if os.path.lexists(path):
raise ConflictError(
f"schedule {spec.name!r} already exists ({path}).",
hint="Use 'schedls rm' instead.",
)
plan = Plan(backend=self.name, action="create")
plan.summary = [
("Backend", "cron (system)"),
("Schedule", expression),
("Run as", run_as),
("Command", spec.command.display()),
("File", path),
]
plan.files = [FileChange(path=path, content=content, mode=0o644, expected_uid=0)]
plan.warnings.append("Cron executes command text through /bin/sh (or the crontab's configured SHELL).")
plan.payload = {
"mode": "file",
"action": "create",
"name": spec.name,
"path": path,
"expected_uid": 0,
"snapshots": {path: None},
}
return plan
def plan_remove(self, job: ScheduledJob) -> Plan: def plan_remove(self, job: ScheduledJob) -> Plan:
if not job.managed: if not job.managed:
raise SafetyRefusalError( raise SafetyRefusalError(
f"{job.name} was not created by schedls.", f"{job.name} was not created by schedls.",
hint="schedls will not modify unmanaged schedules by default.", hint="schedls will not modify unmanaged schedules by default.",
) )
if job.scope is Scope.SYSTEM:
return self._plan_remove_system(job)
document = self.read() document = self.read()
new_text = document.without_block(job.name) new_text = document.without_block(job.name)
plan = Plan(backend=self.name, action="remove") plan = Plan(backend=self.name, action="remove")
@@ -382,6 +675,7 @@ class CronBackend(SchedulerBackend):
] ]
plan.commands = self._install_commands(new_text) plan.commands = self._install_commands(new_text)
plan.payload = { plan.payload = {
"mode": "crontab",
"action": "remove", "action": "remove",
"name": job.name, "name": job.name,
"old_text": document.text, "old_text": document.text,
@@ -389,12 +683,49 @@ class CronBackend(SchedulerBackend):
} }
return plan return plan
def _plan_remove_system(self, job: ScheduledJob) -> Plan:
if os.geteuid() != 0:
raise SafetyRefusalError(
"removing a system cron job requires appropriate privileges.",
hint="Run the command under sudo yourself if that is your intention:\n sudo schedls rm ...",
)
path = job.source.path
expected_path = os.path.join(self.paths.cron_d, f"{_MANAGED_PREFIX}{job.name}")
if path != expected_path:
raise SafetyRefusalError(f"refusing to remove unexpected system cron file: {path!r}")
content = _read_text(path)
if content is None:
raise OperationalError(f"could not read {path}")
document = CrontabDocument(content, system=True)
if document.warnings or document.find_block(job.name) is None:
raise SafetyRefusalError(f"{path} is no longer a valid schedls-managed drop-in; refusing to remove it.")
plan = Plan(backend=self.name, action="remove")
plan.summary = [
("Backend", "cron (system)"),
("Will remove", path),
]
plan.files = [FileChange(path=path, content=None, expected_uid=0)]
plan.payload = {
"mode": "file",
"action": "remove",
"name": job.name,
"path": path,
"expected_uid": 0,
"snapshots": {path: content},
}
return plan
def _install_commands(self, new_text: str) -> list[CommandPlan]: def _install_commands(self, new_text: str) -> list[CommandPlan]:
return [CommandPlan(("crontab", "-"), "install crontab", "identity", input_text=new_text)] return [CommandPlan(("crontab", "-"), "install crontab", "identity", input_text=new_text)]
# -- applying ------------------------------------------------------------- # -- applying -------------------------------------------------------------
def apply(self, plan: Plan) -> MutationResult: def apply(self, plan: Plan) -> MutationResult:
if plan.payload.get("mode") == "file":
return self._apply_file(plan)
return self._apply_crontab(plan)
def _apply_crontab(self, plan: Plan) -> MutationResult:
old_text = plan.payload.get("old_text", "") old_text = plan.payload.get("old_text", "")
new_text = plan.payload.get("new_text", "") new_text = plan.payload.get("new_text", "")
current_document = self.read() current_document = self.read()
@@ -417,6 +748,53 @@ class CronBackend(SchedulerBackend):
messages=["Crontab updated."], messages=["Crontab updated."],
) )
def _apply_file(self, plan: Plan) -> MutationResult:
snapshots: dict[str, str | None] = plan.payload.get("snapshots", {})
expected_uid = plan.payload.get("expected_uid", 0)
written: list[str] = []
try:
for change in plan.files:
if _read_text(change.path) != snapshots.get(change.path):
raise SafetyRefusalError(
f"{change.path} changed on disk after the plan was prepared; refusing to apply."
)
if change.content is None:
if remove_file(change.path, expected_uid=expected_uid):
written.append(change.path)
else:
atomic_write_text(
change.path,
change.content,
mode=change.mode,
expected_uid=expected_uid,
)
written.append(change.path)
except BaseException as exc:
self._rollback_file(written, snapshots, expected_uid)
if isinstance(exc, KeyboardInterrupt | SystemExit):
raise
if isinstance(exc, OperationalError | SafetyRefusalError):
raise
raise OperationalError(str(exc)) from exc
self._verify_installed(plan)
action = plan.payload.get("action")
message = "System cron drop-in installed." if action == "create" else "System cron drop-in removed."
return MutationResult(changed=bool(written), messages=[message])
def _rollback_file(
self,
written: list[str],
snapshots: dict[str, str | None],
expected_uid: int | None,
) -> None:
for path in reversed(written):
previous = snapshots.get(path)
with contextlib.suppress(Exception):
if previous is None:
remove_file(path, expected_uid=expected_uid)
else:
atomic_write_text(path, previous, mode=0o644, expected_uid=expected_uid)
def _validate(self, text: str) -> None: def _validate(self, text: str) -> None:
if not self.capabilities_info().supports_validation: if not self.capabilities_info().supports_validation:
return return
@@ -433,11 +811,26 @@ class CronBackend(SchedulerBackend):
os.unlink(name) os.unlink(name)
def _verify_installed(self, plan: Plan) -> None: def _verify_installed(self, plan: Plan) -> None:
document = self.read()
name = plan.payload.get("name") name = plan.payload.get("name")
if plan.payload.get("mode") == "file":
if plan.payload.get("action") != "create" or not name:
return
document = CrontabDocument(_read_text(plan.payload.get("path", "")) or "", system=True)
if name not in document.managed_blocks():
raise OperationalError("the drop-in was written but the schedls block could not be verified.")
return
document = self.read()
if plan.payload.get("action") == "create" and name and name not in document.managed_blocks(): if plan.payload.get("action") == "create" and name and name not in document.managed_blocks():
raise OperationalError("the crontab was installed but the schedls block could not be verified.") raise OperationalError("the crontab was installed but the schedls block could not be verified.")
def _restore(self, text: str) -> None: def _restore(self, text: str) -> None:
with contextlib.suppress(Exception): with contextlib.suppress(Exception):
self.runner.run(["crontab", "-"], env_policy="identity", check=False, input_text=text) self.runner.run(["crontab", "-"], env_policy="identity", check=False, input_text=text)
def _read_text(path: str) -> str | None:
try:
with open(path, encoding="utf-8") as handle:
return handle.read()
except OSError:
return None
+37 -5
View File
@@ -172,6 +172,11 @@ def _add_schedule_options(parser: argparse.ArgumentParser, *, creation: bool) ->
def _add_creation_options(parser: argparse.ArgumentParser) -> None: def _add_creation_options(parser: argparse.ArgumentParser) -> None:
_add_schedule_options(parser, creation=True) _add_schedule_options(parser, creation=True)
parser.add_argument(
"--run-as",
metavar="USER",
help="run a system cron job as USER (default: root)",
)
_add_mutation_flags(parser) _add_mutation_flags(parser)
@@ -496,6 +501,8 @@ def _spec_for_new(args: argparse.Namespace, tail: list[str]) -> JobSpec:
if args.timer: if args.timer:
if args.cron_expr: if args.cron_expr:
raise UsageError("--cron-expr is a cron option; use --calendar for systemd timers.") raise UsageError("--cron-expr is a cron option; use --calendar for systemd timers.")
if args.run_as:
raise UsageError("--run-as is a system cron option.")
calendar = _calendar_from_args(args) calendar = _calendar_from_args(args)
if not calendar: if not calendar:
raise UsageError("no schedule given.", hint="Use --calendar or a convenience flag such as --daily.") raise UsageError("no schedule given.", hint="Use --calendar or a convenience flag such as --daily.")
@@ -517,14 +524,20 @@ def _spec_for_new(args: argparse.Namespace, tail: list[str]) -> JobSpec:
raise UsageError("--jitter/--accuracy/--persistent/--working-directory are systemd options.") raise UsageError("--jitter/--accuracy/--persistent/--working-directory are systemd options.")
if args.env: if args.env:
raise UsageError("--env is a systemd option; cron environment variables are not supported yet.") raise UsageError("--env is a systemd option; cron environment variables are not supported yet.")
if _resolve_scope(args) is Scope.SYSTEM:
raise UsageError(
"--system is not supported for cron jobs.",
hint="Cron jobs are always created for the current user.",
)
expression = _cron_expression_from_args(args) expression = _cron_expression_from_args(args)
if not expression: if not expression:
raise UsageError("no schedule given.", hint="Use --cron-expr or a convenience flag such as --daily.") raise UsageError("no schedule given.", hint="Use --cron-expr or a convenience flag such as --daily.")
if scope is Scope.SYSTEM:
return JobSpec(
name=args.name,
backend=Backend.CRON,
scope=Scope.SYSTEM,
command=command,
cron_expression=expression,
run_as=args.run_as or "root",
)
if args.run_as:
raise UsageError("--run-as requires --system for cron jobs.", hint="Cron jobs run as the current user.")
return JobSpec( return JobSpec(
name=args.name, name=args.name,
backend=Backend.CRON, backend=Backend.CRON,
@@ -607,6 +620,22 @@ def _wizard_backend(args: argparse.Namespace, prompter: Prompter) -> Backend:
return Backend.CRON return Backend.CRON
def _wizard_scope(args: argparse.Namespace, backend: Backend, prompter: Prompter) -> Scope:
provided = getattr(args, "scope_group", None) or getattr(args, "scope_filter", None)
if provided is not None:
return Scope(provided)
if backend is Backend.SYSTEMD:
options = [("user", "user timer"), ("system", "system timer (root)")]
else:
options = [
("user", "current user's crontab"),
("system", "system drop-in /etc/cron.d (root)"),
]
selected = prompter.choice("Scope:", options, default="user")
args.scope_group = Scope.SYSTEM if selected == "system" else Scope.USER
return Scope(args.scope_group)
def _wizard_command(args: argparse.Namespace, tail: list[str], prompter: Prompter) -> list[str]: def _wizard_command(args: argparse.Namespace, tail: list[str], prompter: Prompter) -> list[str]:
if args.shell or tail: if args.shell or tail:
return tail return tail
@@ -622,6 +651,9 @@ def _wizard_new(args: argparse.Namespace, tail: list[str], prompter: Prompter) -
if args.name is None: if args.name is None:
args.name = prompter.text("Schedule name", validator=validate_name) args.name = prompter.text("Schedule name", validator=validate_name)
backend = _wizard_backend(args, prompter) backend = _wizard_backend(args, prompter)
scope = _wizard_scope(args, backend, prompter)
if backend is Backend.CRON and scope is Scope.SYSTEM and args.run_as is None:
args.run_as = prompter.text("Run as user", default="root", validator=cron_renderer.validate_run_as)
tail = _wizard_command(args, tail, prompter) tail = _wizard_command(args, tail, prompter)
if not _has_schedule(args): if not _has_schedule(args):
_apply_schedule(args, prompter.schedule(backend)) _apply_schedule(args, prompter.schedule(backend))
+2
View File
@@ -99,6 +99,7 @@ class CronDetails:
raw_line: str | None = None raw_line: str | None = None
line: int | None = None line: int | None = None
environment: tuple[tuple[str, str], ...] = () environment: tuple[tuple[str, str], ...] = ()
user: str | None = None
@dataclass(frozen=True) @dataclass(frozen=True)
@@ -134,6 +135,7 @@ class JobSpec:
command: Command command: Command
calendar: tuple[str, ...] = () calendar: tuple[str, ...] = ()
cron_expression: str | None = None cron_expression: str | None = None
run_as: str | None = None
persistent: bool = False persistent: bool = False
jitter: str | None = None jitter: str | None = None
accuracy: str | None = None accuracy: str | None = None
+9 -2
View File
@@ -21,7 +21,7 @@ def run_doctor(
) -> None: ) -> None:
systemd = _systemd_report(runner, systemd_backend) systemd = _systemd_report(runner, systemd_backend)
cron = _cron_report(runner, cron_backend) cron = _cron_report(runner, cron_backend)
usable = systemd["available"] or cron["crontab_available"] usable = systemd["available"] or cron["crontab_available"] or cron["file_sources"]
if output.json_mode: if output.json_mode:
output.emit_json( output.emit_json(
@@ -54,6 +54,7 @@ def run_doctor(
output.key_values( output.key_values(
[ [
("crontab", _yes_no(cron["crontab_available"])), ("crontab", _yes_no(cron["crontab_available"])),
("system cron files", _yes_no(cron["file_sources"])),
("implementation", cron["implementation"] or "unknown"), ("implementation", cron["implementation"] or "unknown"),
("current user allowed", _yes_no(cron["user_allowed"])), ("current user allowed", _yes_no(cron["user_allowed"])),
("syntax validation", _yes_no(cron["validation"])), ("syntax validation", _yes_no(cron["validation"])),
@@ -80,18 +81,24 @@ def _systemd_report(runner: CommandRunner, systemd_backend: SystemdBackend) -> d
def _cron_report(runner: CommandRunner, cron_backend: CronBackend) -> dict[str, Any]: def _cron_report(runner: CommandRunner, cron_backend: CronBackend) -> dict[str, Any]:
crontab_available = cron_backend.crontab_available()
file_sources = cron_backend.file_sources_available()
if not cron_backend.available(): if not cron_backend.available():
return { return {
"crontab_available": False, "crontab_available": False,
"file_sources": file_sources,
"implementation": None, "implementation": None,
"user_allowed": False, "user_allowed": False,
"validation": False, "validation": False,
} }
info = cron_backend.capabilities_info() info = cron_backend.capabilities_info()
allowed = False
if crontab_available:
completed = runner.run(["crontab", "-l"], env_policy="identity", check=False) completed = runner.run(["crontab", "-l"], env_policy="identity", check=False)
allowed = completed.returncode == 0 or "no crontab" in (completed.stderr + completed.stdout).lower() allowed = completed.returncode == 0 or "no crontab" in (completed.stderr + completed.stdout).lower()
return { return {
"crontab_available": True, "crontab_available": crontab_available,
"file_sources": file_sources,
"implementation": info.implementation, "implementation": info.implementation,
"user_allowed": allowed, "user_allowed": allowed,
"validation": info.supports_validation, "validation": info.supports_validation,
+4
View File
@@ -139,6 +139,10 @@ def render_show(output: Output, job: ScheduledJob) -> None:
if job.cron is not None: if job.cron is not None:
output.line() output.line()
output.key_values([("Source", job.source.detail)]) output.key_values([("Source", job.source.detail)])
if job.source.path:
output.key_values([("File", job.source.path)])
if job.cron.user:
output.key_values([("Run as", job.cron.user)])
if job.cron.shell: if job.cron.shell:
output.key_values([("SHELL", job.cron.shell)]) output.key_values([("SHELL", job.cron.shell)])
if job.cron.mailto: if job.cron.mailto:
+1
View File
@@ -164,6 +164,7 @@ def job_to_dict(job: ScheduledJob) -> dict[str, Any]:
"shell": job.cron.shell, "shell": job.cron.shell,
"mailto": job.cron.mailto, "mailto": job.cron.mailto,
"line": job.cron.line, "line": job.cron.line,
"user": job.cron.user,
"environment": [list(item) for item in job.cron.environment], "environment": [list(item) for item in job.cron.environment],
} }
return data return data
+35 -1
View File
@@ -13,7 +13,7 @@ import shlex
from ..errors import InvalidScheduleError, SafetyRefusalError from ..errors import InvalidScheduleError, SafetyRefusalError
from ..models import Command from ..models import Command
from ..security import has_unsafe_control_characters from ..security import MANAGED_COMMENT, has_unsafe_control_characters
BLOCK_BEGIN = "# schedls:begin name={name}{extra}" BLOCK_BEGIN = "# schedls:begin name={name}{extra}"
BLOCK_END = "# schedls:end name={name}" BLOCK_END = "# schedls:end name={name}"
@@ -31,6 +31,8 @@ _NICKNAMES = {
"@hourly", "@hourly",
} }
_RANGE_RE = re.compile(r"^[0-9]{1,2}-[0-9]{1,2}$") _RANGE_RE = re.compile(r"^[0-9]{1,2}-[0-9]{1,2}$")
_SYSTEM_NAME_RE = re.compile(r"\A[A-Za-z0-9][A-Za-z0-9_-]{0,63}\Z")
_USER_RE = re.compile(r"\A[A-Za-z0-9_][A-Za-z0-9_.-]{0,31}\Z")
def escape_percent(text: str) -> str: def escape_percent(text: str) -> str:
@@ -122,6 +124,38 @@ def render_line(expression: str, command: Command) -> str:
return f"{validate_expression(expression)} {render_command(command)}" return f"{validate_expression(expression)} {render_command(command)}"
def validate_run_as(user: str) -> str:
if not _USER_RE.match(user):
raise InvalidScheduleError(
f"invalid run-as user: {user!r}",
hint="User names start alphanumeric or '_', then letters, digits, '_', '.' or '-'.",
)
return user
def validate_system_name(name: str) -> str:
"""Validate a name for an ``/etc/cron.d/schedls-<name>`` drop-in.
Cron ignores files whose names contain a period, so this is stricter than
the general schedule-name grammar.
"""
if not _SYSTEM_NAME_RE.match(name):
raise InvalidScheduleError(
f"invalid system schedule name: {name!r}",
hint="System cron names allow letters, digits, '_' and '-' only.",
)
return name
def render_system_line(expression: str, command: Command, user: str) -> str:
return f"{validate_expression(expression)} {validate_run_as(user)} {render_command(command)}"
def render_block(name: str, lines: list[str], *, extra: str = "") -> str: def render_block(name: str, lines: list[str], *, extra: str = "") -> str:
body = [BLOCK_BEGIN.format(name=name, extra=extra), *lines, BLOCK_END.format(name=name)] body = [BLOCK_BEGIN.format(name=name, extra=extra), *lines, BLOCK_END.format(name=name)]
return "\n".join(body) + "\n" return "\n".join(body) + "\n"
def render_system_file(name: str, lines: list[str]) -> str:
"""Render a complete schedls-owned drop-in for ``/etc/cron.d``."""
return f"{MANAGED_COMMENT}\n{render_block(name, lines)}"
+48
View File
@@ -11,6 +11,7 @@ from schedls.runner import CommandRunner
pytestmark = pytest.mark.integration pytestmark = pytest.mark.integration
NAME = "schedls-it-cron" NAME = "schedls-it-cron"
SYSTEM_NAME = "schedls-it-system"
def _backend_or_skip() -> CronBackend: def _backend_or_skip() -> CronBackend:
@@ -62,3 +63,50 @@ def test_cron_lifecycle_preserves_content() -> None:
assert backend.find(NAME) is None assert backend.find(NAME) is None
finally: finally:
_restore(backend, original) _restore(backend, original)
def test_system_cron_discovery_never_executes() -> None:
if not os.path.isdir("/etc/cron.d"):
pytest.skip("/etc/cron.d not present")
backend = CronBackend(CommandRunner())
jobs = backend.discover([Scope.SYSTEM])
for job in jobs:
assert job.backend is Backend.CRON
assert job.scope is Scope.SYSTEM
assert not job.command.argv
assert job.cron is not None
def test_system_cron_lifecycle() -> None:
if os.geteuid() != 0:
pytest.skip("system cron mutation requires root")
if os.environ.get("SCHEDLS_RUN_CRON_TESTS") != "1":
pytest.skip("set SCHEDLS_RUN_CRON_TESTS=1 to allow cron.d mutation")
if not os.path.isdir("/etc/cron.d"):
pytest.skip("/etc/cron.d not present")
backend = CronBackend(CommandRunner())
path = f"/etc/cron.d/schedls-{SYSTEM_NAME}"
spec = JobSpec(
name=SYSTEM_NAME,
backend=Backend.CRON,
scope=Scope.SYSTEM,
command=Command(argv=("/usr/bin/true",)),
cron_expression="15 2 * * *",
run_as="root",
)
try:
plan = backend.plan_create(spec)
assert path in [change.path for change in plan.files]
backend.apply(plan)
job = backend.find(SYSTEM_NAME)
assert job is not None
assert job.managed is True
assert job.cron is not None and job.cron.user == "root"
backend.apply(backend.plan_remove(job))
assert not os.path.exists(path)
assert backend.find(SYSTEM_NAME) is None
finally:
if os.path.exists(path):
os.unlink(path)
+20 -1
View File
@@ -102,8 +102,27 @@ def test_spec_for_new_rejects_cron_expr_for_timer() -> None:
_spec_for_new(args, ["/bin/true"]) _spec_for_new(args, ["/bin/true"])
def test_spec_for_new_rejects_system_scope_for_cron() -> None: def test_spec_for_new_system_cron() -> None:
args = build_parser().parse_args(["new", "x", "--cron", "--daily", "02:00", "--system"]) args = build_parser().parse_args(["new", "x", "--cron", "--daily", "02:00", "--system"])
spec = _spec_for_new(args, ["/bin/true"])
assert spec.scope is Scope.SYSTEM
assert spec.run_as == "root"
def test_spec_for_new_system_cron_run_as() -> None:
args = build_parser().parse_args(["new", "x", "--cron", "--daily", "02:00", "--system", "--run-as", "www-data"])
spec = _spec_for_new(args, ["/bin/true"])
assert spec.run_as == "www-data"
def test_spec_for_new_rejects_run_as_for_user_cron() -> None:
args = build_parser().parse_args(["new", "x", "--cron", "--daily", "02:00", "--run-as", "www-data"])
with pytest.raises(UsageError):
_spec_for_new(args, ["/bin/true"])
def test_spec_for_new_rejects_run_as_for_timer() -> None:
args = build_parser().parse_args(["new", "x", "--timer", "--daily", "02:00", "--run-as", "www-data"])
with pytest.raises(UsageError): with pytest.raises(UsageError):
_spec_for_new(args, ["/bin/true"]) _spec_for_new(args, ["/bin/true"])
+304
View File
@@ -0,0 +1,304 @@
from __future__ import annotations
import os
import pytest
from schedls.backends.base import FileChange, Plan
from schedls.backends.cron import CronBackend, CronPaths
from schedls.errors import ConflictError, InvalidScheduleError, SafetyRefusalError
from schedls.models import Backend, Command, JobSpec, Scope
from schedls.renderers import cron as renderer
def _make_paths(tmp_path) -> CronPaths:
root = tmp_path / "etc"
root.mkdir()
return CronPaths(
crontab=str(root / "crontab"),
cron_d=str(root / "cron.d"),
hourly=str(root / "cron.hourly"),
daily=str(root / "cron.daily"),
weekly=str(root / "cron.weekly"),
monthly=str(root / "cron.monthly"),
spool_crontabs=str(tmp_path / "var" / "spool" / "cron" / "crontabs"),
spool=str(tmp_path / "var" / "spool" / "cron"),
)
def _write(path, text: str, mode: int = 0o644):
path.parent.mkdir(parents=True, exist_ok=True)
path.write_text(text)
path.chmod(mode)
return path
def test_available_without_crontab_uses_file_sources(tmp_path, fake_runner) -> None:
paths = _make_paths(tmp_path)
assert CronBackend(fake_runner, paths).available() is False
_write(tmp_path / "etc/cron.d/backup", "0 2 * * * root /usr/bin/backup\n")
assert CronBackend(fake_runner, paths).available() is True
def test_discovers_system_crontabs(tmp_path, fake_runner) -> None:
paths = _make_paths(tmp_path)
_write(
tmp_path / "etc/crontab",
"SHELL=/bin/sh\n17 * * * * root /usr/bin/hourly\n@daily www-data /usr/bin/report\n",
)
_write(tmp_path / "etc/cron.d/backup", "0 2 * * * root /usr/bin/backup\n")
_write(
tmp_path / "etc/cron.d/schedls-cleanup",
renderer.render_system_file("cleanup", ["30 3 * * 0 deploy /usr/bin/cleanup"]),
)
_write(tmp_path / "etc/cron.d/with.dot", "0 2 * * * root /usr/bin/ignored\n")
_write(tmp_path / "etc/cron.d/.placeholder", "")
jobs = CronBackend(fake_runner, paths).discover([Scope.SYSTEM])
by_name = {job.name: job for job in jobs}
assert set(by_name) == {"crontab:2", "crontab:3", "backup:1", "cleanup"}
assert by_name["crontab:2"].scope is Scope.SYSTEM
assert by_name["crontab:2"].cron.user == "root"
assert by_name["crontab:2"].command.raw == "/usr/bin/hourly"
assert by_name["crontab:3"].cron.user == "www-data"
assert by_name["backup:1"].managed is False
assert by_name["backup:1"].schedule.expression == "0 2 * * *"
assert by_name["backup:1"].source.path == paths.cron_d + "/backup"
managed = by_name["cleanup"]
assert managed.managed is True
assert managed.cron.user == "deploy"
assert managed.schedule.expression == "30 3 * * 0"
assert managed.source.path == paths.cron_d + "/schedls-cleanup"
def test_discovers_periodic_directories(tmp_path, fake_runner) -> None:
paths = _make_paths(tmp_path)
_write(tmp_path / "etc/cron.daily/logrotate", "#!/bin/sh\n", mode=0o755)
_write(tmp_path / "etc/cron.daily/README", "text\n", mode=0o644)
_write(tmp_path / "etc/cron.hourly/.hidden", "#!/bin/sh\n", mode=0o755)
jobs = CronBackend(fake_runner, paths).discover([Scope.SYSTEM])
assert [job.name for job in jobs] == ["logrotate"]
job = jobs[0]
assert job.schedule.expression == "@daily"
assert job.command.display() == paths.daily + "/logrotate"
assert job.cron.user == "root"
assert job.managed is False
assert "cron.daily" in job.source.detail
def test_spool_crontabs_require_root(tmp_path, fake_runner, monkeypatch) -> None:
paths = _make_paths(tmp_path)
_write(tmp_path / "var/spool/cron/crontabs/alice", "5 4 * * * /usr/bin/alice\n")
_write(tmp_path / "var/spool/cron/crontabs/root", "5 4 * * * /usr/bin/root\n")
backend = CronBackend(fake_runner, paths)
monkeypatch.setattr(os, "geteuid", lambda: 1000)
assert backend.discover([Scope.USER]) == []
monkeypatch.setattr(os, "geteuid", lambda: 0)
monkeypatch.setattr(CronBackend, "_current_user", staticmethod(lambda: "root"))
jobs = backend.discover([Scope.USER])
assert [job.name for job in jobs] == ["alice:1"]
assert jobs[0].scope is Scope.USER
assert jobs[0].cron.user == "alice"
assert jobs[0].source.path.endswith("crontabs/alice")
def test_spool_falls_back_to_flat_layout(tmp_path, fake_runner, monkeypatch) -> None:
paths = _make_paths(tmp_path)
_write(tmp_path / "var/spool/cron/alice", "5 4 * * * /usr/bin/alice\n")
(tmp_path / "var/spool/cron/atjobs").mkdir(parents=True)
monkeypatch.setattr(os, "geteuid", lambda: 0)
monkeypatch.setattr(CronBackend, "_current_user", staticmethod(lambda: "root"))
jobs = CronBackend(fake_runner, paths).discover([Scope.USER])
assert [job.name for job in jobs] == ["alice:1"]
def test_malformed_drop_in_is_unmanaged(tmp_path, fake_runner) -> None:
paths = _make_paths(tmp_path)
_write(tmp_path / "etc/cron.d/schedls-broken", "0 2 * * * root /bin/true\n")
jobs = CronBackend(fake_runner, paths).discover([Scope.SYSTEM])
assert [job.name for job in jobs] == ["schedls-broken:1"]
assert jobs[0].managed is False
assert jobs[0].warnings
def _system_spec(**overrides) -> JobSpec:
values = {
"name": "backup",
"backend": Backend.CRON,
"scope": Scope.SYSTEM,
"command": Command(argv=("/usr/bin/backup", "/srv/data")),
"cron_expression": "0 2 * * *",
"run_as": "www-data",
}
values.update(overrides)
return JobSpec(**values)
def test_plan_create_system_cron(tmp_path, fake_runner, monkeypatch) -> None:
paths = _make_paths(tmp_path)
(tmp_path / "etc/cron.d").mkdir(parents=True, exist_ok=True)
monkeypatch.setattr(os, "geteuid", lambda: 0)
monkeypatch.setattr("schedls.backends.cron.check_trusted_directory", lambda path, *, expected_uid: None)
plan = CronBackend(fake_runner, paths).plan_create(_system_spec())
assert plan.payload["mode"] == "file"
assert plan.payload["expected_uid"] == 0
assert not plan.commands
change = plan.files[0]
assert change.path == paths.cron_d + "/schedls-backup"
assert "0 2 * * * www-data /usr/bin/backup /srv/data" in change.content
assert "# schedls:begin name=backup" in change.content
assert ("Run as", "www-data") in plan.summary
def test_plan_create_system_cron_requires_root(tmp_path, fake_runner, monkeypatch) -> None:
paths = _make_paths(tmp_path)
monkeypatch.setattr(os, "geteuid", lambda: 1000)
with pytest.raises(SafetyRefusalError):
CronBackend(fake_runner, paths).plan_create(_system_spec())
def test_plan_create_system_cron_rejects_dotted_name(tmp_path, fake_runner, monkeypatch) -> None:
paths = _make_paths(tmp_path)
monkeypatch.setattr(os, "geteuid", lambda: 0)
with pytest.raises(InvalidScheduleError):
CronBackend(fake_runner, paths).plan_create(_system_spec(name="my.job"))
def test_plan_create_system_cron_conflict(tmp_path, fake_runner, monkeypatch) -> None:
paths = _make_paths(tmp_path)
_write(tmp_path / "etc/cron.d/schedls-backup", "0 2 * * * root /bin/true\n")
monkeypatch.setattr(os, "geteuid", lambda: 0)
monkeypatch.setattr("schedls.backends.cron.check_trusted_directory", lambda path, *, expected_uid: None)
with pytest.raises(ConflictError):
CronBackend(fake_runner, paths).plan_create(_system_spec())
def test_apply_file_mode_create_and_remove(tmp_path, fake_runner) -> None:
paths = _make_paths(tmp_path)
(tmp_path / "etc/cron.d").mkdir(parents=True, exist_ok=True)
backend = CronBackend(fake_runner, paths)
uid = os.getuid()
path = tmp_path / "etc/cron.d/schedls-backup"
content = renderer.render_system_file("backup", ["0 2 * * * root /usr/bin/backup"])
create = Plan(backend="cron", action="create")
create.files = [FileChange(path=str(path), content=content, mode=0o644, expected_uid=uid)]
create.payload = {
"mode": "file",
"action": "create",
"name": "backup",
"path": str(path),
"expected_uid": uid,
"snapshots": {str(path): None},
}
result = backend.apply(create)
assert result.changed
assert path.read_text() == content
remove = Plan(backend="cron", action="remove")
remove.files = [FileChange(path=str(path), content=None, expected_uid=uid)]
remove.payload = {
"mode": "file",
"action": "remove",
"name": "backup",
"path": str(path),
"expected_uid": uid,
"snapshots": {str(path): content},
}
result = backend.apply(remove)
assert result.changed
assert not path.exists()
def test_apply_file_mode_refuses_changed_snapshot(tmp_path, fake_runner) -> None:
paths = _make_paths(tmp_path)
_write(tmp_path / "etc/cron.d/schedls-backup", "changed\n")
backend = CronBackend(fake_runner, paths)
path = tmp_path / "etc/cron.d/schedls-backup"
plan = Plan(backend="cron", action="remove")
plan.files = [FileChange(path=str(path), content=None, expected_uid=os.getuid())]
plan.payload = {
"mode": "file",
"action": "remove",
"name": "backup",
"path": str(path),
"expected_uid": os.getuid(),
"snapshots": {str(path): "expected\n"},
}
with pytest.raises(SafetyRefusalError):
backend.apply(plan)
assert path.exists()
def test_apply_file_mode_rolls_back_on_failure(tmp_path, fake_runner) -> None:
paths = _make_paths(tmp_path)
(tmp_path / "etc/cron.d").mkdir(parents=True, exist_ok=True)
backend = CronBackend(fake_runner, paths)
uid = os.getuid()
first = tmp_path / "etc/cron.d/schedls-one"
second = tmp_path / "etc/cron.d/schedls-two"
_write(second, "conflict\n")
plan = Plan(backend="cron", action="create")
plan.files = [
FileChange(path=str(first), content=renderer.render_system_file("one", ["0 2 * * * root /bin/true"])),
FileChange(path=str(second), content=renderer.render_system_file("two", ["0 3 * * * root /bin/true"])),
]
plan.payload = {
"mode": "file",
"action": "create",
"name": "one",
"path": str(first),
"expected_uid": uid,
"snapshots": {str(first): None, str(second): None},
}
with pytest.raises(SafetyRefusalError):
backend.apply(plan)
assert not first.exists()
def test_plan_remove_system_cron(tmp_path, fake_runner, monkeypatch) -> None:
paths = _make_paths(tmp_path)
_write(
tmp_path / "etc/cron.d/schedls-cleanup",
renderer.render_system_file("cleanup", ["30 3 * * 0 root /usr/bin/cleanup"]),
)
backend = CronBackend(fake_runner, paths)
job = backend.discover([Scope.SYSTEM])[0]
monkeypatch.setattr(os, "geteuid", lambda: 0)
plan = backend.plan_remove(job)
assert plan.payload["mode"] == "file"
assert plan.files[0].path == paths.cron_d + "/schedls-cleanup"
assert plan.files[0].content is None
def test_plan_remove_system_cron_requires_root(tmp_path, fake_runner, monkeypatch) -> None:
paths = _make_paths(tmp_path)
_write(
tmp_path / "etc/cron.d/schedls-cleanup",
renderer.render_system_file("cleanup", ["30 3 * * 0 root /usr/bin/cleanup"]),
)
backend = CronBackend(fake_runner, paths)
job = backend.discover([Scope.SYSTEM])[0]
monkeypatch.setattr(os, "geteuid", lambda: 1000)
with pytest.raises(SafetyRefusalError):
backend.plan_remove(job)
def test_plan_remove_refuses_unmanaged(tmp_path, fake_runner) -> None:
paths = _make_paths(tmp_path)
_write(tmp_path / "etc/cron.d/backup", "0 2 * * * root /usr/bin/backup\n")
backend = CronBackend(fake_runner, paths)
job = backend.discover([Scope.SYSTEM])[0]
with pytest.raises(SafetyRefusalError):
backend.plan_remove(job)
+45
View File
@@ -93,3 +93,48 @@ def test_empty_crontab() -> None:
updated = document.with_block("x", ["0 0 * * * /bin/true"]) updated = document.with_block("x", ["0 0 * * * /bin/true"])
assert updated.endswith("\n") assert updated.endswith("\n")
assert "name=x" in updated assert "name=x" in updated
SYSTEM_SAMPLE = (
"SHELL=/bin/sh\n"
"PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin\n"
"\n"
"# system jobs\n"
"17 * * * * root cd / && run-parts --report /etc/cron.hourly\n"
"@daily www-data /usr/local/bin/report\n"
"\n"
"# schedls:begin name=cleanup\n"
"30 3 * * 0 root /usr/local/bin/cleanup\n"
"# schedls:end name=cleanup\n"
)
def test_system_crontab_parses_user_field() -> None:
document = CrontabDocument(SYSTEM_SAMPLE, system=True)
jobs = [entry for entry in document.entries if entry.kind == "job"]
assert jobs[0].expression == "17 * * * *"
assert jobs[0].user == "root"
assert jobs[0].command == "cd / && run-parts --report /etc/cron.hourly"
assert jobs[1].expression == "@daily"
assert jobs[1].user == "www-data"
assert jobs[1].command == "/usr/local/bin/report"
def test_system_crontab_detects_managed_block() -> None:
document = CrontabDocument(SYSTEM_SAMPLE, system=True)
block = document.find_block("cleanup")
assert block is not None
assert block.job_lines[0].user == "root"
assert document.render() == SYSTEM_SAMPLE
def test_user_crontab_still_parses_five_fields() -> None:
document = CrontabDocument("15 7 * * * ~/bin/foo\n", system=False)
assert document.entries[0].expression == "15 7 * * *"
assert document.entries[0].user is None
assert document.entries[0].command == "~/bin/foo"
def test_system_entry_without_user_is_not_a_job() -> None:
document = CrontabDocument("15 7 * * * ~/bin/foo\n", system=True)
assert document.entries[0].kind == "comment"
+71 -3
View File
@@ -150,12 +150,13 @@ def test_eof_raises_confirmation_required() -> None:
def test_wizard_new_systemd(monkeypatch: pytest.MonkeyPatch) -> None: def test_wizard_new_systemd(monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.setattr("sys.stdin", FakeStdin(isatty=True)) monkeypatch.setattr("sys.stdin", FakeStdin(isatty=True))
args = build_parser().parse_args(["new", "-i"]) args = build_parser().parse_args(["new", "-i"])
answers = ["backup", "", "n", "/usr/local/bin/backup /srv/data", "", "02:00", "n"] answers = ["backup", "", "", "n", "/usr/local/bin/backup /srv/data", "", "02:00", "n"]
prompter, _ = make_prompter(answers) prompter, _ = make_prompter(answers)
args, tail = _wizard_new(args, [], prompter) args, tail = _wizard_new(args, [], prompter)
spec = _spec_for_new(args, tail) spec = _spec_for_new(args, tail)
assert spec.name == "backup" assert spec.name == "backup"
assert spec.backend is Backend.SYSTEMD assert spec.backend is Backend.SYSTEMD
assert spec.scope is Scope.USER
assert spec.calendar == ("*-*-* 02:00:00",) assert spec.calendar == ("*-*-* 02:00:00",)
assert spec.command.argv == ("/usr/local/bin/backup", "/srv/data") assert spec.command.argv == ("/usr/local/bin/backup", "/srv/data")
@@ -163,17 +164,19 @@ def test_wizard_new_systemd(monkeypatch: pytest.MonkeyPatch) -> None:
def test_wizard_new_cron(monkeypatch: pytest.MonkeyPatch) -> None: def test_wizard_new_cron(monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.setattr("sys.stdin", FakeStdin(isatty=True)) monkeypatch.setattr("sys.stdin", FakeStdin(isatty=True))
args = build_parser().parse_args(["new", "-i"]) args = build_parser().parse_args(["new", "-i"])
answers = ["cleanup", "2", "n", "/usr/local/bin/cleanup", "", "04:00"] answers = ["cleanup", "2", "", "n", "/usr/local/bin/cleanup", "", "04:00"]
prompter, _ = make_prompter(answers) prompter, _ = make_prompter(answers)
args, tail = _wizard_new(args, [], prompter) args, tail = _wizard_new(args, [], prompter)
spec = _spec_for_new(args, tail) spec = _spec_for_new(args, tail)
assert spec.backend is Backend.CRON assert spec.backend is Backend.CRON
assert spec.scope is Scope.USER
assert spec.cron_expression == "0 4 * * *" assert spec.cron_expression == "0 4 * * *"
assert spec.run_as is None
def test_wizard_new_skips_provided_fields(monkeypatch: pytest.MonkeyPatch) -> None: def test_wizard_new_skips_provided_fields(monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.setattr("sys.stdin", FakeStdin(isatty=True)) monkeypatch.setattr("sys.stdin", FakeStdin(isatty=True))
args = build_parser().parse_args(["new", "backup", "-i", "--timer", "--daily", "02:00"]) args = build_parser().parse_args(["new", "backup", "-i", "--timer", "--daily", "02:00", "--user"])
prompter, fake = make_prompter(["n"]) prompter, fake = make_prompter(["n"])
args, tail = _wizard_new(args, ["/bin/true"], prompter) args, tail = _wizard_new(args, ["/bin/true"], prompter)
spec = _spec_for_new(args, tail) spec = _spec_for_new(args, tail)
@@ -181,6 +184,71 @@ def test_wizard_new_skips_provided_fields(monkeypatch: pytest.MonkeyPatch) -> No
assert fake.prompts == ["Set advanced timer options? [y/N] "] assert fake.prompts == ["Set advanced timer options? [y/N] "]
def test_wizard_new_scope_prompt_defaults_to_user(monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.setattr("sys.stdin", FakeStdin(isatty=True))
args = build_parser().parse_args(["new", "cleanup", "-i", "--cron", "--daily", "04:00"])
prompter, fake = make_prompter(["", "n", "/usr/local/bin/cleanup"])
args, tail = _wizard_new(args, [], prompter)
spec = _spec_for_new(args, tail)
assert spec.scope is Scope.USER
assert spec.run_as is None
assert any(prompt.startswith("Scope:") for prompt in fake.prompts)
assert not any(prompt.startswith("Run as user") for prompt in fake.prompts)
def test_wizard_new_system_cron_prompts_run_as(monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.setattr("sys.stdin", FakeStdin(isatty=True))
args = build_parser().parse_args(["new", "report", "-i", "--cron", "--daily", "04:00"])
prompter, _ = make_prompter(["2", "www-data", "n", "/usr/local/bin/report"])
args, tail = _wizard_new(args, [], prompter)
spec = _spec_for_new(args, tail)
assert spec.scope is Scope.SYSTEM
assert spec.run_as == "www-data"
def test_wizard_new_system_cron_run_as_defaults_to_root(monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.setattr("sys.stdin", FakeStdin(isatty=True))
args = build_parser().parse_args(["new", "report", "-i", "--cron", "--daily", "04:00"])
prompter, _ = make_prompter(["2", "", "n", "/usr/local/bin/report"])
args, tail = _wizard_new(args, [], prompter)
spec = _spec_for_new(args, tail)
assert spec.scope is Scope.SYSTEM
assert spec.run_as == "root"
def test_wizard_new_system_cron_run_as_reprompts(monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.setattr("sys.stdin", FakeStdin(isatty=True))
args = build_parser().parse_args(["new", "report", "-i", "--cron", "--daily", "04:00"])
prompter, fake = make_prompter(["2", "bad user", "www-data", "n", "/usr/local/bin/report"])
args, tail = _wizard_new(args, [], prompter)
spec = _spec_for_new(args, tail)
assert spec.run_as == "www-data"
assert fake.prompts.count("Run as user [root]: ") == 2
def test_wizard_new_provided_scope_and_run_as_are_not_reasked(monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.setattr("sys.stdin", FakeStdin(isatty=True))
args = build_parser().parse_args(
["new", "report", "-i", "--cron", "--system", "--run-as", "root", "--daily", "04:00"]
)
prompter, fake = make_prompter(["n", "/usr/local/bin/report"])
args, tail = _wizard_new(args, [], prompter)
spec = _spec_for_new(args, tail)
assert spec.scope is Scope.SYSTEM
assert spec.run_as == "root"
assert all("Scope:" not in prompt and "Run as user" not in prompt for prompt in fake.prompts)
def test_wizard_new_systemd_scope_prompt(monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.setattr("sys.stdin", FakeStdin(isatty=True))
args = build_parser().parse_args(["new", "backup", "-i", "--timer", "--daily", "02:00"])
prompter, _ = make_prompter(["2", "n", "/usr/local/bin/backup", "n"])
args, tail = _wizard_new(args, [], prompter)
spec = _spec_for_new(args, tail)
assert spec.scope is Scope.SYSTEM
assert spec.calendar == ("*-*-* 02:00:00",)
def test_wizard_edit_changes_schedule(monkeypatch: pytest.MonkeyPatch) -> None: def test_wizard_edit_changes_schedule(monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.setattr("sys.stdin", FakeStdin(isatty=True)) monkeypatch.setattr("sys.stdin", FakeStdin(isatty=True))
job = _systemd_job() job = _systemd_job()
+33
View File
@@ -125,5 +125,38 @@ def test_managed_block() -> None:
assert block == ("# schedls:begin name=backup\n0 2 * * * /bin/true\n# schedls:end name=backup\n") assert block == ("# schedls:begin name=backup\n0 2 * * * /bin/true\n# schedls:end name=backup\n")
def test_render_system_line() -> None:
line = renderer.render_system_line("0 2 * * *", Command(argv=("/bin/echo", "100%")), "www-data")
assert line == "0 2 * * * www-data /bin/echo 100\\%"
def test_render_system_file_has_marker() -> None:
content = renderer.render_system_file("backup", ["0 2 * * * root /bin/true"])
assert content.startswith("# Managed by schedls\n# schedls:begin name=backup\n")
assert content.endswith("# schedls:end name=backup\n")
@pytest.mark.parametrize("name", ["backup", "my-job", "job_1"])
def test_system_name_accepts(name: str) -> None:
assert renderer.validate_system_name(name) == name
@pytest.mark.parametrize("name", ["my.job", ".hidden", "-leading", "with space", ""])
def test_system_name_rejects(name: str) -> None:
with pytest.raises(InvalidScheduleError):
renderer.validate_system_name(name)
@pytest.mark.parametrize("user", ["root", "www-data", "nginx", "user.name", "_svc"])
def test_run_as_accepts(user: str) -> None:
assert renderer.validate_run_as(user) == user
@pytest.mark.parametrize("user", ["", "-root", "a b", "a;b", "a$b", "x" * 33])
def test_run_as_rejects(user: str) -> None:
with pytest.raises(InvalidScheduleError):
renderer.validate_run_as(user)
def test_shlex_reference() -> None: def test_shlex_reference() -> None:
assert shlex.quote("a b") == "'a b'" assert shlex.quote("a b") == "'a b'"