steam-backlog-enforcer/steam_backlog_enforcer/_total_block_hosts.py
Krzysztof kuhy Rudnicki 5d5aa3e773
Some checks are pending
dependency freshness / dependencies on newest stable (push) Waiting to run
md-naming / markdown naming convention (push) Waiting to run
pre-commit / pre-commit (${{ matrix.group }}) (mypy, mypy, ) (push) Waiting to run
pre-commit / pre-commit (${{ matrix.group }}) (pylint, pylint, ) (push) Waiting to run
pre-commit / pre-commit (${{ matrix.group }}) (rest, , mypy,pylint) (push) Waiting to run
Tests / test (push) Waiting to run
Tests / web-coverage (push) Waiting to run
repo-contract / repo contract (push) Waiting to run
Add Librarian-only research window to total block
kuhy 2026-11-11: game-design research needs Librarian (app 4197610)
actually played during the 6-day total block. New root command
total-block-research --until T opens ONE window per lock: <= 48 h,
never past the lock end, a rerun never extends it.

The command only validates and records (/var/lib/steam-backlog-
enforcer, root 0700; lock id + deadline + two latches). The daemon
opens and closes everything: Steam hosts names, the store block, the
total-block chain (IP cache kept) and the steam package, reinstalled
with only guard-lib's package-block hook masked for that one pacman
call (--hookdir, proved in a guest). Lock file, hook and end date are
never touched. Browser-game sites stay null-routed.

Only Librarian may run: loop-local allowed set, strict mode (no
whitelist exceptions, no zero-achievement games), launchers and
counted games killed; state.json is never read or written.

Expiry latches the record, then the ordinary tick re-applies hosts
(now reconciled each tick), chain, uninstall and purge; the normal
store block is restored once, unconditionally.

Failure modes: missing/corrupt/unparseable record = no window and a
corrupt one also refuses a new window (fail closed); a clock set
back cannot reopen a latched window.

Checked: 3290 tests at 100% coverage; whole-tree pylint 10/10 run in
three parts (the hook exceeds the 60 s cap, so SKIP=pylint here); vmbox
guest with real guardctl package-block and the real unit, window
opened, Librarian-only enforced, clock moved past the deadline and the
full block re-applied. Not verified on the host.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01WzxdWWzuCEg1m87jpKyRrw
2026-11-11 14:29:58 +01:00

148 lines
4.9 KiB
Python

"""/etc/hosts null-routing for the total gaming block.
Deliberately distinct from :mod:`store_blocker`'s own BLOCKED_DOMAINS /
STEAM_ENFORCER hosts section, so ending a total block never disturbs the
user's normal ``config.block_store`` entries. The iptables half of the same
block lives in :mod:`steam_backlog_enforcer._total_block_iptables`.
"""
from __future__ import annotations
import logging
import subprocess
from steam_backlog_enforcer._hosts_protection import (
_disable_hosts_protection,
_enable_hosts_protection,
_sudo_write_hosts,
)
from steam_backlog_enforcer._total_block_domains import (
_ALL_TOTAL_BLOCK_DOMAINS,
NULL_ROUTE_IP,
RESEARCH_BLOCKED_DOMAINS,
)
from steam_backlog_enforcer.config import HOSTS_FILE
logger = logging.getLogger(__name__)
_HOSTS_BLOCK_BEGIN = "# BEGIN steam-backlog-enforcer total-block\n"
_HOSTS_BLOCK_END = "# END steam-backlog-enforcer total-block\n"
def _expected_block(*, steam_open: bool = False) -> str:
"""The enforcer's /etc/hosts section as it should currently read.
With *steam_open* (a research window) the section lists the game sites only.
"""
domains = RESEARCH_BLOCKED_DOMAINS if steam_open else _ALL_TOTAL_BLOCK_DOMAINS
lines = [_HOSTS_BLOCK_BEGIN]
lines += [f"{NULL_ROUTE_IP} {domain}\n" for domain in domains]
lines.append(_HOSTS_BLOCK_END)
return "".join(lines)
def apply_total_block_hosts() -> bool:
"""Append the total-block domain block to /etc/hosts, if not present."""
try:
content = HOSTS_FILE.read_text(encoding="utf-8")
except OSError:
logger.exception("Failed to read /etc/hosts")
return False
if _HOSTS_BLOCK_BEGIN in content:
return True
new_content = content if content.endswith("\n") else content + "\n"
new_content += _expected_block()
try:
_disable_hosts_protection()
_sudo_write_hosts(new_content)
except OSError, subprocess.SubprocessError:
logger.exception("Failed to write total-block hosts entries")
return False
finally:
_enable_hosts_protection()
return True
def _write_hosts(content: str, failure: str) -> bool:
"""Write *content* through the guard-lib unlock/relock; False on failure."""
try:
_disable_hosts_protection()
_sudo_write_hosts(content)
except OSError, subprocess.SubprocessError:
logger.exception(failure)
return False
finally:
_enable_hosts_protection()
return True
def refresh_total_block_hosts(*, steam_open: bool = False) -> bool:
"""Bring an existing section in line with the current domain list.
Unlike :func:`apply_total_block_hosts` (which leaves a present section
alone, so the 3 s tick stays cheap), this replaces the section when its
text differs -- how a list change reaches an already-active block, and how
the full list returns when a research window ends. Only the text between
the markers changes; a BEGIN without END, or an unreadable file, is left
untouched (False). A missing section is installed (the full one, or with
*steam_open* the research one).
Args:
steam_open: Write the research-window section (game sites only).
"""
try:
content = HOSTS_FILE.read_text(encoding="utf-8")
except OSError:
logger.exception("Failed to read /etc/hosts")
return False
expected = _expected_block(steam_open=steam_open)
start = content.find(_HOSTS_BLOCK_BEGIN)
if start == -1:
if not steam_open:
return apply_total_block_hosts()
head = content if content.endswith("\n") else content + "\n"
return _write_hosts(head + expected, "Failed to write research hosts entries")
end_at = content.find(_HOSTS_BLOCK_END, start)
if end_at == -1:
logger.error("total-block section has no END marker; not touching hosts")
return False
end = end_at + len(_HOSTS_BLOCK_END)
if content[start:end] == expected:
return True
return _write_hosts(
content[:start] + expected + content[end:],
"Failed to refresh total-block hosts entries",
)
def remove_total_block_hosts() -> bool:
"""Remove the total-block domain block from /etc/hosts, if present."""
try:
content = HOSTS_FILE.read_text(encoding="utf-8")
except OSError:
logger.exception("Failed to read /etc/hosts")
return False
if _HOSTS_BLOCK_BEGIN not in content:
return True
start = content.index(_HOSTS_BLOCK_BEGIN)
end_marker_at = content.index(_HOSTS_BLOCK_END, start)
end = end_marker_at + len(_HOSTS_BLOCK_END)
new_content = content[:start] + content[end:]
try:
_disable_hosts_protection()
_sudo_write_hosts(new_content)
except OSError, subprocess.SubprocessError:
logger.exception("Failed to remove total-block hosts entries")
return False
finally:
_enable_hosts_protection()
return True