runs

type Collector ¶

type Collector struct {
	// contains filtered or unexported fields
}

Collector is the ExecutionObserver an operation runs under when a front-end shapes its result afterwards: it records every completed step as reported, a group step with its children still nested on it (the group carries its own status, error and output; the children are its breakdown). The engine serializes observer calls, but a run's steps are read while it is still reporting, so the record is mutex-guarded. The zero value is ready to use.

func (*Collector) OnGateComplete(string, types.StepResults, time.Duration)

func (*Collector) OnGateStart(string, []string)

func (*Collector) OnPhaseComplete(string, types.StepResults, time.Duration)

func (*Collector) OnPhaseStart(string, []string)

func (c *Collector) OnStepComplete(result types.StepResult)

func (*Collector) OnStepStart(string, string)

func (c *Collector) Steps() []types.StepResult

type Registry ¶

type Registry interface {
	// Reserve takes the slot for the operation named name on behalf of holder; a held
	// slot fails with CodeUnavailable "busy: <holder> is running".
	Reserve(name, holder string) (interfaces.Reservation, error)
}

Registry is the slice of the operations registry the table needs: reserving the working-tree slot for one operation on behalf of a holder (the run id).

interface-composition exemption — the consumer-side contract between the run table and execution/ops.Registry, with no core interface to embed.

type Snapshot ¶

type Snapshot struct {
	// Started is when Start launched the run.
	Started time.Time
	// Ended is when the operation returned; zero while running.
	Ended time.Time
	// Err is the operation's coded error; nil while running or on success.
	Err error
	// LogPaths is the log paths onDone returned, aligned with the front-end's
	// flattened view of Steps; nil while running.
	LogPaths []string
	// ID is the run id Start returned.
	ID string
	// Op is the operation's name.
	Op string
	// State is where the run is in its life.
	State State
	// Steps is every step the operation has completed so far, in order, a group step
	// with its children nested.
	Steps []types.StepResult
}

Snapshot is a point-in-time copy of one run.

type State ¶

type State string

State is where a run is in its life.

const (
	// StateRunning is a run whose operation has not returned yet.
	StateRunning State = "running"
	// StateSucceeded is a run whose operation returned nil.
	StateSucceeded State = "succeeded"
	// StateFailed is a run whose operation returned an error other than a cancel
	// (a timeout included).
	StateFailed State = "failed"
	// StateCancelled is a run stopped by Cancel or CancelAll.
	StateCancelled State = "cancelled"
)

type Table ¶

type Table struct {
	// contains filtered or unexported fields
}

Table tracks the background runs of one front-end session. Build it with New.

func New(
	reg Registry,
	newID func() string,
	onDone func(Snapshot) ([]string, error),
	keep int,
) *Table

func (t *Table) Cancel(id string) error

func (t *Table) CancelAll()

func (t *Table) List() []Snapshot

func (t *Table) Result(id string) (Snapshot, error)

func (t *Table) Start(ctx context.Context, name string, input any) (string, error)

func (t *Table) Status(id string) (Snapshot, error)

func (t *Table) Wait()