docker

type Backend interface {
	// Containers
	ListContainers(showAll bool) ([]Container, error)
	InspectContainer(id string) (*InspectResult, error)
	StartContainer(id string) error
	StopContainer(id string) error
	RestartContainer(id string) error
	RemoveContainer(id string, force bool) error
	KillContainer(id string, signal string) error
	// ContainerLogs streams log lines until stop is called or the container
	// stops producing. The caller MUST call stop when it abandons the channel,
	// otherwise the Follow connection and producer goroutine leak.
	ContainerLogs(id string, opts LogOptions) (lines <-chan string, stop func(), err error)
	ContainerStats(ids []string) (map[string]ContainerStats, error)
	ExecInteractive(containerID string, cmd []string) (ExecSession, error)
	RunContainer(opts RunOptions) error
	// RunInteractive starts a disposable interactive container from an image
	// (`docker run --rm -it` analogue); closing the session removes it.
	RunInteractive(opts ExecRunOptions) (ExecSession, error)
	// Container filesystem (`docker cp` / browse). ListPath lists a directory
	// inside the container; CopyFromContainer downloads a path into a local
	// directory; CopyToContainer uploads a local path into a container directory.
	ListPath(containerID, dir string) ([]FileEntry, error)
	CopyFromContainer(containerID, srcPath, destDir string) error
	CopyToContainer(containerID, localPath, destDir string) error
	// Images
	ListImages() ([]Image, error)
	InspectImage(id string) (*InspectResult, error)
	RemoveImage(id string, force bool) error
	// Networks
	ListNetworks() ([]Network, error)
	InspectNetwork(id string) (*InspectResult, error)
	RemoveNetwork(id string) error
	CreateNetwork(opts NetworkCreateOptions) error
	// Volumes
	ListVolumes() ([]Volume, error)
	InspectVolume(name string) (*InspectResult, error)
	RemoveVolume(name string) error
	CreateVolume(opts VolumeCreateOptions) error
	PruneVolumes() (int, error)
	// Extra image ops
	PullImage(ref string) error
	PruneImages() (int, error)
	TagImage(source, target string) error
	// PushImage / BuildImage stream daemon progress lines. The returned stop
	// aborts the operation and releases the request/connection; the caller MUST
	// call it when it abandons the channel, otherwise the producer leaks.
	PushImage(ref string, auth RegistryAuth) (lines <-chan string, stop func(), err error)
	BuildImage(contextDir, tag string) (lines <-chan string, stop func(), err error)
	ImageHistory(id string) (*InspectResult, error)
	// Docker Compose projects (discovered via container labels)
	ListComposeProjects() ([]ComposeProject, error)
	ListComposeContainers(project string) ([]Container, error)
	InspectComposeProject(project string) (*InspectResult, error)
	// ComposeLogs streams the aggregated project logs; same stop contract as
	// ContainerLogs.
	ComposeLogs(project string, opts LogOptions) (lines <-chan string, stop func(), err error)
	ComposeStart(project string) error
	ComposeStop(project string) error
	ComposeRestart(project string) error
	ComposePause(project string) error
	ComposeUnpause(project string) error
	ComposeRemove(project string) error
	// ComposeUp/Pull/Down, CreateComposeFile and RestoreComposeProject stream
	// progress lines from the compose engine. Each returns a stop the caller MUST
	// call when it abandons the channel, otherwise the SSH session/producer leak.
	ComposeUp(project string) (lines <-chan string, stop func(), err error)
	ComposePull(project string) (lines <-chan string, stop func(), err error)
	ComposeDown(project string) (lines <-chan string, stop func(), err error)
	ComposeConfig(project string) (string, error)
	ReadComposeFile(project string) (path, content string, err error)
	WriteComposeFile(project, content string) error
	CreateComposeFile(dir, content string) (lines <-chan string, stop func(), err error)
	BackupComposeProject(project string) (string, error)
	RestoreComposeProject(project, backupPath string) (lines <-chan string, stop func(), err error)
	// SupportsHostCompose reports whether the backend can run the compose
	// operations that need shell/filesystem access to the host —
	// up/down/pull/config/edit/create/backup/restore. These require an SSH
	// connection; a tcp:// connection returns false. Discovery and the
	// container-level lifecycle ops (start/stop/restart/…) work regardless.
	SupportsHostCompose() bool
	// System-wide operations
	// SystemDF reports the daemon's disk usage (`docker system df`).
	SystemDF() (*InspectResult, error)
	// SystemPrune removes stopped containers, unused networks, dangling images
	// and the build cache; it returns a human-readable summary.
	SystemPrune() (string, error)
	// Events returns a live stream of Docker daemon events as formatted strings.
	// stop ends the subscription and closes the channel; the caller MUST call it
	// when it abandons the stream (closing the view, refreshing).
	Events() (lines <-chan string, stop func(), err error)
	// Ping checks the connection to the daemon is alive (used by auto-reconnect).
	Ping() error
	// Runtime reports which container engine backs the connection (Docker vs
	// Podman), so the UI can label it and host-side compose ops pick the right
	// CLI verb. The result is probed once and cached.
	Runtime() Runtime
	// Info returns a one-shot daemon summary (container/image counts, version) —
	// the data behind the multi-host dashboard. Reachable is left to the caller.
	Info() (HostSummary, error)
	Close()
}

