worker

type AdmissionRefused struct{ Reason string }

type CheckAnswer struct {
	Termination execution.Termination `json:"termination"`
	ExitCode    int                   `json:"exitCode"`
	RunErr      string                `json:"runErr,omitempty"`
	Output      []byte                `json:"output,omitempty"`
	Report      []byte                `json:"report,omitempty"`
	ReportErr   string                `json:"reportErr,omitempty"`
}

type CheckSpec struct {
	Image        string   `json:"image"`
	Argv         []string `json:"argv"`
	Env          []string `json:"env,omitempty"`
	NoEntrypoint bool     `json:"noEntrypoint,omitempty"`
	// Egress lets the container reach the network, where a scanner binding
	// asks for it; otherwise it has none.
	Egress bool `json:"egress,omitempty"`
	// Limits bound the check's container (and so a test run in it); a
	// request with none (an older AppTown) runs under the task defaults.
	Limits         execution.Limits `json:"limits,omitzero"`
	TimeoutSeconds int              `json:"timeoutSeconds"`
	Writable       bool             `json:"writable,omitempty"`
	Report         string           `json:"report,omitempty"`
	// History says a bundle follows the tree, to present read-only at
	// /history.
	History bool `json:"history,omitempty"`
	// ExportImage is an image on this worker (by ID) saved into the tree
	// before the check runs (an image scan).
	ExportImage string `json:"exportImage,omitempty"`
	// NoTree runs the command with nothing mounted, in the image's own
	// working directory (an exec-image check).
	NoTree bool `json:"noTree,omitempty"`
	// Files are generated files the check sees read-only (execution.File),
	// written beside its tree, in the check's folder.
	Files []execution.File `json:"files,omitempty"`
	// Services run beside the check on a network of its own
	// (execution.Request.Services), labelled as the check is, so the sweep
	// removes them with it.
	Services []deploy.ServiceSpec `json:"services,omitempty"`
}

type Checks struct {
	URL    string
	Client *http.Client
	// Limits bound each check's container on the worker (AppTown's task
	// limits).
	Limits execution.Limits
}

type DeliverRequest struct {
	Text string `json:"text"`
}

type DockerImages struct{ Binary string }

type PreviewImages struct {
	Parts map[string]string `json:"parts"`
	Init  map[string]string `json:"init,omitempty"`
}

type PreviewSpec struct {
	Name         string `json:"name"`
	StackID      string `json:"stackId"`
	Slug         string `json:"slug"`
	Incarnation  string `json:"incarnation"`
	ProbeSeconds int    `json:"probeSeconds"`
	PageCheck    bool   `json:"pageCheck,omitempty"`
	// VisitorHost is the host a visitor's request carries (BootRequest).
	VisitorHost string `json:"visitorHost,omitempty"`
	// Images, for a release's preview, are the release's images by digest
	// (<repository>@sha256:<hex>): the boot pulls them with the prepared
	// registry login and builds nothing. nil builds the tree, as a change's
	// preview does.
	Images *PreviewImages `json:"images,omitempty"`
}

type PreviewState struct {
	Running     bool   `json:"running"`
	Incarnation string `json:"incarnation,omitempty"`
	ContainerID string `json:"containerId,omitempty"`
	// Image and Digest are what the app runs, for a boot's answer.
	Image  string `json:"image,omitempty"`
	Digest string `json:"digest,omitempty"`
	// BrowserValues are the values the app's page is given, read from the
	// container, for a state's answer: null when they cannot be read, and
	// an empty object when the container states there are none.
	BrowserValues map[string]string `json:"browserValues"`
	// Boot failure, for a boot request: the phase, the error and the log.
	Phase   string `json:"phase,omitempty"`
	Error   string `json:"error,omitempty"`
	LogTail string `json:"logTail,omitempty"`
	// Page is what the boot's front-page check saw, for a boot's answer,
	// passed or refused.
	Page *docker.PageWitness `json:"page,omitempty"`
}

