controller

type BackendInfoView struct {
	Kind      store.BackendKind `json:"kind"`
	Available bool              `json:"available"`
	Version   string            `json:"version,omitempty"`
	Rootless  bool              `json:"rootless"`
	Endpoint  string            `json:"endpoint,omitempty"`
	Detail    string            `json:"detail,omitempty"`
	DinD      bool              `json:"supports_dind"`
}

type CapacityDemandEvent struct {
	SchemaVersion         int               `json:"schema_version"`
	EventID               string            `json:"event_id"`
	Type                  string            `json:"type"`
	Timestamp             time.Time         `json:"timestamp"`
	PoolID                string            `json:"pool_id"`
	HostSelector          store.StringMap   `json:"host_selector"`
	Backend               store.BackendKind `json:"backend"`
	RequiredRunnerSlots   int               `json:"required_runner_slots"`
	CurrentCapacity       int               `json:"current_capacity"`
	QueuedJobCount        int               `json:"queued_job_count"`
	OldestQueueAgeSeconds int64             `json:"oldest_queue_age_seconds"`
}

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

type Fence = store.RecoveryFence

type HostExclusion struct {
	Host string `json:"host"`
	// Code is which of the placement rules turned this host down, for a caller
	// that wants to group or colour them: unavailable, backend, platform, size.
	Code   string `json:"code"`
	Reason string `json:"reason"`
}

type HostFit struct {
	Count  int
	Detail string
	// Alternatives are the backends offered by the hosts that match this pool
	// in every way except its backend, in the order a pool would move to them.
	// The wizard turns them into the second half of its warning, in the same
	// words the scheduler uses once the pool is real.
	Alternatives []string
	// PlatformMismatch counts the hosts that fit in every other way but are
	// not the machine the pool asked for. It is called out separately because
	// it is the one mismatch no backend change can fix: the answer is a
	// different host, or a different platform on the pool.
	PlatformMismatch int
	// Selected is how many hosts the pool's host selector reaches at all,
	// whatever became of them afterwards. It is the number the wizard's
	// placement step shows while a selector is being typed, and Count is the
	// number its review step shows -- so when the two differ, something
	// happened between them that an operator has to be told about.
	Selected int
	// Excluded is that difference, host by host: everything the selector
	// reaches and the fleet cannot run, with the reason in the operator's
	// terms. It is what turns "2 hosts match" followed by "1 host can run
	// this pool" from a contradiction into an explanation.
	Excluded []HostExclusion
}

type HostStats struct {
	Total    int `json:"total"`
	Healthy  int `json:"healthy"`
	Cordoned int `json:"cordoned"`
	Capacity int `json:"capacity"`
	Used     int `json:"used"`
}

