change terraform download warning to debug log

hugodutka · hugodutka · commit d3162e60aace · 2025-02-20T13:10:11.000Z
diff --git a/provisioner/terraform/install.go b/provisioner/terraform/install.go
@@ -2,8 +2,10 @@ package terraform
 
 import (
 	"context"
+	"fmt"
 	"os"
 	"path/filepath"
+	"sync/atomic"
 	"time"
 
 	"github.com/gofrs/flock"
@@ -30,7 +32,9 @@ var (
 
 // Install implements a thread-safe, idempotent Terraform Install
 // operation.
-func Install(ctx context.Context, log slog.Logger, dir string, wantVersion *version.Version) (string, error) {
+//
+//nolint:revive // verbose is a control flag that controls the verbosity of the log output.
+func Install(ctx context.Context, log slog.Logger, verbose bool, dir string, wantVersion *version.Version) (string, error) {
 	err := os.MkdirAll(dir, 0o750)
 	if err != nil {
 		return "", err
@@ -64,13 +68,37 @@ func Install(ctx context.Context, log slog.Logger, dir string, wantVersion *vers
 		Version:    TerraformVersion,
 	}
 	installer.SetLogger(slog.Stdlib(ctx, log, slog.LevelDebug))
-	log.Debug(
-		ctx,
-		"installing terraform",
+
+	logInstall := log.Debug
+	if verbose {
+		logInstall = log.Info
+	}
+
+	logInstall(ctx, "installing terraform",
 		slog.F("prev_version", hasVersionStr),
 		slog.F("dir", dir),
-		slog.F("version", TerraformVersion),
-	)
+		slog.F("version", TerraformVersion))
+
+	prolongedInstall := atomic.Bool{}
+	prolongedInstallCtx, prolongedInstallCancel := context.WithCancel(ctx)
+	go func() {
+		seconds := 15
+		select {
+		case <-time.After(time.Duration(seconds) * time.Second):
+			prolongedInstall.Store(true)
+			// We always want to log this at the info level.
+			log.Info(
+				prolongedInstallCtx,
+				fmt.Sprintf("terraform installation is taking longer than %d seconds, still in progress", seconds),
+				slog.F("prev_version", hasVersionStr),
+				slog.F("dir", dir),
+				slog.F("version", TerraformVersion),
+			)
+		case <-prolongedInstallCtx.Done():
+			return
+		}
+	}()
+	defer prolongedInstallCancel()
 
 	path, err := installer.Install(ctx)
 	if err != nil {
@@ -83,5 +111,9 @@ func Install(ctx context.Context, log slog.Logger, dir string, wantVersion *vers
 		return "", xerrors.Errorf("%s should be %s", path, binPath)
 	}
 
+	if prolongedInstall.Load() {
+		log.Info(ctx, "terraform installation complete")
+	}
+
 	return path, nil
 }
diff --git a/provisioner/terraform/install_test.go b/provisioner/terraform/install_test.go
@@ -40,7 +40,7 @@ func TestInstall(t *testing.T) {
 			wg.Add(1)
 			go func() {
 				defer wg.Done()
-				p, err := terraform.Install(ctx, log, dir, version)
+				p, err := terraform.Install(ctx, log, false, dir, version)
 				assert.NoError(t, err)
 				paths <- p
 			}()
diff --git a/provisioner/terraform/serve.go b/provisioner/terraform/serve.go
@@ -2,11 +2,13 @@ package terraform
 
 import (
 	"context"
+	"errors"
 	"path/filepath"
 	"sync"
 	"time"
 
 	"github.com/cli/safeexec"
+	"github.com/hashicorp/go-version"
 	semconv "go.opentelemetry.io/otel/semconv/v1.14.0"
 	"go.opentelemetry.io/otel/trace"
 	"golang.org/x/xerrors"
@@ -41,10 +43,15 @@ type ServeOptions struct {
 	ExitTimeout time.Duration
 }
 
-func absoluteBinaryPath(ctx context.Context, logger slog.Logger) (string, error) {
+type systemBinaryDetails struct {
+	absolutePath string
+	version      *version.Version
+}
+
+func systemBinary(ctx context.Context) (*systemBinaryDetails, error) {
 	binaryPath, err := safeexec.LookPath("terraform")
 	if err != nil {
-		return "", xerrors.Errorf("Terraform binary not found: %w", err)
+		return nil, xerrors.Errorf("Terraform binary not found: %w", err)
 	}
 
 	// If the "coder" binary is in the same directory as
@@ -54,59 +61,68 @@ func absoluteBinaryPath(ctx context.Context, logger slog.Logger) (string, error)
 	// to execute this properly!
 	absoluteBinary, err := filepath.Abs(binaryPath)
 	if err != nil {
-		return "", xerrors.Errorf("Terraform binary absolute path not found: %w", err)
+		return nil, xerrors.Errorf("Terraform binary absolute path not found: %w", err)
 	}
 
 	// Checking the installed version of Terraform.
 	installedVersion, err := versionFromBinaryPath(ctx, absoluteBinary)
 	if err != nil {
-		return "", xerrors.Errorf("Terraform binary get version failed: %w", err)
+		return nil, xerrors.Errorf("Terraform binary get version failed: %w", err)
 	}
 
-	logger.Info(ctx, "detected terraform version",
-		slog.F("installed_version", installedVersion.String()),
-		slog.F("min_version", minTerraformVersion.String()),
-		slog.F("max_version", maxTerraformVersion.String()))
-
-	if installedVersion.LessThan(minTerraformVersion) {
-		logger.Warn(ctx, "installed terraform version too old, will download known good version to cache")
-		return "", terraformMinorVersionMismatch
+	details := &systemBinaryDetails{
+		absolutePath: absoluteBinary,
+		version:      installedVersion,
 	}
 
-	// Warn if the installed version is newer than what we've decided is the max.
-	// We used to ignore it and download our own version but this makes it easier
-	// to test out newer versions of Terraform.
-	if installedVersion.GreaterThanOrEqual(maxTerraformVersion) {
-		logger.Warn(ctx, "installed terraform version newer than expected, you may experience bugs",
-			slog.F("installed_version", installedVersion.String()),
-			slog.F("max_version", maxTerraformVersion.String()))
+	if installedVersion.LessThan(minTerraformVersion) {
+		return details, terraformMinorVersionMismatch
 	}
 
-	return absoluteBinary, nil
+	return details, nil
 }
 
 // Serve starts a dRPC server on the provided transport speaking Terraform provisioner.
 func Serve(ctx context.Context, options *ServeOptions) error {
 	if options.BinaryPath == "" {
-		absoluteBinary, err := absoluteBinaryPath(ctx, options.Logger)
+		binaryDetails, err := systemBinary(ctx)
 		if err != nil {
 			// This is an early exit to prevent extra execution in case the context is canceled.
 			// It generally happens in unit tests since this method is asynchronous and
 			// the unit test kills the app before this is complete.
-			if xerrors.Is(err, context.Canceled) {
-				return xerrors.Errorf("absolute binary context canceled: %w", err)
+			if errors.Is(err, context.Canceled) {
+				return xerrors.Errorf("system binary context canceled: %w", err)
 			}
 
-			options.Logger.Warn(ctx, "no usable terraform binary found, downloading to cache dir",
-				slog.F("terraform_version", TerraformVersion.String()),
-				slog.F("cache_dir", options.CachePath))
-			binPath, err := Install(ctx, options.Logger, options.CachePath, TerraformVersion)
+			if errors.Is(err, terraformMinorVersionMismatch) {
+				options.Logger.Warn(ctx, "installed terraform version too old, will download known good version to cache, or use a previously cached version",
+					slog.F("installed_version", binaryDetails.version.String()),
+					slog.F("min_version", minTerraformVersion.String()))
+			}
+
+			binPath, err := Install(ctx, options.Logger, options.ExternalProvisioner, options.CachePath, TerraformVersion)
 			if err != nil {
 				return xerrors.Errorf("install terraform: %w", err)
 			}
 			options.BinaryPath = binPath
 		} else {
-			options.BinaryPath = absoluteBinary
+			logVersion := options.Logger.Debug
+			if options.ExternalProvisioner {
+				logVersion = options.Logger.Info
+			}
+			logVersion(ctx, "detected terraform version",
+				slog.F("installed_version", binaryDetails.version.String()),
+				slog.F("min_version", minTerraformVersion.String()),
+				slog.F("max_version", maxTerraformVersion.String()))
+			// Warn if the installed version is newer than what we've decided is the max.
+			// We used to ignore it and download our own version but this makes it easier
+			// to test out newer versions of Terraform.
+			if binaryDetails.version.GreaterThanOrEqual(maxTerraformVersion) {
+				options.Logger.Warn(ctx, "installed terraform version newer than expected, you may experience bugs",
+					slog.F("installed_version", binaryDetails.version.String()),
+					slog.F("max_version", maxTerraformVersion.String()))
+			}
+			options.BinaryPath = binaryDetails.absolutePath
 		}
 	}
 	if options.Tracer == nil {
diff --git a/provisioner/terraform/serve_internal_test.go b/provisioner/terraform/serve_internal_test.go
@@ -54,7 +54,6 @@ func Test_absoluteBinaryPath(t *testing.T) {
 				t.Skip("Dummy terraform executable on Windows requires sh which isn't very practical.")
 			}
 
-			log := testutil.Logger(t)
 			// Create a temp dir with the binary
 			tempDir := t.TempDir()
 			terraformBinaryOutput := fmt.Sprintf(`#!/bin/sh
@@ -85,11 +84,12 @@ func Test_absoluteBinaryPath(t *testing.T) {
 			}
 
 			ctx := testutil.Context(t, testutil.WaitShort)
-			actualAbsoluteBinary, actualErr := absoluteBinaryPath(ctx, log)
+			actualBinaryDetails, actualErr := systemBinary(ctx)
 
-			require.Equal(t, expectedAbsoluteBinary, actualAbsoluteBinary)
 			if tt.expectedErr == nil {
 				require.NoError(t, actualErr)
+				require.Equal(t, expectedAbsoluteBinary, actualBinaryDetails.absolutePath)
+				require.Equal(t, tt.terraformVersion, actualBinaryDetails.version.String())
 			} else {
 				require.EqualError(t, actualErr, tt.expectedErr.Error())
 			}

Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,6 @@ func Test_absoluteBinaryPath(t *testing.T) {`
`54`	`54`	`t.Skip("Dummy terraform executable on Windows requires sh which isn't very practical.")`
`55`	`55`	`}`
`56`	`56`
`57`		`- log := testutil.Logger(t)`
`58`	`57`	`// Create a temp dir with the binary`
`59`	`58`	`tempDir := t.TempDir()`
`60`	`59`	terraformBinaryOutput := fmt.Sprintf(`#!/bin/sh
`@@ -85,11 +84,12 @@ func Test_absoluteBinaryPath(t *testing.T) {`
`85`	`84`	`}`
`86`	`85`
`87`	`86`	`ctx := testutil.Context(t, testutil.WaitShort)`
`88`		`- actualAbsoluteBinary, actualErr := absoluteBinaryPath(ctx, log)`
	`87`	`+ actualBinaryDetails, actualErr := systemBinary(ctx)`
`89`	`88`
`90`		`- require.Equal(t, expectedAbsoluteBinary, actualAbsoluteBinary)`
`91`	`89`	`if tt.expectedErr == nil {`
`92`	`90`	`require.NoError(t, actualErr)`
	`91`	`+ require.Equal(t, expectedAbsoluteBinary, actualBinaryDetails.absolutePath)`
	`92`	`+ require.Equal(t, tt.terraformVersion, actualBinaryDetails.version.String())`
`93`	`93`	`} else {`
`94`	`94`	`require.EqualError(t, actualErr, tt.expectedErr.Error())`
`95`	`95`	`}`