WIP: destroy mutator + test (pipelines only); Graph is now generic

Author: denik

acceptance/bin/read_state.py

@@ -30,7 +30,7 @@ def print_resource_terraform(section, name, *attrs):
                 print(section, name, " ".join(values))
                 found += 1
     if not found:
-        print(f"Resource {section=} {name=} {resource_type=} not found. Available: {raw}")
+        print(f"State not found for {section}.{name}")
 
 
 def print_resource_terranova(section, name, *attrs):
@@ -40,7 +40,7 @@ def print_resource_terranova(section, name, *attrs):
     resources = data["resources"].get(section, {})
     result = resources.get(name)
     if result is None:
-        print(f"Resource {section=} {name=} not found. Available: {raw}")
+        print(f"State not found for {section}.{name}")
         return
     state = result["state"]
     state.setdefault("id", result.get("__id__"))

acceptance/bundle/resources/pipelines/output.txt

@@ -36,6 +36,7 @@ Deploying resources...
 Updating deployment state...
 Deployment complete!
 
+=== Fetch pipeline ID and verify remote state
 >>> [CLI] pipelines get [UUID]
 {
   "creator_user_name":"[USERNAME]",
@@ -63,3 +64,25 @@ Deployment complete!
   },
   "state":"IDLE"
 }
+
+=== Destroy the pipeline and verify that it's removed from the state and from remote
+>>> [CLI] bundle destroy --auto-approve
+The following resources will be deleted:
+  delete pipeline my
+
+All files and directories at the following location will be deleted: /Workspace/Users/[USERNAME]/.bundle/acc-[UNIQUE_NAME]/default
+
+Deleting files...
+Destroy complete!
+
+>>> print_requests
+{
+  "method": "DELETE",
+  "path": "/api/2.0/pipelines/[UUID]"
+}
+State not found for pipelines.my
+
+>>> musterr [CLI] pipelines get [UUID]
+Error: Not Found
+
+Exit code (musterr): 1

acceptance/bundle/resources/pipelines/script

@@ -5,8 +5,8 @@ trace $CLI bundle deploy
 
 print_requests() {
     jq --sort-keys 'select(.method != "GET" and (.path | contains("/pipelines")))' < out.requests.txt
-    rm out.requests.txt
-    read_state.py pipelines my id name
+    errcode rm out.requests.txt
+    errcode read_state.py pipelines my id name
 }
 
 trace print_requests
@@ -17,6 +17,18 @@ trace $CLI bundle deploy
 # fields that it previously recevied from the backend.
 # The get call below verifies that it does not matter -- the pipeline is the same in the end.
 #trace print_requests
+rm out.requests.txt
+
+title "Fetch pipeline ID and verify remote state"
+
+ppid=`read_id.py pipelines my`
+
+trace $CLI pipelines get $ppid
+rm out.requests.txt
+
+title "Destroy the pipeline and verify that it's removed from the state and from remote"
+trace $CLI bundle destroy --auto-approve
+trace print_requests
 
-trace $CLI pipelines get $(read_id.py pipelines my)
+trace musterr $CLI pipelines get $ppid
 rm out.requests.txt

acceptance/script.prepare

@@ -11,6 +11,21 @@ errcode() {
     fi
 }
 
