Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
fix: fix image polling schedule rescheduling api shape (#3224)
Kyle Mendell8e8023e3765c
diff --git a/backend/internal/services/job_service.go b/backend/internal/services/job_service.goindex d6bad27d5..a332ff79c 100644--- a/backend/internal/services/job_service.go+++ b/backend/internal/services/job_service.go@@ -20,6 +20,7 @@ import (type JobRunner interface {GetJob(jobID string) (schedulertypes.Job, bool)+ GetJobRuntimeState(jobID string) (schedulertypes.JobRuntimeState, bool)RescheduleJob(ctx context.Context, job schedulertypes.Job) error}@@ -65,17 +66,19 @@ func (s *JobService) SetScheduler(ctx context.Context, scheduler JobRunner) { //}func (s *JobService) GetJobSchedules(ctx context.Context) jobschedule.Config {+ defaults := DefaultSettingsConfig()+// Use SettingsService cache for fast reads.return jobschedule.Config{- EnvironmentHealthInterval: s.settings.GetStringSetting(ctx, "environmentHealthInterval", "0 */2 * * * *"),- EventCleanupInterval: s.settings.GetStringSetting(ctx, "eventCleanupInterval", "0 0 */6 * * *"),- ExpiredSessionsCleanupInterval: s.settings.GetStringSetting(ctx, "expiredSessionsCleanupInterval", "0 0 0 * * *"),- AutoUpdateInterval: s.settings.GetStringSetting(ctx, "autoUpdateInterval", "0 0 0 * * *"),- DockerClientRefreshInterval: s.settings.GetStringSetting(ctx, "dockerClientRefreshInterval", "*/30 * * * * *"),- PollingInterval: s.settings.GetStringSetting(ctx, "pollingInterval", "0 */15 * * * *"),- ScheduledPruneInterval: s.settings.GetStringSetting(ctx, "scheduledPruneInterval", "0 0 0 * * *"),- VulnerabilityScanInterval: s.settings.GetStringSetting(ctx, "vulnerabilityScanInterval", "0 0 0 * * *"),- AutoHealInterval: s.settings.GetStringSetting(ctx, "autoHealInterval", "*/30 * * * * *"),+ EnvironmentHealthInterval: s.settings.GetStringSetting(ctx, "environmentHealthInterval", defaults.EnvironmentHealthInterval.Value),+ EventCleanupInterval: s.settings.GetStringSetting(ctx, "eventCleanupInterval", defaults.EventCleanupInterval.Value),+ ExpiredSessionsCleanupInterval: s.settings.GetStringSetting(ctx, "expiredSessionsCleanupInterval", defaults.ExpiredSessionsCleanupInterval.Value),+ AutoUpdateInterval: s.settings.GetStringSetting(ctx, "autoUpdateInterval", defaults.AutoUpdateInterval.Value),+ DockerClientRefreshInterval: s.settings.GetStringSetting(ctx, "dockerClientRefreshInterval", defaults.DockerClientRefreshInterval.Value),+ PollingInterval: s.settings.GetStringSetting(ctx, "pollingInterval", defaults.PollingInterval.Value),+ ScheduledPruneInterval: s.settings.GetStringSetting(ctx, "scheduledPruneInterval", defaults.ScheduledPruneInterval.Value),+ VulnerabilityScanInterval: s.settings.GetStringSetting(ctx, "vulnerabilityScanInterval", defaults.VulnerabilityScanInterval.Value),+ AutoHealInterval: s.settings.GetStringSetting(ctx, "autoHealInterval", defaults.AutoHealInterval.Value),}}@@ -118,6 +121,7 @@ func (s *JobService) UpdateJobSchedules(ctx context.Context, updates jobschedulechanged := falsechangedKeys := make([]string, 0, len(fields))+ previousValues := make(map[string]string, len(fields))upsert := func(tx *gorm.DB, key string, v *string, currentVal string) error {if v == nil {return nil@@ -127,6 +131,7 @@ func (s *JobService) UpdateJobSchedules(ctx context.Context, updates jobschedule}changed = truechangedKeys = append(changedKeys, key)+ previousValues[key] = currentValreturn tx.Save(&models.SettingVariable{Key: key, Value: *v}).Error}@@ -145,18 +150,31 @@ func (s *JobService) UpdateJobSchedules(ctx context.Context, updates jobschedule// Refresh settings cache so jobs reading from SettingsService see new values.if changed {if err := s.settings.LoadDatabaseSettings(ctx); err != nil {- return jobschedule.Config{}, fmt.Errorf("failed to reload settings after job schedule update: %w", err)+ restoreErr := s.restoreJobSchedulesInternal(ctx, previousValues, changedKeys)+ return jobschedule.Config{}, errors.Join(+ fmt.Errorf("failed to reload settings after job schedule update: %w", err),+ restoreErr,+ )}- s.RescheduleJobsForSettingKeys(ctx, changedKeys)+ if err := s.RescheduleJobsForSettingKeys(ctx, changedKeys); err != nil {+ restoreErr := s.restoreJobSchedulesInternal(ctx, previousValues, changedKeys)+ return jobschedule.Config{}, errors.Join(+ fmt.Errorf("failed to apply job schedule update: %w", err),+ restoreErr,+ )+ }}return s.GetJobSchedules(ctx), nil}-func (s *JobService) RescheduleJobsForSettingKeys(ctx context.Context, changedKeys []string) {- if s == nil || s.scheduler == nil || len(changedKeys) == 0 {- return+func (s *JobService) RescheduleJobsForSettingKeys(ctx context.Context, changedKeys []string) error {+ if len(changedKeys) == 0 {+ return nil+ }+ if s == nil || s.scheduler == nil {+ return errors.New("job scheduler not initialized")}changed := make(map[string]struct{}, len(changedKeys))@@ -164,6 +182,7 @@ func (s *JobService) RescheduleJobsForSettingKeys(ctx context.Context, changedKechanged[key] = struct{}{}}+ var rescheduleErrors []errorfor jobID, jobMeta := range meta.GetAllJobMetadata() {if !jobMetadataAffectedBySettingInternal(jobMeta, changed) {continue@@ -182,13 +201,15 @@ func (s *JobService) RescheduleJobsForSettingKeys(ctx context.Context, changedKereschedCtx = s.lifecycleCtx}s.OnEnvironmentHealthReschedule(reschedCtx)+ } else {+ rescheduleErrors = append(rescheduleErrors, errors.New("environment-health rescheduler not initialized"))}continue}job, ok := s.scheduler.GetJob(jobID)if !ok {- slog.DebugContext(ctx, "Skipping reschedule for unregistered job", "job", jobID)+ rescheduleErrors = append(rescheduleErrors, fmt.Errorf("job %s not found in scheduler", jobID))continue}@@ -198,9 +219,50 @@ func (s *JobService) RescheduleJobsForSettingKeys(ctx context.Context, changedKerescheduleCtx = s.lifecycleCtx}if err := s.scheduler.RescheduleJob(rescheduleCtx, job); err != nil {- slog.WarnContext(ctx, "Failed to reschedule job", "job", jobID, "error", err)+ rescheduleErrors = append(rescheduleErrors, fmt.Errorf("reschedule job %s: %w", jobID, err))+ continue+ }++ runtimeState, ok := s.scheduler.GetJobRuntimeState(jobID)+ if !ok {+ rescheduleErrors = append(rescheduleErrors, fmt.Errorf("job %s has no runtime scheduler state", jobID))+ continue+ }++ expectedSchedule := job.Schedule(rescheduleCtx)+ if runtimeState.Schedule != expectedSchedule {+ rescheduleErrors = append(rescheduleErrors, fmt.Errorf("job %s runtime schedule %q does not match requested schedule %q", jobID, runtimeState.Schedule, expectedSchedule))+ }+ }++ return errors.Join(rescheduleErrors...)+}++func (s *JobService) restoreJobSchedulesInternal(ctx context.Context, previousValues map[string]string, changedKeys []string) error {+ if len(previousValues) == 0 {+ return nil+ }++ if err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {+ for key, value := range previousValues {+ if err := tx.Save(&models.SettingVariable{Key: key, Value: value}).Error; err != nil {+ return err+ }}+ return nil+ }); err != nil {+ return fmt.Errorf("failed to restore previous job schedules: %w", err)+ }++ if err := s.settings.LoadDatabaseSettings(ctx); err != nil {+ return fmt.Errorf("failed to reload restored job schedules: %w", err)}++ if err := s.RescheduleJobsForSettingKeys(ctx, changedKeys); err != nil {+ return fmt.Errorf("failed to restore runtime job schedules: %w", err)+ }++ return nil}func jobMetadataAffectedBySettingInternal(jobMeta meta.JobMetadata, changed map[string]struct{}) bool {@@ -225,13 +287,20 @@ func (s *JobService) ListJobs(ctx context.Context) (*jobschedule.JobListResponseallMetadata := meta.GetAllJobMetadata()jobs := make([]jobschedule.JobStatus, 0, len(allMetadata))- for _, meta := range allMetadata {- schedule := s.getJobScheduleInternal(ctx, meta)+ for _, jobMeta := range allMetadata {+ schedule := s.getJobScheduleInternal(ctx, jobMeta)nextRun := s.calculateNextRunInternal(schedule)- enabled := s.isJobEnabledInternal(ctx, meta)- prerequisites := s.evaluatePrerequisitesInternal(ctx, meta)+ enabled := s.isJobEnabledInternal(ctx, jobMeta)+ prerequisites := s.evaluatePrerequisitesInternal(ctx, jobMeta)++ if s.scheduler != nil && jobMeta.SettingsKey != "" && jobMeta.ID != "environment-health" {+ if runtimeState, ok := s.scheduler.GetJobRuntimeState(jobMeta.ID); ok && runtimeState.Schedule != "" {+ schedule = runtimeState.Schedule+ nextRun = runtimeState.NextRun+ }+ }- jobStatus := meta.ToJobStatus(schedule, nextRun, enabled, prerequisites)+ jobStatus := jobMeta.ToJobStatus(schedule, nextRun, enabled, prerequisites)jobs = append(jobs, jobStatus)}@@ -305,20 +374,8 @@ func (s *JobService) getJobScheduleInternal(ctx context.Context, meta meta.JobMereturn ""}- defaultSchedules := map[string]string{- "environmentHealthInterval": "0 */2 * * * *",- "eventCleanupInterval": "0 0 */6 * * *",- "expiredSessionsCleanupInterval": "0 0 0 * * *",- "autoUpdateInterval": "0 0 0 * * *",- "dockerClientRefreshInterval": "*/30 * * * * *",- "pollingInterval": "0 */15 * * * *",- "scheduledPruneInterval": "0 0 0 * * *",- "vulnerabilityScanInterval": "0 0 0 * * *",- "autoHealInterval": "*/30 * * * * *",- }-- defaultSchedule := defaultSchedules[meta.SettingsKey]- if defaultSchedule == "" {+ defaultSchedule, _, _, err := DefaultSettingsConfig().FieldByKey(meta.SettingsKey)+ if err != nil || defaultSchedule == "" {defaultSchedule = "0 0 0 * * *"}diff --git a/backend/internal/services/job_service_test.go b/backend/internal/services/job_service_test.goindex c668b5e70..6f1098497 100644--- a/backend/internal/services/job_service_test.go+++ b/backend/internal/services/job_service_test.go@@ -2,9 +2,12 @@ package servicesimport ("context"+ "errors""testing"+ "time""github.com/getarcaneapp/arcane/backend/v2/internal/config"+ "github.com/getarcaneapp/arcane/backend/v2/internal/models""github.com/getarcaneapp/arcane/types/v2/jobschedule"schedulertypes "github.com/getarcaneapp/arcane/types/v2/scheduler""github.com/stretchr/testify/require"@@ -21,6 +24,7 @@ func TestJobService_GetJobSchedules_DefaultDockerClientRefreshInterval(t *testincfg := jobSvc.GetJobSchedules(ctx)require.Equal(t, "*/30 * * * * *", cfg.DockerClientRefreshInterval)+ require.Equal(t, "0 0 * * * *", cfg.PollingInterval)}func TestJobService_ListJobs_AnalyticsHeartbeatIsManagedInternally(t *testing.T) {@@ -78,6 +82,31 @@ func TestJobService_ListJobs_IncludesDockerClientRefreshJob(t *testing.T) {require.Equal(t, "*/30 * * * * *", refreshJob.Schedule)}+func TestJobService_ListJobs_UsesRuntimeScheduleAndNextRun(t *testing.T) {+ ctx := context.Background()+ db := setupSettingsTestDB(t)++ settingsSvc, err := NewSettingsService(ctx, db)+ 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{+ Schedule: "0 0 8 * * *",+ NextRun: &nextRun,+ Scheduled: true,+ }++ jobSvc := NewJobService(db, settingsSvc, &config.Config{})+ jobSvc.SetScheduler(ctx, scheduler)+ 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)+}+func TestJobService_UpdateJobSchedules_ReschedulesChangedJob(t *testing.T) {ctx := context.Background()db := setupSettingsTestDB(t)@@ -124,6 +153,67 @@ func TestJobService_UpdateJobSchedules_UsesLifecycleContextForReschedule(t *testrequire.Equal(t, true, scheduler.rescheduleContexts[0].Value(lifecycleContextKey{}))}+func TestJobService_UpdateJobSchedules_RejectsInvalidCronWithoutChangingSetting(t *testing.T) {+ ctx := context.Background()+ db := setupSettingsTestDB(t)++ settingsSvc, err := NewSettingsService(ctx, db)+ require.NoError(t, err)+ require.NoError(t, settingsSvc.EnsureDefaultSettings(ctx))+ require.NoError(t, settingsSvc.LoadDatabaseSettings(ctx))++ jobSvc := NewJobService(db, settingsSvc, &config.Config{})+ scheduler := newFakeJobSchedulerInternal("image-polling")+ jobSvc.SetScheduler(ctx, scheduler)++ _, err = jobSvc.UpdateJobSchedules(ctx, jobschedule.Update{+ PollingInterval: new("not a cron expression"),+ })+ require.ErrorContains(t, err, "invalid cron expression for pollingInterval")+ require.Equal(t, "0 0 * * * *", settingsSvc.GetStringSetting(ctx, "pollingInterval", ""))+ require.Empty(t, scheduler.rescheduled)+}++func TestJobService_UpdateJobSchedules_UnchangedScheduleDoesNotReschedule(t *testing.T) {+ ctx := context.Background()+ db := setupSettingsTestDB(t)++ settingsSvc, err := NewSettingsService(ctx, db)+ require.NoError(t, err)++ jobSvc := NewJobService(db, settingsSvc, &config.Config{})+ updated, err := jobSvc.UpdateJobSchedules(ctx, jobschedule.Update{+ PollingInterval: new("0 0 * * * *"),+ })+ require.NoError(t, err)+ require.Equal(t, "0 0 * * * *", updated.PollingInterval)+}++func TestJobService_UpdateJobSchedules_RestoresPreviousScheduleWhenRescheduleFails(t *testing.T) {+ ctx := context.Background()+ db := setupSettingsTestDB(t)++ settingsSvc, err := NewSettingsService(ctx, db)+ require.NoError(t, err)+ require.NoError(t, settingsSvc.EnsureDefaultSettings(ctx))+ require.NoError(t, settingsSvc.LoadDatabaseSettings(ctx))++ jobSvc := NewJobService(db, settingsSvc, &config.Config{})+ scheduler := newFakeJobSchedulerInternal("image-polling")+ scheduler.rescheduleErr = errors.New("scheduler unavailable")+ jobSvc.SetScheduler(ctx, scheduler)++ _, err = jobSvc.UpdateJobSchedules(ctx, jobschedule.Update{+ PollingInterval: new("0 0 8 * * *"),+ })+ require.ErrorContains(t, err, "scheduler unavailable")+ require.Equal(t, "0 0 * * * *", settingsSvc.GetStringSetting(ctx, "pollingInterval", ""))++ var persisted models.SettingVariable+ require.NoError(t, db.WithContext(ctx).First(&persisted, "key = ?", "pollingInterval").Error)+ require.Equal(t, "0 0 * * * *", persisted.Value)+}+func TestJobService_UpdateJobSchedules_SkipsManagerOnlyJobsInAgentMode(t *testing.T) {ctx := context.Background()db := setupSettingsTestDB(t)@@ -143,6 +233,30 @@ func TestJobService_UpdateJobSchedules_SkipsManagerOnlyJobsInAgentMode(t *testinrequire.Empty(t, scheduler.rescheduled)}+func TestJobService_UpdateJobSchedules_DelegatesEnvironmentHealthReschedule(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()+ jobSvc.SetScheduler(ctx, scheduler)++ rescheduled := 0+ jobSvc.OnEnvironmentHealthReschedule = func(context.Context) {+ rescheduled+++ }++ _, err = jobSvc.UpdateJobSchedules(ctx, jobschedule.Update{+ EnvironmentHealthInterval: new("0 */5 * * * *"),+ })+ require.NoError(t, err)+ require.Equal(t, 1, rescheduled)+ require.Empty(t, scheduler.rescheduled)+}+func findJobStatusByIDInternal(t *testing.T, jobs []jobschedule.JobStatus, id string) jobschedule.JobStatus {t.Helper()@@ -158,8 +272,10 @@ func findJobStatusByIDInternal(t *testing.T, jobs []jobschedule.JobStatus, id sttype fakeJobSchedulerInternal struct {jobs map[string]schedulertypes.Job+ runtimeStates map[string]schedulertypes.JobRuntimeStaterescheduled []stringrescheduleContexts []context.Context+ rescheduleErr error}func newFakeJobSchedulerInternal(jobIDs ...string) *fakeJobSchedulerInternal {@@ -169,7 +285,8 @@ func newFakeJobSchedulerInternal(jobIDs ...string) *fakeJobSchedulerInternal {}return &fakeJobSchedulerInternal{- jobs: jobs,+ jobs: jobs,+ runtimeStates: make(map[string]schedulertypes.JobRuntimeState),}}@@ -178,9 +295,22 @@ func (s *fakeJobSchedulerInternal) GetJob(jobID string) (schedulertypes.Job, booreturn job, ok}+func (s *fakeJobSchedulerInternal) GetJobRuntimeState(jobID string) (schedulertypes.JobRuntimeState, bool) {+ state, ok := s.runtimeStates[jobID]+ return state, ok+}+func (s *fakeJobSchedulerInternal) RescheduleJob(ctx context.Context, job schedulertypes.Job) error {s.rescheduled = append(s.rescheduled, job.Name())s.rescheduleContexts = append(s.rescheduleContexts, ctx)+ if s.rescheduleErr != nil {+ return s.rescheduleErr+ }++ s.runtimeStates[job.Name()] = schedulertypes.JobRuntimeState{+ Schedule: job.Schedule(ctx),+ Scheduled: true,+ }return nil}diff --git a/backend/pkg/scheduler/job_schedule_integration_test.go b/backend/pkg/scheduler/job_schedule_integration_test.gonew file mode 100644index 000000000..9c1ed42ec--- /dev/null+++ b/backend/pkg/scheduler/job_schedule_integration_test.go@@ -0,0 +1,178 @@+package scheduler++import (+ "context"+ "path/filepath"+ "testing"+ "time"++ "github.com/getarcaneapp/arcane/backend/v2/internal/config"+ "github.com/getarcaneapp/arcane/backend/v2/internal/database"+ "github.com/getarcaneapp/arcane/backend/v2/internal/models"+ "github.com/getarcaneapp/arcane/backend/v2/internal/services"+ "github.com/getarcaneapp/arcane/types/v2/jobschedule"+ sqlite "github.com/libtnb/sqlite"+ "github.com/stretchr/testify/require"+ "gorm.io/gorm"+ "gorm.io/gorm/logger"+)++func TestImagePollingScheduleUpdatePersistsAndReplacesRuntimeEntry(t *testing.T) {+ ctx := context.Background()+ databasePath := filepath.Join(t.TempDir(), "arcane.db")+ db, settingsService := openJobScheduleTestDatabaseInternal(t, ctx, databasePath)++ 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"]++ 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)++ var persisted models.SettingVariable+ require.NoError(t, db.WithContext(ctx).First(&persisted, "key = ?", "pollingInterval").Error)+ 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)+ }++ 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)++ cancelLifecycle()+ waitForSchedulerStopInternal(jobScheduler)+ closeJobScheduleTestDatabaseInternal(t, db)++ 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()+ t.Cleanup(func() {+ cancelRestartLifecycle()+ waitForSchedulerStopInternal(restartScheduler)+ 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)+ 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.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)+ require.Empty(t, restartScheduler.cron.Entries())++ disabledJobs, err := restartJobService.ListJobs(ctx)+ require.NoError(t, err)+ disabledStatus := findJobStatusInternal(t, disabledJobs, "image-polling")+ require.False(t, disabledStatus.Enabled)+ require.Nil(t, disabledStatus.NextRun)+ require.Equal(t, disabledSchedule, disabledStatus.Schedule)+}++func openJobScheduleTestDatabaseInternal(t *testing.T, ctx context.Context, databasePath string) (*database.DB, *services.SettingsService) {+ t.Helper()++ gormDB, err := gorm.Open(sqlite.Open(databasePath), &gorm.Config{Logger: logger.Default.LogMode(logger.Silent)})+ require.NoError(t, err)+ require.NoError(t, gormDB.AutoMigrate(&models.SettingVariable{}))++ db := &database.DB{DB: gormDB}+ settingsService, err := services.NewSettingsService(ctx, db)+ require.NoError(t, err)+ require.NoError(t, settingsService.EnsureDefaultSettings(ctx))+ require.NoError(t, settingsService.LoadDatabaseSettings(ctx))++ return db, settingsService+}++func closeJobScheduleTestDatabaseInternal(t *testing.T, db *database.DB) {+ t.Helper()++ sqlDB, err := db.DB.DB()+ require.NoError(t, err)+ require.NoError(t, sqlDB.Close())+}++func waitForSchedulerStopInternal(jobScheduler *JobScheduler) {+ <-jobScheduler.cron.Stop().Done()+}++func findJobStatusInternal(t *testing.T, jobs *jobschedule.JobListResponse, jobID string) jobschedule.JobStatus {+ t.Helper()++ for _, job := range jobs.Jobs {+ if job.ID == jobID {+ return job+ }+ }++ 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.goindex e43696d71..2fb92dcab 100644--- a/backend/pkg/scheduler/scheduler.go+++ b/backend/pkg/scheduler/scheduler.go@@ -11,17 +11,19 @@ import ()type JobScheduler struct {- // mu guards jobs, jobsByID and entryIDs. It is held across the cron+ // mu guards jobs, jobsByID, entryIDs and schedules. It is held across the cron// add/remove calls (which are themselves quick and never block on job// execution) but never across job.Run — Run executes on cron's own// goroutine, so a running job must not call back into a locking method here.- mu sync.Mutex- cron *cron.Cron- jobs []schedulertypes.Job- jobsByID map[string]schedulertypes.Job- entryIDs map[string]cron.EntryID- context context.Context- location *time.Location+ mu sync.Mutex+ cron *cron.Cron+ jobs []schedulertypes.Job+ jobsByID map[string]schedulertypes.Job+ entryIDs map[string]cron.EntryID+ schedules map[string]string+ parser cron.Parser+ context context.Context+ location *time.Location}// NewJobScheduler creates a new job scheduler with the specified timezone location.@@ -31,14 +33,17 @@ func NewJobScheduler(ctx context.Context, location *time.Location) *JobSchedulerif location == nil {location = time.UTC}+ parser := cron.NewParser(cron.Second | cron.Minute | cron.Hour | cron.Dom | cron.Month | cron.Dow | cron.Descriptor)slog.InfoContext(ctx, "Initializing job scheduler", "timezone", location.String())return &JobScheduler{- cron: cron.New(cron.WithSeconds(), cron.WithLocation(location)),- jobs: []schedulertypes.Job{},- jobsByID: make(map[string]schedulertypes.Job),- entryIDs: make(map[string]cron.EntryID),- context: ctx,- location: location,+ cron: cron.New(cron.WithParser(parser), cron.WithLocation(location)),+ jobs: []schedulertypes.Job{},+ jobsByID: make(map[string]schedulertypes.Job),+ entryIDs: make(map[string]cron.EntryID),+ schedules: make(map[string]string),+ parser: parser,+ context: ctx,+ location: location,}}@@ -58,6 +63,38 @@ func (js *JobScheduler) GetJob(jobID string) (schedulertypes.Job, bool) {return job, ok}+// GetJobRuntimeState returns the schedule currently installed for a registered job.+func (js *JobScheduler) GetJobRuntimeState(jobID string) (schedulertypes.JobRuntimeState, bool) {+ js.mu.Lock()+ defer js.mu.Unlock()++ if _, ok := js.jobsByID[jobID]; !ok {+ return schedulertypes.JobRuntimeState{}, false+ }++ state := schedulertypes.JobRuntimeState{Schedule: js.schedules[jobID]}+ entryID, ok := js.entryIDs[jobID]+ if !ok {+ return state, true+ }++ entry := js.cron.Entry(entryID)+ if entry.ID == 0 {+ return state, true+ }++ state.Scheduled = true+ nextRun := entry.Next+ if nextRun.IsZero() && entry.Schedule != nil {+ nextRun = entry.Schedule.Next(time.Now().In(js.location))+ }+ if !nextRun.IsZero() {+ state.NextRun = new(nextRun)+ }++ return state, true+}+// HasJob reports whether a job with the given name is currently registered.func (js *JobScheduler) HasJob(jobID string) bool {js.mu.Lock()@@ -69,7 +106,7 @@ func (js *JobScheduler) HasJob(jobID string) bool {func (js *JobScheduler) StartScheduler() {js.mu.Lock()for _, job := range js.jobs {- if err := js.scheduleJobInternal(js.context, job); err != nil {+ if err := js.upsertJobInternal(js.context, job); err != nil {slog.ErrorContext(js.context, "Failed to schedule job", "name", job.Name(), "error", err)}}@@ -77,10 +114,10 @@ func (js *JobScheduler) StartScheduler() {js.cron.Start()}-// AddJob registers and schedules a job at runtime. It is an idempotent upsert: if-// a job with the same name is already scheduled, its existing cron entry is-// removed first (preventing a leaked, forever-firing entry when the schedule-// changes). Safe to call before or after StartScheduler.+// AddJob registers and schedules a job at runtime. It is an idempotent upsert: a+// replacement expression is validated before the existing entry is removed, then+// the replacement is installed without leaking a second live entry.+// Safe to call before or after StartScheduler.func (js *JobScheduler) AddJob(ctx context.Context, job schedulertypes.Job) error {js.mu.Lock()defer js.mu.Unlock()@@ -98,6 +135,7 @@ func (js *JobScheduler) RemoveJob(ctx context.Context, jobName string) {delete(js.entryIDs, jobName)}delete(js.jobsByID, jobName)+ delete(js.schedules, jobName)for i, j := range js.jobs {if j.Name() == jobName {js.jobs = append(js.jobs[:i], js.jobs[i+1:]...)@@ -125,52 +163,74 @@ func (js *JobScheduler) Run(ctx context.Context) error {return nil}-// upsertJobInternal records the job and (re)schedules it. Callers must hold js.mu.+// upsertJobInternal records the job and (re)schedules it. A replacement expression+// is parsed before the previous entry is removed so invalid input leaves the last+// valid entry untouched. Callers must hold js.mu.func (js *JobScheduler) upsertJobInternal(ctx context.Context, job schedulertypes.Job) error {jobName := job.Name()- if entryID, ok := js.entryIDs[jobName]; ok {- js.cron.Remove(entryID)- delete(js.entryIDs, jobName)+ previousSchedule := js.schedules[jobName]+ previousEntryID, hadPreviousEntry := js.entryIDs[jobName]+ schedule := job.Schedule(ctx)++ shouldSchedule := true+ if conditionalJob, ok := job.(schedulertypes.ConditionalJob); ok {+ shouldSchedule = conditionalJob.ShouldSchedule(ctx)}- delete(js.jobsByID, jobName)- if err := js.scheduleJobInternal(ctx, job); err != nil {- return err+ var (+ parsedSchedule cron.Schedule+ entryID cron.EntryID+ nextRun *time.Time+ )+ if shouldSchedule {+ var err error+ parsedSchedule, err = js.parser.Parse(schedule)+ if err != nil {+ return err+ }+ } else {+ slog.DebugContext(ctx, "Job disabled; not scheduling", "name", jobName)}- js.jobsByID[jobName] = job+ if hadPreviousEntry {+ js.cron.Remove(previousEntryID)+ delete(js.entryIDs, jobName)+ }+ if shouldSchedule {+ entryID, nextRun = js.addCronEntryInternal(job, schedule, parsedSchedule)+ js.entryIDs[jobName] = entryID+ }- slog.DebugContext(ctx, "Job scheduled", "name", jobName, "scheduled", js.isJobScheduledInternal(jobName), "contextCanceled", ctx.Err() != nil)- return nil-}+ js.jobsByID[jobName] = job+ js.schedules[jobName] = schedule-// scheduleJobInternal adds the job to cron. Callers must hold js.mu. The cron-// closure runs the job with the scheduler's lifecycle context (js.context), never-// the per-call ctx — the per-call ctx may be a request context that is canceled-// once the originating handler returns, which would silently kill future fires.-func (js *JobScheduler) scheduleJobInternal(ctx context.Context, job schedulertypes.Job) error {- if conditionalJob, ok := job.(schedulertypes.ConditionalJob); ok && !conditionalJob.ShouldSchedule(ctx) {- slog.DebugContext(ctx, "Job disabled; not scheduling", "name", job.Name())- return nil+ if previousSchedule == "" && shouldSchedule {+ slog.InfoContext(ctx, "Starting Job", "name", jobName, "schedule", schedule)+ } else if previousSchedule != schedule || hadPreviousEntry != shouldSchedule {+ slog.InfoContext(ctx, "Job rescheduled", "name", jobName, "previousSchedule", previousSchedule, "newSchedule", schedule, "nextRun", nextRun)}- schedule := job.Schedule(ctx)- slog.InfoContext(ctx, "Starting Job", "name", job.Name(), "schedule", schedule)+ slog.DebugContext(ctx, "Job scheduled", "name", jobName, "scheduled", shouldSchedule, "contextCanceled", ctx.Err() != nil)+ return nil+}- entryID, err := js.cron.AddFunc(schedule, func() {+// addCronEntryInternal adds a job closure that always runs with the scheduler's+// lifecycle context. Callers must hold js.mu.+func (js *JobScheduler) addCronEntryInternal(job schedulertypes.Job, schedule string, parsedSchedule cron.Schedule) (cron.EntryID, *time.Time) {+ entryID := js.cron.Schedule(parsedSchedule, cron.FuncJob(func() {slog.InfoContext(js.context, "Job starting", "name", job.Name(), "schedule", schedule)job.Run(js.context)slog.InfoContext(js.context, "Job finished", "name", job.Name())- })- if err != nil {- return err- }+ }))- js.entryIDs[job.Name()] = entryID- return nil-}+ entry := js.cron.Entry(entryID)+ nextRun := entry.Next+ if nextRun.IsZero() && entry.Schedule != nil {+ nextRun = entry.Schedule.Next(time.Now().In(js.location))+ }+ if nextRun.IsZero() {+ return entryID, nil+ }-func (js *JobScheduler) isJobScheduledInternal(jobName string) bool {- _, ok := js.entryIDs[jobName]- return ok+ return entryID, new(nextRun)}diff --git a/backend/pkg/scheduler/scheduler_test.go b/backend/pkg/scheduler/scheduler_test.goindex 60b7bd47e..a6a405dd5 100644--- a/backend/pkg/scheduler/scheduler_test.go+++ b/backend/pkg/scheduler/scheduler_test.go@@ -201,21 +201,33 @@ func TestJobScheduler_AddJob_UpsertReplacesEntryWithoutLeaking(t *testing.T) {require.NoError(t, js.AddJob(context.Background(), job))require.Len(t, js.cron.Entries(), 1)require.NotEqual(t, firstEntry, js.entryIDs[job.Name()])++ state, ok := js.GetJobRuntimeState(job.Name())+ require.True(t, ok)+ require.True(t, state.Scheduled)+ require.Equal(t, "*/10 * * * * *", state.Schedule)+ require.NotNil(t, state.NextRun)}-func TestJobScheduler_AddJob_InvalidRescheduleClearsRegisteredState(t *testing.T) {+func TestJobScheduler_AddJob_InvalidRescheduleKeepsExistingEntry(t *testing.T) {js := NewJobScheduler(context.Background(), nil)job := &testSchedulerJob{name: "dyn-invalid-reschedule", schedule: "*/5 * * * * *"}require.NoError(t, js.AddJob(context.Background(), job))require.True(t, js.HasJob(job.Name()))require.Len(t, js.cron.Entries(), 1)+ firstEntry := js.entryIDs[job.Name()]job.schedule = "not a cron schedule"require.Error(t, js.AddJob(context.Background(), job))- require.False(t, js.HasJob(job.Name()))- require.NotContains(t, js.entryIDs, job.Name())- require.Empty(t, js.cron.Entries())+ require.True(t, js.HasJob(job.Name()))+ require.Equal(t, firstEntry, js.entryIDs[job.Name()])+ require.Len(t, js.cron.Entries(), 1)++ state, ok := js.GetJobRuntimeState(job.Name())+ require.True(t, ok)+ require.True(t, state.Scheduled)+ require.Equal(t, "*/5 * * * * *", state.Schedule)}func TestJobScheduler_RemoveJob_RemovesEntryAndIsNoopWhenAbsent(t *testing.T) {diff --git a/types/scheduler/job.go b/types/scheduler/job.goindex f35fe5541..2263d7996 100644--- a/types/scheduler/job.go+++ b/types/scheduler/job.go@@ -1,6 +1,17 @@package scheduler-import "context"+import (+ "context"+ "time"+)++// JobRuntimeState describes the schedule currently installed in a scheduler.+// It intentionally exposes only read-only state needed by job-management APIs.+type JobRuntimeState struct {+ Schedule string+ NextRun *time.Time+ Scheduled bool+}type Job interface {Name() string