Update containerd dependencies to match 1.0.2

- ed1cbe1fc3...4f6e87ae04
- 29da22c617...c0710c92e8
- runc (already ahead)
- 76e68349ad...d452837986

Signed-off-by: Sebastiaan van Stijn <github@gone.nl>

vendor.conf

@@ -107,12 +107,12 @@ google.golang.org/genproto d80a6e20e776b0b17a324d0ba1ab50a39c8e8944
 github.com/containerd/containerd 3fa104f843ec92328912e042b767d26825f202aa
 github.com/containerd/fifo fbfb6a11ec671efbe94ad1c12c2e98773f19e1e6
 github.com/containerd/continuity 992a5f112bd2211d0983a1cc8562d2882848f3a3
-github.com/containerd/cgroups 29da22c6171a4316169f9205ab6c49f59b5b852f
+github.com/containerd/cgroups c0710c92e8b3a44681d1321dcfd1360fc5c6c089
 github.com/containerd/console 84eeaae905fa414d03e07bcd6c8d3f19e7cf180e
-github.com/containerd/go-runc ed1cbe1fc31f5fb2359d3a54b6330d1a097858b7
+github.com/containerd/go-runc 4f6e87ae043f859a38255247b49c9abc262d002f
 github.com/containerd/typeurl f6943554a7e7e88b3c14aad190bf05932da84788
 github.com/dmcgowan/go-tar go1.10
-github.com/stevvooe/ttrpc 76e68349ad9ab4d03d764c713826d31216715e4f
+github.com/stevvooe/ttrpc d4528379866b0ce7e9d71f3eb96f0582fc374577
 
 # cluster
 github.com/docker/swarmkit 68a376dc30d8c4001767c39456b990dbd821371b

vendor/github.com/containerd/cgroups/blkio.go

@@ -3,12 +3,12 @@ package cgroups
 import (
 	"bufio"
 	"fmt"
+	"io"
 	"io/ioutil"
 	"os"
 	"path/filepath"
 	"strconv"
 	"strings"
-	"syscall"
 
 	specs "github.com/opencontainers/runtime-spec/specs-go"
 )
@@ -105,8 +105,13 @@ func (b *blkioController) Stat(path string, stats *Metrics) error {
 			},
 		)
 	}
+	f, err := os.Open("/proc/diskstats")
+	if err != nil {
+		return err
+	}
+	defer f.Close()
 
-	devices, err := getDevices("/dev")
+	devices, err := getDevices(f)
 	if err != nil {
 		return err
 	}
