Files
pipelines/internal/pipeline/saved_schedules.go
T

436 lines
16 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
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
}
now := time.Now()
for _, l := range all {
if l.graph.Settings == nil {
continue
}
for slot, rule := range l.graph.Settings.Schedules {
if rule.Timezone == "" {
// Preserve execution-server-local semantics without capturing an
// offline opener's timezone. ScheduleLocation resolves Local there.
rule.Timezone = "Local"
}
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
}
// Opening a store does not identify the execution server: maintenance
// and offline clients can migrate it from any working directory.
// Only runner startup may bind this trusted legacy exception.
spec := protocol.SavedSchedule{Name: fmt.Sprintf("%s (legacy %d)", l.name, slot+1), PipelineID: l.id, Version: l.version, Enabled: true, 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()
}
// BindLegacyScheduleWorkspace captures the old runtime-default workspace once,
// from the execution server before admission APIs or the scheduler are available.
// Store.Open never supplies it. Blank workspaces are allowed only on imported
// legacy rows; normal saves always require an explicit accessible directory.
// Only this missing field is filled: revisions, cadence, enabled state, tombstones,
// provenance and any workspace already chosen by the operator remain untouched.
func (s *Store) BindLegacyScheduleWorkspace(ctx context.Context, workspace string) error {
resolved, err := ResolveRunWorkspace(workspace, true)
if err != nil {
return err
}
s.mu.Lock()
defer s.mu.Unlock()
_, err = s.db.ExecContext(ctx, `UPDATE saved_schedules SET spec_json=json_set(spec_json,'$.workspace',?) WHERE legacy_version IS NOT NULL AND legacy_slot IS NOT NULL AND deleted=0 AND COALESCE(json_extract(spec_json,'$.workspace'),'')=''`, resolved)
return err
}
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 err = ValidateRunWritePaths(workspace, spec.WritePaths); err != nil {
return nil, err
}
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 execution-server startup may capture the old legacy 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
}