runtime

Documentation

Index

• Constants
• Variables
• type ConsoleSize
• type CreateOpts
• type ExecOpts
• type ExecProcess
• type Exit
• type IO
• type PlatformRuntime
• type Process
• type ProcessInfo
• type State
• type Status
• type Task
• type TaskInfo
• type TaskList
  • func NewTaskList() *TaskList
  • func (l *TaskList) Add(ctx context.Context, t Task) error
  • func (l *TaskList) AddWithNamespace(namespace string, t Task) error
  • func (l *TaskList) Delete(ctx context.Context, id string)
  • func (l *TaskList) Get(ctx context.Context, id string) (Task, error)
  • func (l *TaskList) GetAll(ctx context.Context, noNS bool) ([]Task, error)
  • func (l *TaskList) IsEmpty() bool
• type TaskMonitor
  • func NewMultiTaskMonitor(monitors ...TaskMonitor) TaskMonitor
  • func NewNoopMonitor() TaskMonitor

Constants

const (
	// TaskCreateEventTopic for task create
	TaskCreateEventTopic = "/tasks/create"
	// TaskStartEventTopic for task start
	TaskStartEventTopic = "/tasks/start"
	// TaskOOMEventTopic for task oom
	TaskOOMEventTopic = "/tasks/oom"
	// TaskExitEventTopic for task exit
	TaskExitEventTopic = "/tasks/exit"
	// TaskDeleteEventTopic for task delete
	TaskDeleteEventTopic = "/tasks/delete"
	// TaskExecAddedEventTopic for task exec create
	TaskExecAddedEventTopic = "/tasks/exec-added"
	// TaskExecStartedEventTopic for task exec start
	TaskExecStartedEventTopic = "/tasks/exec-started"
	// TaskPausedEventTopic for task pause
	TaskPausedEventTopic = "/tasks/paused"
	// TaskResumedEventTopic for task resume
	TaskResumedEventTopic = "/tasks/resumed"
	// TaskCheckpointedEventTopic for task checkpoint
	TaskCheckpointedEventTopic = "/tasks/checkpointed"
	// TaskUnknownTopic for unknown task events
	TaskUnknownTopic = "/tasks/?"
)

Variables

var (
	// ErrTaskNotExists is returned when a task does not exist
	ErrTaskNotExists = errors.New("task does not exist")
	// ErrTaskAlreadyExists is returned when a task already exists
	ErrTaskAlreadyExists = errors.New("task already exists")
)

Types

type ConsoleSize

type ConsoleSize struct {
	Width  uint32
	Height uint32
}

ConsoleSize of a pty or windows terminal

type CreateOpts

type CreateOpts struct {
	// Spec is the OCI runtime spec
	Spec typeurl.Any
	// Rootfs mounts to perform to gain access to the container's filesystem
	Rootfs []mount.Mount
	// IO for the container's main process
	IO IO
	// Checkpoint digest to restore container state
	Checkpoint string
	// RuntimeOptions for the runtime
	RuntimeOptions typeurl.Any
	// TaskOptions received for the task
	TaskOptions typeurl.Any
	// Runtime name to use (e.g. `io.containerd.NAME.VERSION`).
	// As an alternative full abs path to binary may be specified instead.
	Runtime string
	// SandboxID is an optional ID of sandbox this container belongs to
	SandboxID string
}

CreateOpts contains task creation data

type ExecOpts

type ExecOpts struct {
	Spec *types.Any
	IO   IO
}

ExecOpts provides additional options for additional processes running in a task

type ExecProcess

type ExecProcess interface {
	Process

	// Delete deletes the process
	Delete(ctx context.Context) (*Exit, error)
}

ExecProcess is a process spawned in container via Task.Exec call. The only difference from a regular `Process` is that exec process can delete self, while task process requires slightly more complex logic and needs to be deleted through the task manager.

type Exit

type Exit struct {
	Pid       uint32
	Status    uint32
	Timestamp time.Time
}

Exit information for a process

type IO

type IO struct {
	Stdin    string
	Stdout   string
	Stderr   string
	Terminal bool
}

IO holds process IO information

type PlatformRuntime

type PlatformRuntime interface {
	// ID of the runtime
	ID() string
	// Create creates a task with the provided id and options.
	Create(ctx context.Context, taskID string, opts CreateOpts) (Task, error)
	// Get returns a task.
	Get(ctx context.Context, taskID string) (Task, error)
	// Tasks returns all the current tasks for the runtime.
	// Any container runs at most one task at a time.
	Tasks(ctx context.Context, all bool) ([]Task, error)
	// Delete remove a task.
	Delete(ctx context.Context, taskID string) (*Exit, error)
}

