Run MWL backup/reset on os-defined schedule

Author: carlosmartinez

.env.development

@@ -11,9 +11,7 @@ MWL_AET=SCREENING_MWL
 MWL_PORT=4243
 MWL_DB_PATH=/var/lib/pacs/worklist.db
 
-# MWL Reset Scheduler Configuration
 BACKUP_PATH=/var/lib/pacs/backups
-MWL_RESET_SCHEDULE=0 2 * * *
 
 # PACS Server Configuration
 PACS_AET=SCREENING_PACS

compose.yml

@@ -93,21 +93,6 @@ services:
         condition: service_healthy
     restart: unless-stopped
 
-  reset:
-    build:
-      context: .
-      dockerfile: Dockerfile
-    container_name: mwl-reset
-    command: ["uv", "run", "python", "-m", "reset_main"]
-    volumes:
-      - pacs-db:/var/lib/pacs
-    environment:
-      - MWL_DB_PATH=/var/lib/pacs/worklist.db
-      - BACKUP_PATH=/var/lib/pacs/backups
-      - MWL_RESET_SCHEDULE=0 2 * * *
-      - LOG_LEVEL=INFO
-    restart: unless-stopped
-
 volumes:
   pacs-storage:
     driver: local

docs/adr/ADR-004_MWL_Daily_Backup_And_Reset.md

@@ -12,22 +12,22 @@ The worklist is inherently ephemeral: appointments are scheduled per clinic, and
 
 The gateway MWL is not intended to be a canonical or long-term data store. Retaining worklist items indefinitely would cause the database to grow to unwieldy proportions and would give a false impression of data durability.
 
+The gateway runs as a Python process on a Windows VM managed by Azure Arc. Scheduling therefore belongs in the infrastructure layer (Windows Task Scheduler, configurable via Arc).
+
 ## Decision
 
-Reset the MWL database on a configurable schedule (default: daily at 02:00 UTC) by:
+Reset the MWL database on a schedule managed by Windows Task Scheduler by:
 
 1. Backing up the database before clearing it, using SQLite's native `conn.backup()` API
 2. Deleting all rows from `worklist_items`
 
-This runs as a dedicated `reset` container (`reset_main.py` / `MWLResetScheduler`).
-
-The schedule is configured via a cron expression (`MWL_RESET_SCHEDULE`), which allows any cadence (daily, weekly, etc) to be expressed in a single environment variable without code changes.
+`reset_main.py` is performs these two steps and exits. Windows Task Scheduler (registered via `scripts/bat/schtasks.bat`) invokes it on whatever schedule is configured in infrastructure.
 
 **Alternatives considered:**
 
-- **Reset on startup only** — would not handle long-running deployments where the container is not restarted between clinics
+- **In-process Python scheduler** (`croniter` sleep loop) — puts scheduling logic in application code; duplicates a facility the OS already provides; requires a long-running process that serves no other purpose
+- **Reset on startup only** — would not handle long-running deployments where the process is not restarted between clinics
 - **No reset** — leads to unbounded growth and stale data visible to the modality
-- **Interval-based env vars** (`RESET_INTERVAL=daily`, `RESET_TIME=02:00`, `RESET_DAY=monday`) — more verbose config, requires code changes to support new intervals; cron expression is more expressive in a single value
 
 ## Consequences
 
@@ -36,11 +36,11 @@ The schedule is configured via a cron expression (`MWL_RESET_SCHEDULE`), which a
 - Worklist is clean at the start of each clinic with no manual intervention
 - Database size remains bounded
 - Backup before clear means data is recoverable if needed
-- Schedule is fully configurable via env var without code changes
-- Follows the existing one-process-per-container pattern
+- Schedule is owned by infrastructure (Arc / Task Scheduler), not application code — no code change needed to adjust timing
+- `reset_main.py` is a simple, testable, one-shot script with no scheduler machinery
 
 ### Negative Consequences
 
-- Adds a fifth service to the deployment
+- Schedule configuration lives outside the codebase; requires infrastructure access to change
 - Any worklist items written very close to the reset time could be cleared before the modality queries them. This is mitigated by choosing a reset time well outside clinic hours
 - Backups accumulate on disk and will need periodic pruning; this is not currently automated

docs/mwl/README.md

