Merge pull request #462 from crosbymichael/shim

shim: GRPC service

cmd/ctr/main.go

@@ -40,6 +40,7 @@ containerd client
 		deleteCommand,
 		listCommand,
 		inspectCommand,
+		shimCommand,
 	}
 	app.Before = func(context *cli.Context) error {
 		if context.GlobalBool("debug") {
@@ -48,7 +49,7 @@ containerd client
 		return nil
 	}
 	if err := app.Run(os.Args); err != nil {
-		fmt.Fprintf(os.Stderr, "containerd: %s\n", err)
+		fmt.Fprintf(os.Stderr, "ctr: %s\n", err)
 		os.Exit(1)
 	}
 }

cmd/ctr/shim.go

@@ -0,0 +1,296 @@
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"net"
+	"os"
+	"strconv"
+	"time"
+
+	gocontext "context"
+
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/grpclog"
+
+	"github.com/Sirupsen/logrus"
+	"github.com/crosbymichael/console"
+	"github.com/docker/containerd/api/shim"
+	"github.com/urfave/cli"
+)
+
+var fifoFlags = []cli.Flag{
+	cli.StringFlag{
+		Name:  "stdin",
+		Usage: "specify the path to the stdin fifo",
+	},
+	cli.StringFlag{
+		Name:  "stdout",
+		Usage: "specify the path to the stdout fifo",
+	},
+	cli.StringFlag{
+		Name:  "stderr",
+		Usage: "specify the path to the stderr fifo",
+	},
+	cli.BoolFlag{
+		Name:  "tty,t",
+		Usage: "enable tty support",
+	},
+}
+
+var shimCommand = cli.Command{
+	Name:  "shim",
+	Usage: "interact with a shim directly",
+	Subcommands: []cli.Command{
+		shimCreateCommand,
+		shimStartCommand,
+		shimDeleteCommand,
+		shimEventsCommand,
+		shimStateCommand,
+		shimExecCommand,
+	},
+}
+
+var shimCreateCommand = cli.Command{
+	Name:  "create",
+	Usage: "create a container with a shim",
+	Flags: append(fifoFlags,
+		cli.StringFlag{
+			Name:  "bundle",
+			Usage: "bundle path for the container",
+		},
+		cli.StringFlag{
+			Name:  "runtime",
+			Value: "runc",
+			Usage: "runtime to use for the container",
+		},
+		cli.BoolFlag{
+			Name:  "attach,a",
+			Usage: "stay attached to the container and open the fifos",
+		},
+	),
+	Action: func(context *cli.Context) error {
+		id := context.Args().First()
+		if id == "" {
+			return fmt.Errorf("container id must be provided")
+		}
+		service, err := getShimService()
+		if err != nil {
+			return err
+		}
+		tty := context.Bool("tty")
+		wg, err := prepareStdio(context.String("stdin"), context.String("stdout"), context.String("stderr"), tty)
+		if err != nil {
+			return err
+		}
+		r, err := service.Create(gocontext.Background(), &shim.CreateRequest{
+			ID:       id,
+			Bundle:   context.String("bundle"),
+			Runtime:  context.String("runtime"),
+			Stdin:    context.String("stdin"),
+			Stdout:   context.String("stdout"),
+			Stderr:   context.String("stderr"),
+			Terminal: tty,
+		})
+		if err != nil {
+			return err
+		}
+		fmt.Printf("container created with id %s and pid %d\n", id, r.Pid)
+		if context.Bool("attach") {
+			if tty {
+				current := console.Current()
+				defer current.Reset()
+				if err := current.SetRaw(); err != nil {
+					return err
+				}
+				size, err := current.Size()
+				if err != nil {
+					return err
+				}
+				if _, err := service.Pty(gocontext.Background(), &shim.PtyRequest{
+					Pid:    r.Pid,
+					Width:  uint32(size.Width),
+					Height: uint32(size.Height),
+				}); err != nil {
+					return err
+				}
+			}
+			wg.Wait()
+		}
+		return nil
+	},
+}
+
+var shimStartCommand = cli.Command{
+	Name:  "start",
+	Usage: "start a container with a shim",
+	Action: func(context *cli.Context) error {
+		service, err := getShimService()
+		if err != nil {
+			return err
+		}
+		_, err = service.Start(gocontext.Background(), &shim.StartRequest{})
+		return err
+	},
+}
+
+var shimDeleteCommand = cli.Command{
+	Name:  "delete",
+	Usage: "delete a container with a shim",
+	Action: func(context *cli.Context) error {
+		service, err := getShimService()
+		if err != nil {
+			return err
+		}
+		pid, err := strconv.Atoi(context.Args().First())
+		if err != nil {
+			return err
+		}
+		r, err := service.Delete(gocontext.Background(), &shim.DeleteRequest{
+			Pid: uint32(pid),
+		})
+		if err != nil {
+			return err
+		}
+		fmt.Printf("container deleted and returned exit status %d\n", r.ExitStatus)
+		return nil
+	},
+}
+
+var shimStateCommand = cli.Command{
+	Name:  "state",
+	Usage: "get the state of all the processes of the shim",
+	Action: func(context *cli.Context) error {
+		service, err := getShimService()
+		if err != nil {
+			return err
+		}
+		r, err := service.State(gocontext.Background(), &shim.StateRequest{})
+		if err != nil {
+			return err
+		}
+		data, err := json.Marshal(r)
+		if err != nil {
+			return err
+		}
+		buf := bytes.NewBuffer(nil)
+		if err := json.Indent(buf, data, " ", "    "); err != nil {
+			return err
+		}
+		buf.WriteTo(os.Stdout)
+		return nil
+	},
+}
+
+var shimExecCommand = cli.Command{
+	Name:  "exec",
+	Usage: "exec a new process in the shim's container",
+	Flags: append(fifoFlags,
+		cli.BoolFlag{
+			Name:  "attach,a",
+			Usage: "stay attached to the container and open the fifos",
+		},
+		cli.StringSliceFlag{
+			Name:  "env,e",
+			Usage: "add environment vars",
+			Value: &cli.StringSlice{},
+		},
+		cli.StringFlag{
+			Name:  "cwd",
+			Usage: "current working directory",
+		},
+	),
+	Action: func(context *cli.Context) error {
+		service, err := getShimService()
+		if err != nil {
+			return err
+		}
+		tty := context.Bool("tty")
+		wg, err := prepareStdio(context.String("stdin"), context.String("stdout"), context.String("stderr"), tty)
+		if err != nil {
+			return err
+		}
+		rq := &shim.ExecRequest{
+			Args:     []string(context.Args()),
+			Env:      context.StringSlice("env"),
+			Cwd:      context.String("cwd"),
+			Stdin:    context.String("stdin"),
+			Stdout:   context.String("stdout"),
+			Stderr:   context.String("stderr"),
+			Terminal: tty,
+		}
+		r, err := service.Exec(gocontext.Background(), rq)
+		if err != nil {
+			return err
+		}
+		fmt.Printf("exec running with pid %d\n", r.Pid)
+		if context.Bool("attach") {
+			logrus.Info("attaching")
+			if tty {
+				current := console.Current()
+				defer current.Reset()
+				if err := current.SetRaw(); err != nil {
+					return err
+				}
+				size, err := current.Size()
+				if err != nil {
+					return err
+				}
+				if _, err := service.Pty(gocontext.Background(), &shim.PtyRequest{
+					Pid:    r.Pid,
+					Width:  uint32(size.Width),
+					Height: uint32(size.Height),
+				}); err != nil {
+					return err
+				}
+			}
+			wg.Wait()
+		}
+		return nil
+	},
+}
+
+var shimEventsCommand = cli.Command{
+	Name:  "events",
+	Usage: "get events for a shim",
+	Action: func(context *cli.Context) error {
+		service, err := getShimService()
+		if err != nil {
+			return err
+		}
+		events, err := service.Events(gocontext.Background(), &shim.EventsRequest{})
+		if err != nil {
+			return err
+		}
+		for {
+			e, err := events.Recv()
+			if err != nil {
+				return err
+			}
+			fmt.Printf("type=%s id=%s pid=%d status=%d\n", e.Type, e.ID, e.Pid, e.ExitStatus)
+		}
+		return nil
+	},
+}
+
+func getShimService() (shim.ShimClient, error) {
+	bindSocket := "shim.sock"
+
+	// reset the logger for grpc to log to dev/null so that it does not mess with our stdio
+	grpclog.SetLogger(log.New(ioutil.Discard, "", log.LstdFlags))
+	dialOpts := []grpc.DialOption{grpc.WithInsecure(), grpc.WithTimeout(100 * time.Second)}
+	dialOpts = append(dialOpts,
+		grpc.WithDialer(func(addr string, timeout time.Duration) (net.Conn, error) {
+			return net.DialTimeout("unix", bindSocket, timeout)
+		},
+		))
+	conn, err := grpc.Dial(fmt.Sprintf("unix://%s", bindSocket), dialOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return shim.NewShimClient(conn), nil
+
+}

cmd/ctr/utils.go

@@ -14,6 +14,7 @@ import (
 
 	gocontext "context"
 
+	"github.com/Sirupsen/logrus"
 	"github.com/docker/containerd/api/execution"
 	"github.com/tonistiigi/fifo"
 	"github.com/urfave/cli"
@@ -38,6 +39,7 @@ func prepareStdio(stdin, stdout, stderr string, console bool) (*sync.WaitGroup,
 	}(f)
 	go func(w io.WriteCloser) {
 		io.Copy(w, os.Stdin)
+		logrus.Info("stdin copy finished")
 		w.Close()
 	}(f)
 
@@ -54,6 +56,7 @@ func prepareStdio(stdin, stdout, stderr string, console bool) (*sync.WaitGroup,
 	go func(r io.ReadCloser) {
 		io.Copy(os.Stdout, r)
 		r.Close()
+		logrus.Info("stdout copy finished")
 		wg.Done()
 	}(f)
 
@@ -71,6 +74,7 @@ func prepareStdio(stdin, stdout, stderr string, console bool) (*sync.WaitGroup,
 		go func(r io.ReadCloser) {
 			io.Copy(os.Stderr, r)
 			r.Close()
+			logrus.Info("stderr copy finished")
 			wg.Done()
 		}(f)
 	}
@@ -115,7 +119,6 @@ func getTempDir(id string) (string, error) {
 	if err != nil {
 		return "", err
 	}
-
 	tmpDir, err := ioutil.TempDir(filepath.Join(os.TempDir(), "ctr"), fmt.Sprintf("%s-", id))
 	if err != nil {
 		return "", err