mirror of
https://github.com/moby/moby.git
synced 2022-11-09 12:21:53 -05:00
133 lines
4.8 KiB
Go
133 lines
4.8 KiB
Go
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
|
|
}
|
|
|
|
// 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
|
|
|
|
// 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.
|
|
}
|