type HostView struct {
	Usage           *store.HostUsage  `json:"usage,omitempty"`
	UsageFresh      bool              `json:"usage_fresh"`
	AdmissionReason string            `json:"admission_reason,omitempty"`
	Connection      string            `json:"connection"`
	ID              string            `json:"id"`
	Name            string            `json:"name"`
	Address         string            `json:"address,omitempty"`
	Embedded        bool              `json:"embedded"`
	Capacity        int               `json:"capacity"`
	ActiveRunners   int               `json:"active_runners"`
	Free            int               `json:"free"`
	Backends        []string          `json:"backends"`
	BackendInfo     []BackendInfoView `json:"backend_info"`
	Labels          map[string]string `json:"labels"`
	OS              string            `json:"os,omitempty"`
	Distro          string            `json:"distro,omitempty"`
	OSVersion       string            `json:"os_version,omitempty"`
	Arch            string            `json:"arch,omitempty"`
	// CPUs and MemoryMB are how much machine this host is, as its agent
	// reported it: the daemon's view of the machine where that is larger than
	// the agent's own share, because a container runner runs beside the agent
	// rather than inside its cgroup.
	CPUs     int   `json:"cpus,omitempty"`
	MemoryMB int64 `json:"memory_mb,omitempty"`
	// DiskTotalMB and DiskFreeMB are the filesystem holding the agent's work
	// directory, which is where a runner's checkout and its caches land -- so
	// it is the disk that decides whether a job has anywhere to go, and the
	// answer to "the host has slots free, why did nothing start?".
	//
	// Free is what a runner may write to rather than what is unused; the two
	// differ by the reserve the filesystem keeps for root, and a runner is not
	// root. Zero on both is "not measured" -- an agent too old to report it,
	// or a platform with no portable way to ask -- and is not a full disk.
	DiskTotalMB int64 `json:"disk_total_mb,omitempty"`
	DiskFreeMB  int64 `json:"disk_free_mb,omitempty"`
	// ReserveCPUs, ReserveMemoryMB and ReserveDiskMB are what the operator has
	// held back from placement, for the machine's own sake rather than for any
	// pool's. They are the operator's alone: a heartbeat never writes them,
	// exactly as it never writes capacity.
	ReserveCPUs     int   `json:"reserve_cpus,omitempty"`
	ReserveMemoryMB int64 `json:"reserve_memory_mb,omitempty"`
	ReserveDiskMB   int64 `json:"reserve_disk_mb,omitempty"`
	// AllocatableCPUs, AllocatableMemoryMB and AllocatableDiskMB are the
	// machine less its reserve: what the scheduler may actually place onto,
	// which is the figure a "how full is this host" question is asked against.
	// The floors under the reserve -- 512 MB of memory and 2 GB of disk -- are
	// applied here too, so what is shown is what is used.
	AllocatableCPUs     float64 `json:"allocatable_cpus,omitempty"`
	AllocatableMemoryMB int64   `json:"allocatable_memory_mb,omitempty"`
	AllocatableDiskMB   int64   `json:"allocatable_disk_mb,omitempty"`
	// ReservedCPUs and ReservedMemoryMB are what the runners already on this
	// host have promised away, as of the last scheduling pass and from the
	// snapshot that pass decided on. Disk is deliberately absent: free disk is
	// a measurement of the filesystem as it is now, so what those runners have
	// written is in DiskFreeMB already, and adding their reservations would
	// charge the same bytes twice.
	//
	// ReservedKnown is false until a pass has run, because zero would read as
	// an idle machine rather than as an unanswered question.
	ReservedCPUs     float64 `json:"reserved_cpus,omitempty"`
	ReservedMemoryMB int64   `json:"reserved_memory_mb,omitempty"`
	ReservedKnown    bool    `json:"reserved_known"`
	// ResourcesKnown is whether this host has reported what machine it is at
	// all. An agent too old to say is placed by slots alone, which is what
	// keeps an upgrade from emptying a fleet -- and the page has to say so,
	// because a host showing no figures looks broken rather than old.
	ResourcesKnown bool `json:"resources_known"`
	// Platform is what this host is in the terms a pool asks in, and
	// PlatformLabel is the same thing as a sentence: "Ubuntu 24.04, arm64".
	Platform      store.Platform `json:"platform"`
	PlatformLabel string         `json:"platform_label,omitempty"`
	// CanonicalName is the name this machine would be given today. It is shown
	// beside a host called something that says nothing, so an operator can see
	// what renaming it would buy them.
	CanonicalName  string `json:"canonical_name,omitempty"`
	Version        string `json:"version,omitempty"`
	VersionChannel string `json:"version_channel,omitempty"`
	Cordoned       bool   `json:"cordoned"`
	// ProtocolVersion is the agent protocol this host reported, and
	// Incompatible whether this controller can work with it. An incompatible
	// host is excluded from placement exactly as a cordoned one is, so the
	// Hosts page has to say which of the two it is: nothing is broken, the
	// host is up and heartbeating, and it has quietly stopped taking work.
	ProtocolVersion    int    `json:"protocol_version,omitempty"`
	Incompatible       bool   `json:"incompatible"`
	IncompatibleReason string `json:"incompatible_reason,omitempty"`
	// VersionSkew is how this host's release stands to the controller's:
	// "behind", "ahead", "differs", or absent when they match. It is computed
	// here rather than in the browser because the controller is the side that
	// knows its own version, and because the agent's own warning comes from
	// the same comparison -- the two used to disagree for two builds of one
	// tag, and a badge that contradicts a log line is worse than neither.
	VersionSkew    string    `json:"version_skew,omitempty"`
	UpgradeCommand string    `json:"upgrade_command,omitempty"`
	UpgradeVersion string    `json:"upgrade_version,omitempty"`
	UpgradeNote    string    `json:"upgrade_note,omitempty"`
	Healthy        bool      `json:"healthy"`
	LastHeartbeat  time.Time `json:"last_heartbeat"`
	CreatedAt      time.Time `json:"created_at"`
}

