container

type Container struct {
	// Config defines the properties of the container to manage.
	Config types.ContainerConfig `json:"config"`
	// Status stores container status. Setting status allows to manage existing containers
	// and e.g. removing them.
	Status *types.ContainerStatus `json:"status,omitempty"`
	// Runtime stores configuration for various container runtimes.
	Runtime RuntimeConfig `json:"runtime,omitempty"`
}

type Containers struct {
	// PreviousState stores previous state of the containers, which should be obtained and persisted
	// after containers modifications.
	PreviousState ContainersState `json:"previousState,omitempty"`

	// DesiredState is a user-defined desired containers configuration.
	DesiredState ContainersState `json:"desiredState,omitempty"`
}

type ContainersInterface interface {
	// CheckCurrentState iterates over containers defined in the state, checks if they exist, are
	// running etc and writes to containers current state. This allows then to compare current state
	// of the containers with desired state, using Containers() method, to check if there are any
	// pending changes to cluster configuration.
	//
	// Calling CheckCurrentState is required before calling Deploy(), to ensure, that Deploy() executes
	// correct actions.
	CheckCurrentState() error

	// Deploy creates configured containers.
	//
	// CheckCurrentState() must be called before calling Deploy(), otherwise error will be returned.
	Deploy() error

	// StateToYaml converts resource's containers state into YAML format and returns it to the user,
	// so it can be persisted, e.g. to the file.
	StateToYaml() ([]byte, error)

	// ToExported converts unexported containers struct into exported one, which can be then
	// serialized and persisted.
	ToExported() *Containers

	// DesiredState returns desired state of configured containers.
	//
	// Desired state differs from
	// exported or user-defined desired state, as it will have container IDs filled from the
	// previous state.
	//
	// All returned containers will also have status set to running, as this is always the desired
	// state of the container.
	//
	// Having those fields modified allows to minimize the difference when comparing previous state
	// and desired state.
	DesiredState() ContainersState
}

type ContainersState map[string]*HostConfiguredContainer

type ContainersStateInterface interface {
	// CheckState updates the state of all previously configured containers
	// and their configuration on the host
	CheckState() error

	// RemoveContainer removes the container by ID.
	RemoveContainer(containerName string) error

	// CreateAndStart is a helper, which creates and spawns given container.
	CreateAndStart(containerName string) error

	// Export converts unexported containersState to exported type, so it can be serialized and stored.
	Export() ContainersState
}

type Hook func() error

type Hooks struct {
	// PostStart hook will be executed after container is started.
	PostStart *Hook
}

type HostConfiguredContainer struct {
	// Container stores container configuration.
	Container Container `json:"container"`

	// Host defines how to communicate with configured container runtime.
	Host host.Host `json:"host"`

	// ConfigFiles stores a list of configuration files, which should be created
	// on the host, where the container will be created.
	ConfigFiles map[string]string `json:"configFiles,omitempty"`

	// Hooks holds all hooks, which will be triggered after certain container actions.
	//
	// Due to it's nature, it can only be set programmatically.
	Hooks *Hooks `json:"-"`
}

type HostConfiguredContainerInterface interface {
	// ConfigurationStatus updates configuration file struct with current state on the target host.
	ConfigurationStatus() error

	// Configure copies specified configuration files on target host.
	//
	// It uses host definition to connect to container runtime, which is then used
	// to create temporary container used for copying files and also bypassing privileges requirements.
	//
	// With Kubelet runtime, 'tar' binary is required on the container to be able to write and read the configurations.
	// By default, the image which will be deployed will be used for copying the configuration as well, to avoid pulling
	// multiple images, which will save disk space and time. If it happens that this image does not have 'tar' binary,
	// user can override ConfigImage field in the configuration, to specify different image which should be
	// pulled and used for configuration management.
	Configure(paths []string) error

	// Create creates new container on target host. If container already exists,
	// error should be returned.
	Create() error

	// Status updates container status.
	Status() error

	// Start starts created container. Container must be created before it's started.
	Start() error

	// Stop stops the container.
	Stop() error

	// Delete removes the container from the host. Host volumes and configuration files
	// won't be removed.
	Delete() error
}

type InstanceInterface interface {
	// Status returns container status read from the configured container runtime.
	Status() (types.ContainerStatus, error)

	// Read reads content of the given file paths in the container.
	Read(srcPath []string) ([]*types.File, error)

	// Copy copies file into the container.
	Copy(files []*types.File) error

	// Stat checks if given files exist on the container and returns map of
	// file modes. If key is missing, it means file does not exist in the container.
	Stat(paths []string) (map[string]os.FileMode, error)

	// Start starts the container.
	Start() error

	// Stop stops the container.
	Stop() error

	// Delete deletes the container.
	Delete() error
}

type Interface interface {
	// Create creates the container.
	Create() (InstanceInterface, error)

	// From status restores container instance from given status.
	FromStatus() (InstanceInterface, error)

	// UpdateStatus updates container status.
	UpdateStatus() error

	// Start starts the container.
	Start() error

	// Stop stops the container.
	Stop() error

	// Delete removes the container.
	Delete() error

	// Status returns container status.
	Status() *types.ContainerStatus

	// Config allows reading container configuration.
	Config() types.ContainerConfig

	// RuntimeConfig allows reading container runtime configuration.
	RuntimeConfig() runtime.Config

	// Runtime allows getting container runtime.
	Runtime() runtime.Runtime

	// SetRuntime allows overriding used container runtime.
	SetRuntime(runtime.Runtime)

	// SetStatus allows overriding container status.
	SetStatus(types.ContainerStatus)
}

type ResourceInstance interface {
	ToHostConfiguredContainer() (*HostConfiguredContainer, error)
}

type RuntimeConfig struct {
	// Docker stores Docker runtime configuration.
	Docker *docker.Config `json:"docker,omitempty"`
}