@@ -9,8 +9,8 @@ The MWL server is a lightweight, production-ready DICOM worklist solution that:
 - Provides scheduled procedure information via [DICOM C-FIND](https://dicom.nema.org/medical/dicom/current/output/html/part04.html#chapter_C) protocol
 - Stores worklist items in SQLite database
 - Supports filtering by modality, date, and patient ID
-- Resets the worklist on a schedule, backing up the database before clearing it
-- Runs in a separate container alongside the [PACS Server](../pacs/README.md)
+- Resets the worklist daily via a scheduled `reset_main.py` script invoked by Windows Task Scheduler
+- Runs as a Python process on a Windows VM managed by Azure Arc
 
 ## Architecture
 
@@ -26,12 +26,12 @@ The MWL server is a lightweight, production-ready DICOM worklist solution that:
 │  │   Handler    │      │   Layer      │      │ Database │   │                  │
 │  └──────────────┘      └──────────────┘      └──────────┘   │                  │
 │         │                      ▲                            │                  │
-│         │                      │                            │        backup + clear (cron)
-│         └──────────────────────┘                            │                  │
+│         │                      │                            │        backup + clear
+│         └──────────────────────┘                            │      (Task Scheduler)
 │         Query & Response                                    │                  │
 └─────────────────────────────────────────────────────────────┘                  │
-           ▲                          ▲                                   ┌──────┴─────────┐
-           │                          │                                   │ Reset Scheduler│
+           ▲                         ▲                                    ┌───────┴────────┐
+           │                         │                                    │  reset_main.py │
     ┌──────┴──────┐           ┌───────┴────────┐                          └────────────────┘
     │  Modality   │           │ Relay Listener │
     │  (SCU)      │           │ (Populates DB) │
@@ -45,27 +45,25 @@ The MWL server is a lightweight, production-ready DICOM worklist solution that:
 3. **Filtering**: MWL server filters by modality, date, patient ID, status
 4. **Response**: Server returns matching worklist items to modality
 5. **Status Updates**: C-STORE receipt transitions items from `SCHEDULED` to `IN PROGRESS`; [MPPS](https://dicom.nema.org/medical/dicom/current/output/html/part04.html#chapter_F) transitions items to `COMPLETED` or `DISCONTINUED`
-6. **Reset**: Reset scheduler backs up and clears the database on a configurable schedule
+6. **Daily Reset**: Windows Task Scheduler invokes `reset_main.py`, which backs up and clears the database
 
 ## Running the MWL Server
 
-The MWL server runs in a separate container:
+The gateway runs as a Python process on a Windows VM:
 
 ```bash
-# Start all services
-docker compose up -d
+# Start the MWL server
+uv run python -m mwl_main
 
-# Start only the MWL server and reset scheduler
-docker compose up -d mwl reset
-
-# View MWL server logs
-docker compose logs -f mwl
+# Run a one-shot backup and reset (normally invoked by Task Scheduler)
+uv run python -m reset_main
+```
 
-# View reset scheduler logs
-docker compose logs -f reset
+For local development, Docker Compose is available:
 
-# Stop all services
-docker compose down
+```bash
+docker compose up -d mwl
+docker compose logs -f mwl
 ```
 
 ## Configuration
@@ -79,22 +77,25 @@ docker compose down
 | `MWL_DB_PATH` | `/var/lib/pacs/worklist.db` | SQLite database path |
 | `LOG_LEVEL` | `INFO` | Logging level |
 
-### Reset scheduler
+### Reset script (`reset_main.py`)
 
 | Variable | Default | Description |
 |----------|---------|-------------|
 | `MWL_DB_PATH` | `/var/lib/pacs/worklist.db` | SQLite database path |
 | `BACKUP_PATH` | `/var/lib/pacs/backups` | Directory for database backups |
-| `MWL_RESET_SCHEDULE` | `0 2 * * *` | Cron expression for reset schedule (UTC) |
 | `LOG_LEVEL` | `INFO` | Logging level |
 
-The `MWL_RESET_SCHEDULE` value is a standard cron expression. Examples:
+The reset schedule is configured in Windows Task Scheduler (registered via `scripts/bat/schtasks.bat`), not in the application.
+
+## Scheduling the daily reset (Windows)
+
+Register the scheduled task (run once, on the gateway VM):
+
+```bat
+scripts\bat\schtasks.bat
+```
 
-| Expression | Schedule |
-|------------|----------|
-| `0 2 * * *` | Daily at 02:00 UTC (default) |
-| `0 2 * * 1` | Every Monday at 02:00 UTC |
-| `0 2 1 * *` | First day of each month at 02:00 UTC |
+This creates a Task Scheduler task that runs `reset_main.py` daily at midnight. The schedule can be adjusted in Task Scheduler or via Azure Arc without any code change.
 
 ## Example query
 
@@ -131,14 +132,14 @@ assoc.release()
 Check worklist items:
 
 ```bash
-docker compose exec gateway sqlite3 /var/lib/pacs/worklist.db \
+sqlite3 /var/lib/pacs/worklist.db \
   "SELECT accession_number, patient_name, scheduled_date, status FROM worklist_items;"
 ```
 
 Add test worklist item:
 
 ```bash
-docker compose exec gateway sqlite3 /var/lib/pacs/worklist.db <<EOF
+sqlite3 /var/lib/pacs/worklist.db <<EOF
 INSERT INTO worklist_items (
     accession_number, patient_id, patient_name, patient_birth_date,
     scheduled_date, scheduled_time, modality, study_description
@@ -158,29 +159,12 @@ uv run pytest tests/integration/test_c_find_returns_worklist_items.py -v
 uv run pytest tests/integration/test_request_cfind_on_worklist.py -v
 ```
 
-## Multi-container architecture
-
-The MWL-related services run in separate containers. See [ADR-003: Separate containers for PACS and MWL](../adr/ADR-003_Separate_containers_for_PACS_and_MWL.md) and [ADR-004: Daily backup and reset of the MWL database](../adr/ADR-004_MWL_Daily_Backup_And_Reset.md) for the architectural decisions.
-
-**Docker Compose services:**
-
-```yaml
-services:
-  mwl:
-    container_name: mwl-server
-    command: ["uv", "run", "python", "-m", "mwl_main"]
-    ports:
-      - "4243:4243"
-
-  reset:
-    container_name: mwl-reset
-    command: ["uv", "run", "python", "-m", "reset_main"]
-```
-
-**Worklist item status transitions:**
+## Worklist item status transitions
 
 ```
 SCHEDULED ──(first C-STORE)──▶ IN PROGRESS ──(MPPS N-SET)──▶ COMPLETED
                                      │
                                      └────────(MPPS N-SET)──▶ DISCONTINUED
 ```
+
+See [ADR-003: Separate containers for PACS and MWL](../adr/ADR-003_Separate_containers_for_PACS_and_MWL.md) and [ADR-004: Daily backup and reset of the MWL database](../adr/ADR-004_MWL_Daily_Backup_And_Reset.md) for architectural decisions.

pyproject.toml

@@ -16,7 +16,6 @@ dependencies = [
   "requests>=2.32.0",
   "python-dotenv>=1.2.1",
   "azure-monitor-opentelemetry>=1.8.6",
-  "croniter>=6.2.2",
 ]
 
 [dependency-groups]

scripts/bat/backup_database.bat

@@ -1,4 +1,4 @@
-:: Batch file to run the backup_database.py script
+:: Backs up and resets the MWL worklist database. Intended to be run via Windows Task Scheduler.
 @echo off
-set %rootdir=%1
-python "%rootdir%\scripts\python\backup_database.py"
+set rootdir=%~1
+"%rootdir%\.venv\Scripts\python.exe" -m reset_main

src/reset_main.py

@@ -1,11 +1,11 @@
-"""Entry point for MWL daily backup and reset scheduler."""
+"""MWL backup and reset script. Intended to be invoked by Windows Task Scheduler (or equivalent)."""
 
 import logging
 import os
+import sys
 
 from dotenv import load_dotenv
 
-from services.mwl.reset import MWLResetScheduler
 from services.storage import MWLStorage
 from telemetry import configure_telemetry
 
@@ -15,29 +15,35 @@
 
 def main():
     """
-    Main entry point for MWL reset scheduler.
+    Backs up and clears the MWL database. Exits with code 1 if the clear fails.
 
     Environment variables:
-    MWL_DB_PATH:        Path to the MWL SQLite database (default: /var/lib/pacs/worklist.db)
-    BACKUP_PATH:        Directory for database backups (default: /var/lib/pacs/backups)
-    MWL_RESET_SCHEDULE: Cron expression for reset schedule in UTC (default: 0 2 * * * — daily at 02:00)
+    MWL_DB_PATH:  Path to the MWL SQLite database (default: /var/lib/pacs/worklist.db)
+    BACKUP_PATH:  Directory for database backups (default: /var/lib/pacs/backups)
     """
     logging.basicConfig(
         level=os.getenv("LOG_LEVEL", "INFO").upper(),
         format=os.getenv("LOG_FORMAT", "%(asctime)s - %(name)s - %(levelname)s - %(message)s"),
     )
+    logger = logging.getLogger(__name__)
 
     mwl_db_path = os.getenv("MWL_DB_PATH", "/var/lib/pacs/worklist.db")
     backup_path = os.getenv("BACKUP_PATH", "/var/lib/pacs/backups")
-    reset_schedule = os.getenv("MWL_RESET_SCHEDULE", "0 2 * * *")
 
     mwl_storage = MWLStorage(mwl_db_path)
-    scheduler = MWLResetScheduler(mwl_storage, backup_path, reset_schedule)
 
     try:
-        scheduler.run()
-    except KeyboardInterrupt:
-        logging.info("Received shutdown signal")
+        path = mwl_storage.backup(backup_path)
+        logger.info(f"Backup complete: {path}")
+    except Exception as e:
+        logger.error(f"MWL backup failed: {e}", exc_info=True)
+
+    try:
+        count = mwl_storage.clear()
+        logger.info(f"MWL reset complete: {count} items deleted")
+    except Exception as e:
+        logger.error(f"MWL clear failed: {e}", exc_info=True)
+        sys.exit(1)
 
 
 if __name__ == "__main__":