type InstallationView struct {
	ID             string           `json:"id"`
	AppID          int64            `json:"app_id"`
	InstallationID int64            `json:"installation_id"`
	Target         string           `json:"target"`
	TargetType     store.TargetType `json:"target_type"`
	APIBaseURL     string           `json:"api_base_url"`
	AppSlug        string           `json:"app_slug,omitempty"`
	WebURL         string           `json:"web_url,omitempty"`
	// SettingsURL is the App's own settings page on GitHub. It is carried on
	// every installation, not only on the one the connect flow just created,
	// because the one thing a manifest cannot do is set the App's avatar --
	// GitHub takes it as an upload -- and an operator who missed that step
	// during setup has nowhere else to be told about it. Empty when the slug
	// is unknown, which is what a hand-added installation looks like.
	SettingsURL   string     `json:"settings_url,omitempty"`
	Enterprise    bool       `json:"enterprise"`
	Healthy       bool       `json:"healthy"`
	LastError     string     `json:"last_error,omitempty"`
	LastCheckedAt *time.Time `json:"last_checked_at"`
	PoolCount     int        `json:"pool_count"`
	CreatedAt     time.Time  `json:"created_at"`
	UpdatedAt     time.Time  `json:"updated_at"`
}

type JobExplanation struct {
	JobID string         `json:"job_id"`
	State store.JobState `json:"state"`
	// Summary is the sentence. It is always set, including for a job that is
	// running or finished: "nothing is wrong" is an answer to the question, and
	// a caller that has to special-case an empty string will print nothing on
	// the one page an operator opened to be told something.
	Summary string `json:"summary"`
	// Detail is what the summary leaves out, in the scheduler's own words
	// where it has any.
	Detail string `json:"detail,omitempty"`
	// Fix is what to do. Empty means there is nothing to do, which is the
	// normal case and is different from not knowing.
	Fix string `json:"fix,omitempty"`
	// Waiting is whether the job is still waiting on something. Blocked is
	// whether waiting will not on its own end it: a fleet that is merely busy
	// clears, and a pool nothing can place never will.
	Waiting bool `json:"waiting"`
	Blocked bool `json:"blocked"`
	// PoolID, RunnerID and HostID are what the explanation is about, so a
	// caller can link to them rather than parse them back out of the prose.
	PoolID     string    `json:"pool_id,omitempty"`
	RunnerID   string    `json:"runner_id,omitempty"`
	HostID     string    `json:"host_id,omitempty"`
	ComputedAt time.Time `json:"computed_at"`
}

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

