Switch to github.com/golang/dep for vendoring

Signed-off-by: Mrunal Patel <mrunalp@gmail.com>

vendor/github.com/opencontainers/runc/libcontainer/utils/utils.go

@@ -0,0 +1,102 @@
+package utils
+
+import (
+	"crypto/rand"
+	"encoding/hex"
+	"encoding/json"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+	"syscall"
+)
+
+const (
+	exitSignalOffset = 128
+)
+
+// GenerateRandomName returns a new name joined with a prefix.  This size
+// specified is used to truncate the randomly generated value
+func GenerateRandomName(prefix string, size int) (string, error) {
+	id := make([]byte, 32)
+	if _, err := io.ReadFull(rand.Reader, id); err != nil {
+		return "", err
+	}
+	if size > 64 {
+		size = 64
+	}
+	return prefix + hex.EncodeToString(id)[:size], nil
+}
+
+// ResolveRootfs ensures that the current working directory is
+// not a symlink and returns the absolute path to the rootfs
+func ResolveRootfs(uncleanRootfs string) (string, error) {
+	rootfs, err := filepath.Abs(uncleanRootfs)
+	if err != nil {
+		return "", err
+	}
+	return filepath.EvalSymlinks(rootfs)
+}
+
+// ExitStatus returns the correct exit status for a process based on if it
+// was signaled or exited cleanly
+func ExitStatus(status syscall.WaitStatus) int {
+	if status.Signaled() {
+		return exitSignalOffset + int(status.Signal())
+	}
+	return status.ExitStatus()
+}
+
+// WriteJSON writes the provided struct v to w using standard json marshaling
+func WriteJSON(w io.Writer, v interface{}) error {
+	data, err := json.Marshal(v)
+	if err != nil {
+		return err
+	}
+	_, err = w.Write(data)
+	return err
+}
+
+// CleanPath makes a path safe for use with filepath.Join. This is done by not
+// only cleaning the path, but also (if the path is relative) adding a leading
+// '/' and cleaning it (then removing the leading '/'). This ensures that a
+// path resulting from prepending another path will always resolve to lexically
+// be a subdirectory of the prefixed path. This is all done lexically, so paths
+// that include symlinks won't be safe as a result of using CleanPath.
+func CleanPath(path string) string {
+	// Deal with empty strings nicely.
+	if path == "" {
+		return ""
+	}
+
+	// Ensure that all paths are cleaned (especially problematic ones like
+	// "/../../../../../" which can cause lots of issues).
+	path = filepath.Clean(path)
+
+	// If the path isn't absolute, we need to do more processing to fix paths
+	// such as "../../../../<etc>/some/path". We also shouldn't convert absolute
+	// paths to relative ones.
+	if !filepath.IsAbs(path) {
+		path = filepath.Clean(string(os.PathSeparator) + path)
+		// This can't fail, as (by definition) all paths are relative to root.
+		path, _ = filepath.Rel(string(os.PathSeparator), path)
+	}
+
+	// Clean the path again for good measure.
+	return filepath.Clean(path)
+}
+
+// SearchLabels searches a list of key-value pairs for the provided key and
+// returns the corresponding value. The pairs must be separated with '='.
+func SearchLabels(labels []string, query string) string {
+	for _, l := range labels {
+		parts := strings.SplitN(l, "=", 2)
+		if len(parts) < 2 {
+			continue
+		}
+		if parts[0] == query {
+			return parts[1]
+		}
+	}
+	return ""
+}

vendor/github.com/opencontainers/runc/libcontainer/utils/utils_test.go