type Previews struct {
	URL    string
	Client *http.Client
	// Session is AppTown session its requests belong to, a positive
	// number (NextSession); "" is this process's start.
	Session string
}

type Reach struct {
	URL       string `json:"url"`
	Reachable bool   `json:"reachable"`
	Error     string `json:"error,omitempty"`
}

type ReachRequest struct {
	URLs []string `json:"urls"`
}

type RecordFile struct {
	Name     string    `json:"name"`
	Size     int64     `json:"size"`
	Modified time.Time `json:"modified"`
}

type RemoteAgent struct {
	Sessions SessionClient
	// Image is the agent image when a launch names none.
	Image string
	// Root is the directory holding AppTown's session directories
	// (<root>/<id>), where each chat's record is copied back to.
	Root string
	// Source writes a bundle of the change's branch for a session's work
	// tree to dest and names its branch and commit. It is asked once, before
	// the chat first starts; nil sends none.
	Source func(ctx context.Context, in console.Launch, dest string) (branch, commit string, err error)
	// CopyEvery is how often a started chat's record is copied back; zero
	// means two seconds.
	CopyEvery time.Duration
	// Ending, when set, makes the last save of an ending chat, after its
	// runtime has stopped and before it is removed (SaveLast answers that
	// save's bundle). An error keeps the chat: its end is asked again.
	Ending func(ctx context.Context, id string) error
	// HandedBack, when set, is called after a copy in which AppTown's
	// copy of the record shows the agent has handed back a turn it had not
	// shown before: the moment to save. It is a trigger, never proof that
	// the chat has stopped working.
	HandedBack func(id string)
	// Now is AppTown's clock, which stamps a good copy's time
	// (RecordAsOf). Nil is the real clock (clock.Or).
	Now func() time.Time
	// contains filtered or unexported fields
}

type Server struct {
	// Installation is the only client identity the worker accepts: the
	// Common Name of the client certificate.
	Installation string
	// State holds records and workspaces; nothing else on the machine is
	// touched.
	State string
	// Tasks runs the tasks: the worker's own Docker daemon in production.
	Tasks execution.TaskDriver
	// Sessions runs chats (sessions.go): AppTown's own chat runtime on the
	// worker's Docker. Nil for a worker that runs none.
	Sessions console.Agent
	// Images answers whether a session's image is on the worker's Docker;
	// a session whose image is absent is refused with the reason. Nil
	// checks nothing.
	Images interface {
		Has(ctx context.Context, image string) (bool, error)
	}
	// Checks runs check containers (checks.go) on the worker's Docker. Nil
	// for a worker that runs none.
	Checks interface {
		Run(ctx context.Context, backend string, req execution.Request) execution.Outcome
	}
	// AgentImage is the agent image this worker built (agent_image.go),
	// reported with its labels, read through ImageLabels, at
	// GET /v1/agent-image. "" reports none.
	AgentImage  string
	ImageLabels interface {
		Labels(ctx context.Context, image string) (map[string]string, error)
	}

	// DindImage is the image of a task's private Docker daemon
	// (private.go); "" refuses a task that asks for one.
	DindImage string
	// Docker is the Docker private Docker runs on and the profile is
	// measured from (docker.CLI in production); nil is the docker CLI.
	Docker docker.Client
	// Profile is what the worker measured when it started
	// (MeasureProfile), reported at GET /v1/profile.
	Profile execution.WorkerProfile

	// ServiceLimits are each private service's limits (private.go); zero is
	// execution.DefaultServiceLimits. A check's services get Checks' own.
	ServiceLimits execution.Limits
	// StateDisk reads the filesystem holding a folder: the state folder's,
	// for admitting new work. Nil reads it (diskspace.Statfs).
	StateDisk func(path string) (diskspace.Space, error)
	// ToolCache is the folder mounted writable at execution.ToolCacheMount
	// in every task's and check's container (tool_cache.go); "" mounts none.
	ToolCache string
	// Previews is the Docker previews boot with (docker.CLI in production);
	// nil runs none.
	Previews docker.Client
	// Now is the worker's clock: what it stamps and judges expiries,
	// deadlines and leases by. Nil is the real clock (clock.Or).
	Now func() time.Time
	// contains filtered or unexported fields
}

