Allow users to use multistage Docker builds based on Docker version

commands/operator-sdk/cmd/build.go

@@ -37,6 +37,7 @@ var (
 	namespacedManBuild string
 	testLocationBuild  string
 	enableTests        bool
+	genMultistage      bool
 )
 
 func NewBuildCmd() *cobra.Command {
@@ -58,6 +59,7 @@ For example:
 		Run: buildFunc,
 	}
 	buildCmd.Flags().BoolVar(&enableTests, "enable-tests", false, "Enable in-cluster testing by adding test binary to the image")
+	buildCmd.Flags().BoolVar(&genMultistage, "gen-multistage", false, "Generate multistage build and test Dockerfiles")
 	buildCmd.Flags().StringVar(&testLocationBuild, "test-location", "./test/e2e", "Location of tests")
 	buildCmd.Flags().StringVar(&namespacedManBuild, "namespaced-manifest", "deploy/operator.yaml", "Path of namespaced resources manifest for tests")
 	return buildCmd
@@ -141,24 +143,7 @@ func buildFunc(cmd *cobra.Command, args []string) {
 	if len(args) != 1 {
 		log.Fatalf("build command needs exactly 1 argument")
 	}
-
 	projutil.MustInProjectRoot()
-	goBuildEnv := append(os.Environ(), "GOOS=linux", "GOARCH=amd64", "CGO_ENABLED=0")
-	absProjectPath := projutil.MustGetwd()
-
-	// Don't need to build go code if Ansible Operator
-	if mainExists() {
-		managerDir := filepath.Join(projutil.CheckAndGetProjectGoPkg(), scaffold.ManagerDir)
-		outputBinName := filepath.Join(absProjectPath, scaffold.BuildBinDir, filepath.Base(absProjectPath))
-		buildCmd := exec.Command("go", "build", "-o", outputBinName, managerDir)
-		buildCmd.Env = goBuildEnv
-		buildCmd.Stdout = os.Stdout
-		buildCmd.Stderr = os.Stderr
-		err := buildCmd.Run()
-		if err != nil {
-			log.Fatalf("failed to build operator binary: (%v)", err)
-		}
-	}
 
 	image := args[0]
 	baseImageName := image
@@ -168,10 +153,18 @@ func buildFunc(cmd *cobra.Command, args []string) {
 
 	log.Infof("Building Docker image %s", baseImageName)
 
-	dbcmd := exec.Command("docker", "build", ".", "-f", "build/Dockerfile", "-t", baseImageName)
-	dbcmd.Stdout = os.Stdout
-	dbcmd.Stderr = os.Stderr
-	err := dbcmd.Run()
+	// The runtime environment may have docker v17.05+, in which case the SDK
+	// can build the binary within a container in a multistage pipeline.
+	// Otherwise the binary will be built on the host and COPY'd into the
+	// resulting image.
+	buildDockerfile := filepath.Join(scaffold.BuildDir, scaffold.DockerfileFile)
+	buildDockerfile = makeDockerfileIfMultistage(buildDockerfile, false)
+	if projutil.IsOperatorGo() && !projutil.IsDockerfileMultistage(buildDockerfile) {
+		if err := buildOperatorBinary(); err != nil {
+			log.Fatalf("failed to build operator binary: (%v)", err)
+		}
+	}
+	err := projutil.DockerBuild(buildDockerfile, baseImageName)
 	if err != nil {
 		if enableTests {
 			log.Fatalf("failed to output intermediate image %s: (%v)", image, err)
@@ -181,15 +174,6 @@ func buildFunc(cmd *cobra.Command, args []string) {
 	}
 
 	if enableTests {
-		testBinary := filepath.Join(absProjectPath, scaffold.BuildBinDir, filepath.Base(absProjectPath)+"-test")
-		buildTestCmd := exec.Command("go", "test", "-c", "-o", testBinary, testLocationBuild+"/...")
-		buildTestCmd.Env = goBuildEnv
-		buildTestCmd.Stdout = os.Stdout
-		buildTestCmd.Stderr = os.Stderr
-		err = buildTestCmd.Run()
-		if err != nil {
-			log.Fatalf("failed to build test binary: (%v)", err)
-		}
 		// if a user is using an older sdk repo as their library, make sure they have required build files
 		testDockerfile := filepath.Join(scaffold.BuildTestDir, scaffold.DockerfileFile)
 		_, err = os.Stat(testDockerfile)
@@ -206,21 +190,35 @@ func buildFunc(cmd *cobra.Command, args []string) {
 
 			s := &scaffold.Scaffold{}
 			err = s.Execute(cfg,
-				&scaffold.TestFrameworkDockerfile{},
+				&scaffold.TestFrameworkDockerfile{
+					Multistage: projutil.IsDockerMultistage(),
+				},
 				&scaffold.GoTestScript{},
-				&scaffold.TestPod{Image: image, TestNamespaceEnv: test.TestNamespaceEnv},
+				&scaffold.TestPod{
+					Image:            image,
+					TestNamespaceEnv: test.TestNamespaceEnv,
+				},
 			)
 			if err != nil {
 				log.Fatalf("test-framework manifest scaffold failed: (%v)", err)
 			}
+		} else if err == nil {
+			testDockerfile = makeDockerfileIfMultistage(testDockerfile, true)
 		}
 
 		log.Infof("Building test Docker image %s", image)
 
-		testDbcmd := exec.Command("docker", "build", ".", "-f", testDockerfile, "-t", image, "--build-arg", "NAMESPACEDMAN="+namespacedManBuild, "--build-arg", "BASEIMAGE="+baseImageName)
-		testDbcmd.Stdout = os.Stdout
-		testDbcmd.Stderr = os.Stderr
-		err = testDbcmd.Run()
+		// Similarly to the operator binary build, hosts that have docker < v17.05
+		// will build test binaries locally.
+		if !projutil.IsDockerfileMultistage(testDockerfile) {
+			if err := buildTestBinary(); err != nil {
+				log.Fatalf("failed to build operator binary: (%v)", err)
+			}
+		}
+		err = projutil.DockerBuild(testDockerfile, image,
+			"TESTDIR="+testLocationBuild,
+			"BASEIMAGE="+baseImageName,
+			"NAMESPACEDMAN="+namespacedManBuild)
 		if err != nil {
 			log.Fatalf("failed to output test image %s: (%v)", image, err)
 		}
@@ -231,7 +229,89 @@ func buildFunc(cmd *cobra.Command, args []string) {
 	log.Info("Operator build complete.")
 }
 
-func mainExists() bool {
-	_, err := os.Stat(filepath.Join(scaffold.ManagerDir, scaffold.CmdFile))
-	return err == nil
+// makeDockerfileIfMultistage is effectively a function for migrating
+// single-stage to multistage Dockerfiles. makeDockerfileIfMultistage scaffolds
+// a multistage Dockerfile for Go operators on hosts with docker v17.05+ if a
+// multistage Dockerfile is not already present at path dockerfile; if isTest
+// is true, makeDockerfileIfMultistage will scaffold a test framework
+// Dockerfile. The newly scaffolded file is named 'multistage.Dockerfile',
+// which users are expected to rename to 'Dockerfile'. Users will see a warning
+// if docker v17.05+ is present but they haven't set the --gen-multistage flag
+// in `operator-sdk build...`
+func makeDockerfileIfMultistage(dockerfile string, isTest bool) string {
+	if !projutil.IsOperatorGo() || !projutil.IsDockerMultistage() {
+		return dockerfile
+	}
+	if !projutil.IsDockerfileMultistage(dockerfile) {
+		msDockerfile := "multistage." + scaffold.DockerfileFile
+		if !genMultistage {
+			warnStr := `Project uses a non-multistage %sDockerfile but the present docker version
+supports multistage builds. Run operator-sdk build with --gen-multistage to write
+a multistage Dockerfile to '%s' and build it. Rename this
+file to '%s' to avoid this warning.`
+			if isTest {
+				warnStr = fmt.Sprintf(warnStr,
+					"test ",
+					filepath.Join(scaffold.BuildTestDir, msDockerfile),
+					dockerfile)
+			} else {
+				warnStr = fmt.Sprintf(warnStr,
+					"",
+					filepath.Join(scaffold.BuildDir, msDockerfile),
+					dockerfile)
+			}
+			log.Warn(warnStr)
+		} else {
+			absProjectPath := projutil.MustGetwd()
+			cfg := &input.Config{
+				AbsProjectPath: absProjectPath,
+				ProjectName:    filepath.Base(absProjectPath),
+				Repo:           projutil.CheckAndGetProjectGoPkg(),
+			}
+
+			var f input.File
+			if isTest {
+				dockerfile = filepath.Join(scaffold.BuildTestDir, msDockerfile)
+				f = &scaffold.TestFrameworkDockerfile{
+					Multistage: true,
+					Input:      input.Input{Path: dockerfile},
+				}
+			} else {
+				dockerfile = filepath.Join(scaffold.BuildDir, msDockerfile)
+				f = &scaffold.Dockerfile{
+					Multistage: true,
+					Input:      input.Input{Path: dockerfile},
+				}
+			}
+			err := (&scaffold.Scaffold{}).Execute(cfg, f)
+			if err != nil {
+				log.Fatalf("failed to write %s: (%v)", msDockerfile, err)
+			}
+		}
+	}
+
+	return dockerfile
+}
+
+// buildOperatorBinary builds the operator binary locally.
+func buildOperatorBinary() error {
+	absProjectPath := projutil.MustGetwd()
+	binName := filepath.Base(absProjectPath)
+	managerDir := filepath.Join(projutil.CheckAndGetProjectGoPkg(), scaffold.ManagerDir)
+	outputBinName := filepath.Join(absProjectPath, scaffold.BuildBinDir, binName)
+
+	cmd := exec.Command("go", "build", "-o", outputBinName, managerDir)
+	cmd.Env = append(os.Environ(), "GOOS=linux", "GOARCH=amd64", "CGO_ENABLED=0")
+	return projutil.ExecCmd(cmd)
+}
+
+// buildTestBinary builds the test framework binary locally.
+func buildTestBinary() error {
+	absProjectPath := projutil.MustGetwd()
+	binName := filepath.Base(absProjectPath)
+	outputBinName := filepath.Join(absProjectPath, scaffold.BuildBinDir, binName+"-test")
+
+	cmd := exec.Command("go", "test", "-c", "-o", outputBinName, testLocationBuild+"/...")
+	cmd.Env = append(os.Environ(), "GOOS=linux", "GOARCH=amd64", "CGO_ENABLED=0")
+	return projutil.ExecCmd(cmd)
 }