type ComposeProject struct {
	Project     string // com.docker.compose.project (e.g. "mcmc"); used for `-p`
	Name        string // display name of the deployment (working_dir basename)
	WorkingDir  string // identity: distinguishes deployments sharing a project
	ConfigFiles string
	Status      string // running | stopped | paused | partial | error
	Command     string
	Running     int
	Total       int
}

type Container struct {
	ID      string
	Name    string
	Image   string
	Status  string
	State   string
	Health  string // healthy | unhealthy | starting | "" (no healthcheck)
	Ports   string
	CPU     string
	Memory  string
	Created time.Time
	// Labels and Networks back the label:/network: filter predicates; they are
	// not shown in the table. Networks holds the attached network names.
	Labels   map[string]string
	Networks []string
}

type ContainerStats struct {
	ID         string
	CPUPerc    float64 // CPU usage as a percentage of total host capacity (matches `docker stats`)
	MemUsage   uint64  // memory usage in bytes, page cache excluded
	MemLimit   uint64  // memory limit in bytes
	MemPerc    float64 // MemUsage / MemLimit * 100
	NetRx      uint64  // total bytes received across all networks
	NetTx      uint64  // total bytes sent across all networks
	BlockRead  uint64  // total bytes read from block devices
	BlockWrite uint64  // total bytes written to block devices
}

type ExecRunOptions struct {
	Image   string
	Volumes []string
	Cmd     []string
}

type ExecSession interface {
	io.ReadWriteCloser
	// Resize sets the remote TTY window size (rows × cols, in cells).
	Resize(rows, cols int) error
}

type FakeBackend struct {
	Containers []Container
	Images     []Image
	Networks   []Network
	Volumes    []Volume
	Composes   []ComposeProject

	// ComposeFiles maps project name -> compose file content (for edit demo).
	ComposeFiles map[string]string

	// NoHostCompose simulates a tcp:// connection, where host-side compose
	// operations (up/down/pull/config/edit/create/backup/restore) are
	// unavailable. The default (false) mirrors an ssh:// connection so the demo
	// exercises every feature.
	NoHostCompose bool

	// LogLines is the canned log stream returned by ContainerLogs.
	LogLines []string

	// RuntimeKind simulates the container engine reported by Runtime(); the zero
	// value (RuntimeUnknown) is treated as Docker. Set RuntimePodman to exercise
	// the Podman-specific paths without a live host.
	RuntimeKind Runtime
}

type FileEntry struct {
	Name  string
	IsDir bool
}

type HostSummary struct {
	Host      string // saved-host URL the snapshot belongs to
	Reachable bool   // daemon answered Info within the budget
	Err       string // failure reason when unreachable

	Containers int    // total containers
	Running    int    // running containers
	Paused     int    // paused containers
	Stopped    int    // stopped containers
	Images     int    // images
	Version    string // daemon server version
	Name       string // daemon hostname
	NCPU       int    // logical CPUs
	MemTotal   int64  // total memory (bytes)
}

type Image struct {
	ID      string
	Tags    string
	Size    string
	Created time.Time
}

type InspectResult struct {
	Name    string
	RawYAML string
}

type LogOptions struct {
	Tail  int
	Since string
	Until string
}

type NamespacedBackend interface {
	// Namespaces lists the available namespaces.
	Namespaces() ([]string, error)
	// CurrentNamespace reports the active namespace.
	CurrentNamespace() string
	// SetNamespace switches the active namespace for subsequent operations.
	SetNamespace(name string)
}

type Network struct {
	ID     string
	Name   string
	Driver string
	Scope  string
	Subnet string
}

type NetworkCreateOptions struct {
	Name    string
	Driver  string
	Subnet  string
	Gateway string
}

type RegistryAuth struct {
	Registry string // server address, e.g. "myregistry:5000"; empty = default
	Username string
	Password string
}

type RunOptions struct {
	Image   string
	Name    string
	Ports   []string
	Env     []string
	Volumes []string
}

type Runtime string

type Volume struct {
	Name       string
	Driver     string
	Mountpoint string
	Created    string
}

type VolumeCreateOptions struct {
	Name   string
	Driver string
}