steam-backlog-enforcer/steam_backlog_enforcer/enforcer.py
Krzysztof kuhy Rudnicki d6d9a2d1a6 pylint: clear the mechanical residue, the howlongtobeatpy 1.0.23 call, and three duplicate blocks
The pinned howlongtobeatpy (1.0.23) takes a user agent in
send_website_request_getcode and dropped parse_all_scripts; the call
still matched 1.0.20, which only worked because the deployed env was
behind its own pin. Now on the pinned API, and the env upgraded.

Three modules carried the same executable/path constant block since the
250-line split; it is _store_tools. Four carried the same "restore the
hours a refetch lost" loop; it is restore_prior_hours. Both detached
launches go through one helper that returns the process. Thirteen
try/except/else blocks are flat, dataclass fields come from
dataclasses.fields, and the rest are one-line fixes.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HHCbkJWXHjtTUaqvnHRAqA
2026-09-12 20:31:27 +02:00

178 lines
5.7 KiB
Python

"""Enforce that only the assigned game may run."""
from __future__ import annotations
import logging
import os
from pathlib import Path
import shutil
import signal
import subprocess
from steam_backlog_enforcer._desktop_env import (
desktop_user_cmd,
resolve_desktop_user,
)
from steam_backlog_enforcer.game_uninstall import is_protected_app
logger = logging.getLogger(__name__)
def get_running_steam_game_pids() -> dict[int, int]:
"""Scan /proc to find running Steam game processes.
Returns: dict mapping PID -> SteamAppId.
"""
running: dict[int, int] = {}
proc = Path("/proc")
for entry in proc.iterdir():
if not entry.name.isdigit():
continue
try:
environ = (entry / "environ").read_bytes()
pairs = environ.split(b"\x00")
for pair in pairs:
if pair.startswith(b"SteamAppId="):
value = pair.split(b"=", 1)[1].decode("utf-8", errors="replace")
if value.isdigit():
running[int(entry.name)] = int(value)
break
except PermissionError, OSError, ValueError:
continue
return running
def get_pids_by_process_names(names: frozenset[str]) -> dict[int, str]:
"""Scan /proc/*/comm for processes whose command name is in *names*.
The kernel truncates ``/proc/[pid]/comm`` to 15 characters (plus a null
terminator), so *names* longer than that (e.g. ``EpicGamesLauncher``,
``gdlauncher-carbon``) are matched against their own first 15 characters
- matching how the kernel actually stores them, not an exact string
that could never appear in ``comm``.
Returns: dict mapping PID -> matched comm string.
"""
truncated = {name[:15]: name for name in names}
running: dict[int, str] = {}
proc = Path("/proc")
for entry in proc.iterdir():
if not entry.name.isdigit():
continue
try:
comm = (entry / "comm").read_text(encoding="utf-8").strip()
except PermissionError, OSError, ValueError:
continue
if comm in truncated:
running[int(entry.name)] = truncated[comm]
return running
def kill_processes_by_name(names: frozenset[str]) -> list[tuple[int, str]]:
"""Kill (SIGTERM) every running process whose name is in *names*.
Matching is by ``/proc/[pid]/comm`` via :func:`get_pids_by_process_names`,
not the ``SteamAppId`` environment variable (unlike
:func:`get_running_steam_game_pids`) - this is for non-Steam processes
(the Steam client itself, and third-party game launchers) that don't set
that variable.
Returns: list of (pid, matched_name) actually killed.
"""
killed: list[tuple[int, str]] = []
for pid, name in get_pids_by_process_names(names).items():
if _kill_pid_by_name(pid, name):
killed.append((pid, name))
return killed
def _kill_pid_by_name(pid: int, name: str) -> bool:
"""Send SIGTERM to *pid*. Returns True if the signal was delivered."""
try:
os.kill(pid, signal.SIGTERM)
except ProcessLookupError:
return False
except PermissionError:
logger.exception("No permission to kill PID %d (%s).", pid, name)
return False
return True
def enforce_allowed_game(
allowed_app_ids: set[int],
*,
kill_unauthorized: bool = True,
) -> list[tuple[int, int]]:
"""Check running games; optionally kill unauthorized ones.
Args:
allowed_app_ids: Every app id the user may play right now — the
assignment plus any concurrent manual picks. Empty disables the
check entirely (nothing is assigned, so nothing is unauthorized).
kill_unauthorized: Whether to kill violating processes.
Returns list of (pid, app_id) that were killed or detected.
"""
if not allowed_app_ids:
return []
running = get_running_steam_game_pids()
violations: list[tuple[int, int]] = []
for pid, app_id in running.items():
if app_id in allowed_app_ids:
continue
# Skip Steam client itself (app_id 0 or very low IDs).
if app_id == 0:
continue
if is_protected_app(app_id):
continue
violations.append((pid, app_id))
if kill_unauthorized:
kill_process(pid, app_id)
return violations
def kill_process(pid: int, app_id: int) -> None:
"""Kill a process by PID."""
try:
logger.warning("Killing unauthorized game (AppID=%d, PID=%d)", app_id, pid)
os.kill(pid, signal.SIGTERM)
except ProcessLookupError:
logger.debug("Process %d already gone.", pid)
except PermissionError:
logger.exception("No permission to kill PID %d.", pid)
def send_notification(title: str, body: str) -> None:
"""Send a desktop notification into the real user's session.
The enforcer runs as root under systemd, where a bare ``notify-send`` has
no DBUS_SESSION_BUS_ADDRESS and so cannot reach the user's session bus —
it failed silently for every caller. Dropping to the desktop user supplies
the session variables it needs.
"""
_notify_send = shutil.which("notify-send") or "/usr/bin/notify-send"
cmd = desktop_user_cmd(
[_notify_send, title, body, "--icon=dialog-warning"],
resolve_desktop_user(),
)
try:
subprocess.run(
cmd,
capture_output=True,
timeout=5,
check=False,
)
except FileNotFoundError, OSError:
logger.debug("notify-send not available.")
except subprocess.TimeoutExpired:
# sudo can block where a bare notify-send would not; a dropped
# notification is better than an exception escaping the enforce loop.
logger.debug("notify-send timed out.")