libcontainerd

Documentation

Index

• Constants
• type Backend
• type Client
• type CommonStateInfo
• type CreateOption
  • func WithRestartManager(rm restartmanager.RestartManager) CreateOption
• type IOPipe
• type Process
• type Remote
  • func New(stateDir string, options ...RemoteOption) (_ Remote, err error)
• type RemoteOption
  • func WithDebugLog(debug bool) RemoteOption
  • func WithRemoteAddr(addr string) RemoteOption
  • func WithRuntimeArgs(args []string) RemoteOption
  • func WithStartDaemon(start bool) RemoteOption
• type Resources
• type Spec
• type StateInfo
• type Stats
• type Summary
• type User

Constants

const (
	StateStart        = "start-container"
	StatePause        = "pause"
	StateResume       = "resume"
	StateExit         = "exit"
	StateRestart      = "restart"
	StateRestore      = "restore"
	StateStartProcess = "start-process"
	StateExitProcess  = "exit-process"
	StateOOM          = "oom" // fake state

)

State constants used in state change reporting.

const (
	// InitFriendlyName is the name given in the lookup map of processes
	// for the first process started in a container.
	InitFriendlyName = "init"
)

Types

type Backend

type Backend interface {
	StateChanged(containerID string, state StateInfo) error
	AttachStreams(processFriendlyName string, io IOPipe) error
}

Backend defines callbacks that the client of the library needs to implement.

type Client

type Client interface {
	Create(containerID string, spec Spec, options ...CreateOption) error
	Signal(containerID string, sig int) error
	AddProcess(containerID, processFriendlyName string, process Process) error
	Resize(containerID, processFriendlyName string, width, height int) error
	Pause(containerID string) error
	Resume(containerID string) error
	Restore(containerID string, options ...CreateOption) error
	Stats(containerID string) (*Stats, error)
	GetPidsForContainer(containerID string) ([]int, error)
	Summary(containerID string) ([]Summary, error)
	UpdateResources(containerID string, resources Resources) error
}

Client provides access to containerd features.

type CommonStateInfo

type CommonStateInfo struct {
	State     string
	Pid       uint32
	ExitCode  uint32
	ProcessID string
}

CommonStateInfo contains the state info common to all platforms.

type CreateOption

type CreateOption interface {
	Apply(interface{}) error
}

CreateOption allows to configure parameters of container creation.

func WithRestartManager

func WithRestartManager(rm restartmanager.RestartManager) CreateOption

WithRestartManager sets the restartmanager to be used with the container.

type IOPipe

type IOPipe struct {
	Stdin    io.WriteCloser
	Stdout   io.Reader
	Stderr   io.Reader
	Terminal bool // Whether stderr is connected on Windows
}

IOPipe contains the stdio streams.

type Process

type Process struct {
	// Terminal creates an interactive terminal for the container.
	Terminal bool `json:"terminal"`
	// User specifies user information for the process.
	User *User `json:"user"`
	// Args specifies the binary and arguments for the application to execute.
	Args []string `json:"args"`
	// Env populates the process environment for the process.
	Env []string `json:"env,omitempty"`
	// Cwd is the current working directory for the process and must be
	// relative to the container's root.
	Cwd *string `json:"cwd"`
	// Capabilities are linux capabilities that are kept for the container.
	Capabilities []string `json:"capabilities,omitempty"`
	// Rlimits specifies rlimit options to apply to the process.
	Rlimits []specs.Rlimit `json:"rlimits,omitempty"`
	// ApparmorProfile specified the apparmor profile for the container.
	ApparmorProfile *string `json:"apparmorProfile,omitempty"`
	// SelinuxProcessLabel specifies the selinux context that the container process is run as.
	SelinuxLabel *string `json:"selinuxLabel,omitempty"`
}

Process contains information to start a specific application inside the container.

type Remote

type Remote interface {
	// Client returns a new Client instance connected with given Backend.
	Client(Backend) (Client, error)
	// Cleanup stops containerd if it was started by libcontainerd.
	// Note this is not used on Windows as there is no remote containerd.
	Cleanup()
}

Remote on Linux defines the accesspoint to the containerd grpc API. Remote on Windows is largely an unimplemented interface as there is no remote containerd.

func New

func New(stateDir string, options ...RemoteOption) (_ Remote, err error)

New creates a fresh instance of libcontainerd remote.

type RemoteOption

type RemoteOption interface {
	Apply(Remote) error
}

RemoteOption allows to configure parameters of remotes. This is unused on Windows.

func WithDebugLog

func WithDebugLog(debug bool) RemoteOption

WithDebugLog defines if containerd debug logs will be enabled for daemon.

func WithRemoteAddr

func WithRemoteAddr(addr string) RemoteOption

WithRemoteAddr sets the external containerd socket to connect to.

func WithRuntimeArgs

func WithRuntimeArgs(args []string) RemoteOption

WithRuntimeArgs sets the list of runtime args passed to containerd

func WithStartDaemon

func WithStartDaemon(start bool) RemoteOption

WithStartDaemon defines if libcontainerd should also run containerd daemon.

type Resources

type Resources containerd.UpdateResource

Resources defines updatable container resource values.

type Spec

type Spec specs.Spec

Spec is the base configuration for the container. It specifies platform independent configuration. This information must be included when the bundle is packaged for distribution.

type StateInfo

type StateInfo struct {
	CommonStateInfo

	// Platform specific StateInfo
	OOMKilled bool
}

StateInfo contains description about the new state container has entered.

type Stats

type Stats containerd.StatsResponse

Stats contains a stats properties from containerd.

type Summary

type Summary struct{}

Summary container a container summary from containerd

type User

type User specs.User

User specifies linux specific user and group information for the container's main process.