package server import ( "context" "database/sql" "errors" "fmt" "log" "strings" "time" "pageswiki/internal/dregarnuhr" "pageswiki/internal/store" ) // This adapter preserves SQL/storage ownership and all existing queue IDs. type schedulerQueue struct{ store *store.Store } func (q schedulerQueue) Settings(ctx context.Context) (dregarnuhr.Settings, error) { if err := ctx.Err(); err != nil { return dregarnuhr.Settings{}, err } if q.store.ReadOnly || q.store.BackgroundJobsDisabled { return dregarnuhr.Settings{Paused: true}, nil } return q.store.GetQueueSettings() } func (q schedulerQueue) Claim(ctx context.Context, now time.Time) (*dregarnuhr.Job, error) { job, err := q.store.ClaimDueEventAt(ctx, now) if errors.Is(err, sql.ErrNoRows) { return nil, dregarnuhr.ErrNoJob } return job, err } func (q schedulerQueue) Cancellation(ctx context.Context, id string) (bool, error) { return q.store.EventCancellationState(ctx, id) } func (q schedulerQueue) Started(ctx context.Context, job *dregarnuhr.Job) error { return q.store.AddEventLogContext(ctx, job.UUID, job.EventUUID, "info", "execution started") } func (q schedulerQueue) Finish(ctx context.Context, job *dregarnuhr.Job, err error, now time.Time) error { return q.store.FinishEventAt(ctx, job.UUID, err, now) } func (s *Server) eventRunner() *dregarnuhr.Runner { s.schedulerOnce.Do(func() { s.schedulerRunner = dregarnuhr.NewRunner(schedulerQueue{s.store}, s.registeredEventHandlers(), dregarnuhr.RunnerOptions{ Active: &s.schedulerRunning, Foreground: func() bool { return s.foregroundRequests.Load() > 0 }, Wake: s.wakeEventScheduler, Report: func(stage string, job *dregarnuhr.Job, err error) { if errors.Is(err, store.ErrEventCompletionLog) { stage = "finish-log" } if strings.HasSuffix(stage, "-log") { reportEventLogFailure(stage, job, err) return } if job != nil { log.Printf("component=%s event scheduler %s failed job=%s type=%s: %v", dregarnuhr.Component, stage, job.UUID, job.Type, err) } else { log.Printf("component=%s event scheduler %s failed: %v", dregarnuhr.Component, stage, err) } }, }) }) return s.schedulerRunner } // Logging failures must be visible without repeating a successful side effect // (such as push delivery), or echoing payloads, SQL text or driver messages. func (s *Server) addEventProgressLog(ctx context.Context, job *store.EventJob, message string) { if err := s.store.AddEventLogContext(ctx, job.UUID, job.EventUUID, "info", message); err != nil { reportEventLogFailure("progress-log", job, err) } } func reportEventLogFailure(stage string, job *dregarnuhr.Job, err error) { category := "storage_error" var code interface{ Code() int } switch { case errors.Is(err, context.Canceled): category = "cancelled" case errors.Is(err, context.DeadlineExceeded): category = "deadline_exceeded" case errors.Is(err, store.ErrReadOnly): category = "read_only" case errors.As(err, &code): category = fmt.Sprintf("sqlite_%d", code.Code()) } log.Printf("component=%s event scheduler %s failed job=%q type=%q reason=%s", dregarnuhr.Component, stage, job.UUID, job.Type, category) } func (s *Server) runDueEvents() { if s.store == nil { return } s.eventRunner().Dispatch(context.Background()) } func (s *Server) schedulerActivity(ctx context.Context, now time.Time) error { _, err := s.store.ExpireApprovalRequests(ctx, now.UnixMilli(), 100) // Preserve independent City processing even if approval expiry fails. s.enqueueCityActivityEvents() return err } func (s *Server) schedulerLoop() dregarnuhr.Loop { return dregarnuhr.Loop{ Every: time.Second, Wake: s.schedulerWake, OnWake: s.schedulerActivity, Triggers: []dregarnuhr.Trigger{ {Name: "initial-preview-sweep", After: 5 * time.Second, Run: func(context.Context, time.Time) error { s.enqueueAllPreviewEvents(); return nil }}, {Name: "preview-sweep", Every: 15 * time.Minute, Run: func(context.Context, time.Time) error { s.enqueueAllPreviewEvents(); return nil }}, {Name: "history-cleanup", Every: time.Hour, Run: func(context.Context, time.Time) error { settings, err := s.store.GetQueueSettings() if err != nil { return err } return s.store.PurgeEventHistory(settings.RetentionHours) }}, {Name: "activity-sweep", Every: 10 * time.Second, Run: s.schedulerActivity}, }, Step: func(ctx context.Context, now time.Time) error { _, err := s.store.EnqueueDueDefinitions(now) s.eventRunner().Dispatch(ctx) return err }, Report: func(stage string, err error) { log.Printf("component=%s event scheduler %s failed: %v", dregarnuhr.Component, stage, err) }, } }