configure docker client for remote builds just-in-time

cmd/deploy.go

@@ -125,6 +125,8 @@ func runDeploy(cmdCtx *cmdctx.CmdContext) error {
 		return err
 	}
 
+	needsCleaning := false
+
 	if imageRef != "" {
 		// image specified, resolve it, tagging and pushing if docker+local
 		cmdCtx.Statusf("deploy", cmdctx.SINFO, "Deploying image: %s\n", imageRef)
@@ -141,6 +143,7 @@ func runDeploy(cmdCtx *cmdctx.CmdContext) error {
 			}
 		}
 	} else {
+		needsCleaning = true
 		// no image specified, build one
 		buildArgs := map[string]string{}
 
@@ -211,7 +214,7 @@ func runDeploy(cmdCtx *cmdctx.CmdContext) error {
 		cmdCtx.Statusf("deploy", cmdctx.SINFO, "Image size: %s\n", humanize.Bytes(uint64(image.Size)))
 
 		cmdCtx.Status("deploy", cmdctx.SBEGIN, "Pushing Image")
-		err := buildOp.PushImage(*image)
+		err := buildOp.PushImage(cmdCtx, *image)
 		if err != nil {
 			return err
 		}
@@ -239,7 +242,9 @@ func runDeploy(cmdCtx *cmdctx.CmdContext) error {
 		return err
 	}
 
-	buildOp.CleanDeploymentTags()
+	if needsCleaning {
+		buildOp.CleanDeploymentTags(cmdCtx)
+	}
 
 	cmdCtx.Statusf("deploy", cmdctx.SINFO, "Release v%d created\n", release.Version)
 

docker/build.go

@@ -9,6 +9,7 @@ import (
 	"os"
 	"path"
 	"strings"
+	"sync"
 	"time"
 
 	"github.com/dustin/go-humanize"
@@ -42,6 +43,8 @@ type BuildOperation struct {
 	ctx                  context.Context
 	apiClient            *api.Client
 	dockerClient         *DockerClient
+	dockerConfigured     bool
+	dockerMutex          sync.Mutex
 	localDockerAvailable bool
 	out                  io.Writer
 	appName              string
@@ -80,26 +83,39 @@ func NewBuildOperation(ctx context.Context, cmdCtx *cmdctx.CmdContext) (*BuildOp
 
 	if err := op.dockerClient.Check(ctx); err == nil {
 		op.localDockerAvailable = true
+		if localOnly {
+			return nil, fmt.Errorf("Local docker unavailable and --local-only was passed, cannot proceed.")
+		}
 	} else {
 		terminal.Debugf("Error pinging local docker: %s\n", err)
 	}
 
-	if remoteOnly {
+	return op, nil
+}
+
+func (op *BuildOperation) configureDocker(cmdCtx *cmdctx.CmdContext) error {
+	op.dockerMutex.Lock()
+	defer op.dockerMutex.Unlock()
+
+	if op.dockerConfigured {
+		return nil
+	}
+
+	if op.remoteOnly {
 		terminal.Info("Remote only, hooking you up with a remote Docker builder...")
-		if err := setRemoteBuilder(ctx, cmdCtx, dockerClient); err != nil {
-			return nil, err
-		}
-	} else if err := op.dockerClient.Check(ctx); err != nil {
-		if localOnly {
-			return nil, fmt.Errorf("Local docker unavailable and --local-only was passed, cannot proceed.")
+		if err := setRemoteBuilder(op.ctx, cmdCtx, op.dockerClient); err != nil {
+			return err
 		}
+	} else if !op.localDockerAvailable {
 		terminal.Info("Local docker unavailable, hooking you up with a remote Docker builder...")
-		if err := setRemoteBuilder(ctx, cmdCtx, dockerClient); err != nil {
-			return nil, err
+		if err := setRemoteBuilder(op.ctx, cmdCtx, op.dockerClient); err != nil {
+			return err
 		}
 	}
 
-	return op, nil
+	op.dockerConfigured = true
+
+	return nil
 }
 
 func (op *BuildOperation) LocalDockerAvailable() bool {
@@ -121,6 +137,11 @@ func (op *BuildOperation) ResolveImageLocally(ctx context.Context, cmdCtx *cmdct
 		return nil, nil
 	}
 
+	// probably not needed, but still good
+	if err := op.configureDocker(cmdCtx); err != nil {
+		return nil, err
+	}
+
 	imgSummary, err := op.dockerClient.findImage(ctx, imageRef)
 	if err != nil {
 		return nil, err
@@ -147,7 +168,7 @@ func (op *BuildOperation) ResolveImageLocally(ctx context.Context, cmdCtx *cmdct
 		Tag:  op.imageTag,
 	}
 
-	err = op.PushImage(*image)
+	err = op.PushImage(cmdCtx, *image)
 
 	if err != nil {
 		return nil, err
@@ -156,20 +177,28 @@ func (op *BuildOperation) ResolveImageLocally(ctx context.Context, cmdCtx *cmdct
 	return image, nil
 }
 
-func (op *BuildOperation) pushImage(imageTag string) error {
+func (op *BuildOperation) pushImage(cmdCtx *cmdctx.CmdContext, imageTag string) error {
 
 	if imageTag == "" {
 		return errors.New("invalid image reference")
 	}
 
+	// ensure docker is configured
+	if err := op.configureDocker(cmdCtx); err != nil {
+		return err
+	}
+
 	if err := op.dockerClient.PushImage(op.ctx, imageTag, op.out); err != nil {
 		return err
 	}
 
 	return nil
 }
 
-func (op *BuildOperation) CleanDeploymentTags() {
+func (op *BuildOperation) CleanDeploymentTags(cmdCtx *cmdctx.CmdContext) {
+	if err := op.configureDocker(cmdCtx); err != nil {
+		terminal.Warnf("could not clean up deployment tags: %v\n", err)
+	}
 	err := op.dockerClient.DeleteDeploymentImages(op.ctx, op.imageTag)
 	if err != nil {
 		terminal.Debugf("Error cleaning deployment tags: %s", err)
@@ -256,6 +285,10 @@ func (op *BuildOperation) BuildWithDocker(cmdCtx *cmdctx.CmdContext, dockerfileP
 
 	normalizedBuildArgs := normalizeBuildArgs(appConfig, buildArgs)
 
+	if err := op.configureDocker(cmdCtx); err != nil {
+		return nil, err
+	}
+
 	img, err := op.dockerClient.BuildImage(op.ctx, archive.File, op.imageTag, normalizedBuildArgs, op.out)
 
 	if err != nil {
@@ -288,6 +321,10 @@ func (op *BuildOperation) BuildWithPack(cmdCtx *cmdctx.CmdContext, buildArgs map
 		return nil, ErrNoBuildpackBuilder
 	}
 
+	if err := op.configureDocker(cmdCtx); err != nil {
+		return nil, err
+	}
+
 	c := op.initPackClient()
 
 	env := map[string]string{}
@@ -332,8 +369,8 @@ func (op *BuildOperation) BuildWithPack(cmdCtx *cmdctx.CmdContext, buildArgs map
 }
 
 // PushImage - Push the Image (where?)
-func (op *BuildOperation) PushImage(image Image) error {
-	return op.pushImage(image.Tag)
+func (op *BuildOperation) PushImage(cmdCtx *cmdctx.CmdContext, image Image) error {
+	return op.pushImage(cmdCtx, image.Tag)
 }
 
 // ResolveDockerfile - Resolve the location of the dockerfile, allowing for upper and lowercase naming