diff --git a/docs/architecture/migration-decisions.md b/docs/architecture/migration-decisions.md index 0e4a4a660..326c1f348 100644 --- a/docs/architecture/migration-decisions.md +++ b/docs/architecture/migration-decisions.md @@ -264,9 +264,10 @@ around is no longer a boundary. returns and validates `workflow.ExecutionSettings`, so any package holding it links the workflow domain and therefore `internal/agentexec`. This is why the client cannot move as one package -- see open question 2. -- The schedules document, whose type is `cronstore.JobSpec` in - `internal/infrastructure`. A domain vocabulary package may not import - infrastructure. +- The schedules document, whose type is `scheduling.JobSpec` in + `internal/domain/scheduling` -- the vocabulary moved there when the legacy + file-backed cronstore was deleted, which is also what satisfies the rule + that a domain vocabulary package may not import infrastructure. - The schema derivation, which describes the documents the server advertises. **Placement as landed (2026-09-22, `archie-core-1ng1`).** One new package, diff --git a/internal/app/archied/migrate_legacy_schedules_test.go b/internal/app/archied/migrate_legacy_schedules_test.go deleted file mode 100644 index dcf35ddeb..000000000 --- a/internal/app/archied/migrate_legacy_schedules_test.go +++ /dev/null @@ -1,206 +0,0 @@ -package archied - -import ( - "encoding/json" - "log/slog" - "os" - "path/filepath" - "testing" - "time" - - "github.com/samcharles93/archie-core/internal/app/controlplane" - controlpb "github.com/samcharles93/archie-core/internal/contracts/controlplane/v1" - "github.com/samcharles93/archie-core/internal/infrastructure/cronstore" - "github.com/samcharles93/archie-core/internal/store" -) - -// migrationServer builds the validating side exactly as RunStateStore composes -// it: a store over a throwaway file and openStateStoreControlPlane, the root -// helper that registers the shared step vocabulary. -func migrationServer(t *testing.T) (*controlplane.Server, *store.Store) { - t.Helper() - st, err := store.Open(t.Context(), filepath.Join(t.TempDir(), "archie.db-tasks.sqlite")) - if err != nil { - t.Fatalf("open store: %v", err) - } - t.Cleanup(func() { _ = st.Close() }) - server, err := openStateStoreControlPlane(st) - if err != nil { - t.Fatalf("open control plane: %v", err) - } - return server, st -} - -// seedSchedules mirrors RunStateStore's ImportConfig: the schedules resource -// starts as the empty seed at version 1, which is the state the legacy -// migration runs against. -func seedSchedules(t *testing.T, control *controlplane.Server) int64 { - t.Helper() - seed, err := json.Marshal([]cronstore.JobSpec{}) - if err != nil { - t.Fatalf("encode empty schedules seed: %v", err) - } - response, err := control.Command(t.Context(), &controlpb.CommandRequest{ - Kind: controlplane.SchedulesKind, Command: "replace", ValueJson: seed, - ExpectedVersion: 0, Actor: "system:migration", Source: "legacy-config", RequestId: "import:schedules", - }) - if err != nil { - t.Fatalf("seed schedules: %v", err) - } - return response.GetResource().GetVersion() -} - -// writeLegacyJobs writes a legacy cronstore file at the layout -// migrateLegacySchedules reads: /cron/jobs.json, in the -// store's own on-disk envelope shape (schema v2). -func writeLegacyJobs(t *testing.T, dir string, jobs []cronstore.JobSpec) string { - t.Helper() - data, err := json.Marshal(struct { - SchemaVersion int `json:"schema_version"` - Jobs []cronstore.JobSpec `json:"jobs"` - }{SchemaVersion: 2, Jobs: jobs}) - if err != nil { - t.Fatalf("encode fixture: %v", err) - } - return writeLegacyFile(t, dir, string(data)) -} - -func writeLegacyFile(t *testing.T, dir, content string) string { - t.Helper() - path := filepath.Join(dir, "cron", "jobs.json") - if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil { - t.Fatalf("create legacy cron directory: %v", err) - } - if err := os.WriteFile(path, []byte(content), 0o644); err != nil { - t.Fatalf("write legacy jobs file: %v", err) - } - return path -} - -// legacyJob is a schema-v1-shaped job the old daemon's cron engine wrote. -// An empty Kind means chat, the pre-field default (cronstore.KindChat). -func legacyJob(id, kind string, interval time.Duration) cronstore.JobSpec { - stamped := time.Date(2026, 9, 1, 9, 0, 0, 0, time.UTC) - return cronstore.JobSpec{ - ID: id, Kind: kind, Detail: "legacy " + id, - Schedule: cronstore.Schedule{Kind: cronstore.ScheduleInterval, Interval: cronstore.Duration(interval)}, - NextRun: stamped, Created: stamped, Updated: stamped, - } -} - -// storedScheduleIDs decodes the schedules resource into the job IDs it holds. -func storedScheduleIDs(t *testing.T, st *store.Store) []string { - t.Helper() - resource, err := st.Resource(t.Context(), controlplane.SchedulesKind) - if err != nil { - t.Fatalf("read schedules resource: %v", err) - } - var jobs []cronstore.JobSpec - if err := json.Unmarshal(resource.Value, &jobs); err != nil { - t.Fatalf("decode schedules resource: %v", err) - } - ids := make([]string, 0, len(jobs)) - for _, job := range jobs { - ids = append(ids, job.ID) - } - return ids -} - -// TestMigrateLegacySchedulesMovesOnlyWorkflowJobs: a legacy file holding a -// chat job (the pre-field default, kind omitted) and a workflow job migrates -// the workflow job and skips -- never refuses -- the chat one. The current -// behaviour replaces the whole list and lets the schedules validator fail the -// State Store on the chat job, taking every process that dials it down with -// it (archie-core-q6vw). -func TestMigrateLegacySchedulesMovesOnlyWorkflowJobs(t *testing.T) { - dir := t.TempDir() - dbPath := filepath.Join(dir, "archie.db-tasks.sqlite") - writeLegacyJobs(t, dir, []cronstore.JobSpec{ - legacyJob("chat-daily", "", 24*time.Hour), - legacyJob("tdd-hourly", cronstore.KindWorkflow, time.Hour), - }) - server, st := migrationServer(t) - version := seedSchedules(t, server) - - migrateLegacySchedules(t.Context(), server, dbPath, version, discardLog()) - got := storedScheduleIDs(t, st) - if len(got) != 1 || got[0] != "tdd-hourly" { - t.Fatalf("schedules resource holds %v, want only the migratable workflow job", got) - } - if _, err := os.Stat(path_migrated(dir)); err != nil { - t.Fatalf("migrated legacy file not marked (jobs.json.migrated): %v", err) - } - if _, err := os.Stat(filepath.Join(dir, "cron", "jobs.json")); !os.IsNotExist(err) { - t.Fatalf("legacy file still at its original path after a successful migration") - } -} - -// path_migrated is where a completed migration leaves the legacy file. -func path_migrated(dir string) string { - return filepath.Join(dir, "cron", "jobs.json.migrated") -} - -// TestMigrateLegacySchedulesKeepsStoreRunningWhenNothingIsMigratable: a -// legacy file holding only chat jobs leaves the schedules resource untouched -// and reports -- never fails -- the skip. The store's whole job is to come up. -func TestMigrateLegacySchedulesKeepsStoreRunningWhenNothingIsMigratable(t *testing.T) { - dir := t.TempDir() - dbPath := filepath.Join(dir, "archie.db-tasks.sqlite") - path := writeLegacyJobs(t, dir, []cronstore.JobSpec{ - legacyJob("chat-daily", "", 24*time.Hour), - legacyJob("chat-weekly", "chat", 7*24*time.Hour), - }) - server, st := migrationServer(t) - version := seedSchedules(t, server) - - migrateLegacySchedules(t.Context(), server, dbPath, version, discardLog()) - if _, err := os.Stat(path); err != nil { - t.Fatalf("legacy file removed though nothing was migrated: %v", err) - } - if got := storedScheduleIDs(t, st); len(got) != 0 { - t.Fatalf("schedules resource holds %v, want the untouched empty seed", got) - } -} - -// TestMigrateLegacySchedulesKeepsStoreRunningOnUnreadableLegacyStore: a -// corrupt legacy file is a diagnosis, not a boot blocker. The store must come -// up on the empty seed and the file must stay in place for the operator. -func TestMigrateLegacySchedulesKeepsStoreRunningOnUnreadableLegacyStore(t *testing.T) { - dir := t.TempDir() - dbPath := filepath.Join(dir, "archie.db-tasks.sqlite") - path := writeLegacyFile(t, dir, "{not json") - server, _ := migrationServer(t) - version := seedSchedules(t, server) - - migrateLegacySchedules(t.Context(), server, dbPath, version, discardLog()) - if _, err := os.Stat(path); err != nil { - t.Fatalf("legacy file removed though it was never read: %v", err) - } -} - -// TestMigrateLegacySchedulesLeavesTheFileWhenTheReplaceIsRefused: even a -// workflow job the schedules validator refuses is skipped and retried on the -// next start, the way ImportConfig skips a refused seed -- never fatal. -func TestMigrateLegacySchedulesLeavesTheFileWhenTheReplaceIsRefused(t *testing.T) { - dir := t.TempDir() - dbPath := filepath.Join(dir, "archie.db-tasks.sqlite") - path := writeLegacyJobs(t, dir, []cronstore.JobSpec{ - legacyJob("broken-interval", cronstore.KindWorkflow, 0), // interval schedule with no interval - }) - server, st := migrationServer(t) - version := seedSchedules(t, server) - - migrateLegacySchedules(t.Context(), server, dbPath, version, discardLog()) - if _, err := os.Stat(path); err != nil { - t.Fatalf("legacy file removed though the replace never landed: %v", err) - } - if got := storedScheduleIDs(t, st); len(got) != 0 { - t.Fatalf("schedules resource holds %v, want the untouched empty seed", got) - } -} - -// discardLog returns a logger that drops every record: these tests pin the -// migration's effects on the resource and the file, not its reporting. -func discardLog() *slog.Logger { - return slog.New(slog.DiscardHandler) -} diff --git a/internal/app/archied/scheduling.go b/internal/app/archied/scheduling.go index 0e10eacd3..a4fa4df0e 100644 --- a/internal/app/archied/scheduling.go +++ b/internal/app/archied/scheduling.go @@ -14,7 +14,6 @@ import ( "github.com/samcharles93/archie-core/internal/infrastructure/configuration" "github.com/samcharles93/archie-core/internal/infrastructure/crondelivery" "github.com/samcharles93/archie-core/internal/infrastructure/cronevents" - "github.com/samcharles93/archie-core/internal/infrastructure/cronstore" ) // schedulingConfig translates external input into the domain-owned engine @@ -75,7 +74,7 @@ func (b *boot) setupScheduling() error { if err != nil { return fmt.Errorf("scheduling: build workflow runner: %w", err) } - router, err := crondelivery.NewRouter(store, map[string]scheduling.Runner{cronstore.KindWorkflow: workflowRunner}, cfg.Events) + router, err := crondelivery.NewRouter(store, map[string]scheduling.Runner{scheduling.KindWorkflow: workflowRunner}, cfg.Events) if err != nil { return fmt.Errorf("scheduling: build router: %w", err) } @@ -93,17 +92,27 @@ type scheduleResourceStore struct { client *controlplane.Client } -func (s scheduleResourceStore) Get(ctx context.Context, id string) (cronstore.JobSpec, bool, error) { +// The schedules document behind the control plane is the production +// RouterStore: it resolves a job id to its spec and records a completed run. +// The assertions this replaces used to pin the retired file-backed store; +// crondelivery's contract comments name this type as the implementation. +var ( + _ crondelivery.SpecLookup = scheduleResourceStore{} + _ crondelivery.RunRecorder = scheduleResourceStore{} + _ crondelivery.RouterStore = scheduleResourceStore{} +) + +func (s scheduleResourceStore) Get(ctx context.Context, id string) (scheduling.JobSpec, bool, error) { jobs, _, err := s.client.Schedules(ctx) if err != nil { - return cronstore.JobSpec{}, false, err + return scheduling.JobSpec{}, false, err } for _, job := range jobs { if job.ID == id { return job, true, nil } } - return cronstore.JobSpec{}, false, nil + return scheduling.JobSpec{}, false, nil } func (s scheduleResourceStore) Due(ctx context.Context, now time.Time) ([]scheduling.Job, error) { @@ -132,7 +141,7 @@ func (s scheduleResourceStore) MarkRun(ctx context.Context, id string, runAt tim continue } found = true - if jobs[index].Schedule.Resolved().Kind == cronstore.ScheduleOnce { + if jobs[index].Schedule.Resolved().Kind == scheduling.ScheduleOnce { jobs = append(jobs[:index], jobs[index+1:]...) break } @@ -146,7 +155,7 @@ func (s scheduleResourceStore) MarkRun(ctx context.Context, id string, runAt tim break } if !found { - return fmt.Errorf("%w: id %q", cronstore.ErrJobNotFound, id) + return fmt.Errorf("%w: id %q", scheduling.ErrJobNotFound, id) } _, err = s.client.ReplaceSchedules(ctx, jobs, version, "system:scheduler", "scheduler", fmt.Sprintf("schedule-run:%s:%d", id, runAt.UnixNano())) if err == nil { diff --git a/internal/app/archied/state_store.go b/internal/app/archied/state_store.go index 1fe82d3ef..7b6ca1498 100644 --- a/internal/app/archied/state_store.go +++ b/internal/app/archied/state_store.go @@ -13,10 +13,8 @@ import ( "context" "encoding/json" "fmt" - "log/slog" "net" "net/http" - "os" "path/filepath" "time" @@ -24,11 +22,9 @@ import ( "github.com/samcharles93/archie-core/internal/app/controlplane" "github.com/samcharles93/archie-core/internal/config" - controlpb "github.com/samcharles93/archie-core/internal/contracts/controlplane/v1" "github.com/samcharles93/archie-core/internal/domain/health" "github.com/samcharles93/archie-core/internal/domain/identity" "github.com/samcharles93/archie-core/internal/domain/storecontract" - "github.com/samcharles93/archie-core/internal/infrastructure/cronstore" "github.com/samcharles93/archie-core/internal/infrastructure/readiness" "github.com/samcharles93/archie-core/internal/infrastructure/stateadmin" "github.com/samcharles93/archie-core/internal/infrastructure/staterpc" @@ -112,12 +108,11 @@ func RunStateStore(ctx context.Context, options StateStoreOptions) error { if err != nil { return err } - versions, skipped, err := control.ImportConfig(ctx, b.cfg) + _, skipped, err := control.ImportConfig(ctx, b.cfg) if err != nil { return fmt.Errorf("import control-plane resources: %w", err) } b.reportUnseededResources(skipped) - migrateLegacySchedules(ctx, control, b.cfg.DBPath, versions[controlplane.SchedulesKind], b.log) token := options.Token if token == "" { @@ -191,81 +186,6 @@ func openStateStoreControlPlane(resources controlplane.ResourceStore) (*controlp return server, nil } -// migrateLegacySchedules carries a legacy cronstore file -- the old daemon's -// /cron/jobs.json -- into the schedules resource, once, on a fresh -// seed. It moves only the jobs the schedules resource can hold: workflow -// jobs, the one delivery the router maps. Chat and unrecognised kinds were -// already dead deliveries in the old engine (the delivery router maps -// KindWorkflow alone), so they are reported and left in the legacy file -// rather than being allowed to refuse the replace the whole store depends on. -// -// Nothing here is fatal. The migration is a legacy-data courtesy: an -// unreadable or refused sidecar is logged and left in place for the next -// start, the way ImportConfig skips a seed the resource validator refuses -- -// a value this process cannot use must not stop the one process every other -// process dials (docs/prds/runtime-control-plane.md, "Bootstrap, migration, -// and recovery"). A successful replace is marked by renaming the file to -// jobs.json.migrated, so the whole legacy list -- the skipped jobs included -// -- stays on disk for the operator; until the rename lands, the replaying -// request ID keeps the replace idempotent across restarts. -func migrateLegacySchedules(ctx context.Context, control *controlplane.Server, dbPath string, version int64, log *slog.Logger) { - if version != 1 { - return - } - path := filepath.Join(filepath.Dir(dbPath), "cron", "jobs.json") - if _, err := os.Stat(path); err != nil { - if os.IsNotExist(err) { - return - } - log.Warn("legacy cron store not readable; schedules migration skipped and retried on the next start", "path", path, "err", err) - return - } - jobs, err := readLegacyJobs(ctx, path) - if err != nil { - log.Error("legacy cron store unreadable; schedules migration skipped and retried on the next start", "path", path, "err", err) - return - } - migratable := make([]cronstore.JobSpec, 0, len(jobs)) - for _, job := range jobs { - if job.Kind == cronstore.KindWorkflow { - migratable = append(migratable, job) - continue - } - log.Warn("legacy cron job is not a workflow job; the schedules resource does not carry it and it stays in the legacy file", "id", job.ID, "kind", job.Kind) - } - if len(migratable) == 0 { - log.Info("legacy cron store holds no workflow jobs; nothing to migrate", "path", path, "jobs", len(jobs)) - return - } - value, err := json.Marshal(migratable) - if err != nil { - log.Error("encode legacy cron jobs; schedules migration skipped and retried on the next start", "path", path, "err", err) - return - } - if _, err := control.Command(ctx, &controlpb.CommandRequest{Kind: controlplane.SchedulesKind, Command: "replace", ValueJson: value, ExpectedVersion: 1, Actor: "system:migration", Source: "legacy-cronstore", RequestId: "import:legacy-schedules"}); err != nil { - log.Error("legacy cron jobs do not satisfy the schedules resource; migration skipped and retried on the next start", "path", path, "err", err) - return - } - if err := os.Rename(path, path+".migrated"); err != nil { - log.Error("mark the migrated legacy cron file; migration retried on the next start", "path", path, "err", err) - } -} - -// readLegacyJobs reads the legacy cronstore file and closes its handle, -// reporting whichever failure came first. -func readLegacyJobs(ctx context.Context, path string) ([]cronstore.JobSpec, error) { - legacy, err := cronstore.Open(path) - if err != nil { - return nil, err - } - jobs, listErr := legacy.List(ctx) - closeErr := legacy.Close() - if listErr != nil { - return nil, listErr - } - return jobs, closeErr -} - // openStateStore opens the single task-store SQLite file exactly once for // service ownership. It resolves secrets (for the binding cipher) but does // NOT open gateway chat sessions -- those live in the separate archie-gateway diff --git a/internal/app/controlplane/client.go b/internal/app/controlplane/client.go index 58b1564c1..aa411513e 100644 --- a/internal/app/controlplane/client.go +++ b/internal/app/controlplane/client.go @@ -11,9 +11,9 @@ import ( pb "github.com/samcharles93/archie-core/internal/contracts/controlplane/v1" "github.com/samcharles93/archie-core/internal/domain/agent" + "github.com/samcharles93/archie-core/internal/domain/scheduling" "github.com/samcharles93/archie-core/internal/domain/workflow" "github.com/samcharles93/archie-core/internal/infrastructure/controlplanerpc" - "github.com/samcharles93/archie-core/internal/infrastructure/cronstore" ) // Client is the control-plane client for every resource that does not resolve @@ -25,7 +25,7 @@ import ( // Client is the control-plane client a process that serves the store uses. It // embeds the Messaging Service's client -- the generic resource read path and // the channel-settings projection -- and adds the resource-specific reads and -// watches, which need the workflow and cronstore engines that such a process +// watches, which need the workflow and scheduling engines that such a process // already links (archie-core-1ng1). type Client struct { *controlplanerpc.Client @@ -213,19 +213,19 @@ func sendUpdate[T any](ctx context.Context, out chan<- T, update T) bool { } } -func (c *Client) Schedules(ctx context.Context) ([]cronstore.JobSpec, int64, error) { +func (c *Client) Schedules(ctx context.Context) ([]scheduling.JobSpec, int64, error) { response, err := c.rpc.Query(ctx, &pb.QueryRequest{Kind: SchedulesKind}) if err != nil { return nil, 0, controlplanerpc.ClientError(err) } - var jobs []cronstore.JobSpec + var jobs []scheduling.JobSpec if err := json.Unmarshal(response.Resource.ValueJson, &jobs); err != nil { return nil, 0, err } return jobs, response.Resource.Version, nil } -func (c *Client) ReplaceSchedules(ctx context.Context, jobs []cronstore.JobSpec, expectedVersion int64, actor, source, requestID string) (int64, error) { +func (c *Client) ReplaceSchedules(ctx context.Context, jobs []scheduling.JobSpec, expectedVersion int64, actor, source, requestID string) (int64, error) { value, err := json.Marshal(jobs) if err != nil { return 0, err diff --git a/internal/app/controlplane/schedules.go b/internal/app/controlplane/schedules.go index bbc0fe2ff..4e8e15e3b 100644 --- a/internal/app/controlplane/schedules.go +++ b/internal/app/controlplane/schedules.go @@ -8,7 +8,6 @@ import ( "github.com/samcharles93/archie-core/internal/config" "github.com/samcharles93/archie-core/internal/domain/scheduling" - "github.com/samcharles93/archie-core/internal/infrastructure/cronstore" ) const SchedulesKind = "schedules" @@ -17,9 +16,9 @@ func scheduleDefinition() Definition { return Definition{ Kind: SchedulesKind, Title: "Schedules", - Document: []cronstore.JobSpec{}, + Document: []scheduling.JobSpec{}, ApplyMode: "live", - Seed: func(config.Config) any { return []cronstore.JobSpec{} }, + Seed: func(config.Config) any { return []scheduling.JobSpec{} }, Validate: func(input []byte) error { return validateAs(input, validateSchedules) }, @@ -27,7 +26,7 @@ func scheduleDefinition() Definition { } } -func validateSchedules(jobs []cronstore.JobSpec) error { +func validateSchedules(jobs []scheduling.JobSpec) error { seen := make(map[string]struct{}, len(jobs)) for _, job := range jobs { if strings.TrimSpace(job.ID) == "" { @@ -37,7 +36,7 @@ func validateSchedules(jobs []cronstore.JobSpec) error { return fmt.Errorf("duplicate schedule %q", job.ID) } seen[job.ID] = struct{}{} - if job.Kind != cronstore.KindWorkflow { + if job.Kind != scheduling.KindWorkflow { return fmt.Errorf("schedule %q has unsupported kind %q", job.ID, job.Kind) } if err := job.Schedule.Validate(); err != nil { @@ -51,7 +50,7 @@ func validateSchedules(jobs []cronstore.JobSpec) error { } func normalizeSchedules(input []byte) ([]byte, error) { - var jobs []cronstore.JobSpec + var jobs []scheduling.JobSpec if err := json.Unmarshal(input, &jobs); err != nil { return nil, err } diff --git a/internal/app/controlplane/schedules_test.go b/internal/app/controlplane/schedules_test.go index 3a7d20f42..8a7ae612a 100644 --- a/internal/app/controlplane/schedules_test.go +++ b/internal/app/controlplane/schedules_test.go @@ -5,14 +5,14 @@ import ( "testing" "time" - "github.com/samcharles93/archie-core/internal/infrastructure/cronstore" + "github.com/samcharles93/archie-core/internal/domain/scheduling" ) func TestScheduleDefinitionComputesFirstRunAndRejectsDuplicateIDs(t *testing.T) { t.Parallel() definition := scheduleDefinition() - jobs := []cronstore.JobSpec{{ID: "daily", Kind: cronstore.KindWorkflow, Schedule: cronstore.Schedule{Kind: cronstore.ScheduleInterval, Interval: cronstore.Duration(time.Hour)}}} + jobs := []scheduling.JobSpec{{ID: "daily", Kind: scheduling.KindWorkflow, Schedule: scheduling.Schedule{Kind: scheduling.ScheduleInterval, Interval: scheduling.Duration(time.Hour)}}} input, err := json.Marshal(jobs) if err != nil { t.Fatal(err) @@ -21,7 +21,7 @@ func TestScheduleDefinitionComputesFirstRunAndRejectsDuplicateIDs(t *testing.T) if err != nil { t.Fatal(err) } - var normalized []cronstore.JobSpec + var normalized []scheduling.JobSpec if err := json.Unmarshal(got, &normalized); err != nil { t.Fatal(err) } diff --git a/internal/app/controlplane/schema.go b/internal/app/controlplane/schema.go index da181275f..ca28599d2 100644 --- a/internal/app/controlplane/schema.go +++ b/internal/app/controlplane/schema.go @@ -17,7 +17,7 @@ const bareObjectSchema = `{"type":"object"}` var timeType = reflect.TypeFor[time.Time]() // stdDuration is the marker this tree's string-form duration types satisfy: -// config.Duration, channelDuration and cronstore.Duration each expose the +// config.Duration, channelDuration and scheduling.Duration each expose the // standard duration for arithmetic. var stdDuration = reflect.TypeOf((*interface{ Std() time.Duration })(nil)).Elem() @@ -28,7 +28,7 @@ var stdDuration = reflect.TypeOf((*interface{ Std() time.Duration })(nil)).Elem( // stale the moment a fourth duration type appears and the failure is silent in // the worst direction: the field derives as an integer and a client renders a // number box for a duration. That is exactly what the enumerated version of this -// function did to cronstore.Duration when the schedules interval became one. +// function did to scheduling.Duration when the schedules interval became one. func durationLike(t reflect.Type) bool { if !t.Implements(stdDuration) { return false diff --git a/internal/domain/scheduling/jobspec.go b/internal/domain/scheduling/jobspec.go new file mode 100644 index 000000000..1a5da4d52 --- /dev/null +++ b/internal/domain/scheduling/jobspec.go @@ -0,0 +1,112 @@ +package scheduling + +import ( + "errors" + "time" +) + +// Kind values for JobSpec.Kind: the discriminator that decides which delivery +// runner handles a job. +// +// They live beside the field that carries them because they are part of the +// schedules vocabulary an operator writes into the schedules document, a strict +// decoder reads back, and a build that never heard of a kind must reject loudly +// rather than deliver the wrong way. Which runner serves a kind is not this +// package's business: the router in internal/infrastructure/crondelivery owns +// that mapping, which is why an unrecognised kind is stored verbatim rather +// than refused at write time. +const ( + // KindChat delivers the job's Payload.Text as a chat message through the + // deployment's channel. It is the default: an empty Kind means KindChat, + // so every job written before this field existed keeps delivering the + // way it did when it was created. + KindChat = "chat" + + // KindWorkflow submits the job as a unit of work through the work-intake + // path, so the existing task lifecycle owns scheduling, retries, gates + // and PR opening. + KindWorkflow = "workflow" +) + +// JobSpec is one scheduled job as the schedules document persists it, plus +// the bookkeeping fields the scheduler computes (NextRun, LastRun, Created, +// Updated). The wire shape is the public API; the scheduling.Job returned +// to the engine is a stripped subset. +type JobSpec struct { + // ID is the unique identifier. Required, non-empty, and the merge + // key for run recording. + ID string `json:"id"` + + // Pool is "parallel" or "sequential". Empty means sequential — the + // safer default, matching Pool.resolve(). + Pool string `json:"pool,omitempty"` + + // Detail is a human-readable label rendered on events. + Detail string `json:"detail,omitempty"` + + // Kind selects which delivery runner handles this job. Empty means + // KindChat, so a job written before this field existed keeps + // delivering as a chat message. This package does not interpret the + // value: an unrecognised kind is stored verbatim and refused by the + // delivery router, which is the one place the mapping from kind to + // runner lives. + Kind string `json:"kind,omitempty"` + + // Schedule decides when this job is due. See schedule.go for the + // supported kinds and their arithmetic. + Schedule Schedule `json:"schedule"` + + // Target and Payload describe where the job's output goes and what it + // carries. They live on the wire so jobs created ahead of the delivery + // runners that read them do not need a shape migration. + Target Target `json:"target"` + Payload Payload `json:"payload"` + + // NextRun is the absolute moment the job will next fire. Computed + // at write time so the engine's hot path is a single comparison. + NextRun time.Time `json:"next_run"` + + // LastRun is the last run time reported by the run-recording step, + // nil if the job has never run. The schedule does not know whether + // the run succeeded — that judgement belongs to the runner. + LastRun *time.Time `json:"last_run,omitempty"` + + // Created and Updated are audit metadata written by the document's + // owner; the engine does not read them. + Created time.Time `json:"created"` + Updated time.Time `json:"updated"` +} + +// Target identifies where the job's output goes. Empty Target is valid — +// the delivery runner chooses a default. +type Target struct { + // ChatID is the chat channel id (Telegram chat id, email address, + // webhook URL — depends on the channel). Empty defers to a default + // chosen by the delivery runner. + ChatID string `json:"chat_id,omitempty"` +} + +// Payload is the content sent at run time. +type Payload struct { + // Text is the literal message body. Templating is a future concern + // and is deliberately absent here. + Text string `json:"text,omitempty"` +} + +// Sentinels the schedule vocabulary and its callers match with errors.Is. +var ( + // ErrJobNotFound is returned by a job source when the requested id + // is absent from its document. + ErrJobNotFound = errors.New("scheduling: job not found") + + // ErrInvalidSpec is returned when a JobSpec or Schedule fails + // structural validation (empty id, unknown schedule kind, + // non-positive interval). + ErrInvalidSpec = errors.New("scheduling: invalid job spec") + + // ErrScheduleUnsupported is returned when a job's schedule kind + // cannot compute its next run time. Interval arithmetic is fully + // implemented; cron and once return this so callers can surface a + // clear error rather than silently advancing. + ErrScheduleUnsupported = errors.New("scheduling: schedule kind not implemented") +) diff --git a/internal/infrastructure/cronstore/schedule.go b/internal/domain/scheduling/schedule.go similarity index 99% rename from internal/infrastructure/cronstore/schedule.go rename to internal/domain/scheduling/schedule.go index f08ecfadb..25d044645 100644 --- a/internal/infrastructure/cronstore/schedule.go +++ b/internal/domain/scheduling/schedule.go @@ -1,4 +1,4 @@ -package cronstore +package scheduling import ( "encoding/json" diff --git a/internal/infrastructure/crondelivery/contract.go b/internal/infrastructure/crondelivery/contract.go index 0496c772b..a65b2dc31 100644 --- a/internal/infrastructure/crondelivery/contract.go +++ b/internal/infrastructure/crondelivery/contract.go @@ -29,24 +29,23 @@ import ( "time" "github.com/samcharles93/archie-core/internal/domain/scheduling" - "github.com/samcharles93/archie-core/internal/infrastructure/cronstore" ) // SpecLookup resolves a job id to its persisted spec. // -// It is declared here (consumer-owned) rather than imported from cronstore as -// a concrete type so this package depends on the one method it uses. -// *cronstore.Store satisfies it as written, so a deployment passes the store -// straight in. +// It is declared here (consumer-owned) rather than imported from the document's +// owner as a concrete type so this package depends on the one method it uses. +// scheduleResourceStore in internal/app/archied satisfies it as written, so a +// deployment passes that in. type SpecLookup interface { // Get returns the job and whether it was found; the error is reserved - // for I/O failures, matching cronstore.Store.Get. - Get(ctx context.Context, id string) (cronstore.JobSpec, bool, error) + // for I/O failures, matching scheduleResourceStore.Get. + Get(ctx context.Context, id string) (scheduling.JobSpec, bool, error) } // RunRecorder advances a job's schedule once a run has completed. It is // declared here (consumer-owned) for the same reason SpecLookup is, and -// *cronstore.Store satisfies it as written. +// scheduleResourceStore satisfies it as written. // // MarkRun is the only step that moves a job's NextRun, so a store whose Due // keeps reporting an already-completed job keeps handing it back on every @@ -98,20 +97,18 @@ var errSpecMissing = errors.New("crondelivery: job spec not found") // hydrate loads the job's persisted spec, wrapping both a store error and the // not-found case so a caller can match on one sentinel. -func hydrate(ctx context.Context, specs SpecLookup, job scheduling.Job) (cronstore.JobSpec, error) { +func hydrate(ctx context.Context, specs SpecLookup, job scheduling.Job) (scheduling.JobSpec, error) { spec, ok, err := specs.Get(ctx, job.ID) if err != nil { - return cronstore.JobSpec{}, fmt.Errorf("crondelivery: load job %q: %w", job.ID, err) + return scheduling.JobSpec{}, fmt.Errorf("crondelivery: load job %q: %w", job.ID, err) } if !ok { - return cronstore.JobSpec{}, fmt.Errorf("%w: id %q", errSpecMissing, job.ID) + return scheduling.JobSpec{}, fmt.Errorf("%w: id %q", errSpecMissing, job.ID) } return spec, nil } -// compile-time check: the store is the lookup a deployment hands in unchanged. -var ( - _ SpecLookup = (*cronstore.Store)(nil) - _ RunRecorder = (*cronstore.Store)(nil) - _ RouterStore = (*cronstore.Store)(nil) -) +// Compile-time check that the production store satisfies the contract. It +// lives in internal/app/archied, which imports this package, so the assertion +// is made there (scheduling.go) rather than here, where it would be an import +// cycle. diff --git a/internal/infrastructure/crondelivery/helpers_test.go b/internal/infrastructure/crondelivery/helpers_test.go index b162db762..d12791229 100644 --- a/internal/infrastructure/crondelivery/helpers_test.go +++ b/internal/infrastructure/crondelivery/helpers_test.go @@ -6,13 +6,12 @@ package crondelivery import ( "context" - "path/filepath" + "fmt" "sync" "testing" "time" "github.com/samcharles93/archie-core/internal/domain/scheduling" - "github.com/samcharles93/archie-core/internal/infrastructure/cronstore" ) // --- fakes -------------------------------------------------------------------- @@ -88,24 +87,24 @@ func (n *naiveRunner) count() int { // fakeLookup serves specs from a map and ignores ctx entirely, like // naiveCourier. // -// The cancellation tests need it because the real store is itself -// cancellation-aware: *cronstore.Store.Get returns ctx.Err() before it reads, -// so with a real store the runner's own guard is masked — hydrate fails and the -// run returns the context error whether or not the runner checked. A lookup -// that ignores ctx removes that mask, leaving the runner's guard as the only -// thing that can prevent the side effect. +// The cancellation tests need it because a production store is expected to be +// cancellation-aware: a source whose Get returns ctx.Err() before it reads +// masks the runner's own guard — hydrate fails and the run returns the context +// error whether or not the runner checked. A lookup that ignores ctx removes +// that mask, leaving the runner's guard as the only thing that can prevent the +// side effect. type fakeLookup struct { - specs map[string]cronstore.JobSpec + specs map[string]scheduling.JobSpec } -func (f *fakeLookup) Get(_ context.Context, id string) (cronstore.JobSpec, bool, error) { +func (f *fakeLookup) Get(_ context.Context, id string) (scheduling.JobSpec, bool, error) { spec, ok := f.specs[id] return spec, ok, nil } // MarkRun satisfies RouterStore. It deliberately does nothing: these tests // exercise the runner's and the router's own dispatch guards, and the record -// step is covered against the real store in +// step is covered against a store that really advances in // TestRouterAdvancesTheScheduleAfterASuccessfulRun. func (f *fakeLookup) MarkRun(_ context.Context, _ string, _ time.Time) error { return nil } @@ -247,20 +246,80 @@ func (c *countingRunner) count() int { // --- helpers ------------------------------------------------------------------ -// newStore opens a real cronstore on a temp path and closes it on cleanup. -func newStore(t *testing.T) *cronstore.Store { - t.Helper() - s, err := cronstore.Open(filepath.Join(t.TempDir(), "jobs.json")) - if err != nil { - t.Fatalf("cronstore.Open: %v", err) - } - t.Cleanup(func() { _ = s.Close() }) - return s +// memStore is the test's schedules document: a map with the three faces the +// production store shows the package — SpecLookup (Get), RunRecorder (MarkRun +// with real schedule arithmetic), and JobSource (Due). It replaces the file- +// backed store this package's fixtures used to open, which died with the +// legacy jobs.json store; the document now lives behind the control plane in +// production, and what these tests need from persistence is semantics, not a +// file. +type memStore struct { + mu sync.Mutex + jobs map[string]scheduling.JobSpec } -// createJob persists a spec through the real store and returns the scheduling -// job the engine would hand a runner for it. -func createJob(t *testing.T, s *cronstore.Store, spec cronstore.JobSpec) scheduling.Job { +func newStore(t *testing.T) *memStore { + t.Helper() + return &memStore{jobs: make(map[string]scheduling.JobSpec)} +} + +// Create persists a spec verbatim. Fixtures that want a due job set NextRun +// themselves (createJob does it when unset). +func (m *memStore) Create(_ context.Context, spec scheduling.JobSpec) error { + m.mu.Lock() + defer m.mu.Unlock() + if _, exists := m.jobs[spec.ID]; exists { + return fmt.Errorf("memStore: id %q already exists", spec.ID) + } + m.jobs[spec.ID] = spec + return nil +} + +func (m *memStore) Get(_ context.Context, id string) (scheduling.JobSpec, bool, error) { + m.mu.Lock() + defer m.mu.Unlock() + spec, ok := m.jobs[id] + return spec, ok, nil +} + +// Due returns the jobs whose NextRun is at or before now, the same contract +// the production source keeps. +func (m *memStore) Due(_ context.Context, now time.Time) ([]scheduling.Job, error) { + m.mu.Lock() + defer m.mu.Unlock() + due := make([]scheduling.Job, 0, len(m.jobs)) + for _, spec := range m.jobs { + if !spec.NextRun.After(now) { + due = append(due, scheduling.Job{ID: spec.ID, Pool: scheduling.Pool(spec.Pool), Detail: spec.Detail}) + } + } + return due, nil +} + +// MarkRun advances an interval job's NextRun the way the production +// recording step does, and reports a once schedule as unsupported — the +// sentinel the router swallows. +func (m *memStore) MarkRun(_ context.Context, id string, runAt time.Time) error { + m.mu.Lock() + defer m.mu.Unlock() + spec, ok := m.jobs[id] + if !ok { + return fmt.Errorf("%w: id %q", scheduling.ErrJobNotFound, id) + } + next, err := spec.Schedule.NextRun(runAt) + if err != nil { + return err + } + at := runAt.UTC() + spec.LastRun = &at + spec.NextRun = next + m.jobs[id] = spec + return nil +} + +// createJob persists a spec and returns the scheduling job the engine would +// hand a runner for it. +func createJob(t *testing.T, s *memStore, spec scheduling.JobSpec) scheduling.Job { t.Helper() if spec.NextRun.IsZero() { // Due now: the engine only ever hands a runner a job its source @@ -268,30 +327,30 @@ func createJob(t *testing.T, s *cronstore.Store, spec cronstore.JobSpec) schedul spec.NextRun = time.Now().UTC().Add(-time.Minute) } if err := s.Create(t.Context(), spec); err != nil { - t.Fatalf("cronstore.Create(%q): %v", spec.ID, err) + t.Fatalf("Create(%q): %v", spec.ID, err) } return scheduling.Job{ID: spec.ID, Pool: scheduling.Pool(spec.Pool), Detail: spec.Detail} } // chatSpec is a minimal chat job. -func chatSpec(id, chatID, text string) cronstore.JobSpec { - return cronstore.JobSpec{ +func chatSpec(id, chatID, text string) scheduling.JobSpec { + return scheduling.JobSpec{ ID: id, Detail: "test job " + id, - Kind: cronstore.KindChat, - Schedule: cronstore.Schedule{Kind: cronstore.ScheduleInterval, Interval: cronstore.Duration(time.Hour)}, - Target: cronstore.Target{ChatID: chatID}, - Payload: cronstore.Payload{Text: text}, + Kind: scheduling.KindChat, + Schedule: scheduling.Schedule{Kind: scheduling.ScheduleInterval, Interval: scheduling.Duration(time.Hour)}, + Target: scheduling.Target{ChatID: chatID}, + Payload: scheduling.Payload{Text: text}, } } // workflowSpec is a minimal workflow job. -func workflowSpec(id, detail, body string) cronstore.JobSpec { - return cronstore.JobSpec{ +func workflowSpec(id, detail, body string) scheduling.JobSpec { + return scheduling.JobSpec{ ID: id, Detail: detail, - Kind: cronstore.KindWorkflow, - Schedule: cronstore.Schedule{Kind: cronstore.ScheduleInterval, Interval: cronstore.Duration(time.Hour)}, - Payload: cronstore.Payload{Text: body}, + Kind: scheduling.KindWorkflow, + Schedule: scheduling.Schedule{Kind: scheduling.ScheduleInterval, Interval: scheduling.Duration(time.Hour)}, + Payload: scheduling.Payload{Text: body}, } } diff --git a/internal/infrastructure/crondelivery/router.go b/internal/infrastructure/crondelivery/router.go index d2421e8a3..fc73da673 100644 --- a/internal/infrastructure/crondelivery/router.go +++ b/internal/infrastructure/crondelivery/router.go @@ -9,7 +9,6 @@ import ( "github.com/samcharles93/archie-core/internal/domain/scheduling" "github.com/samcharles93/archie-core/internal/events" - "github.com/samcharles93/archie-core/internal/infrastructure/cronstore" ) // phaseDispatch names the step that failed on a KindJobError the Router emits. @@ -43,7 +42,7 @@ type Router struct { // emission — the router still refuses, it is just unobservable, the same // tolerance the engine has for its own nil sink. // -// An empty kind resolves to cronstore.KindChat, so a deployment only needs a +// An empty kind resolves to scheduling.KindChat, so a deployment only needs a // mapping for the kinds it actually uses. func NewRouter(specs RouterStore, runners map[string]scheduling.Runner, sink scheduling.Sink) (*Router, error) { if specs == nil { @@ -67,7 +66,7 @@ func (r *Router) Run(ctx context.Context, job scheduling.Job) error { kind := spec.Kind if kind == "" { - kind = cronstore.KindChat + kind = scheduling.KindChat } runner, ok := r.runners[kind] if !ok { @@ -86,12 +85,12 @@ func (r *Router) Run(ctx context.Context, job scheduling.Job) error { // per tick instead. // // A schedule kind with no recurring next run -- a one-shot -- reports -// cronstore.ErrScheduleUnsupported, which is the job's definition rather than a +// scheduling.ErrScheduleUnsupported, which is the job's definition rather than a // run failure, so it is swallowed. Anything else is returned: the run happened // but the bookkeeping did not, and hiding that would leave the job silently // re-firing. func (r *Router) recordRun(ctx context.Context, job scheduling.Job) error { - if err := r.specs.MarkRun(ctx, job.ID, time.Now()); err != nil && !errors.Is(err, cronstore.ErrScheduleUnsupported) { + if err := r.specs.MarkRun(ctx, job.ID, time.Now()); err != nil && !errors.Is(err, scheduling.ErrScheduleUnsupported) { return fmt.Errorf("crondelivery: record run of job %q: %w", job.ID, err) } return nil diff --git a/internal/infrastructure/crondelivery/router_test.go b/internal/infrastructure/crondelivery/router_test.go index 8f85cf4d4..63d557c6d 100644 --- a/internal/infrastructure/crondelivery/router_test.go +++ b/internal/infrastructure/crondelivery/router_test.go @@ -8,7 +8,6 @@ import ( "github.com/samcharles93/archie-core/internal/domain/scheduling" "github.com/samcharles93/archie-core/internal/events" - "github.com/samcharles93/archie-core/internal/infrastructure/cronstore" ) // --- Router ------------------------------------------------------------------- @@ -19,17 +18,17 @@ import ( func routerFixture(t *testing.T, kind string) (*Router, *countingRunner, *countingRunner, *recordingSink) { t.Helper() s := newStore(t) - createJob(t, s, cronstore.JobSpec{ + createJob(t, s, scheduling.JobSpec{ ID: "routed", Detail: "routed job", Kind: kind, - Schedule: cronstore.Schedule{Kind: cronstore.ScheduleInterval, Interval: cronstore.Duration(time.Hour)}, + Schedule: scheduling.Schedule{Kind: scheduling.ScheduleInterval, Interval: scheduling.Duration(time.Hour)}, }) chat, workflow := &countingRunner{}, &countingRunner{} sink := &recordingSink{} r, err := NewRouter(s, map[string]scheduling.Runner{ - cronstore.KindChat: chat, - cronstore.KindWorkflow: workflow, + scheduling.KindChat: chat, + scheduling.KindWorkflow: workflow, }, sink) if err != nil { t.Fatalf("NewRouter: %v", err) @@ -44,8 +43,8 @@ func TestRouterDispatchesByKind(t *testing.T) { wantChat int wantWorkflow int }{ - {"chat kind reaches the chat runner", cronstore.KindChat, 1, 0}, - {"workflow kind reaches the workflow runner", cronstore.KindWorkflow, 0, 1}, + {"chat kind reaches the chat runner", scheduling.KindChat, 1, 0}, + {"workflow kind reaches the workflow runner", scheduling.KindWorkflow, 0, 1}, {"empty kind defaults to the chat runner", "", 1, 0}, } for _, tc := range tests { @@ -117,15 +116,15 @@ func TestRouterUnknownKindIsRefusedAtTheGate(t *testing.T) { // tolerance: a nil sink disables emission without disabling the refusal. func TestRouterNilSinkDoesNotPanicOnUnknownKind(t *testing.T) { s := newStore(t) - createJob(t, s, cronstore.JobSpec{ + createJob(t, s, scheduling.JobSpec{ ID: "routed", Kind: "teleport", - Schedule: cronstore.Schedule{Kind: cronstore.ScheduleInterval, Interval: cronstore.Duration(time.Hour)}, + Schedule: scheduling.Schedule{Kind: scheduling.ScheduleInterval, Interval: scheduling.Duration(time.Hour)}, }) chat, workflow := &countingRunner{}, &countingRunner{} r, err := NewRouter(s, map[string]scheduling.Runner{ - cronstore.KindChat: chat, - cronstore.KindWorkflow: workflow, + scheduling.KindChat: chat, + scheduling.KindWorkflow: workflow, }, nil) if err != nil { t.Fatalf("NewRouter: %v", err) @@ -143,7 +142,7 @@ func TestRouterNilSinkDoesNotPanicOnUnknownKind(t *testing.T) { func TestRouterMissingSpecReturnsError(t *testing.T) { s := newStore(t) r, err := NewRouter(s, map[string]scheduling.Runner{ - cronstore.KindChat: &countingRunner{}, + scheduling.KindChat: &countingRunner{}, }, &recordingSink{}) if err != nil { t.Fatalf("NewRouter: %v", err) @@ -161,7 +160,7 @@ func TestRouterMissingSpecReturnsError(t *testing.T) { // the job the engine built, not a re-derived one: identity and pool are the // engine's, and the runner's event attribution depends on them surviving. func TestRouterPassesTheEngineJobThrough(t *testing.T) { - r, chat, _, _ := routerFixture(t, cronstore.KindChat) + r, chat, _, _ := routerFixture(t, scheduling.KindChat) job := scheduling.Job{ID: "routed", Pool: scheduling.PoolSequential, Detail: "detail from engine"} if err := r.Run(t.Context(), job); err != nil { @@ -185,7 +184,7 @@ func TestRouterPassesTheEngineJobThrough(t *testing.T) { // honours cancellation would make this pass whether or not the runner checks, // which is the failure mode the criterion exists to prevent. func TestEveryRunnerHonoursCancellation(t *testing.T) { - lookup := &fakeLookup{specs: map[string]cronstore.JobSpec{ + lookup := &fakeLookup{specs: map[string]scheduling.JobSpec{ "chat-job": chatSpec("chat-job", "ops-room", "hello"), "wf-job": workflowSpec("wf-job", "workflow job", "body"), }} @@ -204,8 +203,8 @@ func TestEveryRunnerHonoursCancellation(t *testing.T) { // router's own guard: a cancelled run must not reach the dispatch. forwarded := &naiveRunner{} router, err := NewRouter(lookup, map[string]scheduling.Runner{ - cronstore.KindChat: forwarded, - cronstore.KindWorkflow: workflow, + scheduling.KindChat: forwarded, + scheduling.KindWorkflow: workflow, }, &recordingSink{}) if err != nil { t.Fatalf("NewRouter: %v", err) @@ -246,27 +245,27 @@ func TestEveryRunnerHonoursCancellation(t *testing.T) { const dailyStatusSummary = "Daily status summary: all workers healthy, no tasks parked." // TestDailyStatusSummaryEndToEnd is the epic's headline scenario exercised -// through the whole chain a deployment uses: a real job persisted in a real -// cronstore is reported due by the store's own JobSource, handed to the router +// through the whole chain a deployment uses: a scheduled job in the schedules +// document is reported due by its own JobSource, handed to the router // the engine is given, dispatched to the chat runner, and delivered as the // composed message. func TestDailyStatusSummaryEndToEnd(t *testing.T) { s := newStore(t) const chatID = "ops-room" - spec := cronstore.JobSpec{ + spec := scheduling.JobSpec{ ID: "daily-status", Detail: "daily status summary", - Kind: cronstore.KindChat, - Schedule: cronstore.Schedule{Kind: cronstore.ScheduleInterval, Interval: cronstore.Duration(24 * time.Hour)}, - Target: cronstore.Target{ChatID: chatID}, - Payload: cronstore.Payload{Text: dailyStatusSummary}, + Kind: scheduling.KindChat, + Schedule: scheduling.Schedule{Kind: scheduling.ScheduleInterval, Interval: scheduling.Duration(24 * time.Hour)}, + Target: scheduling.Target{ChatID: chatID}, + Payload: scheduling.Payload{Text: dailyStatusSummary}, // Due now: create it with a next_run in the past, the state a // long-idle daemon wakes up to. NextRun: time.Now().UTC().Add(-time.Minute), } if err := s.Create(t.Context(), spec); err != nil { - t.Fatalf("cronstore.Create: %v", err) + t.Fatalf("Create: %v", err) } // The engine's source: the store itself, answering what is due. @@ -284,7 +283,7 @@ func TestDailyStatusSummaryEndToEnd(t *testing.T) { t.Fatalf("NewChatCourier: %v", err) } router, err := NewRouter(s, map[string]scheduling.Runner{ - cronstore.KindChat: courierRunner, + scheduling.KindChat: courierRunner, }, &recordingSink{}) if err != nil { t.Fatalf("NewRouter: %v", err) @@ -334,7 +333,7 @@ func TestConstructorsRejectNilDependencies(t *testing.T) { }}, {"Router without a spec lookup", func() error { _, err := NewRouter(nil, map[string]scheduling.Runner{ - cronstore.KindChat: &countingRunner{}, + scheduling.KindChat: &countingRunner{}, }, nil) return err }}, @@ -363,7 +362,7 @@ func TestImplementsSchedulingRunner(t *testing.T) { } // TestRouterAdvancesTheScheduleAfterASuccessfulRun is the acceptance criterion -// for a recurring job's timing: cronstore.Store.MarkRun is the only step that +// for a recurring job's timing: the recording step is the only thing that // moves a job's NextRun, and the Router is the single Runner the engine hands // every job. With no caller the store keeps reporting the job due on every // tick, so a job scheduled every hour fires once per tick instead. @@ -380,7 +379,7 @@ func TestRouterAdvancesTheScheduleAfterASuccessfulRun(t *testing.T) { } r, err := NewRouter(s, map[string]scheduling.Runner{ - cronstore.KindChat: &countingRunner{}, + scheduling.KindChat: &countingRunner{}, }, &recordingSink{}) if err != nil { t.Fatalf("NewRouter: %v", err) @@ -404,23 +403,23 @@ func TestRouterAdvancesTheScheduleAfterASuccessfulRun(t *testing.T) { // TestRouterToleratesAOnceScheduleWithoutANextRun pins the other half: a // one-shot job has no recurring next run by definition, so MarkRun reports -// cronstore.ErrScheduleUnsupported. That is not a run failure -- the job ran -- +// scheduling.ErrScheduleUnsupported. That is not a run failure -- the job ran -- // and returning it would make the engine emit KindJobError for a job that // succeeded. func TestRouterToleratesAOnceScheduleWithoutANextRun(t *testing.T) { s := newStore(t) at := time.Now().Add(-time.Hour) - job := createJob(t, s, cronstore.JobSpec{ + job := createJob(t, s, scheduling.JobSpec{ ID: "one-shot", Detail: "one-shot job", - Kind: cronstore.KindChat, - Schedule: cronstore.Schedule{Kind: cronstore.ScheduleOnce, At: &at}, - Target: cronstore.Target{ChatID: "chat-1"}, - Payload: cronstore.Payload{Text: "once"}, + Kind: scheduling.KindChat, + Schedule: scheduling.Schedule{Kind: scheduling.ScheduleOnce, At: &at}, + Target: scheduling.Target{ChatID: "chat-1"}, + Payload: scheduling.Payload{Text: "once"}, }) r, err := NewRouter(s, map[string]scheduling.Runner{ - cronstore.KindChat: &countingRunner{}, + scheduling.KindChat: &countingRunner{}, }, &recordingSink{}) if err != nil { t.Fatalf("NewRouter: %v", err) diff --git a/internal/infrastructure/crondelivery/runner_test.go b/internal/infrastructure/crondelivery/runner_test.go index 5701aac02..d7f559754 100644 --- a/internal/infrastructure/crondelivery/runner_test.go +++ b/internal/infrastructure/crondelivery/runner_test.go @@ -7,7 +7,6 @@ import ( "time" "github.com/samcharles93/archie-core/internal/domain/scheduling" - "github.com/samcharles93/archie-core/internal/infrastructure/cronstore" ) // --- ChatCourier -------------------------------------------------------------- @@ -83,7 +82,7 @@ func TestChatCourierHonoursCancellation(t *testing.T) { t.Run("cancelled before the run sends nothing", func(t *testing.T) { // Both the lookup and the courier ignore ctx, so only the // runner's own guard can stop the send. - lookup := &fakeLookup{specs: map[string]cronstore.JobSpec{ + lookup := &fakeLookup{specs: map[string]scheduling.JobSpec{ "cancel-me": chatSpec("cancel-me", "ops-room", "morning"), }} courier := &naiveCourier{} @@ -224,7 +223,7 @@ func TestWorkflowTaskHonoursCancellation(t *testing.T) { t.Run("cancelled before the run submits nothing", func(t *testing.T) { // Both the lookup and the submitter ignore ctx, so only the // runner's own guard can stop the submit. - lookup := &fakeLookup{specs: map[string]cronstore.JobSpec{ + lookup := &fakeLookup{specs: map[string]scheduling.JobSpec{ "cancel-me": workflowSpec("cancel-me", "cancel me", "body"), }} sub := &naiveSubmitter{} diff --git a/internal/infrastructure/cronstore/doc.go b/internal/infrastructure/cronstore/doc.go deleted file mode 100644 index d886acc7b..000000000 --- a/internal/infrastructure/cronstore/doc.go +++ /dev/null @@ -1,41 +0,0 @@ -// Package cronstore is the file-backed job store that backs the scheduling -// ticker engine. It is infrastructure: it owns the on-disk layout, the -// cross-process lock, and the version-stamped JSON schema. It does not own -// timing semantics — those live in internal/domain/scheduling. -// -// Two surfaces: -// -// - scheduling.JobSource: Due(ctx, now) — what the engine consumes. -// - CRUD on JobSpec — what the CLI and dashboard consume. -// -// Both share the same Store value, the same lock, and the same on-disk -// file. The engine applies no schedule arithmetic of its own; whatever -// "due" means is the store's decision, including future kinds the store -// grows into. -// -// Concurrency model: every read and write acquires an OS-level flock on a -// sibling lock file, so a CLI edit and a daemon writer cannot tear the file. -// Conflict resolution is last-writer-wins: the second writer overwrites the -// first's whole document. The lock makes that serial rather than racy. -// In-process, two Store values for the same path are serialised by a -// package-level mutex keyed by lock-file path — flock is per file -// description on Linux and would not block them otherwise. -// -// File format (versioned; bump schemaVersion on ANY shape change -// including additive ones, since DisallowUnknownFields rejects them): -// -// { -// "schema_version": 2, -// "jobs": [ JobSpec, ... ] -// } -// -// Version 2 added JobSpec.Kind, the delivery discriminator. A version-1 -// file still loads — Kind reads back empty, which the delivery router -// resolves to the chat default — so jobs created before the field existed -// keep firing the way they always did. -// -// JobSpec carries the engine-facing fields it always needed (ID, Pool, -// Detail) plus everything the store computes for it (NextRun, LastRun, -// Created, Updated). Merge semantics on Update mean a nil field in a Patch -// leaves the corresponding persisted field untouched. -package cronstore diff --git a/internal/infrastructure/cronstore/errors.go b/internal/infrastructure/cronstore/errors.go deleted file mode 100644 index 2bd7268db..000000000 --- a/internal/infrastructure/cronstore/errors.go +++ /dev/null @@ -1,39 +0,0 @@ -package cronstore - -import "errors" - -// Sentinel errors callers can match with errors.Is. -var ( - // ErrUnsupportedSchema is returned by Open when the persisted file - // declares a schema version this build does not understand. The - // store treats that as an explicit refusal to read: a forward - // version may have shape we cannot safely render back out, and - // silently downgrading would lose data. - ErrUnsupportedSchema = errors.New("cronstore: unsupported schema version") - - // ErrCorruptFile is returned by Open when the file exists but does - // not decode as a valid envelope: truncated, garbage, or fields of - // the wrong shape. The store never panics on bad input, so the - // engine can surface this as phase="source" KindJobError. - ErrCorruptFile = errors.New("cronstore: corrupt file") - - // ErrJobExists is returned by Create when the requested id is - // already present. Callers that want upsert semantics should - // follow up with Update. - ErrJobExists = errors.New("cronstore: job already exists") - - // ErrJobNotFound is returned by Get, Update and MarkRun when the - // id is absent. Delete is the exception: it is idempotent. - ErrJobNotFound = errors.New("cronstore: job not found") - - // ErrInvalidSpec is returned by Create and Update when the supplied - // JobSpec / Patch fails the store's structural validation (empty id, - // unknown schedule kind, non-positive interval). - ErrInvalidSpec = errors.New("cronstore: invalid job spec") - - // ErrScheduleUnsupported is returned by MarkRun when the job's - // schedule kind cannot compute its next run time. Slice 1 only - // knows interval arithmetic; cron / once return this so callers - // can surface a clear error rather than silently advancing. - ErrScheduleUnsupported = errors.New("cronstore: schedule kind not implemented") -) diff --git a/internal/infrastructure/cronstore/kind.go b/internal/infrastructure/cronstore/kind.go deleted file mode 100644 index 128a2e7cd..000000000 --- a/internal/infrastructure/cronstore/kind.go +++ /dev/null @@ -1,24 +0,0 @@ -package cronstore - -// Kind values for JobSpec.Kind: the discriminator that decides which delivery -// runner handles a job. -// -// They live here, beside the field that carries them, because they are part of -// the on-disk vocabulary — an operator writes one in jobs.json, the strict -// decoder reads it back, and a file written by a build that never heard of it -// must fail loudly rather than deliver the wrong way. Which runner serves a -// kind is not the store's business: the router in -// internal/infrastructure/crondelivery owns that mapping, which is why an -// unrecognised kind is left on disk rather than refused at Create. -const ( - // KindChat delivers the job's Payload.Text as a chat message through the - // deployment's channel. It is the default: an empty Kind means KindChat, - // so every job written before this field existed (schema version 1) - // keeps delivering the way it did when it was created. - KindChat = "chat" - - // KindWorkflow submits the job as a unit of work through the work-intake - // path, so the existing task lifecycle owns scheduling, retries, gates - // and PR opening. - KindWorkflow = "workflow" -) diff --git a/internal/infrastructure/cronstore/kind_test.go b/internal/infrastructure/cronstore/kind_test.go deleted file mode 100644 index e4e4d8d06..000000000 --- a/internal/infrastructure/cronstore/kind_test.go +++ /dev/null @@ -1,148 +0,0 @@ -// Tests for the JobSpec.Kind discriminator added in the cron-delivery slice. -// -// The store owns the persisted vocabulary; the runner mapping belongs to -// internal/infrastructure/crondelivery. These tests pin the store-side -// properties that mapping depends on: the field round-trips, an empty value -// reads back as the chat default, and a file written before the field existed -// still loads. -package cronstore - -import ( - "bytes" - "context" - "os" - "path/filepath" - "testing" - "time" -) - -// TestPersistedFileStampsCurrentSchemaVersion guards the additive-change rule -// documented on schemaVersion: adding Kind to JobSpec forces a version bump, -// because DisallowUnknownFields means an older build must reject a file -// carrying a field it does not know rather than silently dropping it. -func TestPersistedFileStampsCurrentSchemaVersion(t *testing.T) { - dir := t.TempDir() - path := filepath.Join(dir, "jobs.json") - s, err := Open(path) - if err != nil { - t.Fatalf("Open: %v", err) - } - defer s.Close() - mustCreate(t, s, fixedIntervalSpec("x", time.Minute)) - if err := s.Close(); err != nil { - t.Fatalf("Close: %v", err) - } - - data, err := os.ReadFile(path) - if err != nil { - t.Fatalf("ReadFile: %v", err) - } - if !bytes.Contains(data, []byte(`"schema_version":2`)) { - t.Errorf("file does not carry the bumped schema_version:2 stamp: %s", data) - } -} - -// TestKindRoundTrips pins that the discriminator survives a write and read on -// the real file, not just in memory: Create serialises it, a fresh Open with -// the strict decoder must read it back. -func TestKindRoundTrips(t *testing.T) { - dir := t.TempDir() - path := filepath.Join(dir, "jobs.json") - - s, err := Open(path) - if err != nil { - t.Fatalf("Open: %v", err) - } - spec := fixedIntervalSpec("nightly-build", time.Hour) - spec.Kind = KindWorkflow - mustCreate(t, s, spec) - if err := s.Close(); err != nil { - t.Fatalf("Close: %v", err) - } - - // A second handle proves the value is on disk and survives the strict - // decoder, rather than only living in the writer's in-memory mirror. - reopened, err := Open(path) - if err != nil { - t.Fatalf("reopen: %v", err) - } - defer reopened.Close() - - got, ok, err := reopened.Get(context.Background(), "nightly-build") - if err != nil { - t.Fatalf("Get: %v", err) - } - if !ok { - t.Fatal("Get returned ok=false after reopen") - } - if got.Kind != KindWorkflow { - t.Errorf("Kind = %q, want %q", got.Kind, KindWorkflow) - } -} - -// TestEmptyKindLoadsAsChatDefault pins the compatibility rule the router -// relies on: a job that names no kind delivers as a chat message. Asserting -// the empty string (rather than KindChat) is deliberate — the store must not -// rewrite what the operator wrote; resolving empty to "chat" is the router's -// job, and this test pins that the store hands it through untouched. -func TestEmptyKindLoadsAsChatDefault(t *testing.T) { - s := newTestStore(t) - mustCreate(t, s, fixedIntervalSpec("no-kind", time.Minute)) - - got, ok, err := s.Get(context.Background(), "no-kind") - if err != nil { - t.Fatalf("Get: %v", err) - } - if !ok { - t.Fatal("Get returned ok=false") - } - if got.Kind != "" { - t.Errorf("Kind = %q, want empty (the chat default)", got.Kind) - } -} - -// TestVersion1FileWithoutKindStillLoads is the migration guard for the schema -// bump. A file written by Slice 1 has schema_version 1 and no kind field; the -// bumped build must load it rather than rejecting it, or every existing cron -// job stops firing the moment this ships. -func TestVersion1FileWithoutKindStillLoads(t *testing.T) { - dir := t.TempDir() - path := filepath.Join(dir, "jobs.json") - past := time.Now().Add(-time.Minute).UTC().Format(time.RFC3339Nano) - contents := `{"schema_version":1,"jobs":[{"id":"legacy","pool":"sequential",` + - `"detail":"written before kind existed",` + - `"schedule":{"kind":"interval","interval":60000000000},` + - `"target":{"chat_id":"ops"},"payload":{"text":"legacy payload"},` + - `"next_run":"` + past + `","created":"` + past + `","updated":"` + past + `"}]}` - if err := os.WriteFile(path, []byte(contents), 0o600); err != nil { - t.Fatalf("WriteFile: %v", err) - } - - s, err := Open(path) - if err != nil { - t.Fatalf("Open on a version-1 file after the bump = %v, want nil", err) - } - defer s.Close() - - got, ok, err := s.Get(context.Background(), "legacy") - if err != nil { - t.Fatalf("Get: %v", err) - } - if !ok { - t.Fatal("Get returned ok=false for a version-1 job") - } - if got.Kind != "" { - t.Errorf("Kind = %q, want empty for a version-1 job", got.Kind) - } - if got.Payload.Text != "legacy payload" { - t.Errorf("Payload.Text = %q, want %q", got.Payload.Text, "legacy payload") - } - // It must still be dispatchable: the engine reads due jobs through Due. - due, err := s.Due(context.Background(), time.Now()) - if err != nil { - t.Fatalf("Due: %v", err) - } - if len(due) != 1 || due[0].ID != "legacy" { - t.Errorf("Due on a version-1 file = %+v, want the legacy job", due) - } -} diff --git a/internal/infrastructure/cronstore/lock_unix.go b/internal/infrastructure/cronstore/lock_unix.go deleted file mode 100644 index d2734da9d..000000000 --- a/internal/infrastructure/cronstore/lock_unix.go +++ /dev/null @@ -1,68 +0,0 @@ -//go:build unix - -package cronstore - -import ( - "fmt" - "os" - "syscall" -) - -// lockedFile is an OS-level flock wrapper around a sidecar file. The -// store acquires it before reading or writing the JSON, so a CLI edit -// and a daemon writer cannot tear the same jobs.json. -// -// flock is per-open-file-description, which means a single Store holds -// the lock for as long as it lives; concurrent processes opening the -// same sidecar queue behind it. -type lockedFile struct { - f *os.File -} - -// openLock creates (or opens) the lock file and returns it unlocked. -// The lock is acquired separately via Lock, so Open can hydrate without -// holding it. -func openLock(path string) (*lockedFile, error) { - f, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE, 0o644) - if err != nil { - return nil, fmt.Errorf("open lock file %s: %w", path, err) - } - return &lockedFile{f: f}, nil -} - -// Lock blocks until the OS-level exclusive flock is acquired. flock is -// reentrant on Linux per-fd, so calling Lock twice on the same lockedFile -// from the same goroutine is fine; calling it from two goroutines still -// serialises. -func (l *lockedFile) Lock() error { - if l == nil || l.f == nil { - return fmt.Errorf("cronstore: lock not initialised") - } - if err := syscall.Flock(int(l.f.Fd()), syscall.LOCK_EX); err != nil { - return fmt.Errorf("flock LOCK_EX: %w", err) - } - return nil -} - -// Unlock releases the exclusive flock. Idempotent in the sense that a -// second call after Close simply returns nil because the fd is closed. -func (l *lockedFile) Unlock() error { - if l == nil || l.f == nil { - return nil - } - if err := syscall.Flock(int(l.f.Fd()), syscall.LOCK_UN); err != nil { - return fmt.Errorf("flock LOCK_UN: %w", err) - } - return nil -} - -// Close closes the sidecar fd. The flock is released automatically by -// the kernel. -func (l *lockedFile) Close() error { - if l == nil || l.f == nil { - return nil - } - err := l.f.Close() - l.f = nil - return err -} diff --git a/internal/infrastructure/cronstore/lock_windows.go b/internal/infrastructure/cronstore/lock_windows.go deleted file mode 100644 index 823db691e..000000000 --- a/internal/infrastructure/cronstore/lock_windows.go +++ /dev/null @@ -1,53 +0,0 @@ -//go:build windows - -// flock is a POSIX primitive; Windows does not implement syscall.Flock -// the same way. Windows deployments of archied are not the supported -// surface (the deployment model in CLAUDE.md and deployments/*.toml is -// Linux + macOS), so this file deliberately fails closed: every Lock -// returns an error rather than silently degrading to "no lock". -// -// If a Windows deployment ever becomes supported, swap this for a real -// LockFileEx / UnlockFileEx implementation; the rest of the store does -// not need to change. - -package cronstore - -import ( - "errors" - "fmt" - "os" -) - -// lockedFile is a stub on Windows. The store still opens the sidecar -// file so the on-disk layout matches across platforms, but every Lock -// returns an explicit error. -type lockedFile struct { - f *os.File -} - -func openLock(path string) (*lockedFile, error) { - f, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE, 0o644) - if err != nil { - return nil, fmt.Errorf("open lock file %s: %w", path, err) - } - return &lockedFile{f: f}, nil -} - -// errLockUnsupported is wrapped in every Lock call so callers can match -// on it without parsing strings. -var errLockUnsupported = errors.New("cronstore: cross-process locking is unsupported on Windows") - -func (l *lockedFile) Lock() error { return errLockUnsupported } -func (l *lockedFile) Unlock() error { return nil } - -func (l *lockedFile) Close() error { - if l == nil || l.f == nil { - return nil - } - err := l.f.Close() - l.f = nil - return err -} - -// Keep imports alive when this file is built in isolation. -var _ = fmt.Sprintf diff --git a/internal/infrastructure/cronstore/process_lock.go b/internal/infrastructure/cronstore/process_lock.go deleted file mode 100644 index 49558d281..000000000 --- a/internal/infrastructure/cronstore/process_lock.go +++ /dev/null @@ -1,33 +0,0 @@ -package cronstore - -import "sync" - -// processLocks serialises Stores within one process. It exists because -// Linux flock is per file description, not per inode: two Store -// instances opening the same jobs.json.lock each get their own fd and -// their own independent flock state, so they would not block each -// other inside a single process. The cross-process lock handles the -// CLI-vs-daemon case; this map handles the in-process case. -// -// Keyed by absolute lock-file path so two unrelated cronstores in the -// same process do not contend. Entries are created lazily and live for -// the life of the process; the map is append-only and small in -// practice (one entry per distinct config dir). -var ( - processLocksMu sync.Mutex - processLocks = map[string]*sync.Mutex{} -) - -// processLockFor returns the per-lock-path mutex, creating it on first -// use. Callers must hold it for the duration of an operation that has -// already acquired the cross-process flock. -func processLockFor(path string) *sync.Mutex { - processLocksMu.Lock() - defer processLocksMu.Unlock() - if m, ok := processLocks[path]; ok { - return m - } - m := &sync.Mutex{} - processLocks[path] = m - return m -} diff --git a/internal/infrastructure/cronstore/schedule_duration_test.go b/internal/infrastructure/cronstore/schedule_duration_test.go deleted file mode 100644 index c1457c685..000000000 --- a/internal/infrastructure/cronstore/schedule_duration_test.go +++ /dev/null @@ -1,91 +0,0 @@ -package cronstore - -import ( - "encoding/json" - "strings" - "testing" - "time" -) - -// TestScheduleIntervalWritesADurationString pins the document form: the interval -// an operator edits must read as a duration, not as the nanosecond count that -// asked them to type 1800000000000. -func TestScheduleIntervalWritesADurationString(t *testing.T) { - encoded, err := json.Marshal(Schedule{Kind: ScheduleInterval, Interval: Duration(30 * time.Minute)}) - if err != nil { - t.Fatalf("marshal: %v", err) - } - if got := string(encoded); !strings.Contains(got, `"interval":"30m0s"`) { - t.Errorf("marshalled schedule = %s, want interval as the string \"30m0s\"", got) - } - if strings.Contains(string(encoded), "1800000000000") { - t.Errorf("marshalled schedule = %s, want no nanosecond count", encoded) - } -} - -// TestScheduleIntervalReadsEveryStoredForm covers what the store already holds. -// Every schedule written before this shape existed carries a nanosecond count, in -// both the control plane's schedules resource and this package's own jobs table, -// and both have to keep working without being re-saved first. -func TestScheduleIntervalReadsEveryStoredForm(t *testing.T) { - for _, tt := range []struct { - name string - document string - expected time.Duration - }{ - {"legacy nanosecond count", `{"kind":"interval","interval":1800000000000}`, 30 * time.Minute}, - {"duration string", `{"kind":"interval","interval":"30m"}`, 30 * time.Minute}, - {"duration string, canonical", `{"kind":"interval","interval":"30m0s"}`, 30 * time.Minute}, - } { - t.Run(tt.name, func(t *testing.T) { - var schedule Schedule - if err := json.Unmarshal([]byte(tt.document), &schedule); err != nil { - t.Fatalf("unmarshal %s: %v", tt.document, err) - } - if schedule.Interval.Std() != tt.expected { - t.Errorf("Interval = %v, want %v", schedule.Interval, tt.expected) - } - if err := schedule.Validate(); err != nil { - t.Errorf("Validate() = %v, want the decoded schedule to be usable", err) - } - }) - } -} - -// TestScheduleIntervalRefusesWhatItCannotUse keeps the tolerance above from -// becoming indifference: a duration that does not parse must fail loudly rather -// than decode as zero, because a zero interval is a job that never fires. -func TestScheduleIntervalRefusesWhatItCannotUse(t *testing.T) { - for _, tt := range []struct{ name, document string }{ - {"an unparseable duration", `{"kind":"interval","interval":"soon"}`}, - {"a fractional count", `{"kind":"interval","interval":1.5}`}, - {"a null interval", `{"kind":"interval","interval":null}`}, - } { - t.Run(tt.name, func(t *testing.T) { - var schedule Schedule - if err := json.Unmarshal([]byte(tt.document), &schedule); err == nil { - t.Fatalf("unmarshal(%s) = nil, want a refusal: a silent zero interval never fires", tt.document) - } - }) - } -} - -// TestScheduleIntervalRoundTripsThroughTheStore pins the shape the jobs table -// keeps, since it persists the spec as JSON rather than as columns. -func TestScheduleIntervalRoundTripsThroughTheStore(t *testing.T) { - spec := JobSpec{ID: "nightly", Schedule: Schedule{Kind: ScheduleInterval, Interval: Duration(90 * time.Minute)}} - encoded, err := json.Marshal(spec) - if err != nil { - t.Fatalf("marshal: %v", err) - } - if !strings.Contains(string(encoded), `"interval":"1h30m0s"`) { - t.Fatalf("marshalled spec = %s, want the interval as \"1h30m0s\"", encoded) - } - var decoded JobSpec - if err := json.Unmarshal(encoded, &decoded); err != nil { - t.Fatalf("unmarshal: %v", err) - } - if decoded.Schedule.Interval.Std() != 90*time.Minute { - t.Errorf("round-tripped Interval = %v, want 1h30m0s", decoded.Schedule.Interval) - } -} diff --git a/internal/infrastructure/cronstore/store.go b/internal/infrastructure/cronstore/store.go deleted file mode 100644 index 89df661ed..000000000 --- a/internal/infrastructure/cronstore/store.go +++ /dev/null @@ -1,665 +0,0 @@ -package cronstore - -import ( - "bytes" - "context" - "encoding/json" - "errors" - "fmt" - "io/fs" - "os" - "path/filepath" - "strings" - "sync" - "sync/atomic" - "time" - - "github.com/samcharles93/archie-core/internal/domain/scheduling" -) - -// schemaVersion is stamped on every persisted file. Bump it on any -// breaking change to JobSpec, Schedule, Payload or envelope shape, AND -// on any additive change: DisallowUnknownFields means a future build -// that adds a new field to JobSpec must also bump schemaVersion so -// older builds keep rejecting the file rather than silently dropping -// the new field. -const schemaVersion = 2 - -// filePerm is the mode applied to the jobs.json file on write. Payloads -// and chat ids can carry operator-identifying information, so 0o600 is -// the default; operators who want it group-readable can chmod after. -const filePerm = 0o600 - -// JobSpec is one persisted cron job as the engine's view sees it, plus -// the bookkeeping fields the store computes (NextRun, LastRun, Created, -// Updated). The wire shape is the public API; the scheduling.Job returned -// to the engine is a stripped subset. -type JobSpec struct { - // ID is the unique identifier. Required, non-empty, and the merge - // key for Update and MarkRun. - ID string `json:"id"` - - // Pool is "parallel" or "sequential". Empty means sequential — the - // safer default, matching scheduling.Pool.resolve(). - Pool string `json:"pool,omitempty"` - - // Detail is a human-readable label rendered on events. - Detail string `json:"detail,omitempty"` - - // Kind selects which delivery runner handles this job. Empty means - // KindChat, so a job written before this field existed (schema - // version 1) keeps delivering as a chat message. The store does not - // interpret the value: an unrecognised kind is persisted verbatim and - // refused by the delivery router, which is the one place the mapping - // from kind to runner lives. - Kind string `json:"kind,omitempty"` - - // Schedule decides when this job is due. See schedule.go for the - // supported kinds and their arithmetic. - Schedule Schedule `json:"schedule"` - - // Target and Payload are placeholders for Slice 2 (delivery runner). - // They live on the wire now so jobs created ahead of Slice 2 do not - // need a schema migration when delivery lands. - Target Target `json:"target"` - Payload Payload `json:"payload"` - - // NextRun is the absolute moment the job will next fire. Computed - // at write time so the engine's hot path is a single comparison. - NextRun time.Time `json:"next_run"` - - // LastRun is the last run time reported by MarkRun, nil if the job - // has never run. Mutated only by MarkRun. The store does not know - // whether the run succeeded — that judgement belongs to the runner. - LastRun *time.Time `json:"last_run,omitempty"` - - // Created and Updated are stamped by Create / Update respectively. - // They are audit metadata; the engine does not read them. - Created time.Time `json:"created"` - Updated time.Time `json:"updated"` -} - -// Target identifies where the job's output goes (Slice 2 fills this in). -// Empty Target is valid — Slice 1 stores the field but no consumer reads -// it yet. -type Target struct { - // ChatID is the chat channel id (Telegram chat id, email address, - // webhook URL — depends on the channel). Empty defers to a default - // chosen by the delivery runner. - ChatID string `json:"chat_id,omitempty"` -} - -// Payload is the content sent at run time. Slice 2 fills this in; Slice 1 -// stores the text verbatim so the engine does not need to know about it. -type Payload struct { - // Text is the literal message body. Templating (cron blueprints) is - // a Slice 3 concern and is deliberately absent here. - Text string `json:"text,omitempty"` -} - -// Patch is the partial JobSpec Update merges over the existing record. A -// nil pointer field leaves the corresponding persisted field untouched; -// the non-nil pointer or non-zero value overwrites it. -// -// Schedule is replaced wholesale when the Patch's Schedule pointer is -// non-nil — schedules are not deep-merged, because each field of -// Schedule carries semantics (Kind, Interval, Cron, At) that have no -// meaningful "preserve" answer on their own. -type Patch struct { - Pool *string `json:"pool,omitempty"` - Detail *string `json:"detail,omitempty"` - Schedule *Schedule `json:"schedule,omitempty"` - Target *Target `json:"target,omitempty"` - Payload *Payload `json:"payload,omitempty"` -} - -// envelope is the on-disk shape. Kept private so the only public surface -// is JobSpec / Patch. -type envelope struct { - SchemaVersion int `json:"schema_version"` - Jobs []JobSpec `json:"jobs"` -} - -// Store is one open handle to the job file. It is safe for concurrent -// callers in the same process, and safe against concurrent CLI / daemon -// processes through the cross-process lock. -// -// All exported methods take a context for cancellation; reads and writes -// are short, so the ctx is plumbed through but rarely observed. -// -// After Close, every other method returns ErrClosed. Close itself is -// safe to call multiple times. -type Store struct { - path string // jobs.json - lock *lockedFile - - // closed is set by Close so concurrent callers fail fast rather than - // dereferencing a closed lock fd. - closed atomic.Bool - - // mu guards the in-memory copy that mirrors the file. Acquire it - // before reading or writing jobs; the cross-process lock guards - // the file itself. They must always be taken in the same order: - // cross-process lock first, then mu. - mu sync.Mutex - buf []JobSpec // in-memory mirror of the on-disk jobs array -} - -// ErrClosed is returned by every method after Close. It lets callers -// distinguish "I gave up" from a real error. -var ErrClosed = errors.New("cronstore: store is closed") - -// Open constructs a Store for the given jobs.json path. The file is -// created lazily on first write, but the parent directory is created -// immediately so a subsequent Create does not race against mkdir. -// -// Open validates the persisted file's schema version: a future version -// the build does not know returns ErrUnsupportedSchema rather than a -// silent best-effort decode. A corrupt or truncated file returns -// ErrCorruptFile. -func Open(path string) (*Store, error) { - if path == "" { - return nil, fmt.Errorf("%w: path must be non-empty", ErrInvalidSpec) - } - if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil { - return nil, fmt.Errorf("cronstore: create parent directory: %w", err) - } - lock, err := openLock(path + ".lock") - if err != nil { - return nil, fmt.Errorf("cronstore: open lock: %w", err) - } - - s := &Store{ - path: path, - lock: lock, - } - - // Best-effort hydrate. An absent file is fine: the store will - // materialise it on first Create. - if err := s.hydrate(); err != nil { - _ = lock.Close() - return nil, err - } - return s, nil -} - -// Path returns the file the store reads and writes. Exposed for -// diagnostics and for the CLI to print the location it is editing. -func (s *Store) Path() string { return s.path } - -// Close releases the cross-process lock. After Close, every other -// method returns ErrClosed. Close is safe to call more than once. -func (s *Store) Close() error { - if !s.closed.CompareAndSwap(false, true) { - return nil - } - if s.lock == nil { - return nil - } - err := s.lock.Close() - s.lock = nil - return err -} - -// checkOpen returns ErrClosed when the store has been closed. Every -// public method calls this first so a Close mid-operation surfaces as a -// real error rather than a panic on a nil lock fd. -func (s *Store) checkOpen() error { - if s.closed.Load() { - return ErrClosed - } - return nil -} - -// Create adds a new job. Fails with ErrJobExists on a duplicate id, with -// ErrInvalidSpec on a structurally invalid spec. The store stamps -// Created / Updated to now and computes NextRun from the schedule. -func (s *Store) Create(ctx context.Context, spec JobSpec) error { - if err := ctx.Err(); err != nil { - return err - } - if err := s.checkOpen(); err != nil { - return err - } - if strings.TrimSpace(spec.ID) == "" { - return fmt.Errorf("%w: id must be non-empty", ErrInvalidSpec) - } - if err := spec.Schedule.Validate(); err != nil { - return err - } - if err := scheduling.Pool(spec.Pool).Validate(); err != nil { - return err - } - - if err := s.withLock(func() error { - for _, existing := range s.buf { - if existing.ID == spec.ID { - return fmt.Errorf("%w: id %q", ErrJobExists, spec.ID) - } - } - - now := time.Now().UTC() - // Honor a caller-supplied NextRun when present: the test suite - // needs to set up past/future due states deterministically, and - // the CLI may want to schedule a one-off for a specific time. - // Zero NextRun falls back to the schedule's first-run arithmetic. - if spec.NextRun.IsZero() { - next, err := spec.Schedule.firstRun(now) - if err != nil { - return err - } - spec.NextRun = next.UTC() - } - spec.Created = now - spec.Updated = now - spec.Schedule = spec.Schedule.resolve() - s.buf = append(s.buf, spec) - return s.writeLocked() - }); err != nil { - return err - } - return nil -} - -// Get returns the job by id. The second return value is false when the -// id is absent; the error is reserved for I/O failures. The returned -// JobSpec is a deep copy: callers can mutate LastRun and other fields -// without disturbing the store's in-memory mirror. -func (s *Store) Get(ctx context.Context, id string) (JobSpec, bool, error) { - if err := ctx.Err(); err != nil { - return JobSpec{}, false, err - } - if err := s.checkOpen(); err != nil { - return JobSpec{}, false, err - } - var ( - got JobSpec - ok bool - ) - err := s.withLock(func() error { - for _, j := range s.buf { - if j.ID == id { - got = deepCopyJob(j) - ok = true - return nil - } - } - return nil - }) - return got, ok, err -} - -// List returns a copy of every persisted job. Order is the on-disk -// order, which is also the creation order. Callers may mutate the -// returned slice and its elements without disturbing the store's -// in-memory mirror. -func (s *Store) List(ctx context.Context) ([]JobSpec, error) { - if err := ctx.Err(); err != nil { - return nil, err - } - if err := s.checkOpen(); err != nil { - return nil, err - } - var out []JobSpec - err := s.withLock(func() error { - out = make([]JobSpec, len(s.buf)) - for i := range s.buf { - out[i] = deepCopyJob(s.buf[i]) - } - return nil - }) - return out, err -} - -// Update applies a Patch over the existing record. Fields the Patch -// leaves nil are preserved verbatim; non-nil pointers and the Schedule -// are wholesale replacements. Schedule changes trigger a NextRun -// recomputation, since NextRun is derived from Schedule and LastRun. -// -// Returns ErrJobNotFound when the id is absent. -func (s *Store) Update(ctx context.Context, id string, patch Patch) error { - if err := ctx.Err(); err != nil { - return err - } - if err := s.checkOpen(); err != nil { - return err - } - if id == "" { - return fmt.Errorf("%w: id must be non-empty", ErrInvalidSpec) - } - if patch.Pool != nil { - if err := scheduling.Pool(*patch.Pool).Validate(); err != nil { - return err - } - } - if patch.Schedule != nil { - if err := patch.Schedule.Validate(); err != nil { - return err - } - } - return s.withLock(func() error { - for i := range s.buf { - if s.buf[i].ID != id { - continue - } - if err := applyPatch(&s.buf[i], patch); err != nil { - return err - } - s.buf[i].Updated = time.Now().UTC() - return s.writeLocked() - } - return fmt.Errorf("%w: id %q", ErrJobNotFound, id) - }) -} - -// applyPatch overwrites record's non-nil Patch fields in place, recomputing -// NextRun when Schedule changes. -func applyPatch(record *JobSpec, patch Patch) error { - if patch.Pool != nil { - record.Pool = *patch.Pool - } - if patch.Detail != nil { - record.Detail = *patch.Detail - } - if patch.Schedule != nil { - if err := applyScheduleChange(record, patch.Schedule); err != nil { - return err - } - } - if patch.Target != nil { - record.Target = *patch.Target - } - if patch.Payload != nil { - record.Payload = *patch.Payload - } - return nil -} - -// applyScheduleChange sets record's Schedule and recomputes NextRun, which -// is stale once Schedule changes. Recomputed from the last run if there is -// one, else as a first run from now — keeping it strictly future-of-now -// would re-fire a job the operator just shortened. -func applyScheduleChange(record *JobSpec, schedule *Schedule) error { - record.Schedule = schedule.resolve() - var next time.Time - var err error - if record.LastRun != nil { - next, err = record.Schedule.nextRun(*record.LastRun) - } else { - next, err = record.Schedule.firstRun(time.Now().UTC()) - } - if err != nil { - return err - } - record.NextRun = next.UTC() - return nil -} - -// Delete removes the job by id. Idempotent: deleting a missing id -// returns nil rather than ErrJobNotFound, so a CLI retry after a -// partial failure cannot stall the operator. -func (s *Store) Delete(ctx context.Context, id string) error { - if err := ctx.Err(); err != nil { - return err - } - if err := s.checkOpen(); err != nil { - return err - } - if id == "" { - return fmt.Errorf("%w: id must be non-empty", ErrInvalidSpec) - } - return s.withLock(func() error { - for i := range s.buf { - if s.buf[i].ID != id { - continue - } - s.buf = append(s.buf[:i], s.buf[i+1:]...) - return s.writeLocked() - } - return nil - }) -} - -// MarkRun records that id ran at runAt and advances NextRun to the -// schedule's next firing. It is the engine-side counterpart to Create: -// once the ticker has dispatched a job, the runner (or the engine -// itself, in tests) calls MarkRun to keep next_run fresh. -// -// Returns ErrJobNotFound when the id is absent and -// ErrScheduleUnsupported when the schedule kind has no defined -// "next after this run" semantics. -func (s *Store) MarkRun(ctx context.Context, id string, runAt time.Time) error { - if err := ctx.Err(); err != nil { - return err - } - if err := s.checkOpen(); err != nil { - return err - } - if id == "" { - return fmt.Errorf("%w: id must be non-empty", ErrInvalidSpec) - } - return s.withLock(func() error { - for i := range s.buf { - if s.buf[i].ID != id { - continue - } - next, err := s.buf[i].Schedule.nextRun(runAt) - if err != nil { - return err - } - t := runAt.UTC() - s.buf[i].LastRun = &t - s.buf[i].NextRun = next.UTC() - s.buf[i].Updated = time.Now().UTC() - return s.writeLocked() - } - return fmt.Errorf("%w: id %q", ErrJobNotFound, id) - }) -} - -// Due implements scheduling.JobSource. It returns the jobs whose -// NextRun is at or before now, in creation order. The returned -// scheduling.Job is the engine's projection of the persisted JobSpec: -// only the fields the engine relies on (ID, Pool, Detail) cross the -// boundary. Schedule / Payload / Target are deliberately not exposed: -// the engine does no arithmetic on them and has no business knowing -// they exist. -// -// A job with an unrecognised pool is skipped: Create / Update enforce -// the set, but a file edited by hand could carry an invalid value, and -// the engine cannot reason about a pool it has never heard of. The -// store does not crash on bad input — the same way it does not panic -// on a truncated file. -func (s *Store) Due(ctx context.Context, now time.Time) ([]scheduling.Job, error) { - if err := ctx.Err(); err != nil { - return nil, err - } - if err := s.checkOpen(); err != nil { - return nil, err - } - var due []scheduling.Job - err := s.withLock(func() error { - for _, j := range s.buf { - if j.NextRun.After(now) { - continue - } - pool := scheduling.Pool(j.Pool) - if err := pool.Validate(); err != nil { - continue - } - due = append(due, scheduling.Job{ - ID: j.ID, - Pool: pool, - Detail: j.Detail, - }) - } - return nil - }) - return due, err -} - -// withLock serialises access to the file. Callers receive a closure -// that runs with the cross-process lock held and the in-memory buffer -// freshly hydrated from disk; the closure's return value becomes -// withLock's return value. -// -// Three locks stack, always in this order: -// -// 1. processMu: keyed by lock-file path. Serialises every Store that -// points at the same jobs.json within one process. Necessary -// because Linux flock is per file description: two Store instances -// in the same process have independent fds and would otherwise -// proceed in parallel. fcntl / POSIX locks would not have this -// property — they would block — but flock is the documented -// primitive on Linux + macOS, so we compensate at this layer. -// 2. cross-process flock: serialises Store instances across -// processes (CLI vs daemon). flock alone is insufficient for -// in-process coordination (see #1). -// 3. s.mu: guards s.buf against same-Store concurrent goroutines. -// Redundant under #1 + #2 but cheap, and it documents the -// invariant for any reader trying to follow the locking story. -// -// After all three are held, the in-memory buffer is re-read from disk -// so a writer that just acquired the locks sees every change the -// previous writer committed. Without this, a Store that opened before -// any writes happened would carry an empty view forever and silently -// overwrite everything. -// -// Re-reading on every operation is acceptable for cron workloads: the -// file holds O(dozens) of jobs, not O(thousands), and operations are -// human-paced, not high-throughput. -func (s *Store) withLock(fn func() error) error { - processMu := processLockFor(s.path + ".lock") - processMu.Lock() - defer processMu.Unlock() - - if s.closed.Load() { - return ErrClosed - } - if err := s.lock.Lock(); err != nil { - return fmt.Errorf("cronstore: acquire lock: %w", err) - } - defer func() { _ = s.lock.Unlock() }() - - s.mu.Lock() - defer s.mu.Unlock() - - if err := s.hydrate(); err != nil { - return err - } - return fn() -} - -// hydrate reads the file into the in-memory buffer. Called from Open -// (no lock needed; nothing else can see the Store yet) and from -// withLock (with both locks held). -func (s *Store) hydrate() error { - data, err := os.ReadFile(s.path) - if err != nil { - if errors.Is(err, fs.ErrNotExist) { - return nil - } - return fmt.Errorf("%w: read %s: %w", ErrCorruptFile, s.path, err) - } - if len(bytes.TrimSpace(data)) == 0 { - return nil - } - var env envelope - dec := json.NewDecoder(bytes.NewReader(data)) - // Reject unknown fields so a typo on the operator's side does not - // silently land in a future field and shadow a real value. The - // cost is that any additive change to JobSpec MUST bump - // schemaVersion — see the comment on that constant. - dec.DisallowUnknownFields() - if err := dec.Decode(&env); err != nil { - return fmt.Errorf("%w: decode %s: %w", ErrCorruptFile, s.path, err) - } - if env.SchemaVersion == 0 { - return fmt.Errorf("%w: missing schema_version in %s", ErrCorruptFile, s.path) - } - if env.SchemaVersion > schemaVersion { - return fmt.Errorf("%w: file is version %d, this build understands up to %d", - ErrUnsupportedSchema, env.SchemaVersion, schemaVersion) - } - s.buf = env.Jobs - return nil -} - -// writeLocked persists the in-memory buffer to the file. Must be called -// with s.mu held and the cross-process lock held — both guarantees -// follow from withLock. Atomic write via temp-file + rename, so a -// crash mid-write leaves the previous file intact rather than a -// truncated mess the next Open would have to clean up. -func (s *Store) writeLocked() error { - env := envelope{ - SchemaVersion: schemaVersion, - Jobs: s.buf, - } - var buf bytes.Buffer - enc := json.NewEncoder(&buf) - // operator-readable file: do not escape <, >, &. The default - // encoding/json behaviour writes these as < etc, which is - // round-trip-safe but unreadable when a human opens jobs.json to - // understand why a job failed to fire. - enc.SetEscapeHTML(false) - if err := enc.Encode(env); err != nil { - return fmt.Errorf("cronstore: encode: %w", err) - } - if err := atomicWriteFile(s.path, buf.Bytes(), filePerm); err != nil { - return fmt.Errorf("cronstore: write %s: %w", s.path, err) - } - return nil -} - -// atomicWriteFile writes data to path via a sibling temp file and -// rename. Rename within a single filesystem is atomic on POSIX, so a -// concurrent reader either sees the previous file in full or the new -// one in full — never a half-written body. Sync before rename gives a -// durability guarantee: the inode's data is on disk before the -// directory entry switches over. -func atomicWriteFile(path string, data []byte, perm os.FileMode) error { - dir := filepath.Dir(path) - tmp, err := os.CreateTemp(dir, filepath.Base(path)+".tmp-*") - if err != nil { - return err - } - tmpName := tmp.Name() - defer func() { - // Best-effort cleanup on any failure path. The rename has - // either happened (and tmpName is gone) or it has not (and - // the temp file still needs to go). - _ = os.Remove(tmpName) - }() - if _, err := tmp.Write(data); err != nil { - _ = tmp.Close() - return err - } - if err := tmp.Sync(); err != nil { - _ = tmp.Close() - return err - } - if err := tmp.Close(); err != nil { - return err - } - if err := os.Chmod(tmpName, perm); err != nil { - return err - } - return os.Rename(tmpName, path) -} - -// deepCopyJob returns a JobSpec value independent of the source's -// pointer fields. JobSpec carries one pointer (LastRun); a shallow -// copy aliases it and lets callers mutate the store's in-memory state -// by writing through the returned value. -func deepCopyJob(j JobSpec) JobSpec { - out := j - if j.LastRun != nil { - t := *j.LastRun - out.LastRun = &t - } - if j.Schedule.At != nil { - t := *j.Schedule.At - out.Schedule.At = &t - } - return out -} diff --git a/internal/infrastructure/cronstore/store_review_test.go b/internal/infrastructure/cronstore/store_review_test.go deleted file mode 100644 index 19b87fea2..000000000 --- a/internal/infrastructure/cronstore/store_review_test.go +++ /dev/null @@ -1,485 +0,0 @@ -// Additional tests added in response to the Slice-1 adversarial review. -// They live in a separate file so the original spec file stays focused -// on the contract-level behaviour the engine depends on, and these -// cases stay grouped where the reviewer can re-read them as a unit. -package cronstore - -import ( - "bytes" - "context" - "errors" - "os" - "os/exec" - "path/filepath" - "sync" - "testing" - "time" - - "github.com/samcharles93/archie-core/internal/domain/scheduling" -) - -// --- C2 + P8: ErrCorruptFile is the right sentinel for bad files ------- - -func TestOpenTruncatedFileReturnsErrCorruptFile(t *testing.T) { - dir := t.TempDir() - path := filepath.Join(dir, "jobs.json") - if err := os.WriteFile(path, []byte(`{"schema_version":1,"jobs":[{"id":"x","`), 0o600); err != nil { - t.Fatalf("WriteFile: %v", err) - } - _, err := Open(path) - if !errors.Is(err, ErrCorruptFile) { - t.Fatalf("Open on truncated file = %v, want ErrCorruptFile", err) - } -} - -func TestOpenGarbageFileReturnsErrCorruptFile(t *testing.T) { - dir := t.TempDir() - path := filepath.Join(dir, "jobs.json") - if err := os.WriteFile(path, []byte("not json at all"), 0o600); err != nil { - t.Fatalf("WriteFile: %v", err) - } - _, err := Open(path) - if !errors.Is(err, ErrCorruptFile) { - t.Fatalf("Open on garbage file = %v, want ErrCorruptFile", err) - } -} - -func TestOpenEmptyFileIsTreatedAsNoJobs(t *testing.T) { - dir := t.TempDir() - path := filepath.Join(dir, "jobs.json") - if err := os.WriteFile(path, []byte(" \n\t "), 0o600); err != nil { - t.Fatalf("WriteFile: %v", err) - } - s, err := Open(path) - if err != nil { - t.Fatalf("Open on whitespace-only file = %v, want nil", err) - } - defer s.Close() - jobs, _ := s.List(context.Background()) - if len(jobs) != 0 { - t.Errorf("List on whitespace-only file = %d jobs, want 0", len(jobs)) - } -} - -// --- C6 / P8: DisallowUnknownFields rejects hand-edited extras --------- - -func TestOpenRejectsUnknownFieldAtSameSchemaVersion(t *testing.T) { - dir := t.TempDir() - path := filepath.Join(dir, "jobs.json") - // A future build might add a "tags" field to JobSpec. An older - // build with DisallowUnknownFields set must reject the file rather - // than silently dropping the field — that's the contract behind - // bumping schemaVersion on additive changes. - contents := `{"schema_version":1,"jobs":[{"id":"x","pool":"parallel","schedule":{"kind":"interval","interval":60000000000},"target":{},"payload":{},"next_run":"2026-08-28T12:00:00Z","created":"2026-08-28T12:00:00Z","updated":"2026-08-28T12:00:00Z","tags":["ops"]}]}` - if err := os.WriteFile(path, []byte(contents), 0o600); err != nil { - t.Fatalf("WriteFile: %v", err) - } - _, err := Open(path) - if !errors.Is(err, ErrCorruptFile) { - t.Fatalf("Open on file with unknown field = %v, want ErrCorruptFile", err) - } -} - -// --- P2: Get / List return deep copies ------------------------------- - -func TestGetReturnsDeepCopyOfLastRun(t *testing.T) { - s := newTestStore(t) - mustCreate(t, s, fixedIntervalSpec("x", time.Hour)) - first, _, _ := s.Get(context.Background(), "x") - if first.LastRun != nil { - t.Fatalf("LastRun on fresh create = %v, want nil", first.LastRun) - } - runAt := time.Now().UTC().Add(-time.Minute) - if err := s.MarkRun(context.Background(), "x", runAt); err != nil { - t.Fatalf("MarkRun: %v", err) - } - got, _, _ := s.Get(context.Background(), "x") - if got.LastRun == nil { - t.Fatal("LastRun is nil after MarkRun") - } - // Caller mutates the returned LastRun. The store's in-memory - // value must NOT change — a future Get must still report the - // original runAt. - *got.LastRun = time.Date(2099, 1, 1, 0, 0, 0, 0, time.UTC) - got2, _, _ := s.Get(context.Background(), "x") - if !got2.LastRun.Equal(runAt) { - t.Errorf("after caller mutation, Get returned LastRun=%v, want %v", got2.LastRun, runAt) - } -} - -func TestListReturnsDeepCopies(t *testing.T) { - s := newTestStore(t) - mustCreate(t, s, fixedIntervalSpec("x", time.Hour)) - mustCreate(t, s, fixedIntervalSpec("y", time.Hour)) - - list1, _ := s.List(context.Background()) - if len(list1) != 2 { - t.Fatalf("List returned %d jobs, want 2", len(list1)) - } - // Caller mutates the returned slice (deletes an entry) and a job's - // string fields. Neither must touch the store's in-memory mirror. - list1[0].Detail = "tampered" - - list2, _ := s.List(context.Background()) - if len(list2) != 2 { - t.Errorf("after caller truncated list, second List returned %d jobs, want 2", len(list2)) - } - for _, j := range list2 { - if j.Detail == "tampered" { - t.Errorf("caller's Detail mutation leaked into the store: %+v", j) - } - } -} - -// --- P3: pool validation in Create / Update --------------------------- - -func TestCreateRejectsInvalidPool(t *testing.T) { - s := newTestStore(t) - spec := fixedIntervalSpec("x", time.Minute) - spec.Pool = "paralle" // typo - if err := s.Create(context.Background(), spec); err == nil { - t.Fatal("Create with invalid pool succeeded; want error") - } -} - -func TestUpdateRejectsInvalidPool(t *testing.T) { - s := newTestStore(t) - mustCreate(t, s, fixedIntervalSpec("x", time.Minute)) - if err := s.Update(context.Background(), "x", Patch{Pool: new("paralle")}); err == nil { - t.Fatal("Update with invalid pool succeeded; want error") - } -} - -// --- P5 / C1 / P6: Once schedule behaviour + MarkRun sentinel --------- - -func TestCreateAcceptsOnceSchedule(t *testing.T) { - s := newTestStore(t) - at := time.Now().Add(time.Hour) - spec := JobSpec{ - ID: "one-off", - Schedule: Schedule{ - Kind: ScheduleOnce, - At: &at, - }, - } - if err := s.Create(context.Background(), spec); err != nil { - t.Fatalf("Create with Once schedule: %v", err) - } -} - -func TestDueFiresOnceAtConfiguredTime(t *testing.T) { - s := newTestStore(t) - at := time.Date(2026, 8, 28, 12, 0, 0, 0, time.UTC) - spec := JobSpec{ - ID: "one-off", - Schedule: Schedule{ - Kind: ScheduleOnce, - At: &at, - }, - } - if err := s.Create(context.Background(), spec); err != nil { - t.Fatalf("Create: %v", err) - } - - due, err := s.Due(context.Background(), at) - if err != nil { - t.Fatalf("Due: %v", err) - } - if len(due) != 1 || due[0].ID != "one-off" { - t.Errorf("Due(at) = %+v, want one-off", due) - } - due, _ = s.Due(context.Background(), at.Add(-time.Second)) - if len(due) != 0 { - t.Errorf("Due(at - 1s) = %+v, want empty", due) - } -} - -func TestMarkRunOnOnceReturnsErrScheduleUnsupported(t *testing.T) { - s := newTestStore(t) - at := time.Now().Add(time.Hour) - spec := JobSpec{ - ID: "one-off", - Schedule: Schedule{ - Kind: ScheduleOnce, - At: &at, - }, - } - if err := s.Create(context.Background(), spec); err != nil { - t.Fatalf("Create: %v", err) - } - err := s.MarkRun(context.Background(), "one-off", time.Now()) - if !errors.Is(err, ErrScheduleUnsupported) { - t.Fatalf("MarkRun on once = %v, want ErrScheduleUnsupported", err) - } -} - -// --- P8: Due drops unknown pool values silently ----------------------- - -func TestDueSilentlySkipsUnknownPool(t *testing.T) { - dir := t.TempDir() - path := filepath.Join(dir, "jobs.json") - s, err := Open(path) - if err != nil { - t.Fatalf("Open: %v", err) - } - defer s.Close() - // Hand-edit the file: bypass Create's validation by writing a - // job with an invalid pool directly to disk. - past := time.Now().Add(-time.Minute).UTC().Format(time.RFC3339Nano) - contents := `{"schema_version":1,"jobs":[{"id":"badpool","pool":"paralle","schedule":{"kind":"interval","interval":60000000000},"target":{},"payload":{},"next_run":"` + past + `","created":"` + past + `","updated":"` + past + `"}]}` - if err := os.WriteFile(path, []byte(contents), 0o600); err != nil { - t.Fatalf("WriteFile: %v", err) - } - // Drop the in-memory mirror so the next read picks up the file. - if err := s.hydrate(); err != nil { - t.Fatalf("hydrate: %v", err) - } - due, err := s.Due(context.Background(), time.Now()) - if err != nil { - t.Fatalf("Due: %v", err) - } - if len(due) != 0 { - t.Errorf("Due returned %d jobs for an invalid pool, want 0", len(due)) - } - // But Get still sees the job — Create/Update validation is the - // gate that prevents this in normal operation; a hand-edited - // file remains visible through CRUD. - if _, ok, _ := s.Get(context.Background(), "badpool"); !ok { - t.Error("Get returned ok=false for a hand-edited job with bad pool") - } -} - -// --- P10: UTF-8 + quote + newline round-trip -------------------------- - -func TestCreateAndGetRoundTripWithUnicodeAndQuotes(t *testing.T) { - s := newTestStore(t) - spec := JobSpec{ - ID: "ops-standup", - Pool: string(scheduling.PoolSequential), - Detail: "Hello\n\"世界\"\\back", - Schedule: Schedule{ - Kind: ScheduleInterval, - Interval: Duration(30 * time.Minute), - }, - Payload: Payload{Text: " & 中文"}, - } - mustCreate(t, s, spec) - got, ok, err := s.Get(context.Background(), spec.ID) - if err != nil { - t.Fatalf("Get: %v", err) - } - if !ok { - t.Fatal("Get returned ok=false") - } - if got.Detail != spec.Detail { - t.Errorf("Detail = %q, want %q", got.Detail, spec.Detail) - } - if got.Payload.Text != spec.Payload.Text { - t.Errorf("Payload.Text = %q, want %q", got.Payload.Text, spec.Payload.Text) - } -} - -// --- C3: operator-readable file does not HTML-escape ------------------- - -func TestFileIsOperatorReadableNoHTMLEscape(t *testing.T) { - dir := t.TempDir() - path := filepath.Join(dir, "jobs.json") - s, _ := Open(path) - defer s.Close() - spec := fixedIntervalSpec("x", time.Minute) - spec.Payload.Text = "" - mustCreate(t, s, spec) - _ = s.Close() - - data, err := os.ReadFile(path) - if err != nil { - t.Fatalf("ReadFile: %v", err) - } - // With SetEscapeHTML(false), < > & appear as the literal characters. - // The escaped form would be <, >, & — none of which - // is the printable payload. Assert the literal is there. - if !bytes.Contains(data, []byte(`""`)) { - t.Errorf("payload was HTML-escaped; want operator-readable literal: %s", data) - } -} - -// --- C4: file is 0o600, not 0o644 -------------------------------------- - -func TestFileIsCreatedWithOwnerOnlyPermissions(t *testing.T) { - dir := t.TempDir() - path := filepath.Join(dir, "jobs.json") - s, _ := Open(path) - defer s.Close() - mustCreate(t, s, fixedIntervalSpec("x", time.Minute)) - _ = s.Close() - - info, err := os.Stat(path) - if err != nil { - t.Fatalf("Stat: %v", err) - } - perm := info.Mode().Perm() - if perm != 0o600 { - t.Errorf("jobs.json perm = %#o, want 0o600", perm) - } -} - -// --- C5: cross-process flock via os/exec ------------------------------ - -// TestCrossProcessFlockBlocksParentWhileChildHoldsLock runs a child -// process that grabs the cross-process flock and sleeps; the parent -// then tries to take the same lock and must block for at least the -// child's sleep duration. Without the flock, the parent's Create -// would return immediately and the test would fail. -func TestCrossProcessFlockBlocksParentWhileChildHoldsLock(t *testing.T) { - if testing.Short() { - t.Skip("subprocess test") - } - if _, err := exec.LookPath("go"); err != nil { - t.Skip("no go toolchain available for subprocess test") - } - dir := t.TempDir() - path := filepath.Join(dir, "jobs.json") - ctx := t.Context() - - // Build a tiny helper that opens the same file and holds the - // flock. The helper is built once per run; the cost is paid only - // when this test runs. - helperSrc := filepath.Join(dir, "helper.go") - if err := os.WriteFile(helperSrc, []byte(` -package main - -import ( - "fmt" - "os" - "syscall" - "time" -) - -func main() { - f, err := os.OpenFile(os.Args[1]+".lock", os.O_RDWR|os.O_CREATE, 0o644) - if err != nil { fmt.Println("open:", err); os.Exit(2) } - if err := syscall.Flock(int(f.Fd()), syscall.LOCK_EX); err != nil { - fmt.Println("flock:", err); os.Exit(3) - } - fmt.Println("locked") - // Signal readiness, then hold the lock long enough for the - // parent to observe the block. - time.Sleep(2 * time.Second) - _ = f.Close() -} -`), 0o644); err != nil { - t.Fatalf("WriteFile helper: %v", err) - } - helperBin := filepath.Join(dir, "helper") - if out, err := exec.CommandContext(ctx, "go", "build", "-o", helperBin, helperSrc).CombinedOutput(); err != nil { - t.Fatalf("go build helper: %v\n%s", err, out) - } - - // Launch the child in the background. - child := exec.CommandContext(ctx, helperBin, path) - child.Stdout = os.Stdout - child.Stderr = os.Stderr - if err := child.Start(); err != nil { - t.Fatalf("child Start: %v", err) - } - defer func() { - _ = child.Process.Kill() - _ = child.Wait() - }() - - // Give the child a moment to acquire the lock. - time.Sleep(300 * time.Millisecond) - - // From the parent, open the same Store and call Create. Without - // flock, Create would return instantly; with flock, it must - // block until the child releases. - parent, err := Open(path) - if err != nil { - t.Fatalf("parent Open: %v", err) - } - defer parent.Close() - - start := time.Now() - if err := parent.Create(context.Background(), fixedIntervalSpec("from-parent", time.Minute)); err != nil { - t.Fatalf("parent Create: %v", err) - } - elapsed := time.Since(start) - - // The child held the lock for ~2s. The parent's Create must have - // blocked for at least the overlap between its start and the - // child's release — conservatively, >1s. - if elapsed < time.Second { - t.Errorf("parent Create returned in %v; expected to block on the child's flock", elapsed) - } -} - -// --- P1: Close mid-operation returns ErrClosed ------------------------ - -func TestMethodsReturnErrClosedAfterClose(t *testing.T) { - s := newTestStore(t) - mustCreate(t, s, fixedIntervalSpec("x", time.Minute)) - if err := s.Close(); err != nil { - t.Fatalf("Close: %v", err) - } - // Every public method must surface ErrClosed, not panic on the - // nil lock fd. - tests := []struct { - name string - fn func() error - }{ - {"Create", func() error { return s.Create(context.Background(), fixedIntervalSpec("y", time.Minute)) }}, - {"Get", func() error { _, _, err := s.Get(context.Background(), "x"); return err }}, - {"List", func() error { _, err := s.List(context.Background()); return err }}, - {"Update", func() error { return s.Update(context.Background(), "x", Patch{Detail: new("z")}) }}, - {"Delete", func() error { return s.Delete(context.Background(), "x") }}, - {"MarkRun", func() error { return s.MarkRun(context.Background(), "x", time.Now()) }}, - {"Due", func() error { _, err := s.Due(context.Background(), time.Now()); return err }}, - } - // Close itself is documented as idempotent (returns nil on the - // second call), so it does NOT appear in the ErrClosed list above. - if err := s.Close(); err != nil { - t.Errorf("second Close = %v, want nil", err) - } - for _, tc := range tests { - t.Run(tc.name, func(t *testing.T) { - err := tc.fn() - if !errors.Is(err, ErrClosed) { - t.Errorf("%s after Close = %v, want ErrClosed", tc.name, err) - } - }) - } -} - -// --- P8: same-path stores share the in-process mutex ------------------ - -func TestTwoStoresForSamePathSerialiseInProcess(t *testing.T) { - // This is the test that fails without process_lock.go. With it, - // 50/50 writes from each side land; without it, half the data - // disappears. Mirrors TestConcurrentWritersAreSerialised but in - // its own right so the regression is named. - dir := t.TempDir() - path := filepath.Join(dir, "jobs.json") - a, _ := Open(path) - defer a.Close() - b, _ := Open(path) - defer b.Close() - - var wg sync.WaitGroup - for i := range 25 { - wg.Add(2) - go func(i int) { - defer wg.Done() - _ = a.Create(context.Background(), fixedIntervalSpec("a"+itoa(i), time.Minute)) - }(i) - go func(i int) { - defer wg.Done() - _ = b.Create(context.Background(), fixedIntervalSpec("b"+itoa(i), time.Minute)) - }(i) - } - wg.Wait() - - jobs, _ := a.List(context.Background()) - if len(jobs) != 50 { - t.Errorf("after 50 concurrent writes from two stores, %d persisted, want 50", len(jobs)) - } -} diff --git a/internal/infrastructure/cronstore/store_test.go b/internal/infrastructure/cronstore/store_test.go deleted file mode 100644 index ec3694e34..000000000 --- a/internal/infrastructure/cronstore/store_test.go +++ /dev/null @@ -1,512 +0,0 @@ -// Package cronstore is the persistent job store backing the scheduling -// ticker engine. Tests in this file are the spec: an implementing agent -// must make every test in this file pass WITHOUT modifying the tests -// themselves. -// -// The store's only contract with the engine is scheduling.JobSource: one -// file-backed JSON document, cross-process locked, with version-stamped -// schema so future slices can extend it without breaking old files. -package cronstore - -import ( - "context" - "errors" - "os" - "path/filepath" - "strconv" - "strings" - "sync" - "testing" - "time" - - "github.com/samcharles93/archie-core/internal/domain/scheduling" -) - -// helpers - -func newTestStore(t *testing.T) *Store { - t.Helper() - dir := t.TempDir() - path := filepath.Join(dir, "jobs.json") - s, err := Open(path) - if err != nil { - t.Fatalf("Open(%s): %v", path, err) - } - t.Cleanup(func() { _ = s.Close() }) - return s -} - -func mustCreate(t *testing.T, s *Store, spec JobSpec) { - t.Helper() - if err := s.Create(context.Background(), spec); err != nil { - t.Fatalf("Create(%q): %v", spec.ID, err) - } -} - -func fixedIntervalSpec(id string, every time.Duration) JobSpec { - return JobSpec{ - ID: id, - Pool: string(scheduling.PoolParallel), - Detail: "test job " + id, - Schedule: Schedule{ - Kind: ScheduleInterval, - Interval: Duration(every), - }, - Payload: Payload{Text: "hello " + id}, - } -} - -// --- open / close ------------------------------------------------------------ - -func TestOpenMissingFileReturnsEmpty(t *testing.T) { - dir := t.TempDir() - s, err := Open(filepath.Join(dir, "jobs.json")) - if err != nil { - t.Fatalf("Open: %v", err) - } - defer s.Close() - - jobs, err := s.List(context.Background()) - if err != nil { - t.Fatalf("List: %v", err) - } - if len(jobs) != 0 { - t.Errorf("List on missing file = %d jobs, want 0", len(jobs)) - } -} - -func TestOpenCreatesParentDirectory(t *testing.T) { - dir := t.TempDir() - deep := filepath.Join(dir, "a", "b", "c", "jobs.json") - s, err := Open(deep) - if err != nil { - t.Fatalf("Open with missing parent: %v", err) - } - defer s.Close() - mustCreate(t, s, fixedIntervalSpec("x", time.Minute)) - if _, err := os.Stat(deep); err != nil { - t.Fatalf("expected file to exist at %s: %v", deep, err) - } -} - -// --- schema versioning ------------------------------------------------------- - -func TestPersistedFileHasVersionStamp(t *testing.T) { - dir := t.TempDir() - path := filepath.Join(dir, "jobs.json") - s, err := Open(path) - if err != nil { - t.Fatalf("Open: %v", err) - } - mustCreate(t, s, fixedIntervalSpec("x", time.Minute)) - _ = s.Close() - - data, err := os.ReadFile(path) - if err != nil { - t.Fatalf("ReadFile: %v", err) - } - // Asserted against the constant, not a literal: the stamp must track - // schemaVersion through every bump (Kind was the first), and a - // hardcoded value here would fail on the bump as a false alarm - // instead of guarding the property it names. - want := `"schema_version":` + strconv.Itoa(schemaVersion) - if !strings.Contains(string(data), want) { - t.Errorf("file does not contain %s stamp: %s", want, data) - } -} - -func TestOpenRejectsUnknownSchemaVersion(t *testing.T) { - dir := t.TempDir() - path := filepath.Join(dir, "jobs.json") - if err := os.WriteFile(path, []byte(`{"schema_version":999,"jobs":[]}`), 0o644); err != nil { - t.Fatalf("WriteFile: %v", err) - } - if _, err := Open(path); err == nil { - t.Fatal("Open with future schema version succeeded; want error") - } else if !errors.Is(err, ErrUnsupportedSchema) { - t.Errorf("error = %v, want ErrUnsupportedSchema", err) - } -} - -// --- create / read ----------------------------------------------------------- - -func TestCreateAndGetRoundTrip(t *testing.T) { - s := newTestStore(t) - want := JobSpec{ - ID: "morning-status", - Pool: string(scheduling.PoolSequential), - Detail: "morning status", - Schedule: Schedule{ - Kind: ScheduleInterval, - Interval: Duration(30 * time.Minute), - }, - Payload: Payload{Text: "status please"}, - } - mustCreate(t, s, want) - - got, ok, err := s.Get(context.Background(), want.ID) - if err != nil { - t.Fatalf("Get: %v", err) - } - if !ok { - t.Fatal("Get returned ok=false") - } - if got.ID != want.ID { - t.Errorf("ID = %q, want %q", got.ID, want.ID) - } - if got.Pool != want.Pool { - t.Errorf("Pool = %q, want %q", got.Pool, want.Pool) - } - if got.Detail != want.Detail { - t.Errorf("Detail = %q, want %q", got.Detail, want.Detail) - } - if got.Schedule.Kind != want.Schedule.Kind { - t.Errorf("Schedule.Kind = %q, want %q", got.Schedule.Kind, want.Schedule.Kind) - } - if got.Schedule.Interval != want.Schedule.Interval { - t.Errorf("Schedule.Interval = %v, want %v", got.Schedule.Interval, want.Schedule.Interval) - } - if got.Payload.Text != want.Payload.Text { - t.Errorf("Payload.Text = %q, want %q", got.Payload.Text, want.Payload.Text) - } - if got.NextRun.IsZero() { - t.Error("NextRun is zero; Create must compute it for an interval job") - } - if got.Created.IsZero() { - t.Error("Created is zero; Create must stamp it") - } - if got.Updated.IsZero() { - t.Error("Updated is zero; Create must stamp it") - } - if !got.Created.Equal(got.Updated) { - t.Errorf("Created %v != Updated %v on a fresh create", got.Created, got.Updated) - } -} - -func TestGetMissingReturnsNotFound(t *testing.T) { - s := newTestStore(t) - _, ok, err := s.Get(context.Background(), "nope") - if err != nil { - t.Fatalf("Get: %v", err) - } - if ok { - t.Error("Get of missing id returned ok=true") - } -} - -func TestCreateRejectsEmptyID(t *testing.T) { - s := newTestStore(t) - if err := s.Create(context.Background(), fixedIntervalSpec("", time.Minute)); err == nil { - t.Fatal("Create with empty id succeeded; want error") - } -} - -func TestCreateRejectsUnknownScheduleKind(t *testing.T) { - s := newTestStore(t) - spec := fixedIntervalSpec("x", time.Minute) - spec.Schedule.Kind = "magic" - if err := s.Create(context.Background(), spec); err == nil { - t.Fatal("Create with unknown schedule kind succeeded; want error") - } -} - -func TestCreateRejectsDuplicateID(t *testing.T) { - s := newTestStore(t) - mustCreate(t, s, fixedIntervalSpec("dup", time.Minute)) - if err := s.Create(context.Background(), fixedIntervalSpec("dup", time.Hour)); err == nil { - t.Fatal("Create with duplicate id succeeded; want error") - } -} - -// --- update with merge semantics -------------------------------------------- - -func TestUpdatePreservesFieldsNotInPatch(t *testing.T) { - s := newTestStore(t) - mustCreate(t, s, JobSpec{ - ID: "patch-me", - Pool: string(scheduling.PoolParallel), - Detail: "original detail", - Schedule: Schedule{ - Kind: ScheduleInterval, - Interval: Duration(10 * time.Minute), - }, - Payload: Payload{Text: "original payload"}, - }) - - if err := s.Update(context.Background(), "patch-me", Patch{ - Detail: new("updated detail"), - }); err != nil { - t.Fatalf("Update: %v", err) - } - - got, _, _ := s.Get(context.Background(), "patch-me") - if got.Detail != "updated detail" { - t.Errorf("Detail = %q, want %q", got.Detail, "updated detail") - } - // Untouched fields must survive. - if got.Pool != string(scheduling.PoolParallel) { - t.Errorf("Pool = %q, want %q (merge must preserve)", got.Pool, scheduling.PoolParallel) - } - if got.Schedule.Interval.Std() != 10*time.Minute { - t.Errorf("Schedule.Interval = %v, want %v (merge must preserve)", got.Schedule.Interval, 10*time.Minute) - } - if got.Payload.Text != "original payload" { - t.Errorf("Payload.Text = %q, want %q (merge must preserve)", got.Payload.Text, "original payload") - } -} - -func TestUpdateAdvancesUpdatedTimestamp(t *testing.T) { - s := newTestStore(t) - mustCreate(t, s, fixedIntervalSpec("ts", time.Minute)) - first, _, _ := s.Get(context.Background(), "ts") - - // Sleep long enough that Updated must move forward even on coarse - // clocks. mtime resolution on some filesystems is the second. - time.Sleep(1100 * time.Millisecond) - - if err := s.Update(context.Background(), "ts", Patch{Detail: new("new")}); err != nil { - t.Fatalf("Update: %v", err) - } - got, _, _ := s.Get(context.Background(), "ts") - if !got.Updated.After(first.Updated) { - t.Errorf("Updated did not advance: first=%v got=%v", first.Updated, got.Updated) - } -} - -func TestUpdateRecomputesNextRunWhenScheduleChanges(t *testing.T) { - s := newTestStore(t) - mustCreate(t, s, fixedIntervalSpec("rs", time.Hour)) - first, _, _ := s.Get(context.Background(), "rs") - - // Change the interval; NextRun must move. - if err := s.Update(context.Background(), "rs", Patch{ - Schedule: &Schedule{Kind: ScheduleInterval, Interval: Duration(2 * time.Minute)}, - }); err != nil { - t.Fatalf("Update: %v", err) - } - got, _, _ := s.Get(context.Background(), "rs") - if got.Schedule.Interval.Std() != 2*time.Minute { - t.Errorf("Schedule.Interval = %v, want %v", got.Schedule.Interval, 2*time.Minute) - } - if !got.NextRun.Before(first.NextRun) { - t.Errorf("NextRun did not move earlier after shortening interval: first=%v got=%v", first.NextRun, got.NextRun) - } -} - -func TestUpdateMissingReturnsNotFound(t *testing.T) { - s := newTestStore(t) - if err := s.Update(context.Background(), "ghost", Patch{Detail: new("x")}); err == nil { - t.Fatal("Update of missing id succeeded; want error") - } -} - -// --- delete ------------------------------------------------------------------ - -func TestDeleteRemovesJob(t *testing.T) { - s := newTestStore(t) - mustCreate(t, s, fixedIntervalSpec("bye", time.Minute)) - if err := s.Delete(context.Background(), "bye"); err != nil { - t.Fatalf("Delete: %v", err) - } - if _, ok, _ := s.Get(context.Background(), "bye"); ok { - t.Error("Get after Delete returned ok=true") - } -} - -func TestDeleteMissingIsIdempotent(t *testing.T) { - s := newTestStore(t) - // First delete is a no-op on a missing id; second delete must not panic - // and must not return an error. CLI retries should be safe. - if err := s.Delete(context.Background(), "never-existed"); err != nil { - t.Errorf("Delete(missing) = %v, want nil", err) - } - if err := s.Delete(context.Background(), "never-existed"); err != nil { - t.Errorf("Delete(missing) again = %v, want nil", err) - } -} - -// --- list -------------------------------------------------------------------- - -func TestListReturnsAllJobs(t *testing.T) { - s := newTestStore(t) - mustCreate(t, s, fixedIntervalSpec("a", time.Minute)) - mustCreate(t, s, fixedIntervalSpec("b", time.Minute)) - mustCreate(t, s, fixedIntervalSpec("c", time.Minute)) - - jobs, err := s.List(context.Background()) - if err != nil { - t.Fatalf("List: %v", err) - } - if len(jobs) != 3 { - t.Errorf("List returned %d jobs, want 3", len(jobs)) - } -} - -// --- JobSource.Due ----------------------------------------------------------- - -func TestDueReturnsOnlyJobsWhoseNextRunIsInThePast(t *testing.T) { - s := newTestStore(t) - now := time.Date(2026, 8, 28, 12, 0, 0, 0, time.UTC) - - // past: due - past := fixedIntervalSpec("past", 30*time.Minute) - past.NextRun = now.Add(-time.Minute) - // future: not due - future := fixedIntervalSpec("future", 30*time.Minute) - future.NextRun = now.Add(time.Hour) - mustCreate(t, s, past) - mustCreate(t, s, future) - - got, err := s.Due(context.Background(), now) - if err != nil { - t.Fatalf("Due: %v", err) - } - if len(got) != 1 { - t.Fatalf("Due returned %d jobs, want 1: %+v", len(got), got) - } - if got[0].ID != "past" { - t.Errorf("due job = %q, want %q", got[0].ID, "past") - } - if got[0].Pool != scheduling.PoolParallel { - t.Errorf("due job pool = %q, want %q", got[0].Pool, scheduling.PoolParallel) - } - if got[0].Detail != "test job past" { - t.Errorf("due job detail = %q, want %q", got[0].Detail, "test job past") - } -} - -func TestDueOnEmptyStoreReturnsEmptySlice(t *testing.T) { - s := newTestStore(t) - got, err := s.Due(context.Background(), time.Now()) - if err != nil { - t.Fatalf("Due: %v", err) - } - if len(got) != 0 { - t.Errorf("Due on empty = %d jobs, want 0", len(got)) - } -} - -func TestImplementsSchedulingJobSource(t *testing.T) { - // Static, compile-time check: *Store must satisfy scheduling.JobSource - // so the ticker engine can poll it without knowing the file layout. - var _ scheduling.JobSource = (*Store)(nil) -} - -func TestMarkRunAdvancesNextRun(t *testing.T) { - s := newTestStore(t) - mustCreate(t, s, fixedIntervalSpec("recurring", time.Hour)) - - first, _, _ := s.Get(context.Background(), "recurring") - runAt := first.NextRun.Add(time.Minute) // pretend engine ran a bit late - if err := s.MarkRun(context.Background(), "recurring", runAt); err != nil { - t.Fatalf("MarkRun: %v", err) - } - got, _, _ := s.Get(context.Background(), "recurring") - if got.LastRun == nil { - t.Fatal("LastRun is nil after MarkRun") - } - if !got.LastRun.Equal(runAt) { - t.Errorf("LastRun = %v, want %v", got.LastRun, runAt) - } - wantNext := runAt.Add(time.Hour) - if !got.NextRun.Equal(wantNext) { - t.Errorf("NextRun = %v, want %v (last_run + interval)", got.NextRun, wantNext) - } -} - -func TestMarkRunMissingReturnsNotFound(t *testing.T) { - s := newTestStore(t) - if err := s.MarkRun(context.Background(), "ghost", time.Now()); err == nil { - t.Fatal("MarkRun of missing id succeeded; want error") - } -} - -// --- partial-write handling -------------------------------------------------- - -func TestOpenTruncatedFileReturnsExplicitError(t *testing.T) { - dir := t.TempDir() - path := filepath.Join(dir, "jobs.json") - // Header present, body cut mid-array. Must not panic on read; the - // engine surfaces this as phase="source" KindJobError, not a crash. - if err := os.WriteFile(path, []byte(`{"schema_version":1,"jobs":[{"id":"x","`), 0o644); err != nil { - t.Fatalf("WriteFile: %v", err) - } - _, err := Open(path) - if err == nil { - t.Fatal("Open on truncated file succeeded; want explicit error") - } - if errors.Is(err, ErrUnsupportedSchema) { - t.Errorf("error = ErrUnsupportedSchema; want a corrupt-file error") - } -} - -func TestOpenGarbageFileReturnsExplicitError(t *testing.T) { - dir := t.TempDir() - path := filepath.Join(dir, "jobs.json") - if err := os.WriteFile(path, []byte("not json at all"), 0o644); err != nil { - t.Fatalf("WriteFile: %v", err) - } - if _, err := Open(path); err == nil { - t.Fatal("Open on garbage file succeeded; want explicit error") - } -} - -// --- cross-process locking --------------------------------------------------- - -func TestConcurrentWritersAreSerialised(t *testing.T) { - dir := t.TempDir() - path := filepath.Join(dir, "jobs.json") - a, err := Open(path) - if err != nil { - t.Fatalf("Open a: %v", err) - } - defer a.Close() - b, err := Open(path) - if err != nil { - t.Fatalf("Open b: %v", err) - } - defer b.Close() - - // 50 writes from each writer, on the same file, interleaved. Without - // the lock, two writers would race and the file would end up either - // truncated or holding a non-deterministic subset. The lock makes - // each writer wait, so all 100 distinct ids end up persisted. - var wg sync.WaitGroup - for i := range 50 { - wg.Add(2) - go func(i int) { - defer wg.Done() - id := "a" + itoa(i) - _ = a.Create(context.Background(), fixedIntervalSpec(id, time.Minute)) - }(i) - go func(i int) { - defer wg.Done() - id := "b" + itoa(i) - _ = b.Create(context.Background(), fixedIntervalSpec(id, time.Minute)) - }(i) - } - wg.Wait() - - jobs, err := a.List(context.Background()) - if err != nil { - t.Fatalf("List: %v", err) - } - if len(jobs) != 100 { - t.Errorf("after 100 concurrent writes, %d jobs persisted, want 100", len(jobs)) - } -} - -// itoa avoids strconv import in tests. -func itoa(n int) string { - if n == 0 { - return "0" - } - var buf [20]byte - i := len(buf) - for n > 0 { - i-- - buf[i] = byte('0' + n%10) - n /= 10 - } - return string(buf[i:]) -}