@@ -268,50 +273,32 @@ type deviceKey struct {
 // getDevices makes a best effort attempt to read all the devices into a map
 // keyed by major and minor number. Since devices may be mapped multiple times,
 // we err on taking the first occurrence.
-func getDevices(path string) (map[deviceKey]string, error) {
+func getDevices(r io.Reader) (map[deviceKey]string, error) {
-	// TODO(stevvooe): We are ignoring lots of errors. It might be kind of
+
-	// challenging to debug this if we aren't mapping devices correctly.
+	var (
-	// Consider logging these errors.
+		s       = bufio.NewScanner(r)
-	devices := map[deviceKey]string{}
+		devices = make(map[deviceKey]string)
-	if err := filepath.Walk(path, func(p string, fi os.FileInfo, err error) error {
+	)
+	for s.Scan() {
+		fields := strings.Fields(s.Text())
+		major, err := strconv.Atoi(fields[0])
 		if err != nil {
-			return err
+			return nil, err
 		}
-		switch {
+		minor, err := strconv.Atoi(fields[1])
-		case fi.IsDir():
+		if err != nil {
-			switch fi.Name() {
+			return nil, err
-			case "pts", "shm", "fd", "mqueue", ".lxc", ".lxd-mounts":
-				return filepath.SkipDir
-			default:
-				return nil
-			}
-		case fi.Name() == "console":
-			return nil
-		default:
-			if fi.Mode()&os.ModeDevice == 0 {
-				// skip non-devices
-				return nil
-			}
-
-			st, ok := fi.Sys().(*syscall.Stat_t)
-			if !ok {
-				return fmt.Errorf("%s: unable to convert to system stat", p)
-			}
-
-			key := deviceKey{major(st.Rdev), minor(st.Rdev)}
-			if _, ok := devices[key]; ok {
-				return nil // skip it if we have already populated the path.
-			}
-
-			devices[key] = p
 		}
-
+		key := deviceKey{
-		return nil
+			major: uint64(major),
-	}); err != nil {
+			minor: uint64(minor),
-		return nil, err
+		}
+		if _, ok := devices[key]; ok {
+			continue
+		}
+		devices[key] = filepath.Join("/dev", fields[2])
 	}
-
+	return devices, s.Err()
-	return devices, nil
 }
 
 func major(devNumber uint64) uint64 {

vendor/github.com/containerd/cgroups/errors.go

@@ -12,7 +12,7 @@ var (
 	ErrFreezerNotSupported      = errors.New("cgroups: freezer cgroup not supported on this system")
 	ErrMemoryNotSupported       = errors.New("cgroups: memory cgroup not supported on this system")
 	ErrCgroupDeleted            = errors.New("cgroups: cgroup deleted")
-	ErrNoCgroupMountDestination = errors.New("cgroups: cannot found cgroup mount destination")
+	ErrNoCgroupMountDestination = errors.New("cgroups: cannot find cgroup mount destination")
 )
 
 // ErrorHandler is a function that handles and acts on errors

vendor/github.com/containerd/go-runc/runc.go

@@ -1,7 +1,6 @@
 package runc
 
 import (
-	"bytes"
 	"context"
 	"encoding/json"
 	"errors"
@@ -532,7 +531,9 @@ func (r *Runc) Restore(context context.Context, id, bundle string, opts *Restore
 
 // Update updates the current container with the provided resource spec
 func (r *Runc) Update(context context.Context, id string, resources *specs.LinuxResources) error {
-	buf := bytes.NewBuffer(nil)
+	buf := getBuf()
+	defer putBuf(buf)
+
 	if err := json.NewEncoder(buf).Encode(resources); err != nil {
 		return err
 	}
@@ -638,11 +639,12 @@ func (r *Runc) runOrError(cmd *exec.Cmd) error {
 }
 
 func cmdOutput(cmd *exec.Cmd, combined bool) ([]byte, error) {
-	var b bytes.Buffer
+	b := getBuf()
+	defer putBuf(b)
 
-	cmd.Stdout = &b
+	cmd.Stdout = b
 	if combined {
-		cmd.Stderr = &b
+		cmd.Stderr = b
 	}
 	ec, err := Monitor.Start(cmd)
 	if err != nil {

vendor/github.com/containerd/go-runc/utils.go

@@ -1,8 +1,10 @@
 package runc
 
 import (
+	"bytes"
 	"io/ioutil"
 	"strconv"
+	"sync"
 	"syscall"
 )
 
@@ -26,3 +28,18 @@ func exitStatus(status syscall.WaitStatus) int {
 	}
 	return status.ExitStatus()
 }
+
+var bytesBufferPool = sync.Pool{
+	New: func() interface{} {
+		return bytes.NewBuffer(nil)
+	},
+}
+
+func getBuf() *bytes.Buffer {
+	return bytesBufferPool.Get().(*bytes.Buffer)
+}
+
+func putBuf(b *bytes.Buffer) {
+	b.Reset()
+	bytesBufferPool.Put(b)
+}

vendor/github.com/stevvooe/ttrpc/channel.go

@@ -5,6 +5,7 @@ import (
 	"context"
 	"encoding/binary"
 	"io"
+	"net"
 	"sync"
 
 	"github.com/pkg/errors"
@@ -60,16 +61,18 @@ func writeMessageHeader(w io.Writer, p []byte, mh messageHeader) error {
 var buffers sync.Pool
 
 type channel struct {
+	conn  net.Conn
 	bw    *bufio.Writer
 	br    *bufio.Reader
 	hrbuf [messageHeaderLength]byte // avoid alloc when reading header
 	hwbuf [messageHeaderLength]byte
 }
 
-func newChannel(w io.Writer, r io.Reader) *channel {
+func newChannel(conn net.Conn) *channel {
 	return &channel{
-		bw: bufio.NewWriter(w),
+		conn: conn,
-		br: bufio.NewReader(r),
+		bw:   bufio.NewWriter(conn),
+		br:   bufio.NewReader(conn),
 	}
 }
 

vendor/github.com/stevvooe/ttrpc/client.go

@@ -2,8 +2,12 @@ package ttrpc
 
 import (
 	"context"
+	"io"
 	"net"
+	"os"
+	"strings"
 	"sync"
+	"syscall"
 
 	"github.com/containerd/containerd/log"
 	"github.com/gogo/protobuf/proto"
@@ -11,6 +15,10 @@ import (
 	"google.golang.org/grpc/status"
 )
 
+// ErrClosed is returned by client methods when the underlying connection is
+// closed.
+var ErrClosed = errors.New("ttrpc: closed")
+
 type Client struct {
 	codec   codec
 	conn    net.Conn
@@ -19,18 +27,20 @@ type Client struct {
 
 	closed    chan struct{}
 	closeOnce sync.Once
+	closeFunc func()
 	done      chan struct{}
 	err       error
 }
 
 func NewClient(conn net.Conn) *Client {
 	c := &Client{
-		codec:   codec{},
+		codec:     codec{},
-		conn:    conn,
+		conn:      conn,
-		channel: newChannel(conn, conn),
+		channel:   newChannel(conn),
-		calls:   make(chan *callRequest),
+		calls:     make(chan *callRequest),
-		closed:  make(chan struct{}),
+		closed:    make(chan struct{}),
-		done:    make(chan struct{}),
+		done:      make(chan struct{}),
+		closeFunc: func() {},
 	}
 
 	go c.run()
@@ -91,7 +101,7 @@ func (c *Client) dispatch(ctx context.Context, req *Request, resp *Response) err
 
 	select {
 	case err := <-errs:
-		return err
+		return filterCloseErr(err)
 	case <-c.done:
 		return c.err
 	}
@@ -105,6 +115,11 @@ func (c *Client) Close() error {
 	return nil
 }
 
+// OnClose allows a close func to be called when the server is closed
+func (c *Client) OnClose(closer func()) {
+	c.closeFunc = closer
+}
+
 type message struct {
 	messageHeader
 	p   []byte
@@ -150,6 +165,7 @@ func (c *Client) run() {
 
 	defer c.conn.Close()
 	defer close(c.done)
+	defer c.closeFunc()
 
 	for {
 		select {
@@ -171,7 +187,14 @@ func (c *Client) run() {
 			call.errs <- c.recv(call.resp, msg)
 			delete(waiters, msg.StreamID)
 		case <-shutdown:
+			if shutdownErr != nil {
+				shutdownErr = filterCloseErr(shutdownErr)
+			} else {
+				shutdownErr = ErrClosed
+			}
+
 			shutdownErr = errors.Wrapf(shutdownErr, "ttrpc: client shutting down")
+
 			c.err = shutdownErr
 			for _, waiter := range waiters {
 				waiter.errs <- shutdownErr
@@ -179,9 +202,12 @@ func (c *Client) run() {
 			c.Close()
 			return
 		case <-c.closed:
+			if c.err == nil {
+				c.err = ErrClosed
+			}
 			// broadcast the shutdown error to the remaining waiters.
 			for _, waiter := range waiters {
-				waiter.errs <- shutdownErr
+				waiter.errs <- c.err
 			}
 			return
 		}
@@ -209,3 +235,30 @@ func (c *Client) recv(resp *Response, msg *message) error {
 	defer c.channel.putmbuf(msg.p)
 	return proto.Unmarshal(msg.p, resp)
 }
+
+// filterCloseErr rewrites EOF and EPIPE errors to ErrClosed. Use when
+// returning from call or handling errors from main read loop.
+//
+// This purposely ignores errors with a wrapped cause.
+func filterCloseErr(err error) error {
+	if err == nil {
+		return nil
+	}
+
+	if err == io.EOF {
+		return ErrClosed
+	}
+
+	if strings.Contains(err.Error(), "use of closed network connection") {
+		return ErrClosed
+	}
+
+	// if we have an epipe on a write, we cast to errclosed
+	if oerr, ok := err.(*net.OpError); ok && oerr.Op == "write" {
+		if serr, ok := oerr.Err.(*os.SyscallError); ok && serr.Err == syscall.EPIPE {
+			return ErrClosed
+		}
+	}
+
+	return err
+}

vendor/github.com/stevvooe/ttrpc/server.go

@@ -16,7 +16,7 @@ import (
 )
 
 var (
-	ErrServerClosed = errors.New("ttrpc: server close")
+	ErrServerClosed = errors.New("ttrpc: server closed")
 )
 
 type Server struct {
@@ -281,7 +281,7 @@ func (c *serverConn) run(sctx context.Context) {
 	)
 
 	var (
-		ch          = newChannel(c.conn, c.conn)
+		ch          = newChannel(c.conn)
 		ctx, cancel = context.WithCancel(sctx)
 		active      int
 		state       connState = connStateIdle