Add bundle debug terraform command

bundle/deploy/terraform/init.go

@@ -14,7 +14,6 @@ import (
 	"github.com/databricks/cli/bundle/config"
 	"github.com/databricks/cli/libs/env"
 	"github.com/databricks/cli/libs/log"
-	"github.com/hashicorp/go-version"
 	"github.com/hashicorp/hc-install/product"
 	"github.com/hashicorp/hc-install/releases"
 	"github.com/hashicorp/terraform-exec/tfexec"
@@ -28,6 +27,21 @@ func (m *initialize) Name() string {
 }
 
 func (m *initialize) findExecPath(ctx context.Context, b *bundle.Bundle, tf *config.Terraform) (string, error) {
+	// Load exec path from the environment if it matches the currently used version.
+	envTFVersion := env.Get(ctx, "DATABRICKS_TF_VERSION")
+	envExecPath := env.Get(ctx, "DATABRICKS_TF_EXEC_PATH")
+	if envExecPath != "" && envTFVersion == TerraformVersion.String() {
+		_, err := os.Stat(envExecPath)
+		if err != nil && !os.IsNotExist(err) {
+			return "", err
+		}
+		if err == nil {
+			tf.ExecPath = envExecPath
+			log.Debugf(ctx, "Using Terraform from the environment at %s", tf.ExecPath)
+			return tf.ExecPath, nil
+		}
+	}
+
 	// If set, pass it through [exec.LookPath] to resolve its absolute path.
 	if tf.ExecPath != "" {
 		execPath, err := exec.LookPath(tf.ExecPath)
@@ -59,7 +73,7 @@ func (m *initialize) findExecPath(ctx context.Context, b *bundle.Bundle, tf *con
 	// Download Terraform to private bin directory.
 	installer := &releases.ExactVersion{
 		Product:    product.Terraform,
-		Version:    version.Must(version.NewVersion("1.5.5")),
+		Version:    TerraformVersion,
 		InstallDir: binDir,
 		Timeout:    1 * time.Minute,
 	}
@@ -102,6 +116,20 @@ func inheritEnvVars(ctx context.Context, environ map[string]string) error {
 		environ["TF_CLI_CONFIG_FILE"] = configFile
 	}
 
+	// Map $DATABRICKS_TF_PLUGIN_CACHE_DIR to $TF_PLUGIN_CACHE_DIR
+	// This lets terraform use pre-downloaded Databricks plugins
+	cacheDir, ok := env.Lookup(ctx, "DATABRICKS_TF_PLUGIN_CACHE_DIR")
+	if ok {
+		_, err := os.Stat(cacheDir)
+		if err != nil && !os.IsNotExist(err) {
+			return err
+		}
+		if err == nil {
+			log.Debugf(ctx, "Using Terraform plugin cache dir: %s", cacheDir)
+			environ["TF_PLUGIN_CACHE_DIR"] = cacheDir
+		}
+	}
+
 	return nil
 }
 

bundle/deploy/terraform/init_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"os"
 	"os/exec"
+	"path/filepath"
 	"runtime"
 	"strings"
 	"testing"
@@ -269,3 +270,83 @@ func TestSetUserProfileFromInheritEnvVars(t *testing.T) {
 	assert.Contains(t, env, "USERPROFILE")
 	assert.Equal(t, env["USERPROFILE"], "c:\\foo\\c")
 }
+
+func TestInheritEnvVarsWithAbsentPluginsCacheDir(t *testing.T) {
+	env := map[string]string{}
+	t.Setenv("DATABRICKS_TF_PLUGIN_CACHE_DIR", "/tmp/cache")
+	err := inheritEnvVars(context.Background(), env)
+	require.NoError(t, err)
+	require.NotContains(t, env, "TF_PLUGIN_CACHE_DIR")
+}
+
+func TestInheritEnvVarsWithRealPluginsCacheDir(t *testing.T) {
+	env := map[string]string{}
+	dir := t.TempDir()
+	t.Setenv("DATABRICKS_TF_PLUGIN_CACHE_DIR", dir)
+	err := inheritEnvVars(context.Background(), env)
+	require.NoError(t, err)
+	require.Equal(t, dir, env["TF_PLUGIN_CACHE_DIR"])
+}
+
+func TestFindExecPathFromEnvironmentWithWrongVersion(t *testing.T) {
+	m := &initialize{}
+	b := &bundle.Bundle{
+		Config: config.Root{
+			Path: t.TempDir(),
+			Bundle: config.Bundle{
+				Target: "whatever",
+				Terraform: &config.Terraform{
+					ExecPath: "terraform",
+				},
+			},
+		},
+	}
+	t.Setenv("DATABRICKS_TF_VERSION", "1.2.3")
+	t.Setenv("DATABRICKS_TF_EXEC_PATH", "/tmp/terraform")
+	_, err := m.findExecPath(context.Background(), b, b.Config.Bundle.Terraform)
+	require.NoError(t, err)
+	require.NotEqual(t, "/tmp/terraform", b.Config.Bundle.Terraform.ExecPath)
+}
+
+func TestFindExecPathFromEnvironmentWithCorrectVersionAndNoBinary(t *testing.T) {
+	m := &initialize{}
+	b := &bundle.Bundle{
+		Config: config.Root{
+			Path: t.TempDir(),
+			Bundle: config.Bundle{
+				Target: "whatever",
+				Terraform: &config.Terraform{
+					ExecPath: "terraform",
+				},
+			},
+		},
+	}
+	t.Setenv("DATABRICKS_TF_VERSION", TerraformVersion.String())
+	t.Setenv("DATABRICKS_TF_EXEC_PATH", "/tmp/terraform")
+	_, err := m.findExecPath(context.Background(), b, b.Config.Bundle.Terraform)
+	require.NoError(t, err)
+	require.NotEqual(t, "/tmp/terraform", b.Config.Bundle.Terraform.ExecPath)
+}
+
+func TestFindExecPathFromEnvironmentWithCorrectVersionAndBinary(t *testing.T) {
+	m := &initialize{}
+	b := &bundle.Bundle{
+		Config: config.Root{
+			Path: t.TempDir(),
+			Bundle: config.Bundle{
+				Target: "whatever",
+				Terraform: &config.Terraform{
+					ExecPath: "terraform",
+				},
+			},
+		},
+	}
+	tmpBinPath := filepath.Join(t.TempDir(), "terraform")
+	_, err := os.Create(tmpBinPath)
+	require.NoError(t, err)
+	t.Setenv("DATABRICKS_TF_VERSION", TerraformVersion.String())
+	t.Setenv("DATABRICKS_TF_EXEC_PATH", tmpBinPath)
+	_, err = m.findExecPath(context.Background(), b, b.Config.Bundle.Terraform)
+	require.NoError(t, err)
+	require.Equal(t, tmpBinPath, b.Config.Bundle.Terraform.ExecPath)
+}

bundle/deploy/terraform/pkg.go

@@ -1,4 +1,27 @@
 package terraform
 
+import (
+	"github.com/databricks/cli/bundle/internal/tf/schema"
+	"github.com/hashicorp/go-version"
+)
+
 const TerraformStateFileName = "terraform.tfstate"
 const TerraformConfigFileName = "bundle.tf.json"
+
+var TerraformVersion = version.Must(version.NewVersion("1.5.5"))
+
+type TerraformMetadata struct {
+	Version         string `json:"version"`
+	ProviderHost    string `json:"provider_host"`
+	ProviderSource  string `json:"provider_source"`
+	ProviderVersion string `json:"provider_version"`
+}
+
+func NewTerraformMetadata() *TerraformMetadata {
+	return &TerraformMetadata{
+		Version:         TerraformVersion.String(),
+		ProviderHost:    schema.ProviderHost,
+		ProviderSource:  schema.ProviderSource,
+		ProviderVersion: schema.ProviderVersion,
+	}
+}

bundle/internal/tf/codegen/templates/root.go.tmpl

@@ -19,13 +19,17 @@ type Root struct {
 	Resource *Resources   `json:"resource,omitempty"`
 }
 
+const ProviderHost = "registry.terraform.io"
+const ProviderSource = "databricks/databricks"
+const ProviderVersion = "{{ .ProviderVersion }}"
+
 func NewRoot() *Root {
 	return &Root{
 		Terraform: map[string]interface{}{
 			"required_providers": map[string]interface{}{
 				"databricks": map[string]interface{}{
-					"source":  "databricks/databricks",
-					"version": "{{ .ProviderVersion }}",
+					"source": ProviderSource,
+					"version": ProviderVersion,
 				},
 			},
 		},

bundle/internal/tf/schema/root.go

@@ -19,13 +19,17 @@ type Root struct {
 	Resource *Resources   `json:"resource,omitempty"`
 }
 
+const ProviderHost = "registry.terraform.io"
+const ProviderSource = "databricks/databricks"
+const ProviderVersion = "1.37.0"
+
 func NewRoot() *Root {
 	return &Root{
 		Terraform: map[string]interface{}{
 			"required_providers": map[string]interface{}{
 				"databricks": map[string]interface{}{
-					"source":  "databricks/databricks",
-					"version": "1.37.0",
+					"source":  ProviderSource,
+					"version": ProviderVersion,
 				},
 			},
 		},

cmd/bundle/bundle.go

@@ -24,6 +24,7 @@ func New() *cobra.Command {
 	cmd.AddCommand(newValidateCommand())
 	cmd.AddCommand(newInitCommand())
 	cmd.AddCommand(newSummaryCommand())
+	cmd.AddCommand(newDependenciesCommand())
 	cmd.AddCommand(newGenerateCommand())
 	cmd.AddCommand(deployment.NewDeploymentCommand())
 	return cmd

cmd/bundle/dependencies.go

@@ -0,0 +1,48 @@
+package bundle
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+
+	"github.com/databricks/cli/bundle/deploy/terraform"
+	"github.com/databricks/cli/cmd/root"
+	"github.com/databricks/cli/libs/flags"
+	"github.com/spf13/cobra"
+)
+
+type Dependencies struct {
+	Terraform *terraform.TerraformMetadata `json:"terraform"`
+}
+
+func newDependenciesCommand() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "dependencies",
+		Short: "Prints CLI dependencies required for the bundle namespace",
+		Args:  root.NoArgs,
+		// This command is currently intended for the Databricks VSCode extension only
+		Hidden: true,
+	}
+
+	cmd.RunE = func(cmd *cobra.Command, args []string) error {
+		dependencies := &Dependencies{
+			Terraform: terraform.NewTerraformMetadata(),
+		}
+		switch root.OutputType(cmd) {
+		case flags.OutputText:
+			return fmt.Errorf("%w, only json output is supported", errors.ErrUnsupported)
+		case flags.OutputJSON:
+			buf, err := json.MarshalIndent(dependencies, "", "  ")
+			if err != nil {
+				return err
+			}
+			cmd.OutOrStdout().Write(buf)
+		default:
+			return fmt.Errorf("unknown output type %s", root.OutputType(cmd))
+		}
+
+		return nil
+	}
+
+	return cmd
+}