From 35899a6a7f6e914d4e833e011f261b675d586e3a Mon Sep 17 00:00:00 2001 From: chodeus <190988615+chodeus@users.noreply.github.com> Date: Thu, 15 Oct 2026 14:40:44 +0800 Subject: [PATCH] fix: keep the current mode when delete or an unknown mode is saved while the container runs --- app/main.py | 18 +++++++- app/webui.py | 6 ++- docs/configuration.md | 2 +- tests/test_runtime_mode.py | 85 ++++++++++++++++++++++++++++++++++++++ 4 files changed, 108 insertions(+), 3 deletions(-) create mode 100644 tests/test_runtime_mode.py diff --git a/app/main.py b/app/main.py index a8b00d5..b8ada01 100644 --- a/app/main.py +++ b/app/main.py @@ -3238,6 +3238,9 @@ def setup_logging(log_level, log_file=None): webui_port = 8484 """ +# Modes a running container can switch to; delete runs only at startup. +_RUNTIME_MODES = ("setup", "report", "move") + # Maps config-file keys (lowercase) to environment variable names. _CONFIG_KEY_MAP = { 'music_dir': 'MUSIC_DIR', @@ -3434,6 +3437,19 @@ def _copy_config_file_to_env(path): return overridden +def _usable_saved_mode(raw, current): + """The saved mode for the next pass; *current* when *raw* is delete or unknown, as only startup can act on those.""" + mode = (raw or current).lower() + if mode in _RUNTIME_MODES: + return mode + if mode == "delete": + logger.warning("mode = delete only runs at startup. For an interactive delete, run " + "'docker exec -it beatscheck delete'. Keeping mode %s.", current) + else: + logger.warning("Unknown mode '%s' in beatscheck.conf. Keeping mode %s.", mode, current) + return current + + def _reload_config(cfg): """Re-read beatscheck.conf and update cfg for the next scan. @@ -3449,7 +3465,7 @@ def _reload_config(cfg): "MUSIC_DIR", cfg.input_folder).rstrip("/") cfg.output_folder = os.environ.get( "OUTPUT_DIR", cfg.output_folder).rstrip("/") - saved_mode = (os.environ.get("MODE") or cfg.saved_mode).lower() + saved_mode = _usable_saved_mode(os.environ.get("MODE"), cfg.saved_mode) # A rescan's mode holds until the saved mode changes after it. if saved_mode != cfg.saved_mode: cfg.rescan_mode = None diff --git a/app/webui.py b/app/webui.py index 95a4090..cfb5a5d 100644 --- a/app/webui.py +++ b/app/webui.py @@ -371,7 +371,7 @@ def _login_record_success(key): # The canonical config-key map lives in main.py; import it so the WebUI's # allowed-keys list and parser stay in sync without duplication. from main import ( # noqa: E402 - _CONFIG_KEY_MAP, _acquire_scan_lock, _load_corrupt_details, + _CONFIG_KEY_MAP, _RUNTIME_MODES, _acquire_scan_lock, _load_corrupt_details, _parse_config_lines, _release_scan_lock, _sync_env_from_config_file, write_corrupt_list, write_json_atomic, write_text_atomic, ) @@ -1218,6 +1218,10 @@ def do_POST(self): {"error": "unknown keys: " + ", ".join(sorted(rejected))}, 400) return + if 'mode' in updates and str(updates['mode']).lower() not in _RUNTIME_MODES: + self._json_response( + {"error": "mode must be setup, report or move"}, 400) + return # Don't overwrite real key with the mask sentinel if updates.get('lidarr_api_key') == _API_KEY_MASK: del updates['lidarr_api_key'] diff --git a/docs/configuration.md b/docs/configuration.md index 6d73d18..8e932b0 100644 --- a/docs/configuration.md +++ b/docs/configuration.md @@ -7,7 +7,7 @@ On first run, BeatsCheck creates `/config/beatscheck.conf` with all options and | Setting | Default | Description | |---------|---------|-------------| | `output_dir` | `/data/corrupted` | Quarantine destination for move mode. Must match a mounted volume | -| `mode` | `setup` | `setup` (idle), `report`, `delete`, or `move`. `rescan report` or `rescan move` switches to that mode until the saved `mode` changes or the container restarts | +| `mode` | `setup` | `setup` (idle), `report`, `delete`, or `move`. `rescan report` or `rescan move` switches to that mode until the saved `mode` changes or the container restarts. `delete` works only at startup: saved while the container runs, it (or an unknown mode) is ignored with a warning, and the WebUI won't save it; use `docker exec -it beatscheck delete` | | `workers` | `4` | Parallel ffmpeg decode workers. 2 = conservative, 4 = balanced, 8+ = fast | | `run_interval` | `0` | Hours between scans. `0` = scan once, then stay idle until `rescan`. `168` = weekly. `24` = daily | | `delete_after` | `0` | Days before corrupt files are auto-deleted. `0` = never (manual only). `7` = 7 day review window | diff --git a/tests/test_runtime_mode.py b/tests/test_runtime_mode.py new file mode 100644 index 0000000..3bfdc2c --- /dev/null +++ b/tests/test_runtime_mode.py @@ -0,0 +1,85 @@ +"""A saved mode of delete, or one BeatsCheck doesn't know, leaves a running container in its current mode.""" + +import json +import os +import re +import sys +import urllib.error +import urllib.request + +import pytest + +sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "app")) + +import main # noqa: E402 +import webui # noqa: E402 + + +def _cfg(tmp_path, monkeypatch, saved): + """Load a config that saves mode = *saved*, with os.environ isolated.""" + monkeypatch.setattr(os, "environ", {"CONFIG_DIR": str(tmp_path)}) + monkeypatch.setattr(main, "_docker_env_vars", set()) + monkeypatch.setattr(sys, "argv", ["main.py"]) + main._write_default_config(str(tmp_path)) + _save(tmp_path, saved) + return main._load_config() + + +def _save(tmp_path, mode): + conf = tmp_path / "beatscheck.conf" + conf.write_text(re.sub(r"(?m)^mode = .*$", f"mode = {mode}", conf.read_text())) + + +def test_a_saved_delete_keeps_the_current_mode_and_says_how_to_delete(tmp_path, monkeypatch, caplog): + cfg = _cfg(tmp_path, monkeypatch, "report") + _save(tmp_path, "delete") + main._reload_config(cfg) + assert cfg.mode == "report" + assert "docker exec -it beatscheck delete" in caplog.text + + +def test_an_unknown_saved_mode_keeps_the_current_mode(tmp_path, monkeypatch, caplog): + cfg = _cfg(tmp_path, monkeypatch, "report") + _save(tmp_path, "reprot") + main._reload_config(cfg) + assert cfg.mode == "report" + assert "Unknown mode 'reprot'" in caplog.text + + +def test_a_saved_mode_in_capitals_still_applies(tmp_path, monkeypatch): + cfg = _cfg(tmp_path, monkeypatch, "report") + _save(tmp_path, "MOVE") + main._reload_config(cfg) + assert cfg.mode == "move" + + +def test_a_saved_delete_does_not_end_a_rescan(tmp_path, monkeypatch): + cfg = _cfg(tmp_path, monkeypatch, "report") + main._apply_rescan_trigger("move", cfg) + main._reload_config(cfg) + _save(tmp_path, "delete") + main._reload_config(cfg) + assert cfg.mode == "move" + + +def _post_config(base, config): + req = urllib.request.Request( + base + "/api/config", data=json.dumps({"config": config}).encode(), + headers={"Content-Type": "application/json"}, method="POST") + try: + with urllib.request.urlopen(req, timeout=10) as resp: # nosec B310 # the fixture's http://127.0.0.1 URL + return resp.status + except urllib.error.HTTPError as e: + return e.code + + +@pytest.mark.parametrize("mode, status", [("delete", 400), ("reprot", 400), (1, 400), ("Move", 200)]) +def test_the_webui_saves_only_a_mode_a_running_container_can_use(webui_server, tmp_path, monkeypatch, mode, status): + monkeypatch.setattr(os, "environ", {}) + monkeypatch.setattr(main, "_docker_env_vars", set()) + (tmp_path / "beatscheck.conf").write_text("mode = report\n") + webui._save_auth_off(str(tmp_path)) + got = _post_config(webui_server, {"mode": mode}) + saved = (tmp_path / "beatscheck.conf").read_text() + assert got == status + assert ("Move" in saved) == (status == 200)