type SessionClient struct {
	URL    string
	Client *http.Client
}

type SessionMount struct {
	Blob   string `json:"blob"`
	Target string `json:"target"`
}

type SessionSpec struct {
	Image        string `json:"image"`
	Model        string `json:"model,omitempty"`
	AgentSession string `json:"agentSession"`
	Docker       bool   `json:"docker,omitempty"`
	// Mirror is the Docker Hub mirror the chat's private daemon and its
	// builder pull through ("" none); its resolvers are the worker's own.
	Mirror string         `json:"mirror,omitempty"`
	Env    []string       `json:"env,omitempty"`
	Mounts []SessionMount `json:"mounts,omitempty"`
}

type SessionStatus struct {
	ID      string `json:"id"`
	Known   bool   `json:"known"`
	Removed bool   `json:"removed,omitempty"`
	// Agent is the chat's container; Docker its private daemon.
	Agent struct {
		Exists      bool `json:"exists"`
		Running     bool `json:"running"`
		EverStarted bool `json:"everStarted"`
		// Attached: the worker holds the chat's terminal.
		Attached bool `json:"attached"`
	} `json:"agent"`
	Docker struct {
		Exists  bool `json:"exists"`
		Running bool `json:"running"`
	} `json:"docker"`
	// Script: a save's container exists on the chat's work tree.
	Script struct {
		Exists bool `json:"exists"`
	} `json:"script"`
	// Stale: the container no longer matches the session's spec and is
	// stopped, so a rebuild may make a new one. A running chat is never
	// stale here: it is rebuilt only once it has stopped.
	Stale bool `json:"stale,omitempty"`
	// FilesDigest identifies the chat's files as last sent.
	FilesDigest string `json:"filesDigest,omitempty"`
	// Source is the commit the chat's work tree was made from; empty until
	// AppTown sends it.
	Source string `json:"source,omitempty"`
}

type SessionSummary struct {
	ID      string    `json:"id"`
	Created time.Time `json:"created"`
	Removed bool      `json:"removed,omitempty"`
}

type TaskRequest struct {
	Key       string              `json:"key"`
	Admission execution.Admission `json:"admission"`
	Image     string              `json:"image"`
	Argv      []string            `json:"argv"`
	Env       []string            `json:"env"`
	Workspace string              `json:"workspace,omitempty"`
	// Source is the commit the workspace was uploaded with.
	Source string `json:"source,omitempty"`
	// Request is the client's identity for what the task runs. The worker
	// holds a key to it; without one, to the request as sent.
	Request  string   `json:"request,omitempty"`
	ReadOnly bool     `json:"readOnly,omitempty"`
	Labels   []string `json:"labels,omitempty"`
	// Files are generated files the task sees read-only (execution.File),
	// kept in the task's own folder until it is released.
	Files []execution.File `json:"files,omitempty"`
	// Inputs name blobs sent to this worker, presented read-only under
	// /apptown/in; Results are files captured when the task exits (task_io.go).
	Inputs  []execution.Input  `json:"inputs,omitempty"`
	Results []execution.Result `json:"results,omitempty"`
	// Images are OCI image layouts a release build leaves in its
	// workspace's state, captured when it exits (task_images.go).
	Images []execution.ImageResult `json:"images,omitempty"`
	// Private is the task's own network, services and daemon (private.go).
	Private *execution.PrivateDocker `json:"private,omitempty"`
}

type VersionReport struct {
	Version     string `json:"version"`
	ProtocolMin int    `json:"protocolMin"`
	ProtocolMax int    `json:"protocolMax"`
}