package main import ( "context" "errors" "log" "time" ) // dueSourceClaimer is the storage slice the scheduler needs; *postgresstore.Store // satisfies it and tests can fake it without a database. type dueSourceClaimer interface { ClaimDueSourceRefreshes(ctx context.Context, now time.Time) (int, int, error) } // runSourceRefreshTick performs one dispatcher pass and logs only when work // moved, so an idle system does not spam the worker log. func runSourceRefreshTick(ctx context.Context, claimer dueSourceClaimer, now time.Time) error { claimed, enqueued, err := claimer.ClaimDueSourceRefreshes(ctx, now) if err != nil { return err } if claimed > 0 || enqueued > 0 { log.Printf("source refresh scheduler claimed=%d enqueued=%d", claimed, enqueued) } return nil } // runSourceRefreshScheduler ticks until ctx is cancelled. The FIRST tick is // deliberately delayed by one interval: startup already races ApplyMigrations // and handler registration, and a due backlog enqueue adds nothing on the // second the process comes up (the worker will drain whatever is queued anyway // once sources were scheduled before a restart). func runSourceRefreshScheduler(ctx context.Context, claimer dueSourceClaimer, interval time.Duration, onError func(error)) { if claimer == nil || interval <= 0 { return } if onError == nil { onError = func(err error) { log.Printf("source refresh scheduler error: %v", err) } } ticker := time.NewTicker(interval) defer ticker.Stop() for { select { case <-ctx.Done(): return case tick := <-ticker.C: if err := runSourceRefreshTick(ctx, claimer, tick.UTC()); err != nil && !errors.Is(err, context.Canceled) { onError(err) } } } }