type JobView struct {
	Provisioning string         `json:"provisioning"`
	ProvisionNow bool           `json:"provision_now"`
	ID           string         `json:"id"`
	GitHubJobID  int64          `json:"github_job_id"`
	GitHubRunID  int64          `json:"github_run_id"`
	Repo         string         `json:"repo"`
	Workflow     string         `json:"workflow"`
	JobName      string         `json:"job_name"`
	Labels       []string       `json:"labels"`
	State        store.JobState `json:"state"`
	Conclusion   string         `json:"conclusion,omitempty"`
	// InstallationID is the GitHub App installation covering this job's
	// repository. It is read-only and derived at ingest; a pool only ever runs
	// work in its own installation's target, so this is half of why a job is
	// or is not claimed.
	InstallationID string `json:"installation_id,omitempty"`
	PoolID         string `json:"pool_id,omitempty"`
	PoolName       string `json:"pool_name,omitempty"`
	RunnerID       string `json:"runner_id,omitempty"`
	RunnerName     string `json:"runner_name,omitempty"`
	HTMLURL        string `json:"html_url,omitempty"`
	Matched        bool   `json:"matched"`
	// EligibleAt is when this fleet could first have acted on the job: the
	// moment an enabled pool claimed its labels. It is the start of the
	// scheduling-latency interval, and it is not queued_at -- the wait
	// before anything could run the job is not this fleet's to answer for.
	// Absent on a job nothing has claimed, and on one recorded before the
	// column existed.
	EligibleAt *time.Time `json:"eligible_at,omitempty"`
	// Hosted is true when every label names a runner somebody else operates:
	// GitHub's own or a hosted-runner vendor's. Such a job is theirs to run,
	// so it being unmatched here is expected rather than a job going nowhere.
	Hosted     bool            `json:"hosted"`
	HeadBranch string          `json:"head_branch,omitempty"`
	HeadSHA    string          `json:"head_sha,omitempty"`
	RunAttempt int             `json:"run_attempt,omitempty"`
	Steps      []store.JobStep `json:"steps"`
	// FailedStep is the step a failed job stopped at, worked out here from the
	// steps so that the grid and the drawer name the same one. Null when the
	// job did not fail on a step it ran.
	FailedStep *store.JobStep `json:"failed_step"`
	// RunnerFault is set when the runner executing this job stopped before
	// GitHub reported the job over: the fleet's own explanation of a failure
	// GitHub records like any other.
	RunnerFault string     `json:"runner_fault,omitempty"`
	QueuedAt    time.Time  `json:"queued_at"`
	StartedAt   *time.Time `json:"started_at"`
	CompletedAt *time.Time `json:"completed_at"`
	QueueWaitMS int64      `json:"queue_wait_ms"`
	DurationMS  int64      `json:"duration_ms"`
}

type MigrationApplyRequest struct {
	InstallationID string            `json:"installation_id"`
	Repos          []string          `json:"repos"`
	Mapping        map[string]string `json:"mapping"`
	// Overrides are the exceptions to Mapping. They sit alongside Workflows
	// rather than inside it: Workflows says which files move at all, and an
	// override says where one job in one of them lands.
	Overrides []migrate.Override `json:"overrides"`
	// Workflows narrows a repository to the workflow files named here, keyed by
	// repository. A repository absent from the map gets every file the mapping
	// would change, which is what a client that does not know about the field
	// asks for. It exists because a repository with a dozen workflow files is
	// rarely one where all dozen should move at once.
	Workflows map[string][]string `json:"workflows"`
	// Title, Body and CommitMessage override the defaults. They are here
	// because the pull request lands in somebody else's repository, and an
	// organisation with a pull-request template or a commit convention should
	// not have to accept ours.
	Title         string `json:"title"`
	Body          string `json:"body"`
	CommitMessage string `json:"commit_message"`
	// Badge says whether each pull request also adds the "CI has the
	// Zoomies" badge to the repository's README. It is a pointer because
	// the default is yes: a client that does not know the field asks for the
	// badge, and only an explicit false leaves the README alone. The badge is
	// how the people who read a README find out what runs its CI, and a
	// checkbox is a fair price for a line in somebody else's front page.
	Badge *bool `json:"badge"`
}

type MigrationOutcome struct {
	Results []MigrationResult `json:"results"`
	Opened  int               `json:"opened"`
	Skipped int               `json:"skipped"`
	Failed  int               `json:"failed"`
	// Branch is the branch every pull request was opened from, for the audit
	// row; each result carries its own for the wire.
	Branch string `json:"-"`
}

