get bind mount socket path from docker endpoint

Signed-off-by: Nick Adcock <nick.adcock@docker.com>

Author: zappy-shu

Gopkg.lock

@@ -276,19 +276,21 @@ func TestBundle(t *testing.T) {
 	assert.Assert(t, fs.Equal(tmpDir.Join("simple.dockerapp"), manifest))
 }
 
-func TestDockerAppLifecycleWithBindMounts(t *testing.T) {
-	testDockerAppLifecycle(t, true)
-}
-
-func TestDockerAppLifecycleWithoutBindMounts(t *testing.T) {
-	testDockerAppLifecycle(t, false)
+func TestDockerAppLifecycle(t *testing.T) {
+	t.Run("withBindMounts", func(t *testing.T) {
+		testDockerAppLifecycle(t, true)
+	})
+	t.Run("withoutBindMounts", func(t *testing.T) {
+		testDockerAppLifecycle(t, false)
+	})
 }
 
 func testDockerAppLifecycle(t *testing.T, useBindMount bool) {
 	cmd, cleanup := dockerCli.createTestCmd()
 	defer cleanup()
+	appName := strings.Replace(t.Name(), "/", "_", 1)
 
-	tmpDir := fs.NewDir(t, t.Name())
+	tmpDir := fs.NewDir(t, appName)
 	defer tmpDir.Remove()
 
 	cmd.Env = append(cmd.Env, "DUFFLE_HOME="+tmpDir.Path())
@@ -309,19 +311,19 @@ func testDockerAppLifecycle(t *testing.T, useBindMount bool) {
 	cmd.Command = dockerCli.Command("context", "create", "swarm-context", "--docker", fmt.Sprintf(`"host=tcp://%s"`, swarm.GetAddress(t)), "--default-stack-orchestrator", "swarm")
 	icmd.RunCmd(cmd).Assert(t, icmd.Success)
 
-	if useBindMount {
-		// When creating a context on a Windows host we cannot use
-		// the unix socket but it's needed inside the invocation image.
-		// The workaround is to create a context with an empty host.
-		// This host will default to the unix socket inside the
-		// invocation image
-		cmd.Command = dockerCli.Command("context", "create", "swarm-target-context", "--docker", "host=", "--default-stack-orchestrator", "swarm")
-		icmd.RunCmd(cmd).Assert(t, icmd.Success)
-	} else {
-		cmd.Command = dockerCli.Command("context", "create", "swarm-target-context", "--docker", fmt.Sprintf(`"host=tcp://%s"`, swarm.GetPrivateAddress(t)), "--default-stack-orchestrator", "swarm")
-		icmd.RunCmd(cmd).Assert(t, icmd.Success)
+	// When creating a context on a Windows host we cannot use
+	// the unix socket but it's needed inside the invocation image.
+	// The workaround is to create a context with an empty host.
+	// This host will default to the unix socket inside the
+	// invocation image
+	host := "host="
+	if !useBindMount {
+		host += fmt.Sprintf("tcp://%s", swarm.GetPrivateAddress(t))
 	}
 
+	cmd.Command = dockerCli.Command("context", "create", "swarm-target-context", "--docker", host, "--default-stack-orchestrator", "swarm")
+	icmd.RunCmd(cmd).Assert(t, icmd.Success)
+
 	// Initialize the swarm
 	cmd.Env = append(cmd.Env, "DOCKER_CONTEXT=swarm-context")
 	cmd.Command = dockerCli.Command("swarm", "init")
@@ -332,47 +334,47 @@ func testDockerAppLifecycle(t *testing.T, useBindMount bool) {
 	icmd.RunCmd(cmd).Assert(t, icmd.Success)
 
 	// Install a Docker Application Package
-	cmd.Command = dockerCli.Command("app", "install", "testdata/simple/simple.dockerapp", "--name", t.Name())
+	cmd.Command = dockerCli.Command("app", "install", "testdata/simple/simple.dockerapp", "--name", appName)
 	checkContains(t, icmd.RunCmd(cmd).Assert(t, icmd.Success).Combined(),
 		[]string{
-			fmt.Sprintf("Creating network %s_back", t.Name()),
-			fmt.Sprintf("Creating network %s_front", t.Name()),
-			fmt.Sprintf("Creating service %s_db", t.Name()),
-			fmt.Sprintf("Creating service %s_api", t.Name()),
-			fmt.Sprintf("Creating service %s_web", t.Name()),
+			fmt.Sprintf("Creating network %s_back", appName),
+			fmt.Sprintf("Creating network %s_front", appName),
+			fmt.Sprintf("Creating service %s_db", appName),
+			fmt.Sprintf("Creating service %s_api", appName),
+			fmt.Sprintf("Creating service %s_web", appName),
 		})
 
 	// Query the application status
-	cmd.Command = dockerCli.Command("app", "status", t.Name())
+	cmd.Command = dockerCli.Command("app", "status", appName)
 	checkContains(t, icmd.RunCmd(cmd).Assert(t, icmd.Success).Combined(),
 		[]string{
-			fmt.Sprintf("[[:alnum:]]+        %s_db    replicated          [0-1]/1                 postgres:9.3", t.Name()),
-			fmt.Sprintf(`[[:alnum:]]+        %s_web   replicated          [0-1]/1                 nginx:latest        \*:8082->80/tcp`, t.Name()),
-			fmt.Sprintf("[[:alnum:]]+        %s_api   replicated          [0-1]/1                 python:3.6", t.Name()),
+			fmt.Sprintf("[[:alnum:]]+        %s_db    replicated          [0-1]/1                 postgres:9.3", appName),
+			fmt.Sprintf(`[[:alnum:]]+        %s_web   replicated          [0-1]/1                 nginx:latest        \*:8082->80/tcp`, appName),
+			fmt.Sprintf("[[:alnum:]]+        %s_api   replicated          [0-1]/1                 python:3.6", appName),
 		})
 
 	// Upgrade the application, changing the port
-	cmd.Command = dockerCli.Command("app", "upgrade", t.Name(), "--set", "web_port=8081")
+	cmd.Command = dockerCli.Command("app", "upgrade", appName, "--set", "web_port=8081")
 	checkContains(t, icmd.RunCmd(cmd).Assert(t, icmd.Success).Combined(),
 		[]string{
-			fmt.Sprintf("Updating service %s_db", t.Name()),
-			fmt.Sprintf("Updating service %s_api", t.Name()),
-			fmt.Sprintf("Updating service %s_web", t.Name()),
+			fmt.Sprintf("Updating service %s_db", appName),
+			fmt.Sprintf("Updating service %s_api", appName),
+			fmt.Sprintf("Updating service %s_web", appName),
 		})
 
 	// Query the application status again, the port should have change
-	cmd.Command = dockerCli.Command("app", "status", t.Name())
+	cmd.Command = dockerCli.Command("app", "status", appName)
 	icmd.RunCmd(cmd).Assert(t, icmd.Expected{ExitCode: 0, Out: "8081"})
 
 	// Uninstall the application
-	cmd.Command = dockerCli.Command("app", "uninstall", t.Name())
+	cmd.Command = dockerCli.Command("app", "uninstall", appName)
 	checkContains(t, icmd.RunCmd(cmd).Assert(t, icmd.Success).Combined(),
 		[]string{
-			fmt.Sprintf("Removing service %s_api", t.Name()),
-			fmt.Sprintf("Removing service %s_db", t.Name()),
-			fmt.Sprintf("Removing service %s_web", t.Name()),
-			fmt.Sprintf("Removing network %s_front", t.Name()),
-			fmt.Sprintf("Removing network %s_back", t.Name()),
+			fmt.Sprintf("Removing service %s_api", appName),
+			fmt.Sprintf("Removing service %s_db", appName),
+			fmt.Sprintf("Removing service %s_web", appName),
+			fmt.Sprintf("Removing network %s_front", appName),
+			fmt.Sprintf("Removing network %s_back", appName),
 		})
 }
 

e2e/.docker/.buildNodeID

@@ -8,6 +8,7 @@ import (
 	"strings"
 
 	"github.com/deislabs/duffle/pkg/bundle"
+	"github.com/deislabs/duffle/pkg/claim"
 	"github.com/deislabs/duffle/pkg/credentials"
 	"github.com/deislabs/duffle/pkg/driver"
 	"github.com/deislabs/duffle/pkg/duffle/home"
@@ -16,7 +17,6 @@ import (
 	"github.com/docker/app/internal/packager"
 	bundlestore "github.com/docker/app/internal/store"
 	"github.com/docker/cli/cli/command"
-	"github.com/docker/cli/cli/context"
 	"github.com/docker/cli/cli/context/docker"
 	"github.com/docker/cli/cli/context/store"
 	"github.com/docker/distribution/reference"
@@ -25,6 +25,13 @@ import (
 	"github.com/pkg/errors"
 )
 
+type bindMount struct {
+	required bool
+	endpoint string
+}
+
+const defaultSocketPath string = "/var/run/docker.sock"
+
 func prepareCredentialSet(contextName string, contextStore store.Store, b *bundle.Bundle, namedCredentialsets []string) (map[string]string, error) {
 	creds := map[string]string{}
 	for _, file := range namedCredentialsets {
@@ -80,21 +87,21 @@ func duffleHome() home.Home {
 }
 
 // prepareDriver prepares a driver per the user's request.
-func prepareDriver(dockerCli command.Cli, bindLocalSocket bool) (driver.Driver, error) {
+func prepareDriver(dockerCli command.Cli, bindMount bindMount) (driver.Driver, error) {
 	driverImpl, err := driver.Lookup("docker")
 	if err != nil {
 		return driverImpl, err
 	}
 	if d, ok := driverImpl.(*driver.DockerDriver); ok {
 		d.SetDockerCli(dockerCli)
-		if bindLocalSocket {
+		if bindMount.required {
 			d.AddConfigurationOptions(func(config *container.Config, hostConfig *container.HostConfig) error {
 				config.User = "0:0"
 				mounts := []mount.Mount{
 					{
 						Type:   mount.TypeBind,
-						Source: "/var/run/docker.sock",
-						Target: "/var/run/docker.sock",
+						Source: bindMount.endpoint,
+						Target: bindMount.endpoint,
 					},
 				}
 				hostConfig.Mounts = mounts
@@ -180,36 +187,53 @@ func resolveBundle(dockerCli command.Cli, name string, pullRef bool, insecureReg
 	return nil, fmt.Errorf("could not resolve bundle %q", name)
 }
 
-func requiresBindMount(targetContextName string, targetOrchestrator string, dockerCli command.Cli) (bool, error) {
+func requiredClaimBindMount(c claim.Claim, targetContextName string, dockerCli command.Cli) (bindMount, error) {
+	var specifiedOrchestrator string
+	if rawOrchestrator, ok := c.Parameters["docker.orchestrator"]; ok {
+		specifiedOrchestrator = rawOrchestrator.(string)
+	}
+
+	return requiredBindMount(targetContextName, specifiedOrchestrator, dockerCli)
+}
+
+func requiredBindMount(targetContextName string, targetOrchestrator string, dockerCli command.Cli) (bindMount, error) {
 	if targetOrchestrator == "kubernetes" {
-		return false, nil
+		return bindMount{}, nil
 	}
 
 	// TODO:smarter handling of default context required
 	if targetContextName == "" {
-		return true, nil
+		return bindMount{true, defaultSocketPath}, nil
 	}
 
 	ctxMeta, err := dockerCli.ContextStore().GetContextMetadata(targetContextName)
 	if err != nil {
-		return false, err
+		return bindMount{}, err
 	}
 	dockerCtx, err := command.GetDockerContext(ctxMeta)
 	if err != nil {
-		return false, err
+		return bindMount{}, err
 	}
 	if dockerCtx.StackOrchestrator == command.OrchestratorKubernetes {
-		return false, nil
+		return bindMount{}, nil
 	}
 	dockerEndpoint, err := docker.EndpointFromContext(ctxMeta)
 	if err != nil {
-		return false, err
+		return bindMount{}, err
 	}
 
-	return isDockerHostLocal(dockerEndpoint), nil
+	host := dockerEndpoint.Host
+	return bindMount{isDockerHostLocal(host), socketPath(host)}, nil
 }
 
-func isDockerHostLocal(dockerEndpoint context.EndpointMetaBase) bool {
-	host := dockerEndpoint.Host
-	return host == "" || host == "unix:///var/run/docker.sock" || host == "npipe:////./pipe/docker_engine"
+func socketPath(host string) string {
+	if strings.HasPrefix(host, "unix://") {
+		return strings.TrimPrefix(host, "unix://")
+	}
+
+	return defaultSocketPath
+}
+
+func isDockerHostLocal(host string) bool {
+	return host == "" || strings.HasPrefix(host, "unix://") || strings.HasPrefix(host, "npipe://")
 }

e2e/commands_test.go

@@ -4,7 +4,6 @@ import (
 	"testing"
 
 	"github.com/docker/cli/cli/command"
-	"github.com/docker/cli/cli/context"
 	"gotest.tools/assert"
 )
 
@@ -16,34 +15,38 @@ func TestRequiresBindMount(t *testing.T) {
 		name               string
 		targetContextName  string
 		targetOrchestrator string
-		expectedResult     bool
+		expectedRequired   bool
+		expectedEndpoint   string
 		expectedError      string
 	}{
 		{
 			name:               "kubernetes-orchestrator",
 			targetContextName:  "target-context",
 			targetOrchestrator: "kubernetes",
-			expectedResult:     false,
+			expectedRequired:   false,
+			expectedEndpoint:   "",
 			expectedError:      "",
 		},
 		{
 			name:               "no-context",
 			targetContextName:  "",
 			targetOrchestrator: "swarm",
-			expectedResult:     true,
+			expectedRequired:   true,
+			expectedEndpoint:   "/var/run/docker.sock",
 			expectedError:      "",
 		},
 	}
 
 	for _, testCase := range testCases {
 		t.Run(testCase.name, func(t *testing.T) {
-			result, err := requiresBindMount(testCase.targetContextName, testCase.targetOrchestrator, dockerCli)
+			result, err := requiredBindMount(testCase.targetContextName, testCase.targetOrchestrator, dockerCli)
 			if testCase.expectedError == "" {
 				assert.NilError(t, err)
 			} else {
 				assert.Error(t, err, testCase.expectedError)
 			}
-			assert.Equal(t, testCase.expectedResult, result)
+			assert.Equal(t, testCase.expectedRequired, result.required)
+			assert.Equal(t, testCase.expectedEndpoint, result.endpoint)
 		})
 	}
 }
@@ -78,8 +81,42 @@ func TestIsDockerHostLocal(t *testing.T) {
 
 	for _, testCase := range testCases {
 		t.Run(testCase.name, func(t *testing.T) {
-			dockerEndpoint := context.EndpointMetaBase{Host: testCase.host}
-			assert.Equal(t, testCase.expected, isDockerHostLocal(dockerEndpoint))
+			assert.Equal(t, testCase.expected, isDockerHostLocal(testCase.host))
+		})
+	}
+}
+
+func TestSocketPath(t *testing.T) {
+	testCases := []struct {
+		name     string
+		host     string
+		expected string
+	}{
+		{
+			name:     "unixSocket",
+			host:     "unix:///my/socket.sock",
+			expected: "/my/socket.sock",
+		},
+		{
+			name:     "namedPipe",
+			host:     "npipe:////./docker",
+			expected: "/var/run/docker.sock",
+		},
+		{
+			name:     "emptyHost",
+			host:     "",
+			expected: "/var/run/docker.sock",
+		},
+		{
+			name:     "tcpHost",
+			host:     "tcp://my/tcp/endpoint",
+			expected: "/var/run/docker.sock",
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			assert.Equal(t, testCase.expected, socketPath(testCase.host))
 		})
 	}
 }