Separate saved run schedules from pipeline definitions
This commit is contained in:
@@ -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 != "{}" {
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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
|
||||
}
|
||||
@@ -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")
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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
@@ -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 := ""
|
||||
|
||||
@@ -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"`
|
||||
|
||||
@@ -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"`
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
|
||||
@@ -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"`
|
||||
|
||||
@@ -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"`
|
||||
}
|
||||
@@ -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
@@ -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
|
||||
}
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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
@@ -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)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
|
||||
@@ -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)
|
||||
|
||||
Reference in New Issue
Block a user