type MigrationPlan struct {
	InstallationID string `json:"installation_id"`
	Target         string `json:"target"`
	// Repositories is every repository looked at, whether or not it changed.
	// A repository with nothing to do is information: it means its workflows
	// are already somewhere deliberate.
	Repositories []migrate.RepoPlan `json:"repositories"`
	// HostedLabels is every hosted-runner label found across them -- GitHub's
	// own and the vendors' -- which is what the mapping step lists.
	HostedLabels []string `json:"hosted_labels"`
	// Mapping is what was applied -- the request's, or the proposal the server
	// made from the pools that exist.
	Mapping map[string]string `json:"mapping"`
	// Overrides is what was applied on top of it, echoed back so that a plan
	// describes itself: every `to` under Repositories came either from Mapping
	// or from one of these.
	Overrides []migrate.Override `json:"overrides"`
	// Unmapped are the hosted labels no pool was proposed for. They are the
	// operator's decision, and the reason a plan can be empty.
	Unmapped []string `json:"unmapped"`
	// Pools is what the mapping step chooses between.
	Pools  []MigrationPoolOption `json:"pools"`
	Counts migrate.Counts        `json:"counts"`
	// Truncated says there are more repositories after this page. It is kept
	// alongside NextCursor because it is what a client reads to know the
	// listing is incomplete, whether or not it can page.
	Truncated bool `json:"truncated"`
	// NextCursor is what to send as Cursor to read the next page. Empty means
	// this was the last one.
	NextCursor string `json:"next_cursor,omitempty"`
	// TotalRepos is how many repositories the installation can see, so a wizard
	// showing a page can say what fraction of the whole it is.
	TotalRepos int `json:"total_repos"`
	// MissingPermissions is what the App still needs before the apply step can
	// work. It is reported here, in the step before, because discovering it
	// halfway through opening pull requests leaves half of them open.
	MissingPermissions []string `json:"missing_permissions"`
	// PermissionHint is the sentence that fixes MissingPermissions.
	PermissionHint string `json:"permission_hint,omitempty"`
	// SettingsURL is where to go and fix it.
	SettingsURL string `json:"settings_url,omitempty"`
}

type MigrationPlanRequest struct {
	InstallationID string `json:"installation_id"`
	// Repos limits the plan to these repositories. Empty means every
	// repository the installation can see, up to the limit.
	Repos []string `json:"repos"`
	// Mapping is hosted label -> the runs-on value that replaces it. Empty asks
	// the server to propose one from the pools that exist.
	Mapping map[string]string `json:"mapping"`
	// Overrides are the exceptions to Mapping, each naming one job in one file
	// in one repository. Empty is the common case: most fleets want one answer
	// per hosted-runner label everywhere.
	Overrides []migrate.Override `json:"overrides"`
	// Cursor asks for the page of repositories after this one. It is the full
	// name of the last repository the previous page returned, because the
	// listing is sorted by name: a name is stable when the App gains or loses
	// a repository between two pages, and an offset is not.
	Cursor string `json:"cursor"`
}

type MigrationPoolOption struct {
	ID     string   `json:"id"`
	Name   string   `json:"name"`
	Labels []string `json:"labels"`
	// RunsOn is what a workflow writes to reach this pool: the value the
	// mapping should hold.
	RunsOn  string `json:"runs_on"`
	Enabled bool   `json:"enabled"`
}

