Switch to github.com/golang/dep for vendoring

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

vendor/github.com/containers/image/docker/daemon/daemon_dest.go

@@ -14,7 +14,7 @@ import (
 	"github.com/containers/image/docker/reference"
 	"github.com/containers/image/manifest"
 	"github.com/containers/image/types"
-	"github.com/docker/engine-api/client"
+	"github.com/docker/docker/client"
 	"github.com/opencontainers/go-digest"
 	"github.com/pkg/errors"
 	"golang.org/x/net/context"
@@ -95,9 +95,12 @@ func (d *daemonImageDestination) Close() {
 	if !d.committed {
 		logrus.Debugf("docker-daemon: Closing tar stream to abort loading")
 		// In principle, goroutineCancel() should abort the HTTP request and stop the process from continuing.
-		// In practice, though, https://github.com/docker/engine-api/blob/master/client/transport/cancellable/cancellable.go
-		// currently just runs the HTTP request to completion in a goroutine, and returns early if the context is canceled
-		// without terminating the HTTP request at all.  So we need this CloseWithError to terminate sending the HTTP request Body
+		// In practice, though, various HTTP implementations used by client.Client.ImageLoad() (including
+		// https://github.com/golang/net/blob/master/context/ctxhttp/ctxhttp_pre17.go and the
+		// net/http version with native Context support in Go 1.7) do not always actually immediately cancel
+		// the operation: they may process the HTTP request, or a part of it, to completion in a goroutine, and
+		// return early if the context is canceled without terminating the goroutine at all.
+		// So we need this CloseWithError to terminate sending the HTTP request Body
 		// immediately, and hopefully, through terminating the sending which uses "Transfer-Encoding: chunked"" without sending
 		// the terminating zero-length chunk, prevent the docker daemon from processing the tar stream at all.
 		// Whether that works or not, closing the PipeWriter seems desirable in any case.
@@ -144,6 +147,10 @@ func (d *daemonImageDestination) AcceptsForeignLayerURLs() bool {
 // to any other readers for download using the supplied digest.
 // If stream.Read() at any time, ESPECIALLY at end of input, returns an error, PutBlob MUST 1) fail, and 2) delete any data stored so far.
 func (d *daemonImageDestination) PutBlob(stream io.Reader, inputInfo types.BlobInfo) (types.BlobInfo, error) {
+	if inputInfo.Digest.String() == "" {
+		return types.BlobInfo{}, errors.Errorf(`Can not stream a blob with unknown digest to "docker-daemon:"`)
+	}
+
 	if ok, size, err := d.HasBlob(inputInfo); err == nil && ok {
 		return types.BlobInfo{Digest: inputInfo.Digest, Size: size}, nil
 	}

vendor/github.com/containers/image/docker/daemon/daemon_src.go

@@ -11,7 +11,7 @@ import (
 
 	"github.com/containers/image/manifest"
 	"github.com/containers/image/types"
-	"github.com/docker/engine-api/client"
+	"github.com/docker/docker/client"
 	"github.com/opencontainers/go-digest"
 	"github.com/pkg/errors"
 	"golang.org/x/net/context"

vendor/github.com/containers/image/docker/daemon/daemon_transport_test.go

@@ -0,0 +1,236 @@
+package daemon
+
+import (
+	"testing"
+
+	"github.com/containers/image/docker/reference"
+	"github.com/containers/image/types"
+	"github.com/opencontainers/go-digest"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+const (
+	sha256digestHex = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"
+	sha256digest    = "sha256:" + sha256digestHex
+)
+
+func TestTransportName(t *testing.T) {
+	assert.Equal(t, "docker-daemon", Transport.Name())
+}
+
+func TestTransportParseReference(t *testing.T) {
+	testParseReference(t, Transport.ParseReference)
+}
+
+func TestTransportValidatePolicyConfigurationScope(t *testing.T) {
+	for _, scope := range []string{ // A semi-representative assortment of values; everything is rejected.
+		sha256digestHex,
+		sha256digest,
+		"docker.io/library/busybox:latest",
+		"docker.io",
+		"",
+	} {
+		err := Transport.ValidatePolicyConfigurationScope(scope)
+		assert.Error(t, err, scope)
+	}
+}
+
+func TestParseReference(t *testing.T) {
+	testParseReference(t, ParseReference)
+}
+
+// testParseReference is a test shared for Transport.ParseReference and ParseReference.
+func testParseReference(t *testing.T, fn func(string) (types.ImageReference, error)) {
+	for _, c := range []struct{ input, expectedID, expectedRef string }{
+		{sha256digest, sha256digest, ""},                                                    // Valid digest format
+		{"sha512:" + sha256digestHex + sha256digestHex, "", ""},                             // Non-digest.Canonical digest
+		{"sha256:ab", "", ""},                                                               // Invalid digest value (too short)
+		{sha256digest + "ab", "", ""},                                                       // Invalid digest value (too long)
+		{"sha256:XX23456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef", "", ""}, // Invalid digest value
+		{"UPPERCASEISINVALID", "", ""},                                                      // Invalid reference input
+		{"busybox", "", ""},                                                                 // Missing tag or digest
+		{"busybox:latest", "", "busybox:latest"},                                            // Explicit tag
+		{"busybox@" + sha256digest, "", "busybox@" + sha256digest},                          // Explicit digest
+		// A github.com/distribution/reference value can have a tag and a digest at the same time!
+		// github.com/docker/reference handles that by dropping the tag. That is not obviously the
+		// right thing to do, but it is at least reasonable, so test that we keep behaving reasonably.
+		// This test case should not be construed to make this an API promise.
+		// FIXME? Instead work extra hard to reject such input?
+		{"busybox:latest@" + sha256digest, "", "busybox@" + sha256digest}, // Both tag and digest
+		{"docker.io/library/busybox:latest", "", "busybox:latest"},        // All implied values explicitly specified
+	} {
+		ref, err := fn(c.input)
+		if c.expectedID == "" && c.expectedRef == "" {
+			assert.Error(t, err, c.input)
+		} else {
+			require.NoError(t, err, c.input)
+			daemonRef, ok := ref.(daemonReference)
+			require.True(t, ok, c.input)
+			// If we don't reject the input, the interpretation must be consistent for reference.ParseIDOrReference
+			dockerID, dockerRef, err := reference.ParseIDOrReference(c.input)
+			require.NoError(t, err, c.input)
+
+			if c.expectedRef == "" {
+				assert.Equal(t, c.expectedID, daemonRef.id.String(), c.input)
+				assert.Nil(t, daemonRef.ref, c.input)
+
+				assert.Equal(t, c.expectedID, dockerID.String(), c.input)
+				assert.Nil(t, dockerRef, c.input)
+			} else {
+				assert.Equal(t, "", daemonRef.id.String(), c.input)
+				require.NotNil(t, daemonRef.ref, c.input)
+				assert.Equal(t, c.expectedRef, daemonRef.ref.String(), c.input)
+
+				assert.Equal(t, "", dockerID.String(), c.input)
+				require.NotNil(t, dockerRef, c.input)
+				assert.Equal(t, c.expectedRef, dockerRef.String(), c.input)
+			}
+		}
+	}
+}
+
+// refWithTagAndDigest is a reference.NamedTagged and reference.Canonical at the same time.
+type refWithTagAndDigest struct{ reference.Canonical }
+
+func (ref refWithTagAndDigest) Tag() string {
+	return "notLatest"
+}
+
+// A common list of reference formats to test for the various ImageReference methods.
+// (For IDs it is much simpler, we simply use them unmodified)
+var validNamedReferenceTestCases = []struct{ input, dockerRef, stringWithinTransport string }{
+	{"busybox:notlatest", "busybox:notlatest", "busybox:notlatest"},                // Explicit tag
+	{"busybox" + sha256digest, "busybox" + sha256digest, "busybox" + sha256digest}, // Explicit digest
+	{"docker.io/library/busybox:latest", "busybox:latest", "busybox:latest"},       // All implied values explicitly specified
+	{"example.com/ns/foo:bar", "example.com/ns/foo:bar", "example.com/ns/foo:bar"}, // All values explicitly specified
+}
+
+func TestNewReference(t *testing.T) {
+	// An ID reference.
+	id, err := digest.Parse(sha256digest)
+	require.NoError(t, err)
+	ref, err := NewReference(id, nil)
+	require.NoError(t, err)
+	daemonRef, ok := ref.(daemonReference)
+	require.True(t, ok)
+	assert.Equal(t, id, daemonRef.id)
+	assert.Nil(t, daemonRef.ref)
+
+	// Named references
+	for _, c := range validNamedReferenceTestCases {
+		parsed, err := reference.ParseNamed(c.input)
+		require.NoError(t, err)
+		ref, err := NewReference("", parsed)
+		require.NoError(t, err, c.input)
+		daemonRef, ok := ref.(daemonReference)
+		require.True(t, ok, c.input)
+		assert.Equal(t, "", daemonRef.id.String())
+		require.NotNil(t, daemonRef.ref)
+		assert.Equal(t, c.dockerRef, daemonRef.ref.String(), c.input)
+	}
+
+	// Both an ID and a named reference provided
+	parsed, err := reference.ParseNamed("busybox:latest")
+	require.NoError(t, err)
+	_, err = NewReference(id, parsed)
+	assert.Error(t, err)
+
+	// A reference with neither a tag nor digest
+	parsed, err = reference.ParseNamed("busybox")
+	require.NoError(t, err)
+	_, err = NewReference("", parsed)
+	assert.Error(t, err)
+
+	// A github.com/distribution/reference value can have a tag and a digest at the same time!
+	parsed, err = reference.ParseNamed("busybox@" + sha256digest)
+	require.NoError(t, err)
+	refDigested, ok := parsed.(reference.Canonical)
+	require.True(t, ok)
+	tagDigestRef := refWithTagAndDigest{refDigested}
+	_, err = NewReference("", tagDigestRef)
+	assert.Error(t, err)
+}
+
+func TestReferenceTransport(t *testing.T) {
+	ref, err := ParseReference(sha256digest)
+	require.NoError(t, err)
+	assert.Equal(t, Transport, ref.Transport())
+
+	ref, err = ParseReference("busybox:latest")
+	require.NoError(t, err)
+	assert.Equal(t, Transport, ref.Transport())
+}
+
+func TestReferenceStringWithinTransport(t *testing.T) {
+	ref, err := ParseReference(sha256digest)
+	require.NoError(t, err)
+	assert.Equal(t, sha256digest, ref.StringWithinTransport())
+
+	for _, c := range validNamedReferenceTestCases {
+		ref, err := ParseReference(c.input)
+		require.NoError(t, err, c.input)
+		stringRef := ref.StringWithinTransport()
+		assert.Equal(t, c.stringWithinTransport, stringRef, c.input)
+		// Do one more round to verify that the output can be parsed, to an equal value.
+		ref2, err := Transport.ParseReference(stringRef)
+		require.NoError(t, err, c.input)
+		stringRef2 := ref2.StringWithinTransport()
+		assert.Equal(t, stringRef, stringRef2, c.input)
+	}
+}
+
+func TestReferenceDockerReference(t *testing.T) {
+	ref, err := ParseReference(sha256digest)
+	require.NoError(t, err)
+	assert.Nil(t, ref.DockerReference())
+
+	for _, c := range validNamedReferenceTestCases {
+		ref, err := ParseReference(c.input)
+		require.NoError(t, err, c.input)
+		dockerRef := ref.DockerReference()
+		require.NotNil(t, dockerRef, c.input)
+		assert.Equal(t, c.dockerRef, dockerRef.String(), c.input)
+	}
+}
+
+func TestReferencePolicyConfigurationIdentity(t *testing.T) {
+	ref, err := ParseReference(sha256digest)
+	require.NoError(t, err)
+	assert.Equal(t, "", ref.PolicyConfigurationIdentity())
+
+	for _, c := range validNamedReferenceTestCases {
+		ref, err := ParseReference(c.input)
+		require.NoError(t, err, c.input)
+		assert.Equal(t, "", ref.PolicyConfigurationIdentity(), c.input)
+	}
+}
+
+func TestReferencePolicyConfigurationNamespaces(t *testing.T) {
+	ref, err := ParseReference(sha256digest)
+	require.NoError(t, err)
+	assert.Empty(t, ref.PolicyConfigurationNamespaces())
+
+	for _, c := range validNamedReferenceTestCases {
+		ref, err := ParseReference(c.input)
+		require.NoError(t, err, c.input)
+		assert.Empty(t, ref.PolicyConfigurationNamespaces(), c.input)
+	}
+}
+
+// daemonReference.NewImage, daemonReference.NewImageSource, openshiftReference.NewImageDestination
+// untested because just creating the objects immediately connects to the daemon.
+
+func TestReferenceDeleteImage(t *testing.T) {
+	ref, err := ParseReference(sha256digest)
+	require.NoError(t, err)
+	err = ref.DeleteImage(nil)
+	assert.Error(t, err)
+
+	for _, c := range validNamedReferenceTestCases {
+		ref, err := ParseReference(c.input)
+		require.NoError(t, err, c.input)
+		err = ref.DeleteImage(nil)
+		assert.Error(t, err, c.input)
+	}
+}