Kpt Deployer Deploy() Implementation/Tests

pkg/skaffold/deploy/kpt.go

@@ -31,6 +31,7 @@ import (
 	"github.com/GoogleContainerTools/skaffold/pkg/skaffold/build"
 	"github.com/GoogleContainerTools/skaffold/pkg/skaffold/config"
 	deploy "github.com/GoogleContainerTools/skaffold/pkg/skaffold/deploy/kubectl"
+	"github.com/GoogleContainerTools/skaffold/pkg/skaffold/event"
 	"github.com/GoogleContainerTools/skaffold/pkg/skaffold/runner/runcontext"
 	"github.com/GoogleContainerTools/skaffold/pkg/skaffold/schema/latest"
 	"github.com/GoogleContainerTools/skaffold/pkg/skaffold/util"
@@ -60,8 +61,40 @@ func NewKptDeployer(runCtx *runcontext.RunContext, labels map[string]string) *Kp
 	}
 }
 
+// Deploy hydrates the manifests using kustomizations and kpt functions as described in the render method,
+// outputs them to the applyDir, and runs `kpt live apply` against applyDir to create resources in the cluster.
+// `kpt live apply` supports automated pruning declaratively via resources in the applyDir.
 func (k *KptDeployer) Deploy(ctx context.Context, out io.Writer, builds []build.Artifact) ([]string, error) {
-	return nil, nil
+	manifests, err := k.renderManifests(ctx, out, builds)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(manifests) == 0 {
+		return nil, nil
+	}
+
+	namespaces, err := manifests.CollectNamespaces()
+	if err != nil {
+		event.DeployInfoEvent(fmt.Errorf("could not fetch deployed resource namespace. "+
+			"This might cause port-forward and deploy health-check to fail: %w", err))
+	}
+
+	applyDir, err := k.getApplyDir(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("getting applyDir: %w", err)
+	}
+
+	outputRenderedManifests(manifests.String(), filepath.Join(applyDir, "resources.yaml"), out)
+
+	cmd := exec.CommandContext(ctx, "kpt", kptCommandArgs(applyDir, []string{"live", "apply"}, k.Live.Apply, nil)...)
+	cmd.Stdout = out
+	cmd.Stderr = out
+	if err := util.RunCmd(cmd); err != nil {
+		return nil, err
+	}
+
+	return namespaces, nil
 }
 
 // Dependencies returns a list of files that the deployer depends on. This does NOT include applyDir.
@@ -91,17 +124,17 @@ func (k *KptDeployer) Dependencies() ([]string, error) {
 }
 
 // Cleanup deletes what was deployed by calling `kpt live destroy`.
