Documentation

Index

Constants

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

Variables

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

Functions

This section is empty.

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 *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, id string, opts CreateOpts) (Task, error)
            	// Get returns a task.
            	Get(context.Context, string) (Task, error)
            	// Tasks returns all the current tasks for the runtime.
            	// Any container runs at most one task at a time.
            	Tasks(context.Context, bool) ([]Task, error)
            	// Add adds a task into runtime.
            	Add(context.Context, Task) error
            	// Delete remove a task.
            	Delete(context.Context, 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(context.Context) (State, error)
              	// Kill signals a container
              	Kill(context.Context, uint32, bool) error
              	// Pty resizes the processes pty/console
              	ResizePty(context.Context, ConsoleSize) error
              	// CloseStdin closes the processes stdin
              	CloseIO(context.Context) error
              	// Start the container's user defined process
              	Start(context.Context) error
              	// Wait for the process to exit
              	Wait(context.Context) (*Exit, error)
              	// Delete deletes the process
              	Delete(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() uint32
                      	// Namespace that the task exists in
                      	Namespace() string
                      	// Pause pauses the container process
                      	Pause(context.Context) error
                      	// Resume unpauses the container process
                      	Resume(context.Context) error
                      	// Exec adds a process into the container
                      	Exec(context.Context, string, ExecOpts) (Process, error)
                      	// Pids returns all pids
                      	Pids(context.Context) ([]ProcessInfo, error)
                      	// Checkpoint checkpoints a container to an image with live system data
                      	Checkpoint(context.Context, string, *types.Any) error
                      	// Update sets the provided resources to a running task
                      	Update(context.Context, *types.Any) error
                      	// Process returns a process within the task for the provided id
                      	Process(context.Context, string) (Process, error)
                      	// Stats returns runtime specific metrics for a task
                      	Stats(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

                                              Directories

                                              Path Synopsis
                                              linux
                                              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.
                                              v1
                                              v2