WIP: we don't need a client to resolve the context

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

Author: thaJeztah

cli/command/cli.go

@@ -81,7 +81,6 @@ type DockerCli struct {
 	contextStore       store.Store
 	init               sync.Once
 	initErr            error
-	dockerEndpoint     docker.Endpoint
 	contextStoreConfig store.Config
 	initTimeout        time.Duration
 }
@@ -153,7 +152,7 @@ func (cli *DockerCli) loadConfigFile() {
 // ServerInfo returns the server version details for the host this client is
 // connected to
 func (cli *DockerCli) ServerInfo() ServerInfo {
-	// TODO(thaJeztah) make ServerInfo() lazily load the info (ping only when needed)
+	_ = cli.initialize()
 	return cli.serverInfo
 }
 
@@ -329,7 +328,7 @@ func (cli *DockerCli) getInitTimeout() time.Duration {
 	return defaultInitTimeout
 }
 
-func (cli *DockerCli) initializeFromClient() {
+func (cli *DockerCli) initializeFromClient(apiClient client.APIClient) ServerInfo {
 	ctx := context.Background()
 	if !strings.HasPrefix(cli.DockerEndpoint().Host, "ssh://") {
 		// @FIXME context.WithTimeout doesn't work with connhelper / ssh connections
@@ -339,24 +338,22 @@ func (cli *DockerCli) initializeFromClient() {
 		defer cancel()
 	}
 
-	ping, err := cli.client.Ping(ctx)
+	ping, err := apiClient.Ping(ctx)
 	if err != nil {
 		// Default to true if we fail to connect to daemon
-		cli.serverInfo = ServerInfo{HasExperimental: true}
-
 		if ping.APIVersion != "" {
-			cli.client.NegotiateAPIVersionPing(ping)
+			apiClient.NegotiateAPIVersionPing(ping)
 		}
-		return
+		return ServerInfo{HasExperimental: true}
 	}
+	apiClient.NegotiateAPIVersionPing(ping)
 
-	cli.serverInfo = ServerInfo{
+	return ServerInfo{
 		HasExperimental: ping.Experimental,
 		OSType:          ping.OSType,
 		BuildkitVersion: ping.BuilderVersion,
 		SwarmStatus:     ping.SwarmStatus,
 	}
-	cli.client.NegotiateAPIVersionPing(ping)
 }
 
 // NotaryClient provides a Notary Repository to interact with signed metadata for an image
@@ -428,27 +425,39 @@ func resolveContextName(opts *cliflags.ClientOptions, config *configfile.ConfigF
 
 // DockerEndpoint returns the current docker endpoint
 func (cli *DockerCli) DockerEndpoint() docker.Endpoint {
-	if err := cli.initialize(); err != nil {
-		// Note that we're not terminating here, as this function may be used
-		// in cases where we're able to continue.
-		_, _ = fmt.Fprintf(cli.Err(), "Failed to initialize: %s\n", cli.initErr)
+	ep, _ := cli.getDockerEndPoint()
+	// if err != nil {
+	// 	// This fails if no contextStore is configured; we should fall
+	// 	// back to using default, but only if resolveContextName uses
+	// 	// DefaultContextName.
+	// 	ep1, err := ResolveDefaultContext(cli.options, storeConfig)
+	// 	ep = ep1.(docker.Endpoint)
+	// 	panic(err)
+	// }
+	return ep
+}
+
+func (cli *DockerCli) getDockerEndPoint() (ep docker.Endpoint, err error) {
+	if cn := cli.CurrentContext(); cn == DefaultContextName {
+		return resolveDefaultDockerEndpoint(cli.options)
+	} else {
+		return resolveDockerEndpoint(cli.contextStore, cn)
 	}
-	return cli.dockerEndpoint
 }
 
 func (cli *DockerCli) initialize() error {
 	cli.init.Do(func() {
-		cli.dockerEndpoint, cli.initErr = resolveDockerEndpoint(cli.contextStore, resolveContextName(cli.options, cli.configFile))
-		if cli.initErr != nil {
-			cli.initErr = errors.Wrap(cli.initErr, "unable to resolve docker endpoint")
-			return
-		}
 		if cli.client == nil {
-			if cli.client, cli.initErr = newAPIClientFromEndpoint(cli.dockerEndpoint, cli.configFile); cli.initErr != nil {
+			var ep docker.Endpoint
+			ep, cli.initErr = cli.getDockerEndPoint()
+			if cli.initErr != nil {
+				return
+			}
+			if cli.client, cli.initErr = newAPIClientFromEndpoint(ep, cli.configFile); cli.initErr != nil {
 				return
 			}
 		}
-		cli.initializeFromClient()
+		cli.serverInfo = cli.initializeFromClient(cli.client)
 	})
 	return cli.initErr
 }

cli/command/cli_test.go

@@ -160,10 +160,12 @@ func TestInitializeFromClient(t *testing.T) {
 			}
 
 			cli := &DockerCli{
-				client: apiclient,
-				err:    io.Discard,
+				client:  apiclient,
+				err:     io.Discard,
+				options: flags.NewClientOptions(),
 			}
-			cli.initializeFromClient()
+			err := cli.initialize()
+			assert.NilError(t, err)
 			assert.DeepEqual(t, cli.ServerInfo(), testcase.expectedServer)
 			assert.Equal(t, apiclient.negotiated, testcase.negotiated)
 		})

e2e/global/cli_test.go

@@ -21,7 +21,7 @@ func TestTLSVerify(t *testing.T) {
 	// Regardless of whether we specify true or false we need to
 	// test to make sure tls is turned on if --tlsverify is specified at all
 	result := icmd.RunCmd(icmd.Command("docker", "--tlsverify=false", "ps"))
-	result.Assert(t, icmd.Expected{ExitCode: 1, Err: "unable to resolve docker endpoint:"})
+	result.Assert(t, icmd.Expected{ExitCode: 1, Err: "Failed to initialize:"})
 
 	result = icmd.RunCmd(icmd.Command("docker", "--tlsverify=true", "ps"))
 	result.Assert(t, icmd.Expected{ExitCode: 1, Err: "ca.pem"})