Files
sam 3a965e2a4f feat(nats): an external broker defers logins to archie through auth callout (#1866)
Task containers log in with their run credential on an external broker and
reach only their own subjects, decided by the embedded broker's authenticator.
The broker token is never put in a container environment.
2026-11-14 04:04:15 +11:00

272 lines
10 KiB
Go

// Package daemon is archied's resident loop: poll GitHub for labelled
// issues, enqueue them, and process tasks through their routed workflows.
// State lives in the store; the daemon is restartable at any point.
package daemon
import (
"context"
"errors"
"fmt"
"log/slog"
"strings"
"sync"
"time"
"github.com/samcharles93/archie-core/internal/config"
"github.com/samcharles93/archie-core/internal/domain/eda/playbook"
"github.com/samcharles93/archie-core/internal/domain/identity"
"github.com/samcharles93/archie-core/internal/domain/storecontract"
"github.com/samcharles93/archie-core/internal/domain/workflow"
"github.com/samcharles93/archie-core/internal/eventbus"
"github.com/samcharles93/archie-core/internal/events"
"github.com/samcharles93/archie-core/internal/forge"
"github.com/samcharles93/archie-core/internal/logging"
"github.com/samcharles93/archie-core/internal/storage"
"github.com/samcharles93/archie-core/internal/taskstate"
"github.com/samcharles93/archie-core/internal/worktree"
)
// TaskTransport publishes discovered work, collects it back, and asks a worker
// to run a task. The daemon's TaskBus runs on it.
type TaskTransport interface {
PublishUnique(ctx context.Context, subject, idempotencyKey string, payload []byte) error
Fetch(ctx context.Context) (eventbus.Message, error)
Request(ctx context.Context, subject string, payload []byte) ([]byte, error)
}
// RunCredentialIssuer issues the one credential a task's container holds: it
// authorizes the task's own State Store calls and the push of its branch.
// It lapses at the task's time limit plus a margin if never revoked.
type RunCredentialIssuer interface {
Issue(ctx context.Context, task *workflow.Task, limit time.Duration) (token string, revoke func(), err error)
}
// NATSEndpoint is the broker address archied connected with at startup. It is
// runtime state rather than configuration: embedded mode generates it. A
// container logs in with its run credential, never the broker's token.
type NATSEndpoint struct {
URL string
}
// StateStoreEndpoint is the State Store target and the CA its certificate
// chains to, both passed to agent containers.
type StateStoreEndpoint struct {
URL string
CA []byte
}
type Daemon struct {
ResolveRepository func(context.Context, *workflow.Task, string) (RepositoryAccess, error)
// Cfg publishes the running configuration. Read through Cfg() so a
// reload swaps the published snapshot atomically. See config.Holder.
Cfg *config.Holder
// ConnectedNATS is the endpoint the daemon connected with at startup;
// container env uses it, never live config.
ConnectedNATS NATSEndpoint
// ConnectedStateStore is the State Store target the daemon dialed at
// startup, passed to containers.
ConnectedStateStore StateStoreEndpoint
Store storecontract.TaskStore
// BindingDispatch offers captured events to armed bindings and starts their
// tasks. Built by the composition root from its own stores.
BindingDispatch *BindingDispatch
// Identity answers identity, org and access questions. Built by the
// composition root with NewIdentityGate.
Identity *IdentityGate
Forge forge.Forge
Trees *worktree.Manager
Bus *events.Bus
Log *slog.Logger
// TaskTransport is the NATS connection the task bus runs on. The bus is
// built by WireTaskBus.
TaskTransport TaskTransport
// TaskBus takes, runs and publishes tasks. Set by WireTaskBus.
TaskBus *TaskBus
// ReviewScanner reconciles PRs, scans their reviews and drains review
// reactions into remediate runs.
ReviewScanner *ReviewScanner
// RunCredentials issues each task's run credential (see runCredential).
// Required whenever ConnectedStateStore.URL is set: the task is parked
// rather than handed the daemon's own administrative token.
RunCredentials RunCredentialIssuer
// ModelEgress gives native task containers model access without provider
// keys. Nil parks a task whose providers need a key.
ModelEgress ModelEgress
// TaskModels answers the model aliases a task's org resolves against.
TaskModels TaskModels
// TaskInstructions answers the instance and organisation instructions a
// task's agent runs follow.
TaskInstructions TaskInstructions
// AgentStatus records agent versions for update verification.
AgentStatus *AgentStatus
// Runtime runs each task's agent in a fresh isolated container. Nil means
// autonomous execution is unavailable and process parks tasks.
Runtime TaskRuntime
// Storage is the pluggable storage backend for container mounts.
// A runnable task requires it; acquireTaskContainer parks on nil.
Storage storage.Backend
// IssuePoller discovers forge issues and publishes them as tasks.
IssuePoller *IssuePoller
// PackageAuthorities bounds the tools a package workflow's run is offered.
PackageAuthorities PackageAuthorities
// Playbooks are the loaded EDA playbooks, consulted before kind/label
// bindings when pinning a workflow.
Playbooks interface {
Dispatch(context.Context, playbook.DispatchInput) (playbook.Decision, bool)
Run(context.Context, storecontract.PlaybookDispatcher, *slog.Logger, playbook.DispatchInput) error
}
// PlaybookLedger is the at-most-once gate action playbooks run through.
PlaybookLedger storecontract.PlaybookDispatcher
// WorkflowDefinitions supplies the active database definitions and the
// label routes that pick one. A task is pinned once before dispatch;
// retries reuse the task's stored YAML.
WorkflowDefinitions workflowDefinitionSource
// TaskLogs persists each task's log output and mirrors it to the dashboard.
// Nil disables task logging.
TaskLogs *logging.TaskRegistry
// running holds a cancel function for every task currently executing,
// so /stop can reach work already in flight. Its zero value is ready
// to use.
running runningTasks
// loopPasses maps each run loop ("cycle", "drain") to when its latest
// pass began, as Unix nanoseconds. StalestLoop reports the oldest, so one
// wedged loop isn't hidden by a healthy one.
loopPasses sync.Map
}
// IssueSource is one forge connection's repositories as the identity
// permitted to read them sees them.
type IssueSource struct {
Identity identity.IdentityID
Forge forge.Forge
// BotUser is the connection's external account, the assignee polled for.
BotUser string
// Dispatch and Label are the discovery rule the connection's org polls
// with. Empty means the daemon's own.
Dispatch config.Dispatch
Label string
Repos []config.Repo
}
// taskHold is one submitted task's claim on execution capacity: its slot under
// the global limit, and its place at the tail of its repo's chain, which the
// next task for that repo is blocked on. A run that waits on a callee gives
// both back so the callee can run, and takes them again when the wait ends.
type taskHold struct {
dispatcher *taskDispatcher
repo string
// chain is true when the repo runs one task at a time, so the run holds a
// place in that repo's chain.
chain bool
// baton is the run's place in its repo's chain, closed when it gives that
// place up; nil while it holds none.
baton chan struct{}
// slot is true while the run counts against the global limit.
slot bool
// waits counts the callees the run is waiting on: an open call gives capacity
// back and the last closed call takes it again.
waits int
// finished is true once the run's process returned.
finished bool
// id is the task this hold belongs to, named by the run once it knows the
// task's id.
id int64
attempt int
// stopped closes when the run's own context ends, so a re-acquire waiting
// for capacity stops with a per-task stop. A context cannot be stored on the
// hold (containedctx), hence the channel; nil until the run has one.
stopped <-chan struct{}
}
// bindStop ties a re-acquire's wait to the run's own context.
func (h *taskHold) bindStop(ctx context.Context) {
h.dispatcher.mu.Lock()
h.stopped = ctx.Done()
h.dispatcher.mu.Unlock()
}
// name records which task's capacity this hold is, so a wait on a callee can
// give it back by task id. Zero names nothing: a task arriving on the NATS
// stream has no id until the store claims its row inside the run.
func (h *taskHold) name(id int64, attempt int) {
if id == 0 {
return
}
h.dispatcher.mu.Lock()
h.id = id
h.attempt = attempt
h.dispatcher.holds[id] = h
h.dispatcher.mu.Unlock()
}
// passFailed reports a maintenance pass whose items failed; each item's cause
// is already logged where it happened.
func passFailed(pass string, failed []string) error {
if len(failed) == 0 {
return nil
}
return fmt.Errorf("%s failed for %d item(s): %s", pass, len(failed), strings.Join(failed, ", "))
}
// pinFailure carries the park class for a pin failure: operator-actionable
// for a bad pin or missing workflow, transient for a store error.
type pinFailure struct {
class taskstate.ParkClass
err error
}
func (e pinFailure) Error() string { return e.err.Error() }
func (e pinFailure) Unwrap() error { return e.err }
// pinParkClass reports the class a pin failure carries, defaulting to
// taskstate.ParkNeedsDecision for a cause that did not classify itself: the safe
// misread is "an operator should look at this", never "a requeue will fix it".
func pinParkClass(err error) taskstate.ParkClass {
if failure, ok := errors.AsType[pinFailure](err); ok {
return failure.class
}
return taskstate.ParkNeedsDecision
}
// blockedPark names what a park is missing alongside the failure.
type blockedPark struct {
blocker taskstate.Blocker
err error
}
func (e blockedPark) Error() string { return e.err.Error() }
func (e blockedPark) Unwrap() error { return e.err }
// parkBlocker reports the blocker err names, or empty.
func parkBlocker(err error) taskstate.Blocker {
if b, ok := errors.AsType[blockedPark](err); ok {
return b.blocker
}
if failure, ok := errors.AsType[*forge.AccessError](err); ok {
return accessBlocker(failure.Code)
}
return ""
}
// accessBlocker maps a repository access failure code onto what fixes it.
func accessBlocker(code string) taskstate.Blocker {
switch code {
case "operation_denied":
return taskstate.BlockerConnectionPermit
case "repository_not_configured", "connection_required", "connection_missing":
return taskstate.BlockerRepository
case "credential_unavailable", "account_unverified":
return taskstate.BlockerConnectionCredential
case "forge_unavailable":
return taskstate.BlockerForgeExtension
}
return ""
}