View Source
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/?"


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


This section is empty.


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 *types.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 *types.Any
    	// TaskOptions received for the task
    	TaskOptions *types.Any
    	// Runtime to use
    	Runtime 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 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)
            	// Add adds a task into runtime.
            	Add(ctx context.Context, task Task) error
            	// Delete remove a task.
            	Delete(ctx context.Context, taskID string)

              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)
              	// Delete deletes the process
              	Delete(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
                      	// StoppedStatus when a process has stopped
                      	// DeletedStatus when a process has been deleted
                      	// PausedStatus when a process is paused
                      	// PausingStatus when a process is currently pausing

                      type Task

                      type Task interface {
                      	// PID of the process
                      	PID() uint32
                      	// 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) (Process, 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) (Process, 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

                                        type TaskMonitor

                                        type TaskMonitor interface {
                                        	// Monitor adds the provided container to the monitor
                                        	Monitor(Task) error
                                        	// Stop stops and removes the provided container from the monitor
                                        	Stop(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


                                              Path Synopsis
                                              Package restart enables containers to have labels added and monitored to keep the container's task running if it is killed.
                                              Package restart enables containers to have labels added and monitored to keep the container's task running if it is killed.