execdriver

Documentation

Index

• Variables
• type Command
• type CommonCommand
• type CommonProcessConfig
• type CommonResources
• type Context
• type Driver
• type DriverCallback
• type ExitStatus
• type Hooks
• type Info
• type Mount
• type Network
• type NetworkInterface
• type Pipes
  • func NewPipes(stdin io.ReadCloser, stdout, stderr io.Writer, useStdin bool) *Pipes
• type ProcessConfig
• type ResourceStats
• type Resources
• type StdConsole
  • func NewStdConsole(processConfig *ProcessConfig, pipes *Pipes) (*StdConsole, error)
  • func (s *StdConsole) AttachPipes(command *exec.Cmd, pipes *Pipes) error
  • func (s *StdConsole) Close() error
  • func (s *StdConsole) Resize(h, w int) error
• type Terminal

Variables

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")
)

Define error messages

Types

type Command

type Command struct {
	CommonCommand

	FirstStart  bool     `json:"first_start"`  // Optimisation for first boot of Windows
	Hostname    string   `json:"hostname"`     // Windows sets the hostname in the execdriver
	LayerFolder string   `json:"layer_folder"` // Layer folder for a command
	LayerPaths  []string `json:"layer_paths"`  // Layer paths for a command
	Isolation   string   `json:"isolation"`    // Isolation level for the container
	ArgsEscaped bool     `json:"args_escaped"` // True if args are already escaped
	HvPartition bool     `json:"hv_partition"` // True if it's an hypervisor partition
}

Command wraps an os/exec.Cmd to add more metadata

type CommonCommand

type CommonCommand struct {
	ContainerPid  int           `json:"container_pid"` // the pid for the process inside a container
	ID            string        `json:"id"`
	InitPath      string        `json:"initpath"`    // dockerinit
	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.
}

CommonCommand is the common platform agnostic part of the Command structure which wraps an os/exec.Cmd to add more metadata

type CommonProcessConfig

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
}

CommonProcessConfig is the common platform agnostic part of the ProcessConfig structure that describes a process that will be run inside a container.

type CommonResources

type CommonResources struct {
	Memory            int64  `json:"memory"`
	MemoryReservation int64  `json:"memory_reservation"`
	CPUShares         int64  `json:"cpu_shares"`
	BlkioWeight       uint16 `json:"blkio_weight"`
}

CommonResources contains the resource configs for a driver that are common across platforms.

type Context

type Context map[string]string

Context is a generic key value pair that allows arbitrary data to be sent

type Driver

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
}

Driver is an interface for drivers to implement including all basic functions a driver should have

type DriverCallback

type DriverCallback func(processConfig *ProcessConfig, pid int, chOOM <-chan struct{}) error

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 ExitStatus

type ExitStatus struct {
	// The exit code with which the container exited.
	ExitCode int
}

ExitStatus provides exit reasons for a container.

type Hooks

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
}

Hooks is a struct containing function pointers to callbacks used by any execdriver implementation exploiting hooks capabilities

type Info

type Info interface {
	IsRunning() bool
}

Info is driver specific information based on processes registered with the driver

type Mount

type Mount struct {
	Source      string `json:"source"`
	Destination string `json:"destination"`
	Writable    bool   `json:"writable"`
}

Mount contains information for a mount operation.

type Network

type Network struct {
	Interface   *NetworkInterface `json:"interface"`
	ContainerID string            `json:"container_id"` // id of the container to join network.
}

Network settings of the container

type NetworkInterface

type NetworkInterface struct {
	MacAddress string `json:"mac"`
	Bridge     string `json:"bridge"`
	IPAddress  string `json:"ip"`

	// PortBindings is the port mapping between the exposed port in the
	// container and the port on the host.
	PortBindings nat.PortMap `json:"port_bindings"`
}

NetworkInterface contains network configs for a driver

type Pipes

type Pipes struct {
	Stdin          io.ReadCloser
	Stdout, Stderr io.Writer
}

Pipes is a wrapper around a container's output for stdin, stdout, stderr

func NewPipes

func NewPipes(stdin io.ReadCloser, stdout, stderr io.Writer, useStdin bool) *Pipes

NewPipes returns a wrapper around a container's output

type ProcessConfig

type ProcessConfig struct {
	CommonProcessConfig

	// Fields below here are platform specific
	ConsoleSize [2]int `json:"-"` // h,w of initial console size
}

ProcessConfig is the platform specific structure that describes a process that will be run inside a container.

type ResourceStats

type ResourceStats struct {
	*libcontainer.Stats
	Read        time.Time `json:"read"`
	MemoryLimit int64     `json:"memory_limit"`
	SystemUsage uint64    `json:"system_usage"`
}

ResourceStats contains information about resource usage by a container.

type Resources

type Resources struct {
	CommonResources
}

Resources contains all resource configs for a driver. Currently these are all for cgroup configs.

type StdConsole

type StdConsole struct {
	// Closers holds io.Closer references for closing at terminal close time
	Closers []io.Closer
}

StdConsole defines standard console operations for execdriver

func NewStdConsole

func NewStdConsole(processConfig *ProcessConfig, pipes *Pipes) (*StdConsole, error)

NewStdConsole returns a new StdConsole struct

func (*StdConsole) AttachPipes

func (s *StdConsole) AttachPipes(command *exec.Cmd, pipes *Pipes) error

AttachPipes attaches given pipes to exec.Cmd

func (*StdConsole) Close

func (s *StdConsole) Close() error

Close implements Close method of Terminal interface

func (*StdConsole) Resize

func (s *StdConsole) Resize(h, w int) error

Resize implements Resize method of Terminal interface

type Terminal

type Terminal interface {
	io.Closer
	Resize(height, width int) error
}

Terminal represents a pseudo TTY, it is for when using a container interactively.