Files
pipelines/internal/pipeline/runs_sessions.go
T

146 lines
5.5 KiB
Go

package pipeline
import (
"context"
)
func (s *Store) RunSession(ctx context.Context, id int64, sequence int, session string, active bool, metadata ...string) error {
tx, err := s.db.BeginTx(ctx, nil)
if err != nil {
return err
}
defer tx.Rollback()
if err = affected(tx.ExecContext(ctx, "UPDATE run_steps SET session_id=?,agent_active=? WHERE run_id=? AND sequence=? AND status='running'", session, active, id, sequence)); err != nil {
return err
}
if len(metadata) > 0 {
backend := metadata[0]
if backend == "" {
backend = "v2"
}
reference := ""
if len(metadata) > 1 {
reference = metadata[1]
}
if _, err = tx.ExecContext(ctx, "INSERT INTO run_session_owners(run_id,sequence,backend,reference) VALUES(?,?,?,?) ON CONFLICT(run_id,sequence) DO UPDATE SET backend=excluded.backend,reference=excluded.reference", id, sequence, backend, reference); err != nil {
return err
}
}
return tx.Commit()
}
// ConfirmRecoveredSession clears the agent-active marker after startup has
// interrupted a previously active session, so it no longer blocks new work.
func (s *Store) ConfirmRecoveredSession(ctx context.Context, owner SessionOwner) error {
tx, err := s.db.BeginTx(ctx, nil)
if err != nil {
return err
}
defer tx.Rollback()
if _, err := tx.ExecContext(ctx, "UPDATE run_steps SET agent_active=0 WHERE run_id=? AND session_id=?", owner.RunID, owner.ID); err != nil {
return err
}
if _, err := tx.ExecContext(ctx, `UPDATE pipeline_runs SET cleanup_unconfirmed=0 WHERE id=? AND NOT EXISTS(SELECT 1 FROM run_steps WHERE run_id=? AND agent_active=1)`, owner.RunID, owner.RunID); err != nil {
return err
}
return tx.Commit()
}
type SessionOwner struct {
ID string
Backend string
Directory string
Reference string
// RunID is the owning run, used to tell an orphaned session (no active run)
// from one owned by a run that is active right now.
RunID int64
// Active is true while the owning step records the session as agent-active.
Active bool
}
func (s *Store) RunSessionOwner(ctx context.Context, id int64, sequence int) (SessionOwner, error) {
var owner SessionOwner
err := s.db.QueryRowContext(ctx, `SELECT s.session_id,COALESCE(o.backend,'v2'),r.workspace,COALESCE(o.reference,'') FROM run_steps s JOIN pipeline_runs r ON r.id=s.run_id LEFT JOIN run_session_owners o ON o.run_id=s.run_id AND o.sequence=s.sequence WHERE s.run_id=? AND s.sequence=?`, id, sequence).Scan(&owner.ID, &owner.Backend, &owner.Directory, &owner.Reference)
return owner, err
}
// sessionOwnerScanLimit bounds the ownership scan so a long-lived database with
// thousands of historical sessions cannot make one chat_sessions request scan
// them all. Rows are read newest-run first, so the bound only ever drops the
// oldest owners, never the sessions a client can still be writing.
const sessionOwnerScanLimit = 1024
// ActiveSessionOwners reports every currently active agent session, deduped by
// session id (newest owning run wins).
func (s *Store) ActiveSessionOwners(ctx context.Context) ([]SessionOwner, error) {
return s.sessionOwners(ctx, true)
}
// OwnedSessions reports every session the server ever recorded in run_steps,
// deduped by session id (newest owning run wins) and including inactive ones, so
// chat_sessions can be restricted to sessions this server created.
func (s *Store) OwnedSessions(ctx context.Context) ([]SessionOwner, error) {
return s.sessionOwners(ctx, false)
}
// sessionOwners is the single ownership query both ActiveSessionOwners and
// OwnedSessions run, so the SQL is not duplicated. It reads one bounded,
// newest-run-first window and drops repeated session ids in favour of the most
// recent owning run's directory and active flag.
func (s *Store) sessionOwners(ctx context.Context, activeOnly bool) ([]SessionOwner, error) {
query := `SELECT s.session_id,COALESCE(o.backend,'v2'),r.workspace,COALESCE(o.reference,''),s.run_id,s.agent_active
FROM run_steps s JOIN pipeline_runs r ON r.id=s.run_id LEFT JOIN run_session_owners o ON o.run_id=s.run_id AND o.sequence=s.sequence WHERE s.session_id<>''`
if activeOnly {
query += " AND s.agent_active=1"
}
query += " ORDER BY s.run_id DESC"
var args []any
if !activeOnly {
query += " LIMIT ?"
args = append(args, sessionOwnerScanLimit)
}
// Recovery cannot silently drop old but still-active owners at the history cap.
rows, err := s.db.QueryContext(ctx, query, args...)
if err != nil {
return nil, err
}
defer rows.Close()
seen := map[string]struct{}{}
var owners []SessionOwner
for rows.Next() {
var owner SessionOwner
var active int
if err = rows.Scan(&owner.ID, &owner.Backend, &owner.Directory, &owner.Reference, &owner.RunID, &active); err != nil {
return nil, err
}
owner.Active = active != 0
if _, ok := seen[owner.ID]; ok {
continue
}
seen[owner.ID] = struct{}{}
owners = append(owners, owner)
}
return owners, rows.Err()
}
// ActiveAgentSessionsForRun returns the distinct active agent session ids that
// belong to one run. It is scoped to run_steps.run_id so concurrent runs never
// observe each other's sessions: run_steps is keyed by (run_id, sequence), so
// this is one indexed lookup, not a scan.
func (s *Store) ActiveAgentSessionsForRun(ctx context.Context, runID int64) ([]string, error) {
rows, err := s.db.QueryContext(ctx, "SELECT DISTINCT session_id FROM run_steps WHERE run_id=? AND agent_active=1 AND session_id<>''", runID)
if err != nil {
return nil, err
}
defer rows.Close()
ids := []string{}
for rows.Next() {
var id string
if err := rows.Scan(&id); err != nil {
return nil, err
}
ids = append(ids, id)
}
return ids, rows.Err()
}