feat: kfn build uses ko as default

Author: yuwenma

go/cli/commands/build.go

@@ -30,80 +30,121 @@ import (
 
 //go:embed embed/Dockerfile
 var f embed.FS
+var execCmdFn = execCmd
+var execLookPathFn = exec.LookPath
 
 const (
-	ImageTag              = "function:latest"
+	// Builder Type
+	Ko = "ko"
+	Docker =  "docker"
+
+	// Docker constant variables
+	Image           = "function:latest"
 	DockerfilePath        = "Dockerfile"
-	builtinDockerfilePath = "embed/Dockerfile"
+	BuiltinDockerfilePath = "embed/Dockerfile"
+
+	// Ko constant variables
+	KoDockerRepoEnvVar = "KO_DOCKER_REPO"
+	KoLocalRepo = "ko.local"
 )
 
-func NewBuildCmd(ctx context.Context) *cobra.Command {
+func NewBuildRunner(ctx context.Context) *BuildRunner {
 	r := &BuildRunner{
 		ctx: ctx,
+		Ko: &KoBuilder{},
+		Docker: &DockerBuilder{},
 	}
 	r.Command = &cobra.Command{
 		Use:     "build",
-		Short:   "build the KRM function as a docker image",
-		PreRunE: r.PreRunE,
+		Short:   "build your KRM function to a container image",
 		RunE:    r.RunE,
 	}
-	r.Command.Flags().StringVarP(&r.Tag, "tag", "t", ImageTag,
-		"the docker image tag")
-	r.Command.Flags().StringVarP(&r.DockerfilePath, "file", "f", "",
-		"Name of the Dockerfile. If not given, using a default builtin Dockerfile")
-	return r.Command
+	r.Command.Flags().StringVarP(&r.BuilderType, "builder", "b", Ko,
+		"the image builder. `ko` is the default builder, which requires `go build`; `docker` is accepted, and " +
+		" requires you to have docker installed and running")
+	r.Command.Flags().StringVarP(&r.Docker.Image, "image", "i", Image,
+		fmt.Sprintf("the image (with tag), default to %v", Image))
+	r.Command.Flags().StringVarP(&r.Docker.DockerfilePath, "dockerfile", "f", "",
+		"path to the Dockerfile. If not given, using a default builtin Dockerfile")
+	r.Command.Flags().StringVarP(&r.Ko.Repo, "repo", "r", "",
+		"the image repo. default to ko.local")
+	r.Command.Flags().StringVarP(&r.Ko.Tag, "tag", "t", "latest",
+		"the ko image tag")
+	// TODO: Docker CLI uses `--tag` flag to refer to "image:tag", which could be confusing but broadly accepted.
+	// We should better guide users on how to use "tag" and "image" flags for kfn.
+	// Here we use "tag" for ko <tag> (same as `ko build --tag`) and "image" for docker <image:tag> (same as `docker build --tag`)
+	return r
 }
 
 type BuildRunner struct {
 	ctx     context.Context
 	Command *cobra.Command
 
-	Tag            string
+	BuilderType string
+	Tag string
+	Ko *KoBuilder
+	Docker *DockerBuilder
+}
+
+type Builder interface {
+	Build() error
+	Validate() error
+}
+
+type DockerBuilder struct {
+	Image            string
 	DockerfilePath string
 }
 
-func (r *BuildRunner) PreRunE(cmd *cobra.Command, args []string) error {
-	if err := r.requireDocker(); err != nil {
-		return err
-	}
-	if !r.dockerfileExist() {
-		err := r.createDockerfile()
-		if err != nil {
-			return err
-		}
-	}
-	return nil
+type KoBuilder struct{
+	Repo string
+	Tag string
 }
 
 func (r *BuildRunner) RunE(cmd *cobra.Command, args []string) error {
-	return r.runDockerBuild()
+	var builder Builder
+	switch r.BuilderType {
+	case Docker:
+		builder = r.Docker
+	case Ko:
+		builder = r.Ko
+	}
+	if err := builder.Validate(); err != nil {
+		return err
+	}
+	return builder.Build()
 }
 
-func (r *BuildRunner) runDockerBuild() error {
-	args := []string{"build", ".", "-f", r.DockerfilePath, "--tag", r.Tag}
-	cmd := exec.Command("docker", args...)
-	var out, errout bytes.Buffer
-	cmd.Stdout = &out
-	cmd.Stderr = &errout
-	err := cmd.Run()
+func (r *DockerBuilder) Build() error {
+	args := []string{"build", ".", "-f", r.DockerfilePath, "--tag", r.Image}
+	out, err:= execCmdFn(nil, "docker", args...)
 	if err != nil {
-		color.Red(strings.TrimSpace(errout.String()))
 		return err
 	}
-	color.Green(out.String())
-	color.Green("Image %v builds successfully. Now you can publish the image", r.Tag)
+	fmt.Println(out)
+	color.Green("Image %v builds successfully. Now you can publish the image", r.Image)
 	return nil
 }
 
-func (r *BuildRunner) requireDocker() error {
-	_, err := exec.LookPath("docker")
+func (r *DockerBuilder) Validate() error {
+	if err := r.validateDockerInstalled(); err != nil {
+		return err
+	}
+	if r.fileExist() {
+		return nil
+	}
+	return r.createDockerfile()
+}
+
+func (r *DockerBuilder) validateDockerInstalled() error {
+	_, err := execLookPathFn("docker")
 	if err != nil {
 		return fmt.Errorf("kfn requires that `docker` is installed and on the PATH")
 	}
 	return nil
 }
 
-func (r *BuildRunner) dockerfileExist() bool {
+func (r *DockerBuilder) fileExist() bool {
 	if r.DockerfilePath == "" {
 		r.DockerfilePath = DockerfilePath
 	}
@@ -114,14 +155,74 @@ func (r *BuildRunner) dockerfileExist() bool {
 	return true
 }
 
-func (r *BuildRunner) createDockerfile() error {
-	dockerfileContent, err := f.ReadFile(builtinDockerfilePath)
+func (r *DockerBuilder) createDockerfile() error {
+	dockerfileContent, err := f.ReadFile(BuiltinDockerfilePath)
+	if err != nil {
+		return err
+	}
+	if err = os.WriteFile(DockerfilePath, dockerfileContent, 0644); err != nil {
+		return err
+	}
+	fmt.Println("created Dockerfile")
+	return nil
+}
+
+func (r *KoBuilder) GuaranteeKoInstalled() error {
+	_, err := execLookPathFn("ko")
+	if err == nil {
+		return nil
+	}
+	if _, err = execCmdFn(nil, "go", "install", "github.com/google/ko@latest"); err != nil {
+		return err
+	}
+	fmt.Println("successfully installed ko")
+	return nil
+}
+func (r *KoBuilder) Build() error {
+	args := []string{"build", "-B", "--tags", r.Tag}
+	envs := []string{KoDockerRepoEnvVar+ "=" + r.Repo}
+	out, err:= execCmdFn(envs, "ko", args...)
 	if err != nil {
 		return err
 	}
-	if err := os.WriteFile(DockerfilePath, dockerfileContent, 0644); err != nil {
+
+	if r.Repo == KoLocalRepo {
+		color.Green("Image builds successfully. Now you can publish the image %v", out)
+	} else {
+		color.Green( "Image builds and pushed successfully: %v", out)
+	}
+	return nil
+}
+
+func (r *KoBuilder) Validate() error {
+	if err := r.GuaranteeKoInstalled(); err != nil {
 		return err
 	}
-	color.Green("created Dockerfile")
+	// Find KO_DOCKER_REPO value from multiple places for `ko build`.
+	if r.Repo != "" {
+		return nil
+	}
+	if repo, ok := os.LookupEnv(KoDockerRepoEnvVar); ok {
+		r.Repo = repo
+		return nil
+	}
+	r.Repo = "ko.local"
 	return nil
 }
+
+func execCmd(envs []string, name string, args... string) (string, error) {
+	cmd := exec.Command(name, args...)
+	if len(envs) != 0 {
+		cmd.Env = os.Environ()
+		cmd.Env = append(cmd.Env, envs...)
+	}
+	var out, errout bytes.Buffer
+	cmd.Stdout = &out
+	cmd.Stderr = &errout
+	err := cmd.Run()
+	if err != nil{
+		color.Red(strings.TrimSpace(errout.String()))
+		return "", err
+	}
+	return strings.TrimSpace(out.String()), nil
+}

go/cli/commands/build_test.go

@@ -0,0 +1,136 @@
+package commands
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestBuild(t *testing.T) {
+	testcases := map[string]struct{
+		args []string
+		// expected args is key, and expected return is value
+		cmdExpected []string
+		// expected env var is key, and existence is value
+		lookPathExpected map[string]bool
+		expectedError string
+	}{
+		"default build is ko, ko already exists": {
+			args: []string{""},
+			cmdExpected: []string{
+				"KO_DOCKER_REPO=ko.local ko build -B --tags latest",
+			},
+			lookPathExpected: map[string]bool{
+				"ko": true,
+			},
+		},
+		"default build is ko, ko not exists": {
+			args: []string{""},
+			cmdExpected: []string{
+				"go install github.com/google/ko@latest",
+				"KO_DOCKER_REPO=ko.local ko build -B --tags latest",
+			},
+			lookPathExpected: map[string]bool{
+				"ko": false,
+			},
+		},
+		"ko as builder, specify repo": {
+			args: []string{"--repo=gcr.io/test"},
+			cmdExpected: []string{
+				"KO_DOCKER_REPO=gcr.io/test ko build -B --tags latest",
+			},
+			lookPathExpected: map[string]bool{
+				"ko": true,
+			},
+		},
+		"ko as builder, specify tag": {
+			args: []string{"--repo=gcr.io/test", "--tag=v1"},
+			cmdExpected: []string{
+				"KO_DOCKER_REPO=gcr.io/test ko build -B --tags v1",
+			},
+			lookPathExpected: map[string]bool{
+				"ko": true,
+			},
+		},
+		"docker as builder, docker not exists": {
+			args: []string{"--builder=docker"},
+			lookPathExpected: map[string]bool{
+				"docker": false,
+			},
+			expectedError: "kfn requires that `docker` is installed and on the PATH",
+		},
+		"docker as builder, docker exists": {
+			args: []string{"--builder=docker"},
+			cmdExpected: []string{
+				"docker build . -f Dockerfile --tag function:latest",
+			},
+			lookPathExpected: map[string]bool{
+				"docker": true,
+			},
+		},
+		"docker as builder, specify dockerfile": {
+			args: []string{"--builder=docker", "--dockerfile=tmp/Dockerfile"},
+			cmdExpected: []string{
+				"docker build . -f tmp/Dockerfile --tag function:latest",
+			},
+			lookPathExpected: map[string]bool{
+				"docker": true,
+			},
+		},
+		"docker as builder, specify image": {
+			args: []string{"--builder=docker", "--image=dockertest:latest", "--dockerfile=tmp/Dockerfile"},
+			cmdExpected: []string{
+				"docker build . -f tmp/Dockerfile --tag dockertest:latest",
+			},
+			lookPathExpected: map[string]bool{
+				"docker": true,
+			},
+		},
+	}
+	for name, test := range testcases{
+		r := NewBuildRunner(context.TODO())
+		execCmdFn = func(envs []string, name string, args... string) (string, error) {
+			fakeExecCmd(t, test.cmdExpected, envs, name, args...)
+			return "", nil
+		}
+		execLookPathFn = func(file string) (string, error) {
+			return "", fakeExecLookPath(t, test.lookPathExpected, file)
+		}
+		r.Command.SetArgs(test.args)
+		err := r.Command.Execute()
+		if test.expectedError == "" {
+			if err != nil {
+				t.Errorf("%v failed. got error: %v", name, err)
+			}
+		} else {
+			assert.EqualError(t, err, test.expectedError)
+		}
+	}
+}
+
+func fakeExecCmd(t *testing.T, expectedArgsAndReturns []string,  envs []string, name string, args... string) {
+	c := envs
+	c = append(c, name)
+	c = append(c, args...)
+	command := strings.Join(c, " ")
+	for _, expected:= range expectedArgsAndReturns {
+		if expected == command {
+			return
+		}
+	}
+	t.Fatalf("unexpected command run %v", command)
+}
+
+func fakeExecLookPath(t *testing.T, expectedlookPath map[string]bool, name string) error {
+	val, ok := expectedlookPath[name]
+	if !ok {
+		t.Fatalf("unexpected env var check %v", name)
+	}
+	if val {
+		return nil
+	}
+	return fmt.Errorf("env var not exists")
+}

go/cli/commands/init.go

@@ -29,7 +29,7 @@ const (
 	DefaultPkgName = "function"
 )
 
-func NewInitCmd(ctx context.Context) *cobra.Command {
+func NewInitRunner(ctx context.Context) *InitRunner {
 	r := &InitRunner{
 		ctx: ctx,
 	}
@@ -41,7 +41,7 @@ func NewInitCmd(ctx context.Context) *cobra.Command {
 	}
 	r.Command.Flags().StringVarP(&r.FnPkgPath, "fnPkg", "", DefaultFnPkg,
 		"a kpt package that contains a basic KRM function source code to get start")
-	return r.Command
+	return r
 }
 
 // InitRunner initializes a KRM function project from a scaffolded `kpt pkg`.