Fix schedule reload: scheduler now syncs from DB directly (v2.6.63)

Schedule create/update/delete dispatched reload_schedules_task via Celery,
but prefork workers execute tasks in pool children while APScheduler runs
only in the scheduler-lock-holding main process. The reload always landed
in a child and was skipped, so schedule changes never reached the running
scheduler without a container restart.

The scheduler process now re-syncs its jobs from the database every 60
seconds, gated on a fingerprint of schedule definitions so jobs are only
rebuilt on actual change. next_run is computed at schedule creation so the
UI shows the upcoming fire before the first run.

Author: ttlequals0

CHANGELOG.MD

@@ -5,6 +5,12 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0).
 
+## [2.6.63] - 2026-07-09
+
+### Fixed
+
+- **Created or edited schedules now take effect within a minute instead of requiring a container restart.** Schedule CRUD dispatched `reload_schedules_task` through Celery, but prefork workers execute tasks in pool children while APScheduler runs only in the scheduler-lock-holding main process - the reload always landed in a child, logged "Scheduler not running in this worker", and was skipped, so no schedule change since the mechanism was added ever reached the running scheduler without a restart (verified live: a freshly created `file_changes` schedule never fired at its cron time). The scheduler process now re-syncs its jobs directly from the database every 60 seconds, gated on a fingerprint of the schedule definitions so jobs are only rebuilt when something actually changed. New schedules also get `next_run` computed at creation so the UI shows the upcoming fire immediately instead of after the first run.
+
 ## [2.6.62] - 2026-07-09
 
 ### Added

pixelprobe/api/admin_routes.py

@@ -382,6 +382,13 @@ def create_schedule():
             is_active=True,
             created_at=datetime.now(timezone.utc)
         )
+        # Populate next_run immediately so the UI shows it before the first
+        # fire (the scheduler's db-sync job registers the actual APScheduler
+        # job within a minute)
+        try:
+            schedule.next_run = calculate_next_run(schedule.cron_expression)
+        except Exception as e:
+            logger.warning(f"Could not calculate next_run for new schedule: {e}")
         db.session.add(schedule)
         db.session.commit()
 

pixelprobe/scheduler.py

@@ -62,6 +62,9 @@ def __init__(self, app=None):
 
         self.pending_retries: Dict[str, int] = {}
         self._retry_lock = threading.Lock()
+        # Snapshot of saved-schedule definitions; the db-sync job reloads jobs
+        # only when this changes (see _sync_schedules_from_db)
+        self._schedules_fp = None
         self.retry_delay_minutes = self._load_positive_int_env(
             'SCHEDULE_RETRY_DELAY_MINUTES', self.DEFAULT_RETRY_DELAY_MINUTES, min_value=1
         )
@@ -277,10 +280,31 @@ def init_app(self, app):
             misfire_grace_time=60
         )
         logger.info("Scheduled stuck scan detection to run every 5 minutes")
-        
+
+        # Re-sync saved schedules from the database every 60 seconds.
+        # Schedule create/update/delete happens in gunicorn workers, but
+        # APScheduler runs only in the process holding the scheduler lock; the
+        # Celery reload task always executes in a prefork pool child and can
+        # never reach it, so changes only took effect after a restart. The id
+        # must not start with 'schedule_' or update_schedules would remove it.
+        self.scheduler.add_job(
+            func=self._sync_schedules_from_db,
+            trigger="interval",
+            seconds=60,
+            id="db_schedule_sync",
+            name="Sync saved schedules from database",
+            misfire_grace_time=30,
+            coalesce=True
+        )
+        logger.info("Scheduled database schedule sync every 60 seconds")
+
         # Load saved schedules from database
         with app.app_context():
             self._load_saved_schedules()
+            try:
+                self._schedules_fp = self._schedule_fingerprint()
+            except Exception as e:
+                logger.warning(f"Could not compute initial schedule fingerprint: {e}")
 
     def _load_exclusions(self):
         """Load path and extension exclusions from environment variables"""
@@ -743,6 +767,38 @@ def update_schedules(self):
         # Reload from database
         with self.app.app_context():
             self._load_saved_schedules()