type MigrationResult struct {
	Repo string `json:"repo"`
	// Status is "opened", "skipped" or "failed".
	Status string `json:"status"`
	// PullRequestURL and PullRequestNumber are set when Status is "opened".
	PullRequestURL    string `json:"pull_request_url,omitempty"`
	PullRequestNumber int    `json:"pull_request_number,omitempty"`
	Branch            string `json:"branch,omitempty"`
	// Workflows is how many files the pull request changed.
	Workflows int `json:"workflows"`
	// Jobs is how many runs-on lines it rewrote.
	Jobs int `json:"jobs"`
	// Reason explains a skip or a failure.
	Reason string `json:"reason,omitempty"`
	// Badge says what became of the README badge on a pull request that was
	// opened: "added", "present" when the README already carried it,
	// "no_readme" when there was nowhere Markdown to put it, "unread" when
	// GitHub would not hand the README over, and "off" when the request
	// asked for none. BadgeReason says which of the no_readme and unread
	// cases it was. A badge that could not be added never stops the
	// migration: the runs-on lines are the work, and the badge is the thanks.
	Badge       string `json:"badge,omitempty"`
	BadgeReason string `json:"badge_reason,omitempty"`
}

type Options struct {
	// Store is the only writer of persistent state.
	Store *store.Store
	// Config is the validated configuration; the controller reads the
	// scheduler tunables, the GitHub settings and the retention windows.
	Config *config.Config
	// Key unseals the GitHub App private keys and webhook secrets held in the
	// database. Without it no installation can be used.
	Key *cryptox.Key
	// Auth mints agent tokens, redeems join tokens and records audit rows.
	Auth *auth.Service
	// Events carries every state change to the UI's SSE stream.
	Events *events.Bus
	// GitHub builds a client per installation; nil uses the real GitHub App
	// factory, and tests pass one backed by github.NewFake.
	GitHub github.Factory
	// Backends is only needed when this process also runs the embedded agent.
	Backends *backend.Registry
	Logger   *slog.Logger
	// Clock is injectable so tests can freeze time.
	Clock func() time.Time
	// HTTPClient delivers capacity-demand events. Tests may inject a transport.
	HTTPClient *http.Client
	// LogLevel is the gate the process logger is filtered at, when the caller
	// built one that can move. UpdateConfig sets it from log.level, so that a
	// level changed through PATCH /settings or SIGHUP is the level the process
	// actually logs at, not merely the one the settings page shows.
	LogLevel *slog.LevelVar
	// Lease is this controller's claim on the database, taken before the
	// controller was built. A nil lease means nothing renews and nothing is
	// reported, which is what an embedded or test controller wants.
	Lease *store.ControllerLease
}

type PoolCountsView struct {
	Provisioning int `json:"provisioning"`
	Registering  int `json:"registering"`
	Idle         int `json:"idle"`
	Busy         int `json:"busy"`
	Draining     int `json:"draining"`
	Failed       int `json:"failed"`
	Live         int `json:"live"`
}

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

type PoolStats struct {
	PoolID   string `json:"pool_id"`
	PoolName string `json:"pool_name"`
	Min      int    `json:"min"`
	Max      int    `json:"max"`
	Live     int    `json:"live"`
	Busy     int    `json:"busy"`
	Idle     int    `json:"idle"`
	// Queued is the number of queued jobs this pool has claimed.
	Queued      int     `json:"queued"`
	Utilisation float64 `json:"utilisation"`
}