-func (k *KptDeployer) Cleanup(ctx context.Context, _ io.Writer) error {
+func (k *KptDeployer) Cleanup(ctx context.Context, out io.Writer) error {
 	applyDir, err := k.getApplyDir(ctx)
 	if err != nil {
 		return fmt.Errorf("getting applyDir: %w", err)
 	}
 
 	cmd := exec.CommandContext(ctx, "kpt", kptCommandArgs(applyDir, []string{"live", "destroy"}, nil, nil)...)
-	out, err := util.RunCmdOut(cmd)
-	if err != nil {
-		// Kpt errors are written in STDOUT and surrounded by `\n`.
-		return fmt.Errorf("kpt live destroy: %s", strings.Trim(string(out), "\n"))
+	cmd.Stdout = out
+	cmd.Stderr = out
+	if err := util.RunCmd(cmd); err != nil {
+		return err
 	}
 
 	return nil

pkg/skaffold/deploy/kpt_test.go

@@ -36,20 +36,114 @@ import (
 )
 
 func TestKpt_Deploy(t *testing.T) {
+	output := `apiVersion: v1
+kind: Pod
+metadata:
+  namespace: default
+spec:
+  containers:
+  - image: gcr.io/project/image1
+    name: image1
+`
 	tests := []struct {
-		description string
-		expected    []string
-		shouldErr   bool
+		description    string
+		builds         []build.Artifact
+		cfg            *latest.KptDeploy
+		kustomizations map[string]string
+		commands       util.Command
+		expected       []string
+		shouldErr      bool
 	}{
 		{
-			description: "nil",
+			description: "no manifest",
+			cfg: &latest.KptDeploy{
+				Dir: ".",
+			},
+			commands: testutil.
+				CmdRunOut("kpt fn source .", ``).
+				AndRunOut("kpt fn sink .pipeline", ``).
+				AndRunOut("kpt fn run .pipeline --dry-run", ``),
+		},
+		{
+			description: "invalid manifest",
+			cfg: &latest.KptDeploy{
+				Dir: ".",
+			},
+			commands: testutil.
+				CmdRunOut("kpt fn source .", ``).
+				AndRunOut("kpt fn sink .pipeline", ``).
+				AndRunOut("kpt fn run .pipeline --dry-run", `foo`),
+			shouldErr: true,
+		},
+		{
+			description: "invalid user specified applyDir",
+			cfg: &latest.KptDeploy{
+				Dir:      ".",
+				ApplyDir: "invalid_path",
+			},
+			commands: testutil.
+				CmdRunOut("kpt fn source .", ``).
+				AndRunOut("kpt fn sink .pipeline", ``).
+				AndRunOut("kpt fn run .pipeline --dry-run", output),
+			shouldErr: true,
+		},
+		{
+			description: "kustomization and specified kpt fn",
+			cfg: &latest.KptDeploy{
+				Dir:      ".",
+				Fn:       latest.KptFn{FnPath: "kpt-func.yaml"},
+				ApplyDir: "valid_path",
+			},
+			kustomizations: map[string]string{"Kustomization": `resources:
+- foo.yaml`},
+			commands: testutil.
+				CmdRunOut("kpt fn source .", ``).
+				AndRunOut("kpt fn sink .pipeline", ``).
+				AndRunOut("kustomize build -o .pipeline .", ``).
+				AndRunOut("kpt fn run .pipeline --dry-run --fn-path kpt-func.yaml", output).
+				AndRun("kpt live apply valid_path"),
+			expected: []string{"default"},
+		},
+		{
+			description: "kpt live apply fails",
+			cfg: &latest.KptDeploy{
+				Dir: ".",
+			},
+			commands: testutil.
+				CmdRunOut("kpt fn source .", ``).
+				AndRunOut("kpt fn sink .pipeline", ``).
+				AndRunOut("kpt fn run .pipeline --dry-run", output).
+				AndRunOut("kpt live init .kpt-hydrated", ``).
+				AndRunErr("kpt live apply .kpt-hydrated", errors.New("BUG")),
+			shouldErr: true,
 		},
 	}
 	for _, test := range tests {
 		testutil.Run(t, test.description, func(t *testutil.T) {
-			k := NewKptDeployer(&runcontext.RunContext{}, nil)
-			res, err := k.Deploy(context.Background(), nil, nil)
-			t.CheckErrorAndDeepEqual(test.shouldErr, err, test.expected, res)
+			t.Override(&util.DefaultExecCommand, test.commands)
+			tmpDir := t.NewTempDir().Chdir()
+
+			tmpDir.WriteFiles(test.kustomizations)
+
+			k := NewKptDeployer(&runcontext.RunContext{
+				Cfg: latest.Pipeline{
+					Deploy: latest.DeployConfig{
+						DeployType: latest.DeployType{
+							KptDeploy: test.cfg,
+						},
+					},
+				},
+			}, nil)
+
+			if k.ApplyDir == "valid_path" {
+				// 0755 is a permission setting where the owner can read, write, and execute.
+				// Others can read and execute but not modify the directory.
+				os.Mkdir(k.ApplyDir, 0755)
+			}
+
+			_, err := k.Deploy(context.Background(), ioutil.Discard, test.builds)
+
+			t.CheckError(test.shouldErr, err)
 		})
 	}
 }
@@ -194,19 +288,19 @@ func TestKpt_Cleanup(t *testing.T) {
 		{
 			description: "valid user specified applyDir w/o template resource",
 			applyDir:    "valid_path",
-			commands:    testutil.CmdRunOutErr("kpt live destroy valid_path", "", errors.New("BUG")),
+			commands:    testutil.CmdRunErr("kpt live destroy valid_path", errors.New("BUG")),
 			shouldErr:   true,
 		},
 		{
 			description: "valid user specified applyDir w/ template resource (emulated)",
 			applyDir:    "valid_path",
-			commands:    testutil.CmdRunOut("kpt live destroy valid_path", ""),
+			commands:    testutil.CmdRun("kpt live destroy valid_path"),
 		},
 		{
 			description: "unspecified applyDir",
 			commands: testutil.
 				CmdRunOut("kpt live init .kpt-hydrated", "").
-				AndRunOut("kpt live destroy .kpt-hydrated", ""),
+				AndRun("kpt live destroy .kpt-hydrated"),
 		},
 	}
 	for _, test := range tests {