+            self._schedules_fp = self._schedule_fingerprint()
+
+    def _schedule_fingerprint(self):
+        """Snapshot of every field that affects job registration.
+
+        Must be called inside an app context.
+        """
+        return tuple(db.session.query(
+            ScanSchedule.id, ScanSchedule.name, ScanSchedule.cron_expression,
+            ScanSchedule.scan_type, ScanSchedule.scan_paths,
+            ScanSchedule.force_rescan, ScanSchedule.time_budget_minutes,
+            ScanSchedule.is_active
+        ).order_by(ScanSchedule.id).all())
+
+    def _sync_schedules_from_db(self):
+        """Reload saved schedules when their definitions change in the database.
+
+        Schedule CRUD runs in gunicorn workers; APScheduler runs only in the
+        process holding the scheduler lock. The Celery reload task executes in
+        a prefork pool child where the scheduler is never running, so it was
+        always skipped and new/edited schedules never registered until a
+        restart. Polling a fingerprint keeps the job store in sync without
+        cross-process messaging, and only churns jobs when something changed.
+        """
+        try:
+            with self.app.app_context():
+                fingerprint = self._schedule_fingerprint()
+            if fingerprint != self._schedules_fp:
+                logger.info("Schedule definitions changed in database; reloading scheduler jobs")
+                self.update_schedules()
+        except Exception as e:
+            logger.error(f"Schedule database sync failed: {e}")
 
     def _check_stuck_scans(self):
         """Check for stuck scans and mark them as crashed"""

pixelprobe/version.py

@@ -4,7 +4,7 @@
 # Default version - this is the single source of truth
 
 
-_DEFAULT_VERSION = '2.6.62'
+_DEFAULT_VERSION = '2.6.63'
 
 
 # Allow override via environment variable for CI/CD, but default to the hardcoded version

tests/test_scheduler.py

@@ -1,4 +1,5 @@
 from datetime import datetime, timedelta, timezone
+from unittest.mock import patch
 
 import pytest
 
@@ -225,6 +226,63 @@ def test_update_schedules_removes_and_reloads(self, scheduler, app, db):
             # at least verify the method runs without error
 
 
+class TestScheduleDbSync:
+    """The db-sync job is how schedule CRUD reaches the scheduler process.
+
+    The Celery reload task always executes in a prefork pool child where the
+    scheduler is not running, so it is skipped; without the sync job a created
+    or edited schedule only registered after a container restart.
+    """
+
+    @pytest.fixture
+    def scheduler(self, app, db):
+        scheduler = MediaScheduler()
+        scheduler.init_app(app)
+        yield scheduler
+        scheduler.shutdown()
+
+    def test_sync_job_registered(self, scheduler):
+        job = scheduler.scheduler.get_job('db_schedule_sync')
+        assert job is not None
+        # update_schedules removes every job whose id starts with 'schedule_';
+        # the sync job must never match that prefix or it would delete itself
+        assert not job.id.startswith('schedule_')
+
+    def test_sync_reloads_when_definitions_change(self, scheduler, app, db):
+        with app.app_context():
+            schedule = ScanSchedule(name='Sync Test', cron_expression='0 2 * * *',
+                                    scan_type='file_changes', time_budget_minutes=10,
+                                    is_active=True)
+            db.session.add(schedule)
+            db.session.commit()
+
+        with patch.object(scheduler, 'update_schedules') as update:
+            scheduler._sync_schedules_from_db()
+        update.assert_called_once()
+
+    def test_sync_skips_when_unchanged(self, scheduler, app, db):
+        with app.app_context():
+            scheduler._schedules_fp = scheduler._schedule_fingerprint()
+        with patch.object(scheduler, 'update_schedules') as update:
+            scheduler._sync_schedules_from_db()
+        update.assert_not_called()
+
+    def test_budget_change_triggers_reload(self, scheduler, app, db):
+        with app.app_context():
+            schedule = ScanSchedule(name='Budget Sync', cron_expression='0 2 * * *',
+                                    scan_type='file_changes', time_budget_minutes=10,
+                                    is_active=True)
+            db.session.add(schedule)
+            db.session.commit()
+            scheduler._schedules_fp = scheduler._schedule_fingerprint()
+            schedule.time_budget_minutes = 30
+            db.session.commit()
+
+        with patch.object(scheduler, 'update_schedules') as update:
+            scheduler._sync_schedules_from_db()
+        update.assert_called_once()
+
+
 class TestQueueConflictRetry:
     """Test that skipped scheduled scans get a one-shot retry queued."""