"""Warning, cutoff and kill steps of the playtime policy. The escalation ladder once a budget is spent: warn, ask Steam to shut down cleanly, then mask its binaries and SIGTERM/SIGKILL what is still running. The grace between shutdown and masking exists because masking makes ``steam -shutdown`` itself a no-op. """ from __future__ import annotations from dataclasses import replace import logging from typing import TYPE_CHECKING from leisure_watch.procscan import qualifying_pids from steam_backlog_enforcer import config as config_mod from steam_backlog_enforcer._playtime_block import ( reconcile, ) from steam_backlog_enforcer._playtime_budget import pending_warning from steam_backlog_enforcer._playtime_kill import ( kill_gaming_processes, request_steam_shutdown, steam_and_launcher_pids, ) from steam_backlog_enforcer._playtime_notify import _humanise, notify_desktop_user from steam_backlog_enforcer._playtime_state import ( _SHUTDOWN_GRACE_SECONDS, PlaytimeRules, PlaytimeState, ) if TYPE_CHECKING: from datetime import datetime logger = logging.getLogger(__name__) def reconcile_for(rules: PlaytimeRules, *, should_block: bool) -> None: """Drive the real Steam-binary mounts -- never from a demo. The mounts are the daemon's. A demo run as root used to release a real, spent-budget block on every under-budget tick (the daemon re-applied it 3 s later); run as the desktop user (the web UI) it failed without a word. So a demo's policy runs in full except this step, which _begin_cutoff announces. Args: rules: Policy for this tick (``rules.demo`` marks a demo run). should_block: Whether the launchers should currently be masked. """ if not rules.demo: reconcile(should_block=should_block) _CUTOFF_BODY = { False: "Daily budget used up. Steam and games are shutting down. " "Unblocks at 06:00.", True: "Daily leisure budget used up. Steam, games and leisure apps are " "shutting down. Unblocks at 06:00.", } def _noun(rules: PlaytimeRules) -> str: """What the budget is called: "Leisure" from the go-live day (Phase 2).""" return "Leisure" if rules.leisure else "Gaming" def _warn(state: PlaytimeState, rules: PlaytimeRules) -> PlaytimeState: """Fire the due warning, if any, and record that it fired. Args: state: Current accounting state. rules: Policy for this tick. Returns: The updated state. """ threshold = pending_warning(state, rules) if threshold is None: return state noun = _noun(rules) left = f"{_humanise(threshold)} of today's {noun.lower()} budget left." logger.info( "%s warning: %s (billed %.0fs of %.0fs)", noun, left, state.seconds, rules.budget_seconds, ) notify_desktop_user(f"{noun} time running out", left) return replace(state, warned_seconds=[*state.warned_seconds, threshold]) def _begin_cutoff( state: PlaytimeState, rules: PlaytimeRules, *, now: datetime, ) -> PlaytimeState: """Start the cutoff: ask Steam to close cleanly, then SIGTERM the games. No mount happens on this tick. Masking the Steam binaries turns ``steam -shutdown`` into a no-op, which would cost a clean close — and therefore a cloud-save flush — on every single cutoff. Args: state: Current accounting state. rules: Policy for this tick. now: Timezone-aware local timestamp. Returns: The updated state. """ logger.warning( "Daily %s budget exhausted; shutting Steam down.", _noun(rules).lower() ) notify_desktop_user(f"{_noun(rules)} time is up", _CUTOFF_BODY[rules.leisure]) request_steam_shutdown() kill_gaming_processes(_kill_set(rules), force=False) if rules.demo: logger.warning( "Demo: in %.0f s the real block would mask Steam's binaries; only the " "daemon does that. This demo keeps killing games until you stop it.", _SHUTDOWN_GRACE_SECONDS, ) return replace(state, blocked_at=now.timestamp()) def _sustain_block( state: PlaytimeState, rules: PlaytimeRules, *, now: datetime, ) -> PlaytimeState: """Hold the block: mask the binaries once the grace has passed, keep killing. Args: state: Current accounting state. rules: Policy for this tick. now: Timezone-aware local timestamp. Returns: *state*, unchanged — upkeep mutates the system, not the record. """ elapsed = now.timestamp() - state.blocked_at if elapsed >= _SHUTDOWN_GRACE_SECONDS: reconcile_for(rules, should_block=True) kill_gaming_processes(_kill_set(rules), force=elapsed >= rules.sigkill_after) return state def _kill_set(rules: PlaytimeRules) -> set[int]: """Return every PID the cutoff should terminate. Wider than :func:`qualifying_pids` on purpose. A Lutris-launched Wine game has no ``SteamAppId`` and its ``comm`` is the game's own binary, so neither matcher sees it — only walking down from the launcher does. Args: rules: Policy for this tick. Returns: PIDs to signal. """ return ( set(qualifying_pids(rules, config_mod.CONFIG_FILE)) | steam_and_launcher_pids() )