Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
feat: replace scheduled image polling with Docker event-driven update checks (#3290)
Kyle Mendell91d0669df7b2
diff --git a/backend/internal/bootstrap/jobs_bootstrap.go b/backend/internal/bootstrap/jobs_bootstrap.goindex 1ca1c7cec..88b309111 100644--- a/backend/internal/bootstrap/jobs_bootstrap.go+++ b/backend/internal/bootstrap/jobs_bootstrap.go@@ -9,10 +9,10 @@ import ("github.com/getarcaneapp/arcane/backend/v2/internal/config""github.com/getarcaneapp/arcane/backend/v2/internal/di""github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane"- pkg_scheduler "github.com/getarcaneapp/arcane/backend/v2/pkg/scheduler"+ "github.com/getarcaneapp/arcane/backend/v2/pkg/scheduler")-func registerJobs(appCtx context.Context, newScheduler *pkg_scheduler.JobScheduler, appServices *di.Services, appConfig *config.Config) {+func registerJobs(appCtx context.Context, newScheduler *scheduler.JobScheduler, appServices *di.Services, appConfig *config.Config) {// wire constructs every job from the built services; bootstrap owns registration,// the agent-mode gating, the startup heartbeat, and the settings callbacks.jobs := di.InitializeJobs(appCtx, appConfig, appServices)@@ -41,7 +41,7 @@ func registerJobs(appCtx context.Context, newScheduler *pkg_scheduler.JobSchedul}newScheduler.RegisterJob(jobs.AutoUpdate)- newScheduler.RegisterJob(jobs.ImagePolling)+ newScheduler.RegisterBusWatcher(jobs.ImageUpdateWatcher, true)newScheduler.RegisterJob(jobs.DockerClientRefresh)newScheduler.RegisterJob(jobs.Analytics)// Send initial heartbeat on startup without blocking bootstrap.@@ -65,7 +65,7 @@ func registerJobs(appCtx context.Context, newScheduler *pkg_scheduler.JobSchedul// registerDynamicJobs injects the scheduler into the services that own per-entity// jobs and registers the jobs for already-existing entities at startup. AddJob is// an idempotent upsert, so these run safely before the scheduler is started.-func registerDynamicJobs(appCtx context.Context, newScheduler *pkg_scheduler.JobScheduler, appServices *di.Services, appConfig *config.Config) {+func registerDynamicJobs(appCtx context.Context, newScheduler *scheduler.JobScheduler, appServices *di.Services, appConfig *config.Config) {// GitOps: one job per auto-sync-enabled sync (runs on manager and agents).if appServices.GitOpsSync != nil {appServices.GitOpsSync.SetScheduler(appCtx, newScheduler)@@ -87,10 +87,10 @@ func registerDynamicJobs(appCtx context.Context, newScheduler *pkg_scheduler.Job}}-func setupSettingsCallbacks(lifecycleCtx context.Context, appServices *di.Services, appConfig *config.Config, newScheduler *pkg_scheduler.JobScheduler, jobs *di.Jobs) {+func setupSettingsCallbacks(lifecycleCtx context.Context, appServices *di.Services, appConfig *config.Config, newScheduler *scheduler.JobScheduler, jobs *di.Jobs) {appServices.Settings.OnImagePollingSettingsChanged = func(_ context.Context) {- if err := newScheduler.RescheduleJob(lifecycleCtx, jobs.ImagePolling); err != nil {- slog.WarnContext(lifecycleCtx, "Failed to reschedule image-polling job", "error", err)+ if jobs.ImageUpdateWatcher != nil {+ jobs.ImageUpdateWatcher.Trigger()}if err := newScheduler.RescheduleJob(lifecycleCtx, jobs.AutoUpdate); err != nil {slog.WarnContext(lifecycleCtx, "Failed to reschedule auto-update job", "error", err)diff --git a/backend/internal/di/providers.go b/backend/internal/di/providers.goindex 44ec350d1..9a214da0f 100644--- a/backend/internal/di/providers.go+++ b/backend/internal/di/providers.go@@ -14,7 +14,7 @@ import ("github.com/getarcaneapp/arcane/backend/v2/internal/database""github.com/getarcaneapp/arcane/backend/v2/internal/middleware""github.com/getarcaneapp/arcane/backend/v2/internal/services"- pkg_scheduler "github.com/getarcaneapp/arcane/backend/v2/pkg/scheduler"+ "github.com/getarcaneapp/arcane/backend/v2/pkg/scheduler""github.com/getarcaneapp/arcane/backend/v2/resources")@@ -157,30 +157,30 @@ func provideAuthMiddlewareInternal(auth *services.AuthService, apiKey *services.// bootstrap then registers the constructed jobs with the scheduler and wires the// settings-change callbacks — those are post-construction concerns wire does not handle.type Jobs struct {- AutoUpdate *pkg_scheduler.AutoUpdateJob- ImagePolling *pkg_scheduler.ImagePollingJob- DockerClientRefresh *pkg_scheduler.DockerClientRefreshJob- Analytics *pkg_scheduler.AnalyticsJob- EventCleanup *pkg_scheduler.EventCleanupJob- PruningVolumeHelper *pkg_scheduler.PruningVolumeHelperJob- ExpiredSessionsCleanup *pkg_scheduler.ExpiredSessionsCleanupJob- ScheduledPrune *pkg_scheduler.ScheduledPruneJob- FilesystemWatcher *pkg_scheduler.FilesystemWatcherJob- VulnerabilityScan *pkg_scheduler.VulnerabilityScanJob- AutoHeal *pkg_scheduler.AutoHealJob+ AutoUpdate *scheduler.AutoUpdateJob+ ImageUpdateWatcher *scheduler.ImageUpdateWatcher+ DockerClientRefresh *scheduler.DockerClientRefreshJob+ Analytics *scheduler.AnalyticsJob+ EventCleanup *scheduler.EventCleanupJob+ PruningVolumeHelper *scheduler.PruningVolumeHelperJob+ ExpiredSessionsCleanup *scheduler.ExpiredSessionsCleanupJob+ ScheduledPrune *scheduler.ScheduledPruneJob+ FilesystemWatcher *scheduler.FilesystemWatcherJob+ VulnerabilityScan *scheduler.VulnerabilityScanJob+ AutoHeal *scheduler.AutoHealJob}// provideAnalyticsJobInternal preserves the existing nil http.Client (the analytics job// builds its own default client when none is supplied).-func provideAnalyticsJobInternal(settings *services.SettingsService, kv *services.KVService, cfg *config.Config) *pkg_scheduler.AnalyticsJob {- return pkg_scheduler.NewAnalyticsJob(settings, kv, nil, cfg)+func provideAnalyticsJobInternal(settings *services.SettingsService, kv *services.KVService, cfg *config.Config) *scheduler.AnalyticsJob {+ return scheduler.NewAnalyticsJob(settings, kv, nil, cfg)}// provideFilesystemWatcherJobInternal supplies ctx + cfg.ProjectScanMaxDepth and keeps the// watcher-setup failure non-fatal (logged; a nil job is tolerated downstream), matching// the previous bootstrap behavior.-func provideFilesystemWatcherJobInternal(ctx context.Context, project *services.ProjectService, template *services.TemplateService, settings *services.SettingsService, cfg *config.Config) *pkg_scheduler.FilesystemWatcherJob {- job, err := pkg_scheduler.RegisterFilesystemWatcherJob(ctx, project, template, settings, cfg.ProjectScanMaxDepth)+func provideFilesystemWatcherJobInternal(ctx context.Context, project *services.ProjectService, template *services.TemplateService, settings *services.SettingsService, cfg *config.Config) *scheduler.FilesystemWatcherJob {+ job, err := scheduler.RegisterFilesystemWatcherJob(ctx, project, template, settings, cfg.ProjectScanMaxDepth)if err != nil {slog.ErrorContext(ctx, "Failed to register filesystem watcher job", "error", err)}diff --git a/backend/internal/di/wire.go b/backend/internal/di/wire.goindex ef68687a1..b7f800d9d 100644--- a/backend/internal/di/wire.go+++ b/backend/internal/di/wire.go@@ -15,7 +15,7 @@ import ("github.com/getarcaneapp/arcane/backend/v2/internal/config""github.com/getarcaneapp/arcane/backend/v2/internal/database""github.com/getarcaneapp/arcane/backend/v2/internal/services"- pkg_scheduler "github.com/getarcaneapp/arcane/backend/v2/pkg/scheduler"+ "github.com/getarcaneapp/arcane/backend/v2/pkg/scheduler")// ServiceSet is the single, central provider set for the whole backend. Every@@ -94,17 +94,17 @@ var JobSet = wire.NewSet("Event", "Activity", "Session", "System", "Notification", "Project","Template", "Vulnerability", "Volume",),- pkg_scheduler.NewAutoUpdateJob,- pkg_scheduler.NewImagePollingJob,- pkg_scheduler.NewDockerClientRefreshJob,+ scheduler.NewAutoUpdateJob,+ scheduler.NewImageUpdateWatcher,+ scheduler.NewDockerClientRefreshJob,provideAnalyticsJobInternal,- pkg_scheduler.NewEventCleanupJob,- pkg_scheduler.NewPruningVolumeHelperJob,- pkg_scheduler.NewExpiredSessionsCleanupJob,- pkg_scheduler.NewScheduledPruneJob,+ scheduler.NewEventCleanupJob,+ scheduler.NewPruningVolumeHelperJob,+ scheduler.NewExpiredSessionsCleanupJob,+ scheduler.NewScheduledPruneJob,provideFilesystemWatcherJobInternal,- pkg_scheduler.NewVulnerabilityScanJob,- pkg_scheduler.NewAutoHealJob,+ scheduler.NewVulnerabilityScanJob,+ scheduler.NewAutoHealJob,wire.Struct(new(Jobs), "*"),)diff --git a/backend/internal/di/wire_gen.go b/backend/internal/di/wire_gen.goindex 28fa881de..55ef195c7 100644--- a/backend/internal/di/wire_gen.go+++ b/backend/internal/di/wire_gen.go@@ -123,8 +123,8 @@ func InitializeJobs(ctx context.Context, cfg *config.Config, svcs *Services) *JoautoUpdateJob := scheduler.NewAutoUpdateJob(updaterService, settingsService)imageUpdateService := svcs.ImageUpdateenvironmentService := svcs.Environment- imagePollingJob := scheduler.NewImagePollingJob(imageUpdateService, settingsService, environmentService)dockerClientService := svcs.Docker+ imageUpdateWatcher := scheduler.NewImageUpdateWatcher(imageUpdateService, settingsService, environmentService, dockerClientService)dockerClientRefreshJob := scheduler.NewDockerClientRefreshJob(dockerClientService, settingsService)kvService := svcs.KVanalyticsJob := provideAnalyticsJobInternal(settingsService, kvService, cfg)@@ -146,7 +146,7 @@ func InitializeJobs(ctx context.Context, cfg *config.Config, svcs *Services) *JoautoHealJob := scheduler.NewAutoHealJob(dockerClientService, settingsService, eventService, notificationService)jobs := &Jobs{AutoUpdate: autoUpdateJob,- ImagePolling: imagePollingJob,+ ImageUpdateWatcher: imageUpdateWatcher,DockerClientRefresh: dockerClientRefreshJob,Analytics: analyticsJob,EventCleanup: eventCleanupJob,@@ -187,5 +187,5 @@ var JobSet = wire.NewSet(wire.FieldsOf(new(*Services),"Updater", "Settings", "ImageUpdate", "Environment", "Docker", "KV","Event", "Activity", "Session", "System", "Notification", "Project","Template", "Vulnerability", "Volume",-), scheduler.NewAutoUpdateJob, scheduler.NewImagePollingJob, scheduler.NewDockerClientRefreshJob, provideAnalyticsJobInternal, scheduler.NewEventCleanupJob, scheduler.NewPruningVolumeHelperJob, scheduler.NewExpiredSessionsCleanupJob, scheduler.NewScheduledPruneJob, provideFilesystemWatcherJobInternal, scheduler.NewVulnerabilityScanJob, scheduler.NewAutoHealJob, wire.Struct(new(Jobs), "*"),+), scheduler.NewAutoUpdateJob, scheduler.NewImageUpdateWatcher, scheduler.NewDockerClientRefreshJob, provideAnalyticsJobInternal, scheduler.NewEventCleanupJob, scheduler.NewPruningVolumeHelperJob, scheduler.NewExpiredSessionsCleanupJob, scheduler.NewScheduledPruneJob, provideFilesystemWatcherJobInternal, scheduler.NewVulnerabilityScanJob, scheduler.NewAutoHealJob, wire.Struct(new(Jobs), "*"),)diff --git a/backend/internal/services/docker_client_service.go b/backend/internal/services/docker_client_service.goindex 6c9acb1e9..c8bae0e8a 100644--- a/backend/internal/services/docker_client_service.go+++ b/backend/internal/services/docker_client_service.go@@ -31,6 +31,7 @@ import (const dockerClientNegotiationTimeout = 5 * time.Secondconst dockerListCacheTTL = 0+const dockerImageStateResyncActionInternal events.Action = "arcane-resync"type DockerClientService struct {db *database.DB@@ -329,6 +330,7 @@ func (s *DockerClientService) WatchEvents(ctx context.Context) {s.invalidateListCachesInternal()eventBackoff.Reset()result := dockerClient.Events(ctx, client.EventsListOptions{})+ s.publishImageStateResyncInternal()err = s.consumeEventsInternal(ctx, result.Messages, result.Err)if err != nil && !errors.Is(err, context.Canceled) && !errors.Is(err, io.EOF) {slog.WarnContext(ctx, "Docker event stream stopped", "error", err)@@ -339,6 +341,13 @@ func (s *DockerClientService) WatchEvents(ctx context.Context) {}}+func (s *DockerClientService) publishImageStateResyncInternal() {+ s.EventBus().Publish(events.Message{+ Type: events.ImageEventType,+ Action: dockerImageStateResyncActionInternal,+ })+}+func (s *DockerClientService) consumeEventsInternal(ctx context.Context, messages <-chan events.Message, errs <-chan error) error {for {select {diff --git a/backend/internal/services/docker_client_service_test.go b/backend/internal/services/docker_client_service_test.goindex 0e22a3811..c7b6cf32f 100644--- a/backend/internal/services/docker_client_service_test.go+++ b/backend/internal/services/docker_client_service_test.go@@ -12,6 +12,7 @@ import ("github.com/getarcaneapp/arcane/backend/v2/internal/config""github.com/moby/moby/api/types/container"+ "github.com/moby/moby/api/types/events""github.com/moby/moby/api/types/image""github.com/moby/moby/client""github.com/stretchr/testify/assert"@@ -168,6 +169,42 @@ func TestDockerClientService_RefreshClientProbeFailureKeepsCachedClient(t *testiassert.False(t, svc.clientLastProbe.IsZero())}+func TestDockerClientService_PublishImageStateResyncNotifiesSubscribersAndInvalidatesCache(t *testing.T) {+ ctx, cancel := context.WithCancel(context.Background())+ t.Cleanup(cancel)+ svc := NewDockerClientService(ctx, nil, &config.Config{}, nil)+ t.Cleanup(svc.Close)++ eventCh, unsubscribe := svc.EventBus().Subscribe(events.ImageEventType)+ t.Cleanup(unsubscribe)++ fetches := 0+ _, err := svc.imageCache.GetOrFetch(ctx, func(context.Context) ([]image.Summary, error) {+ fetches+++ return []image.Summary{{ID: "sha256:first"}}, nil+ })+ require.NoError(t, err)+ require.Equal(t, 1, fetches)++ svc.publishImageStateResyncInternal()++ select {+ case message := <-eventCh:+ require.Equal(t, events.ImageEventType, message.Type)+ require.Equal(t, dockerImageStateResyncActionInternal, message.Action)+ case <-time.After(time.Second):+ t.Fatal("timed out waiting for image state resync event")+ }++ require.Eventually(t, func() bool {+ _, fetchErr := svc.imageCache.GetOrFetch(ctx, func(context.Context) ([]image.Summary, error) {+ fetches+++ return []image.Summary{{ID: "sha256:second"}}, nil+ })+ return fetchErr == nil && fetches == 2+ }, time.Second, 5*time.Millisecond)+}+func TestCountImageUsage_UsesContainerImageIDs(t *testing.T) {images := []image.Summary{{ID: "sha256:image-a", Containers: -1},diff --git a/backend/internal/services/job_service.go b/backend/internal/services/job_service.goindex a332ff79c..fda4ddbd7 100644--- a/backend/internal/services/job_service.go+++ b/backend/internal/services/job_service.go@@ -22,6 +22,7 @@ type JobRunner interface {GetJob(jobID string) (schedulertypes.Job, bool)GetJobRuntimeState(jobID string) (schedulertypes.JobRuntimeState, bool)RescheduleJob(ctx context.Context, job schedulertypes.Job) error+ RunBusWatcherNow(ctx context.Context, watcherID string) error}// JobService manages configuration for background job schedules.@@ -323,6 +324,13 @@ func (s *JobService) RunJobNowInline(ctx context.Context, jobID string) error {if jobID == "environment-health" && s.RunEnvironmentHealthNow != nil {return s.RunEnvironmentHealthNow(context.WithoutCancel(ctx))}+ jobMeta, ok := meta.GetJobMetadata(jobID)+ if ok && jobMeta.IsContinuous && jobMeta.CanRunManually {+ if s == nil || s.scheduler == nil {+ return errors.New("job service or scheduler not initialized")+ }+ return s.scheduler.RunBusWatcherNow(context.WithoutCancel(ctx), jobID)+ }job, err := s.getRunnableJobInternal(jobID)if err != nil {@@ -383,13 +391,12 @@ func (s *JobService) getJobScheduleInternal(ctx context.Context, meta meta.JobMe}func (s *JobService) isJobEnabledInternal(ctx context.Context, meta meta.JobMetadata) bool {- if meta.IsContinuous {- return true- }-if meta.EnabledKey != "" {return s.settings.GetBoolSetting(ctx, meta.EnabledKey, false)}+ if meta.IsContinuous {+ return true+ }return true}diff --git a/backend/internal/services/job_service_test.go b/backend/internal/services/job_service_test.goindex 6f1098497..b279199ec 100644--- a/backend/internal/services/job_service_test.go+++ b/backend/internal/services/job_service_test.go@@ -90,8 +90,8 @@ func TestJobService_ListJobs_UsesRuntimeScheduleAndNextRun(t *testing.T) {require.NoError(t, err)nextRun := time.Date(2026, time.July, 10, 8, 0, 0, 0, time.UTC)- scheduler := newFakeJobSchedulerInternal("image-polling")- scheduler.runtimeStates["image-polling"] = schedulertypes.JobRuntimeState{+ scheduler := newFakeJobSchedulerInternal("auto-update")+ scheduler.runtimeStates["auto-update"] = schedulertypes.JobRuntimeState{Schedule: "0 0 8 * * *",NextRun: &nextRun,Scheduled: true,@@ -102,9 +102,31 @@ func TestJobService_ListJobs_UsesRuntimeScheduleAndNextRun(t *testing.T) {jobs, err := jobSvc.ListJobs(ctx)require.NoError(t, err)- imagePollingJob := findJobStatusByIDInternal(t, jobs.Jobs, "image-polling")- require.Equal(t, "0 0 8 * * *", imagePollingJob.Schedule)- require.Equal(t, nextRun, *imagePollingJob.NextRun)+ autoUpdateJob := findJobStatusByIDInternal(t, jobs.Jobs, "auto-update")+ require.Equal(t, "0 0 8 * * *", autoUpdateJob.Schedule)+ require.Equal(t, nextRun, *autoUpdateJob.NextRun)+}++func TestJobService_ListJobs_ImageUpdateWatcherIsContinuousAndRespectsEnabled(t *testing.T) {+ ctx := context.Background()+ db := setupSettingsTestDB(t)++ settingsSvc, err := NewSettingsService(ctx, db)+ require.NoError(t, err)+ require.NoError(t, settingsSvc.SetBoolSetting(ctx, "pollingEnabled", false))++ jobSvc := NewJobService(db, settingsSvc, &config.Config{})+ jobs, err := jobSvc.ListJobs(ctx)+ require.NoError(t, err)++ watcher := findJobStatusByIDInternal(t, jobs.Jobs, "image-polling")+ require.Equal(t, "Image Update Watcher", watcher.Name)+ require.Equal(t, "continuous", watcher.Schedule)+ require.Empty(t, watcher.SettingsKey)+ require.Nil(t, watcher.NextRun)+ require.True(t, watcher.IsContinuous)+ require.True(t, watcher.CanRunManually)+ require.False(t, watcher.Enabled)}func TestJobService_UpdateJobSchedules_ReschedulesChangedJob(t *testing.T) {@@ -115,15 +137,34 @@ func TestJobService_UpdateJobSchedules_ReschedulesChangedJob(t *testing.T) {require.NoError(t, err)jobSvc := NewJobService(db, settingsSvc, &config.Config{})- scheduler := newFakeJobSchedulerInternal("image-polling", "auto-update")+ scheduler := newFakeJobSchedulerInternal("auto-update")jobSvc.SetScheduler(ctx, scheduler)_, err = jobSvc.UpdateJobSchedules(ctx, jobschedule.Update{- PollingInterval: new("0 */10 * * * *"),+ AutoUpdateInterval: new("0 */10 * * * *"),})require.NoError(t, err)- require.Equal(t, []string{"image-polling"}, scheduler.rescheduled)+ require.Equal(t, []string{"auto-update"}, scheduler.rescheduled)+}++func TestJobService_UpdateJobSchedules_DeprecatedPollingIntervalDoesNotReschedule(t *testing.T) {+ ctx := context.Background()+ db := setupSettingsTestDB(t)++ settingsSvc, err := NewSettingsService(ctx, db)+ require.NoError(t, err)++ jobSvc := NewJobService(db, settingsSvc, &config.Config{})+ scheduler := newFakeJobSchedulerInternal("auto-update")+ jobSvc.SetScheduler(ctx, scheduler)++ updated, err := jobSvc.UpdateJobSchedules(ctx, jobschedule.Update{+ PollingInterval: new("0 */10 * * * *"),+ })+ require.NoError(t, err)+ require.Equal(t, "0 */10 * * * *", updated.PollingInterval)+ require.Empty(t, scheduler.rescheduled)}func TestJobService_UpdateJobSchedules_UsesLifecycleContextForReschedule(t *testing.T) {@@ -138,11 +179,11 @@ func TestJobService_UpdateJobSchedules_UsesLifecycleContextForReschedule(t *testrequestCtx, cancelRequest := context.WithCancel(context.Background())jobSvc := NewJobService(db, settingsSvc, &config.Config{})- scheduler := newFakeJobSchedulerInternal("image-polling")+ scheduler := newFakeJobSchedulerInternal("auto-update")jobSvc.SetScheduler(lifecycleCtx, scheduler)_, err = jobSvc.UpdateJobSchedules(requestCtx, jobschedule.Update{- PollingInterval: new("0 */10 * * * *"),+ AutoUpdateInterval: new("0 */10 * * * *"),})require.NoError(t, err)@@ -163,7 +204,7 @@ func TestJobService_UpdateJobSchedules_RejectsInvalidCronWithoutChangingSetting(require.NoError(t, settingsSvc.LoadDatabaseSettings(ctx))jobSvc := NewJobService(db, settingsSvc, &config.Config{})- scheduler := newFakeJobSchedulerInternal("image-polling")+ scheduler := newFakeJobSchedulerInternal()jobSvc.SetScheduler(ctx, scheduler)_, err = jobSvc.UpdateJobSchedules(ctx, jobschedule.Update{@@ -199,19 +240,19 @@ func TestJobService_UpdateJobSchedules_RestoresPreviousScheduleWhenRescheduleFairequire.NoError(t, settingsSvc.LoadDatabaseSettings(ctx))jobSvc := NewJobService(db, settingsSvc, &config.Config{})- scheduler := newFakeJobSchedulerInternal("image-polling")+ scheduler := newFakeJobSchedulerInternal("auto-update")scheduler.rescheduleErr = errors.New("scheduler unavailable")jobSvc.SetScheduler(ctx, scheduler)_, err = jobSvc.UpdateJobSchedules(ctx, jobschedule.Update{- PollingInterval: new("0 0 8 * * *"),+ AutoUpdateInterval: new("0 0 8 * * *"),})require.ErrorContains(t, err, "scheduler unavailable")- require.Equal(t, "0 0 * * * *", settingsSvc.GetStringSetting(ctx, "pollingInterval", ""))+ require.Equal(t, "0 0 0 * * *", settingsSvc.GetStringSetting(ctx, "autoUpdateInterval", ""))var persisted models.SettingVariable- require.NoError(t, db.WithContext(ctx).First(&persisted, "key = ?", "pollingInterval").Error)- require.Equal(t, "0 0 * * * *", persisted.Value)+ require.NoError(t, db.WithContext(ctx).First(&persisted, "key = ?", "autoUpdateInterval").Error)+ require.Equal(t, "0 0 0 * * *", persisted.Value)}func TestJobService_UpdateJobSchedules_SkipsManagerOnlyJobsInAgentMode(t *testing.T) {@@ -257,6 +298,19 @@ func TestJobService_UpdateJobSchedules_DelegatesEnvironmentHealthReschedule(t *trequire.Empty(t, scheduler.rescheduled)}+func TestJobService_RunJobNowInline_DelegatesImageUpdateWatcherWithDetachedContext(t *testing.T) {+ ctx, cancel := context.WithCancel(context.Background())+ cancel()++ scheduler := newFakeJobSchedulerInternal()+ jobSvc := &JobService{scheduler: scheduler}++ require.NoError(t, jobSvc.RunJobNowInline(ctx, "image-polling"))+ require.Equal(t, []string{"image-polling"}, scheduler.busWatcherRuns)+ require.Len(t, scheduler.busWatcherContexts, 1)+ require.NoError(t, scheduler.busWatcherContexts[0].Err())+}+func findJobStatusByIDInternal(t *testing.T, jobs []jobschedule.JobStatus, id string) jobschedule.JobStatus {t.Helper()@@ -276,6 +330,8 @@ type fakeJobSchedulerInternal struct {rescheduled []stringrescheduleContexts []context.ContextrescheduleErr error+ busWatcherRuns []string+ busWatcherContexts []context.Context}func newFakeJobSchedulerInternal(jobIDs ...string) *fakeJobSchedulerInternal {@@ -314,6 +370,12 @@ func (s *fakeJobSchedulerInternal) RescheduleJob(ctx context.Context, job schedureturn nil}+func (s *fakeJobSchedulerInternal) RunBusWatcherNow(ctx context.Context, watcherID string) error {+ s.busWatcherRuns = append(s.busWatcherRuns, watcherID)+ s.busWatcherContexts = append(s.busWatcherContexts, ctx)+ return nil+}+type fakeJobInternal struct {name string}diff --git a/backend/internal/services/settings_service.go b/backend/internal/services/settings_service.goindex 8dabfd6a1..b9ff2b381 100644--- a/backend/internal/services/settings_service.go+++ b/backend/internal/services/settings_service.go@@ -535,7 +535,7 @@ func (s *SettingsService) prepareUpdateValues(updates settings.Update, cfg, defavaluesToUpdate = append(valuesToUpdate, models.SettingVariable{Key: key, Value: valueToSave})switch key {- case "pollingEnabled", "pollingInterval":+ case "pollingEnabled":changedPolling = truecase "autoUpdate", "autoUpdateInterval":changedAutoUpdate = truediff --git a/backend/pkg/scheduler/image_polling_job.go b/backend/pkg/scheduler/image_polling_job.godeleted file mode 100644index 9c6a8b14e..000000000--- a/backend/pkg/scheduler/image_polling_job.go+++ /dev/null@@ -1,83 +0,0 @@-package scheduler--import (- "context"- "log/slog"-- "github.com/getarcaneapp/arcane/backend/v2/internal/services"-)--type ImagePollingJob struct {- imageUpdateService *services.ImageUpdateService- settingsService *services.SettingsService- environmentService *services.EnvironmentService-}--func NewImagePollingJob(imageUpdateService *services.ImageUpdateService, settingsService *services.SettingsService, environmentService *services.EnvironmentService) *ImagePollingJob {- return &ImagePollingJob{- imageUpdateService: imageUpdateService,- settingsService: settingsService,- environmentService: environmentService,- }-}--func (j *ImagePollingJob) Name() string {- return "image-polling"-}--func (j *ImagePollingJob) ShouldSchedule(ctx context.Context) bool {- return j.settingsService.GetBoolSetting(ctx, "pollingEnabled", true)-}--func (j *ImagePollingJob) Schedule(ctx context.Context) string {- s := j.settingsService.GetStringSetting(ctx, "pollingInterval", "0 0 * * * *")- if s == "" {- return "0 0 * * * *"- }- return s-}--func (j *ImagePollingJob) Run(ctx context.Context) {- pollingEnabled := j.settingsService.GetBoolSetting(ctx, "pollingEnabled", true)- if !pollingEnabled {- slog.DebugContext(ctx, "polling disabled; skipping image scan")- return- }-- slog.InfoContext(ctx, "image scan run started")-- creds, err := j.environmentService.GetEnabledRegistryCredentials(ctx)- if err != nil {- slog.WarnContext(ctx, "failed to load registry credentials for polling", "error", err.Error())- creds = nil- }-- results, err := j.imageUpdateService.CheckAllImages(ctx, 0, creds)- if err != nil {- slog.ErrorContext(ctx, "image scan failed", "err", err)- return- }-- total := len(results)- updates := 0- errors := 0- for _, r := range results {- if r == nil {- continue- }- if r.Error != "" {- errors++- continue- }- if r.HasUpdate {- updates++- }- }-- slog.InfoContext(ctx, "image scan run completed", "checked", total, "updates", updates, "errors", errors)-}--func (j *ImagePollingJob) Reschedule(ctx context.Context) error {- slog.InfoContext(ctx, "rescheduling image polling job in new scheduler; currently requires restart")- return nil-}diff --git a/backend/pkg/scheduler/image_update_watcher.go b/backend/pkg/scheduler/image_update_watcher.gonew file mode 100644index 000000000..2d217bc5c--- /dev/null+++ b/backend/pkg/scheduler/image_update_watcher.go@@ -0,0 +1,217 @@+package scheduler++import (+ "context"+ "errors"+ "fmt"+ "log/slog"+ "sync"+ "sync/atomic"+ "time"++ "github.com/getarcaneapp/arcane/backend/v2/internal/services"+ "github.com/getarcaneapp/arcane/types/v2/containerregistry"+ "github.com/getarcaneapp/arcane/types/v2/imageupdate"+ "github.com/moby/moby/api/types/events"+ "go.getarcane.app/streams/bus"+)++const imageUpdateWatcherDebounce = 2 * time.Second++type imageUpdateScannerInternal interface {+ CheckAllImages(ctx context.Context, limit int, externalCreds []containerregistry.Credential) (map[string]*imageupdate.Response, error)+}++type registryCredentialLoaderInternal interface {+ GetEnabledRegistryCredentials(ctx context.Context) ([]containerregistry.Credential, error)+}++type pollingSettingReaderInternal interface {+ GetBoolSetting(ctx context.Context, key string, fallback bool) bool+}++type dockerEventBusProviderInternal interface {+ EventBus() *bus.DockerEventBus+}++type imageUpdateScanRunInternal struct {+ done chan struct{}+}++// ImageUpdateWatcher continuously reconciles image update state after Docker image changes.+type ImageUpdateWatcher struct {+ imageUpdateService imageUpdateScannerInternal+ settingsService pollingSettingReaderInternal+ environmentService registryCredentialLoaderInternal+ dockerService dockerEventBusProviderInternal+ triggerCh chan struct{}+ debounce time.Duration+ activeRun atomic.Pointer[imageUpdateScanRunInternal]+}++// NewImageUpdateWatcher constructs the image update watcher from the existing services.+func NewImageUpdateWatcher(imageUpdateService *services.ImageUpdateService, settingsService *services.SettingsService, environmentService *services.EnvironmentService, dockerService *services.DockerClientService) *ImageUpdateWatcher {+ return &ImageUpdateWatcher{+ imageUpdateService: imageUpdateService,+ settingsService: settingsService,+ environmentService: environmentService,+ dockerService: dockerService,+ triggerCh: make(chan struct{}, 1),+ debounce: imageUpdateWatcherDebounce,+ }+}++// Name identifies the watcher in scheduler lifecycle logs.+func (w *ImageUpdateWatcher) Name() string {+ return "image-polling"+}++// Start subscribes to Docker image events and runs scans until ctx is canceled.+func (w *ImageUpdateWatcher) Start(ctx context.Context) error {+ if w == nil || w.dockerService == nil || w.dockerService.EventBus() == nil {+ return errors.New("docker event bus unavailable")+ }++ eventCh, unsubscribe := w.dockerService.EventBus().Subscribe(events.ImageEventType, bus.WithSubscriberBuffer(16))+ defer unsubscribe()++ var listener sync.WaitGroup+ listener.Go(func() {+ for {+ select {+ case <-ctx.Done():+ return+ case _, ok := <-eventCh:+ if !ok {+ return+ }+ w.Trigger()+ }+ }+ })++ slog.InfoContext(ctx, "image update watcher started")+ w.Trigger()+ w.runTriggeredScansInternal(ctx)+ listener.Wait()+ slog.InfoContext(ctx, "image update watcher stopped")+ return nil+}++// Trigger queues an image scan without blocking the Docker event publisher.+func (w *ImageUpdateWatcher) Trigger() {+ if w == nil {+ return+ }+ select {+ case w.triggerCh <- struct{}{}:+ default:+ }+}++// RunNow performs the same full-host image scan used by automatic watcher triggers.+func (w *ImageUpdateWatcher) RunNow(ctx context.Context) error {+ if w == nil || w.settingsService == nil || w.imageUpdateService == nil || w.environmentService == nil {+ return errors.New("image update watcher is not initialized")+ }++ run := &imageUpdateScanRunInternal{done: make(chan struct{})}+ for {+ activeRun := w.activeRun.Load()+ if activeRun == nil && w.activeRun.CompareAndSwap(nil, run) {+ break+ }+ if activeRun == nil {+ continue+ }++ select {+ case <-ctx.Done():+ return ctx.Err()+ case <-activeRun.done:+ }+ }+ defer func() {+ w.activeRun.Store(nil)+ close(run.done)+ }()++ if err := ctx.Err(); err != nil {+ return err+ }+ if !w.settingsService.GetBoolSetting(ctx, "pollingEnabled", true) {+ slog.DebugContext(ctx, "image update watcher disabled; skipping image scan")+ return nil+ }++ slog.InfoContext(ctx, "image scan run started")++ creds, err := w.environmentService.GetEnabledRegistryCredentials(ctx)+ if err != nil {+ slog.WarnContext(ctx, "failed to load registry credentials for image scan", "error", err.Error())+ creds = nil+ }++ results, err := w.imageUpdateService.CheckAllImages(ctx, 0, creds)+ if err != nil {+ return fmt.Errorf("image scan failed: %w", err)+ }++ total := len(results)+ updates := 0+ scanErrors := 0+ for _, result := range results {+ if result == nil {+ continue+ }+ if result.Error != "" {+ scanErrors+++ continue+ }+ if result.HasUpdate {+ updates+++ }+ }++ slog.InfoContext(ctx, "image scan run completed", "checked", total, "updates", updates, "errors", scanErrors)+ return nil+}++func (w *ImageUpdateWatcher) runTriggeredScansInternal(ctx context.Context) {+ for {+ select {+ case <-ctx.Done():+ return+ case <-w.triggerCh:+ }++ if !w.waitForDebounceInternal(ctx) {+ return+ }+ if err := w.RunNow(ctx); err != nil && !errors.Is(err, context.Canceled) {+ slog.ErrorContext(ctx, "image update watcher scan failed", "error", err)+ }+ }+}++func (w *ImageUpdateWatcher) waitForDebounceInternal(ctx context.Context) bool {+ timer := time.NewTimer(w.debounce)+ defer timer.Stop()++ for {+ select {+ case <-ctx.Done():+ return false+ case <-w.triggerCh:+ if !timer.Stop() {+ select {+ case <-timer.C:+ default:+ }+ }+ timer.Reset(w.debounce)+ case <-timer.C:+ return true+ }+ }+}diff --git a/backend/pkg/scheduler/image_update_watcher_test.go b/backend/pkg/scheduler/image_update_watcher_test.gonew file mode 100644index 000000000..ca5297d4b--- /dev/null+++ b/backend/pkg/scheduler/image_update_watcher_test.go@@ -0,0 +1,259 @@+package scheduler++import (+ "context"+ "errors"+ "sync"+ "testing"+ "time"++ "github.com/getarcaneapp/arcane/types/v2/containerregistry"+ "github.com/getarcaneapp/arcane/types/v2/imageupdate"+ "github.com/moby/moby/api/types/events"+ "github.com/stretchr/testify/require"+ "go.getarcane.app/streams/bus"+)++type imageUpdateScannerFakeInternal struct {+ mu sync.Mutex+ calls int+ active int+ maxActive int+ errors []error+ startedCh chan int+ releaseCh <-chan struct{}+}++func (s *imageUpdateScannerFakeInternal) CheckAllImages(ctx context.Context, _ int, _ []containerregistry.Credential) (map[string]*imageupdate.Response, error) {+ s.mu.Lock()+ s.calls+++ call := s.calls+ s.active+++ s.maxActive = max(s.maxActive, s.active)+ var err error+ if call <= len(s.errors) {+ err = s.errors[call-1]+ }+ startedCh := s.startedCh+ releaseCh := s.releaseCh+ s.mu.Unlock()++ if startedCh != nil {+ select {+ case startedCh <- call:+ default:+ }+ }+ if releaseCh != nil {+ select {+ case <-ctx.Done():+ err = ctx.Err()+ case <-releaseCh:+ }+ }++ s.mu.Lock()+ s.active--+ s.mu.Unlock()++ return map[string]*imageupdate.Response{}, err+}++func (s *imageUpdateScannerFakeInternal) countInternal() int {+ s.mu.Lock()+ defer s.mu.Unlock()+ return s.calls+}++func (s *imageUpdateScannerFakeInternal) maxActiveInternal() int {+ s.mu.Lock()+ defer s.mu.Unlock()+ return s.maxActive+}++type pollingSettingReaderFakeInternal struct {+ mu sync.RWMutex+ enabled bool+}++func (s *pollingSettingReaderFakeInternal) GetBoolSetting(context.Context, string, bool) bool {+ s.mu.RLock()+ defer s.mu.RUnlock()+ return s.enabled+}++func (s *pollingSettingReaderFakeInternal) setEnabledInternal(enabled bool) {+ s.mu.Lock()+ s.enabled = enabled+ s.mu.Unlock()+}++type registryCredentialLoaderFakeInternal struct{}++func (registryCredentialLoaderFakeInternal) GetEnabledRegistryCredentials(context.Context) ([]containerregistry.Credential, error) {+ return nil, nil+}++type dockerEventBusProviderFakeInternal struct {+ eventBus *bus.DockerEventBus+}++func (p dockerEventBusProviderFakeInternal) EventBus() *bus.DockerEventBus {+ return p.eventBus+}++func newImageUpdateWatcherForTestInternal(scanner imageUpdateScannerInternal, settings pollingSettingReaderInternal, eventBus *bus.DockerEventBus) *ImageUpdateWatcher {+ return &ImageUpdateWatcher{+ imageUpdateService: scanner,+ settingsService: settings,+ environmentService: registryCredentialLoaderFakeInternal{},+ dockerService: dockerEventBusProviderFakeInternal{eventBus: eventBus},+ triggerCh: make(chan struct{}, 1),+ debounce: 10 * time.Millisecond,+ }+}++func startImageUpdateWatcherForTestInternal(t *testing.T, watcher *ImageUpdateWatcher) (context.CancelFunc, <-chan error) {+ t.Helper()+ ctx, cancel := context.WithCancel(context.Background())+ errCh := make(chan error, 1)+ go func() {+ errCh <- watcher.Start(ctx)+ }()+ t.Cleanup(func() {+ cancel()+ require.NoError(t, <-errCh)+ })+ return cancel, errCh+}++func TestImageUpdateWatcher_StartScansAtStartupAndCoalescesAllImageEvents(t *testing.T) {+ scanner := &imageUpdateScannerFakeInternal{}+ settings := &pollingSettingReaderFakeInternal{enabled: true}+ eventBus := bus.NewDockerEventBus()+ watcher := newImageUpdateWatcherForTestInternal(scanner, settings, eventBus)+ startImageUpdateWatcherForTestInternal(t, watcher)++ require.Eventually(t, func() bool { return scanner.countInternal() == 1 }, time.Second, 5*time.Millisecond)++ actions := []events.Action{+ events.ActionPull,+ events.ActionCreate,+ events.ActionCommit,+ events.ActionImport,+ events.ActionLoad,+ events.ActionTag,+ events.ActionUnTag,+ events.ActionPrune,+ events.ActionDelete,+ events.ActionPush,+ events.ActionSave,+ events.Action("future-image-action"),+ }+ for _, action := range actions {+ eventBus.Publish(events.Message{Type: events.ImageEventType, Action: action})+ }++ require.Eventually(t, func() bool { return scanner.countInternal() == 2 }, time.Second, 5*time.Millisecond)+ time.Sleep(30 * time.Millisecond)+ require.Equal(t, 2, scanner.countInternal())+}++func TestImageUpdateWatcher_EventDuringScanQueuesOneSerializedFollowUp(t *testing.T) {+ releaseCh := make(chan struct{})+ scanner := &imageUpdateScannerFakeInternal{+ startedCh: make(chan int, 4),+ releaseCh: releaseCh,+ }+ settings := &pollingSettingReaderFakeInternal{enabled: true}+ eventBus := bus.NewDockerEventBus()+ watcher := newImageUpdateWatcherForTestInternal(scanner, settings, eventBus)+ startImageUpdateWatcherForTestInternal(t, watcher)++ require.Equal(t, 1, <-scanner.startedCh)+ for range 20 {+ eventBus.Publish(events.Message{Type: events.ImageEventType, Action: events.ActionTag})+ }+ close(releaseCh)++ require.Equal(t, 2, <-scanner.startedCh)+ time.Sleep(30 * time.Millisecond)+ require.Equal(t, 2, scanner.countInternal())+ require.Equal(t, 1, scanner.maxActiveInternal())+}++func TestImageUpdateWatcher_DisabledTriggersAreSkippedUntilEnabled(t *testing.T) {+ scanner := &imageUpdateScannerFakeInternal{}+ settings := &pollingSettingReaderFakeInternal{enabled: false}+ eventBus := bus.NewDockerEventBus()+ watcher := newImageUpdateWatcherForTestInternal(scanner, settings, eventBus)+ startImageUpdateWatcherForTestInternal(t, watcher)++ time.Sleep(30 * time.Millisecond)+ require.Zero(t, scanner.countInternal())++ eventBus.Publish(events.Message{Type: events.ImageEventType, Action: events.ActionPull})+ time.Sleep(30 * time.Millisecond)+ require.Zero(t, scanner.countInternal())++ settings.setEnabledInternal(true)+ watcher.Trigger()+ require.Eventually(t, func() bool { return scanner.countInternal() == 1 }, time.Second, 5*time.Millisecond)+}++func TestImageUpdateWatcher_ScanErrorDoesNotStopFutureEvents(t *testing.T) {+ scanner := &imageUpdateScannerFakeInternal{errors: []error{errors.New("registry unavailable")}}+ settings := &pollingSettingReaderFakeInternal{enabled: true}+ eventBus := bus.NewDockerEventBus()+ watcher := newImageUpdateWatcherForTestInternal(scanner, settings, eventBus)+ startImageUpdateWatcherForTestInternal(t, watcher)++ require.Eventually(t, func() bool { return scanner.countInternal() == 1 }, time.Second, 5*time.Millisecond)+ eventBus.Publish(events.Message{Type: events.ImageEventType, Action: events.ActionPull})+ require.Eventually(t, func() bool { return scanner.countInternal() == 2 }, time.Second, 5*time.Millisecond)+}++func TestImageUpdateWatcher_RunNowSerializesConcurrentCalls(t *testing.T) {+ releaseCh := make(chan struct{})+ scanner := &imageUpdateScannerFakeInternal{+ startedCh: make(chan int, 2),+ releaseCh: releaseCh,+ }+ settings := &pollingSettingReaderFakeInternal{enabled: true}+ watcher := newImageUpdateWatcherForTestInternal(scanner, settings, bus.NewDockerEventBus())++ errCh := make(chan error, 2)+ go func() { errCh <- watcher.RunNow(context.Background()) }()+ require.Equal(t, 1, <-scanner.startedCh)+ go func() { errCh <- watcher.RunNow(context.Background()) }()++ time.Sleep(20 * time.Millisecond)+ require.Equal(t, 1, scanner.countInternal())+ close(releaseCh)+ require.Equal(t, 2, <-scanner.startedCh)+ require.NoError(t, <-errCh)+ require.NoError(t, <-errCh)+ require.Equal(t, 1, scanner.maxActiveInternal())+}++func TestImageUpdateWatcher_RunNowWaiterHonorsCancellation(t *testing.T) {+ releaseCh := make(chan struct{})+ scanner := &imageUpdateScannerFakeInternal{+ startedCh: make(chan int, 1),+ releaseCh: releaseCh,+ }+ settings := &pollingSettingReaderFakeInternal{enabled: true}+ watcher := newImageUpdateWatcherForTestInternal(scanner, settings, bus.NewDockerEventBus())++ firstErrCh := make(chan error, 1)+ go func() { firstErrCh <- watcher.RunNow(context.Background()) }()+ require.Equal(t, 1, <-scanner.startedCh)++ waitingCtx, cancel := context.WithCancel(context.Background())+ cancel()+ require.ErrorIs(t, watcher.RunNow(waitingCtx), context.Canceled)+ require.Equal(t, 1, scanner.countInternal())++ close(releaseCh)+ require.NoError(t, <-firstErrCh)+}diff --git a/backend/pkg/scheduler/job_schedule_integration_test.go b/backend/pkg/scheduler/job_schedule_integration_test.goindex 9c1ed42ec..a6e1ef689 100644--- a/backend/pkg/scheduler/job_schedule_integration_test.go+++ b/backend/pkg/scheduler/job_schedule_integration_test.go@@ -4,7 +4,6 @@ import ("context""path/filepath""testing"- "time""github.com/getarcaneapp/arcane/backend/v2/internal/config""github.com/getarcaneapp/arcane/backend/v2/internal/database"@@ -17,7 +16,7 @@ import ("gorm.io/gorm/logger")-func TestImagePollingScheduleUpdatePersistsAndReplacesRuntimeEntry(t *testing.T) {+func TestDeprecatedImagePollingSchedulePersistsWithoutRuntimeJob(t *testing.T) {ctx := context.Background()databasePath := filepath.Join(t.TempDir(), "arcane.db")db, settingsService := openJobScheduleTestDatabaseInternal(t, ctx, databasePath)@@ -25,25 +24,19 @@ func TestImagePollingScheduleUpdatePersistsAndReplacesRuntimeEntry(t *testing.T)appConfig := &config.Config{Timezone: "UTC"}lifecycleCtx, cancelLifecycle := context.WithCancel(context.Background())jobScheduler := NewJobScheduler(lifecycleCtx, appConfig.GetLocation())- jobScheduler.RegisterJob(NewImagePollingJob(nil, settingsService, nil))jobService := services.NewJobService(db, settingsService, appConfig)jobService.SetScheduler(lifecycleCtx, jobScheduler)jobScheduler.StartScheduler()- initialState, ok := jobScheduler.GetJobRuntimeState("image-polling")- require.True(t, ok)- require.True(t, initialState.Scheduled)- require.Equal(t, "0 0 * * * *", initialState.Schedule)- require.Len(t, jobScheduler.cron.Entries(), 1)- initialEntryID := jobScheduler.entryIDs["image-polling"]+ _, ok := jobScheduler.GetJobRuntimeState("image-polling")+ require.False(t, ok)+ require.Empty(t, jobScheduler.cron.Entries())requestedSchedule := "0 0 8 * * *"- beforeUpdate := time.Now().UTC()updatedSchedules, err := jobService.UpdateJobSchedules(ctx, jobschedule.Update{PollingInterval: &requestedSchedule,})- afterUpdate := time.Now().UTC()require.NoError(t, err)require.Equal(t, requestedSchedule, updatedSchedules.PollingInterval)@@ -52,24 +45,17 @@ func TestImagePollingScheduleUpdatePersistsAndReplacesRuntimeEntry(t *testing.T)require.Equal(t, requestedSchedule, persisted.Value)require.Equal(t, requestedSchedule, settingsService.GetStringSetting(ctx, "pollingInterval", ""))- runtimeState, ok := jobScheduler.GetJobRuntimeState("image-polling")- require.True(t, ok)- require.True(t, runtimeState.Scheduled)- require.Equal(t, requestedSchedule, runtimeState.Schedule)- require.NotNil(t, runtimeState.NextRun)- require.Equal(t, "UTC", runtimeState.NextRun.Location().String())- requireNextDailyRunInternal(t, *runtimeState.NextRun, beforeUpdate, afterUpdate)- require.Len(t, jobScheduler.cron.Entries(), 1)- require.NotEqual(t, initialEntryID, jobScheduler.entryIDs["image-polling"])- for _, entry := range jobScheduler.cron.Entries() {- require.NotEqual(t, initialEntryID, entry.ID)- }+ _, ok = jobScheduler.GetJobRuntimeState("image-polling")+ require.False(t, ok)+ require.Empty(t, jobScheduler.cron.Entries())jobs, err := jobService.ListJobs(ctx)require.NoError(t, err)imagePollingStatus := findJobStatusInternal(t, jobs, "image-polling")- require.Equal(t, requestedSchedule, imagePollingStatus.Schedule)- require.Equal(t, runtimeState.NextRun, imagePollingStatus.NextRun)+ require.Equal(t, "continuous", imagePollingStatus.Schedule)+ require.Nil(t, imagePollingStatus.NextRun)+ require.True(t, imagePollingStatus.IsContinuous)+ require.Empty(t, imagePollingStatus.SettingsKey)cancelLifecycle()waitForSchedulerStopInternal(jobScheduler)@@ -78,7 +64,6 @@ func TestImagePollingScheduleUpdatePersistsAndReplacesRuntimeEntry(t *testing.T)restartDB, restartSettingsService := openJobScheduleTestDatabaseInternal(t, ctx, databasePath)restartLifecycleCtx, cancelRestartLifecycle := context.WithCancel(context.Background())restartScheduler := NewJobScheduler(restartLifecycleCtx, appConfig.GetLocation())- restartScheduler.RegisterJob(NewImagePollingJob(nil, restartSettingsService, nil))restartJobService := services.NewJobService(restartDB, restartSettingsService, appConfig)restartJobService.SetScheduler(restartLifecycleCtx, restartScheduler)restartScheduler.StartScheduler()@@ -88,28 +73,22 @@ func TestImagePollingScheduleUpdatePersistsAndReplacesRuntimeEntry(t *testing.T)closeJobScheduleTestDatabaseInternal(t, restartDB)})- restartedState, ok := restartScheduler.GetJobRuntimeState("image-polling")- require.True(t, ok)- require.True(t, restartedState.Scheduled)- require.Equal(t, requestedSchedule, restartedState.Schedule)- require.NotNil(t, restartedState.NextRun)- require.Len(t, restartScheduler.cron.Entries(), 1)+ _, ok = restartScheduler.GetJobRuntimeState("image-polling")+ require.False(t, ok)+ require.Empty(t, restartScheduler.cron.Entries())require.Equal(t, requestedSchedule, restartSettingsService.GetStringSetting(ctx, "pollingInterval", ""))restartedJobs, err := restartJobService.ListJobs(ctx)require.NoError(t, err)- require.Equal(t, requestedSchedule, findJobStatusInternal(t, restartedJobs, "image-polling").Schedule)+ require.Equal(t, "continuous", findJobStatusInternal(t, restartedJobs, "image-polling").Schedule)require.NoError(t, restartSettingsService.SetBoolSetting(ctx, "pollingEnabled", false))disabledSchedule := "0 0 9 * * *"_, err = restartJobService.UpdateJobSchedules(ctx, jobschedule.Update{PollingInterval: &disabledSchedule})require.NoError(t, err)- disabledState, ok := restartScheduler.GetJobRuntimeState("image-polling")- require.True(t, ok)- require.False(t, disabledState.Scheduled)- require.Nil(t, disabledState.NextRun)- require.Equal(t, disabledSchedule, disabledState.Schedule)+ _, ok = restartScheduler.GetJobRuntimeState("image-polling")+ require.False(t, ok)require.Empty(t, restartScheduler.cron.Entries())disabledJobs, err := restartJobService.ListJobs(ctx)@@ -117,7 +96,7 @@ func TestImagePollingScheduleUpdatePersistsAndReplacesRuntimeEntry(t *testing.T)disabledStatus := findJobStatusInternal(t, disabledJobs, "image-polling")require.False(t, disabledStatus.Enabled)require.Nil(t, disabledStatus.NextRun)- require.Equal(t, disabledSchedule, disabledStatus.Schedule)+ require.Equal(t, "continuous", disabledStatus.Schedule)}func openJobScheduleTestDatabaseInternal(t *testing.T, ctx context.Context, databasePath string) (*database.DB, *services.SettingsService) {@@ -160,19 +139,3 @@ func findJobStatusInternal(t *testing.T, jobs *jobschedule.JobListResponse, jobIt.Fatalf("job %q not found", jobID)return jobschedule.JobStatus{}}--func requireNextDailyRunInternal(t *testing.T, actual, beforeUpdate, afterUpdate time.Time) {- t.Helper()-- nextAtEight := func(reference time.Time) time.Time {- next := time.Date(reference.Year(), reference.Month(), reference.Day(), 8, 0, 0, 0, time.UTC)- if !next.After(reference) {- next = next.AddDate(0, 0, 1)- }- return next- }-- expectedBefore := nextAtEight(beforeUpdate)- expectedAfter := nextAtEight(afterUpdate)- require.Truef(t, actual.Equal(expectedBefore) || actual.Equal(expectedAfter), "next run %s is neither %s nor %s", actual, expectedBefore, expectedAfter)-}diff --git a/backend/pkg/scheduler/scheduler.go b/backend/pkg/scheduler/scheduler.goindex 0ec57a571..0bf06a772 100644--- a/backend/pkg/scheduler/scheduler.go+++ b/backend/pkg/scheduler/scheduler.go@@ -2,6 +2,7 @@ package schedulerimport ("context"+ "fmt""log/slog""sync""time"@@ -19,11 +20,13 @@ type JobScheduler struct {cron *cron.Cronjobs []schedulertypes.JobjobsByID map[string]schedulertypes.Job+ watchers map[string]schedulertypes.BusWatcherentryIDs map[string]cron.EntryIDschedules map[string]stringparser cron.Parsercontext context.Contextlocation *time.Location+ watcherWG sync.WaitGroup}// NewJobScheduler creates a new job scheduler with the specified timezone location.@@ -39,6 +42,7 @@ func NewJobScheduler(ctx context.Context, location *time.Location) *JobSchedulercron: cron.New(cron.WithParser(parser), cron.WithLocation(location)),jobs: []schedulertypes.Job{},jobsByID: make(map[string]schedulertypes.Job),+ watchers: make(map[string]schedulertypes.BusWatcher),entryIDs: make(map[string]cron.EntryID),schedules: make(map[string]string),parser: parser,@@ -56,6 +60,36 @@ func (js *JobScheduler) RegisterJob(job schedulertypes.Job) {js.jobsByID[job.Name()] = job}+// RegisterBusWatcher starts a continuous event watcher on the scheduler lifecycle.+func (js *JobScheduler) RegisterBusWatcher(watcher schedulertypes.BusWatcher, canRunManually bool) {+ if watcher == nil {+ return+ }+ if canRunManually {+ js.mu.Lock()+ js.watchers[watcher.Name()] = watcher+ js.mu.Unlock()+ }++ js.watcherWG.Go(func() {+ if err := watcher.Start(js.context); err != nil {+ slog.ErrorContext(js.context, "Bus watcher failed", "name", watcher.Name(), "error", err)+ }+ })+}++// RunBusWatcherNow runs a watcher through its serialized manual path.+func (js *JobScheduler) RunBusWatcherNow(ctx context.Context, watcherID string) error {+ js.mu.Lock()+ watcher, ok := js.watchers[watcherID]+ js.mu.Unlock()+ if !ok {+ return fmt.Errorf("bus watcher %s is not manually runnable", watcherID)+ }++ return watcher.RunNow(ctx)+}+func (js *JobScheduler) GetJob(jobID string) (schedulertypes.Job, bool) {js.mu.Lock()defer js.mu.Unlock()@@ -163,6 +197,7 @@ func (js *JobScheduler) Run(ctx context.Context) error {// so Bootstrap cannot close shared services underneath them; the process-level// signal handler owns the hard shutdown deadline for non-cooperative jobs.<-js.cron.Stop().Done()+ js.watcherWG.Wait()return nil}diff --git a/backend/pkg/scheduler/scheduler_test.go b/backend/pkg/scheduler/scheduler_test.goindex d579704e6..b390ce814 100644--- a/backend/pkg/scheduler/scheduler_test.go+++ b/backend/pkg/scheduler/scheduler_test.go@@ -31,6 +31,29 @@ type conditionalTestSchedulerJob struct {shouldSchedule func(context.Context) bool}+type testBusWatcherInternal struct {+ name string+ started chan struct{}+ stopped chan struct{}+ ranNow chan context.Context+}++func (w *testBusWatcherInternal) RunNow(ctx context.Context) error {+ if w.ranNow != nil {+ w.ranNow <- ctx+ }+ return nil+}++func (w *testBusWatcherInternal) Name() string { return w.name }++func (w *testBusWatcherInternal) Start(ctx context.Context) error {+ close(w.started)+ <-ctx.Done()+ close(w.stopped)+ return nil+}+func (j *conditionalTestSchedulerJob) ShouldSchedule(ctx context.Context) bool {if j.shouldSchedule == nil {return true@@ -58,6 +81,62 @@ func TestJobScheduler_StartScheduler_SkipsDisabledConditionalJobs(t *testing.T)require.Empty(t, js.cron.Entries())}+func TestJobScheduler_RegisterBusWatcherUsesLifecycleAndWaitsForShutdown(t *testing.T) {+ ctx, cancel := context.WithCancel(context.Background())+ js := NewJobScheduler(ctx, nil)+ watcher := &testBusWatcherInternal{+ name: "test-bus-watcher",+ started: make(chan struct{}),+ stopped: make(chan struct{}),+ ranNow: make(chan context.Context, 1),+ }++ js.RegisterBusWatcher(watcher, true)++ select {+ case <-watcher.started:+ case <-time.After(time.Second):+ t.Fatal("timed out waiting for bus watcher to start")+ }++ runDone := make(chan error, 1)+ go func() { runDone <- js.Run(ctx) }()+ cancel()++ select {+ case <-watcher.stopped:+ case <-time.After(time.Second):+ t.Fatal("timed out waiting for bus watcher to stop")+ }+ require.NoError(t, <-runDone)+}++func TestJobScheduler_RegisterBusWatcherManualRunOption(t *testing.T) {+ ctx, cancel := context.WithCancel(context.Background())+ defer cancel()++ js := NewJobScheduler(ctx, nil)+ manualWatcher := &testBusWatcherInternal{+ name: "manual-bus-watcher",+ started: make(chan struct{}),+ stopped: make(chan struct{}),+ ranNow: make(chan context.Context, 1),+ }+ automaticOnlyWatcher := &testBusWatcherInternal{+ name: "automatic-only-bus-watcher",+ started: make(chan struct{}),+ stopped: make(chan struct{}),+ }++ js.RegisterBusWatcher(manualWatcher, true)+ js.RegisterBusWatcher(automaticOnlyWatcher, false)++ runCtx := context.Background()+ require.NoError(t, js.RunBusWatcherNow(runCtx, manualWatcher.Name()))+ require.Equal(t, runCtx, <-manualWatcher.ranNow)+ require.Error(t, js.RunBusWatcherNow(runCtx, automaticOnlyWatcher.Name()))+}+func TestJobScheduler_RescheduleJob_RemovesEntryWhenDisabled(t *testing.T) {js := NewJobScheduler(context.Background(), nil)enabled := truediff --git a/types/jobschedule/jobschedule.go b/types/jobschedule/jobschedule.goindex 5889cfcf1..a6a196eb0 100644--- a/types/jobschedule/jobschedule.go+++ b/types/jobschedule/jobschedule.go@@ -12,7 +12,7 @@ type Config struct {ExpiredSessionsCleanupInterval string `json:"expiredSessionsCleanupInterval"`AutoUpdateInterval string `json:"autoUpdateInterval"`DockerClientRefreshInterval string `json:"dockerClientRefreshInterval"`- PollingInterval string `json:"pollingInterval"`+ PollingInterval string `json:"pollingInterval"` // Deprecated: image update checks are event-driven.ScheduledPruneInterval string `json:"scheduledPruneInterval"`VulnerabilityScanInterval string `json:"vulnerabilityScanInterval"`AutoHealInterval string `json:"autoHealInterval"`@@ -27,7 +27,7 @@ type Update struct {ExpiredSessionsCleanupInterval *string `json:"expiredSessionsCleanupInterval,omitempty"`AutoUpdateInterval *string `json:"autoUpdateInterval,omitempty"`DockerClientRefreshInterval *string `json:"dockerClientRefreshInterval,omitempty"`- PollingInterval *string `json:"pollingInterval,omitempty"`+ PollingInterval *string `json:"pollingInterval,omitempty"` // Deprecated: accepted and persisted for compatibility, but ignored.ScheduledPruneInterval *string `json:"scheduledPruneInterval,omitempty"`VulnerabilityScanInterval *string `json:"vulnerabilityScanInterval,omitempty"`AutoHealInterval *string `json:"autoHealInterval,omitempty"`diff --git a/types/meta/job_metadata.go b/types/meta/job_metadata.goindex ded0b650f..014b5b4b4 100644--- a/types/meta/job_metadata.go+++ b/types/meta/job_metadata.go@@ -112,13 +112,13 @@ var jobMetadataRegistry = map[string]JobMetadata{},"image-polling": {ID: "image-polling",- Name: "Image Polling",- Description: "Checks container registries for new image versions",+ Name: "Image Update Watcher",+ Description: "Checks container registries after Docker image changes",Category: "updates",- SettingsKey: "pollingInterval",+ SettingsKey: "",EnabledKey: "pollingEnabled",ManagerOnly: false,- IsContinuous: false,+ IsContinuous: true,CanRunManually: true,Prerequisites: []JobPrerequisiteMetadata{{diff --git a/types/scheduler/job.go b/types/scheduler/job.goindex 2263d7996..79e8ad30a 100644--- a/types/scheduler/job.go+++ b/types/scheduler/job.go@@ -25,6 +25,13 @@ type ConditionalJob interface {ShouldSchedule(ctx context.Context) bool}+// BusWatcher is a continuous event consumer owned by the application scheduler lifecycle.+type BusWatcher interface {+ Name() string+ Start(ctx context.Context) error+ RunNow(ctx context.Context) error+}+// GenericJob is a reusable Job built from closures. It lets a service register a// per-entity dynamic job (e.g. one per GitOps sync or one per environment) without// importing the scheduler package: the service constructs a GenericJob and hands it