cloudposse
diff --git a/‎.editorconfig‎
Lines changed: 9 additions & 0 deletions b/‎.editorconfig‎
Lines changed: 9 additions & 0 deletions
diff --git a/‎internal/exec/terraform_output_utils.go‎
Lines changed: 15 additions & 1 deletion b/‎internal/exec/terraform_output_utils.go‎
Lines changed: 15 additions & 1 deletion
diff --git a/‎internal/exec/terraform_output_utils_integration_test.go‎
Lines changed: 94 additions & 0 deletions b/‎internal/exec/terraform_output_utils_integration_test.go‎
Lines changed: 94 additions & 0 deletions
diff --git a/‎internal/exec/terraform_output_utils_other.go‎
Lines changed: 14 additions & 0 deletions b/‎internal/exec/terraform_output_utils_other.go‎
Lines changed: 14 additions & 0 deletions
diff --git a/‎internal/exec/terraform_output_utils_other_test.go‎
Lines changed: 65 additions & 0 deletions b/‎internal/exec/terraform_output_utils_other_test.go‎
Lines changed: 65 additions & 0 deletions
diff --git a/‎internal/exec/terraform_output_utils_windows.go‎
Lines changed: 42 additions & 0 deletions b/‎internal/exec/terraform_output_utils_windows.go‎
Lines changed: 42 additions & 0 deletions
diff --git a/‎internal/exec/terraform_output_utils_windows_test.go‎
Lines changed: 95 additions & 0 deletions b/‎internal/exec/terraform_output_utils_windows_test.go‎
Lines changed: 95 additions & 0 deletions
@@ -1,27 +1,31 @@
 [*]
 insert_final_newline = true
 end_of_line = lf
+trim_trailing_whitespace = true
 
 # Binary files (override to ensure no text-related rules are applied)
 [*.{png,jpg,gif,svg,pdf,ai,eps,mp4}]
 insert_final_newline = false
 end_of_line = unset
 indent_style = unset
 indent_size = unset
+trim_trailing_whitespace = false
 
 # Override for machine generated binary HTML files in Screengrabs directory
 [website/src/components/Screengrabs/**/*.html]
 insert_final_newline = false
 end_of_line = unset
 indent_style = unset
 indent_size = unset
+trim_trailing_whitespace = false
 
 # Override for machine generated binary files in tests/snapshots directory for golden snapshots
 [test/snapshots/**/*.golden]
 insert_final_newline = false
 end_of_line = unset
 indent_style = unset
 indent_size = unset
+trim_trailing_whitespace = false
 
 # Override for Makefile
 [{Makefile,makefile,GNUmakefile}]
@@ -47,3 +51,8 @@ indent_size = 2
 [*.{tf,tfvars,tpl}]
 indent_style = space
 indent_size = 2
+
+# Go files
+[*.go]
+indent_style = tab
+indent_size = 4
@@ -252,6 +252,9 @@ func execTerraformOutput(
 					cfg.StackStr, stack,
 				)
 			}
+
+			// Add delay on Windows after workspace operations to prevent file locking
+			windowsFileDelay()
 		}
 
 		// Terraform output
@@ -260,10 +263,21 @@ func execTerraformOutput(
 			cfg.ComponentStr, component,
 			cfg.StackStr, stack,
 		)
-		outputMeta, err := tf.Output(ctx)
+
+		// Add small delay on Windows to prevent file locking issues
+		windowsFileDelay()
+
+		// Wrap the output call with retry logic for Windows
+		var outputMeta map[string]tfexec.OutputMeta
+		err = retryOnWindows(func() error {
+			var outputErr error
+			outputMeta, outputErr = tf.Output(ctx)
+			return outputErr
+		})
 		if err != nil {
 			return nil, err
 		}
