636 lines
28 KiB
Go
636 lines
28 KiB
Go
// Package storecontract defines the State Store interfaces its consumers use,
|
|
// without an implementation.
|
|
package storecontract
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"io"
|
|
"time"
|
|
|
|
"github.com/samcharles93/archie-core/internal/domain/binding"
|
|
"github.com/samcharles93/archie-core/internal/domain/eventtype"
|
|
"github.com/samcharles93/archie-core/internal/domain/harnesssecret"
|
|
"github.com/samcharles93/archie-core/internal/domain/health"
|
|
"github.com/samcharles93/archie-core/internal/domain/mapping"
|
|
"github.com/samcharles93/archie-core/internal/domain/source"
|
|
"github.com/samcharles93/archie-core/internal/domain/workflow/task"
|
|
"github.com/samcharles93/archie-core/internal/events"
|
|
"github.com/samcharles93/archie-core/internal/logging"
|
|
)
|
|
|
|
// TaskStore is the full store surface the daemon needs.
|
|
// Consumers depend on TaskStore, never on a concrete type.
|
|
type TaskStore interface {
|
|
TaskLifecycle
|
|
TaskParker
|
|
TaskEvents
|
|
TaskQueries
|
|
TaskArchiver
|
|
TaskRetryer
|
|
ReviewGateResponder
|
|
RemediationStarter
|
|
}
|
|
|
|
// TaskLifecycle manages the core task state machine and enqueuing.
|
|
// Binding-triggered task creation lives on BindingTaskCreator, not here,
|
|
// so the lifecycle surface stays narrow and non-binding consumers (forge
|
|
// poll, chat spawn, drain loop) do not acquire a binding-specific shape.
|
|
type TaskLifecycle interface {
|
|
EnqueueIssue(ctx context.Context, owner, repo string, number int, title, body, labels, identity string) (bool, error)
|
|
EnqueueChatTask(ctx context.Context, owner, repo, title, body, wf, identity, origin, draft string, inputs map[string]any) (*task.Task, error)
|
|
ClaimNext(ctx context.Context) (*task.Task, error)
|
|
ClaimByIssue(ctx context.Context, owner, repo string, number int) (*task.Task, error)
|
|
Transition(ctx context.Context, taskID int64, from, to, detail string) error
|
|
Update(ctx context.Context, t *task.Task) error
|
|
Requeue(ctx context.Context, taskID int64, fromStatus, workflow string) error
|
|
RecoverStale(ctx context.Context) (int64, error)
|
|
}
|
|
|
|
// TaskParker parks a task with a park class and the blocker the park site
|
|
// knows, if any. Unknown classes become needs_human.
|
|
type TaskParker interface {
|
|
ParkTask(ctx context.Context, taskID int64, from, detail, class, blocker string) error
|
|
}
|
|
|
|
// StepRecorder records a running execution's steps.
|
|
type StepRecorder interface {
|
|
StartStep(ctx context.Context, s task.StepStart) (int64, events.Event, error)
|
|
FinishStep(ctx context.Context, s task.StepFinish) (events.Event, error)
|
|
}
|
|
|
|
// ExecutionCanceller cancels an execution and its current attempt's open
|
|
// steps in one transaction. It also cancels the callees the execution was
|
|
// waiting on, and returns their ids (nested callees included) so the caller
|
|
// can stop their runs too.
|
|
type ExecutionCanceller interface {
|
|
CancelExecution(ctx context.Context, taskID int64, reason, to string) ([]int64, error)
|
|
}
|
|
|
|
// StepReader lists one execution's recorded steps.
|
|
type StepReader interface {
|
|
ListSteps(ctx context.Context, executionID int64, attempt int) ([]task.StepExecution, error)
|
|
}
|
|
|
|
// HarnessSecretStore stores one org's OAuth token set per credential binding
|
|
// service, encrypted at rest.
|
|
type HarnessSecretStore interface {
|
|
GetHarnessSecret(ctx context.Context, org, service string) (harnesssecret.Secret, error)
|
|
PutHarnessSecret(ctx context.Context, s harnesssecret.Secret) error
|
|
}
|
|
|
|
// TaskArchiver removes one terminal task's local record with an optimistic
|
|
// status guard. It is separate from the already broad lifecycle contract so
|
|
// consumers that only run tasks do not acquire an operator-only capability.
|
|
type TaskArchiver interface {
|
|
OutcomePoster
|
|
ArchiveTask(ctx context.Context, taskID int64, fromStatus string, audit events.Event) (eventID int64, err error)
|
|
ClearTerminalTasks(ctx context.Context) (int64, error)
|
|
}
|
|
|
|
// TaskRetryer atomically requeues recoverable work and accounts for the new
|
|
// attempt so a partial write cannot evade the retry cap. retryMode is the
|
|
// operator's worktree choice for the next dispatch (taskstate.RetryMode),
|
|
// persisted on the row so the daemon reads it instead of inferring it. resume
|
|
// is where the attempt starts; a resume whose After stage did not complete in
|
|
// its last run is refused with ErrResumeIncomplete.
|
|
type TaskRetryer interface {
|
|
RetryTask(ctx context.Context, taskID int64, fromStatus, workflow, retryMode string, resume task.Resume, currentDefinition bool) error
|
|
}
|
|
|
|
// ReviewGateResponder records the operator's review-gate answer. A re-review
|
|
// increments rereview_rounds and requeues; one past the cap returns
|
|
// ErrRereviewCapReached and writes nothing.
|
|
type ReviewGateResponder interface {
|
|
RespondReviewGate(ctx context.Context, taskID int64, fromStatus, gate string, rereview bool, maxRounds int) error
|
|
}
|
|
|
|
// RemediationStarter queues a review-triggered remediation for an Archie-owned
|
|
// open-PR task: one guarded transition that carries the JSON-encoded review
|
|
// unit in the same write, so a claimed remediation always has its input. Runs
|
|
// for one task are serialised, so a distinct review that arrives while a
|
|
// remediation owns the task is queued behind it and remediated once that run
|
|
// finishes; a re-delivered unit is absorbed, not queued twice.
|
|
// UpdateReviewPayload merges late-arriving comments into the unclaimed unit
|
|
// for the same review, active or queued behind a running remediation.
|
|
type RemediationStarter interface {
|
|
BeginRemediation(ctx context.Context, taskID int64, payload string) error
|
|
UpdateReviewPayload(ctx context.Context, taskID int64, payload string) error
|
|
// SetReviewCursors persists the poll backstop's per-task review and
|
|
// comment high-water marks (pr-review-remediation.md decision 2). The
|
|
// pr_open guard is part of the contract: cursors only move while no
|
|
// remediation run owns the task.
|
|
SetReviewCursors(ctx context.Context, taskID, reviewCursor, commentCursor int64) error
|
|
}
|
|
|
|
// OutcomePoster tracks which finished chat tasks have reported back to their
|
|
// conversation.
|
|
type OutcomePoster interface {
|
|
// UnpostedOutcomes returns finished chat tasks whose outcome has not been
|
|
// posted to the conversation that created them.
|
|
UnpostedOutcomes(ctx context.Context) ([]*task.Task, error)
|
|
// MarkOutcomePosted records that a task's outcome was posted.
|
|
MarkOutcomePosted(ctx context.Context, taskID int64) error
|
|
}
|
|
|
|
// TaskQueries groups read-only task accessors.
|
|
type TaskQueries interface {
|
|
TaskByIssue(ctx context.Context, owner, repo string, number int) (*task.Task, error)
|
|
OpenTaskByPR(ctx context.Context, owner, repo string, number int) (*task.Task, error)
|
|
TaskByID(ctx context.Context, taskID int64) (*task.Task, error)
|
|
OpenPRs(ctx context.Context) ([]task.Task, error)
|
|
// ActiveTasksByOrigin returns the queued and running tasks the
|
|
// conversation origin created, for its /stop.
|
|
ActiveTasksByOrigin(ctx context.Context, origin string) ([]*task.Task, error)
|
|
// Tasks returns the most recently updated tasks.
|
|
Tasks(ctx context.Context, limit int) ([]task.Task, error)
|
|
// TasksPage returns one page of tasks, most recently updated first.
|
|
TasksPage(ctx context.Context, page TaskPage) ([]task.Task, error)
|
|
StatusCounts(ctx context.Context) (map[string]int, error)
|
|
}
|
|
|
|
// TaskEvents groups observability and lifecycle methods.
|
|
type TaskEvents interface {
|
|
InsertEvent(ctx context.Context, e events.Event) (int64, error)
|
|
EventsSince(ctx context.Context, cursor string, limit int) ([]events.Event, error)
|
|
TaskEvents(ctx context.Context, taskID int64) ([]events.Event, error)
|
|
WorkflowStats(ctx context.Context) ([]WorkflowStat, error)
|
|
StageStats(ctx context.Context) ([]StageStat, error)
|
|
TokensByDay(ctx context.Context, days int) ([]DayTokens, error)
|
|
Close() error
|
|
}
|
|
|
|
// CaptureStore persists inbound webhook captures.
|
|
type CaptureStore interface {
|
|
InsertCapture(ctx context.Context, c CapturedEvent, retention time.Duration, maxEvents int) (string, error)
|
|
ListCaptures(ctx context.Context, limit int) ([]CapturedEvent, error)
|
|
}
|
|
|
|
// CaptureRefusalStore counts the events network rules refused, per source.
|
|
type CaptureRefusalStore interface {
|
|
RecordCaptureRefusal(ctx context.Context, source, addr string, at time.Time) error
|
|
CaptureRefusals(ctx context.Context, since time.Time) ([]CaptureRefusals, error)
|
|
}
|
|
|
|
// CaptureRefusals is one source's refusals and accepted captures since a
|
|
// time, and the addresses it refused.
|
|
type CaptureRefusals struct {
|
|
Source string `json:"source"`
|
|
Refused int64 `json:"refused"`
|
|
Accepted int64 `json:"accepted"`
|
|
Addrs []string `json:"addrs"`
|
|
}
|
|
|
|
// ConfigSnapshotStore holds the published configuration view.
|
|
type ConfigSnapshotStore interface {
|
|
PutConfigSnapshot(ctx context.Context, snapshot ConfigSnapshot) error
|
|
ConfigSnapshot(ctx context.Context) (ConfigSnapshot, bool, error)
|
|
}
|
|
|
|
// ChannelStatusStore holds channel runtime state published by the process
|
|
// hosting the channels.
|
|
type ChannelStatusStore interface {
|
|
// PutChannelStatus records the reporting process's whole set: a channel it no
|
|
// longer reports is removed rather than left behind, because a stale "running"
|
|
// row is a lie the dashboard would show indefinitely.
|
|
PutChannelStatus(ctx context.Context, channels []ChannelStatus) error
|
|
ChannelStatus(ctx context.Context) ([]ChannelStatus, error)
|
|
}
|
|
|
|
// ApplyStatusStore holds which version of each control-plane resource each
|
|
// process is running. Same split as ConfigSnapshotStore and for the same
|
|
// reason: the writers are the processes that apply a resource, the reader is
|
|
// the UI, and a task-scoped credential must reach neither.
|
|
type ApplyStatusStore interface {
|
|
PutApplyStatus(ctx context.Context, status ApplyStatus) error
|
|
ListApplyStatus(ctx context.Context) ([]ApplyStatus, error)
|
|
}
|
|
|
|
// PresenceStore holds one record per running service instance. Writers are
|
|
// the services themselves; readers are the UI and archied status.
|
|
type PresenceStore interface {
|
|
PutPresence(ctx context.Context, presence Presence) error
|
|
ListPresence(ctx context.Context) ([]Presence, error)
|
|
}
|
|
|
|
// MappingStore persists payload field mappings. Deliberately separate from
|
|
// TaskStore and CaptureStore for the same reason those are split: the
|
|
// dashboard's mapping editor should only acquire the mapping surface, not the
|
|
// full task or capture APIs. See
|
|
type MappingStore interface {
|
|
InsertMapping(ctx context.Context, m mapping.Mapping) (string, error)
|
|
GetMapping(ctx context.Context, id string) (*mapping.Mapping, error)
|
|
ListMappings(ctx context.Context) ([]mapping.Mapping, error)
|
|
UpdateMapping(ctx context.Context, m mapping.Mapping) error
|
|
DeleteMapping(ctx context.Context, id string) error
|
|
}
|
|
|
|
// MappingMatchRecorder counts the events each mapping resolved, which the
|
|
// store reports as Mapping.MatchCount and LastMatchedAt. Recording the same
|
|
// (mapping, capture) twice counts once.
|
|
type MappingMatchRecorder interface {
|
|
RecordMappingMatch(ctx context.Context, mappingID, captureID string) error
|
|
}
|
|
|
|
// EventTypeStore persists event types. Insert and Update refuse a type whose
|
|
// rule overlaps another on the same source with eventtype.ErrOverlap, and a
|
|
// malformed one with eventtype.ErrInvalid. Update rewrites the name and rule;
|
|
// the schema is the one the type was created with.
|
|
type EventTypeStore interface {
|
|
InsertEventType(ctx context.Context, t eventtype.EventType) (string, error)
|
|
UpdateEventType(ctx context.Context, t eventtype.EventType) error
|
|
DeleteEventType(ctx context.Context, id string) error
|
|
ListEventTypes(ctx context.Context) ([]eventtype.EventType, error)
|
|
}
|
|
|
|
// BindingStore persists bindings and their draft -> pending_approval ->
|
|
// armed states.
|
|
type BindingStore interface {
|
|
InsertBinding(ctx context.Context, b binding.Binding) (string, error)
|
|
GetBinding(ctx context.Context, id string) (*binding.Binding, error)
|
|
ListBindings(ctx context.Context) ([]binding.Binding, error)
|
|
UpdateBinding(ctx context.Context, b binding.Binding) error
|
|
DeleteBinding(ctx context.Context, id string) error
|
|
ApproveBinding(ctx context.Context, id string) error
|
|
PauseBinding(ctx context.Context, id string) error
|
|
ResumeBinding(ctx context.Context, id string) error
|
|
}
|
|
|
|
// SourceStore persists capture sources keyed by path. Secrets are encrypted
|
|
// at rest; signing transitions use an expected-from guard.
|
|
type SourceStore interface {
|
|
InsertSource(ctx context.Context, s source.Source) error
|
|
// GetSource returns (nil, nil) for an unknown path.
|
|
GetSource(ctx context.Context, path string) (*source.Source, error)
|
|
ListSources(ctx context.Context) ([]source.Source, error)
|
|
SetSourceSigning(ctx context.Context, path string, from, to source.Signing) error
|
|
SetSourceSecret(ctx context.Context, path, secret string) error
|
|
SetSourceName(ctx context.Context, path, name string) error
|
|
SetSourceDeliveryHeader(ctx context.Context, path, header string) error
|
|
// DeleteSource refuses with ErrSourceInUse while an armed binding fires
|
|
// on the source.
|
|
DeleteSource(ctx context.Context, path string) error
|
|
}
|
|
|
|
// DispatchLedger reads the binding dispatch ledger.
|
|
type DispatchLedger interface {
|
|
// ListDispatches returns the newest ledger rows matching filter.
|
|
ListDispatches(ctx context.Context, filter DispatchFilter) ([]Dispatch, error)
|
|
}
|
|
|
|
// TaskPage selects one page of the task list. Empty Statuses matches every
|
|
// status. A zero After starts at the newest task; otherwise the page begins
|
|
// after the task it names, in (updated_at, id) descending order.
|
|
type TaskPage struct {
|
|
Statuses []string
|
|
// Workflow, when set, keeps only that workflow's tasks.
|
|
Workflow string
|
|
After TaskCursor
|
|
Limit int
|
|
}
|
|
|
|
// TaskCursor is the position of the last task a page returned.
|
|
type TaskCursor struct {
|
|
UpdatedAt time.Time
|
|
ID int64
|
|
}
|
|
|
|
// Dispatch is one binding/capture ledger row: the task it started, or the
|
|
// reason it started none.
|
|
type Dispatch struct {
|
|
BindingID string `json:"binding_id"`
|
|
BindingVersion int64 `json:"binding_version"`
|
|
CaptureID string `json:"capture_id"`
|
|
TaskID int64 `json:"task_id,omitempty"`
|
|
Reason string `json:"reason,omitempty"`
|
|
DispatchedAt time.Time `json:"dispatched_at"`
|
|
}
|
|
|
|
// DispatchFilter narrows ListDispatches; empty fields match any row.
|
|
type DispatchFilter struct {
|
|
BindingID string
|
|
CaptureID string
|
|
TaskID int64
|
|
Limit int
|
|
}
|
|
|
|
// BindingDispatcher looks up armed bindings, lists undispatched captures and
|
|
// records dispatches.
|
|
type BindingDispatcher interface {
|
|
ArmedBindingsForSource(ctx context.Context, source string) ([]binding.Binding, error)
|
|
RecordDispatch(
|
|
ctx context.Context,
|
|
bindingID string,
|
|
bindingVersion int64,
|
|
captureID string,
|
|
// taskID addresses the SQLite-owned task tables, which are not
|
|
// migrating: it stays an integer on purpose. A dispatch that starts
|
|
// a task is recorded by EnqueueBindingTask instead.
|
|
taskID int64,
|
|
// reason is empty for a dispatch and names the terminal outcome of
|
|
// an evaluation that started no task.
|
|
reason string,
|
|
) error
|
|
ListUndispatchedCaptures(ctx context.Context, bindings []string, limit int) ([]CapturedEvent, error)
|
|
}
|
|
|
|
// BindingTaskCreator is the single-method consumer-facing surface for
|
|
// enqueueing a task triggered by a binding. Splitting it off TaskLifecycle
|
|
// keeps the lifecycle surface narrow (8 methods, the interfacebloat limit)
|
|
// and keeps the binding-specific shape on the binding interfaces.
|
|
type BindingTaskCreator interface {
|
|
// EnqueueBindingTask claims the binding's dispatch of captureID in the
|
|
// ledger, enqueues the task and records its provenance as one unit: an
|
|
// error leaves none of them, and a delivery already dispatched for the
|
|
// binding returns ErrAlreadyDispatched.
|
|
EnqueueBindingTask(ctx context.Context, owner, repo, title, body, wf, identity, bindingID string, bindingVersion int, captureID string, inputs map[string]any) (*task.Task, error)
|
|
}
|
|
|
|
// WorkflowCaller starts a workflow.call callee and reads it back.
|
|
type WorkflowCaller = task.Caller
|
|
|
|
// PlaybookDispatcher records a playbook action dispatch before its side
|
|
// effect runs, returning ErrAlreadyDispatched for a duplicate.
|
|
// DeletePlaybookDispatches deletes one playbook's records.
|
|
type PlaybookDispatcher interface {
|
|
RecordPlaybookDispatch(ctx context.Context, playbookID, playbookVersion, eventID, actionID string) error
|
|
DeletePlaybookDispatches(ctx context.Context, playbookID string) error
|
|
}
|
|
|
|
// TaskLogStore reads one task attempt's log. Found=false means no log;
|
|
// ErrTaskLogsUnavailable means this process cannot read logs.
|
|
type TaskLogStore interface {
|
|
// TaskLog returns a page of one attempt's decoded log. attempt 0 selects
|
|
// the task's current attempt.
|
|
TaskLog(ctx context.Context, taskID int64, attempt int, q logging.Query) (logging.TaskLogPage, error)
|
|
// TaskLogContent writes one attempt's log verbatim to w, for a download.
|
|
// found is false, with a nil error, when the attempt has no log file.
|
|
TaskLogContent(ctx context.Context, taskID int64, attempt int, w io.Writer) (found bool, err error)
|
|
}
|
|
|
|
// CapturedEvent is one unbound inbound webhook capture: no workflow binding,
|
|
// no forge/task association -- just what arrived, from where, and when.
|
|
type CapturedEvent struct {
|
|
ID string `json:"id"`
|
|
ReceivedAt time.Time `json:"received_at"`
|
|
Source string `json:"source"`
|
|
RemoteAddr string `json:"remote_addr"`
|
|
ContentType string `json:"content_type"`
|
|
// Headers and Body are redacted (webhookguard.RedactPayload) before
|
|
// they ever reach InsertCapture; the store persists what it is given.
|
|
Headers string `json:"headers"`
|
|
Body string `json:"body"`
|
|
Authenticated bool `json:"authenticated"`
|
|
// EventType is the ID of the event type the capture was identified as
|
|
// when it arrived, or empty when it matched none. An unidentified capture
|
|
// is never dispatched.
|
|
EventType string `json:"event_type"`
|
|
// Unsigned marks an event that arrived on an approved unsigned source.
|
|
// It dispatches without Authenticated and is flagged wherever it shows.
|
|
Unsigned bool `json:"unsigned"`
|
|
// Delivery names the sender's delivery; a retry of one delivery shares
|
|
// it, so a binding dispatches each delivery once. Intake sets it from the
|
|
// source's delivery header; the store fills the capture ID when empty.
|
|
Delivery string `json:"delivery"`
|
|
}
|
|
|
|
// Dispatchable reports whether a binding may start a task from this event:
|
|
// a valid signature, or a source approved to take unsigned events.
|
|
func (c CapturedEvent) Dispatchable() bool { return c.Authenticated || c.Unsigned }
|
|
|
|
// ConfigSnapshot is the published, secret-free configuration view. Schema
|
|
// names Document's shape.
|
|
type ConfigSnapshot struct {
|
|
Schema string
|
|
Document []byte
|
|
PublishedAt time.Time
|
|
}
|
|
|
|
// ChannelStatus is one channel's runtime state as the process hosting it
|
|
// reports it. ReloadSupported is a capability declaration rather than a request:
|
|
// asking for a reload travels on its own surface, because a transient request and
|
|
// a durable state do not share a lifetime.
|
|
type ChannelStatus struct {
|
|
ID string
|
|
Name string
|
|
State string
|
|
Detail string
|
|
Configured bool
|
|
ReloadSupported bool
|
|
ObservedAt time.Time
|
|
}
|
|
|
|
// ApplyStatus is one process's report on one resource kind. On error,
|
|
// AppliedVersion stays at the last applied version. ReportedAt is
|
|
// re-stamped periodically.
|
|
type ApplyStatus struct {
|
|
Process string `json:"process"`
|
|
Kind string `json:"kind"`
|
|
AppliedVersion int64 `json:"applied_version"`
|
|
Error string `json:"error,omitempty"`
|
|
ReportedAt time.Time `json:"reported_at"`
|
|
}
|
|
|
|
// Presence is one running service instance. Ready and Detail summarise its
|
|
// readiness probes; Detail names the degraded ones.
|
|
type Presence struct {
|
|
Checks []health.Component `json:"checks"`
|
|
Service string `json:"service"`
|
|
InstanceID string `json:"instance_id"`
|
|
Version string `json:"version"`
|
|
InstallType string `json:"install_type"`
|
|
StartedAt time.Time `json:"started_at"`
|
|
ReportedAt time.Time `json:"reported_at"`
|
|
Ready bool `json:"ready"`
|
|
Detail string `json:"detail,omitempty"`
|
|
}
|
|
|
|
// WorkflowStat is one row of the per-workflow metrics table.
|
|
type WorkflowStat struct {
|
|
Workflow string `json:"workflow"`
|
|
Runs int `json:"runs"`
|
|
Merged int `json:"merged"`
|
|
Completed int `json:"completed"`
|
|
PROpen int `json:"pr_open"`
|
|
Parked int `json:"parked"`
|
|
AvgTokens int `json:"avg_tokens"`
|
|
AvgSteps float64 `json:"avg_steps"`
|
|
TotalToken int `json:"total_tokens"`
|
|
}
|
|
|
|
// StageStat is average stage duration and failure counts per stage.
|
|
type StageStat struct {
|
|
Workflow string `json:"workflow"`
|
|
Stage string `json:"stage"`
|
|
Runs int `json:"runs"`
|
|
AvgMs int `json:"avg_ms"`
|
|
Errors int `json:"errors"`
|
|
}
|
|
|
|
// DayTokens is token spend per UTC day.
|
|
type DayTokens struct {
|
|
Day string `json:"day"`
|
|
Tokens int `json:"tokens"`
|
|
}
|
|
|
|
// Sentinel errors, part of the wire contract: staterpc's
|
|
// mapError/unmapError match these by (code, canonical message) across the
|
|
// gRPC boundary, so their message strings are load-bearing and must never
|
|
// change.
|
|
var (
|
|
// ErrStaleTransition is returned when a task transition's expected
|
|
// from status does not match the task's current status.
|
|
ErrStaleTransition = errors.New("store: stale transition: task status does not match expected from status")
|
|
// ErrIllegalTransition is returned when the transition table does not allow
|
|
// the status pair.
|
|
ErrIllegalTransition = errors.New("store: illegal transition: status pair is not in the transition table")
|
|
// ErrInvalidStep is returned when a step-execution request names a kind the
|
|
// store does not record or a step whose identifying fields do not resolve.
|
|
// Distinct from the transition sentinels, which cover a row's state.
|
|
ErrInvalidStep = errors.New("store: invalid step execution request")
|
|
// ErrResumeIncomplete is returned when a retry resumes after a stage whose
|
|
// last run did not complete, so there are no results to start from.
|
|
ErrResumeIncomplete = errors.New("store: the step before the resume point did not complete in its last run")
|
|
// ErrBindingNotFound is returned when a binding ID does not exist.
|
|
ErrBindingNotFound = errors.New("store: binding not found")
|
|
// ErrBindingOverlap is returned when a binding's matcher overlaps an
|
|
// existing binding for the same source.
|
|
ErrBindingOverlap = errors.New("store: binding overlaps existing binding for source")
|
|
// ErrBindingTransition is returned when a binding state transition is
|
|
// rejected by the draft -> pending_approval -> armed machine.
|
|
ErrBindingTransition = errors.New("store: binding state transition rejected")
|
|
// ErrAlreadyDispatched is returned when a dispatch ledger already holds the
|
|
// key.
|
|
ErrAlreadyDispatched = errors.New("store: binding already dispatched for capture")
|
|
// ErrCallNotYours is returned when a workflow.call status read names a
|
|
// task that is not a callee of the calling task, or the caller itself
|
|
// does not exist: a caller reads only the tasks it started
|
|
ErrCallNotYours = errors.New("store: task is not a callee of the calling task")
|
|
// ErrCallCallerNotRunning is returned when a workflow.call enqueue names
|
|
// a caller that is not running: a stale retry, or a bug in the caller.
|
|
ErrCallCallerNotRunning = errors.New("store: workflow.call caller is not running")
|
|
// ErrCallDepthExceeded is returned when a workflow.call enqueue would
|
|
// pass workflow.MaxCallDepth. The engine refuses the same call first;
|
|
// the store re-checks because it owns the table.
|
|
ErrCallDepthExceeded = errors.New("store: workflow.call would pass the depth limit")
|
|
// ErrMappingNotFound is returned when a mapping ID does not exist.
|
|
ErrMappingNotFound = errors.New("store: mapping not found")
|
|
// ErrEventTypeNotFound is returned when an event type ID does not exist.
|
|
ErrEventTypeNotFound = errors.New("store: event type not found")
|
|
// ErrSourceNotFound is returned when a source path does not exist.
|
|
ErrSourceNotFound = errors.New("store: source not found")
|
|
// ErrSourceInUse is returned when deleting a source an armed binding
|
|
// fires on.
|
|
ErrSourceInUse = errors.New("store: source has an armed binding")
|
|
// ErrSourcePathTaken is returned when a new source's path is in use.
|
|
ErrSourcePathTaken = errors.New("store: source path already taken")
|
|
// ErrSourceSigningStale is returned when a signing write's expected
|
|
// from state does not match the stored one.
|
|
ErrSourceSigningStale = errors.New("store: source signing does not match expected state")
|
|
// ErrHarnessSecretNotFound is returned when no OAuth token set is
|
|
// stored for an org/service pair -- the setup terminal has not
|
|
// captured one yet.
|
|
ErrHarnessSecretNotFound = errors.New("store: harness secret not found")
|
|
// ErrRereviewCapReached is returned when a review gate re-review would
|
|
// round past prreview.MaxRereviewRounds. The task stays waiting and its
|
|
// gate row is unchanged. The dashboard answers it 409, like every other
|
|
// conflict.
|
|
ErrRereviewCapReached = errors.New("store: re-review cap reached")
|
|
|
|
// ErrResourceNotFound is returned when a control-plane resource kind has
|
|
// no stored document. It is in-process only (not on the gRPC wire): the
|
|
// control plane runs in the daemon against the local store.
|
|
ErrResourceNotFound = errors.New("resource not found")
|
|
// ErrResourceVersionConflict is returned when a resource write carries an
|
|
// expected version that does not match the stored revision.
|
|
ErrResourceVersionConflict = errors.New("resource version conflict")
|
|
)
|
|
|
|
// ErrUnavailable means the store could not serve a request now: it is
|
|
// restarting or unreachable. It is not paired with a canonical message the way
|
|
// the sentinels above are -- staterpc derives it from the Unavailable code
|
|
// alone, whose text varies by transport -- and it is the one store error a
|
|
// caller with budget may answer by retrying rather than by failing its own
|
|
// work. The wrapping keeps the gRPC status code readable through the chain.
|
|
var ErrUnavailable = errors.New("store: state store unavailable")
|
|
|
|
// Resource is one control-plane resource document: the stored value for an
|
|
// org's kind, its revision, and the audit record written with the last write.
|
|
// Resource and ResourceWrite live here so the UI-side consumers can reference
|
|
// them without linking the PostgreSQL implementation.
|
|
type Resource struct {
|
|
OrgID string
|
|
Kind string
|
|
Value []byte
|
|
Version int64
|
|
Actor string
|
|
Source string
|
|
RequestID string
|
|
ExpectedVersion int64
|
|
CurrentVersion int64
|
|
At time.Time
|
|
}
|
|
|
|
// AuditTableResources is the sys_audit table name for control-plane resources,
|
|
// keyed by ResourceAuditKey.
|
|
const AuditTableResources = "resources"
|
|
|
|
// DefaultOrgID is the org every resource written before orgs existed belongs
|
|
// to, and the org a request that names none acts in.
|
|
const DefaultOrgID = "org-sys"
|
|
|
|
// ResourceAuditKey is the sys_audit record key of one org's resource kind. The
|
|
// default org keeps the bare kind, so audit rows written before resources were
|
|
// per-org still resolve.
|
|
func ResourceAuditKey(orgID, kind string) string {
|
|
if orgID == DefaultOrgID {
|
|
return kind
|
|
}
|
|
return orgID + "/" + kind
|
|
}
|
|
|
|
// AuditEntry is one changed field of one record, as sys_audit holds it. Any
|
|
// store table may write entries; Table and RecordKey locate the record.
|
|
// OldValue and NewValue are JSON; an absent side is empty.
|
|
type AuditEntry struct {
|
|
ID int64
|
|
Table string
|
|
RecordKey string
|
|
Field string
|
|
OldValue []byte
|
|
NewValue []byte
|
|
Version int64
|
|
Actor string
|
|
Source string
|
|
RequestID string
|
|
At time.Time
|
|
}
|
|
|
|
// ResourceWrite is a control-plane resource write request. ExpectedVersion is
|
|
// the optimistic-concurrency guard: a write whose expectation does not match
|
|
// the stored revision is refused with ErrResourceVersionConflict.
|
|
type ResourceWrite struct {
|
|
OrgID string
|
|
Kind string
|
|
Value []byte
|
|
Actor string
|
|
Source string
|
|
RequestID string
|
|
ExpectedVersion int64
|
|
At time.Time
|
|
}
|
|
|
|
// ErrRunCredentialUnknown is a run credential that was never issued, was
|
|
// revoked, or has expired.
|
|
var ErrRunCredentialUnknown = errors.New("run credential unknown or expired")
|
|
|
|
// RunCredentialStore keeps run credentials by digest: the SHA-256 of the
|
|
// token a task's container presents. A lookup of an unknown or expired
|
|
// digest reports ErrRunCredentialUnknown.
|
|
type RunCredentialStore interface {
|
|
PutRunCredential(ctx context.Context, digest [32]byte, taskID int64, expires time.Time) error
|
|
DeleteRunCredential(ctx context.Context, digest [32]byte) error
|
|
RunCredentialTask(ctx context.Context, digest [32]byte, now time.Time) (int64, error)
|
|
DeleteExpiredRunCredentials(ctx context.Context, now time.Time) error
|
|
}
|