Skip to content

Modern Docker Management, Designed for Everyone

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.go
index 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.go
index 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.go
index 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.go
index 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) *Jo
autoUpdateJob := scheduler.NewAutoUpdateJob(updaterService, settingsService)
imageUpdateService := svcs.ImageUpdate
environmentService := 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.KV
analyticsJob := provideAnalyticsJobInternal(settingsService, kvService, cfg)
@@ -146,7 +146,7 @@ func InitializeJobs(ctx context.Context, cfg *config.Config, svcs *Services) *Jo
autoHealJob := 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.go
index 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.Second
const 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.go
index 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 *testi
assert.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.go
index 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.go
index 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 *test
requestCtx, 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_RestoresPreviousScheduleWhenRescheduleFai
require.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 *t
require.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 []string
rescheduleContexts []context.Context
rescheduleErr error
+ busWatcherRuns []string
+ busWatcherContexts []context.Context
}
func newFakeJobSchedulerInternal(jobIDs ...string) *fakeJobSchedulerInternal {
@@ -314,6 +370,12 @@ func (s *fakeJobSchedulerInternal) RescheduleJob(ctx context.Context, job schedu
return 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.go
index 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, defa
valuesToUpdate = append(valuesToUpdate, models.SettingVariable{Key: key, Value: valueToSave})
switch key {
- case "pollingEnabled", "pollingInterval":
+ case "pollingEnabled":
changedPolling = true
case "autoUpdate", "autoUpdateInterval":
changedAutoUpdate = true
diff --git a/backend/pkg/scheduler/image_polling_job.go b/backend/pkg/scheduler/image_polling_job.go
deleted file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
index 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, jobI
t.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.go
index 0ec57a571..0bf06a772 100644
--- a/backend/pkg/scheduler/scheduler.go
+++ b/backend/pkg/scheduler/scheduler.go
@@ -2,6 +2,7 @@ package scheduler
import (
"context"
+ "fmt"
"log/slog"
"sync"
"time"
@@ -19,11 +20,13 @@ type JobScheduler struct {
cron *cron.Cron
jobs []schedulertypes.Job
jobsByID map[string]schedulertypes.Job
+ watchers map[string]schedulertypes.BusWatcher
entryIDs map[string]cron.EntryID
schedules map[string]string
parser cron.Parser
context context.Context
location *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) *JobScheduler
cron: 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.go
index 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 := true
diff --git a/types/jobschedule/jobschedule.go b/types/jobschedule/jobschedule.go
index 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.go
index 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.go
index 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