Allow users to override the Terraform version to use (#3069)

## Changes

Previously, the CLI would use the Terraform binary at
`DATABRICKS_TF_EXEC_PATH` only if the `DATABRICKS_TF_VERSION`
environment variable was set and matched the _built-in default version_.
It was built such that we could ship all binaries with the VS Code
extension to avoid re-downloading (see #1294).

This change expands the scope of these variables and makes them
composable. Now, you can:
1. Configure `DATABRICKS_TF_VERSION` to override the Terraform version
to use
2. Configure `DATABRICKS_TF_EXEC_PATH` to configure the path to an
existing Terraform binary

If 1 is used alone, the CLI will download the specified version. If 2 is
used alone, the CLI will execute the specified binary to confirm that it
matches the _built-in default version_. If both are used, the CLI will
execute the specified binary to confirm that it matches the specified
version.

## Why

To allow users to use newer version of the Terraform CLI.

## Tests

* Unit tests pass
* Integration tests with the latest Terraform version (#3040)

Author: pietern

NEXT_CHANGELOG.md

@@ -15,5 +15,6 @@
 * When building Python artifacts as part of "bundle deploy" we no longer delete `dist`, `build`, `*egg-info` and `__pycache__` directories. ([#2982](https://github.com/databricks/cli/pull/2982))
 * Fix variable resolution for lookup variables with other references ([#3054](https://github.com/databricks/cli/pull/3054))
 * Added preset `presets.artifacts_dynamic_version` that automatically enables `dynamic_version: true` on all "whl" artifacts.
+* Allow users to override the Terraform version to use by setting the `DATABRICKS_TF_VERSION` environment variable ([#3069](https://github.com/databricks/cli/pull/3069))
 
 ### API Changes

bundle/deploy/terraform/init.go

@@ -10,7 +10,6 @@ import (
 	"path/filepath"
 	"runtime"
 	"strings"
-	"time"
 
 	"github.com/databricks/cli/bundle"
 	"github.com/databricks/cli/bundle/config"
@@ -20,7 +19,6 @@ import (
 	"github.com/databricks/cli/libs/env"
 	"github.com/databricks/cli/libs/log"
 	"github.com/hashicorp/hc-install/product"
-	"github.com/hashicorp/hc-install/releases"
 	"github.com/hashicorp/terraform-exec/tfexec"
 	"golang.org/x/exp/maps"
 )
@@ -31,7 +29,7 @@ func (m *initialize) Name() string {
 	return "terraform.Initialize"
 }
 
-func (m *initialize) findExecPath(ctx context.Context, b *bundle.Bundle, tf *config.Terraform) (string, error) {
+func (m *initialize) findExecPath(ctx context.Context, b *bundle.Bundle, tf *config.Terraform, installer Installer) (string, error) {
 	// If set, pass it through [exec.LookPath] to resolve its absolute path.
 	if tf.ExecPath != "" {
 		execPath, err := exec.LookPath(tf.ExecPath)
@@ -43,13 +41,52 @@ func (m *initialize) findExecPath(ctx context.Context, b *bundle.Bundle, tf *con
 		return tf.ExecPath, nil
 	}
 
-	// Load exec path from the environment if it matches the currently used version.
-	envExecPath, err := getEnvVarWithMatchingVersion(ctx, TerraformExecPathEnv, TerraformVersionEnv, TerraformVersion.String())
+	// Resolve the version of the Terraform CLI to use.
+	tv, isDefault, err := GetTerraformVersion(ctx)
 	if err != nil {
 		return "", err
 	}
-	if envExecPath != "" {
-		tf.ExecPath = envExecPath
+
+	// Allow the user to specify the path to the Terraform CLI.
+	// If this is set, verify that the version matches the version we expect.
+	if execPathValue, ok := env.Lookup(ctx, TerraformExecPathEnv); ok {
+		tfe, err := getTerraformExec(ctx, b, execPathValue)
+		if err != nil {
+			return "", err
+		}
+
+		expectedVersion := tv.Version
+		actualVersion, _, err := tfe.Version(ctx, false)
+		if err != nil {
+			return "", fmt.Errorf("unable to execute %s: %w", TerraformExecPathEnv, err)
+		}
+
+		if !actualVersion.Equal(expectedVersion) {
+			if isDefault {
+				return "", fmt.Errorf(
+					"Terraform binary at %s (from $%s) is %s but expected version is %s. Set %s to %s to continue.",
+					execPathValue,
+					TerraformExecPathEnv,
+					actualVersion.String(),
+					expectedVersion.String(),
+					TerraformVersionEnv,
+					actualVersion.String(),
+				)
+			} else {
+				return "", fmt.Errorf(
+					"Terraform binary at %s (from $%s) is %s but expected version is %s (from $%s). Update $%s and $%s so that versions match.",
+					execPathValue,
+					TerraformExecPathEnv,
+					actualVersion.String(),
+					expectedVersion.String(),
+					TerraformVersionEnv,
+					TerraformExecPathEnv,
+					TerraformVersionEnv,
+				)
+			}
+		}
+
+		tf.ExecPath = execPathValue
 		log.Debugf(ctx, "Using Terraform from %s at %s", TerraformExecPathEnv, tf.ExecPath)
 		return tf.ExecPath, nil
 	}
@@ -72,13 +109,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:    TerraformVersion,
-		InstallDir: binDir,
-		Timeout:    1 * time.Minute,
-	}
-	execPath, err = installer.Install(ctx)
+	execPath, err = installer.Install(ctx, binDir, tv.Version)
 	if err != nil {
 		return "", fmt.Errorf("error downloading Terraform: %w", err)
 	}
@@ -251,24 +282,28 @@ func setUserAgentExtraEnvVar(environ map[string]string, b *bundle.Bundle) error
 	return nil
 }
 
+func getTerraformExec(ctx context.Context, b *bundle.Bundle, execPath string) (*tfexec.Terraform, error) {
+	workingDir, err := Dir(ctx, b)
+	if err != nil {
+		return nil, err
+	}
+
+	return tfexec.NewTerraform(workingDir, execPath)
+}
+
 func (m *initialize) Apply(ctx context.Context, b *bundle.Bundle) diag.Diagnostics {
 	tfConfig := b.Config.Bundle.Terraform
 	if tfConfig == nil {
 		tfConfig = &config.Terraform{}
 		b.Config.Bundle.Terraform = tfConfig
 	}
 
-	execPath, err := m.findExecPath(ctx, b, tfConfig)
-	if err != nil {
-		return diag.FromErr(err)
-	}
-
-	workingDir, err := Dir(ctx, b)
+	execPath, err := m.findExecPath(ctx, b, tfConfig, tfInstaller{})
 	if err != nil {
 		return diag.FromErr(err)
 	}
 
-	tf, err := tfexec.NewTerraform(workingDir, execPath)
+	tfe, err := getTerraformExec(ctx, b, execPath)
 	if err != nil {
 		return diag.FromErr(err)
 	}
@@ -302,12 +337,12 @@ func (m *initialize) Apply(ctx context.Context, b *bundle.Bundle) diag.Diagnosti
 
 	// Configure environment variables for auth for Terraform to use.
 	log.Debugf(ctx, "Environment variables for Terraform: %s", strings.Join(maps.Keys(environ), ", "))
-	err = tf.SetEnv(environ)
+	err = tfe.SetEnv(environ)
 	if err != nil {
 		return diag.FromErr(err)
 	}
 
-	b.Terraform = tf
+	b.Terraform = tfe
 	return nil
 }