mirror of
https://github.com/kuhyx/steam-backlog-enforcer.git
synced 2026-11-22 05:42:20 +01:00
Add cancel window to hiding jobs
done, check, pick, pick-manual and hide can be cancelled only while they hide games in the Steam library: cancel_window events, a SIGTERM handler during that phase that skips the hide, and the web UI shows the cancel button while the window is open. Docs fixed (check is mutating). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01WzxdWYNS1qAMRdgAtbr5Rq
This commit is contained in:
parent
4424a26dbe
commit
9ed4725d45
@ -60,7 +60,7 @@ mirror is `web/src/api/contract.ts`; change both together or neither.
|
||||
| GET | `/api/jobs/{id}` | – | `Job` |
|
||||
| GET | `/api/jobs/{id}/events` | `?token=&after=<seq>` | SSE stream of `JobEvent` |
|
||||
| POST | `/api/jobs/{id}/answer` | `PromptAnswer` | `204` |
|
||||
| POST | `/api/jobs/{id}/cancel` | – | `204` (only if `CommandSpec.cancellable`) |
|
||||
| POST | `/api/jobs/{id}/cancel` | – | `204` (only if `CommandSpec.cancellable`, or while the job's `cancel_window` is open) |
|
||||
| POST | `/api/pending/{id}/heartbeat` | – | `PendingAction` |
|
||||
| POST | `/api/pending/{id}/commit` | `{confirm_phrase}` | `Job` |
|
||||
| DELETE | `/api/pending/{id}` | – | `204` |
|
||||
@ -134,7 +134,14 @@ with explicit params, a `Progress` reporter and a `Prompter`.
|
||||
`result.json`. The server only tails files, so jobs survive both page
|
||||
reloads and server restarts (including `_serve_stale` retirement).
|
||||
- At most **one mutating job** at a time (`busy` otherwise). Read-only jobs
|
||||
(`check`, `stats`, `list`, …) may run alongside.
|
||||
(`stats`, `list`) may run alongside. `check` is mutating, like `done`: a
|
||||
new achievement releases the game and assigns the next one.
|
||||
- `done`, `check`, `pick`, `pick-manual` and `hide` cannot be cancelled,
|
||||
except while they hide games in the Steam library (the `cancel_window`
|
||||
event below; `check` has the flag but no hide step today, so it never
|
||||
opens a window). That phase can wait on a Steam launch, and the job holds
|
||||
the mutating lock throughout. Cancelling there skips the hide; the job then carries on and ends normally, so the
|
||||
lock drops.
|
||||
- History: last 50 job dirs kept, older ones pruned at job start. Job ids
|
||||
are `<UTC yyyymmddThhmmss + microseconds>Z-<6 hex>`, so sorting by id is
|
||||
creation order even within one second.
|
||||
@ -157,6 +164,14 @@ with explicit params, a `Progress` reporter and a `Prompter`.
|
||||
- `progress` — `{step, total, label, item?, eta_seconds?}`; `total` may be
|
||||
`null` for indeterminate phases. Any operation over 2 s must emit
|
||||
determinate progress.
|
||||
- `cancel_window` — `{open}`, only from commands flagged `cancel_window` in
|
||||
`jobs/_specs.py` (`done`, `check`, `pick`, `pick-manual`, `hide`):
|
||||
`open: true` when the job starts hiding games in the Steam library,
|
||||
`open: false` when it stops (also after a cancel). The job installs its SIGTERM handler before it
|
||||
writes `open: true` and restores the previous one before `open: false`.
|
||||
`POST /api/jobs/{id}/cancel` is accepted exactly while the latest
|
||||
`cancel_window` event says `open`, else `not_cancellable`; the UI shows
|
||||
its Cancel button on the same condition. Declared in `jobContract.ts`.
|
||||
- `prompt` — `{prompt_id, kind, message, options?, phrase?, default?,
|
||||
app_ids?}`; `kind` is `choice` (pick one of `options`), `confirm`
|
||||
(yes/no), `phrase` (type `phrase` exactly), `text` or `game`. The job
|
||||
|
||||
39
steam_backlog_enforcer/_cancel_window.py
Normal file
39
steam_backlog_enforcer/_cancel_window.py
Normal file
@ -0,0 +1,39 @@
|
||||
"""A stretch of a command during which a web job may be cancelled.
|
||||
|
||||
Most commands cannot be stopped midway, but the library-hiding phase of
|
||||
``done`` and ``check`` can: it only drives Steam, and a hide that is aborted is
|
||||
already a skip. The command code marks that phase with :func:`cancel_window`;
|
||||
*who* acts on the mark is decided by the caller, exactly like
|
||||
:mod:`steam_backlog_enforcer._progress`. The CLI and the root daemon install
|
||||
nothing, so for them the window is a no-op; a web job installs one that
|
||||
announces it to the server and turns SIGTERM into a skipped hide.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from contextlib import AbstractContextManager, contextmanager, nullcontext
|
||||
from contextvars import ContextVar
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from collections.abc import Callable, Iterator
|
||||
|
||||
WindowFactory = Callable[[], AbstractContextManager[None]]
|
||||
|
||||
_ACTIVE: ContextVar[WindowFactory | None] = ContextVar("cancel_window", default=None)
|
||||
|
||||
|
||||
def cancel_window() -> AbstractContextManager[None]:
|
||||
"""Return the context manager that brackets a cancellable phase."""
|
||||
factory = _ACTIVE.get()
|
||||
return nullcontext() if factory is None else factory()
|
||||
|
||||
|
||||
@contextmanager
|
||||
def use_cancel_window(factory: WindowFactory) -> Iterator[None]:
|
||||
"""Make *factory* build the cancel windows for the duration of the context."""
|
||||
token = _ACTIVE.set(factory)
|
||||
try:
|
||||
yield
|
||||
finally:
|
||||
_ACTIVE.reset(token)
|
||||
@ -60,3 +60,13 @@ class FastInstallInProgressError(SteamUnavailableError):
|
||||
underneath it discards the manifest the installer is about to write and
|
||||
resumes the slow client download - so every launch path defers instead.
|
||||
"""
|
||||
|
||||
|
||||
class HidingCancelledError(SteamUnavailableError):
|
||||
"""Raised inside a job's library-hiding phase when the user cancels it.
|
||||
|
||||
Subclasses :class:`SteamUnavailableError` so ``try_hide_other_games``
|
||||
already turns it into a skipped hide: the job carries on and ends
|
||||
normally, releasing the one-mutating-job lock, instead of waiting out a
|
||||
Steam launch that may never finish.
|
||||
"""
|
||||
|
||||
@ -119,7 +119,7 @@ def answer_view(request: Request) -> Reply:
|
||||
|
||||
|
||||
def cancel_view(request: Request) -> Reply:
|
||||
"""``POST /api/jobs/{id}/cancel`` — only for cancellable commands."""
|
||||
"""``POST /api/jobs/{id}/cancel`` — cancellable, or inside a cancel window."""
|
||||
try:
|
||||
cancel(request.args[0])
|
||||
except JobError as exc:
|
||||
|
||||
61
steam_backlog_enforcer/jobs/_cancel_window.py
Normal file
61
steam_backlog_enforcer/jobs/_cancel_window.py
Normal file
@ -0,0 +1,61 @@
|
||||
"""The job side of a cancel window: announce it, and turn SIGTERM into a skip.
|
||||
|
||||
``done`` and ``check`` cannot be stopped midway, except while they hide games
|
||||
in the Steam library (see :mod:`steam_backlog_enforcer._cancel_window`). While
|
||||
a window is open the job writes ``cancel_window`` events (``open: true`` then
|
||||
``open: false``), which the server reads to accept a cancel and the UI reads
|
||||
to show its button, and a SIGTERM raises :class:`HidingCancelledError`. The hide
|
||||
turns that into a skip, so the job finishes normally and drops the lock.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from contextlib import contextmanager
|
||||
import signal
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
from steam_backlog_enforcer._steam_errors import HidingCancelledError
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from collections.abc import Iterator
|
||||
from types import FrameType
|
||||
|
||||
from steam_backlog_enforcer.jobs._events import EventWriter
|
||||
|
||||
CANCEL_WINDOW_EVENT = "cancel_window"
|
||||
|
||||
|
||||
def _raise_cancelled(_signum: int, _frame: FrameType | None) -> None:
|
||||
"""SIGTERM inside the window: abort the hide, once. No I/O, as in the runner.
|
||||
|
||||
Ignoring further SIGTERMs first means a second cancel cannot interrupt the
|
||||
cleanup that restores the previous handler and closes the window.
|
||||
"""
|
||||
signal.signal(signal.SIGTERM, signal.SIG_IGN)
|
||||
msg = "Cancelled"
|
||||
raise HidingCancelledError(msg)
|
||||
|
||||
|
||||
class JobCancelWindow:
|
||||
"""Builds the context manager that brackets one cancellable phase."""
|
||||
|
||||
def __init__(self, writer: EventWriter) -> None:
|
||||
"""Bind to the job's event writer."""
|
||||
self._writer = writer
|
||||
|
||||
@contextmanager
|
||||
def __call__(self) -> Iterator[None]:
|
||||
"""Open the window for the body, then close it, however it ends.
|
||||
|
||||
The handler goes in before ``open`` is written and the previous one
|
||||
comes back before ``close``, so the server only ever sees a window
|
||||
the job can act on. The previous handler is restored rather than
|
||||
assumed to be "ignore": a cancellable command already had its own.
|
||||
"""
|
||||
previous = signal.signal(signal.SIGTERM, _raise_cancelled)
|
||||
try:
|
||||
self._writer.emit(CANCEL_WINDOW_EVENT, open=True)
|
||||
yield
|
||||
finally:
|
||||
signal.signal(signal.SIGTERM, previous)
|
||||
self._writer.emit(CANCEL_WINDOW_EVENT, open=False)
|
||||
@ -35,6 +35,13 @@ def _open_prompt_id(job_id: str) -> str | None:
|
||||
return None if latest in answered else latest
|
||||
|
||||
|
||||
def _cancel_window_open(job_id: str) -> bool:
|
||||
"""Whether the job's latest ``cancel_window`` event says it is open."""
|
||||
path = _store.job_dir(job_id)
|
||||
windows = [e for e in read_events(path) if e.get("type") == "cancel_window"]
|
||||
return bool(windows) and bool(windows[-1].get("open"))
|
||||
|
||||
|
||||
def write_answer(job_id: str, prompt_id: str, value: str) -> None:
|
||||
"""Deliver the user's answer to the prompt the job is waiting on.
|
||||
|
||||
@ -60,7 +67,11 @@ def write_answer(job_id: str, prompt_id: str, value: str) -> None:
|
||||
def cancel(job_id: str) -> None:
|
||||
"""Ask a job to stop: any job waiting on a prompt, else cancellable ones.
|
||||
|
||||
A cancellable job gets SIGTERM, to its own process only.
|
||||
A cancellable job gets SIGTERM, to its own process only. So does a
|
||||
cancel-window job (``done``, ``check``, ``pick``, ``pick-manual``,
|
||||
``hide``), but only while its ``cancel_window`` is open (it is hiding
|
||||
games in the Steam library); the runner turns that SIGTERM into a skipped
|
||||
hide and the job finishes normally.
|
||||
|
||||
Only the job's pid is signalled, never its process group: a job may
|
||||
have started Steam, and cancelling a scan must not take Steam down.
|
||||
@ -77,7 +88,9 @@ def cancel(job_id: str) -> None:
|
||||
(_store.job_dir(job_id) / CANCEL_NAME).touch()
|
||||
return
|
||||
flags = JOB_FLAGS.get(job["command"])
|
||||
if flags is None or not flags.cancellable:
|
||||
if flags is None or not (
|
||||
flags.cancellable or (flags.cancel_window and _cancel_window_open(job_id))
|
||||
):
|
||||
msg = f"{job['command']} cannot be cancelled once started."
|
||||
raise JobError(msg, code="not_cancellable")
|
||||
if job["state"] in TERMINAL_STATES:
|
||||
|
||||
@ -18,6 +18,7 @@ import os
|
||||
import signal
|
||||
from typing import TYPE_CHECKING, Any, Final
|
||||
|
||||
from steam_backlog_enforcer._cancel_window import use_cancel_window
|
||||
from steam_backlog_enforcer._command_gate import lock_reason
|
||||
from steam_backlog_enforcer._echo import routed_echo
|
||||
from steam_backlog_enforcer._fail_safe import FAIL_SAFE_ERRORS
|
||||
@ -25,6 +26,7 @@ from steam_backlog_enforcer._progress import use_progress
|
||||
from steam_backlog_enforcer._prompter import PromptAbortedError, use_prompter
|
||||
from steam_backlog_enforcer.config import Config, State, _atomic_write
|
||||
from steam_backlog_enforcer.jobs import _spawn, _store
|
||||
from steam_backlog_enforcer.jobs._cancel_window import JobCancelWindow
|
||||
from steam_backlog_enforcer.jobs._errors import (
|
||||
JobCancelledError,
|
||||
JobError,
|
||||
@ -156,6 +158,8 @@ def _run_command(
|
||||
stack.callback(logging.getLogger().removeHandler, handler)
|
||||
_on_sigterm(cancellable=flags.cancellable)
|
||||
stack.callback(signal.signal, signal.SIGTERM, signal.SIG_IGN)
|
||||
if flags.cancel_window:
|
||||
stack.enter_context(use_cancel_window(JobCancelWindow(writer)))
|
||||
|
||||
config = Config.load()
|
||||
try:
|
||||
|
||||
@ -24,27 +24,34 @@ class JobFlags:
|
||||
mutating: Takes the one-mutating-job lock.
|
||||
cancellable: SIGTERM cancels it (only where stopping midway is safe).
|
||||
privileged: Runs in the root daemon; never spawned as a job.
|
||||
cancel_window: Cancellable only while the job reports an open
|
||||
``cancel_window`` (hiding games in the Steam library); the work
|
||||
before it cannot be stopped midway.
|
||||
"""
|
||||
|
||||
mutating: bool = True
|
||||
cancellable: bool = False
|
||||
privileged: bool = False
|
||||
cancel_window: bool = False
|
||||
|
||||
|
||||
_PRIVILEGED = JobFlags(privileged=True)
|
||||
|
||||
JOB_FLAGS: Final[dict[str, JobFlags]] = {
|
||||
# check is mutating: a new achievement releases the game and assigns
|
||||
# the next one, exactly like done.
|
||||
"check": JobFlags(),
|
||||
# the next one, exactly like done. Every command that hides games in the
|
||||
# Steam library (try_hide_other_games, which may wait on a Steam launch)
|
||||
# can be stopped only during that step. do_check never hides today, so
|
||||
# check's window is inert until it gains one.
|
||||
"check": JobFlags(cancel_window=True),
|
||||
"scan": JobFlags(cancellable=True),
|
||||
"done": JobFlags(),
|
||||
"pick": JobFlags(),
|
||||
"pick-manual": JobFlags(),
|
||||
"done": JobFlags(cancel_window=True),
|
||||
"pick": JobFlags(cancel_window=True),
|
||||
"pick-manual": JobFlags(cancel_window=True),
|
||||
"abandon-pick": JobFlags(),
|
||||
"install": JobFlags(),
|
||||
"uninstall": JobFlags(),
|
||||
"hide": JobFlags(),
|
||||
"hide": JobFlags(cancel_window=True),
|
||||
"unhide": JobFlags(),
|
||||
"add-exception": JobFlags(),
|
||||
"reset": JobFlags(),
|
||||
|
||||
@ -22,6 +22,7 @@ from typing import TYPE_CHECKING
|
||||
|
||||
from steam_backlog_enforcer._achievement_skip import zero_achievement_ids
|
||||
from steam_backlog_enforcer._actions import allowed_app_ids as _allowed_ids_of
|
||||
from steam_backlog_enforcer._cancel_window import cancel_window
|
||||
from steam_backlog_enforcer._cdp import _cdp_result_value, _evaluate_js
|
||||
from steam_backlog_enforcer._echo import _echo
|
||||
from steam_backlog_enforcer._owned_apps_cache import get_all_owned_app_ids
|
||||
@ -186,7 +187,10 @@ def try_hide_other_games(
|
||||
progress = current_progress()
|
||||
progress.phase("Hiding games in the Steam library", 1)
|
||||
try:
|
||||
return hide_other_games(owned_app_ids, allowed_app_ids), None
|
||||
# A web job may be cancelled here (the Steam launch can wait a while);
|
||||
# the cancel raises a SteamUnavailableError, handled just below.
|
||||
with cancel_window():
|
||||
return hide_other_games(owned_app_ids, allowed_app_ids), None
|
||||
except SteamUnavailableError as exc:
|
||||
return 0, str(exc)
|
||||
finally:
|
||||
|
||||
250
steam_backlog_enforcer/tests/test_jobs_cancel_window.py
Normal file
250
steam_backlog_enforcer/tests/test_jobs_cancel_window.py
Normal file
@ -0,0 +1,250 @@
|
||||
"""Tests for the cancel window: hiding jobs stop only while hiding games.
|
||||
|
||||
A ``done`` job once sat 90+ s in the Steam launch wait holding the one
|
||||
mutating-job lock, and could not be cancelled. Cancelling is now accepted
|
||||
only inside the library-hiding phase: the job announces the phase with
|
||||
``cancel_window`` events, the server signals it only while open, and the
|
||||
runner turns the SIGTERM into a skipped hide so the job ends normally.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from contextlib import contextmanager, suppress
|
||||
import signal
|
||||
from typing import TYPE_CHECKING
|
||||
from unittest.mock import MagicMock, patch
|
||||
|
||||
import pytest
|
||||
|
||||
from steam_backlog_enforcer._cancel_window import cancel_window, use_cancel_window
|
||||
from steam_backlog_enforcer._steam_errors import (
|
||||
HidingCancelledError,
|
||||
SteamUnavailableError,
|
||||
)
|
||||
from steam_backlog_enforcer.jobs import _control, _runner
|
||||
from steam_backlog_enforcer.jobs._cancel_window import JobCancelWindow
|
||||
from steam_backlog_enforcer.jobs._errors import JobError
|
||||
from steam_backlog_enforcer.jobs._events import EventWriter, read_events
|
||||
from steam_backlog_enforcer.jobs._job_io import JobLogSink
|
||||
from steam_backlog_enforcer.jobs._registry import HANDLERS
|
||||
from steam_backlog_enforcer.jobs._runner import _run_command
|
||||
from steam_backlog_enforcer.jobs._specs import JOB_FLAGS
|
||||
from steam_backlog_enforcer.library_hider import try_hide_other_games
|
||||
from steam_backlog_enforcer.tests._jobs_helpers import JOB_ID, make_job
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from collections.abc import Callable, Iterator
|
||||
from contextlib import AbstractContextManager
|
||||
from pathlib import Path
|
||||
|
||||
_PID_ALIVE = "steam_backlog_enforcer.jobs._view._pid_alive"
|
||||
_ALIVE = "steam_backlog_enforcer.jobs._control.pid_of"
|
||||
_KILL = "steam_backlog_enforcer.jobs._control.os.kill"
|
||||
_WINDOW_SIGNAL = "steam_backlog_enforcer.jobs._cancel_window.signal"
|
||||
_GATE = "steam_backlog_enforcer.jobs._runner.enforce_gate"
|
||||
_HIDE = "steam_backlog_enforcer.library_hider.hide_other_games"
|
||||
|
||||
|
||||
def _window_events(path: Path) -> list[bool]:
|
||||
"""The ``open`` flag of every cancel_window event, in order."""
|
||||
return [bool(e["open"]) for e in read_events(path) if e["type"] == "cancel_window"]
|
||||
|
||||
|
||||
# Every command whose job reaches try_hide_other_games, which opens the window.
|
||||
_WINDOWED = ("done", "check", "pick", "pick-manual", "hide")
|
||||
|
||||
|
||||
class TestFlags:
|
||||
"""Which commands have a cancel window."""
|
||||
|
||||
@pytest.mark.parametrize("command", _WINDOWED)
|
||||
def test_hiding_commands_have_a_window(self, command: str) -> None:
|
||||
"""Each is mutating, not generally cancellable, but has the window."""
|
||||
flags = JOB_FLAGS[command]
|
||||
assert flags.mutating
|
||||
assert not flags.cancellable
|
||||
assert flags.cancel_window
|
||||
|
||||
def test_nothing_else_has_one(self) -> None:
|
||||
"""Every other command keeps its old cancel rules."""
|
||||
others = {k for k, f in JOB_FLAGS.items() if f.cancel_window}
|
||||
assert others == set(_WINDOWED)
|
||||
|
||||
|
||||
class TestControlCancel:
|
||||
"""_control.cancel honours the window for the commands that have one."""
|
||||
|
||||
@pytest.fixture(autouse=True)
|
||||
def _alive(self) -> Iterator[None]:
|
||||
with patch(_PID_ALIVE, return_value=True):
|
||||
yield
|
||||
|
||||
def test_accepted_while_the_window_is_open(self) -> None:
|
||||
"""Inside the window, ``done`` gets SIGTERM on its own pid."""
|
||||
path = make_job("done", pid="5\n")
|
||||
EventWriter(path).emit("cancel_window", open=True)
|
||||
with patch(_ALIVE, return_value=5), patch(_KILL) as kill:
|
||||
_control.cancel(JOB_ID)
|
||||
kill.assert_called_once_with(5, signal.SIGTERM)
|
||||
|
||||
def test_refused_before_the_window_opens(self) -> None:
|
||||
"""A windowed job stays uncancellable until its window opens."""
|
||||
make_job("done", pid="5\n")
|
||||
with patch(_KILL) as kill, pytest.raises(JobError) as info:
|
||||
_control.cancel(JOB_ID)
|
||||
assert info.value.code == "not_cancellable"
|
||||
kill.assert_not_called()
|
||||
|
||||
def test_refused_after_the_window_closes(self) -> None:
|
||||
"""Once hiding is over the job can no longer be stopped."""
|
||||
path = make_job("check", pid="5\n")
|
||||
writer = EventWriter(path)
|
||||
writer.emit("cancel_window", open=True)
|
||||
writer.emit("cancel_window", open=False)
|
||||
with patch(_KILL) as kill, pytest.raises(JobError) as info:
|
||||
_control.cancel(JOB_ID)
|
||||
assert info.value.code == "not_cancellable"
|
||||
kill.assert_not_called()
|
||||
|
||||
def test_window_event_does_not_open_other_commands(self) -> None:
|
||||
"""A command without the flag ignores any window event."""
|
||||
path = make_job("abandon-pick", pid="5\n")
|
||||
EventWriter(path).emit("cancel_window", open=True)
|
||||
with patch(_KILL) as kill, pytest.raises(JobError) as info:
|
||||
_control.cancel(JOB_ID)
|
||||
assert info.value.code == "not_cancellable"
|
||||
kill.assert_not_called()
|
||||
|
||||
|
||||
class TestJobCancelWindow:
|
||||
"""JobCancelWindow: the SIGTERM handler and the events, in order."""
|
||||
|
||||
@staticmethod
|
||||
def _body(*, fail: bool) -> None:
|
||||
"""The hide inside the window: fine, or aborted by a cancel."""
|
||||
if fail:
|
||||
raise HidingCancelledError
|
||||
|
||||
def _enter(self, *, fail: bool = False) -> MagicMock:
|
||||
"""Run one window against mocks; return the recorded calls."""
|
||||
path = make_job("done")
|
||||
writer = MagicMock(wraps=EventWriter(path))
|
||||
calls = MagicMock()
|
||||
calls.attach_mock(writer.emit, "emit")
|
||||
fake_signal = MagicMock()
|
||||
fake_signal.SIGTERM = signal.SIGTERM
|
||||
fake_signal.signal.return_value = "previous"
|
||||
calls.attach_mock(fake_signal.signal, "signal")
|
||||
with (
|
||||
patch(_WINDOW_SIGNAL, fake_signal),
|
||||
suppress(HidingCancelledError),
|
||||
JobCancelWindow(writer)(),
|
||||
):
|
||||
self._body(fail=fail)
|
||||
return calls
|
||||
|
||||
def test_handler_is_installed_before_open_and_restored_before_close(
|
||||
self,
|
||||
) -> None:
|
||||
"""The marker is only visible while a handler can act on it."""
|
||||
calls = self._enter()
|
||||
names = [c[0] for c in calls.mock_calls]
|
||||
assert names == ["signal", "emit", "signal", "emit"]
|
||||
assert calls.mock_calls[1].kwargs == {"open": True}
|
||||
assert calls.mock_calls[2].args == (signal.SIGTERM, "previous")
|
||||
assert calls.mock_calls[3].kwargs == {"open": False}
|
||||
|
||||
def test_window_closes_when_the_body_raises(self) -> None:
|
||||
"""An aborted hide still restores the handler and closes the window."""
|
||||
names = [c[0] for c in self._enter(fail=True).mock_calls]
|
||||
assert names == ["signal", "emit", "signal", "emit"]
|
||||
|
||||
def test_sigterm_handler_raises_a_hide_skip_once(self) -> None:
|
||||
"""SIGTERM inside the window raises an error ``try_hide`` turns to a skip.
|
||||
|
||||
The handler also ignores any later SIGTERM, so a second cancel cannot
|
||||
interrupt the cleanup. Called under a mocked ``signal``: a real call
|
||||
would change the test process's own SIGTERM disposition.
|
||||
"""
|
||||
handler = self._enter().mock_calls[0].args[1]
|
||||
fake_signal = MagicMock()
|
||||
with patch(_WINDOW_SIGNAL, fake_signal), pytest.raises(HidingCancelledError):
|
||||
handler(signal.SIGTERM, None)
|
||||
fake_signal.signal.assert_called_once_with(
|
||||
fake_signal.SIGTERM, fake_signal.SIG_IGN
|
||||
)
|
||||
assert issubclass(HidingCancelledError, SteamUnavailableError)
|
||||
|
||||
|
||||
class TestHideUsesTheWindow:
|
||||
"""try_hide_other_games runs the hide inside whatever window is installed."""
|
||||
|
||||
@staticmethod
|
||||
def _recorder(seen: list[str]) -> Callable[[], AbstractContextManager[None]]:
|
||||
@contextmanager
|
||||
def window() -> Iterator[None]:
|
||||
seen.append("open")
|
||||
try:
|
||||
yield
|
||||
finally:
|
||||
seen.append("close")
|
||||
|
||||
return window
|
||||
|
||||
def test_no_window_installed_is_a_noop(self) -> None:
|
||||
"""The CLI and the daemon have no window; hiding is unchanged."""
|
||||
with cancel_window():
|
||||
pass
|
||||
with patch(_HIDE, return_value=2):
|
||||
assert try_hide_other_games([1], {2}) == (2, None)
|
||||
|
||||
def test_hide_runs_between_open_and_close(self) -> None:
|
||||
"""The window brackets exactly the hide."""
|
||||
seen: list[str] = []
|
||||
|
||||
def hide(*_args: object) -> int:
|
||||
seen.append("hide")
|
||||
return 3
|
||||
|
||||
with use_cancel_window(self._recorder(seen)), patch(_HIDE, side_effect=hide):
|
||||
assert try_hide_other_games([1], {2}) == (3, None)
|
||||
assert seen == ["open", "hide", "close"]
|
||||
|
||||
def test_cancel_during_hide_is_a_skip_not_a_failure(self) -> None:
|
||||
"""A cancel mid-hide is reported as a skipped hide; the window closes."""
|
||||
seen: list[str] = []
|
||||
with (
|
||||
use_cancel_window(self._recorder(seen)),
|
||||
patch(_HIDE, side_effect=HidingCancelledError("Cancelled")),
|
||||
):
|
||||
assert try_hide_other_games([1], {2}) == (0, "Cancelled")
|
||||
assert seen == ["open", "close"]
|
||||
|
||||
|
||||
class TestRunnerWiring:
|
||||
"""The runner installs the window only for commands that have one."""
|
||||
|
||||
def _run(self, command: str) -> list[bool]:
|
||||
path = make_job(command)
|
||||
writer = EventWriter(path)
|
||||
|
||||
def handler(*_args: object) -> None:
|
||||
with cancel_window():
|
||||
pass
|
||||
|
||||
with (
|
||||
patch.object(signal, "signal"),
|
||||
patch.object(_runner, "_hold_lock", return_value=None),
|
||||
patch.dict(HANDLERS, {command: handler}),
|
||||
patch(_GATE),
|
||||
):
|
||||
_run_command(path, writer, JobLogSink(writer), {"command": command})
|
||||
return _window_events(path)
|
||||
|
||||
def test_done_opens_and_closes_a_window(self) -> None:
|
||||
"""A ``done`` job reports the window open, then closed."""
|
||||
assert self._run("done") == [True, False]
|
||||
|
||||
def test_abandon_pick_has_no_window(self) -> None:
|
||||
"""A command without the flag never reports one."""
|
||||
assert self._run("abandon-pick") == []
|
||||
@ -61,6 +61,13 @@ export type JobEvent =
|
||||
| (JobEventBase & { type: 'state'; state: JobState })
|
||||
| (JobEventBase & { type: 'log'; level: 'info' | 'warning' | 'error'; message: string })
|
||||
| (JobEventBase & { type: 'progress' } & JobProgress)
|
||||
/**
|
||||
* Sent only by commands with a cancel window (`done`, `pick`, `pick-manual`,
|
||||
* `hide`; `check` has the flag but no hide step yet). The job is cancellable only while `open` is true
|
||||
* (it is hiding games in the Steam library); `POST …/cancel` is refused
|
||||
* outside it.
|
||||
*/
|
||||
| (JobEventBase & { type: 'cancel_window'; open: boolean })
|
||||
| (JobEventBase & {
|
||||
type: 'prompt'
|
||||
prompt_id: string
|
||||
|
||||
@ -24,14 +24,16 @@ export interface LiveJob {
|
||||
connected: boolean
|
||||
/** Seconds since epoch of the first progress event, for rate display. */
|
||||
startedProgressAt: number | null
|
||||
/** A job that is not cancellable as a command can be, right now. */
|
||||
cancelWindowOpen: boolean
|
||||
}
|
||||
|
||||
const EMPTY: LiveJob = {
|
||||
lastSeq: 0, state: null, progress: null, logs: [], prompt: null, result: null,
|
||||
connected: false, startedProgressAt: null,
|
||||
connected: false, startedProgressAt: null, cancelWindowOpen: false,
|
||||
}
|
||||
const TERMINAL = new Set<JobState>(['succeeded', 'failed', 'cancelled'])
|
||||
const EVENT_TYPES = ['state', 'log', 'progress', 'prompt', 'result'] as const
|
||||
const EVENT_TYPES = ['state', 'log', 'progress', 'cancel_window', 'prompt', 'result'] as const
|
||||
const MAX_LOGS = 500
|
||||
|
||||
function reduce(live: LiveJob, e: JobEvent): LiveJob {
|
||||
@ -50,6 +52,9 @@ function reduce(live: LiveJob, e: JobEvent): LiveJob {
|
||||
next.startedProgressAt ??= Date.now() / 1000
|
||||
break
|
||||
}
|
||||
case 'cancel_window':
|
||||
next.cancelWindowOpen = e.open
|
||||
break
|
||||
case 'prompt':
|
||||
next.prompt = e
|
||||
break
|
||||
|
||||
44
web/src/jobs/jobProgress.cancelWindow.test.ts
Normal file
44
web/src/jobs/jobProgress.cancelWindow.test.ts
Normal file
@ -0,0 +1,44 @@
|
||||
// A done/check job is not cancellable as a command, but it announces a cancel
|
||||
// window while it hides games in the Steam library: Cancel shows only then.
|
||||
|
||||
import { beforeEach, describe, expect, it, vi } from 'vitest'
|
||||
import { bodiesOf, installEventSource } from '../test/harness'
|
||||
import { button } from '../test/events'
|
||||
import { mountJob } from '../test/jobHelpers'
|
||||
|
||||
beforeEach(installEventSource)
|
||||
|
||||
const cancelButton = (el: Element) => el.querySelector('[aria-label="Cancel job"]')
|
||||
|
||||
describe('<job-progress> cancel window', () => {
|
||||
it('shows Cancel only while the job reports the window open', async () => {
|
||||
const { el, send } = mountJob({ cancellable: false })
|
||||
await vi.waitFor(() => { expect(el.querySelector('section')).not.toBeNull() })
|
||||
send('state', { state: 'running' })
|
||||
expect(cancelButton(el)).toBeNull()
|
||||
|
||||
send('cancel_window', { open: true })
|
||||
expect(cancelButton(el)).not.toBeNull()
|
||||
|
||||
send('cancel_window', { open: false })
|
||||
expect(cancelButton(el)).toBeNull()
|
||||
})
|
||||
|
||||
it('cancels through the API from inside the window', async () => {
|
||||
const { el, send, routes, id, mock } = mountJob({ cancellable: false })
|
||||
routes[`POST /api/jobs/${id}/cancel`] = undefined
|
||||
send('state', { state: 'running' })
|
||||
send('cancel_window', { open: true })
|
||||
button(el, 'Cancel job').click()
|
||||
await vi.waitFor(() => {
|
||||
expect(bodiesOf(mock, `POST /api/jobs/${id}/cancel`)).toHaveLength(1)
|
||||
})
|
||||
})
|
||||
|
||||
it('drops the button once the job has finished, window or not', () => {
|
||||
const { el, send } = mountJob({ cancellable: false })
|
||||
send('cancel_window', { open: true })
|
||||
send('state', { state: 'succeeded' })
|
||||
expect(cancelButton(el)).toBeNull()
|
||||
})
|
||||
})
|
||||
@ -180,7 +180,7 @@ export class JobProgressElement extends LiveElement {
|
||||
)
|
||||
f.actions.replaceChildren(
|
||||
...(this.cancel.error ? [errorNotice(this.cancel.error)] : []),
|
||||
...((spec?.cancellable || waiting) && !finished
|
||||
...((spec?.cancellable || waiting || live.cancelWindowOpen) && !finished
|
||||
? [
|
||||
h(
|
||||
'div',
|
||||
|
||||
Loading…
Reference in New Issue
Block a user