436 lines
16 KiB
Go
436 lines
16 KiB
Go
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
|
||
}
|