cronboard-service 1.0.4__tar.gz

cronboard_service-1.0.4/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: cronboard-service
+Version: 1.0.4
+Summary: Session D-Bus service that lets the Cronboard GNOME Shell extension read and change your crontab
+License-Expression: GPL-2.0-or-later
+Project-URL: Homepage, https://github.com/seniru-dilmith/cronboard
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: dbus-fast>=2
+
+# Cronboard service
+
+The companion service for the [Cronboard](https://github.com/seniru-dilmith/cronboard) GNOME Shell extension. It runs in your user session and does the work the extension is not allowed to do itself: reading and writing your crontab (with a backup of the previous one), running a job on demand, and checking that the cron service is running. The extension talks to it over the session D-Bus.
+
+```bash
+pipx install cronboard-service
+cronboard-service install
+```
+
+`install` registers the service with the session bus so it starts on demand. Without it you can run `cronboard-service` in a terminal instead.

cronboard_service-1.0.4/README.md

@@ -0,0 +1,10 @@
+# Cronboard service
+
+The companion service for the [Cronboard](https://github.com/seniru-dilmith/cronboard) GNOME Shell extension. It runs in your user session and does the work the extension is not allowed to do itself: reading and writing your crontab (with a backup of the previous one), running a job on demand, and checking that the cron service is running. The extension talks to it over the session D-Bus.
+
+```bash
+pipx install cronboard-service
+cronboard-service install
+```
+
+`install` registers the service with the session bus so it starts on demand. Without it you can run `cronboard-service` in a terminal instead.

cronboard_service-1.0.4/cronboard_service/__main__.py

@@ -0,0 +1,83 @@
+"""The Cronboard session D-Bus service."""
+
+import asyncio
+import os
+import sys
+from pathlib import Path
+
+from dbus_fast import BusType, DBusError
+from dbus_fast.aio import MessageBus
+from dbus_fast.constants import RequestNameReply
+from dbus_fast.service import ServiceInterface, method
+
+from . import core
+
+NAME = "io.github.seniru_dilmith.Cronboard"
+PATH = "/io/github/seniru_dilmith/Cronboard"
+
+
+class Cronboard(ServiceInterface):
+    def __init__(self):
+        super().__init__(NAME)
+
+    @method()
+    async def Read(self) -> "s":
+        return await self._guard(core.read())
+
+    @method()
+    async def Write(self, text: "s", snapshot: "s"):
+        await self._guard(core.write(text, snapshot))
+
+    @method()
+    async def Run(self, argv: "as", env: "a{ss}") -> "(is)":
+        return list(await self._guard(core.run_job(argv, env)))
+
+    @method()
+    async def CronActive(self) -> "b":
+        return await core.cron_active()
+
+    @staticmethod
+    async def _guard(awaitable):
+        """Turns the core's errors into D-Bus errors the extension tells apart by name."""
+        try:
+            return await awaitable
+        except core.NotInstalled:
+            raise DBusError(f"{NAME}.Error.NotInstalled", "cron is not installed: the crontab command was not found.")
+        except core.Conflict:
+            raise DBusError(f"{NAME}.Error.Conflict", "The crontab changed outside Cronboard, so nothing was saved. Check the list and try again.")
+        except Exception as e:
+            raise DBusError(f"{NAME}.Error.Failed", str(e))
+
+
+async def serve():
+    bus = await MessageBus(bus_type=BusType.SESSION).connect()
+    bus.export(PATH, Cronboard())
+    if await bus.request_name(NAME) != RequestNameReply.PRIMARY_OWNER:
+        sys.exit(f"{NAME} is already running")
+    try:
+        await bus.wait_for_disconnect()
+    except EOFError:
+        pass  # the session bus went away (logout)
+
+
+def install():
+    """Registers the service with the session bus so it starts when the extension asks for it."""
+    data = Path(os.environ.get("XDG_DATA_HOME") or Path.home() / ".local" / "share")
+    target = data / "dbus-1" / "services" / f"{NAME}.service"
+    target.parent.mkdir(parents=True, exist_ok=True)
+    exe = Path(sys.argv[0]).resolve()
+    target.write_text(f"[D-BUS Service]\nName={NAME}\nExec={exe}\n")
+    print(f"Registered {target}")
+
+
+def main():
+    if sys.argv[1:] == ["install"]:
+        install()
+    elif len(sys.argv) == 1:
+        asyncio.run(serve())
+    else:
+        sys.exit("usage: cronboard-service [install]")
+
+
+if __name__ == "__main__":
+    main()

cronboard_service-1.0.4/cronboard_service/core.py

@@ -0,0 +1,105 @@
+"""Crontab access and job running. No D-Bus in here, so it can be tested directly."""
+
+import asyncio
+import os
+import re
+import time
+from pathlib import Path
+
+BACKUPS_KEPT = 20
+
+
+class NotInstalled(Exception):
+    pass
+
+
+class Conflict(Exception):
+    pass
+
+
+async def _run(argv, stdin=None, env=None):
+    """Runs a command and returns (exit status, stdout, stderr)."""
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            *argv,
+            stdin=asyncio.subprocess.PIPE if stdin is not None else asyncio.subprocess.DEVNULL,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            env={**os.environ, "LC_ALL": "C", **(env or {})},  # stable messages to match on
+        )
+    except FileNotFoundError as e:
+        raise NotInstalled(argv[0]) from e
+    out, err = await proc.communicate(stdin.encode() if stdin is not None else None)
+    return proc.returncode, out.decode(errors="replace"), err.decode(errors="replace")
+
+
+async def read():
+    """The current crontab text; '' when the user has none."""
+    status, out, err = await _run(["crontab", "-l"])
+    if status == 0:
+        return out
+    if err.startswith("no crontab for "):
+        return ""
+    raise RuntimeError(err.strip() or f"crontab -l exited with status {status}")
+
+
+def _backup_dir():
+    data = os.environ.get("XDG_DATA_HOME") or Path.home() / ".local" / "share"
+    return Path(data) / "cronboard" / "backups"
+
+
+def _backup(text):
+    folder = _backup_dir()
+    folder.mkdir(parents=True, exist_ok=True, mode=0o700)
+    stamp = time.strftime("%Y%m%d-%H%M%S") + f"-{time.time_ns() % 1_000_000:06d}"
+    (folder / f"crontab-{stamp}.txt").write_text(text)
+    for old in sorted(p for p in folder.glob("crontab-*.txt"))[:-BACKUPS_KEPT]:
+        old.unlink(missing_ok=True)
+
+
+async def write(text, snapshot):
+    """Installs text as the crontab, but only if it still matches what the caller last read.
+
+    The previous crontab is backed up first.
+    ponytail: the re-read and the install aren't atomic; flock(1) on a lock file would close that gap.
+    """
+    current = await read()
+    if current != snapshot:
+        raise Conflict()
+    if text == current:
+        return
+    if current:
+        _backup(current)
+    data = text if text == "" or text.endswith("\n") else text + "\n"  # cron needs a final newline
+    status, _, err = await _run(["crontab", "-"], stdin=data)
+    if status != 0:
+        raise RuntimeError(err.strip() or f"crontab exited with status {status}")
+
+
+async def run_job(argv, env):
+    """Runs a job now in a transient systemd user unit, so it isn't a child of this service.
+
+    Waits for it to end and returns (the job's exit status, stderr); a non-empty stderr
+    means systemd-run itself failed. The job's own output goes to the user journal.
+    """
+    runtime = os.environ.get("XDG_RUNTIME_DIR") or f"/run/user/{os.getuid()}"
+    bus = Path(runtime) / "bus"
+    # Shells started with dbus-run-session (nested or test sessions) have a private bus without systemd on it.
+    bus_env = {"DBUS_SESSION_BUS_ADDRESS": f"unix:path={bus}"} if bus.exists() else {}
+    unit = f"cronboard-run-{time.time_ns() // 1000}"
+    status, _, err = await _run(
+        ["systemd-run", "--user", "--wait", "--collect", "--quiet", f"--unit={unit}",
+         f"--working-directory={env.get('HOME', str(Path.home()))}", "--",
+         "/usr/bin/env", "-i", *(f"{k}={v}" for k, v in env.items()), *argv],
+        env=bus_env,
+    )
+    return status, err
+
+
+async def cron_active():
+    """False when a known cron service exists but isn't running."""
+    try:
+        _, out, _ = await _run(["systemctl", "is-active", "cron.service", "crond.service", "cronie.service"])
+    except NotInstalled:
+        return True  # no systemctl: we can't tell, so don't warn
+    return re.search(r"^active$", out, re.M) is not None

cronboard_service-1.0.4/cronboard_service.egg-info/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: cronboard-service
+Version: 1.0.4
+Summary: Session D-Bus service that lets the Cronboard GNOME Shell extension read and change your crontab
+License-Expression: GPL-2.0-or-later
+Project-URL: Homepage, https://github.com/seniru-dilmith/cronboard
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: dbus-fast>=2
+
+# Cronboard service
+
+The companion service for the [Cronboard](https://github.com/seniru-dilmith/cronboard) GNOME Shell extension. It runs in your user session and does the work the extension is not allowed to do itself: reading and writing your crontab (with a backup of the previous one), running a job on demand, and checking that the cron service is running. The extension talks to it over the session D-Bus.
+
+```bash
+pipx install cronboard-service
+cronboard-service install
+```
+
+`install` registers the service with the session bus so it starts on demand. Without it you can run `cronboard-service` in a terminal instead.

cronboard_service-1.0.4/cronboard_service.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+cronboard_service/__init__.py
+cronboard_service/__main__.py
+cronboard_service/core.py
+cronboard_service.egg-info/PKG-INFO
+cronboard_service.egg-info/SOURCES.txt
+cronboard_service.egg-info/dependency_links.txt
+cronboard_service.egg-info/entry_points.txt
+cronboard_service.egg-info/requires.txt
+cronboard_service.egg-info/top_level.txt
+tests/test_core.py

cronboard_service-1.0.4/cronboard_service.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

cronboard_service-1.0.4/cronboard_service.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cronboard-service = cronboard_service.__main__:main

cronboard_service-1.0.4/cronboard_service.egg-info/requires.txt

@@ -0,0 +1 @@
+dbus-fast>=2

cronboard_service-1.0.4/cronboard_service.egg-info/top_level.txt

@@ -0,0 +1 @@
+cronboard_service

cronboard_service-1.0.4/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "cronboard-service"
+version = "1.0.4"
+description = "Session D-Bus service that lets the Cronboard GNOME Shell extension read and change your crontab"
+readme = "README.md"
+license = "GPL-2.0-or-later"
+requires-python = ">=3.10"
+dependencies = ["dbus-fast>=2"]
+
+[project.urls]
+Homepage = "https://github.com/seniru-dilmith/cronboard"
+
+[project.scripts]
+cronboard-service = "cronboard_service.__main__:main"
+
+[tool.setuptools]
+packages = ["cronboard_service"]

cronboard_service-1.0.4/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

cronboard_service-1.0.4/tests/test_core.py

@@ -0,0 +1,64 @@
+import asyncio
+import os
+import stat
+import tempfile
+import unittest
+from pathlib import Path
+
+from cronboard_service import core
+
+# A stand-in crontab that keeps its "crontab" in a file, so the tests never touch the real one.
+FAKE = """#!/bin/sh
+f="$FAKE_CRONTAB"
+case "$1" in
+  -l) [ -f "$f" ] && cat "$f" || { echo "no crontab for tester" >&2; exit 1; } ;;
+  -) cat >"$f" ;;
+esac
+"""
+
+
+class CoreTest(unittest.TestCase):
+    def setUp(self):
+        self.tmp = Path(tempfile.mkdtemp())
+        fake = self.tmp / "crontab"
+        fake.write_text(FAKE)
+        fake.chmod(fake.stat().st_mode | stat.S_IXUSR)
+        self.env = {
+            "PATH": f"{self.tmp}:{os.environ['PATH']}",
+            "FAKE_CRONTAB": str(self.tmp / "stored"),
+            "XDG_DATA_HOME": str(self.tmp / "data"),
+        }
+        self.saved = {k: os.environ.get(k) for k in self.env}
+        os.environ.update(self.env)
+
+    def tearDown(self):
+        for k, v in self.saved.items():
+            if v is None:
+                os.environ.pop(k, None)
+            else:
+                os.environ[k] = v
+
+    def test_no_crontab_reads_as_empty(self):
+        self.assertEqual(asyncio.run(core.read()), "")
+
+    def test_write_then_read_and_backup(self):
+        asyncio.run(core.write("0 5 * * * a", ""))
+        self.assertEqual(asyncio.run(core.read()), "0 5 * * * a\n")  # final newline added
+        asyncio.run(core.write("0 6 * * * b\n", "0 5 * * * a\n"))
+        backups = list((self.tmp / "data" / "cronboard" / "backups").glob("crontab-*.txt"))
+        self.assertEqual([b.read_text() for b in backups], ["0 5 * * * a\n"])
+
+    def test_write_refuses_when_crontab_changed(self):
+        asyncio.run(core.write("x\n", ""))
+        with self.assertRaises(core.Conflict):
+            asyncio.run(core.write("y\n", "something else\n"))
+        self.assertEqual(asyncio.run(core.read()), "x\n")
+
+    def test_missing_crontab_command(self):
+        os.environ["PATH"] = "/nonexistent"
+        with self.assertRaises(core.NotInstalled):
+            asyncio.run(core.read())
+
+
+if __name__ == "__main__":
+    unittest.main()