#!/usr/bin/env python3 """Täglicher Start von media_retention_job.py um 03:00 Europe/Berlin. Der Prozess löscht beim Start nichts. Ein Lauf sofort nach dem Start nur mit RETENTION_RUN_ON_START=1. Ein fehlgeschlagener Lauf bleibt im Log (RETENTION_FAIL); der Prozess bleibt aktiv, damit Docker ihn nicht sofort erneut startet. """ from __future__ import annotations import logging import os import subprocess import sys import time from datetime import datetime, timedelta from zoneinfo import ZoneInfo LOG = logging.getLogger("retention.scheduler") DEFAULT_TZ = "Europe/Berlin" _RUN_ON_START = "RETENTION_RUN_ON_START" _TZ_ENV = "RETENTION_TZ" def retention_zone() -> ZoneInfo: name = os.environ.get(_TZ_ENV, DEFAULT_TZ).strip() or DEFAULT_TZ return ZoneInfo(name) def next_run_at(now: datetime, *, hour: int = 3) -> datetime: """Nächste Uhrzeit `hour`:00 in der Zeitzone von `now`. `now` muss zeitzonenbewusst sein. Die Zone von `now` ist die Planungszone. """ if now.tzinfo is None: raise ValueError("now muss eine Zeitzone tragen") zone = now.tzinfo local = now.astimezone(zone) day = local.date() target = datetime(day.year, day.month, day.day, hour, 0, 0, tzinfo=zone) if target.timestamp() <= local.timestamp(): day = day + timedelta(days=1) target = datetime(day.year, day.month, day.day, hour, 0, 0, tzinfo=zone) return target def seconds_until_next_0300(now: datetime, *, hour: int = 3) -> float: """Sekunden bis zum nächsten Lauf, als absolute Dauer. `target - now` zieht bei gleicher tzinfo die Wanduhr ab und liegt an Umstellungstagen um eine Stunde daneben. `timestamp()` rechnet in UTC. """ target = next_run_at(now, hour=hour) local = now.astimezone(target.tzinfo) return target.timestamp() - local.timestamp() def _job_path() -> str: return os.path.join(os.path.dirname(os.path.abspath(__file__)), "media_retention_job.py") def _run_on_start() -> bool: return os.environ.get(_RUN_ON_START, "").strip() == "1" def run_job() -> int: """Startet den Retention-Job. Führt keine Löschung in diesem Prozess aus.""" LOG.info("Retention-Lauf startet") completed = subprocess.run([sys.executable, "-u", _job_path()], check=False) if completed.returncode != 0: LOG.error("RETENTION_FAIL exit=%s", completed.returncode) else: LOG.info("RETENTION_OK") return int(completed.returncode) def serve( *, iterations: int | None = None, sleep=time.sleep, clock=None, run=None, ) -> None: zone = retention_zone() if clock is None: def clock() -> datetime: return datetime.now(zone) execute = run if run is not None else run_job if _run_on_start(): LOG.info("Sofortlauf wegen RETENTION_RUN_ON_START=1") execute() completed = 0 while iterations is None or completed < iterations: target = next_run_at(clock()) LOG.info("Nächster Retention-Lauf %s", target.isoformat(timespec="seconds")) while True: remaining = target.timestamp() - clock().timestamp() if remaining <= 1: break LOG.info("Warte %.0f Sekunden bis %s", remaining, target.isoformat(timespec="seconds")) sleep(remaining) execute() completed += 1 def main() -> int: logging.basicConfig( level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s", stream=sys.stdout, force=True, ) serve() return 0 if __name__ == "__main__": raise SystemExit(main())