Move shim protos into linux pkg

This moves the shim's API and protos out of the containerd services
package and into the linux runtime package. This is because the shim is
an implementation detail of the linux runtime that we have and it is not
a containerd user facing api.

Signed-off-by: Michael Crosby <crosbymichael@gmail.com>

linux/shim/client.go

@@ -1,150 +1,181 @@
-// +build !windows
+// +build linux
 
 package shim
 
 import (
-	"path/filepath"
+	"context"
+	"fmt"
+	"io"
+	"net"
+	"os"
+	"os/exec"
+	"strings"
 	"syscall"
+	"time"
 
-	shimapi "github.com/containerd/containerd/api/services/shim/v1"
-	"github.com/containerd/containerd/api/types/task"
-	runc "github.com/containerd/go-runc"
-	google_protobuf "github.com/golang/protobuf/ptypes/empty"
-	"golang.org/x/net/context"
 	"golang.org/x/sys/unix"
+
+	"github.com/Sirupsen/logrus"
+	"github.com/pkg/errors"
+
+	shim "github.com/containerd/containerd/linux/shim/v1"
+	"github.com/containerd/containerd/log"
+	"github.com/containerd/containerd/reaper"
+	"github.com/containerd/containerd/sys"
 	"google.golang.org/grpc"
-	"google.golang.org/grpc/metadata"
 )
 
