runtime

Documentation

Index

• Variables
• type Checkpoint
• type Console
• type Container
• type IO
  • func (i *IO) Close() error
• type Process
• type Runtime
• type Stat
• type State
• type Status

Variables

var (
	ErrNotChildProcess       = errors.New("containerd: not a child process for container")
	ErrInvalidContainerType  = errors.New("containerd: invalid container type for runtime")
	ErrCheckpointNotExists   = errors.New("containerd: checkpoint does not exist for container")
	ErrCheckpointExists      = errors.New("containerd: checkpoint already exists")
	ErrContainerExited       = errors.New("containerd: container has exited")
	ErrTerminalsNotSupported = errors.New("containerd: terminals are not supported for runtime")
)

Types

type Checkpoint

type Checkpoint struct {
	// Timestamp is the time that checkpoint happened
	Timestamp time.Time
	// Name is the name of the checkpoint
	Name string
	// Tcp checkpoints open tcp connections
	Tcp bool
	// UnixSockets persists unix sockets in the checkpoint
	UnixSockets bool
	// Shell persists tty sessions in the checkpoint
	Shell bool
	// Exit exits the container after the checkpoint is finished
	Exit bool
}

type Console

type Console interface {
	io.ReadWriter
	io.Closer
}

type Container

type Container interface {
	// ID returns the container ID
	ID() string
	// Start starts the init process of the container
	Start() error
	// Path returns the path to the bundle
	Path() string
	// Pid returns the container's init process id
	Pid() (int, error)
	// SetExited sets the exit status of the container after it's init dies
	SetExited(status int)
	// Delete deletes the container
	Delete() error
	// Processes returns all the containers processes that have been added
	Processes() ([]Process, error)
	// RemoveProcess removes a specific process for the container because it exited
	RemoveProcess(pid int) error
	// State returns the containers runtime state
	State() State
	// Resume resumes a paused container
	Resume() error
	// Pause pauses a running container
	Pause() error
	// Checkpoints returns all the checkpoints for a container
	Checkpoints() ([]Checkpoint, error)
	// Checkpoint creates a new checkpoint
	Checkpoint(Checkpoint) error
	// DeleteCheckpoint deletes the checkpoint for the provided name
	DeleteCheckpoint(name string) error
	// Restore restores the container to that of the checkpoint provided by name
	Restore(name string) error
	// Stats returns realtime container stats and resource information
	Stats() (*Stat, error)
	// OOM signals the channel if the container received an OOM notification
	OOM() (<-chan struct{}, error)
}

type IO

type IO struct {
	Stdin  io.WriteCloser
	Stdout io.ReadCloser
	Stderr io.ReadCloser
}

func (*IO) Close

func (i *IO) Close() error

type Process

type Process interface {
	io.Closer
	Pid() (int, error)
	Spec() specs.Process
	Signal(os.Signal) error
}

type Runtime

type Runtime interface {
	// Type of the runtime
	Type() string
	// Create creates a new container initialized but without it starting it
	Create(id, bundlePath, consolePath string) (Container, *IO, error)
	// StartProcess adds a new process to the container
	StartProcess(c Container, p specs.Process, consolePath string) (Process, *IO, error)
}

Runtime handles containers, containers handle their own actions

type Stat

type Stat struct {
	// Timestamp is the time that the statistics where collected
	Timestamp time.Time
	// Data is the raw stats
	// TODO: it is currently an interface because we don't know what type of exec drivers
	// we will have or what the structure should look like at the moment os the containers
	// can return what they want and we could marshal to json or whatever.
	Data interface{}
}

type State

type State struct {
	Status Status
}

type Status

type Status string

const (
	Paused  Status = "paused"
	Running Status = "running"
)