+musterr() {
+    # Temporarily disable 'set -e' to prevent the script from exiting on error
+    set +e
+    # Execute the provided command with all arguments
+    "$@"
+    local exit_code=$?
+    # Re-enable 'set -e' if it was previously set
+    set -e
+    if [ $exit_code -eq 0 ]; then
+        >&2 printf "\nUnexpected success\n"
+        exit 1
+    fi
+    >&2 printf "\nExit code (musterr): $exit_code\n"
+}
+
 trace() {
     >&2 printf "\n>>> %s\n" "$*"
 

bundle/phases/destroy.go

@@ -4,11 +4,13 @@ import (
 	"context"
 	"errors"
 	"net/http"
+	"strings"
 
 	"github.com/databricks/cli/bundle"
 	"github.com/databricks/cli/bundle/deploy/files"
 	"github.com/databricks/cli/bundle/deploy/lock"
 	"github.com/databricks/cli/bundle/deploy/terraform"
+	"github.com/databricks/cli/bundle/terranova"
 
 	"github.com/databricks/cli/libs/cmdio"
 	"github.com/databricks/cli/libs/diag"
@@ -31,16 +33,31 @@ func assertRootPathExists(ctx context.Context, b *bundle.Bundle) (bool, error) {
 	return true, err
 }
 
-func approvalForDestroy(ctx context.Context, b *bundle.Bundle) (bool, error) {
+func getDeleteActions(ctx context.Context, b *bundle.Bundle) ([]terraformlib.Action, error) {
+	if b.DirectDeployment {
+		allResources := b.ResourceDatabase.GetAllResources()
+		var deleteActions []terraformlib.Action
+		for _, node := range allResources {
+			rType, _ := strings.CutSuffix(node.Section, "s")
+			deleteActions = append(deleteActions, terraformlib.Action{
+				Action:       terraformlib.ActionTypeDelete,
+				ResourceType: rType,
+				ResourceName: node.Name,
+			})
+		}
+		return deleteActions, nil
+	}
+
 	tf := b.Terraform
+
 	if tf == nil {
-		return false, errors.New("terraform not initialized")
+		return nil, errors.New("terraform not initialized")
 	}
 
 	// read plan file
 	plan, err := tf.ShowPlanFile(ctx, b.Plan.Path)
 	if err != nil {
-		return false, err
+		return nil, err
 	}
 
 	var deleteActions []terraformlib.Action
@@ -54,6 +71,12 @@ func approvalForDestroy(ctx context.Context, b *bundle.Bundle) (bool, error) {
 		}
 	}
 
+	return deleteActions, nil
+}
+
+func approvalForDestroy(ctx context.Context, b *bundle.Bundle) (bool, error) {
+	deleteActions, err := getDeleteActions(ctx, b)
+
 	if len(deleteActions) > 0 {
 		cmdio.LogString(ctx, "The following resources will be deleted:")
 		for _, a := range deleteActions {
@@ -79,11 +102,20 @@ func approvalForDestroy(ctx context.Context, b *bundle.Bundle) (bool, error) {
 }
 
 func destroyCore(ctx context.Context, b *bundle.Bundle) diag.Diagnostics {
-	// Core destructive mutators for destroy. These require informed user consent.
-	diags := bundle.ApplySeq(ctx, b,
-		terraform.Apply(),
-		files.Delete(),
-	)
+	var diags diag.Diagnostics
+
+	if b.DirectDeployment {
+		diags = bundle.Apply(ctx, b, terranova.TerranovaDestroy())
+	} else {
+		// Core destructive mutators for destroy. These require informed user consent.
+		diags = bundle.Apply(ctx, b, terraform.Apply())
+	}
+
+	if diags.HasError() {
+		return diags
+	}
+
+	diags = diags.Extend(bundle.Apply(ctx, b, files.Delete()))
 
 	if !diags.HasError() {
 		cmdio.LogString(ctx, "Destroy complete!")
@@ -115,12 +147,14 @@ func Destroy(ctx context.Context, b *bundle.Bundle) (diags diag.Diagnostics) {
 		diags = diags.Extend(bundle.Apply(ctx, b, lock.Release(lock.GoalDestroy)))
 	}()
 
-	diags = diags.Extend(bundle.ApplySeq(ctx, b,
-		terraform.StatePull(),
-		terraform.Interpolate(),
-		terraform.Write(),
-		terraform.Plan(terraform.PlanGoal("destroy")),
-	))
+	if !b.DirectDeployment {
+		diags = diags.Extend(bundle.ApplySeq(ctx, b,
+			terraform.StatePull(),
+			terraform.Interpolate(),
+			terraform.Write(),
+			terraform.Plan(terraform.PlanGoal("destroy")),
+		))
+	}
 
 	if diags.HasError() {
 		return diags

bundle/phases/initialize.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"os"
+	"path/filepath"
 
 	"github.com/databricks/cli/bundle/config/mutator/resourcemutator"
 
@@ -206,6 +207,17 @@ func Initialize(ctx context.Context, b *bundle.Bundle) diag.Diagnostics {
 			b.Config.Bundle.Terraform = &config.Terraform{ExecPath: " "}
 			return nil
 		})
+
+		cacheDir, err := b.CacheDir(ctx)
+		if err != nil {
+			diags = diags.Extend(diag.FromErr(err))
+		}
+
+		databasePath := filepath.Join(cacheDir, "resources.json")
+		err = b.ResourceDatabase.Open(databasePath)
+		if err != nil {
+			diags = diags.Extend(diag.FromErr(err))
+		}
 	} else {
 		// Reads (typed): b.Config.Bundle.Terraform (checks terraform configuration)
 		// Updates (typed): b.Config.Bundle.Terraform (sets default values if not already set)

bundle/terranova/deploy_mutator.go

@@ -3,8 +3,6 @@ package terranova
 import (
 	"context"
 	"fmt"
-	"path/filepath"
-	"strings"
 
 	"github.com/databricks/cli/bundle"
 	"github.com/databricks/cli/bundle/terranova/terranova_resources"
@@ -35,28 +33,19 @@ func (m *terranovaDeployMutator) Apply(ctx context.Context, b *bundle.Bundle) di
 
 	client := b.WorkspaceClient()
 
-	cacheDir, err := b.CacheDir(ctx)
-	if err != nil {
-		return diag.FromErr(err)
-	}
-
-	databasePath := filepath.Join(cacheDir, "resources.json")
-	err = b.ResourceDatabase.Open(databasePath)
-	if err != nil {
-		return diag.FromErr(err)
-	}
+	g := dag.NewGraph[terranova_state.ResourceNode]()
 
-	g := dag.NewGraph()
-
-	_, err = dyn.MapByPattern(
+	_, err := dyn.MapByPattern(
 		b.Config.Value(),
 		dyn.NewPattern(dyn.Key("resources"), dyn.AnyKey(), dyn.AnyKey()),
 		func(p dyn.Path, v dyn.Value) (dyn.Value, error) {
 			section := p[1].Key()
-			resourceName := p[2].Key()
-			node := section + "." + resourceName
+			name := p[2].Key()
 			// log.Warnf(ctx, "Adding node=%s", node)
-			g.AddNode(node)
+			g.AddNode(terranova_state.ResourceNode{
+				Section: section,
+				Name:    name,
+			})
 
 			// TODO: Scan v for references and use g.AddDirectedEdge to add dependency
 			return v, nil
@@ -65,25 +54,16 @@ func (m *terranovaDeployMutator) Apply(ctx context.Context, b *bundle.Bundle) di
 
 	countDeployed := 0
 
-	err = g.Run(maxPoolSize, func(node string) {
+	err = g.Run(maxPoolSize, func(node terranova_state.ResourceNode) {
 		// TODO func(node string) bool
 		// If function returns false, downstream callers are not called
 		// g.Run() should return list of not executed nodes
 		// log.Warnf(ctx, "Processing node=%s", node)
 
-		items := strings.SplitN(node, ".", 2)
-		if len(items) != 2 {
-			diags.AppendErrorf("internal error: unexpected DAG node %#v", node)
-			return
-		}
-
-		section := items[0]
-		name := items[1]
-
 		// TODO: resolve all resource references inside this resource. It should be possible, if graph was constructed correctly.
 		// If it is not possible, return error (and fail this and dependent resources)
 
-		config, ok := b.GetResourceConfig(section, name)
+		config, ok := b.GetResourceConfig(node.Section, node.Name)
 		if !ok {
 			diags.AppendErrorf("internal error: cannot get config for %s", node)
 			return
@@ -92,8 +72,8 @@ func (m *terranovaDeployMutator) Apply(ctx context.Context, b *bundle.Bundle) di
 		d := Deployer{
 			client:       client,
 			db:           &b.ResourceDatabase,
-			section:      section,
-			resourceName: name,
+			section:      node.Section,
+			resourceName: node.Name,
 		}
 
 		err = d.Deploy(ctx, config)

bundle/terranova/destroy_mutator.go

@@ -0,0 +1,57 @@
+package terranova
+
+import (
+	"context"
+
+	"github.com/databricks/cli/bundle"
+	"github.com/databricks/cli/bundle/terranova/terranova_resources"
+	"github.com/databricks/cli/bundle/terranova/terranova_state"
+	"github.com/databricks/cli/libs/dag"
+	"github.com/databricks/cli/libs/diag"
+)
+
+type terranovaDestroyMutator struct{}
+
+func TerranovaDestroy() bundle.Mutator {
+	return &terranovaDestroyMutator{}
+}
+
+func (m *terranovaDestroyMutator) Name() string {
+	return "TerranovaDestroy"
+}
+
+func (m *terranovaDestroyMutator) Apply(ctx context.Context, b *bundle.Bundle) diag.Diagnostics {
+	var diags diag.SafeDiagnostics
+	client := b.WorkspaceClient()
+
+	allResources := b.ResourceDatabase.GetAllResources()
+	g := dag.NewGraph[terranova_state.ResourceNode]()
+
+	for _, node := range allResources {
+		g.AddNode(node)
+	}
+
+	// TODO: respect dependencies; dependencies need to be part of state, not config.
+
+	err := g.Run(maxPoolSize, func(node terranova_state.ResourceNode) {
+		err := terranova_resources.DestroyResource(ctx, client, node.Section, node.ID)
+		if err != nil {
+			diags.AppendErrorf("destroying %s: %s", node, err)
+			return
+		}
+		// TODO: did DestroyResource fail because it did not exist? we can clean it up from the state as well
+
+		err = b.ResourceDatabase.DeleteState(node.Section, node.Name)
+		if err != nil {
+			diags.AppendErrorf("deleting from the state %s: %s", node, err)
+			return
+		}
+	})
+	if err != nil {
+		diags.AppendError(err)
+	}
+
+	_ = b.ResourceDatabase.Finalize()
+
+	return diags.Diags
+}

bundle/terranova/terranova_resources/app.go

@@ -15,8 +15,8 @@ type ResourceApp struct {
 	config apps.App
 }
 
-func NewResourceApp(client *databricks.WorkspaceClient, config resources.App) (ResourceApp, error) {
-	return ResourceApp{
+func NewResourceApp(client *databricks.WorkspaceClient, config resources.App) (*ResourceApp, error) {
+	return &ResourceApp{
 		client: client,
 		config: config.App,
 	}, nil