-func Client(path, namespace string) (shimapi.ShimClient, error) {
-	pid, err := runc.ReadPidFile(filepath.Join(path, "init.pid"))
+type ClientOpt func(context.Context, Config) (shim.ShimClient, io.Closer, error)
+
+// WithStart executes a new shim process
+func WithStart(binary string) ClientOpt {
+	return func(ctx context.Context, config Config) (shim.ShimClient, io.Closer, error) {
+		socket, err := newSocket(config)
+		if err != nil {
+			return nil, nil, err
+		}
+		// close our side of the socket, do not close the listener as it will
+		// remove the socket from disk
+		defer socket.Close()
+
+		cmd := newCommand(binary, config, socket)
+		if err := reaper.Default.Start(cmd); err != nil {
+			return nil, nil, errors.Wrapf(err, "failed to start shim")
+		}
+		log.G(ctx).WithFields(logrus.Fields{
+			"pid":     cmd.Process.Pid,
+			"address": config.Address,
+		}).Infof("shim %s started", binary)
+		if err = sys.SetOOMScore(cmd.Process.Pid, sys.OOMScoreMaxKillable); err != nil {
+			return nil, nil, errors.Wrap(err, "failed to set OOM Score on shim")
+		}
+		return WithConnect(ctx, config)
+	}
+}
+
+func newCommand(binary string, config Config, socket *os.File) *exec.Cmd {
+	args := []string{
+		"--namespace", config.Namespace,
+	}
+	if config.Debug {
+		args = append(args, "--debug")
+	}
+	cmd := exec.Command(binary, args...)
+	cmd.Dir = config.Path
+	// make sure the shim can be re-parented to system init
+	// and is cloned in a new mount namespace because the overlay/filesystems
+	// will be mounted by the shim
+	cmd.SysProcAttr = &syscall.SysProcAttr{
+		Cloneflags: syscall.CLONE_NEWNS,
+		Setpgid:    true,
+	}
+	cmd.ExtraFiles = append(cmd.ExtraFiles, socket)
+	return cmd
+}
+
+func newSocket(config Config) (*os.File, error) {
+	l, err := sys.CreateUnixSocket(config.Address)
 	if err != nil {
 		return nil, err
 	}
+	return l.(*net.UnixListener).File()
+}
 
-	s, err := New(path, namespace)
+func connect(address string) (*grpc.ClientConn, error) {
+	gopts := []grpc.DialOption{
+		grpc.WithBlock(),
+		grpc.WithInsecure(),
+		grpc.WithTimeout(100 * time.Second),
+		grpc.WithDialer(dialer),
+		grpc.FailOnNonTempDialError(true),
+	}
+	conn, err := grpc.Dial(dialAddress(address), gopts...)
+	if err != nil {
+		return nil, errors.Wrapf(err, "failed to dial %q", address)
+	}
+	return conn, nil
+}
+
+func dialer(address string, timeout time.Duration) (net.Conn, error) {
+	address = strings.TrimPrefix(address, "unix://")
+	return net.DialTimeout("unix", address, timeout)
+}
+
+func dialAddress(address string) string {
+	return fmt.Sprintf("unix://%s", address)
+}
+
+// WithConnect connects to an existing shim
+func WithConnect(ctx context.Context, config Config) (shim.ShimClient, io.Closer, error) {
+	conn, err := connect(config.Address)
+	if err != nil {
+		return nil, nil, err
+	}
+	return shim.NewShimClient(conn), conn, nil
+}
+
+// WithLocal uses an in process shim
+func WithLocal(ctx context.Context, config Config) (shim.ShimClient, io.Closer, error) {
+	service, err := NewService(config.Path, config.Namespace)
+	if err != nil {
+		return nil, nil, err
+	}
+	return NewLocal(service), nil, nil
+}
+
+type Config struct {
+	Address   string
+	Path      string
+	Namespace string
+	Debug     bool
+}
+
+// New returns a new shim client
+func New(ctx context.Context, config Config, opt ClientOpt) (*Client, error) {
+	s, c, err := opt(ctx, config)
 	if err != nil {
 		return nil, err
 	}
-	cl := &client{
-		s: s,
-	}
-	// used when quering container status and info
-	cl.s.initProcess = &initProcess{
-		id:  filepath.Base(path),
-		pid: pid,
-		runc: &runc.Runc{
-			Log:          filepath.Join(path, "log.json"),
-			LogFormat:    runc.JSON,
-			PdeathSignal: syscall.SIGKILL,
-			Root:         filepath.Join(RuncRoot, namespace),
-		},
-	}
-	return cl, nil
-}
-
-type client struct {
-	s *Service
-}
-
-func (c *client) Create(ctx context.Context, in *shimapi.CreateRequest, opts ...grpc.CallOption) (*shimapi.CreateResponse, error) {
-	return c.s.Create(ctx, in)
-}
-
-func (c *client) Start(ctx context.Context, in *shimapi.StartRequest, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
-	return c.s.Start(ctx, in)
-}
-
-func (c *client) Delete(ctx context.Context, in *shimapi.DeleteRequest, opts ...grpc.CallOption) (*shimapi.DeleteResponse, error) {
-	return c.s.Delete(ctx, in)
-}
-
-func (c *client) DeleteProcess(ctx context.Context, in *shimapi.DeleteProcessRequest, opts ...grpc.CallOption) (*shimapi.DeleteResponse, error) {
-	return c.s.DeleteProcess(ctx, in)
-}
-
-func (c *client) Exec(ctx context.Context, in *shimapi.ExecRequest, opts ...grpc.CallOption) (*shimapi.ExecResponse, error) {
-	return c.s.Exec(ctx, in)
-}
-
-func (c *client) Pty(ctx context.Context, in *shimapi.PtyRequest, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
-	return c.s.Pty(ctx, in)
-}
-
-func (c *client) Events(ctx context.Context, in *shimapi.EventsRequest, opts ...grpc.CallOption) (shimapi.Shim_EventsClient, error) {
-	return &events{
-		c:   c.s.events,
-		ctx: ctx,
+	return &Client{
+		ShimClient: s,
+		c:          c,
 	}, nil
 }
 
-func (c *client) State(ctx context.Context, in *shimapi.StateRequest, opts ...grpc.CallOption) (*shimapi.StateResponse, error) {
-	return c.s.State(ctx, in)
+type Client struct {
+	shim.ShimClient
+
+	c io.Closer
 }
 
-func (c *client) Pause(ctx context.Context, in *shimapi.PauseRequest, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
-	return c.s.Pause(ctx, in)
-}
-
-func (c *client) Resume(ctx context.Context, in *shimapi.ResumeRequest, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
-	return c.s.Resume(ctx, in)
-}
-
-func (c *client) Kill(ctx context.Context, in *shimapi.KillRequest, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
-	return c.s.Kill(ctx, in)
-}
-
-func (c *client) Processes(ctx context.Context, in *shimapi.ProcessesRequest, opts ...grpc.CallOption) (*shimapi.ProcessesResponse, error) {
-	return c.s.Processes(ctx, in)
-}
-
-func (c *client) Exit(ctx context.Context, in *shimapi.ExitRequest, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
-	// don't exit the calling process for the client
-	// but make sure we unmount the containers rootfs for this client
-	if err := unix.Unmount(filepath.Join(c.s.path, "rootfs"), 0); err != nil {
-		return nil, err
+func (c *Client) IsAlive(ctx context.Context) (bool, error) {
+	_, err := c.ShimInfo(ctx, empty)
+	if err != nil {
+		if err != grpc.ErrServerStopped {
+			return false, err
+		}
+		return false, nil
 	}
-	return empty, nil
+	return true, nil
 }
 
-func (c *client) CloseStdin(ctx context.Context, in *shimapi.CloseStdinRequest, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
-	return c.s.CloseStdin(ctx, in)
+// KillShim kills the shim forcefully
+func (c *Client) KillShim(ctx context.Context) error {
+	info, err := c.ShimInfo(ctx, empty)
+	if err != nil {
+		return err
+	}
+	pid := int(info.ShimPid)
+	// make sure we don't kill ourselves if we are running a local shim
+	if os.Getpid() == pid {
+		return nil
+	}
+	return unix.Kill(pid, unix.SIGKILL)
 }
 
-func (c *client) Checkpoint(ctx context.Context, in *shimapi.CheckpointRequest, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
-	return c.s.Checkpoint(ctx, in)
-}
-
-type events struct {
-	c   chan *task.Event
-	ctx context.Context
-}
-
-func (e *events) Recv() (*task.Event, error) {
-	ev := <-e.c
-	return ev, nil
-}
-
-func (e *events) Header() (metadata.MD, error) {
-	return nil, nil
-}
-
-func (e *events) Trailer() metadata.MD {
-	return nil
-}
-
-func (e *events) CloseSend() error {
-	return nil
-}
-
-func (e *events) Context() context.Context {
-	return e.ctx
-}
-
-func (e *events) SendMsg(m interface{}) error {
-	return nil
-}
-
-func (e *events) RecvMsg(m interface{}) error {
-	return nil
+func (c *Client) Close() error {
+	if c.c == nil {
+		return nil
+	}
+	return c.c.Close()
 }

linux/shim/exec.go

@@ -16,7 +16,7 @@ import (
 	"golang.org/x/sys/unix"
 
 	"github.com/containerd/console"
-	shimapi "github.com/containerd/containerd/api/services/shim/v1"
+	shimapi "github.com/containerd/containerd/linux/shim/v1"
 	"github.com/containerd/fifo"
 	runc "github.com/containerd/go-runc"
 	specs "github.com/opencontainers/runtime-spec/specs-go"
@@ -43,7 +43,7 @@ type execProcess struct {
 	terminal   bool
 }
 
-func newExecProcess(context context.Context, path string, r *shimapi.ExecRequest, parent *initProcess, id int) (process, error) {
+func newExecProcess(context context.Context, path string, r *shimapi.ExecProcessRequest, parent *initProcess, id int) (process, error) {
 	e := &execProcess{
 		id:         id,
 		parent:     parent,
@@ -120,17 +120,6 @@ func newExecProcess(context context.Context, path string, r *shimapi.ExecRequest
 	return e, nil
 }
 
-func rlimits(rr []*shimapi.Rlimit) (o []specs.LinuxRlimit) {
-	for _, r := range rr {
-		o = append(o, specs.LinuxRlimit{
-			Type: r.Type,
-			Hard: r.Hard,
-			Soft: r.Soft,
-		})
-	}
-	return o
-}
-
 func (e *execProcess) Pid() int {
 	return e.pid
 }

linux/shim/init.go

@@ -17,7 +17,7 @@ import (
 	"golang.org/x/sys/unix"
 
 	"github.com/containerd/console"
-	shimapi "github.com/containerd/containerd/api/services/shim/v1"
+	shimapi "github.com/containerd/containerd/linux/shim/v1"
 	"github.com/containerd/containerd/log"
 	"github.com/containerd/containerd/mount"
 	"github.com/containerd/containerd/plugin"
@@ -52,7 +52,7 @@ type initProcess struct {
 	terminal   bool
 }
 
-func newInitProcess(context context.Context, path, namespace string, r *shimapi.CreateRequest) (*initProcess, error) {
+func newInitProcess(context context.Context, path, namespace string, r *shimapi.CreateTaskRequest) (*initProcess, error) {
 	for _, rm := range r.Rootfs {
 		m := &mount.Mount{
 			Type:    rm.Type,
@@ -104,9 +104,10 @@ func newInitProcess(context context.Context, path, namespace string, r *shimapi.
 				WorkDir:    filepath.Join(r.Bundle, "work"),
 				ParentPath: r.ParentCheckpoint,
 			},
-			PidFile:     pidFile,
-			IO:          io,
-			NoPivot:     r.NoPivot,
+			PidFile: pidFile,
+			IO:      io,
+			// TODO: implement runtime options
+			//NoPivot:     r.NoPivot,
 			Detach:      true,
 			NoSubreaper: true,
 		}
@@ -117,7 +118,7 @@ func newInitProcess(context context.Context, path, namespace string, r *shimapi.
 		opts := &runc.CreateOpts{
 			PidFile: pidFile,
 			IO:      io,
-			NoPivot: r.NoPivot,
+			// NoPivot: r.NoPivot,
 		}
 		if socket != nil {
 			opts.ConsoleSocket = socket
@@ -253,7 +254,7 @@ func (p *initProcess) Stdin() io.Closer {
 	return p.stdin
 }
 
-func (p *initProcess) Checkpoint(context context.Context, r *shimapi.CheckpointRequest) error {
+func (p *initProcess) Checkpoint(context context.Context, r *shimapi.CheckpointTaskRequest) error {
 	var actions []runc.CheckpointAction
 	/*
 		if !r.Exit {

linux/shim/local.go

@@ -0,0 +1,126 @@
+// +build !windows
+
+package shim
+
+import (
+	"path/filepath"
+
+	shimapi "github.com/containerd/containerd/linux/shim/v1"
+	google_protobuf "github.com/golang/protobuf/ptypes/empty"
+	"golang.org/x/net/context"
+	"golang.org/x/sys/unix"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/metadata"
+)
+
+// NewLocal returns a shim client implementation for issue commands to a shim
+func NewLocal(s *Service) shimapi.ShimClient {
+	return &local{
+		s: s,
+	}
+}
+
+type local struct {
+	s *Service
+}
+
+func (c *local) Create(ctx context.Context, in *shimapi.CreateTaskRequest, opts ...grpc.CallOption) (*shimapi.CreateTaskResponse, error) {
+	return c.s.Create(ctx, in)
+}
+
+func (c *local) Start(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
+	return c.s.Start(ctx, in)
+}
+
+func (c *local) Delete(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*shimapi.DeleteResponse, error) {
+	// make sure we unmount the containers rootfs for this local
+	if err := unix.Unmount(filepath.Join(c.s.path, "rootfs"), 0); err != nil {
+		return nil, err
+	}
+	return c.s.Delete(ctx, in)
+}
+
+func (c *local) DeleteProcess(ctx context.Context, in *shimapi.DeleteProcessRequest, opts ...grpc.CallOption) (*shimapi.DeleteResponse, error) {
+	return c.s.DeleteProcess(ctx, in)
+}
+
+func (c *local) Exec(ctx context.Context, in *shimapi.ExecProcessRequest, opts ...grpc.CallOption) (*shimapi.ExecProcessResponse, error) {
+	return c.s.Exec(ctx, in)
+}
+
+func (c *local) ResizePty(ctx context.Context, in *shimapi.ResizePtyRequest, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
+	return c.s.ResizePty(ctx, in)
+}
+
+func (c *local) Stream(ctx context.Context, in *shimapi.StreamEventsRequest, opts ...grpc.CallOption) (shimapi.Shim_StreamClient, error) {
+	return &events{
+		c:   c.s.events,
+		ctx: ctx,
+	}, nil
+}
+
+func (c *local) State(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*shimapi.StateResponse, error) {
+	return c.s.State(ctx, in)
+}
+
+func (c *local) Pause(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
+	return c.s.Pause(ctx, in)
+}
+
+func (c *local) Resume(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
+	return c.s.Resume(ctx, in)
+}
+
+func (c *local) Kill(ctx context.Context, in *shimapi.KillRequest, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
+	return c.s.Kill(ctx, in)
+}
+
+func (c *local) ListProcesses(ctx context.Context, in *shimapi.ListProcessesRequest, opts ...grpc.CallOption) (*shimapi.ListProcessesResponse, error) {
+	return c.s.ListProcesses(ctx, in)
+}
+
+func (c *local) CloseIO(ctx context.Context, in *shimapi.CloseIORequest, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
+	return c.s.CloseIO(ctx, in)
+}
+
+func (c *local) Checkpoint(ctx context.Context, in *shimapi.CheckpointTaskRequest, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
+	return c.s.Checkpoint(ctx, in)
+}
+
+func (c *local) ShimInfo(ctx context.Context, in *google_protobuf.Empty, opts ...grpc.CallOption) (*shimapi.ShimInfoResponse, error) {
+	return c.s.ShimInfo(ctx, in)
+}
+
+type events struct {
+	c   chan *shimapi.Event
+	ctx context.Context
+}
+
+func (e *events) Recv() (*shimapi.Event, error) {
+	ev := <-e.c
+	return ev, nil
+}
+
+func (e *events) Header() (metadata.MD, error) {
+	return nil, nil
+}
+
+func (e *events) Trailer() metadata.MD {
+	return nil
+}
+
+func (e *events) CloseSend() error {
+	return nil
+}
+
+func (e *events) Context() context.Context {
+	return e.ctx
+}
+
+func (e *events) SendMsg(m interface{}) error {
+	return nil
+}
+
+func (e *events) RecvMsg(m interface{}) error {
+	return nil
+}

linux/shim/service.go

@@ -9,8 +9,8 @@ import (
 	"syscall"
 
 	"github.com/containerd/console"
-	shimapi "github.com/containerd/containerd/api/services/shim/v1"
 	"github.com/containerd/containerd/api/types/task"
+	shimapi "github.com/containerd/containerd/linux/shim/v1"
 	"github.com/containerd/containerd/reaper"
 	google_protobuf "github.com/golang/protobuf/ptypes/empty"
 	"github.com/pkg/errors"
@@ -22,15 +22,15 @@ var empty = &google_protobuf.Empty{}
 
 const RuncRoot = "/run/containerd/runc"
 
-// New returns a new shim service that can be used via GRPC
-func New(path, namespace string) (*Service, error) {
+// NewService returns a new shim service that can be used via GRPC
+func NewService(path, namespace string) (*Service, error) {
 	if namespace == "" {
 		return nil, fmt.Errorf("shim namespace cannot be empty")
 	}
 	return &Service{
 		path:      path,
 		processes: make(map[int]process),
-		events:    make(chan *task.Event, 4096),
+		events:    make(chan *shimapi.Event, 4096),
 		namespace: namespace,
 	}, nil
 }
@@ -42,14 +42,14 @@ type Service struct {
 	bundle        string
 	mu            sync.Mutex
 	processes     map[int]process
-	events        chan *task.Event
+	events        chan *shimapi.Event
 	eventsMu      sync.Mutex
-	deferredEvent *task.Event
+	deferredEvent *shimapi.Event
 	execID        int
 	namespace     string
 }
 
-func (s *Service) Create(ctx context.Context, r *shimapi.CreateRequest) (*shimapi.CreateResponse, error) {
+func (s *Service) Create(ctx context.Context, r *shimapi.CreateTaskRequest) (*shimapi.CreateTaskResponse, error) {
 	process, err := newInitProcess(ctx, s.path, s.namespace, r)
 	if err != nil {
 		return nil, err
@@ -65,30 +65,30 @@ func (s *Service) Create(ctx context.Context, r *shimapi.CreateRequest) (*shimap
 		ExitCh: make(chan int, 1),
 	}
 	reaper.Default.Register(pid, cmd)
-	s.events <- &task.Event{
-		Type: task.Event_CREATE,
+	s.events <- &shimapi.Event{
+		Type: shimapi.Event_CREATE,
 		ID:   r.ID,
 		Pid:  uint32(pid),
 	}
 	go s.waitExit(process, pid, cmd)
-	return &shimapi.CreateResponse{
+	return &shimapi.CreateTaskResponse{
 		Pid: uint32(pid),
 	}, nil
 }
 
-func (s *Service) Start(ctx context.Context, r *shimapi.StartRequest) (*google_protobuf.Empty, error) {
+func (s *Service) Start(ctx context.Context, r *google_protobuf.Empty) (*google_protobuf.Empty, error) {
 	if err := s.initProcess.Start(ctx); err != nil {
 		return nil, err
 	}
-	s.events <- &task.Event{
-		Type: task.Event_START,
+	s.events <- &shimapi.Event{
+		Type: shimapi.Event_START,
 		ID:   s.id,
 		Pid:  uint32(s.initProcess.Pid()),
 	}
 	return empty, nil
 }
 
-func (s *Service) Delete(ctx context.Context, r *shimapi.DeleteRequest) (*shimapi.DeleteResponse, error) {
+func (s *Service) Delete(ctx context.Context, r *google_protobuf.Empty) (*shimapi.DeleteResponse, error) {
 	p := s.initProcess
 	// TODO (@crosbymichael): how to handle errors here
 	p.Delete(ctx)
@@ -124,7 +124,7 @@ func (s *Service) DeleteProcess(ctx context.Context, r *shimapi.DeleteProcessReq
 	}, nil
 }
 
-func (s *Service) Exec(ctx context.Context, r *shimapi.ExecRequest) (*shimapi.ExecResponse, error) {
+func (s *Service) Exec(ctx context.Context, r *shimapi.ExecProcessRequest) (*shimapi.ExecProcessResponse, error) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	s.execID++
@@ -140,18 +140,18 @@ func (s *Service) Exec(ctx context.Context, r *shimapi.ExecRequest) (*shimapi.Ex
 	reaper.Default.Register(pid, cmd)
 	s.processes[pid] = process
 
-	s.events <- &task.Event{
-		Type: task.Event_EXEC_ADDED,
+	s.events <- &shimapi.Event{
+		Type: shimapi.Event_EXEC_ADDED,
 		ID:   s.id,
 		Pid:  uint32(pid),
 	}
 	go s.waitExit(process, pid, cmd)
-	return &shimapi.ExecResponse{
+	return &shimapi.ExecProcessResponse{
 		Pid: uint32(pid),
 	}, nil
 }
 
-func (s *Service) Pty(ctx context.Context, r *shimapi.PtyRequest) (*google_protobuf.Empty, error) {
+func (s *Service) ResizePty(ctx context.Context, r *shimapi.ResizePtyRequest) (*google_protobuf.Empty, error) {
 	if r.Pid == 0 {
 		return nil, errors.Errorf("pid not provided in request")
 	}
@@ -171,7 +171,7 @@ func (s *Service) Pty(ctx context.Context, r *shimapi.PtyRequest) (*google_proto
 	return empty, nil
 }
 
-func (s *Service) Events(r *shimapi.EventsRequest, stream shimapi.Shim_EventsServer) error {
+func (s *Service) Stream(r *shimapi.StreamEventsRequest, stream shimapi.Shim_StreamServer) error {
 	s.eventsMu.Lock()
 	defer s.eventsMu.Unlock()
 
@@ -195,7 +195,7 @@ func (s *Service) Events(r *shimapi.EventsRequest, stream shimapi.Shim_EventsSer
 	}
 }
 
-func (s *Service) State(ctx context.Context, r *shimapi.StateRequest) (*shimapi.StateResponse, error) {
+func (s *Service) State(ctx context.Context, r *google_protobuf.Empty) (*shimapi.StateResponse, error) {
 	st, err := s.initProcess.ContainerStatus(ctx)
 	if err != nil {
 		return nil, err
@@ -245,28 +245,20 @@ func (s *Service) State(ctx context.Context, r *shimapi.StateRequest) (*shimapi.
 	return o, nil
 }
 
-func (s *Service) Pause(ctx context.Context, r *shimapi.PauseRequest) (*google_protobuf.Empty, error) {
+func (s *Service) Pause(ctx context.Context, r *google_protobuf.Empty) (*google_protobuf.Empty, error) {
 	if err := s.initProcess.Pause(ctx); err != nil {
 		return nil, err
 	}
 	return empty, nil
 }
 
-func (s *Service) Resume(ctx context.Context, r *shimapi.ResumeRequest) (*google_protobuf.Empty, error) {
+func (s *Service) Resume(ctx context.Context, r *google_protobuf.Empty) (*google_protobuf.Empty, error) {
 	if err := s.initProcess.Resume(ctx); err != nil {
 		return nil, err
 	}
 	return empty, nil
 }
 
-func (s *Service) Exit(ctx context.Context, r *shimapi.ExitRequest) (*google_protobuf.Empty, error) {
-	// signal ourself to exit
-	if err := unix.Kill(os.Getpid(), syscall.SIGTERM); err != nil {
-		return nil, err
-	}
-	return empty, nil
-}
-
 func (s *Service) Kill(ctx context.Context, r *shimapi.KillRequest) (*google_protobuf.Empty, error) {
 	if r.Pid == 0 {
 		if err := s.initProcess.Kill(ctx, r.Signal, r.All); err != nil {
@@ -300,7 +292,7 @@ func (s *Service) Kill(ctx context.Context, r *shimapi.KillRequest) (*google_pro
 	return empty, nil
 }
 
-func (s *Service) Processes(ctx context.Context, r *shimapi.ProcessesRequest) (*shimapi.ProcessesResponse, error) {
+func (s *Service) ListProcesses(ctx context.Context, r *shimapi.ListProcessesRequest) (*shimapi.ListProcessesResponse, error) {
 	pids, err := s.getContainerPids(ctx, r.ID)
 	if err != nil {
 		return nil, err
@@ -311,13 +303,13 @@ func (s *Service) Processes(ctx context.Context, r *shimapi.ProcessesRequest) (*
 			Pid: pid,
 		})
 	}
-	resp := &shimapi.ProcessesResponse{
+	resp := &shimapi.ListProcessesResponse{
 		Processes: ps,
 	}
 	return resp, nil
 }
 
-func (s *Service) CloseStdin(ctx context.Context, r *shimapi.CloseStdinRequest) (*google_protobuf.Empty, error) {
+func (s *Service) CloseIO(ctx context.Context, r *shimapi.CloseIORequest) (*google_protobuf.Empty, error) {
 	p, ok := s.processes[int(r.Pid)]
 	if !ok {
 		return nil, fmt.Errorf("process does not exist %d", r.Pid)
@@ -328,20 +320,26 @@ func (s *Service) CloseStdin(ctx context.Context, r *shimapi.CloseStdinRequest)
 	return empty, nil
 }
 
-func (s *Service) Checkpoint(ctx context.Context, r *shimapi.CheckpointRequest) (*google_protobuf.Empty, error) {
+func (s *Service) Checkpoint(ctx context.Context, r *shimapi.CheckpointTaskRequest) (*google_protobuf.Empty, error) {
 	if err := s.initProcess.Checkpoint(ctx, r); err != nil {
 		return nil, err
 	}
 	return empty, nil
 }
 
+func (s *Service) ShimInfo(ctx context.Context, r *google_protobuf.Empty) (*shimapi.ShimInfoResponse, error) {
+	return &shimapi.ShimInfoResponse{
+		ShimPid: uint32(os.Getpid()),
+	}, nil
+}
+
 func (s *Service) waitExit(p process, pid int, cmd *reaper.Cmd) {
 	status := <-cmd.ExitCh
 	p.Exited(status)
 
 	reaper.Default.Delete(pid)
-	s.events <- &task.Event{
-		Type:       task.Event_EXIT,
+	s.events <- &shimapi.Event{
+		Type:       shimapi.Event_EXIT,
 		ID:         s.id,
 		Pid:        uint32(pid),
 		ExitStatus: uint32(status),

linux/shim/v1/shim.proto

@@ -0,0 +1,156 @@
+syntax = "proto3";
+
+package containerd.runtime.linux.shim.v1;
+
+import "google/protobuf/any.proto";
+import "google/protobuf/empty.proto";
+import "gogoproto/gogo.proto";
+import "google/protobuf/timestamp.proto";
+import "github.com/containerd/containerd/api/types/mount.proto";
+import "github.com/containerd/containerd/api/types/task/task.proto";
+
+option go_package = "github.com/containerd/containerd/linux/shim/v1;shim";
+
+// Shim service is launched for each container and is responsible for owning the IO
+// for the container and its additional processes.  The shim is also the parent of
+// each container and allows reattaching to the IO and receiving the exit status
+// for the container processes.
+service Shim {
+	// State returns shim and task state information.
+	rpc State(google.protobuf.Empty) returns (StateResponse);
+
+	rpc Create(CreateTaskRequest) returns (CreateTaskResponse);
+
+	rpc Start(google.protobuf.Empty) returns (google.protobuf.Empty);
+
+	rpc Delete(google.protobuf.Empty) returns (DeleteResponse);
+
+	rpc DeleteProcess(DeleteProcessRequest) returns (DeleteResponse);
+
+	rpc ListProcesses(ListProcessesRequest) returns (ListProcessesResponse);
+
+	rpc Pause(google.protobuf.Empty) returns (google.protobuf.Empty);
+
+	rpc Resume(google.protobuf.Empty) returns (google.protobuf.Empty);
+
+	rpc Checkpoint(CheckpointTaskRequest) returns (google.protobuf.Empty);
+
+	rpc Stream(StreamEventsRequest) returns (stream Event);
+
+	rpc Kill(KillRequest) returns (google.protobuf.Empty);
+
+	rpc Exec(ExecProcessRequest) returns (ExecProcessResponse);
+
+	rpc ResizePty(ResizePtyRequest) returns (google.protobuf.Empty);
+
+	rpc CloseIO(CloseIORequest) returns (google.protobuf.Empty);
+
+	// ShimInfo returns information about the shim.
+	rpc ShimInfo(google.protobuf.Empty) returns (ShimInfoResponse);
+}
+
+message CreateTaskRequest {
+	string id = 1;
+	string bundle = 2;
+	string runtime = 3;
+	repeated containerd.types.Mount rootfs = 4;
+	bool terminal = 5;
+	string stdin = 6;
+	string stdout = 7;
+	string stderr = 8;
+	string checkpoint = 9;
+	string parent_checkpoint = 10;
+}
+
+message CreateTaskResponse {
+	uint32 pid = 1;
+}
+
+message DeleteResponse {
+	uint32 pid = 1;
+	uint32 exit_status = 2;
+	google.protobuf.Timestamp exited_at = 3 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false];
+}
+
+message DeleteProcessRequest {
+	uint32 pid = 1;
+}
+
+message ExecProcessRequest {
+	bool terminal = 1;
+	string stdin = 2;
+	string stdout = 3;
+	string stderr = 4;
+	google.protobuf.Any spec = 5;
+}
+
+message ExecProcessResponse {
+	uint32 pid = 1;
+}
+
+message ResizePtyRequest {
+	uint32 pid = 1;
+	uint32 width = 2;
+	uint32 height = 3;
+}
+
+message StateResponse {
+	string id = 1;
+	string bundle = 2;
+	uint32 pid = 3;
+	containerd.v1.types.Status status = 4;
+	repeated containerd.v1.types.Process processes = 5;
+	string stdin = 6;
+	string stdout = 7;
+	string stderr = 8;
+	bool terminal = 9;
+}
+
+message KillRequest {
+	uint32 signal = 1;
+	bool all = 2;
+	uint32 pid = 3;
+}
+
+message CloseIORequest {
+	uint32 pid = 1;
+	bool stdin = 2;
+}
+
+message ListProcessesRequest {
+	string id = 1;
+}
+
+message ListProcessesResponse{
+	repeated containerd.v1.types.Process processes = 1;
+}
+
+message CheckpointTaskRequest {
+	string path = 1;
+	map<string, string> options = 2;
+}
+
+message ShimInfoResponse {
+	uint32 shim_pid = 1;
+}
+
+message StreamEventsRequest {
+}
+
+message Event {
+	string id = 1;
+
+	enum EventType {
+		EXIT = 0;
+		OOM = 1;
+		CREATE = 2;
+		START = 3;
+		EXEC_ADDED = 4;
+		PAUSED = 5;
+	}
+
+	EventType type = 2;
+	uint32 pid = 3;
+	uint32 exit_status = 4;
+	google.protobuf.Timestamp exited_at = 5 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false];
+}