@@ -0,0 +1,153 @@
+package utils
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"path/filepath"
+	"syscall"
+	"testing"
+)
+
+func TestGenerateName(t *testing.T) {
+	name, err := GenerateRandomName("veth", 5)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	expected := 5 + len("veth")
+	if len(name) != expected {
+		t.Fatalf("expected name to be %d chars but received %d", expected, len(name))
+	}
+
+	name, err = GenerateRandomName("veth", 65)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	expected = 64 + len("veth")
+	if len(name) != expected {
+		t.Fatalf("expected name to be %d chars but received %d", expected, len(name))
+	}
+}
+
+var labelTest = []struct {
+	labels        []string
+	query         string
+	expectedValue string
+}{
+	{[]string{"bundle=/path/to/bundle"}, "bundle", "/path/to/bundle"},
+	{[]string{"test=a", "test=b"}, "bundle", ""},
+	{[]string{"bundle=a", "test=b", "bundle=c"}, "bundle", "a"},
+	{[]string{"", "test=a", "bundle=b"}, "bundle", "b"},
+	{[]string{"test", "bundle=a"}, "bundle", "a"},
+	{[]string{"test=a", "bundle="}, "bundle", ""},
+}
+
+func TestSearchLabels(t *testing.T) {
+	for _, tt := range labelTest {
+		if v := SearchLabels(tt.labels, tt.query); v != tt.expectedValue {
+			t.Errorf("expected value '%s' for query '%s'; got '%s'", tt.expectedValue, tt.query, v)
+		}
+	}
+}
+
+func TestResolveRootfs(t *testing.T) {
+	dir := "rootfs"
+	os.Mkdir(dir, 0600)
+	defer os.Remove(dir)
+
+	path, err := ResolveRootfs(dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pwd, err := os.Getwd()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if path != fmt.Sprintf("%s/%s", pwd, "rootfs") {
+		t.Errorf("expected rootfs to be abs and was %s", path)
+	}
+}
+
+func TestResolveRootfsWithSymlink(t *testing.T) {
+	dir := "rootfs"
+	tmpDir, _ := filepath.EvalSymlinks(os.TempDir())
+	os.Symlink(tmpDir, dir)
+	defer os.Remove(dir)
+
+	path, err := ResolveRootfs(dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if path != tmpDir {
+		t.Errorf("expected rootfs to be the real path %s and was %s", path, os.TempDir())
+	}
+}
+
+func TestResolveRootfsWithNonExistingDir(t *testing.T) {
+	_, err := ResolveRootfs("foo")
+	if err == nil {
+		t.Error("expected error to happen but received nil")
+	}
+}
+
+func TestExitStatus(t *testing.T) {
+	status := syscall.WaitStatus(0)
+	ex := ExitStatus(status)
+	if ex != 0 {
+		t.Errorf("expected exit status to equal 0 and received %d", ex)
+	}
+}
+
+func TestExitStatusSignaled(t *testing.T) {
+	status := syscall.WaitStatus(2)
+	ex := ExitStatus(status)
+	if ex != 130 {
+		t.Errorf("expected exit status to equal 130 and received %d", ex)
+	}
+}
+
+func TestWriteJSON(t *testing.T) {
+	person := struct {
+		Name string
+		Age  int
+	}{
+		Name: "Alice",
+		Age:  30,
+	}
+
+	var b bytes.Buffer
+	err := WriteJSON(&b, person)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	expected := `{"Name":"Alice","Age":30}`
+	if b.String() != expected {
+		t.Errorf("expected to write %s but was %s", expected, b.String())
+	}
+}
+
+func TestCleanPath(t *testing.T) {
+	path := CleanPath("")
+	if path != "" {
+		t.Errorf("expected to received empty string and received %s", path)
+	}
+
+	path = CleanPath("rootfs")
+	if path != "rootfs" {
+		t.Errorf("expected to received 'rootfs' and received %s", path)
+	}
+
+	path = CleanPath("../../../var")
+	if path != "var" {
+		t.Errorf("expected to received 'var' and received %s", path)
+	}
+
+	path = CleanPath("/../../../var")
+	if path != "/var" {
+		t.Errorf("expected to received '/var' and received %s", path)
+	}
+}

vendor/github.com/opencontainers/runc/libcontainer/utils/utils_unix.go

@@ -0,0 +1,33 @@
+// +build !windows
+
+package utils
+
+import (
+	"io/ioutil"
+	"strconv"
+	"syscall"
+)
+
+func CloseExecFrom(minFd int) error {
+	fdList, err := ioutil.ReadDir("/proc/self/fd")
+	if err != nil {
+		return err
+	}
+	for _, fi := range fdList {
+		fd, err := strconv.Atoi(fi.Name())
+		if err != nil {
+			// ignore non-numeric file names
+			continue
+		}
+
+		if fd < minFd {
+			// ignore descriptors lower than our specified minimum
+			continue
+		}
+
+		// intentionally ignore errors from syscall.CloseOnExec
+		syscall.CloseOnExec(fd)
+		// the cases where this might fail are basically file descriptors that have already been closed (including and especially the one that was created when ioutil.ReadDir did the "opendir" syscall)
+	}
+	return nil
+}