docker

type ContainerHost struct {
	IContainerAPI
	// contains filtered or unexported fields
}

type ContainerHostOption func(settings *containerHostSettings) error

type ContainerSample struct {
	// CPUNanoseconds is the container's cumulative cpu time.
	CPUNanoseconds uint64
	// SystemNanoseconds is the host's cumulative cpu time across every cpu.
	SystemNanoseconds uint64
	// OnlineCPUs is how many cpus the host had online at the reading.
	OnlineCPUs uint32
	// MemoryBytes is the memory the container's cgroup charges.
	MemoryBytes uint64
}

type ExecResult struct {
	ExitCode int
	Stdout   []byte
	Stderr   []byte
}

type ExecSpec struct {
	Command []string
	// User is the user[:group] the command runs as; empty means the
	// container's.
	User string
}

type ExitError struct {
	ContainerID string
	Code        int64
}

type IContainerAPI interface {
	ContainerCreate(ctx context.Context, options client.ContainerCreateOptions) (client.ContainerCreateResult, error)
	ContainerInspect(ctx context.Context, id string, options client.ContainerInspectOptions) (client.ContainerInspectResult, error)
	ContainerStart(ctx context.Context, id string, options client.ContainerStartOptions) (client.ContainerStartResult, error)
	ContainerStop(ctx context.Context, id string, options client.ContainerStopOptions) (client.ContainerStopResult, error)
	ContainerKill(ctx context.Context, id string, options client.ContainerKillOptions) (client.ContainerKillResult, error)
	ContainerPause(ctx context.Context, id string, options client.ContainerPauseOptions) (client.ContainerPauseResult, error)
	ContainerUnpause(ctx context.Context, id string, options client.ContainerUnpauseOptions) (client.ContainerUnpauseResult, error)
	ContainerStats(ctx context.Context, id string, options client.ContainerStatsOptions) (client.ContainerStatsResult, error)
	ContainerWait(ctx context.Context, id string, options client.ContainerWaitOptions) client.ContainerWaitResult
	ContainerRemove(ctx context.Context, id string, options client.ContainerRemoveOptions) (client.ContainerRemoveResult, error)
	ContainerLogs(ctx context.Context, id string, options client.ContainerLogsOptions) (client.ContainerLogsResult, error)
	ContainerList(ctx context.Context, options client.ContainerListOptions) (client.ContainerListResult, error)
	ImageList(ctx context.Context, options client.ImageListOptions) (client.ImageListResult, error)
	ImagePrune(ctx context.Context, options client.ImagePruneOptions) (client.ImagePruneResult, error)
	BuildCachePrune(ctx context.Context, options client.BuildCachePruneOptions) (client.BuildCachePruneResult, error)
	DiskUsage(ctx context.Context, options client.DiskUsageOptions) (client.DiskUsageResult, error)
	ImagePull(ctx context.Context, reference string, options client.ImagePullOptions) (client.ImagePullResponse, error)
	ExecCreate(ctx context.Context, containerID string, options client.ExecCreateOptions) (client.ExecCreateResult, error)
	ExecAttach(ctx context.Context, execID string, options client.ExecAttachOptions) (client.ExecAttachResult, error)
	ExecInspect(ctx context.Context, execID string, options client.ExecInspectOptions) (client.ExecInspectResult, error)
	Close() error
}

type IServices interface {
	EnsureService(ctx context.Context, spec ServiceSpec) (ServiceState, error)
	InspectService(ctx context.Context, name string) (ServiceState, error)
	StopService(ctx context.Context, name string) error
}

type Mount struct {
	Source   string
	Target   string
	ReadOnly bool
}

type OwnedLocation struct {
	Container string `json:"container"`
	Volume    string `json:"volume"`
	Image     string `json:"image"`
	Host      string `json:"host"`
	Port      uint16 `json:"port"`
}

type OwnedRecord[Settings any] struct {
	OwnedLocation
	Settings Settings `json:"settings"`
}

type OwnedService[Settings any] struct {
	// contains filtered or unexported fields
}

type OwnedServiceDefinition[Settings any] struct {
	// StateDirectory holds RecordFile, mode 0600; one container per state
	// directory.
	StateDirectory string
	RecordFile     string
	// NamePrefix and a digest of StateDirectory name the container; its
	// volume adds "-data" and is mounted at DataDirectory.
	NamePrefix    string
	DataDirectory string
	// Image is pinned by digest.
	Image string
	// Host is the address the port is published on: loopback, or a tailnet
	// address.
	Host netip.Addr
	// NewSettings fills the owner's settings on the first start only; nil
	// leaves them zero.
	NewSettings func() (Settings, error)
	// Spec is the container a record describes: environment, mounts, health
	// check and anything else of the owner's. Name, Image, HostAddress,
	// HostPort and the data volume are set from the record.
	Spec func(record OwnedRecord[Settings]) ServiceSpec
	// Validate checks the owner's settings each time the record is loaded,
	// naming a required field that is missing; nil checks none.
	Validate func(settings Settings) *RecordError
}

type OwnedServiceOption func(capabilities *ownedCapabilities) error

type OwnedStatus struct {
	Location OwnedLocation `json:"location"`
	State    ServiceState  `json:"state"`
}

type RecordError struct {
	Path    string
	Field   string
	Problem string
	Fix     string
}

type SandboxResult struct {
	ContainerID     string
	ExitCode        int64
	Stdout          []byte
	Stderr          []byte
	StdoutTruncated bool
	StderrTruncated bool
}

type SandboxSpec struct {
	Image            string
	Command          []string
	Environment      []string
	WorkingDirectory string
	User             string
	Mounts           []Mount
	Labels           map[string]string
	// Network is a Docker network mode; empty means no network at all.
	Network string
	// MemoryBytes and NanoCPUs are resource limits; zero means unlimited.
	MemoryBytes int64
	NanoCPUs    int64
	// PidsLimit bounds process creation; zero means [DefaultPidsLimit].
	PidsLimit int64
	// WritableRoot leaves the root filesystem writable.
	WritableRoot bool
}

type ServiceSpec struct {
	Name        string
	Image       string
	Environment []string
	Labels      map[string]string
	// Volumes maps a named volume to the path it is mounted at; the Engine
	// creates a missing volume.
	Volumes map[string]string
	// Mounts are host paths visible inside the container. A missing source is
	// an error rather than a root-owned directory the Engine creates.
	Mounts []Mount
	// Port is the container port ("5432/tcp") published on HostAddress at
	// HostPort, which [ServiceState.HostPort] reports. A fixed HostPort keeps
	// the same port across restarts; zero lets the Engine choose one on every
	// start.
	Port        string
	HostAddress netip.Addr
	HostPort    uint16
	// ExtraHostAddresses publish Port at the same HostPort on each further
	// address, such as a tailnet address beside the loopback one; they need a
	// fixed HostPort, so every address serves the one recorded port.
	ExtraHostAddresses []netip.Addr
	// Command replaces the image's default arguments; empty keeps them.
	Command []string
	// HealthCheck is the command the Engine runs every HealthInterval;
	// [ServiceState.Health] reports its verdict.
	HealthCheck    []string
	HealthInterval time.Duration
	// GPU grants the container the host's GPUs through the nvidia driver.
	GPU bool
}

type ServiceState struct {
	ID      string `json:"id"`
	Status  string `json:"status"`
	Running bool   `json:"running"`
	// Health is the health check's verdict: starting, healthy or unhealthy.
	Health   string `json:"health"`
	HostPort uint16 `json:"host_port"`
}

type StartedContainer struct {
	ID string
	// Pid is the host PID of the container's init process.
	Pid int
}