Separate saved run schedules from pipeline definitions

This commit is contained in:
2026-10-21 00:47:56 +01:00
parent 366931eeec
commit 4d8b34939d
20 changed files with 1391 additions and 336 deletions
+5 -2
View File
@@ -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 != "{}" {
+26
View File
@@ -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
+418
View File
@@ -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
}
+281
View File
@@ -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")
}
}
+37
View File
@@ -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
@@ -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)
}
}
+6 -53
View File
@@ -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()
}
+10 -16
View File
@@ -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 := ""
+13 -6
View File
@@ -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"`
+3
View File
@@ -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"`
+1 -1
View File
@@ -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)
}
+3
View File
@@ -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"`
+32
View File
@@ -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"`
}
+8
View File
@@ -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,
+20 -28
View File
@@ -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
}
+140 -29
View File
@@ -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)
}
}
}
+49 -54
View File
@@ -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
}
+237 -141
View File
@@ -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)
}
})
}
}
+4 -5
View File
@@ -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)
}
+28 -1
View File
@@ -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)