Files
pages/internal/server/dregarnuhr_queue.go
T
Anya Tokugawa a36934e72c
Build and publish container images / images (push) Successful in 16m17s
Release container images / release (push) Successful in 39s
Fix event log writer contention and report persistence failures safely
Take the SQLite writer lock before reading job/policy facts, bound acquisition and cancellation, preserve atomic raw logs and counters, and avoid replaying successful business operations on logging failure. Tested the isolated nine-file release slice with the full Go suite, race tests and go vet.
2026-11-01 19:40:26 +09:00

133 lines
4.6 KiB
Go

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)
},
}
}