workflowexec

type AgentTaskDriver interface {
	execution.TaskDriver
	AgentImage(context.Context) (execution.AgentImage, error)
	Results(context.Context, execution.TaskRef) (map[string]execution.ResultFile, error)
	Profile(context.Context) (execution.WorkerProfile, error)
}

type AgentWorker struct {
	Tasks *TaskRunner
}

type AttemptLinks interface {
	Publish(runID ids.ID, stepID ids.ID, attempt int64, sc trace.SpanContext)
	Forget(runID ids.ID, stepID ids.ID, attempt int64)
}

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

type CommandConfig struct {
	DataDir, Image string
}

type CommandDependencies struct {
	Runner    execution.Runner
	Progress  *progress.Feeds
	Publisher repositoryedit.Publisher
	Branches  *scm.Branches
	// Tasks runs Docker script steps as recorded tasks. Nil keeps the
	// unrecorded path (a runner that dies with AppTown).
	Tasks  *TaskRunner
	Panics interface{ Panic(string, any, []byte) }
	// Docker is asked which containers still write a script's folder.
	Docker *docker.Scope
	// Checks runs a tests step's command, on AppTown's check executor:
	// the worker when one is configured, else this machine. Its zero value
	// runs them through Runner, here.
	Checks CompileCheck
	// Catalog fulfils the app's declared needs (.apptown/app.yaml) as the
	// services a tests step's command runs beside.
	Catalog *dependency.Catalog
	// Now is AppTown's clock; nil is the real one.
	Now func() time.Time
}

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

type CompileCheck struct {
	Run   func(ctx context.Context, req execution.Request) execution.Outcome
	Image string
}

type Config struct {
	DataDir, Image, APIURL string
	// PrivateDocker is apptownd -private-docker: a step declaring private
	// Docker is admitted, here or on a worker, where its attempt records the
	// worker's measured profile. Without it, it is refused.
	PrivateDocker bool
}

type Dependencies struct {
	Adoption     *adoption.Service
	Integrations *integration.Service
	Secrets      *secret.Service
	Catalog      *dependency.Catalog
	Models       model.Selection
	Capacity     *model.Scheduler
	Progress     *progress.Feeds
	Tokens       *identity.RuntimeTokens
	Docker       *docker.Scope
	Workshop     *agentenv.Workshop
	Instructions *agentenv.Instructions
	Home         piharness.Preparer
	CLI          interface{ Path() (string, error) }
	Process      Process
	Ledger       *usage.Ledger
	Publisher    repositoryedit.Publisher
	Branches     *scm.Branches
	Panics       interface{ Panic(string, any, []byte) }
	// Worker runs agent and review steps when set, and nowhere else
	// (agent_attempt.go, review_worker.go). Nil runs both on AppTown's own
	// Docker.
	Worker *AgentWorker
	// Telemetry; nil means no-op.
	Tracer trace.Tracer
	Meter  metric.Meter
	Links  AttemptLinks
	// Now is AppTown's clock, which stamps the run records this executor
	// writes (artifacts); nil is the real one.
	Now func() time.Time
}

type Executor struct {

	// Settle bounds how an agent's or reviewer's finished outcome is
	// recorded again when its write fails (settleProduced). Its zero value
	// is the default bound.
	Settle workflow.Settlement
	// contains filtered or unexported fields
}

type Process interface {
	Run(context.Context, string, execution.Request) execution.Outcome
}

type Recoverer interface {
	RecoverExecution(context.Context, ids.ID, int64) (*workflow.Execution, error)
}

type ReleaseBuilds struct {
	// Tasks is the task runner whose driver is the worker's
	// (ReleaseTaskDriver).
	Tasks *TaskRunner
	// PrivateDocker is apptownd -private-docker: a release build needs
	// private Docker on the worker.
	PrivateDocker bool
}

type ReleaseData interface {
	BeforeRelease(ctx context.Context, projectID ids.ID, deployment string, synthetic bool) (ReleaseWitness, error)
}

