container

type AppContainerStopper interface {
	StopAppContainersExcept(ctx context.Context, appId types.AppId, keep ContainerName) error
}

type ClusterStats struct {
	Version    string `json:"version"`
	Platform   string `json:"platform"`
	Nodes      int    `json:"nodes"`
	ReadyNodes int    `json:"ready_nodes"`
	CPU        string `json:"cpu"`         // total allocatable cpu cores
	Memory     string `json:"memory"`      // total allocatable memory
	NodesError string `json:"nodes_error"` // set when node access is denied
}

type CommandCM struct {
	*types.Logger
	// contains filtered or unexported fields
}

type CommandOptions struct {
	Cpus   string         `mapstructure:"cpus"`
	Memory string         `mapstructure:"memory"`
	Other  map[string]any `mapstructure:",remain"`
}

type Container struct {
	ID          string `json:"ID"`
	Names       string `json:"Names"`
	Image       string `json:"Image"`
	State       string `json:"State"`
	Status      string `json:"Status"`
	PortString  string `json:"Ports"`
	LabelString string `json:"Labels"` // Docker format: "key=value,key=value"
	Port        int
	Labels      map[string]string `json:"-"` // Podman format, parsed from the JSON map
}

type ContainerExitChecker interface {
	// ContainerExited returns whether the named container has terminally
	// exited, along with its status text (e.g. "Exited (1) 5 seconds ago")
	// for error reporting. A missing container is not treated as exited.
	ContainerExited(ctx context.Context, name ContainerName) (exited bool, status string, err error)
}

type ContainerManager interface {
	BuildImage(ctx context.Context, name ImageName, sourceUrl, containerFile string, containerArgs map[string]string) error
	ImageExists(ctx context.Context, name ImageName) (bool, error)
	// RefreshImage pulls (or HEADs) the named image from its registry and returns a
	// stable content-addressable digest (e.g. "sha256:..."). Only used for
	// image-spec apps so the container handler can detect when the upstream
	// reference has moved and recreate the container with the new content.
	RefreshImage(ctx context.Context, name ImageName) (digest string, err error)
	GetContainerState(ctx context.Context, name ContainerName, expectHash string) (hostPort string, running bool, err error)
	StartContainer(ctx context.Context, name ContainerName) error
	StopContainer(ctx context.Context, name ContainerName) error
	RunContainer(ctx context.Context, appEntry *types.AppEntry, sourceDir string, containerName ContainerName,
		imageName ImageName, port int32, envMap map[string]string, volumes []*VolumeInfo,
		containerOptions map[string]string, paramMap map[string]string, versionHash string, isImageSpec bool,
		healthProbe *HealthProbe) error
	DeployContainer(ctx context.Context, req DeployRequest) (DeployResult, error)
	GetContainerLogs(ctx context.Context, name ContainerName, linesToShow int) (string, error)
	VolumeExists(ctx context.Context, name VolumeName) bool
	// VolumeCreate creates the named volume. size is a requested capacity
	// (kubernetes PVC size); empty means the manager default, and managers
	// without sized volumes (docker/podman) ignore it.
	VolumeCreate(ctx context.Context, name VolumeName, size string) error
	SupportsInPlaceUpdate() bool
}

type ContainerName string

type DelegateRequest struct {
	ImageTag       string
	ContainerFile  string
	ContainerArgs  map[string]string
	RegistryConfig *types.RegistryConfig
}

type DeployRequest struct {
	AppEntry           *types.AppEntry
	SourceDir          string
	ContainerName      ContainerName
	ImageName          ImageName
	Port               int32
	EnvMap             map[string]string
	Volumes            []*VolumeInfo
	ContainerOptions   map[string]string
	ParamMap           map[string]string
	VersionHash        string
	IsImageSpec        bool
	HealthProbe        *HealthProbe
	Verify             bool
	DeployAttempts     int
	LogLinesToShow     int
	ShowLogsForFailure bool
	// Litestream, when set, adds the app's replication companion to the pod:
	// per-database restore init containers and the replicate native sidecar.
	Litestream *LitestreamAppSpec
}

