Remove dep on larger packages

This removes most of the deps on the larger packages for the shim and
reduces the binary size and memory footprint from a 7.1mb binary to a
2.6mb binary.

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

containerd-shim/process.go

@@ -12,13 +12,41 @@ import (
 	"strconv"
 	"sync"
 	"syscall"
+	"time"
 
-	"github.com/docker/containerd/runtime"
-	"github.com/opencontainers/runc/libcontainer"
+	"github.com/docker/containerd/specs"
 )
 
 var errRuntime = errors.New("shim: runtime execution error")
 
+type checkpoint struct {
+	// Timestamp is the time that checkpoint happened
+	Created time.Time `json:"created"`
+	// Name is the name of the checkpoint
+	Name string `json:"name"`
+	// Tcp checkpoints open tcp connections
+	Tcp bool `json:"tcp"`
+	// UnixSockets persists unix sockets in the checkpoint
+	UnixSockets bool `json:"unixSockets"`
+	// Shell persists tty sessions in the checkpoint
+	Shell bool `json:"shell"`
+	// Exit exits the container after the checkpoint is finished
+	Exit bool `json:"exit"`
+}
+
+type processState struct {
+	specs.ProcessSpec
+	Exec        bool     `json:"exec"`
+	Stdin       string   `json:"containerdStdin"`
+	Stdout      string   `json:"containerdStdout"`
+	Stderr      string   `json:"containerdStderr"`
+	RuntimeArgs []string `json:"runtimeArgs"`
+	NoPivotRoot bool     `json:"noPivotRoot"`
+	Checkpoint  string   `json:"checkpoint"`
+	RootUID     int      `json:"rootUID"`
+	RootGID     int      `json:"rootGID"`
+}
+
 type process struct {
 	sync.WaitGroup
 	id           string
@@ -26,12 +54,12 @@ type process struct {
 	stdio        *stdio
 	exec         bool
 	containerPid int
-	checkpoint   *runtime.Checkpoint
+	checkpoint   *checkpoint
 	shimIO       *IO
 	stdinCloser  io.Closer
-	console      libcontainer.Console
+	console      *os.File
 	consolePath  string
-	state        *runtime.ProcessState
+	state        *processState
 	runtime      string
 }
 
@@ -59,26 +87,26 @@ func newProcess(id, bundle, runtimeName string) (*process, error) {
 	return p, nil
 }
 
-func loadProcess() (*runtime.ProcessState, error) {
+func loadProcess() (*processState, error) {
 	f, err := os.Open("process.json")
 	if err != nil {
 		return nil, err
 	}
 	defer f.Close()
-	var s runtime.ProcessState
+	var s processState
 	if err := json.NewDecoder(f).Decode(&s); err != nil {
 		return nil, err
 	}
 	return &s, nil
 }
 
-func loadCheckpoint(bundle, name string) (*runtime.Checkpoint, error) {
+func loadCheckpoint(bundle, name string) (*checkpoint, error) {
 	f, err := os.Open(filepath.Join(bundle, "checkpoints", name, "config.json"))
 	if err != nil {
 		return nil, err
 	}
 	defer f.Close()
-	var cpt runtime.Checkpoint
+	var cpt checkpoint
 	if err := json.NewDecoder(f).Decode(&cpt); err != nil {
 		return nil, err
 	}
@@ -200,25 +228,25 @@ func (p *process) openIO() error {
 	}()
 
 	if p.state.Terminal {
-		console, err := libcontainer.NewConsole(uid, gid)
+		master, console, err := newConsole(uid, gid)
 		if err != nil {
 			return err
 		}
-		p.console = console
-		p.consolePath = console.Path()
+		p.console = master
+		p.consolePath = console
 		stdin, err := os.OpenFile(p.state.Stdin, syscall.O_RDONLY, 0)
 		if err != nil {
 			return err
 		}
-		go io.Copy(console, stdin)
+		go io.Copy(master, stdin)
 		stdout, err := os.OpenFile(p.state.Stdout, syscall.O_RDWR, 0)
 		if err != nil {
 			return err
 		}
 		p.Add(1)
 		go func() {
-			io.Copy(stdout, console)
-			console.Close()
+			io.Copy(stdout, master)
+			master.Close()
 			p.Done()
 		}()
 		return nil