package linux import ( "github.com/containerd/containerd" "github.com/containerd/containerd/api/services/shim" "github.com/containerd/containerd/api/types/container" protobuf "github.com/gogo/protobuf/types" specs "github.com/opencontainers/runtime-spec/specs-go" "golang.org/x/net/context" ) type State struct { pid uint32 status containerd.Status } func (s State) Pid() uint32 { return s.pid } func (s State) Status() containerd.Status { return s.status } type Container struct { id string shim shim.ShimClient } func (c *Container) Info() containerd.ContainerInfo { return containerd.ContainerInfo{ ID: c.id, Runtime: runtimeName, } } func (c *Container) Start(ctx context.Context) error { _, err := c.shim.Start(ctx, &shim.StartRequest{}) return err } func (c *Container) State(ctx context.Context) (containerd.State, error) { response, err := c.shim.State(ctx, &shim.StateRequest{}) if err != nil { return nil, err } var status containerd.Status switch response.Status { case container.Status_CREATED: status = containerd.CreatedStatus case container.Status_RUNNING: status = containerd.RunningStatus case container.Status_STOPPED: status = containerd.StoppedStatus case container.Status_PAUSED: status = containerd.PausedStatus // TODO: containerd.DeletedStatus } return &State{ pid: response.Pid, status: status, }, nil } func (c *Container) Pause(ctx context.Context) error { _, err := c.shim.Pause(ctx, &shim.PauseRequest{}) return err } func (c *Container) Resume(ctx context.Context) error { _, err := c.shim.Resume(ctx, &shim.ResumeRequest{}) return err } func (c *Container) Kill(ctx context.Context, signal uint32, all bool) error { _, err := c.shim.Kill(ctx, &shim.KillRequest{ Signal: signal, All: all, }) return err } func (c *Container) Exec(ctx context.Context, opts containerd.ExecOpts) (containerd.Process, error) { request := &shim.ExecRequest{ Stdin: opts.IO.Stdin, Stdout: opts.IO.Stdout, Stderr: opts.IO.Stderr, Terminal: opts.IO.Terminal, Spec: &protobuf.Any{ TypeUrl: specs.Version, Value: opts.Spec, }, } resp, err := c.shim.Exec(ctx, request) if err != nil { return nil, err } return &Process{ pid: int(resp.Pid), c: c, }, nil } type Process struct { pid int c *Container } func (p *Process) Kill(ctx context.Context, signal uint32, _ bool) error { _, err := p.c.shim.Kill(ctx, &shim.KillRequest{ Signal: signal, Pid: uint32(p.pid), }) return err } func (p *Process) State(ctx context.Context) (containerd.State, error) { // use the container status for the status of the process state, err := p.c.State(ctx) if err != nil { return nil, err } state.(*State).pid = uint32(p.pid) return state, nil }