type PoolView struct {
	ID                 string            `json:"id"`
	Name               string            `json:"name"`
	InstallationID     string            `json:"installation_id"`
	InstallationTarget string            `json:"installation_target,omitempty"`
	Labels             []string          `json:"labels"`
	RunnerGroup        string            `json:"runner_group,omitempty"`
	Backend            store.BackendKind `json:"backend"`
	// Platform is the machine this pool's runners need. It picks the runner
	// image and restricts which hosts the scheduler may place them on.
	Platform store.Platform `json:"platform"`
	Image    string         `json:"image"`
	// EffectiveImage is the image runners will actually boot: Image when the
	// pool names one, otherwise the variant its platform selects, otherwise
	// the instance default. A pool page that showed a blank image field and
	// nothing else would leave an operator guessing at the single most
	// important thing about their runners.
	EffectiveImage string           `json:"effective_image"`
	PullPolicy     store.PullPolicy `json:"pull_policy"`
	RunnerVersion  string           `json:"runner_version,omitempty"`
	MinRunners     int              `json:"min_runners"`
	MaxRunners     int              `json:"max_runners"`
	Priority       int              `json:"priority"`
	// RepositoryScaleUpLimit and CostPerRunnerHour are accepted on the way in,
	// so they are rendered on the way out: a field the API takes but never
	// shows again is a field an operator cannot check, edit or explain.
	RepositoryScaleUpLimit int               `json:"repository_scale_up_limit"`
	CostPerRunnerHour      *float64          `json:"cost_per_runner_hour"`
	IdleTimeout            store.Duration    `json:"idle_timeout"`
	Ephemeral              bool              `json:"ephemeral"`
	DockerMode             store.DockerMode  `json:"docker_mode"`
	Resources              store.Resources   `json:"resources"`
	Cache                  store.CacheConfig `json:"cache"`
	HostSelector           map[string]string `json:"host_selector"`
	Env                    map[string]string `json:"env"`
	RunAsRoot              bool              `json:"run_as_root"`
	Enabled                bool              `json:"enabled"`
	CreatedAt              time.Time         `json:"created_at"`
	UpdatedAt              time.Time         `json:"updated_at"`
	Counts                 PoolCountsView    `json:"counts"`
	QueuedJobs             int               `json:"queued_jobs"`
	Utilisation            float64           `json:"utilisation"`
	Warnings               []Problem         `json:"warnings,omitempty"`
}

type Problem struct {
	// Code is a stable identifier such as "host.unhealthy", suitable for
	// grouping or suppressing in an alerting rule.
	Code     string          `json:"code"`
	Severity config.Severity `json:"severity"`
	// Setting names the configuration key involved, when there is one.
	Setting string `json:"setting,omitempty"`
	Title   string `json:"title"`
	Detail  string `json:"detail,omitempty"`
	Fix     string `json:"fix,omitempty"`
	// TargetKind and TargetID let the UI link a problem to the pool, host,
	// runner or installation it is about.
	TargetKind string `json:"target_kind,omitempty"`
	TargetID   string `json:"target_id,omitempty"`
	// Alternatives are the choices the fix leaves open, when the fix is a
	// choice: for a pool no host can run, the backends its hosts do offer. They
	// are carried apart from the prose so the UI can put the change one click
	// away rather than leaving an operator to find the pool's edit form.
	Alternatives []string `json:"alternatives,omitempty"`
	// Since is when the situation started, where that is knowable.
	Since *time.Time `json:"since,omitempty"`
}

type ProblemsView struct {
	OK    bool      `json:"ok"`
	Items []Problem `json:"items"`
}

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

type RunnerStats struct {
	Provisioning int `json:"provisioning"`
	Registering  int `json:"registering"`
	Idle         int `json:"idle"`
	Busy         int `json:"busy"`
	Draining     int `json:"draining"`
	Failed       int `json:"failed"`
	Total        int `json:"total"`
}

