Files
pipelines/internal/pipeline/store.go
T
alan 865993b200 Rework omni search onto a typed search contract and add a TUI artifacts view
Protocol: replace the loose Query/Kind/Matches/Limit search fields with a Search request object and a SearchResults response, and have the server answer search from Store.Search over the shared run projections (runFrom/runStamps).

CLI: add the read-only 'pipelines search QUERY [--type KIND] [--limit N] [--json]' command with usage/help, and document the typed targets, ranking and bounds in docs/cli.md.

TUI: the '/' popup keeps type-to-search, up/down, Enter and Esc, renders one ranked list with kind badges and a bracketed (non-colour) match snippet, and Enter opens the matched pipeline, run, step, artifact or field; footer text updated to match.

TUI: add a dedicated run artifacts view ('A') with open/copy of recorded files, and move artifacts out of the run-detail File changes section (artifactCaptureNotes).

Tests: add Store.OpenReadOnly for read-only inspection of a live database plus pipeline/server/TUI search tests and artifacts tests, including env-gated live checks.
2026-10-16 23:48:38 +01:00

260 lines
8.8 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"
"git.a-wan.net/alan/pipelines/internal/protocol"
"git.a-wan.net/alan/pipelines/internal/stage"
"os"
"path/filepath"
"strings"
"sync"
"time"
_ "modernc.org/sqlite"
)
type Store struct {
db *sql.DB
dir string
mu sync.Mutex
}
func Open(path string) (*Store, error) {
db, err := sql.Open("sqlite", path)
if err != nil {
return nil, err
}
db.SetMaxOpenConns(1)
_, err = db.Exec(`PRAGMA foreign_keys=ON; PRAGMA journal_mode=WAL; PRAGMA busy_timeout=5000;
CREATE TABLE IF NOT EXISTS pipelines (id INTEGER PRIMARY KEY, name TEXT NOT NULL UNIQUE, created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP);
CREATE TABLE IF NOT EXISTS pipeline_versions (id INTEGER PRIMARY KEY, pipeline_id INTEGER NOT NULL REFERENCES pipelines(id), version INTEGER NOT NULL, source TEXT NOT NULL, content_hash TEXT NOT NULL, graph_json TEXT NOT NULL, created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP, UNIQUE(pipeline_id, version));
CREATE TABLE IF NOT EXISTS submissions (id INTEGER PRIMARY KEY, name TEXT NOT NULL, source TEXT NOT NULL, diagnostic TEXT NOT NULL, version_id INTEGER REFERENCES pipeline_versions(id), created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP);`)
if err != nil {
db.Close()
return nil, err
}
s := &Store{db: db, dir: filepath.Dir(path)}
if err := s.initRuns(); err != nil {
db.Close()
return nil, err
}
if err := s.initSchedules(); err != nil {
db.Close()
return nil, err
}
return s, nil
}
func (s *Store) Close() error { return s.db.Close() }
// OpenReadOnly opens an existing database without running schema DDL or
// changing journal mode, so a live database can be queried read-only while its
// server keeps writing. It fails when the file does not exist. It is used by
// tests that inspect a real database and is never part of server startup.
func OpenReadOnly(path string) (*Store, error) {
if _, err := os.Stat(path); err != nil {
return nil, err
}
db, err := sql.Open("sqlite", "file:"+path+"?mode=ro")
if err != nil {
return nil, err
}
db.SetMaxOpenConns(1)
if _, err := db.Exec("PRAGMA busy_timeout=5000"); err != nil {
db.Close()
return nil, err
}
return &Store{db: db, dir: filepath.Dir(path)}, nil
}
// Directory is the resolved directory holding the database, used to place
// adjacent server state such as stage artifacts.
func (s *Store) Directory() string { return s.dir }
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)
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`)
if err != nil {
return nil, err
}
defer rows.Close()
result := []protocol.PipelineSummary{}
for rows.Next() {
var item protocol.PipelineSummary
if err := rows.Scan(&item.ID, &item.Name, &item.Version, &item.Stages, &item.CreatedAt, &item.UpdatedAt); err != nil {
return nil, err
}
result = append(result, item)
}
return result, rows.Err()
}
// Get returns a consistent immutable version and the available version history.
// Version zero selects the latest accepted version.
func (s *Store) Get(ctx context.Context, id int64, version int) (*protocol.PipelineDetail, error) {
if id <= 0 || version < 0 {
return nil, fmt.Errorf("invalid pipeline ID or version")
}
tx, err := s.db.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
if err != nil {
return nil, err
}
defer tx.Rollback()
detail := &protocol.PipelineDetail{}
err = tx.QueryRowContext(ctx, `SELECT p.id,p.name,strftime('%Y-%m-%dT%H:%M:%SZ',p.created_at),
v.version,strftime('%Y-%m-%dT%H:%M:%SZ',v.created_at)
FROM pipelines p JOIN pipeline_versions v ON v.pipeline_id=p.id
WHERE p.id=? ORDER BY v.version DESC LIMIT 1`, id).
Scan(&detail.ID, &detail.Name, &detail.CreatedAt, &detail.LatestVersion, &detail.UpdatedAt)
if err == sql.ErrNoRows {
return nil, fmt.Errorf("pipeline not found")
}
if err != nil {
return nil, err
}
if version == 0 {
version = detail.LatestVersion
}
var graph string
err = tx.QueryRowContext(ctx, `SELECT version,source,content_hash,graph_json,strftime('%Y-%m-%dT%H:%M:%SZ',created_at)
FROM pipeline_versions WHERE pipeline_id=? AND version=?`, id, version).
Scan(&detail.Version, &detail.Source, &detail.ContentHash, &graph, &detail.VersionCreatedAt)
if err == sql.ErrNoRows {
return nil, fmt.Errorf("pipeline version not found")
}
if err != nil {
return nil, err
}
if err := json.Unmarshal([]byte(graph), &detail.Graph); err != nil {
return nil, err
}
// Normalize legacy terminal aliases for clients without rewriting history.
for i := range detail.Graph.Stages {
s := &detail.Graph.Stages[i]
s.Type = stage.EffectiveType(s.Type)
for outcome, target := range s.Edges {
s.Edges[outcome] = protocol.ResolveTarget(outcome, target)
}
}
detail.Stages = len(detail.Graph.Stages)
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 {
return nil, err
}
detail.Versions = []protocol.VersionSummary{}
for rows.Next() {
var item protocol.VersionSummary
if err := rows.Scan(&item.Version, &item.Stages, &item.CreatedAt); err != nil {
rows.Close()
return nil, err
}
detail.Versions = append(detail.Versions, item)
}
err = rows.Err()
rows.Close()
if err != nil {
return nil, err
}
if err := tx.Commit(); err != nil {
return nil, err
}
return detail, nil
}
// Submit persists both accepted and rejected submissions. Equality is source-byte equality.
func (s *Store) Submit(ctx context.Context, name, source string, createOnly ...bool) (int, error) {
fresh := len(createOnly) > 0 && createOnly[0]
return s.SubmitChecked(ctx, name, source, fresh, 0)
}
// SubmitChecked guards draft edits against concurrent accepted versions atomically.
func (s *Store) SubmitChecked(ctx context.Context, name, source string, createOnly bool, expectedVersion int) (int, error) {
s.mu.Lock()
defer s.mu.Unlock()
name = strings.TrimSpace(name)
g, validation := Parse(source)
if expectedVersion < 0 {
validation = fmt.Errorf("expected version must be nonnegative")
}
if name == "" || len(name) > 200 || strings.ContainsAny(name, "\r\n\x00") {
validation = fmt.Errorf("pipeline name must be 1–200 bytes without line breaks or NUL")
}
tx, err := s.db.BeginTx(ctx, nil)
if err != nil {
return 0, err
}
defer tx.Rollback()
var pid int64
var version int
var versionID any
hash := fmt.Sprintf("%x", sha256.Sum256([]byte(source)))
if validation == nil {
_, err = tx.ExecContext(ctx, "INSERT INTO pipelines(name) VALUES (?) ON CONFLICT(name) DO NOTHING", name)
if err != nil {
return 0, err
}
if err = tx.QueryRowContext(ctx, "SELECT id FROM pipelines WHERE name=?", name).Scan(&pid); err != nil {
return 0, err
}
var latestHash string
err = tx.QueryRowContext(ctx, "SELECT version, content_hash FROM pipeline_versions WHERE pipeline_id=? ORDER BY version DESC LIMIT 1", pid).Scan(&version, &latestHash)
if err != nil && err != sql.ErrNoRows {
return 0, err
}
if createOnly && version > 0 {
validation = fmt.Errorf("pipeline name already exists; choose a new name")
} else if expectedVersion > 0 && version != expectedVersion {
validation = fmt.Errorf("draft conflict: expected latest version %d, found %d; review changes before submitting", expectedVersion, version)
} else if hash == latestHash {
validation = fmt.Errorf("no changes")
} else {
version++
encoded, err := json.Marshal(g)
if err != nil {
return 0, err
}
result, err := tx.ExecContext(ctx, "INSERT INTO pipeline_versions(pipeline_id,version,source,content_hash,graph_json) VALUES (?,?,?,?,?)", pid, version, source, hash, string(encoded))
if err != nil {
return 0, err
}
id, err := result.LastInsertId()
if err != nil {
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 := ""
if validation != nil {
diagnostic = validation.Error()
}
if _, err := tx.ExecContext(ctx, "INSERT INTO submissions(name,source,diagnostic,version_id) VALUES (?,?,?,?)", name, source, diagnostic, versionID); err != nil {
return 0, err
}
if err := tx.Commit(); err != nil {
return 0, err
}
return version, validation
}