PlatformRuntime is responsible for the creation and management of tasks and processes for a platform.

type Process

type Process interface {
	// ID of the process
	ID() string
	// State returns the process state
	State(ctx context.Context) (State, error)
	// Kill signals a container
	Kill(ctx context.Context, signal uint32, all bool) error
	// ResizePty resizes the processes pty/console
	ResizePty(ctx context.Context, size ConsoleSize) error
	// CloseIO closes the processes IO
	CloseIO(ctx context.Context) error
	// Start the container's user defined process
	Start(ctx context.Context) error
	// Wait for the process to exit
	Wait(ctx context.Context) (*Exit, error)
}

Process is a runtime object for an executing process inside a container

type ProcessInfo

type ProcessInfo struct {
	// Pid is the process ID
	Pid uint32
	// Info includes additional process information
	// Info varies by platform
	Info interface{}
}

ProcessInfo holds platform specific process information

type State

type State struct {
	// Status is the current status of the container
	Status Status
	// Pid is the main process id for the container
	Pid uint32
	// ExitStatus of the process
	// Only valid if the Status is Stopped
	ExitStatus uint32
	// ExitedAt is the time at which the process exited
	// Only valid if the Status is Stopped
	ExitedAt time.Time
	Stdin    string
	Stdout   string
	Stderr   string
	Terminal bool
}

State information for a process

type Status

type Status int

Status is the runtime status of a task and/or process

const (
	// CreatedStatus when a process has been created
	CreatedStatus Status = iota + 1
	// RunningStatus when a process is running
	RunningStatus
	// StoppedStatus when a process has stopped
	StoppedStatus
	// DeletedStatus when a process has been deleted
	DeletedStatus
	// PausedStatus when a process is paused
	PausedStatus
	// PausingStatus when a process is currently pausing
	PausingStatus
)

type Task

type Task interface {
	Process

	// PID of the process
	PID(ctx context.Context) (uint32, error)
	// Namespace that the task exists in
	Namespace() string
	// Pause pauses the container process
	Pause(ctx context.Context) error
	// Resume unpauses the container process
	Resume(ctx context.Context) error
	// Exec adds a process into the container
	Exec(ctx context.Context, id string, opts ExecOpts) (ExecProcess, error)
	// Pids returns all pids
	Pids(ctx context.Context) ([]ProcessInfo, error)
	// Checkpoint checkpoints a container to an image with live system data
	Checkpoint(ctx context.Context, path string, opts *types.Any) error
	// Update sets the provided resources to a running task
	Update(ctx context.Context, resources *types.Any, annotations map[string]string) error
	// Process returns a process within the task for the provided id
	Process(ctx context.Context, id string) (ExecProcess, error)
	// Stats returns runtime specific metrics for a task
	Stats(ctx context.Context) (*types.Any, error)
}

Task is the runtime object for an executing container

type TaskInfo

type TaskInfo struct {
	ID        string
	Runtime   string
	Spec      []byte
	Namespace string
}

TaskInfo provides task specific information

type TaskList

type TaskList struct {
	// contains filtered or unexported fields
}

TaskList holds and provides locking around tasks

func NewTaskList

func NewTaskList() *TaskList

NewTaskList returns a new TaskList

func (*TaskList) Add

func (l *TaskList) Add(ctx context.Context, t Task) error

Add a task

func (*TaskList) AddWithNamespace

func (l *TaskList) AddWithNamespace(namespace string, t Task) error

AddWithNamespace adds a task with the provided namespace

func (*TaskList) Delete

func (l *TaskList) Delete(ctx context.Context, id string)

Delete a task

func (*TaskList) Get

func (l *TaskList) Get(ctx context.Context, id string) (Task, error)

Get a task

func (*TaskList) GetAll

func (l *TaskList) GetAll(ctx context.Context, noNS bool) ([]Task, error)

GetAll tasks under a namespace

func (*TaskList) IsEmpty

func (l *TaskList) IsEmpty() bool

type TaskMonitor

type TaskMonitor interface {
	// Monitor adds the provided container to the monitor.
	// Labels are optional (can be nil) key value pairs to be added to the metrics namespace.
	Monitor(task Task, labels map[string]string) error
	// Stop stops and removes the provided container from the monitor
	Stop(task Task) error
}

TaskMonitor provides an interface for monitoring of containers within containerd

func NewMultiTaskMonitor

func NewMultiTaskMonitor(monitors ...TaskMonitor) TaskMonitor

NewMultiTaskMonitor returns a new TaskMonitor broadcasting to the provided monitors

func NewNoopMonitor

func NewNoopMonitor() TaskMonitor

NewNoopMonitor is a task monitor that does nothing