From 4d8b34939d5a08ef399322c282762d312565f643 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Wed, 21 Oct 2026 00:47:56 +0100 Subject: [PATCH] Separate saved run schedules from pipeline definitions --- internal/pipeline/runs.go | 7 +- internal/pipeline/runs_create.go | 26 ++ internal/pipeline/saved_schedules.go | 418 ++++++++++++++++++ internal/pipeline/saved_schedules_test.go | 281 ++++++++++++ internal/pipeline/schedule.go | 37 ++ .../pipeline/schedule_create_requests_test.go | 70 +++ internal/pipeline/schedule_store.go | 59 +-- internal/pipeline/store.go | 26 +- internal/protocol/message.go | 19 +- internal/protocol/runevents.go | 3 + internal/protocol/runevents_test.go | 2 +- internal/protocol/runs.go | 3 + internal/protocol/schedules.go | 32 ++ internal/server/runevents.go | 8 + internal/server/runner.go | 48 +- internal/server/schedule_websocket_test.go | 169 +++++-- internal/server/scheduler.go | 103 ++--- internal/server/scheduler_test.go | 378 ++++++++++------ internal/server/tools_test.go | 9 +- internal/server/websocket.go | 29 +- 20 files changed, 1391 insertions(+), 336 deletions(-) create mode 100644 internal/pipeline/saved_schedules.go create mode 100644 internal/pipeline/saved_schedules_test.go create mode 100644 internal/pipeline/schedule_create_requests_test.go create mode 100644 internal/protocol/schedules.go diff --git a/internal/pipeline/runs.go b/internal/pipeline/runs.go index e506d20f..c2894b6b 100644 --- a/internal/pipeline/runs.go +++ b/internal/pipeline/runs.go @@ -23,12 +23,15 @@ const runSelect = `SELECT r.id,r.pipeline_id,p.name,r.version,v.content_hash,r.s ` + runStamps + `,r.diagnostic, CASE WHEN r.status='succeeded' THEN r.output_json ELSE COALESCE((SELECT output_json FROM run_steps WHERE run_id=r.id AND status='completed' ORDER BY sequence DESC LIMIT 1),'{}') END, (SELECT COUNT(*) FROM run_steps WHERE run_id=r.id AND status='completed'),r.workspace,r.title,r.model,r.stage_models,r.notify_mode,r.cancel_requested,r.cleanup_unconfirmed,r.output_format, -CASE WHEN r.status='waiting' THEN COALESCE((SELECT sequence FROM session_export_gates WHERE run_id=r.id),0) ELSE 0 END +CASE WHEN r.status='waiting' THEN COALESCE((SELECT sequence FROM session_export_gates WHERE run_id=r.id),0) ELSE 0 END, +EXISTS(SELECT 1 FROM run_schedule_origin WHERE run_id=r.id), +COALESCE((SELECT schedule_id FROM run_schedule_origin WHERE run_id=r.id),0), +COALESCE((SELECT name FROM run_schedule_origin WHERE run_id=r.id),'') ` + runFrom + ` JOIN pipeline_versions v ON v.pipeline_id=r.pipeline_id AND v.version=r.version` func scanRun(row interface{ Scan(...any) error }, r *protocol.RunSummary) error { var output, stageModels string - if err := row.Scan(&r.ID, &r.PipelineID, &r.Name, &r.Version, &r.ContentHash, &r.Status, &r.Outcome, &r.CurrentStage, &r.CreatedAt, &r.FinishedAt, &r.Diagnostic, &output, &r.CompletedSteps, &r.Workspace, &r.Title, &r.Model, &stageModels, &r.NotifyMode, &r.CancelRequested, &r.CleanupUnconfirmed, &r.OutputFormat, &r.ExportPendingSequence); err != nil { + if err := row.Scan(&r.ID, &r.PipelineID, &r.Name, &r.Version, &r.ContentHash, &r.Status, &r.Outcome, &r.CurrentStage, &r.CreatedAt, &r.FinishedAt, &r.Diagnostic, &output, &r.CompletedSteps, &r.Workspace, &r.Title, &r.Model, &stageModels, &r.NotifyMode, &r.CancelRequested, &r.CleanupUnconfirmed, &r.OutputFormat, &r.ExportPendingSequence, &r.Scheduled, &r.ScheduleID, &r.ScheduleName); err != nil { return err } if stageModels != "" && stageModels != "{}" { diff --git a/internal/pipeline/runs_create.go b/internal/pipeline/runs_create.go index 5b0b556f..723bfe28 100644 --- a/internal/pipeline/runs_create.go +++ b/internal/pipeline/runs_create.go @@ -6,6 +6,7 @@ import ( "encoding/json" "fmt" "strings" + "time" "git.a-wan.net/alan/pipelines/internal/protocol" "git.a-wan.net/alan/pipelines/internal/summarise" @@ -16,6 +17,7 @@ import ( // stages by key (per-stage wins over whole-run). They are recorded so the run // stays reproducible without touching the pinned pipeline version. type RunOverrides struct { + Schedule *ScheduleAdmission OutputFormat string Model string StageModels map[string]string @@ -88,6 +90,22 @@ func (s *Store) CreateRunTitled(ctx context.Context, d *protocol.PipelineDetail, return 0, false, err } defer tx.Rollback() + if origin := overrides.Schedule; origin != nil { + // Acquire the SQLite writer lock while checking the original saved + // revision and occurrence. Edits/deletes between claim and admission + // invalidate admission, including while a title was being generated. + result, err := tx.ExecContext(ctx, `UPDATE saved_schedule_events SET status='admitted' WHERE schedule_id=? AND due=? AND revision=? AND status='claimed' AND run_id IS NULL AND EXISTS(SELECT 1 FROM saved_schedules WHERE id=? AND revision=? AND enabled=1 AND deleted=0)`, origin.ID, origin.Due.UTC().Format(time.RFC3339Nano), origin.Revision, origin.ID, origin.Revision) + if err != nil { + return 0, false, err + } + n, err := result.RowsAffected() + if err != nil { + return 0, false, err + } + if n != 1 { + return 0, false, fmt.Errorf("schedule changed or occurrence already admitted") + } + } result, err := tx.ExecContext(ctx, "INSERT INTO pipeline_runs(pipeline_id,version,request_key,workspace,allow_tools,write_paths,input_json,title,title_source,title_model,model,stage_models,notify_mode,output_format) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)", d.ID, d.Version, key, workspace, tools, string(writes), string(encoded), title.Text, title.Source, title.Model, overrides.Model, string(encodedModels), notifyMode(overrides.NotifyMode), overrides.OutputFormat) if err != nil { return 0, false, err @@ -96,6 +114,14 @@ func (s *Store) CreateRunTitled(ctx context.Context, d *protocol.PipelineDetail, if err != nil { return 0, false, err } + if origin := overrides.Schedule; origin != nil { + if _, err = tx.ExecContext(ctx, `INSERT INTO run_schedule_origin(run_id,schedule_id,name) VALUES(?,?,?)`, id, origin.ID, origin.Name); err != nil { + return 0, false, err + } + if _, err = tx.ExecContext(ctx, `UPDATE saved_schedule_events SET run_id=? WHERE schedule_id=? AND due=?`, id, origin.ID, origin.Due.UTC().Format(time.RFC3339Nano)); err != nil { + return 0, false, err + } + } if parent > 0 { if _, err := tx.ExecContext(ctx, "INSERT INTO run_retries(run_id,original_run_id) VALUES(?,?)", id, parent); err != nil { return 0, false, err diff --git a/internal/pipeline/saved_schedules.go b/internal/pipeline/saved_schedules.go new file mode 100644 index 00000000..dfc2775e --- /dev/null +++ b/internal/pipeline/saved_schedules.go @@ -0,0 +1,418 @@ +package pipeline + +import ( + "context" + "crypto/sha256" + "database/sql" + "encoding/json" + "fmt" + "os" + "path/filepath" + "slices" + "strings" + "time" + + "git.a-wan.net/alan/pipelines/internal/protocol" +) + +func (s *Store) initSavedSchedules() error { + _, err := s.db.Exec(`CREATE TABLE IF NOT EXISTS saved_schedules ( + id INTEGER PRIMARY KEY AUTOINCREMENT, revision INTEGER NOT NULL, pipeline_id INTEGER NOT NULL, + enabled INTEGER NOT NULL, deleted INTEGER NOT NULL DEFAULT 0, spec_json TEXT NOT NULL, + next_due TEXT NOT NULL, created_at TEXT NOT NULL, updated_at TEXT NOT NULL, + legacy_version INTEGER, legacy_slot INTEGER, UNIQUE(pipeline_id,legacy_version,legacy_slot)); + CREATE INDEX IF NOT EXISTS saved_schedules_pipeline ON saved_schedules(pipeline_id,deleted,enabled); + CREATE TABLE IF NOT EXISTS saved_schedule_events ( + schedule_id INTEGER NOT NULL, due TEXT NOT NULL, revision INTEGER NOT NULL, + status TEXT NOT NULL, diagnostic TEXT NOT NULL DEFAULT '', run_id INTEGER, + PRIMARY KEY(schedule_id,due)); + CREATE TABLE IF NOT EXISTS run_schedule_origin ( + run_id INTEGER PRIMARY KEY REFERENCES pipeline_runs(id) ON DELETE CASCADE, schedule_id INTEGER NOT NULL DEFAULT 0, name TEXT NOT NULL DEFAULT ''); + CREATE TABLE IF NOT EXISTS schedule_migrations (name TEXT PRIMARY KEY); + CREATE TABLE IF NOT EXISTS schedule_create_requests ( + request_key TEXT PRIMARY KEY, schedule_id INTEGER NOT NULL REFERENCES saved_schedules(id), payload_hash TEXT NOT NULL);`) + if err != nil { + return err + } + return s.importLegacySchedules() +} + +// One transaction imports only the latest old slots, but retains every old event +// and derives historical provenance exclusively from actual event.run_id links. +// The durable marker and tombstones prevent deletion/disable resurrection. +func (s *Store) importLegacySchedules() error { + ctx := context.Background() + tx, err := s.db.BeginTx(ctx, nil) + if err != nil { + return err + } + defer tx.Rollback() + var done int + if err := tx.QueryRow(`SELECT COUNT(*) FROM schedule_migrations WHERE name='external-v1'`).Scan(&done); err != nil { + return err + } + if done != 0 { + return tx.Commit() + } + rows, err := tx.Query(`SELECT v.pipeline_id,v.version,p.name,v.graph_json FROM pipeline_versions v JOIN pipelines p ON p.id=v.pipeline_id WHERE v.version=(SELECT MAX(version) FROM pipeline_versions WHERE pipeline_id=v.pipeline_id)`) + if err != nil { + return err + } + type legacy struct { + id int64 + version int + name string + graph protocol.Graph + } + var all []legacy + for rows.Next() { + var l legacy + var text string + if err := rows.Scan(&l.id, &l.version, &l.name, &text); err != nil { + rows.Close() + return err + } + if err := json.Unmarshal([]byte(text), &l.graph); err != nil { + rows.Close() + return err + } + all = append(all, l) + } + err = rows.Err() + rows.Close() + if err != nil { + return err + } + workspace, err := os.Getwd() + if err != nil { + return err + } + workspace, err = filepath.EvalSymlinks(workspace) + if err != nil { + return err + } + now := time.Now() + for _, l := range all { + if l.graph.Settings == nil { + continue + } + for slot, rule := range l.graph.Settings.Schedules { + if rule.Timezone == "" { + rule.Timezone = time.Local.String() + } + next, err := NextSchedule(rule, now) + if err != nil { + return err + } + var due string + err = tx.QueryRow(`SELECT next_due FROM schedule_state WHERE pipeline_id=? AND version=? AND slot=?`, l.id, l.version, slot).Scan(&due) + if err == sql.ErrNoRows { + due = next.UTC().Format(time.RFC3339Nano) + } else if err != nil { + return err + } + spec := protocol.SavedSchedule{Name: fmt.Sprintf("%s (legacy %d)", l.name, slot+1), PipelineID: l.id, Version: l.version, Enabled: true, Workspace: workspace, Input: map[string]any{"prompt": l.graph.Settings.Prompt}, Rule: rule} + text, err := json.Marshal(spec) + if err != nil { + return err + } + stamp := now.UTC().Format(time.RFC3339Nano) + if _, err = tx.Exec(`INSERT INTO saved_schedules(revision,pipeline_id,enabled,spec_json,next_due,created_at,updated_at,legacy_version,legacy_slot) VALUES(1,?,1,?,?,?,?,?,?)`, l.id, string(text), due, stamp, stamp, l.version, slot); err != nil { + return err + } + } + } + _, err = tx.Exec(`INSERT OR IGNORE INTO run_schedule_origin(run_id,schedule_id,name) + SELECT e.run_id,COALESCE(s.id,0),COALESCE(json_extract(s.spec_json,'$.name'),p.name || ' (legacy schedule)') + FROM schedule_events e JOIN pipeline_runs r ON r.id=e.run_id AND r.pipeline_id=e.pipeline_id AND r.version=e.version JOIN pipelines p ON p.id=e.pipeline_id LEFT JOIN saved_schedules s ON s.pipeline_id=e.pipeline_id AND s.legacy_version=e.version AND s.legacy_slot=e.slot + WHERE e.run_id>0`) + if err != nil { + return err + } + if _, err = tx.Exec(`INSERT INTO schedule_migrations(name) VALUES('external-v1')`); err != nil { + return err + } + return tx.Commit() +} + +const savedScheduleSelect = `SELECT id,revision,spec_json,next_due,created_at,updated_at FROM saved_schedules` + +func scanSavedSchedule(row interface{ Scan(...any) error }) (protocol.SavedSchedule, error) { + var item protocol.SavedSchedule + var text, due, created, updated string + var id, rev int64 + err := row.Scan(&id, &rev, &text, &due, &created, &updated) + if err != nil { + return item, err + } + if err = json.Unmarshal([]byte(text), &item); err != nil { + return item, err + } + item.ID = id + item.Revision = rev + item.NextDue = due + item.CreatedAt = created + item.UpdatedAt = updated + return item, nil +} + +func (s *Store) ListSchedules(ctx context.Context, pipelineID int64) ([]protocol.SavedSchedule, error) { + rows, err := s.db.QueryContext(ctx, savedScheduleSelect+` WHERE deleted=0 AND (?=0 OR pipeline_id=?) ORDER BY id`, pipelineID, pipelineID) + if err != nil { + return nil, err + } + defer rows.Close() + items := []protocol.SavedSchedule{} + for rows.Next() { + item, err := scanSavedSchedule(rows) + if err != nil { + return nil, err + } + items = append(items, item) + } + return items, rows.Err() +} + +// SaveSchedule does not execute models or change definitions. All run configuration +// is checked against the pinned graph before any durable mutation. +func (s *Store) SaveSchedule(ctx context.Context, spec protocol.SavedSchedule, now time.Time, requestKeys ...string) (*protocol.SavedSchedule, error) { + var requestKey string + if len(requestKeys) > 0 { + requestKey = requestKeys[0] + } + if len(requestKey) > 128 { + return nil, fmt.Errorf("schedule create request key must be at most 128 bytes") + } + if spec.ID < 0 || spec.Revision < 0 || (spec.ID == 0) != (spec.Revision == 0) { + return nil, fmt.Errorf("schedule ID and revision must both be zero for creation or positive for update") + } + spec.Name = strings.TrimSpace(spec.Name) + if spec.Name == "" || len(spec.Name) > 200 || strings.ContainsAny(spec.Name, "\r\n\x00") { + return nil, fmt.Errorf("schedule name must be 1–200 bytes without line breaks or NUL") + } + if spec.Version <= 0 { + return nil, fmt.Errorf("schedule requires an explicit positive pipeline version") + } + workspace, err := ResolveRunWorkspace(spec.Workspace, true) + if err != nil { + return nil, err + } + spec.Workspace = workspace + if prompt, ok := spec.Input["prompt"].(string); !ok || strings.TrimSpace(prompt) == "" { + return nil, fmt.Errorf("a nonempty user prompt is required in input.prompt") + } + if _, err = json.Marshal(spec.Input); err != nil { + return nil, err + } + if err = protocol.ValidateOutputFormat(spec.OutputFormat); err != nil { + return nil, err + } + if spec.NotifyMode != "" && spec.NotifyMode != "auto" && spec.NotifyMode != "on" && spec.NotifyMode != "off" { + return nil, fmt.Errorf("notify_mode must be auto, on or off") + } + d, err := s.Get(ctx, spec.PipelineID, spec.Version) + if err != nil { + return nil, err + } + if _, err = EffectiveModels(d.Graph, spec.Model, spec.StageModels); err != nil { + return nil, err + } + if spec.Rule.Timezone == "" { + spec.Rule.Timezone = time.Local.String() + } + if err = ValidateSchedule(spec.Rule); err != nil { + return nil, err + } + // Hash only normalized editable information, never a computed due time or + // client-supplied server metadata. This namespace is separate from run keys. + canonical := spec + canonical.ID = 0 + canonical.Revision = 0 + canonical.NextDue = "" + canonical.CreatedAt = "" + canonical.UpdatedAt = "" + canonical.NotifyMode = notifyMode(canonical.NotifyMode) + canonical.Rule.Days = slices.Sorted(slices.Values(canonical.Rule.Days)) + canonical.Rule.Times = slices.Sorted(slices.Values(canonical.Rule.Times)) + payload, err := json.Marshal(canonical) + if err != nil { + return nil, err + } + payloadHash := fmt.Sprintf("%x", sha256.Sum256(payload)) + next, err := NextSchedule(spec.Rule, now) + if err != nil { + return nil, err + } + s.mu.Lock() + defer s.mu.Unlock() + tx, err := s.db.BeginTx(ctx, nil) + if err != nil { + return nil, err + } + defer tx.Rollback() + if spec.ID == 0 && requestKey != "" { + var id int64 + var oldHash string + err := tx.QueryRowContext(ctx, `SELECT schedule_id,payload_hash FROM schedule_create_requests WHERE request_key=?`, requestKey).Scan(&id, &oldHash) + if err == nil { + if oldHash != payloadHash { + return nil, fmt.Errorf("schedule create request key already used for different run information") + } + existing, err := scanSavedSchedule(tx.QueryRowContext(ctx, savedScheduleSelect+` WHERE id=? AND deleted=0`, id)) + if err == sql.ErrNoRows { + return nil, fmt.Errorf("schedule created by this request key was deleted; use a new key for an intentional new schedule") + } + if err != nil { + return nil, err + } + if err = tx.Commit(); err != nil { + return nil, err + } + return &existing, nil + } + if err != sql.ErrNoRows { + return nil, err + } + } + stamp := now.UTC().Format(time.RFC3339Nano) + spec.NextDue = next.UTC().Format(time.RFC3339Nano) + spec.CreatedAt = stamp + spec.UpdatedAt = stamp + if spec.ID != 0 { + old, err := scanSavedSchedule(tx.QueryRowContext(ctx, savedScheduleSelect+` WHERE id=? AND deleted=0`, spec.ID)) + if err != nil { + return nil, fmt.Errorf("schedule not found: %w", err) + } + if old.Revision != spec.Revision { + return nil, fmt.Errorf("schedule revision conflict; reload before editing") + } + if old.Enabled == spec.Enabled && sameScheduleRule(old.Rule, spec.Rule) { + spec.NextDue = old.NextDue + } + spec.CreatedAt = old.CreatedAt + } + spec.Revision++ + encoded, err := json.Marshal(spec) + if err != nil { + return nil, err + } + if spec.ID == 0 { + result, err := tx.ExecContext(ctx, `INSERT INTO saved_schedules(revision,pipeline_id,enabled,spec_json,next_due,created_at,updated_at) VALUES(1,?,?,?,?,?,?)`, spec.PipelineID, spec.Enabled, string(encoded), spec.NextDue, spec.CreatedAt, stamp) + if err != nil { + return nil, err + } + spec.ID, err = result.LastInsertId() + if err != nil { + return nil, err + } + if requestKey != "" { + if _, err = tx.ExecContext(ctx, `INSERT INTO schedule_create_requests(request_key,schedule_id,payload_hash) VALUES(?,?,?)`, requestKey, spec.ID, payloadHash); err != nil { + return nil, err + } + } + } else { + result, err := tx.ExecContext(ctx, `UPDATE saved_schedules SET revision=?,pipeline_id=?,enabled=?,spec_json=?,next_due=?,updated_at=? WHERE id=? AND revision=? AND deleted=0`, spec.Revision, spec.PipelineID, spec.Enabled, string(encoded), spec.NextDue, stamp, spec.ID, spec.Revision-1) + if err != nil { + return nil, err + } + n, err := result.RowsAffected() + if err != nil { + return nil, err + } + if n != 1 { + return nil, fmt.Errorf("schedule revision conflict") + } + } + if err = tx.Commit(); err != nil { + return nil, err + } + return &spec, nil +} + +func sameScheduleRule(a, b protocol.Schedule) bool { + // Omitted arrays and empty arrays mean the same rule, as does ordering a + // weekday/clock set differently. Neither should reset an unchanged cadence. + return a.Every == b.Every && a.Timezone == b.Timezone && slices.Equal(slices.Sorted(slices.Values(a.Days)), slices.Sorted(slices.Values(b.Days))) && slices.Equal(slices.Sorted(slices.Values(a.Times)), slices.Sorted(slices.Values(b.Times))) +} + +func (s *Store) DeleteSchedule(ctx context.Context, id, revision int64) error { + if id <= 0 || revision <= 0 { + return fmt.Errorf("schedule ID and expected_revision must be positive") + } + s.mu.Lock() + defer s.mu.Unlock() + result, err := s.db.ExecContext(ctx, `UPDATE saved_schedules SET deleted=1,enabled=0,revision=revision+1,updated_at=? WHERE id=? AND revision=? AND deleted=0`, time.Now().UTC().Format(time.RFC3339Nano), id, revision) + if err != nil { + return err + } + n, err := result.RowsAffected() + if err != nil { + return err + } + if n != 1 { + return fmt.Errorf("schedule revision conflict or schedule not found") + } + return nil +} + +func (s *Store) ClaimSavedSchedule(ctx context.Context, item protocol.SavedSchedule, due, next time.Time, status string) (bool, error) { + s.mu.Lock() + defer s.mu.Unlock() + tx, err := s.db.BeginTx(ctx, nil) + if err != nil { + return false, err + } + defer tx.Rollback() + result, err := tx.ExecContext(ctx, `UPDATE saved_schedules SET next_due=? WHERE id=? AND revision=? AND enabled=1 AND deleted=0 AND next_due=?`, next.UTC().Format(time.RFC3339Nano), item.ID, item.Revision, due.UTC().Format(time.RFC3339Nano)) + if err != nil { + return false, err + } + n, err := result.RowsAffected() + if err != nil || n == 0 { + return false, err + } + _, err = tx.ExecContext(ctx, `INSERT INTO saved_schedule_events(schedule_id,due,revision,status) VALUES(?,?,?,?)`, item.ID, due.UTC().Format(time.RFC3339Nano), item.Revision, status) + if err != nil { + return false, err + } + return true, tx.Commit() +} + +func (s *Store) FinishSavedSchedule(ctx context.Context, id int64, due time.Time, status, diagnostic string) error { + _, err := s.db.ExecContext(ctx, `UPDATE saved_schedule_events SET status=?,diagnostic=? WHERE schedule_id=? AND due=?`, status, diagnostic, id, due.UTC().Format(time.RFC3339Nano)) + return err +} + +// ScheduleAdmission is an internal capability, never decoded from public messages. +type ScheduleAdmission struct { + ID, Revision int64 + Due time.Time + Name string +} + +// ResolveRunWorkspace shares exactly the server's manual-run folder semantics. +// Only the one-time legacy import may capture the old process-default directory. +func ResolveRunWorkspace(selected string, required bool) (string, error) { + if selected == "" { + if required { + return "", fmt.Errorf("schedule workspace must be an explicit absolute directory on the execution server") + } + var err error + selected, err = os.Getwd() + if err != nil { + return "", err + } + } + if !filepath.IsAbs(selected) { + return "", fmt.Errorf("run workspace must be an absolute directory") + } + resolved, err := filepath.EvalSymlinks(selected) + if err != nil { + return "", fmt.Errorf("run workspace is unavailable on the execution server: %q: %w; for Docker, mount this host directory at the same absolute path and use its owner's UID/GID", selected, err) + } + info, err := os.Stat(resolved) + if err != nil || !info.IsDir() { + return "", fmt.Errorf("run workspace %q must be an accessible directory on the execution server", selected) + } + return resolved, nil +} diff --git a/internal/pipeline/saved_schedules_test.go b/internal/pipeline/saved_schedules_test.go new file mode 100644 index 00000000..fe319702 --- /dev/null +++ b/internal/pipeline/saved_schedules_test.go @@ -0,0 +1,281 @@ +package pipeline + +import ( + "context" + "encoding/json" + "path/filepath" + "sync" + "sync/atomic" + "testing" + "time" + + "git.a-wan.net/alan/pipelines/internal/protocol" + "git.a-wan.net/alan/pipelines/internal/summarise" +) + +func savedStoreFixture(t *testing.T) (*Store, int64, protocol.SavedSchedule, time.Time) { + t.Helper() + s, err := Open(filepath.Join(t.TempDir(), "schedules.db")) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { s.Close() }) + ctx := context.Background() + if _, err = s.Submit(ctx, "research", Template([]string{"one"}, true)); err != nil { + t.Fatal(err) + } + items, _ := s.List(ctx) + now := time.Date(2026, 10, 20, 12, 0, 0, 0, time.UTC) + spec := protocol.SavedSchedule{Name: "research topic", PipelineID: items[0].ID, Version: 1, Enabled: true, Input: map[string]any{"prompt": "first", "arbitrary": true}, Workspace: t.TempDir(), Rule: protocol.Schedule{Every: "15m"}} + return s, items[0].ID, spec, now +} + +func TestSavedScheduleIndependentCASAndCadence(t *testing.T) { + s, pid, spec, now := savedStoreFixture(t) + ctx := context.Background() + a, err := s.SaveSchedule(ctx, spec, now) + if err != nil { + t.Fatal(err) + } + spec.Input = map[string]any{"prompt": "second"} + spec.Workspace = t.TempDir() + spec.Rule.Every = "1h" + b, err := s.SaveSchedule(ctx, spec, now) + if err != nil { + t.Fatal(err) + } + if a.ID == b.ID || a.NextDue == b.NextDue || a.Workspace == b.Workspace { + t.Fatal(a, b) + } + originalDue := a.NextDue + stale := *a + a.Input = map[string]any{"prompt": "edited", "other": []any{"preserved"}} + a.Rule.Days = []string{} + a.Rule.Times = []string{} + a, err = s.SaveSchedule(ctx, *a, now.Add(time.Minute)) + if err != nil { + t.Fatal(err) + } + if a.NextDue != originalDue || a.Revision != 2 { + t.Fatal("prompt edit changed cadence", a) + } + if _, err = s.SaveSchedule(ctx, stale, now); err == nil { + t.Fatal("stale update accepted") + } + if err = s.DeleteSchedule(ctx, a.ID, stale.Revision); err == nil { + t.Fatal("stale deletion accepted") + } + due, _ := time.Parse(time.RFC3339Nano, a.NextDue) + if ok, err := s.ClaimSavedSchedule(ctx, stale, due, due.Add(15*time.Minute), "claimed"); err != nil || ok { + t.Fatal("stale claim accepted", ok, err) + } + a.Enabled = false + a, err = s.SaveSchedule(ctx, *a, now.Add(2*time.Minute)) + if err != nil { + t.Fatal(err) + } + if ok, err := s.ClaimSavedSchedule(ctx, *a, due, due.Add(15*time.Minute), "claimed"); err != nil || ok { + t.Fatal("disabled claim accepted", ok, err) + } + items, _ := s.List(ctx) + if !items[0].Scheduled || items[0].ScheduleCount != 2 || items[0].EnabledScheduleCount != 1 { + t.Fatal(items) + } + a.Enabled = true + a, err = s.SaveSchedule(ctx, *a, now.Add(3*time.Minute)) + if err != nil { + t.Fatal(err) + } + if a.NextDue != now.Add(18*time.Minute).Format(time.RFC3339Nano) { + t.Fatal("enable did not re-anchor", a) + } + a.Rule.Every = "30m" + a, err = s.SaveSchedule(ctx, *a, now.Add(4*time.Minute)) + if err != nil { + t.Fatal(err) + } + if a.NextDue != now.Add(34*time.Minute).Format(time.RFC3339Nano) { + t.Fatal("rule edit did not re-anchor", a) + } + if err = s.DeleteSchedule(ctx, a.ID, a.Revision); err != nil { + t.Fatal(err) + } + entries, _ := s.ListSchedules(ctx, pid) + if len(entries) != 1 || entries[0].ID != b.ID || entries[0].Input["prompt"] != "second" { + t.Fatal(entries) + } + if err = s.DeleteSchedule(ctx, b.ID, b.Revision); err != nil { + t.Fatal(err) + } + items, _ = s.List(ctx) + if items[0].Scheduled || items[0].ScheduleCount != 0 { + t.Fatal(items) + } +} + +func TestSavedScheduleClaimExactlyOnceAndAtomicOrigin(t *testing.T) { + s, pid, spec, now := savedStoreFixture(t) + ctx := context.Background() + a, err := s.SaveSchedule(ctx, spec, now) + if err != nil { + t.Fatal(err) + } + due, _ := time.Parse(time.RFC3339Nano, a.NextDue) + var claimed atomic.Int64 + var wg sync.WaitGroup + for i := 0; i < 20; i++ { + wg.Add(1) + go func() { + defer wg.Done() + ok, err := s.ClaimSavedSchedule(ctx, *a, due, due.Add(15*time.Minute), "claimed") + if err != nil { + t.Error(err) + } + if ok { + claimed.Add(1) + } + }() + } + wg.Wait() + if claimed.Load() != 1 { + t.Fatal("claim count", claimed.Load()) + } + d, err := s.Get(ctx, pid, 1) + if err != nil { + t.Fatal(err) + } + origin := &ScheduleAdmission{ID: a.ID, Revision: a.Revision, Due: due, Name: a.Name} + id, created, err := s.CreateRunTitled(ctx, d, "scheduled", a.Workspace, false, nil, a.Input, RunOverrides{Schedule: origin}, summarise.Title{}) + if err != nil || !created { + t.Fatal(id, created, err) + } + run, err := s.GetRun(ctx, id) + if err != nil || !run.Scheduled || run.ScheduleID != a.ID || run.ScheduleName != a.Name { + t.Fatal(run, err) + } + var eventRun int64 + var status string + if err = s.db.QueryRow(`SELECT run_id,status FROM saved_schedule_events WHERE schedule_id=?`, a.ID).Scan(&eventRun, &status); err != nil || eventRun != id || status != "admitted" { + t.Fatal(eventRun, status, err) + } + if _, _, err = s.CreateRunTitled(ctx, d, "duplicate-different-key", a.Workspace, false, nil, a.Input, RunOverrides{Schedule: origin}, summarise.Title{}); err == nil { + t.Fatal("occurrence admitted twice") + } + // Durable next_due and provenance survive opening another store; neither old + // occurrences nor enabled rows may be re-imported or replayed. + other, err := Open(s.path) + if err != nil { + t.Fatal(err) + } + defer other.Close() + entries, err := other.ListSchedules(ctx, pid) + if err != nil || len(entries) != 1 || entries[0].NextDue != due.Add(15*time.Minute).Format(time.RFC3339Nano) { + t.Fatal(entries, err) + } + if ok, err := other.ClaimSavedSchedule(ctx, *a, due, due.Add(15*time.Minute), "claimed"); err != nil || ok { + t.Fatal("replayed after restart", ok, err) + } + run, err = other.GetRun(ctx, id) + if err != nil || !run.Scheduled { + t.Fatal(run, err) + } +} + +func TestLegacyScheduleImportPreservesHistoryAndNeverResurrects(t *testing.T) { + s, pid, _, now := savedStoreFixture(t) + ctx := context.Background() + // Construct a genuinely old published version and events directly in this + // isolated database; production APIs must reject these new publications. + source := "# settings\n```schedule\nevery=15m\n```\n```schedule\ntimes=09:00\ntimezone=Europe/London\n```\n```prompt\nLegacy research prompt\n```\n" + Template([]string{"one"}, true) + graph, err := Parse(source) + if err != nil { + t.Fatal(err) + } + encoded, _ := json.Marshal(graph) + if _, err = s.db.Exec(`UPDATE pipeline_versions SET source=?,graph_json=? WHERE pipeline_id=? AND version=1`, source, string(encoded), pid); err != nil { + t.Fatal(err) + } + d, err := s.Get(ctx, pid, 1) + if err != nil { + t.Fatal(err) + } + // A manually launched run on an embedded-schedule pipeline is NOT scheduled. + manual, _, err := s.CreateRun(ctx, d, "manual", t.TempDir(), false, nil, map[string]any{"prompt": "manual"}) + if err != nil { + t.Fatal(err) + } + historical, _, err := s.CreateRun(ctx, d, "real-old-event", t.TempDir(), false, nil, map[string]any{"prompt": "Legacy research prompt"}) + if err != nil { + t.Fatal(err) + } + due := now.Add(15 * time.Minute).Format(time.RFC3339Nano) + if _, err = s.db.Exec(`INSERT INTO schedule_state(pipeline_id,version,slot,next_due) VALUES(?,1,0,?)`, pid, due); err != nil { + t.Fatal(err) + } + if _, err = s.db.Exec(`INSERT INTO schedule_events(pipeline_id,version,slot,due,status,run_id) VALUES(?,1,0,?,'started',?)`, pid, now.Format(time.RFC3339Nano), historical); err != nil { + t.Fatal(err) + } + if _, err = s.db.Exec(`DELETE FROM schedule_migrations`); err != nil { + t.Fatal(err) + } + var before string + if err = s.db.QueryRow(`SELECT source || graph_json || content_hash FROM pipeline_versions WHERE pipeline_id=?`, pid).Scan(&before); err != nil { + t.Fatal(err) + } + // Remove only the new schema from this scratch fixture, so Open exercises + // the actual upgrade path from a pre-external-schedules database. + if _, err = s.db.Exec(`DROP TABLE schedule_create_requests; DROP TABLE run_schedule_origin; DROP TABLE saved_schedule_events; DROP TABLE saved_schedules; DROP TABLE schedule_migrations`); err != nil { + t.Fatal(err) + } + migrated, err := Open(s.path) + if err != nil { + t.Fatal(err) + } + defer migrated.Close() + entries, err := s.ListSchedules(ctx, pid) + if err != nil || len(entries) != 2 { + t.Fatal(entries, err) + } + if entries[0].NextDue != due || entries[0].Input["prompt"] != "Legacy research prompt" || entries[0].Workspace == "" || entries[0].Version != 1 || entries[0].Rule.Timezone == "" { + t.Fatal(entries[0]) + } + run, err := s.GetRun(ctx, historical) + if err != nil || !run.Scheduled || run.ScheduleID != entries[0].ID { + t.Fatal(run, err) + } + run, err = s.GetRun(ctx, manual) + if err != nil || run.Scheduled { + t.Fatal("manual history guessed as scheduled", run, err) + } + if err = s.DeleteSchedule(ctx, entries[0].ID, entries[0].Revision); err != nil { + t.Fatal(err) + } + entries[1].Enabled = false + if _, err = s.SaveSchedule(ctx, entries[1], now); err != nil { + t.Fatal(err) + } + other, err := Open(s.path) + if err != nil { + t.Fatal(err) + } + defer other.Close() + entries, err = other.ListSchedules(ctx, pid) + if err != nil || len(entries) != 1 || entries[0].Enabled { + t.Fatal("resurrected legacy schedule", entries, err) + } + var after string + if err = other.db.QueryRow(`SELECT source || graph_json || content_hash FROM pipeline_versions WHERE pipeline_id=?`, pid).Scan(&after); err != nil || after != before { + t.Fatal("migration rewrote immutable history", err) + } + var count int + if err = other.db.QueryRow(`SELECT COUNT(*) FROM schedule_events WHERE run_id=?`, historical).Scan(&count); err != nil || count != 1 { + t.Fatal("lost legacy event", count, err) + } + run, err = other.GetRun(ctx, historical) + if err != nil || !run.Scheduled || run.ScheduleID == 0 { + t.Fatal("lost deleted schedule history", run, err) + } + if _, err = other.Submit(ctx, "legacy-new", source); err == nil { + t.Fatal("new legacy publication accepted") + } +} diff --git a/internal/pipeline/schedule.go b/internal/pipeline/schedule.go index c644e53a..b185298d 100644 --- a/internal/pipeline/schedule.go +++ b/internal/pipeline/schedule.go @@ -9,6 +9,43 @@ import ( var weekdays = []string{"sun", "mon", "tue", "wed", "thu", "fri", "sat"} +// ParseDefinition validates new publications. Parse deliberately remains a +// historical reader for immutable versions containing deprecated settings. +func ParseDefinition(source string) (protocol.Graph, error) { + g, err := Parse(source) + if err == nil && g.Settings != nil { + err = fmt.Errorf("embedded schedules are read-only legacy definitions; save a separate schedule with a pipeline version and run information instead") + } + return g, err +} + +func ValidateSchedule(rule protocol.Schedule) error { + text := "" + if len(rule.Days) > 0 { + text += "days=" + strings.Join(rule.Days, ",") + "\n" + } + if len(rule.Times) > 0 { + text += "times=" + strings.Join(rule.Times, ",") + "\n" + } + if rule.Every != "" { + text += "every=" + rule.Every + "\n" + } + if rule.Timezone != "" { + text += "timezone=" + rule.Timezone + "\n" + } + parsed, err := parseSchedule(text) + if err != nil { + return err + } + // The structured form is not a second parser dialect: reject whitespace, + // embedded lines and everyday-as-an-array-element rather than validating a + // normalized rule and then executing the original, different one. + if strings.Join(parsed.Days, ",") != strings.Join(rule.Days, ",") || strings.Join(parsed.Times, ",") != strings.Join(rule.Times, ",") || parsed.Every != rule.Every || parsed.Timezone != rule.Timezone { + return fmt.Errorf("schedule rule must use exact weekday/time values; omit days for everyday") + } + return nil +} + func parseSettings(source string) (string, *protocol.Settings, error) { lines := strings.Split(strings.ReplaceAll(source, "\r\n", "\n"), "\n") first := 0 diff --git a/internal/pipeline/schedule_create_requests_test.go b/internal/pipeline/schedule_create_requests_test.go new file mode 100644 index 00000000..91bf085c --- /dev/null +++ b/internal/pipeline/schedule_create_requests_test.go @@ -0,0 +1,70 @@ +package pipeline + +import ( + "context" + "testing" + "time" +) + +func TestScheduleCreateRequestIdempotency(t *testing.T) { + s, pid, spec, now := savedStoreFixture(t) + ctx := context.Background() + a, err := s.SaveSchedule(ctx, spec, now, "editor-one") + if err != nil { + t.Fatal(err) + } + // A lost reply and retry must not create a second timer or re-anchor it. + retry := spec + retry.Name = " " + spec.Name + " " + retry.NextDue = "ignored server metadata" + retry.CreatedAt = "ignored server metadata" + retry.NotifyMode = "auto" + again, err := s.SaveSchedule(ctx, retry, now.Add(time.Minute), "editor-one") + if err != nil || again.ID != a.ID || again.Revision != a.Revision || again.NextDue != a.NextDue { + t.Fatal(again, err) + } + bad := spec + bad.Title = "different editable payload" + if _, err = s.SaveSchedule(ctx, bad, now, "editor-one"); err == nil { + t.Fatal("conflicting create key accepted") + } + // Two deliberately opened editors may save identical run information. + b, err := s.SaveSchedule(ctx, spec, now, "editor-two") + if err != nil || b.ID == a.ID { + t.Fatal(b, err) + } + entries, err := s.ListSchedules(ctx, pid) + if err != nil || len(entries) != 2 { + t.Fatal(entries, err) + } + // The request-key binding survives reopening, not just this connection. + other, err := Open(s.path) + if err != nil { + t.Fatal(err) + } + defer other.Close() + again, err = other.SaveSchedule(ctx, spec, now.Add(time.Hour), "editor-one") + if err != nil || again.ID != a.ID || again.NextDue != a.NextDue { + t.Fatal(again, err) + } + // Retrying an original create never rolls back a later legitimate edit. + a.Input = map[string]any{"prompt": "newly edited prompt"} + a, err = s.SaveSchedule(ctx, *a, now.Add(time.Minute)) + if err != nil { + t.Fatal(err) + } + again, err = s.SaveSchedule(ctx, spec, now.Add(time.Hour), "editor-one") + if err != nil || again.ID != a.ID || again.Input["prompt"] != "newly edited prompt" || again.Revision != a.Revision { + t.Fatal(again, err) + } + if err = s.DeleteSchedule(ctx, a.ID, a.Revision); err != nil { + t.Fatal(err) + } + if _, err = s.SaveSchedule(ctx, spec, now.Add(time.Hour), "editor-one"); err == nil { + t.Fatal("deleted create key resurrected timer") + } + entries, _ = s.ListSchedules(ctx, pid) + if len(entries) != 1 || entries[0].ID != b.ID { + t.Fatal(entries) + } +} diff --git a/internal/pipeline/schedule_store.go b/internal/pipeline/schedule_store.go index 4ce6e4e7..8c9dc88e 100644 --- a/internal/pipeline/schedule_store.go +++ b/internal/pipeline/schedule_store.go @@ -1,12 +1,8 @@ package pipeline -import ( - "context" - "git.a-wan.net/alan/pipelines/internal/protocol" - "time" -) - func (s *Store) initSchedules() error { + // Retain the legacy tables intact as migration evidence and audit history. + // No runtime writer dispatches or advances embedded-definition schedules. _, err := s.db.Exec(`CREATE TABLE IF NOT EXISTS schedule_state ( pipeline_id INTEGER NOT NULL REFERENCES pipelines(id), version INTEGER NOT NULL, slot INTEGER NOT NULL, next_due TEXT NOT NULL, PRIMARY KEY(pipeline_id,version,slot)); @@ -14,51 +10,8 @@ func (s *Store) initSchedules() error { id INTEGER PRIMARY KEY, pipeline_id INTEGER NOT NULL, version INTEGER NOT NULL, slot INTEGER NOT NULL, due TEXT NOT NULL, status TEXT NOT NULL, diagnostic TEXT NOT NULL DEFAULT '', run_id INTEGER, UNIQUE(pipeline_id,version,slot,due));`) - return err -} - -func (s *Store) ScheduleDue(ctx context.Context, d *protocol.PipelineDetail, slot int, rule protocol.Schedule, now time.Time) (time.Time, error) { - next, err := NextSchedule(rule, now) - if err != nil { - return time.Time{}, err - } - _, err = s.db.ExecContext(ctx, `INSERT INTO schedule_state(pipeline_id,version,slot,next_due) VALUES(?,?,?,?) ON CONFLICT DO NOTHING`, d.ID, d.Version, slot, next.UTC().Format(time.RFC3339Nano)) - if err != nil { - return time.Time{}, err - } - var text string - err = s.db.QueryRowContext(ctx, `SELECT next_due FROM schedule_state WHERE pipeline_id=? AND version=? AND slot=?`, d.ID, d.Version, slot).Scan(&text) - if err != nil { - return time.Time{}, err - } - return time.Parse(time.RFC3339Nano, text) -} - -// Claim and advance before dispatch. A crash cannot replay the occurrence. -// The latest-version check prevents an observed old schedule from starting after -// it was replaced or removed by a newer submission. -func (s *Store) ClaimSchedule(ctx context.Context, d *protocol.PipelineDetail, slot int, due, next time.Time, status string) (bool, error) { - tx, err := s.db.BeginTx(ctx, nil) - if err != nil { - return false, err - } - defer tx.Rollback() - result, err := tx.ExecContext(ctx, `UPDATE schedule_state SET next_due=? WHERE pipeline_id=? AND version=? AND slot=? AND next_due=? AND version=(SELECT MAX(version) FROM pipeline_versions WHERE pipeline_id=?)`, next.UTC().Format(time.RFC3339Nano), d.ID, d.Version, slot, due.UTC().Format(time.RFC3339Nano), d.ID) - if err != nil { - return false, err - } - n, err := result.RowsAffected() - if err != nil || n == 0 { - return false, err - } - _, err = tx.ExecContext(ctx, `INSERT INTO schedule_events(pipeline_id,version,slot,due,status) VALUES(?,?,?,?,?)`, d.ID, d.Version, slot, due.UTC().Format(time.RFC3339Nano), status) - if err != nil { - return false, err - } - return true, tx.Commit() -} - -func (s *Store) FinishSchedule(ctx context.Context, d *protocol.PipelineDetail, slot int, due time.Time, status, diagnostic string, runID int64) error { - _, err := s.db.ExecContext(ctx, `UPDATE schedule_events SET status=?,diagnostic=?,run_id=? WHERE pipeline_id=? AND version=? AND slot=? AND due=?`, status, diagnostic, runID, d.ID, d.Version, slot, due.UTC().Format(time.RFC3339Nano)) - return err + if err != nil { + return err + } + return s.initSavedSchedules() } diff --git a/internal/pipeline/store.go b/internal/pipeline/store.go index f98f86e4..fe412ae3 100644 --- a/internal/pipeline/store.go +++ b/internal/pipeline/store.go @@ -12,7 +12,6 @@ import ( "path/filepath" "strings" "sync" - "time" _ "modernc.org/sqlite" ) @@ -150,7 +149,9 @@ func (s *Store) List(ctx context.Context) ([]protocol.PipelineSummary, error) { rows, err := s.db.QueryContext(ctx, `SELECT p.id, p.name, v.version, json_array_length(v.graph_json, '$.stages'), strftime('%Y-%m-%dT%H:%M:%SZ', p.created_at), strftime('%Y-%m-%dT%H:%M:%SZ', v.created_at), -v.graph_json +v.graph_json, +(SELECT COUNT(*) FROM saved_schedules WHERE pipeline_id=p.id AND deleted=0), +(SELECT COUNT(*) FROM saved_schedules WHERE pipeline_id=p.id AND deleted=0 AND enabled=1) FROM pipelines p JOIN pipeline_versions v ON v.pipeline_id=p.id WHERE v.version=(SELECT MAX(version) FROM pipeline_versions WHERE pipeline_id=p.id) ORDER BY p.name, p.id`) @@ -162,10 +163,11 @@ ORDER BY p.name, p.id`) for rows.Next() { var item protocol.PipelineSummary var graphJSON string - if err := rows.Scan(&item.ID, &item.Name, &item.Version, &item.Stages, &item.CreatedAt, &item.UpdatedAt, &graphJSON); err != nil { + if err := rows.Scan(&item.ID, &item.Name, &item.Version, &item.Stages, &item.CreatedAt, &item.UpdatedAt, &graphJSON, &item.ScheduleCount, &item.EnabledScheduleCount); err != nil { return nil, err } var shape protocol.Graph + item.Scheduled = item.ScheduleCount > 0 if err := json.Unmarshal([]byte(graphJSON), &shape); err == nil && len(shape.Stages) > 0 { // A list needs the drawing, not the definition: strip prompts, // configs, tools, limits, notifications and checks so one list reply @@ -236,6 +238,10 @@ FROM pipeline_versions WHERE pipeline_id=? AND version=?`, id, version). } } detail.Stages = len(detail.Graph.Stages) + if err := tx.QueryRowContext(ctx, `SELECT COUNT(*),COALESCE(SUM(enabled),0) FROM saved_schedules WHERE pipeline_id=? AND deleted=0`, id).Scan(&detail.ScheduleCount, &detail.EnabledScheduleCount); err != nil { + return nil, err + } + detail.Scheduled = detail.ScheduleCount > 0 rows, err := tx.QueryContext(ctx, `SELECT version,json_array_length(graph_json,'$.stages'),strftime('%Y-%m-%dT%H:%M:%SZ',created_at) FROM pipeline_versions WHERE pipeline_id=? ORDER BY version DESC`, id) if err != nil { @@ -272,7 +278,7 @@ func (s *Store) SubmitChecked(ctx context.Context, name, source string, createOn s.mu.Lock() defer s.mu.Unlock() name = strings.TrimSpace(name) - g, validation := Parse(source) + g, validation := ParseDefinition(source) if expectedVersion < 0 { validation = fmt.Errorf("expected version must be nonnegative") } @@ -322,18 +328,6 @@ func (s *Store) SubmitChecked(ctx context.Context, name, source string, createOn return 0, err } versionID = id - if g.Settings != nil { - activated := time.Now() - for slot, rule := range g.Settings.Schedules { - next, err := NextSchedule(rule, activated) - if err != nil { - return 0, err - } - if _, err := tx.ExecContext(ctx, `INSERT INTO schedule_state(pipeline_id,version,slot,next_due) VALUES(?,?,?,?)`, pid, version, slot, next.UTC().Format(time.RFC3339Nano)); err != nil { - return 0, err - } - } - } } } diagnostic := "" diff --git a/internal/protocol/message.go b/internal/protocol/message.go index 5390e3b4..352592ef 100644 --- a/internal/protocol/message.go +++ b/internal/protocol/message.go @@ -94,12 +94,15 @@ type PipelineDetail struct { } type PipelineSummary struct { - ID int64 `json:"id"` - Name string `json:"name"` - Version int `json:"version"` - Stages int `json:"stages"` - CreatedAt string `json:"created_at"` - UpdatedAt string `json:"updated_at"` + Scheduled bool `json:"scheduled"` + ScheduleCount int `json:"schedule_count"` + EnabledScheduleCount int `json:"enabled_schedule_count"` + ID int64 `json:"id"` + Name string `json:"name"` + Version int `json:"version"` + Stages int `json:"stages"` + CreatedAt string `json:"created_at"` + UpdatedAt string `json:"updated_at"` // Shape is the current version's parsed graph, included so a list can draw // a miniature without one detail request per row. Detail responses keep the // full Graph field; this one is deliberately optional and additive. @@ -113,6 +116,10 @@ type PipelineSummary struct { // are optional so older peers ignore them. See search.go for the per-type payloads // and the ranking/kind/bound vocabulary. type Message struct { + Schedule *SavedSchedule `json:"schedule,omitempty"` + Schedules []SavedSchedule `json:"schedules,omitempty"` + ScheduleID int64 `json:"schedule_id,omitempty"` + ExpectedRevision int64 `json:"expected_revision,omitempty"` DefaultHarness string `json:"default_harness,omitempty"` Build *buildinfo.Info `json:"build,omitempty"` Protocol int `json:"protocol,omitempty"` diff --git a/internal/protocol/runevents.go b/internal/protocol/runevents.go index ab523b47..3cf602f4 100644 --- a/internal/protocol/runevents.go +++ b/internal/protocol/runevents.go @@ -25,6 +25,9 @@ const ( // from the frame instead of re-reading the whole list. They repeat on every // frame (pipeline identity never changes mid-run). type RunEventFrame struct { + Scheduled bool `json:"scheduled"` + ScheduleID int64 `json:"schedule_id,omitempty"` + ScheduleName string `json:"schedule_name,omitempty"` // SessionExportUpdated requests a detail refresh even when the stage/run // outcome is unchanged. It never fabricates a second stage completion. SessionExportUpdated bool `json:"session_export_updated,omitempty"` diff --git a/internal/protocol/runevents_test.go b/internal/protocol/runevents_test.go index 2c9cd480..930ea42f 100644 --- a/internal/protocol/runevents_test.go +++ b/internal/protocol/runevents_test.go @@ -21,7 +21,7 @@ func TestRunEventGoldenJSON(t *testing.T) { if err != nil { t.Fatal(err) } - want := `{"run_id":7,"workspace":"/work","pipeline_id":4,"name":"release","title":"Ship it","version":3,"status":"running","current_stage":"build","completed_steps":1,"created_at":"2026-01-02T03:04:05Z","artifacts":2,"step":{"sequence":2,"stage":"build","status":"completed","outcome":"success","target":"#success","artifacts":2}}` + want := `{"scheduled":false,"run_id":7,"workspace":"/work","pipeline_id":4,"name":"release","title":"Ship it","version":3,"status":"running","current_stage":"build","completed_steps":1,"created_at":"2026-01-02T03:04:05Z","artifacts":2,"step":{"sequence":2,"stage":"build","status":"completed","outcome":"success","target":"#success","artifacts":2}}` if string(encoded) != want { t.Fatalf("golden mismatch\n got %s\nwant %s", encoded, want) } diff --git a/internal/protocol/runs.go b/internal/protocol/runs.go index d173fd44..dd48554a 100644 --- a/internal/protocol/runs.go +++ b/internal/protocol/runs.go @@ -134,6 +134,9 @@ type SessionExportRecovery struct { } type RunSummary struct { + Scheduled bool `json:"scheduled"` + ScheduleID int64 `json:"schedule_id,omitempty"` + ScheduleName string `json:"schedule_name,omitempty"` GraphEvidence *RunGraphEvidence `json:"graph_evidence,omitempty"` NotifyMode string `json:"notify_mode,omitempty"` ID int64 `json:"id"` diff --git a/internal/protocol/schedules.go b/internal/protocol/schedules.go new file mode 100644 index 00000000..2640f42b --- /dev/null +++ b/internal/protocol/schedules.go @@ -0,0 +1,32 @@ +package protocol + +const ( + ListSchedules = "list_schedules" + Schedules = "schedules" + SaveSchedule = "save_schedule" + SavedScheduleReply = "schedule" + DeleteSchedule = "delete_schedule" + ScheduleDeleted = "schedule_deleted" +) + +// SavedSchedule pairs an immutable pipeline version with a complete run request. +// Revision is the compare-and-swap token for edits and deletion; zero creates. +type SavedSchedule struct { + ID int64 `json:"id"` + Revision int64 `json:"revision"` + Name string `json:"name"` + PipelineID int64 `json:"pipeline_id"` + Version int `json:"version"` + Enabled bool `json:"enabled"` + Input map[string]any `json:"input"` + Workspace string `json:"workspace"` + Model string `json:"model,omitempty"` + StageModels map[string]string `json:"stage_models,omitempty"` + NotifyMode string `json:"notify_mode,omitempty"` + Title string `json:"title,omitempty"` + OutputFormat string `json:"output_format,omitempty"` + Rule Schedule `json:"rule"` + NextDue string `json:"next_due"` + CreatedAt string `json:"created_at"` + UpdatedAt string `json:"updated_at"` +} diff --git a/internal/server/runevents.go b/internal/server/runevents.go index a586cef6..5d38d6ab 100644 --- a/internal/server/runevents.go +++ b/internal/server/runevents.go @@ -430,6 +430,11 @@ func mergeRunEventFrame(into, in *protocol.RunEventFrame) { if in.NotifyMode != "" { into.NotifyMode = in.NotifyMode } + if in.Scheduled { + into.Scheduled = true + into.ScheduleID = in.ScheduleID + into.ScheduleName = in.ScheduleName + } into.CancelRequested = into.CancelRequested || in.CancelRequested into.CleanupUnconfirmed = into.CleanupUnconfirmed || in.CleanupUnconfirmed if in.Workspace != "" { @@ -510,6 +515,9 @@ func handleRunEvents(request protocol.Message, events *runEventHub, runs *runner continue } frame := protocol.RunEventFrame{ + Scheduled: summary.Scheduled, + ScheduleID: summary.ScheduleID, + ScheduleName: summary.ScheduleName, GraphEvidence: summary.GraphEvidence, NotifyMode: summary.NotifyMode, RunID: summary.ID, diff --git a/internal/server/runner.go b/internal/server/runner.go index fb41e370..5cebf2f5 100644 --- a/internal/server/runner.go +++ b/internal/server/runner.go @@ -128,34 +128,20 @@ func newRunner(ctx context.Context, s *pipeline.Store) (*runner, error) { } func (r *runner) start(request protocol.Message, retryOf ...int64) (*protocol.RunDetail, error) { + return r.startWithSchedule(request, nil, retryOf...) +} + +func (r *runner) startWithSchedule(request protocol.Message, origin *pipeline.ScheduleAdmission, retryOf ...int64) (*protocol.RunDetail, error) { if err := protocol.ValidateOutputFormat(request.OutputFormat); err != nil { return nil, err } if request.Version <= 0 || request.RequestKey == "" || len(request.RequestKey) > 128 { return nil, fmt.Errorf("an explicit version and request key are required") } - workspace, err := os.Getwd() + workspace, err := pipeline.ResolveRunWorkspace(request.Workspace, origin != nil) if err != nil { return nil, err } - workspace, err = filepath.EvalSymlinks(workspace) - if err != nil { - return nil, err - } - if request.Workspace != "" { - if !filepath.IsAbs(request.Workspace) { - return nil, fmt.Errorf("run workspace must be an absolute directory") - } - selected, err := filepath.EvalSymlinks(request.Workspace) - if err != nil { - return nil, fmt.Errorf("run workspace is unavailable on the execution server: %q: %w; for Docker, mount this host directory at the same absolute path and use its owner's UID/GID", request.Workspace, err) - } - info, err := os.Stat(selected) - if err != nil || !info.IsDir() { - return nil, fmt.Errorf("run workspace %q must be an accessible directory on the execution server", request.Workspace) - } - workspace = selected - } if len(request.WritePaths) > 20 { return nil, fmt.Errorf("too many write paths") } @@ -293,7 +279,7 @@ func (r *runner) start(request protocol.Message, retryOf ...int64) (*protocol.Ru return nil, err } } - id, created, err := r.store.CreateRunTitled(r.ctx, d, request.RequestKey, workspace, request.AllowTools, request.WritePaths, request.Input, pipeline.RunOverrides{Model: request.Model, StageModels: request.StageModels, NotifyMode: request.NotifyMode, OutputFormat: request.OutputFormat}, runTitle, retryOf...) + id, created, err := r.store.CreateRunTitled(r.ctx, d, request.RequestKey, workspace, request.AllowTools, request.WritePaths, request.Input, pipeline.RunOverrides{Schedule: origin, Model: request.Model, StageModels: request.StageModels, NotifyMode: request.NotifyMode, OutputFormat: request.OutputFormat}, runTitle, retryOf...) if err != nil { return nil, err } @@ -1302,26 +1288,29 @@ func (s *runState) publishServerChangedFiles() { // emitRun, so a client that has never seen the run can build its list row from // the frame without re-reading the whole list. type runIdentity struct { - pipelineID int64 - name string - title string - version int + scheduled bool + scheduleID int64 + scheduleName string + pipelineID int64 + name string + title string + version int } // identityOfRunSummary is the one projection of a run row onto the identity its // pushed frames carry, so the frame and the list row cannot disagree. func identityOfRunSummary(s protocol.RunSummary) runIdentity { - return runIdentity{pipelineID: s.PipelineID, name: s.Name, title: s.Title, version: s.Version} + return runIdentity{scheduled: s.Scheduled, scheduleID: s.ScheduleID, scheduleName: s.ScheduleName, pipelineID: s.PipelineID, name: s.Name, title: s.Title, version: s.Version} } // rememberRunIdentity records the identity every later frame of run id carries. // It is safe from any goroutine and takes its own lock (never r.mu), so it is // callable from a path that already holds r.mu. func (r *runner) rememberRunIdentity(id int64, ident runIdentity) { - if r.idents == nil { - return - } r.identMu.Lock() + if r.idents == nil { + r.idents = map[int64]runIdentity{} + } r.idents[id] = ident r.identMu.Unlock() } @@ -1336,6 +1325,9 @@ func (r *runner) stampRunIdentity(frame *protocol.RunEventFrame) { if !ok { return } + frame.Scheduled = ident.scheduled + frame.ScheduleID = ident.scheduleID + frame.ScheduleName = ident.scheduleName if frame.PipelineID == 0 { frame.PipelineID = ident.pipelineID } diff --git a/internal/server/schedule_websocket_test.go b/internal/server/schedule_websocket_test.go index 00cb2ded..e18a3ad9 100644 --- a/internal/server/schedule_websocket_test.go +++ b/internal/server/schedule_websocket_test.go @@ -2,26 +2,148 @@ package server import ( "context" - "git.a-wan.net/alan/pipelines/internal/pipeline" - "git.a-wan.net/alan/pipelines/internal/protocol" - "github.com/coder/websocket" - "github.com/coder/websocket/wsjson" "net/http/httptest" "path/filepath" "strings" "testing" "time" + + "git.a-wan.net/alan/pipelines/internal/pipeline" + "git.a-wan.net/alan/pipelines/internal/protocol" + "github.com/coder/websocket" + "github.com/coder/websocket/wsjson" ) -func TestScheduleSubmissionOverWebSocket(t *testing.T) { +func TestScheduleAPIOverWebSocket(t *testing.T) { ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) defer cancel() - store, err := pipeline.Open(filepath.Join(t.TempDir(), "ws.db")) + s, err := pipeline.Open(filepath.Join(t.TempDir(), "ws.db")) if err != nil { t.Fatal(err) } - defer store.Close() - handler := HandlerWithOptions(ctx, Options{AllowAuthoring: true}, store) + defer s.Close() + if _, err = s.Submit(ctx, "research", pipeline.Template([]string{"one"}, true)); err != nil { + t.Fatal(err) + } + items, _ := s.List(ctx) + handler := HandlerWithOptions(ctx, Options{}, s) + defer func() { cancel(); WaitRuns(handler) }() + srv := httptest.NewServer(handler) + defer srv.Close() + conn, _, err := websocket.Dial(ctx, "ws"+strings.TrimPrefix(srv.URL, "http")+"/connect", nil) + if err != nil { + t.Fatal(err) + } + defer conn.CloseNow() + var hello protocol.Message + if err = wsjson.Read(ctx, conn, &hello); err != nil { + t.Fatal(err) + } + rpc := func(request protocol.Message) protocol.Message { + t.Helper() + request.ID = "rpc" + if err := wsjson.Write(ctx, conn, request); err != nil { + t.Fatal(err) + } + var response protocol.Message + if err := wsjson.Read(ctx, conn, &response); err != nil { + t.Fatal(err) + } + if response.ID != request.ID { + t.Fatal(response) + } + return response + } + // Saving run information is not definition authoring, and works on run-only servers. + spec := protocol.SavedSchedule{Name: "first", PipelineID: items[0].ID, Version: 1, Enabled: true, Workspace: t.TempDir(), Input: map[string]any{"prompt": "first research", "arbitrary": "retained"}, Rule: protocol.Schedule{Every: "15m"}, Model: "openai/gpt", NotifyMode: "off", Title: "Research"} + response := rpc(protocol.Message{Type: protocol.SaveSchedule, Schedule: &spec, RequestKey: "editor-first"}) + if response.Type != protocol.SavedScheduleReply || response.Schedule == nil || response.Schedule.ID == 0 || response.Schedule.Revision != 1 { + t.Fatal(response) + } + a := *response.Schedule + response = rpc(protocol.Message{Type: protocol.SaveSchedule, Schedule: &spec, RequestKey: "editor-first"}) + if response.Schedule == nil || response.Schedule.ID != a.ID || response.Schedule.Revision != a.Revision { + t.Fatal("lost reply duplicated timer", response) + } + conflicting := spec + conflicting.Title = "different payload" + response = rpc(protocol.Message{Type: protocol.SaveSchedule, Schedule: &conflicting, RequestKey: "editor-first"}) + if response.Type != protocol.Error { + t.Fatal("conflicting create accepted", response) + } + spec.Name = "second" + spec.Input = map[string]any{"prompt": "second research"} + response = rpc(protocol.Message{Type: protocol.SaveSchedule, Schedule: &spec, RequestKey: "editor-second"}) + if response.Schedule == nil || response.Schedule.ID == a.ID { + t.Fatal(response) + } + b := *response.Schedule + response = rpc(protocol.Message{Type: protocol.ListSchedules, PipelineID: items[0].ID}) + if response.Type != protocol.Schedules || len(response.Schedules) != 2 { + t.Fatal(response) + } + a.Enabled = false + response = rpc(protocol.Message{Type: protocol.SaveSchedule, Schedule: &a}) + if response.Schedule == nil || response.Schedule.Enabled || response.Schedule.Revision != 2 { + t.Fatal(response) + } + response = rpc(protocol.Message{Type: protocol.SaveSchedule, Schedule: &a}) + if response.Type != protocol.Error || !strings.Contains(response.Error, "conflict") { + t.Fatal("stale edit accepted", response) + } + response = rpc(protocol.Message{Type: protocol.DeleteSchedule, ScheduleID: a.ID, ExpectedRevision: 1}) + if response.Type != protocol.Error { + t.Fatal("stale delete accepted", response) + } + response = rpc(protocol.Message{Type: protocol.DeleteSchedule, ScheduleID: b.ID, ExpectedRevision: b.Revision}) + if response.Type != protocol.ScheduleDeleted || response.ScheduleID != b.ID { + t.Fatal(response) + } + response = rpc(protocol.Message{Type: protocol.List}) + if len(response.Pipelines) != 1 || !response.Pipelines[0].Scheduled || response.Pipelines[0].ScheduleCount != 1 || response.Pipelines[0].EnabledScheduleCount != 0 { + t.Fatal("paused schedule projection", response) + } + response = rpc(protocol.Message{Type: protocol.GetPipeline, PipelineID: items[0].ID}) + if response.Detail == nil || response.Detail.ScheduleCount != 1 || !response.Detail.Scheduled { + t.Fatal(response) + } + for _, mutate := range []func(*protocol.SavedSchedule){ + func(s *protocol.SavedSchedule) { s.Workspace = "" }, + func(s *protocol.SavedSchedule) { s.Workspace = "relative" }, + func(s *protocol.SavedSchedule) { s.Workspace = filepath.Join(t.TempDir(), "missing") }, + func(s *protocol.SavedSchedule) { s.Version = 0 }, + func(s *protocol.SavedSchedule) { s.Version = 999 }, + func(s *protocol.SavedSchedule) { s.Input = map[string]any{"unknown": "missing prompt"} }, + func(s *protocol.SavedSchedule) { s.Rule.Every = "1s" }, + func(s *protocol.SavedSchedule) { s.Rule.Times = []string{"09:00"} }, + func(s *protocol.SavedSchedule) { s.Rule.Timezone = "invalid/zone" }, + func(s *protocol.SavedSchedule) { s.StageModels = map[string]string{"missing": "openai/gpt"} }, + func(s *protocol.SavedSchedule) { s.Model = "invalid" }, + func(s *protocol.SavedSchedule) { s.NotifyMode = "invalid" }, + func(s *protocol.SavedSchedule) { s.OutputFormat = "invalid" }, + } { + bad := spec + mutate(&bad) + response = rpc(protocol.Message{Type: protocol.SaveSchedule, Schedule: &bad}) + if response.Type != protocol.Error { + t.Fatal("invalid config saved", bad, response) + } + } + response = rpc(protocol.Message{Type: protocol.ListRuns}) + if len(response.Runs) != 0 { + t.Fatal("validation started work", response) + } +} + +func TestEmbeddedSchedulesReadOnlyOverWebSocket(t *testing.T) { + ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) + defer cancel() + s, err := pipeline.Open(filepath.Join(t.TempDir(), "ws.db")) + if err != nil { + t.Fatal(err) + } + defer s.Close() + handler := HandlerWithOptions(ctx, Options{AllowAuthoring: true}, s) defer func() { cancel(); WaitRuns(handler) }() srv := httptest.NewServer(handler) defer srv.Close() @@ -31,33 +153,22 @@ func TestScheduleSubmissionOverWebSocket(t *testing.T) { } defer conn.CloseNow() var response protocol.Message - if err := wsjson.Read(ctx, conn, &response); err != nil { + if err = wsjson.Read(ctx, conn, &response); err != nil { t.Fatal(err) } - base := "\n```\n```prompt\ntask\n```\n" + pipeline.Template([]string{"one"}, true) - for _, test := range []struct { - rule string - valid bool - }{{"every=15m\ntimes=09:00", false}, {"days=mon", false}, {"every=15m\ndays=mon,fri", true}, {"times=09:00,17:30\ndays=tue,thu", true}} { - source := "# settings\n```schedule\n" + test.rule + base - request := protocol.Message{Type: protocol.Submit, ID: "submit", Name: "scheduled", Source: source} - if err := wsjson.Write(ctx, conn, request); err != nil { + source := "# settings\n```schedule\nevery=15m\n```\n```prompt\ntask\n```\n" + pipeline.Template([]string{"one"}, true) + if _, err = pipeline.Parse(source); err != nil { + t.Fatal("legacy reader broken", err) + } + for _, command := range []string{protocol.Validate, protocol.Submit} { + if err = wsjson.Write(ctx, conn, protocol.Message{Type: command, Name: "legacy", Source: source}); err != nil { t.Fatal(err) } - if err := wsjson.Read(ctx, conn, &response); err != nil { + if err = wsjson.Read(ctx, conn, &response); err != nil { t.Fatal(err) } - if test.valid { - if response.Type != protocol.Submitted || response.Detail == nil || response.Detail.Graph.Settings == nil { - t.Fatal("schedule not accepted/returned", response) - } - d := response.Detail - due, err := store.ScheduleDue(ctx, d, 0, d.Graph.Settings.Schedules[0], time.Now()) - if err != nil || !due.After(time.Now()) { - t.Fatal("schedule not activated", due, err) - } - } else if response.Type != protocol.Error || !strings.Contains(response.Error, "exactly one") { - t.Fatal("XOR not enforced over websocket", response) + if response.Type != protocol.Error || !strings.Contains(response.Error, "separate schedule") { + t.Fatal(response) } } } diff --git a/internal/server/scheduler.go b/internal/server/scheduler.go index 52f82e9e..99ea06e1 100644 --- a/internal/server/scheduler.go +++ b/internal/server/scheduler.go @@ -2,10 +2,11 @@ package server import ( "fmt" - "git.a-wan.net/alan/pipelines/internal/pipeline" - "git.a-wan.net/alan/pipelines/internal/protocol" "log" "time" + + "git.a-wan.net/alan/pipelines/internal/pipeline" + "git.a-wan.net/alan/pipelines/internal/protocol" ) func (r *runner) scheduleLoop() { @@ -30,68 +31,62 @@ func (r *runner) scheduleLoop() { } func (r *runner) scheduleTick(now time.Time, recovery bool) error { - items, err := r.store.List(r.ctx) + items, err := r.store.ListSchedules(r.ctx, 0) if err != nil { return err } for _, item := range items { - d, err := r.store.Get(r.ctx, item.ID, 0) + if !item.Enabled { + continue + } + due, err := time.Parse(time.RFC3339Nano, item.NextDue) if err != nil { return err } - if d.Graph.Settings == nil { + if due.After(now) { continue } - for slot, rule := range d.Graph.Settings.Schedules { - due, err := r.store.ScheduleDue(r.ctx, d, slot, rule, now) - if err != nil { - return err - } - if due.After(now) { - continue - } - next, err := pipeline.NextSchedule(rule, now) - if err != nil { - return err - } - if rule.Every != "" { - interval, _ := time.ParseDuration(rule.Every) - next = due.Add((now.Sub(due)/interval + 1) * interval) - } - status := "claimed" - if recovery || now.Sub(due) > 5*time.Second { - status = "skipped_missed" - } - loc, err := pipeline.ScheduleLocation(rule) - if err != nil { - return err - } - if !pipeline.ScheduleDay(rule, due.In(loc)) { - status = "skipped_day" - } - claimed, err := r.store.ClaimSchedule(r.ctx, d, slot, due, next, status) - if err != nil { - return err - } - if !claimed || status != "claimed" { - continue - } - request := protocol.Message{PipelineID: d.ID, Version: d.Version, RequestKey: fmt.Sprintf("schedule:%d:%d:%d:%d", d.ID, d.Version, slot, due.UnixNano()), Input: map[string]any{"prompt": d.Graph.Settings.Prompt}} - run, err := r.start(request) - runID := int64(0) - diagnostic := "" - status = "started" - if err != nil { - status = "skipped" - diagnostic = err.Error() - } else { - runID = run.ID - } - if err := r.store.FinishSchedule(r.ctx, d, slot, due, status, diagnostic, runID); err != nil { - return err - } - log.Printf("schedule pipeline=%d version=%d slot=%d due=%s status=%s run=%d %s", d.ID, d.Version, slot, due.Format(time.RFC3339), status, runID, diagnostic) + next, err := pipeline.NextSchedule(item.Rule, now) + if err != nil { + return err } + if item.Rule.Every != "" { + interval, _ := time.ParseDuration(item.Rule.Every) + next = due.Add((now.Sub(due)/interval + 1) * interval) + } + status := "claimed" + if recovery || now.Sub(due) > 5*time.Second { + status = "skipped_missed" + } + loc, err := pipeline.ScheduleLocation(item.Rule) + if err != nil { + return err + } + if !pipeline.ScheduleDay(item.Rule, due.In(loc)) { + status = "skipped_day" + } + claimed, err := r.store.ClaimSavedSchedule(r.ctx, item, due, next, status) + if err != nil { + return err + } + if !claimed || status != "claimed" { + continue + } + request := protocol.Message{PipelineID: item.PipelineID, Version: item.Version, RequestKey: fmt.Sprintf("saved-schedule:%d:%d", item.ID, due.UnixNano()), Input: item.Input, Workspace: item.Workspace, Model: item.Model, StageModels: item.StageModels, NotifyMode: item.NotifyMode, Title: item.Title, OutputFormat: item.OutputFormat} + run, err := r.startWithSchedule(request, &pipeline.ScheduleAdmission{ID: item.ID, Revision: item.Revision, Due: due, Name: item.Name}) + diagnostic := "" + status = "started" + var runID int64 + if err != nil { + status = "skipped" + diagnostic = err.Error() + } else { + runID = run.ID + } + if err := r.store.FinishSavedSchedule(r.ctx, item.ID, due, status, diagnostic); err != nil { + return err + } + log.Printf("schedule id=%d pipeline=%d version=%d due=%s status=%s run=%d %s", item.ID, item.PipelineID, item.Version, due.Format(time.RFC3339), status, runID, diagnostic) } return nil } diff --git a/internal/server/scheduler_test.go b/internal/server/scheduler_test.go index 6b3fb848..3a9e5b28 100644 --- a/internal/server/scheduler_test.go +++ b/internal/server/scheduler_test.go @@ -2,163 +2,208 @@ package server import ( "context" - "git.a-wan.net/alan/pipelines/internal/pipeline" - "git.a-wan.net/alan/pipelines/internal/stage" - "os" + "fmt" "path/filepath" - "strings" + "sync" "testing" "time" + + "git.a-wan.net/alan/pipelines/internal/pipeline" + "git.a-wan.net/alan/pipelines/internal/protocol" + "git.a-wan.net/alan/pipelines/internal/stage" + "git.a-wan.net/alan/pipelines/internal/summarise" ) -func TestScheduledExecutionPersistenceAndSkipping(t *testing.T) { +func scheduleFixture(t *testing.T) (context.Context, *pipeline.Store, *runner, int64) { + t.Helper() ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - path := filepath.Join(t.TempDir(), "schedule.db") - store, err := pipeline.Open(path) + s, err := pipeline.Open(filepath.Join(t.TempDir(), "schedule.db")) if err != nil { t.Fatal(err) } - defer func() { store.Close() }() - source := "# settings\n```schedule\nevery=15m\ndays=everyday\n```\n```prompt\nScheduled task\n```\n" + pipeline.Template([]string{"one"}, true) - if _, err := store.Submit(ctx, "scheduled", source); err != nil { + if _, err = s.Submit(ctx, "research", pipeline.Template([]string{"one"}, true)); err != nil { t.Fatal(err) } - items, _ := store.List(ctx) - d, _ := store.Get(ctx, items[0].ID, 0) - rule := d.Graph.Settings.Schedules[0] + items, err := s.List(ctx) + if err != nil { + t.Fatal(err) + } + r, err := newRunner(ctx, s) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { cancel(); r.schedulerWG.Wait(); r.wg.Wait(); s.Close() }) + return ctx, s, r, items[0].ID +} + +func saveTestSchedule(t *testing.T, ctx context.Context, s *pipeline.Store, pid int64, prompt, workspace, every string, now time.Time) *protocol.SavedSchedule { + t.Helper() + item, err := s.SaveSchedule(ctx, protocol.SavedSchedule{Name: prompt, PipelineID: pid, Version: 1, Enabled: true, Workspace: workspace, Input: map[string]any{"prompt": prompt, "custom": map[string]any{"nested": "kept"}}, Rule: protocol.Schedule{Every: every}, Model: "openai/default", StageModels: map[string]string{"one": "openai/override"}, NotifyMode: "off", Title: "Scheduled research", OutputFormat: "markdown"}, now) + if err != nil { + t.Fatal(err) + } + return item +} + +func dueOf(t *testing.T, item *protocol.SavedSchedule) time.Time { + t.Helper() + due, err := time.Parse(time.RFC3339Nano, item.NextDue) + if err != nil { + t.Fatal(err) + } + return due +} + +func TestIndependentScheduledRunsAndProvenance(t *testing.T) { + ctx, s, r, pid := scheduleFixture(t) now := time.Now() - due, err := store.ScheduleDue(ctx, d, 0, rule, now) - if err != nil { - t.Fatal(err) - } - // Reopening must retain the activation/cadence, not reset the timer. - store.Close() - store, err = pipeline.Open(path) - if err != nil { - t.Fatal(err) - } - persisted, err := store.ScheduleDue(ctx, d, 0, rule, now.Add(time.Minute)) - if err != nil || !persisted.Equal(due) { - t.Fatal("timer reset on restart", persisted, due, err) - } - r, err := newRunner(ctx, store) - if err != nil { - t.Fatal(err) - } - calls := 0 + a := saveTestSchedule(t, ctx, s, pid, "First research", t.TempDir(), "1m", now) + b := saveTestSchedule(t, ctx, s, pid, "Second research", t.TempDir(), "90s", now) + r.events = newRunEventHub() + frames := make(chan protocol.RunEventFrame, 64) + sub := r.events.subscribe("schedules", "", nil, func(m protocol.Message) error { frames <- *m.RunEvent; return nil }) + sub.ready() + defer sub.close() + var mu sync.Mutex + seen := map[string]bool{} r.execute = func(ctx context.Context, def stage.Definition, input stage.Values) (stage.Result, error) { - calls++ - if input["prompt"] != "Scheduled task" { - t.Error("wrong scheduled prompt") + mu.Lock() + seen[fmt.Sprint(input["prompt"])] = true + mu.Unlock() + if def.Configs["model"] != "override" || def.Configs["provider"] != "openai" { + t.Error("model override missing", def.Configs) } - return stage.Result{Outcome: "success", Output: stage.Values{"done": true}}, nil + if input["custom"] == nil { + t.Error("arbitrary saved input lost") + } + return stage.Result{Outcome: "success", Output: stage.Values{"done": true, "markdown": "# Research report"}}, nil } - if err := r.scheduleTick(due, false); err != nil { + for _, item := range []*protocol.SavedSchedule{a, b} { + if err := r.scheduleTick(dueOf(t, item), false); err != nil { + t.Fatal(err) + } + r.wg.Wait() + } + runs, err := s.ListRuns(ctx) + if err != nil || len(runs) != 2 { + t.Fatal(runs, err) + } + for _, run := range runs { + if !run.Scheduled || run.ScheduleID == 0 || run.ScheduleName == "" || run.Version != 1 || run.NotifyMode != "off" || run.Title != "Scheduled research" || run.Status != "succeeded" || run.OutputFormat != "markdown" { + t.Fatalf("missing provenance or spec: %+v", run) + } + d, err := s.GetRun(ctx, run.ID) + if err != nil || !d.Scheduled || d.Input["custom"] == nil { + t.Fatal(d, err) + } + } + mu.Lock() + if !seen[a.Name] || !seen[b.Name] { + t.Error("independent prompts missing", seen) + } + mu.Unlock() + terminals := 0 + deadline := time.After(2 * time.Second) + for terminals < 2 { + select { + case frame := <-frames: + if !frame.Scheduled || frame.ScheduleID == 0 || frame.ScheduleName == "" { + t.Fatal("frame preceded provenance", frame) + } + if frame.Status == "succeeded" { + terminals++ + } + case <-deadline: + t.Fatal("missing scheduled terminal frames") + } + } + manual, err := r.start(protocol.Message{ScheduleID: a.ID, PipelineID: pid, Version: 1, Workspace: a.Workspace, RequestKey: "manual", Input: map[string]any{"prompt": "manual", "custom": true}, Model: "openai/override", NotifyMode: "off"}) + if err != nil { t.Fatal(err) } r.wg.Wait() - runs, err := store.ListRuns(ctx) - if err != nil || len(runs) != 1 || runs[0].Status != "succeeded" || calls != 1 { - t.Fatal("scheduled execution", runs, calls, err) + if manual.Scheduled || manual.ScheduleID != 0 { + t.Fatal("manual run forged schedule origin", manual) } - detail, _ := store.GetRun(ctx, runs[0].ID) - if detail.AllowTools { - t.Fatal("scheduled run granted tools") + manual, err = s.GetRun(ctx, manual.ID) + if err != nil || manual.Scheduled { + t.Fatal(manual, err) } - if err := r.scheduleTick(due, false); err != nil { + if _, err = s.Submit(ctx, "research", pipeline.Template([]string{"one", "two"}, true)); err != nil { t.Fatal(err) } - if calls != 1 { - t.Fatal("duplicate occurrence") + entries, _ := s.ListSchedules(ctx, pid) + if len(entries) != 2 || entries[0].Version != 1 { + t.Fatal(entries) } - next, _ := store.ScheduleDue(ctx, d, 0, rule, due) - if err := r.scheduleTick(next.Add(time.Hour), true); err != nil { + if err = s.DeleteSchedule(ctx, a.ID, a.Revision); err != nil { t.Fatal(err) } - runs, _ = store.ListRuns(ctx) - if len(runs) != 1 { - t.Fatal("replayed downtime backlog") - } - // A new manual-only version disables the old schedule. - if _, err := store.Submit(ctx, "scheduled", pipeline.Template([]string{"one"}, true)); err != nil { - t.Fatal(err) - } - next, _ = store.ScheduleDue(ctx, d, 0, rule, due) - claimed, err := store.ClaimSchedule(ctx, d, 0, next, next.Add(time.Minute), "claimed") - if err != nil || claimed { - t.Fatal("obsolete schedule claimed", err) - } - if err := r.scheduleTick(next, false); err != nil { - t.Fatal(err) - } - runs, _ = store.ListRuns(ctx) - if len(runs) != 1 { - t.Fatal("disabled schedule executed") - } -} - -// Opt-in wall-clock integration: no clock injection, no external model calls. -func TestLiveScheduleLoop(t *testing.T) { - if os.Getenv("PIPELINES_LIVE_SCHEDULE_TEST") != "1" { - t.Skip("set PIPELINES_LIVE_SCHEDULE_TEST=1 for the one-minute wall-clock check") - } - ctx, cancel := context.WithCancel(context.Background()) - store, err := pipeline.Open(filepath.Join(t.TempDir(), "live.db")) - if err != nil { - t.Fatal(err) - } - defer store.Close() - r, err := newRunner(ctx, store) - if err != nil { - t.Fatal(err) - } - executed := make(chan stage.Values, 1) - r.execute = func(ctx context.Context, def stage.Definition, input stage.Values) (stage.Result, error) { - executed <- input - return stage.Result{Outcome: "success", Output: stage.Values{"done": true}}, nil - } - r.schedulerWG.Add(1) - go r.scheduleLoop() - defer func() { cancel(); r.schedulerWG.Wait(); r.wg.Wait() }() - source := "# settings\n```schedule\nevery=1m\n```\n```prompt\nwall-clock task\n```\n" + pipeline.Template([]string{"one"}, true) - if _, err := store.Submit(ctx, "live", source); err != nil { - t.Fatal(err) - } - select { - case input := <-executed: - if input["prompt"] != "wall-clock task" { - t.Fatal("wrong prompt", input) + for _, run := range runs { + d, _ := s.GetRun(ctx, run.ID) + if !d.Scheduled || d.ScheduleName != run.ScheduleName { + t.Fatal("delete erased provenance", d) } - case <-time.After(75 * time.Second): - t.Fatal("wall-clock scheduler did not dispatch") } - r.wg.Wait() - runs, err := store.ListRuns(ctx) - if err != nil || len(runs) != 1 || runs[0].Status != "succeeded" { - t.Fatal("scheduled audit missing", runs, err) + // A reconnect snapshot uses the same durable origin after deletion, while + // the manually admitted run remains unscheduled. + var snapshots []protocol.RunEventFrame + if !handleRunEvents(protocol.Message{Type: protocol.Subscribe}, r.events, r, "snapshot", func(m protocol.Message) error { + if m.RunEvent != nil { + snapshots = append(snapshots, *m.RunEvent) + } + return nil + }) { + t.Fatal("subscribe not handled") + } + defer r.events.unsubscribeClient("snapshot") + if len(snapshots) != 3 { + t.Fatal("snapshot count", snapshots) + } + for _, frame := range snapshots { + if frame.RunID == manual.ID { + if frame.Scheduled { + t.Fatal("manual snapshot forged", frame) + } + } else if !frame.Scheduled || frame.ScheduleID == 0 || frame.ScheduleName == "" { + t.Fatal("snapshot lost origin", frame) + } } } -func TestSchedulerSkipsOverlapAndExcludedDays(t *testing.T) { - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - store, err := pipeline.Open(filepath.Join(t.TempDir(), "schedule.db")) - if err != nil { - t.Fatal(err) - } - defer store.Close() - source := "# settings\n```schedule\nevery=15m\n```\n```prompt\ntask\n```\n" + pipeline.Template([]string{"one"}, true) - if _, err := store.Submit(ctx, "test", source); err != nil { - t.Fatal(err) - } - items, _ := store.List(ctx) - d, _ := store.Get(ctx, items[0].ID, 0) - rule := d.Graph.Settings.Schedules[0] - due, _ := store.ScheduleDue(ctx, d, 0, rule, time.Now()) - r, _ := newRunner(ctx, store) +func TestScheduleDeletionDoesNotCancelAdmittedRun(t *testing.T) { + ctx, s, r, pid := scheduleFixture(t) + item := saveTestSchedule(t, ctx, s, pid, "active research", t.TempDir(), "1m", time.Now()) entered, release := make(chan struct{}), make(chan struct{}) - r.execute = func(ctx context.Context, def stage.Definition, input stage.Values) (stage.Result, error) { + r.execute = func(context.Context, stage.Definition, stage.Values) (stage.Result, error) { + close(entered) + <-release + return stage.Result{Outcome: "success", Output: stage.Values{"markdown": "# Finished"}}, nil + } + if err := r.scheduleTick(dueOf(t, item), false); err != nil { + t.Fatal(err) + } + <-entered + if err := s.DeleteSchedule(ctx, item.ID, item.Revision); err != nil { + t.Fatal(err) + } + if err := r.scheduleTick(dueOf(t, item).Add(time.Minute), false); err != nil { + t.Fatal(err) + } + close(release) + r.wg.Wait() + runs, err := s.ListRuns(ctx) + if err != nil || len(runs) != 1 || runs[0].Status != "succeeded" || !runs[0].Scheduled || runs[0].ScheduleID != item.ID { + t.Fatal(runs, err) + } +} + +func TestSavedScheduleRecoveryAndOverlap(t *testing.T) { + ctx, s, r, pid := scheduleFixture(t) + item := saveTestSchedule(t, ctx, s, pid, "task", t.TempDir(), "1m", time.Now()) + due := dueOf(t, item) + entered, release := make(chan struct{}), make(chan struct{}) + r.execute = func(context.Context, stage.Definition, stage.Values) (stage.Result, error) { close(entered) <-release return stage.Result{Outcome: "success", Output: stage.Values{}}, nil @@ -167,30 +212,81 @@ func TestSchedulerSkipsOverlapAndExcludedDays(t *testing.T) { t.Fatal(err) } <-entered - if err := r.scheduleTick(due.Add(15*time.Minute), false); err != nil { + if err := r.scheduleTick(due.Add(time.Minute), false); err != nil { t.Fatal(err) } - runs, _ := store.ListRuns(ctx) - if len(runs) != 1 { - t.Fatal("overlap started") - } close(release) r.wg.Wait() - // A weekday different from the upcoming due date must exclude that occurrence. + if err := r.scheduleTick(due.Add(time.Minute), false); err != nil { + t.Fatal(err) + } + if err := r.scheduleTick(due.Add(time.Hour), true); err != nil { + t.Fatal(err) + } + if err := r.scheduleTick(due.Add(time.Hour), false); err != nil { + t.Fatal(err) + } + runs, err := s.ListRuns(ctx) + if err != nil || len(runs) != 1 { + t.Fatal("replayed or overlapping work", runs, err) + } + entries, _ := s.ListSchedules(ctx, pid) + item = &entries[0] + next := dueOf(t, item) days := []string{"sun", "mon", "tue", "wed", "thu", "fri", "sat"} - excluded := days[(time.Now().Add(15*time.Minute).In(time.Local).Weekday()+1)%7] - source = strings.Replace(source, "every=15m", "every=15m\ndays="+excluded, 1) - if _, err := store.Submit(ctx, "test", source); err != nil { + item.Rule.Days = []string{days[(next.In(time.Local).Weekday()+1)%7]} + item, err = s.SaveSchedule(ctx, *item, next.Add(-time.Minute)) + if err != nil { t.Fatal(err) } - d, _ = store.Get(ctx, d.ID, 0) - rule = d.Graph.Settings.Schedules[0] - due, _ = store.ScheduleDue(ctx, d, 0, rule, time.Now()) - if err := r.scheduleTick(due, false); err != nil { + if err = r.scheduleTick(dueOf(t, item), false); err != nil { t.Fatal(err) } - runs, _ = store.ListRuns(ctx) + runs, _ = s.ListRuns(ctx) if len(runs) != 1 { - t.Fatal("excluded day executed") + t.Fatal("excluded day dispatched", runs) + } +} + +func TestScheduleEditBetweenClaimAndAdmission(t *testing.T) { + for _, operation := range []string{"disable", "edit", "delete"} { + t.Run(operation, func(t *testing.T) { + ctx, s, r, pid := scheduleFixture(t) + item := saveTestSchedule(t, ctx, s, pid, "task", t.TempDir(), "1m", time.Now()) + item.Title = "" + var err error + item, err = s.SaveSchedule(ctx, *item, time.Now()) + if err != nil { + t.Fatal(err) + } + r.title = func(context.Context, string) summarise.Title { + if operation == "delete" { + err = s.DeleteSchedule(ctx, item.ID, item.Revision) + } else { + if operation == "disable" { + item.Enabled = false + } else { + item.Input["prompt"] = "new prompt" + } + _, err = s.SaveSchedule(ctx, *item, time.Now()) + } + if err != nil { + t.Error(err) + } + return summarise.Title{Text: "title"} + } + r.execute = func(context.Context, stage.Definition, stage.Values) (stage.Result, error) { + t.Error("invalidated occurrence executed") + return stage.Result{}, nil + } + if err = r.scheduleTick(dueOf(t, item), false); err != nil { + t.Fatal(err) + } + r.wg.Wait() + runs, _ := s.ListRuns(ctx) + if len(runs) != 0 { + t.Fatal("invalidated occurrence admitted", runs) + } + }) } } diff --git a/internal/server/tools_test.go b/internal/server/tools_test.go index e07e81df..2c200e26 100644 --- a/internal/server/tools_test.go +++ b/internal/server/tools_test.go @@ -48,13 +48,12 @@ func TestWebStagesCanRunWithoutMutationApproval(t *testing.T) { if detail.AllowTools || detail.Status != "succeeded" || len(detail.Steps) != 2 { t.Fatal("web stage required broad approval", detail) } - // Scheduling uses the same prompt-only request and accepts declared web tools. - scheduled := "# settings\n```schedule\nevery=15m\n```\n```prompt\ntask\n```\n" + source - if _, err := store.Submit(ctx, "web", scheduled); err != nil { + // A separate saved run request accepts the same declared web tools. + entry, err := store.SaveSchedule(ctx, protocol.SavedSchedule{Name: "web", PipelineID: items[0].ID, Version: 1, Enabled: true, Workspace: t.TempDir(), Input: map[string]any{"prompt": "task"}, Rule: protocol.Schedule{Every: "15m"}}, time.Now()) + if err != nil { t.Fatal(err) } - d, _ := store.Get(ctx, items[0].ID, 0) - due, _ := store.ScheduleDue(ctx, d, 0, d.Graph.Settings.Schedules[0], time.Now()) + due := dueOf(t, entry) if err := r.scheduleTick(due, false); err != nil { t.Fatal(err) } diff --git a/internal/server/websocket.go b/internal/server/websocket.go index 277a684c..7cc2204e 100644 --- a/internal/server/websocket.go +++ b/internal/server/websocket.go @@ -2,6 +2,7 @@ package server import ( "context" + "fmt" "log" "net/http" "strings" @@ -210,7 +211,7 @@ func HandlerWithOptions(ctx context.Context, options Options, stores ...*pipelin response.Templates[i].Source = pipeline.WithDefaults(response.Templates[i].Source, model, backend) } } else if request.Type == protocol.Validate { - graph, err := pipeline.Parse(request.Source) + graph, err := pipeline.ParseDefinition(request.Source) response.Type = protocol.Validated if err != nil { response.Type = protocol.Error @@ -218,6 +219,32 @@ func HandlerWithOptions(ctx context.Context, options Options, stores ...*pipelin } else { response.Graph = &graph } + } else if (request.Type == protocol.ListSchedules || request.Type == protocol.SaveSchedule || request.Type == protocol.DeleteSchedule) && len(stores) > 0 { + var err error + switch request.Type { + case protocol.ListSchedules: + response.Type = protocol.Schedules + if request.PipelineID < 0 { + err = fmt.Errorf("pipeline_id must be nonnegative") + } else { + response.Schedules, err = stores[0].ListSchedules(ctx, request.PipelineID) + } + case protocol.SaveSchedule: + response.Type = protocol.SavedScheduleReply + if request.Schedule == nil { + err = fmt.Errorf("schedule is required") + } else { + response.Schedule, err = stores[0].SaveSchedule(ctx, *request.Schedule, time.Now(), request.RequestKey) + } + case protocol.DeleteSchedule: + response.Type = protocol.ScheduleDeleted + response.ScheduleID = request.ScheduleID + err = stores[0].DeleteSchedule(ctx, request.ScheduleID, request.ExpectedRevision) + } + if err != nil { + response.Type = protocol.Error + response.Error = err.Error() + } } else if request.Type == protocol.Submit && len(stores) > 0 { response.Type = protocol.Submitted response.Name = strings.TrimSpace(request.Name)