type DeployResult struct {
	ContainerName ContainerName
	VersionHash   string
	HostNamePort  string
}

type DeployRollbackError struct {
	Err         error
	Available   bool
	RollbackErr error
}

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

type DevContainerManager interface {
	ContainerManager
	RemoveImage(ctx context.Context, name ImageName) error
	// RemoveSupersededImages removes the app's generated images other than
	// keep. A dev image hash change builds a new dev-<hash> tagged image; the
	// previous images are never used again and would otherwise accumulate on
	// the dev machine. Callers must remove containers using the old images
	// first. Failure to remove an image is not fatal to a reload.
	RemoveSupersededImages(ctx context.Context, keep ImageName) error
	// RemoveContainer force-removes a dev container. Dev reloads prioritize a
	// short feedback loop and must not wait for the runtime's graceful-stop
	// timeout when replacing a container.
	RemoveContainer(ctx context.Context, name ContainerName) error
	// BuildImageTarget builds like BuildImage but stops at the named
	// Containerfile stage (docker build --target). Empty target builds the
	// full image.
	BuildImageTarget(ctx context.Context, name ImageName, sourceUrl, containerFile string,
		containerArgs map[string]string, buildTarget string) error
	// RunDevContainer runs a dev mode container with the fast reload options
	// applied (source mount workdir, command override, run hash label).
	RunDevContainer(ctx context.Context, appEntry *types.AppEntry, sourceDir string, containerName ContainerName,
		imageName ImageName, port int32, envMap map[string]string, volumes []*VolumeInfo,
		containerOptions map[string]string, paramMap map[string]string, devOpts DevRunOptions) error
	// GetDevContainerInfo reports whether a container with the given name
	// exists, whether it carries the given run hash label, its published host
	// port and whether it is currently running, in one container listing call.
	GetDevContainerInfo(ctx context.Context, name ContainerName, runHash string) (exists, matches bool, hostPort string, running bool, err error)
	// RestartDevContainer restarts (or starts, if stopped) a dev mode
	// container with no stop grace period, prioritizing the dev feedback loop.
	RestartDevContainer(ctx context.Context, name ContainerName) error
}

type DevRunOptions struct {
	// RunHash identifies the full runtime config of the dev container. It is
	// stamped as a label on the container so a reload can detect that the
	// running container is already up to date and skip the recreate.
	RunHash string
	// WorkDir overrides the working directory (where the app source is mounted)
	WorkDir string
	// Command is the app start command, run via `sh -c`, overriding the image
	// entrypoint and cmd. Empty means use the image entrypoint/cmd as is.
	Command string
}

type ExistsResult struct {
	Exists bool
	Digest string
}

type HealthProbe struct {
	Path             string
	Port             int32
	Scheme           string // "HTTP" or "HTTPS"
	PeriodSecs       int32
	TimeoutSecs      int32
	FailureThreshold int32 // steady-state readiness tolerance
	StartupFailures  int32 // startup probe tolerance for slow boots
}

type ImageName string

type KanikoBuild struct {
	Namespace     string
	JobName       string
	Image         string // e.g. "cgr.dev/chainguard/kaniko:latest"
	SourceDir     string // Local directory to tar up and send to Kaniko
	Dockerfile    string
	Destination   string
	ContainerArgs map[string]string
	ExtraArgs     []string
}

type KubernetesCM struct {
	*types.Logger
	// contains filtered or unexported fields
}

type KubernetesOptions struct {
	Cpus        string         `mapstructure:"cpus"`
	Memory      string         `mapstructure:"memory"`
	MinReplicas int32          `mapstructure:"min_replicas"` // min number of replicas to run the app on
	MaxReplicas int32          `mapstructure:"max_replicas"` // max number of replicas to run the app on
	Other       map[string]any `mapstructure:",remain"`
}

