package execdriver import ( "errors" "io" "os/exec" "time" "github.com/opencontainers/runc/libcontainer" ) // Context is a generic key value pair that allows // arbitrary data to be sent type Context map[string]string // Define error messages var ( ErrNotRunning = errors.New("Container is not running") ErrWaitTimeoutReached = errors.New("Wait timeout reached") ErrDriverAlreadyRegistered = errors.New("A driver already registered this docker init function") ErrDriverNotFound = errors.New("The requested docker init has not been found") ) // DriverCallback defines a callback function which is used in "Run" and "Exec". // This allows work to be done in the parent process when the child is passing // through PreStart, Start and PostStop events. // Callbacks are provided a processConfig pointer and the pid of the child. // The channel will be used to notify the OOM events. type DriverCallback func(processConfig *ProcessConfig, pid int, chOOM <-chan struct{}) error // Hooks is a struct containing function pointers to callbacks // used by any execdriver implementation exploiting hooks capabilities type Hooks struct { // PreStart is called before container's CMD/ENTRYPOINT is executed PreStart []DriverCallback // Start is called after the container's process is full started Start DriverCallback // PostStop is called after the container process exits PostStop []DriverCallback } // Info is driver specific information based on // processes registered with the driver type Info interface { IsRunning() bool } // Terminal represents a pseudo TTY, it is for when // using a container interactively. type Terminal interface { io.Closer Resize(height, width int) error } // Driver is an interface for drivers to implement // including all basic functions a driver should have type Driver interface { // Run executes the process, blocks until the process exits and returns // the exit code. It's the last stage on Docker side for running a container. Run(c *Command, pipes *Pipes, hooks Hooks) (ExitStatus, error) // Exec executes the process in an existing container, blocks until the // process exits and returns the exit code. Exec(c *Command, processConfig *ProcessConfig, pipes *Pipes, hooks Hooks) (int, error) // Kill sends signals to process in container. Kill(c *Command, sig int) error // Pause pauses a container. Pause(c *Command) error // Unpause unpauses a container. Unpause(c *Command) error // Name returns the name of the driver. Name() string // Info returns the configuration stored in the driver struct, // "temporary" hack (until we move state from core to plugins). Info(id string) Info // GetPidsForContainer returns a list of pid for the processes running in a container. GetPidsForContainer(id string) ([]int, error) // Terminate kills a container by sending signal SIGKILL. Terminate(c *Command) error // Clean removes all traces of container exec. Clean(id string) error // Stats returns resource stats for a running container Stats(id string) (*ResourceStats, error) // Update updates resource configs for a container Update(c *Command) error // SupportsHooks refers to the driver capability to exploit pre/post hook functionality SupportsHooks() bool } // CommonResources contains the resource configs for a driver that are // common across platforms. type CommonResources struct { Memory int64 `json:"memory"` MemoryReservation int64 `json:"memory_reservation"` CPUShares int64 `json:"cpu_shares"` BlkioWeight uint16 `json:"blkio_weight"` } // ResourceStats contains information about resource usage by a container. type ResourceStats struct { *libcontainer.Stats Read time.Time `json:"read"` MemoryLimit int64 `json:"memory_limit"` SystemUsage uint64 `json:"system_usage"` } // CommonProcessConfig is the common platform agnostic part of the ProcessConfig // structure that describes a process that will be run inside a container. type CommonProcessConfig struct { exec.Cmd `json:"-"` Tty bool `json:"tty"` Entrypoint string `json:"entrypoint"` Arguments []string `json:"arguments"` Terminal Terminal `json:"-"` // standard or tty terminal } // CommonCommand is the common platform agnostic part of the Command structure // which wraps an os/exec.Cmd to add more metadata type CommonCommand struct { ContainerPid int `json:"container_pid"` // the pid for the process inside a container ID string `json:"id"` MountLabel string `json:"mount_label"` // TODO Windows. More involved, but can be factored out Mounts []Mount `json:"mounts"` Network *Network `json:"network"` ProcessConfig ProcessConfig `json:"process_config"` // Describes the init process of the container. ProcessLabel string `json:"process_label"` // TODO Windows. More involved, but can be factored out Resources *Resources `json:"resources"` Rootfs string `json:"rootfs"` // root fs of the container WorkingDir string `json:"working_dir"` TmpDir string `json:"tmpdir"` // Directory used to store docker tmpdirs. }