mirror of
https://github.com/kuhyx/screen-locker.git
synced 2026-11-13 19:10:55 +01:00
Krzysztof kuhy Rudnicki
e5db25468d
Some checks are pending
pre-commit / pre-commit (push) Waiting to run
Tests / test (3.10) (push) Waiting to run
Tests / test (3.11) (push) Waiting to run
Tests / test (3.12) (push) Waiting to run
Tests / lock-popup-safety (push) Waiting to run
release-apk / release (APK) (push) Waiting to run
The screen locker stopped locking on 2026-08-04 and nobody could tell. Not a
logic bug: every predicate worked the whole time. systemd logged
timers.target: Found ordering cycle: early-bird-workout-check.timer/start
after graphical-session.target/start after basic.target/start after
timers.target/start - after early-bird-workout-check.timer
timers.target: Job early-bird-workout-check.timer/start deleted to break
ordering cycle starting with timers.target/start
and left the timer disabled. A timer that is WantedBy=timers.target must not be
ordered After= a target that itself comes after timers.target; systemd resolves
that loop by deleting the job, which is an absence, and absences page nobody.
That timer is the ONLY thing that closes the early-bird window. Each morning a
run inside the window banked early_bird_pending.json, logged "will re-check at
08:30", and exited 0. The re-check never came, so the marker stood all day,
every day, for thirteen days.
It stayed invisible because logging.basicConfig was called only in the
--sync-only branch, never for --production -- the mode systemd actually runs.
Journal proof: zero INFO lines from workout-locker.service since June. Every
early exit logged at INFO into a logger with no handler. Meanwhile the healthy
15-minute sync kept the system looking alive.
The 2026-08-15 Python split is NOT implicated: it was pure code motion, and
basicConfig already sat in that branch before it.
Fixes:
* Drop the After= that closes the cycle; Persistent=true so a machine asleep at
08:30 still re-checks after resume.
* Add workout-locker.timer (*:00,30). The service is WantedBy=
graphical-session.target, i.e. one decision per login, so the 08-16 -> 08-17
day and ISO-week rollover inside one long session was never re-evaluated.
* arm.sh: install units, enable timers, verify -- one command, because
re-arming was a four-command sequence that was easy to half-do, and
`systemctl enable` returns 0 while systemd deletes the timer job.
* check_enforcement_armed.py asks systemd what it actually scheduled (enabled
AND has a next trigger) and fails loudly otherwise. Wired as ExecStartPost on
workout-sync.service, so a disarmed locker marks that unit failed every 15
minutes instead of scrolling past. install_systemd.sh now fails on it too.
Logging (the reason this went unnoticed, so treated as a defect in its own
right):
* basicConfig for every mode, never one branch.
* Every enforcement-abandoning exit records a decision instead of an invisible
INFO: one greppable line -- DECISION lock=no reason=early_bird_window_active
weekly=0/5 -- at WARNING, since per CLAUDE.md an INFO explanation of a
non-action is a silent failure with extra steps. The enforced case is logged
too: "no line at all" was the outage's whole signature.
* A durable JSONL trail outside the repo (~/.local/share/screen_locker/), so
"when did this last actually enforce?" survives journal rotation. --status
and --sync-only record lock=n/a; "did not decide" must never look like
"decided not to lock".
* check_silent_failures.py now also catches sys.exit(0) that explains nothing.
Verified both directions: it flags 3/3 exits in the pre-fix _auto_upgrade.py
and passes the repo clean.
Sync noise: four records replayed as WARNINGs every cycle (~384/day), which is
how the actionable lines got tuned out. manual_workout:2026-08-15 is an empty
stub ({date, kind, type}) -- no workout to recover, and that day's credit was
already counted under a different sync_record_id, so no credit was ever lost.
The three "collided" records are dedup working. Both now report at info; a
WARNING from this logger again means something real. 4 -> 0 per cycle.
Verified on the live system: the periodic timer fired at 16:45 and the journal
shows `DECISION lock=no reason=scheduled_skip_day weekly=0/5` -- the line that
did not exist for thirteen days. Both timers report enabled and scheduled, and
no ordering cycle recurs. Today is a scheduled skip so the machine was not
locked mid-session; enforcement resumes tomorrow 08:30. 1007 tests, 100%
coverage, all hooks green.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01F2b6ZjBcdrkSYnMujx4mWd
72 lines
2.7 KiB
Python
72 lines
2.7 KiB
Python
"""Command-line entry points for ``screen_lock.py``.
|
|
|
|
Split out of ``screen_lock.py`` to keep every file under the 250-line cap.
|
|
The argument handling lives here; ``screen_lock.py`` keeps only the
|
|
``ScreenLocker`` class and a one-line ``__main__`` delegation, so the module
|
|
that every mixin imports stays small.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import logging
|
|
from pathlib import Path
|
|
import sys
|
|
from typing import TYPE_CHECKING
|
|
|
|
from screen_locker._decision_log import record_no_decision
|
|
from screen_locker._status import run_status
|
|
|
|
if TYPE_CHECKING:
|
|
from screen_locker.screen_lock import ScreenLocker
|
|
|
|
__all__ = ["main"]
|
|
|
|
_LOG_FILE_NAME = "workout_log.json"
|
|
|
|
|
|
def _headless_locker(locker_cls: type[ScreenLocker]) -> ScreenLocker:
|
|
"""A ScreenLocker with ``__init__`` bypassed, for the no-UI subcommands.
|
|
|
|
``--status`` and ``--sync-only`` touch only ``log_file`` and
|
|
``workout_data``; constructing the real object would build a Tk UI and,
|
|
in the ``--production`` case, grab the screen.
|
|
"""
|
|
locker = object.__new__(locker_cls)
|
|
locker.log_file = Path(__file__).resolve().parent / _LOG_FILE_NAME
|
|
locker.workout_data = {}
|
|
return locker
|
|
|
|
|
|
def main(locker_cls: type[ScreenLocker], argv: list[str]) -> None:
|
|
"""Dispatch on ``argv`` and run the requested mode."""
|
|
# Configure logging for EVERY mode, not just --sync-only. This used to sit
|
|
# inside the --sync-only branch, so `--production` -- the mode systemd
|
|
# actually runs -- had no handler and fell back to lastResort, which drops
|
|
# everything below WARNING. The result: zero INFO lines from
|
|
# workout-locker.service since June, and a thirteen-day enforcement outage
|
|
# that left no trace at all. Never narrow this back to one branch.
|
|
logging.basicConfig(
|
|
level=logging.INFO,
|
|
format="%(levelname)s %(name)s: %(message)s",
|
|
)
|
|
if "--status" in argv:
|
|
run_status(_headless_locker(locker_cls))
|
|
|
|
if "--sync-only" in argv:
|
|
# Headless sync for the timer unit: pull other devices' workouts and
|
|
# apply their credit, with no Tk and no lock screen. Sync used to run
|
|
# ONLY at process start, so a workout finished after login was not seen
|
|
# until the next login — the timer closes that window.
|
|
_headless_locker(locker_cls).sync_now()
|
|
# Say so explicitly: --sync-only NEVER locks, so a reader tracing "why
|
|
# didn't it lock?" through the journal must not mistake a sync run for
|
|
# an enforcement run that decided to skip.
|
|
record_no_decision("--sync-only")
|
|
sys.exit(0)
|
|
|
|
locker = locker_cls(
|
|
demo_mode="--production" not in argv,
|
|
verify_only="--verify-workout" in argv,
|
|
)
|
|
locker.run()
|