type RunnerView struct {
	ID             string            `json:"id"`
	Name           string            `json:"name"`
	PoolID         string            `json:"pool_id"`
	PoolName       string            `json:"pool_name,omitempty"`
	HostID         string            `json:"host_id"`
	HostName       string            `json:"host_name,omitempty"`
	State          store.RunnerState `json:"state"`
	GitHubRunnerID int64             `json:"github_runner_id,omitempty"`
	ContainerID    string            `json:"container_id,omitempty"`
	Ephemeral      bool              `json:"ephemeral"`
	Labels         []string          `json:"labels"`
	Image          string            `json:"image,omitempty"`
	ImageDigest    string            `json:"image_digest,omitempty"`
	RunnerVersion  string            `json:"runner_version,omitempty"`
	CurrentJobID   string            `json:"current_job_id,omitempty"`
	CurrentJob     *JobView          `json:"current_job,omitempty"`
	Message        string            `json:"message,omitempty"`
	JobsHandled    int               `json:"jobs_handled"`
	CPUPercent     float64           `json:"cpu_percent,omitempty"`
	MemoryBytes    int64             `json:"memory_bytes,omitempty"`
	CreatedAt      time.Time         `json:"created_at"`
	// ContainerStartedAt and RegisteredAt are the two halves of coming up, and
	// they are on the view because the gap between them is the whole diagnosis
	// of a runner stuck in `registering`: a container that never started is a
	// backend or image problem on the host, and a container that started and
	// never registered is a credential, network or GitHub one. Without both, a
	// stuck runner has one symptom and two unrelated causes.
	CreateTaskIssuedAt    *time.Time `json:"create_task_issued_at,omitempty"`
	HostRemovedAt         *time.Time `json:"host_removed_at,omitempty"`
	RegistrationDeletedAt *time.Time `json:"registration_deleted_at,omitempty"`
	CleanupEstimatedAt    *time.Time `json:"cleanup_estimated_at,omitempty"`
	ContainerStartedAt    *time.Time `json:"container_started_at,omitempty"`
	RegisteredAt          *time.Time `json:"registered_at,omitempty"`
	StartedAt             *time.Time `json:"started_at"`
	LastIdleAt            *time.Time `json:"last_idle_at"`
	FinishedAt            *time.Time `json:"finished_at"`
	// CleanupError and its companions describe a runner Zoomies could not
	// finish taking away. An empty error is the normal case; a non-empty one
	// means something is still on a host or on GitHub.
	CleanupError    string     `json:"cleanup_error,omitempty"`
	CleanupFailedAt *time.Time `json:"cleanup_failed_at,omitempty"`
	CleanupAttempts int        `json:"cleanup_attempts,omitempty"`
	// CleanedUpAt is the end of the runner's life: nothing of it left, on the
	// host or on GitHub.
	CleanedUpAt *time.Time `json:"cleaned_up_at,omitempty"`
}

type ScopedJobStats struct {
	QueuedJobs   int   `json:"queued_jobs"`
	RunningJobs  int   `json:"running_jobs"`
	Completed    int   `json:"completed"`
	Succeeded    int   `json:"succeeded"`
	Failed       int   `json:"failed"`
	Cancelled    int   `json:"cancelled"`
	Unknown      int   `json:"unknown"`
	MedianWaitMS int64 `json:"median_wait_ms"`
	P95WaitMS    int64 `json:"p95_wait_ms"`
}

type Stats struct {
	// Window is the period the completed counts and the wait percentiles
	// cover. Completed is Succeeded + Failed + Cancelled + Unknown; a rate
	// computed from Completed and Failed alone would count a job GitHub
	// stopped reporting as a success, which is why the split is here.
	Window            string `json:"window"`
	QueuedJobs        int    `json:"queued_jobs"`
	RunningJobs       int    `json:"running_jobs"`
	Completed         int    `json:"completed"`
	Succeeded         int    `json:"succeeded"`
	Failed            int    `json:"failed"`
	Cancelled         int    `json:"cancelled"`
	Unknown           int    `json:"unknown"`
	MedianWaitMS      int64  `json:"median_wait_ms"`
	P95WaitMS         int64  `json:"p95_wait_ms"`
	P50StartupMS      int64  `json:"p50_startup_ms"`
	P95StartupMS      int64  `json:"p95_startup_ms"`
	P50RegistrationMS int64  `json:"p50_registration_ms"`
	P95RegistrationMS int64  `json:"p95_registration_ms"`

	// Fleet is every job figure above, narrowed to the jobs this fleet has a
	// hand in. Both are carried in one payload rather than chosen by a query
	// parameter because the same numbers arrive over the event stream, which
	// is one frame for every viewer: a per-request scope would be correct
	// until the next frame overwrote it, a second or two later.
	Fleet ScopedJobStats `json:"fleet"`

	Runners RunnerStats `json:"runners"`
	Hosts   HostStats   `json:"hosts"`
	Pools   []PoolStats `json:"pools"`
}