type ReleaseTaskDriver interface {
	execution.TaskDriver
	execution.ImageFiles
	AgentImage(context.Context) (execution.AgentImage, error)
	Profile(context.Context) (execution.WorkerProfile, error)
	ImageResults(context.Context, execution.TaskRef) (map[string]execution.ImageCapture, error)
}

type ReleaseWitness interface {
	Complete() bool
	CopyWords() string
	After(ctx context.Context, declared []string) (problems, notes []string)
}

type RelocationRequest struct {
	Attempt tasks.Attempt
	Task    execution.TaskSpec
}

type RemoteResults interface {
	Collect(ctx context.Context, key, base, message, dest string) (string, error)
}

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

type RepositoryConfig struct {
	DataDir, PublicHost string
	// Now is AppTown's clock, which stamps what a merge request records
	// on a run; nil is the real one.
	Now func() time.Time
}

type Screenshotter interface {
	Take(ctx context.Context, base string, pages []string) verification.Capture
}

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

type ShippingConfig struct {
	DataDir, Image string
	Routing        deployment.Routing
}

type ShippingDependencies struct {
	Deployment *deployment.Service
	// Previews boots a run's preview step.
	Previews *preview.Service
	Docker   *docker.Scope
	// Checks runs the landing's compile check where checks run: the
	// worker's executor when one is configured.
	Checks   CompileCheck
	Progress *progress.Feeds
	Backups  interface{ AfterRelease(ids.ID, string) }
	// ReleaseData copies a deployment's data before a landing releases
	// onto it and witnesses it afterwards (dataprotection.BeforeRelease).
	ReleaseData ReleaseData
	// Builds, on an AppTown with a worker, is where its releases are built;
	// nil builds each on its target (docker.PrepareImages), as before.
	Builds *ReleaseBuilds
	// Now is AppTown's clock, which stamps what shipping records on a
	// run; nil is the real one.
	Now func() time.Time
	// Screenshots pictures a run's preview once its boot passes
	// (verification.Screenshots); nil takes none, and the boot's evidence
	// says so.
	Screenshots Screenshotter
}

type TaskProfile struct {
	Name    string
	Limits  execution.Limits
	Network execution.NetworkPolicy
}

type TaskRunner struct {
	Records *tasks.Records
	Driver  execution.TaskDriver
	// Requests is the folder admitted requests are kept in, one folder per
	// operation (<data>/tasks).
	Requests string
	// Profile is the admission every new task carries.
	Profile TaskProfile
	// Backend identifies where tasks run: which Docker daemon, or which
	// worker. Each attempt records it, and a restarted AppTown acts only on
	// attempts recorded for the backend it has now. Empty is the profile's
	// name.
	Backend string
	// Remote is set when tasks run on another machine (a apptown-worker): each
	// is given a published commit instead of a mount, its work comes back as a
	// bundle, and no script step runs on AppTown's own host.
	Remote RemoteResults
	// Now is AppTown's clock, by which a task's deadline and its
	// admission's expiry are written and judged; nil is the real one.
	Now func() time.Time
	// Poll is how often a waiting task checks that its step is still running,
	// and how long to wait before asking an unanswering backend again.
	Poll time.Duration
	// SettleTries is how many times a step's outcome is written before the
	// task is left recorded for a restarted AppTown; zero means three.
	SettleTries int
	// Patience is how long reading a finished task's result keeps asking an
	// unanswering backend; zero is taskGrace.
	Patience time.Duration
	// AbandonAt is a test seam for crash recovery: returning true for a stage
	// ("reserved", "created", "started") abandons the attempt there, as an AppTown that died
	// at that point would.
	AbandonAt func(stage string) bool
	// ScriptWallClock is a test seam: when set, it is every script task's
	// wall clock in place of its step's timeout, so a test reaches a task's
	// deadline without waiting out the shortest a step can declare (a
	// minute). Zero keeps the step's own.
	ScriptWallClock time.Duration
	// contains filtered or unexported fields
}

type WorkerRefusal struct{ Reason string }