+
 		log.Debug("Executed terraform output command",
 			"command", fmt.Sprintf("terraform output %s -s %s", component, stack),
 			cfg.ComponentStr, component,
 
@@ -0,0 +1,94 @@
+package exec
+
+import (
+	"os"
+	"path/filepath"
+	"runtime"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestRetryOnWindows_FileOperations(t *testing.T) {
+	// Create a temporary directory for testing.
+	tmpDir, err := os.MkdirTemp("", "terraform_output_test")
+	require.NoError(t, err)
+	defer os.RemoveAll(tmpDir)
+
+	testFile := filepath.Join(tmpDir, "test.txt")
+
+	// Create a test file.
+	err = os.WriteFile(testFile, []byte("test content"), 0o644)
+	require.NoError(t, err)
+
+	// Test file deletion with retry logic.
+	err = retryOnWindows(func() error {
+		return os.Remove(testFile)
+	})
+	assert.NoError(t, err)
+
+	// Verify file was deleted.
+	_, err = os.Stat(testFile)
+	assert.True(t, os.IsNotExist(err), "File should be deleted")
+}
+
+func TestRetryOnWindows_SimulatedLockingScenario(t *testing.T) {
+	if runtime.GOOS != "windows" {
+		t.Skipf("This test simulates Windows-specific file locking behavior")
+	}
+
+	tmpDir, err := os.MkdirTemp("", "terraform_lock_test")
+	require.NoError(t, err)
+	defer os.RemoveAll(tmpDir)
+
+	testFile := filepath.Join(tmpDir, "state.tfstate")
+
+	// Create a test file.
+	err = os.WriteFile(testFile, []byte("terraform state"), 0o644)
+	require.NoError(t, err)
+
+	// Open the file to simulate it being locked.
+	file, err := os.Open(testFile)
+	require.NoError(t, err)
+
+	// Try to delete while file is open (this typically fails on Windows).
+	deleteErr := os.Remove(testFile)
+
+	if deleteErr != nil {
+		// File is locked, close it and try with retry logic.
+		file.Close()
+
+		// Small delay to ensure handle is released.
+		time.Sleep(50 * time.Millisecond)
+
+		// Now deletion with retry should work.
+		err = retryOnWindows(func() error {
+			return os.Remove(testFile)
+		})
+		assert.NoError(t, err, "Retry logic should handle file deletion after lock is released")
+	} else {
+		// If deletion succeeded immediately, just close the file.
+		file.Close()
+	}
+
+	// Verify file was deleted.
+	_, err = os.Stat(testFile)
+	assert.True(t, os.IsNotExist(err), "File should be deleted")
+}
+
+func TestWindowsFileDelay_Timing(t *testing.T) {
+	// Test that the delay function behaves correctly on the current platform.
+	start := time.Now()
+	windowsFileDelay()
+	elapsed := time.Since(start)
+
+	if runtime.GOOS == "windows" {
+		// On Windows, expect a delay.
+		assert.GreaterOrEqual(t, elapsed.Milliseconds(), int64(90), "Expected at least 90ms delay on Windows")
+	} else {
+		// On other platforms, expect no significant delay.
+		assert.Less(t, elapsed.Milliseconds(), int64(10), "Expected no significant delay on non-Windows")
+	}
+}
@@ -0,0 +1,14 @@
+//go:build !windows
+// +build !windows
+
+package exec
+
+// windowsFileDelay is a no-op on non-Windows platforms.
+func windowsFileDelay() {
+	// No delay needed on Unix-like systems
+}
+
+// retryOnWindows immediately executes the function on non-Windows platforms.
+func retryOnWindows(fn func() error) error {
+	return fn()
+}
@@ -0,0 +1,65 @@
+//go:build !windows
+// +build !windows
+
+package exec
+
+import (
+	"errors"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestWindowsFileDelay_NoOp(t *testing.T) {
+	// Test that windowsFileDelay is a no-op on non-Windows platforms.
+	start := time.Now()
+	windowsFileDelay()
+	elapsed := time.Since(start)
+
+	// Should have no significant delay on non-Windows platforms.
+	assert.Less(t, elapsed.Milliseconds(), int64(10), "Expected no significant delay on non-Windows platforms")
+}
+
+func TestRetryOnWindows_NoRetry(t *testing.T) {
+	// Test that retryOnWindows executes immediately without retries on non-Windows.
+	callCount := 0
+	testErr := errors.New("test error")
+
+	// Test with error - should not retry on non-Windows.
+	err := retryOnWindows(func() error {
+		callCount++
+		return testErr
+	})
+
+	assert.Error(t, err)
+	assert.Equal(t, testErr, err)
+	assert.Equal(t, 1, callCount, "Function should be called exactly once on non-Windows platforms")
+}
+
+func TestRetryOnWindows_SuccessNoRetry(t *testing.T) {
+	// Test successful execution on non-Windows.
+	callCount := 0
+
+	err := retryOnWindows(func() error {
+		callCount++
+		return nil
+	})
+
+	assert.NoError(t, err)
+	assert.Equal(t, 1, callCount, "Function should be called exactly once on non-Windows platforms")
+}
+
+func TestRetryOnWindows_NoDelay(t *testing.T) {
+	// Test that there's no delay even on error for non-Windows platforms.
+	testErr := errors.New("test error")
+
+	start := time.Now()
+	err := retryOnWindows(func() error {
+		return testErr
+	})
+	elapsed := time.Since(start)
+
+	assert.Error(t, err)
+	assert.Less(t, elapsed.Milliseconds(), int64(10), "Expected no delay on non-Windows platforms even with errors")
+}
@@ -0,0 +1,42 @@
+//go:build windows
+// +build windows
+
+package exec
+
+import (
+	"runtime"
+	"time"
+)
+
+// windowsFileDelay adds a small delay on Windows to allow file handles to be released.
+// This helps prevent "The process cannot access the file because another process has locked
+// a portion of the file" errors when multiple terraform operations run in quick succession.
+func windowsFileDelay() {
+	if runtime.GOOS == "windows" {
+		time.Sleep(100 * time.Millisecond)
+	}
+}
+
+// retryOnWindows wraps a function with retry logic for Windows file operations.
+// It will retry up to 3 times with increasing delays.
+func retryOnWindows(fn func() error) error {
+	if runtime.GOOS != "windows" {
+		return fn()
+	}
+
+	var lastErr error
+	delays := []time.Duration{100 * time.Millisecond, 200 * time.Millisecond, 500 * time.Millisecond}
+
+	for i := 0; i < len(delays); i++ {
+		if err := fn(); err == nil {
+			return nil
+		} else {
+			lastErr = err
+			if i < len(delays)-1 {
+				time.Sleep(delays[i])
+			}
+		}
+	}
+
+	return lastErr
+}
@@ -0,0 +1,95 @@
+//go:build windows
+// +build windows
+
+package exec
+
+import (
+	"errors"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestWindowsFileDelay(t *testing.T) {
+	// Test that windowsFileDelay introduces a delay on Windows.
+	start := time.Now()
+	windowsFileDelay()
+	elapsed := time.Since(start)
+
+	// Should have at least 100ms delay on Windows.
+	assert.GreaterOrEqual(t, elapsed.Milliseconds(), int64(90), "Expected at least 90ms delay on Windows")
+	assert.LessOrEqual(t, elapsed.Milliseconds(), int64(150), "Expected no more than 150ms delay on Windows")
+}
+
+func TestRetryOnWindows_Success(t *testing.T) {
+	// Test successful execution on first try.
+	callCount := 0
+	err := retryOnWindows(func() error {
+		callCount++
+		return nil
+	})
+
+	assert.NoError(t, err)
+	assert.Equal(t, 1, callCount, "Function should be called exactly once on success")
+}
+
+func TestRetryOnWindows_RetryThenSuccess(t *testing.T) {
+	// Test retry logic - fail twice, then succeed.
+	callCount := 0
+	testErr := errors.New("temporary error")
+
+	start := time.Now()
+	err := retryOnWindows(func() error {
+		callCount++
+		if callCount < 3 {
+			return testErr
+		}
+		return nil
+	})
+	elapsed := time.Since(start)
+
+	assert.NoError(t, err)
+	assert.Equal(t, 3, callCount, "Function should be called 3 times (2 failures + 1 success)")
+	// Should have delays: 100ms after first failure, 200ms after second failure.
+	assert.GreaterOrEqual(t, elapsed.Milliseconds(), int64(250), "Expected at least 250ms total delay for 2 retries")
+}
+
+func TestRetryOnWindows_AllFailures(t *testing.T) {
+	// Test when all retries fail.
+	callCount := 0
+	testErr := errors.New("persistent error")
+
+	start := time.Now()
+	err := retryOnWindows(func() error {
+		callCount++
+		return testErr
+	})
+	elapsed := time.Since(start)
+
+	assert.Error(t, err)
+	assert.Equal(t, testErr, err, "Should return the last error")
+	assert.Equal(t, 3, callCount, "Function should be called 3 times (max retries)")
+	// Should have delays: 100ms + 200ms = 300ms minimum.
+	assert.GreaterOrEqual(t, elapsed.Milliseconds(), int64(250), "Expected at least 250ms total delay for all retries")
+}
+
+func TestRetryOnWindows_DifferentErrors(t *testing.T) {
+	// Test that the last error is returned when different errors occur.
+	callCount := 0
+	errList := []error{
+		errors.New("first error"),
+		errors.New("second error"),
+		errors.New("final error"),
+	}
+
+	err := retryOnWindows(func() error {
+		err := errList[callCount]
+		callCount++
+		return err
+	})
+
+	assert.Error(t, err)
+	assert.Equal(t, errList[2], err, "Should return the last error")
+	assert.Equal(t, 3, callCount, "Function should be called 3 times")
+}