type LitestreamAppSpec struct {
	Image      string
	ConfigYAML string
	// ConfigHash identifies the full replication config (rendered yaml,
	// credentials, image); a change recreates the sidecar / rolls the pod.
	ConfigHash string
	Env        map[string]string // LITESTREAM_ACCESS_KEY_ID / LITESTREAM_SECRET_ACCESS_KEY
	Mounts     []LitestreamMount
	Restores   []LitestreamRestore
}

type LitestreamMount struct {
	VolumeName VolumeName
	TargetDir  string // mount path, same as in the app container
}

type LitestreamRestore struct {
	ReplicaURL string // s3://bucket/path?endpoint=... (no credentials)
	OutputPath string // path inside the shared volume mount
}

type LitestreamRunner interface {
	// RunLitestreamRestores runs the pre-start restore step: one one-shot
	// container per database, restoring files missing from the volume.
	RunLitestreamRestores(ctx context.Context, appId types.AppId, spec *LitestreamAppSpec) error
	// EnsureLitestreamSidecar starts (or recreates, on config change) the
	// app's replication sidecar container.
	EnsureLitestreamSidecar(ctx context.Context, appEntry *types.AppEntry, spec *LitestreamAppSpec) error
	// StopLitestreamSidecar gently stops the app's replication sidecar:
	// SIGTERM with a grace period covering litestream's final shutdown sync.
	// A missing or already stopped sidecar is not an error.
	StopLitestreamSidecar(ctx context.Context, appId types.AppId) error
}

type NamespaceStats struct {
	Namespace string `json:"namespace"`
	Kind      string `json:"kind"` // system / apps
	Pods      int    `json:"pods"`
	Running   int    `json:"running"`
	Pending   int    `json:"pending"`
	Failed    int    `json:"failed"`
	Succeeded int    `json:"succeeded"`
	Ready     int    `json:"ready"`
}

type PodCondition struct {
	Type    string `json:"type"`
	Status  string `json:"status"`
	Reason  string `json:"reason"`
	Message string `json:"message"`
}

type PodContainerStatus struct {
	Name     string `json:"name"`
	State    string `json:"state"` // running / waiting / terminated
	Reason   string `json:"reason"`
	Message  string `json:"message"`
	Restarts int    `json:"restarts"`
	Ready    bool   `json:"ready"`
}

type PodEvent struct {
	Type     string `json:"type"` // Normal / Warning
	Reason   string `json:"reason"`
	Message  string `json:"message"`
	Count    int    `json:"count"`
	LastSeen string `json:"last_seen"`
}

type VersionReporter interface {
	CurrentVersionHash(ctx context.Context, name ContainerName) (string, error)
}

type VolumeInfo struct {
	IsSecret   bool
	VolumeName string
	SourcePath string
	TargetPath string
	ReadOnly   bool
	// Size requests a capacity for the backing volume where the manager
	// supports it (kubernetes PVC size). Empty means the manager default;
	// ignored for docker/podman named volumes, which are not sized.
	Size string
	// InitPerms marks a volume whose mount directory must be made writable
	// for the app image's (possibly non-root) user after creation (sqlite
	// binding volumes): a fresh named volume / PVC mount is root-owned.
	InitPerms bool
}

type VolumeInitializer interface {
	InitVolumePermissions(ctx context.Context, image ImageName, volumeName VolumeName, targetDir string) error
}

type VolumeName string

type WorkloadMount struct {
	Name      string
	MountPath string
	ReadOnly  bool
}

type WorkloadPod struct {
	Name       string
	AppId      string
	AppPath    string
	AppVersion string
	Image      string
	Phase      string // Running / Pending / Succeeded / Failed
	Ready      bool
	Restarts   int
	StartedAt  string
	CreatedAt  string
	Node       string
	PodIP      string
	Mounts     []WorkloadMount
}

type WorkloadPodStatus struct {
	Phase       string               `json:"phase"`
	Reason      string               `json:"reason"`
	Message     string               `json:"message"`
	Node        string               `json:"node"`
	Conditions  []PodCondition       `json:"conditions"`
	Containers  []PodContainerStatus `json:"containers"`
	Events      []PodEvent           `json:"events"`
	EventsError string               `json:"events_error"` // events are best-effort, RBAC may deny them
}