Load runtimes dynamically via go1.8 plugins

Signed-off-by: Michael Crosby <crosbymichael@gmail.com> Add registration for more subsystems via plugins Signed-off-by: Michael Crosby <crosbymichael@gmail.com> Move content service to separate package Signed-off-by: Michael Crosby <crosbymichael@gmail.com>
2017-02-16 14:45:13 -08:00 · 2017-02-16 14:45:13 -08:00 · 3101be93bc
commit 3101be93bc
parent b7805198b1
25 changed files with 435 additions and 264 deletions
--- a/linux/shim/service.go
+++ b/linux/shim/service.go
@ -0,0 +1,198 @@
+package shim
+
+import (
+	"os"
+	"sync"
+	"syscall"
+
+	"github.com/crosbymichael/console"
+	shimapi "github.com/docker/containerd/api/services/shim"
+	"github.com/docker/containerd/api/types/container"
+	"github.com/docker/containerd/utils"
+	google_protobuf "github.com/golang/protobuf/ptypes/empty"
+	"github.com/pkg/errors"
+	"golang.org/x/net/context"
+)
+
+var empty = &google_protobuf.Empty{}
+
+// New returns a new shim service that can be used via GRPC
+func New() *Service {
+	return &Service{
+		processes: make(map[int]process),
+		events:    make(chan *container.Event, 4096),
+	}
+}
+
+type Service struct {
+	initProcess *initProcess
+	id          string
+	bundle      string
+	mu          sync.Mutex
+	processes   map[int]process
+	events      chan *container.Event
+	execID      int
+}
+
+func (s *Service) Create(ctx context.Context, r *shimapi.CreateRequest) (*shimapi.CreateResponse, error) {
+	process, err := newInitProcess(ctx, r)
+	if err != nil {
+		return nil, err
+	}
+	s.mu.Lock()
+	s.id = r.ID
+	s.bundle = r.Bundle
+	s.initProcess = process
+	pid := process.Pid()
+	s.processes[pid] = process
+	s.mu.Unlock()
+	s.events <- &container.Event{
+		Type: container.Event_CREATE,
+		ID:   r.ID,
+		Pid:  uint32(pid),
+	}
+	return &shimapi.CreateResponse{
+		Pid: uint32(pid),
+	}, nil
+}
+
+func (s *Service) Start(ctx context.Context, r *shimapi.StartRequest) (*google_protobuf.Empty, error) {
+	if err := s.initProcess.Start(ctx); err != nil {
+		return nil, err
+	}
+	s.events <- &container.Event{
+		Type: container.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) {
+	s.mu.Lock()
+	p, ok := s.processes[int(r.Pid)]
+	s.mu.Unlock()
+	if !ok {
+		p = s.initProcess
+	}
+	if err := p.Delete(ctx); err != nil {
+		return nil, err
+	}
+	s.mu.Lock()
+	delete(s.processes, p.Pid())
+	s.mu.Unlock()
+	return &shimapi.DeleteResponse{
+		ExitStatus: uint32(p.Status()),
+	}, nil
+}
+
+func (s *Service) Exec(ctx context.Context, r *shimapi.ExecRequest) (*shimapi.ExecResponse, error) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.execID++
+	process, err := newExecProcess(ctx, r, s.initProcess, s.execID)
+	if err != nil {
+		return nil, err
+	}
+	pid := process.Pid()
+	s.processes[pid] = process
+	s.events <- &container.Event{
+		Type: container.Event_EXEC_ADDED,
+		ID:   s.id,
+		Pid:  uint32(pid),
+	}
+	return &shimapi.ExecResponse{
+		Pid: uint32(pid),
+	}, nil
+}
+
+func (s *Service) Pty(ctx context.Context, r *shimapi.PtyRequest) (*google_protobuf.Empty, error) {
+	if r.Pid == 0 {
+		return nil, errors.Errorf("pid not provided in request")
+	}
+	ws := console.WinSize{
+		Width:  uint16(r.Width),
+		Height: uint16(r.Height),
+	}
+	s.mu.Lock()
+	p, ok := s.processes[int(r.Pid)]
+	s.mu.Unlock()
+	if !ok {
+		return nil, errors.Errorf("process does not exist %d", r.Pid)
+	}
+	if err := p.Resize(ws); err != nil {
+		return nil, err
+	}
+	return empty, nil
+}
+
+func (s *Service) Events(r *shimapi.EventsRequest, stream shimapi.Shim_EventsServer) error {
+	for e := range s.events {
+		if err := stream.Send(e); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (s *Service) State(ctx context.Context, r *shimapi.StateRequest) (*shimapi.StateResponse, error) {
+	o := &shimapi.StateResponse{
+		ID:        s.id,
+		Bundle:    s.bundle,
+		Pid:       uint32(s.initProcess.Pid()),
+		Processes: []*container.Process{},
+	}
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	for _, p := range s.processes {
+		status := container.Status_RUNNING
+		if err := syscall.Kill(p.Pid(), 0); err != nil {
+			if err != syscall.ESRCH {
+				return nil, err
+			}
+			status = container.Status_STOPPED
+		}
+		o.Processes = append(o.Processes, &container.Process{
+			Pid:    uint32(p.Pid()),
+			Status: status,
+		})
+	}
+	return o, nil
+}
+
+func (s *Service) Pause(ctx context.Context, r *shimapi.PauseRequest) (*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) {
+	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 := syscall.Kill(os.Getpid(), syscall.SIGTERM); err != nil {
+		return nil, err
+	}
+	return empty, nil
+}
+
+func (s *Service) ProcessExit(e utils.Exit) error {
+	s.mu.Lock()
+	if p, ok := s.processes[e.Pid]; ok {
+		p.Exited(e.Status)
+		s.events <- &container.Event{
+			Type:       container.Event_EXIT,
+			ID:         s.id,
+			Pid:        uint32(p.Pid()),
+			ExitStatus: uint32(e.Status),
+		}
+	}
+	s.mu.Unlock()
+	return nil
+}