Merge pull request #330 from clouddrove/fix/smurf-stf

Add Timeout Support to Terraform Format Command

Author: dverma-cd

cmd/stf/format.go

@@ -2,31 +2,36 @@ package stf
 
 import (
 	"os"
+	"time"
 
 	"github.com/clouddrove/smurf/internal/terraform"
 	"github.com/spf13/cobra"
 )
 
 var recursive bool
+var timeout time.Duration
 
 // formatCmd defines a subcommand that formats the Terraform Infrastructure.
 var formatCmd = &cobra.Command{
-	Use:          "format",
+	Use:          "fmt",
 	Short:        "Format the Terraform Infrastructure",
 	SilenceUsage: true,
 	RunE: func(cmd *cobra.Command, args []string) error {
-		err := terraform.Format(recursive)
+		err := terraform.Format(recursive, timeout)
 		if err != nil {
 			os.Exit(1)
 		}
 		return nil
 	},
 	Example: `
-	smurf stf format
+	smurf stf fmt
+	smurf stf fmt --timeout 30s
+	smurf stf fmt --recursive --timeout 2m
 	`,
 }
 
 func init() {
-	formatCmd.Flags().BoolVarP(&recursive, "recursive", "r", false, "Run the command recursively on all subdirectories .By default, only the given directory (or current directory) is processed.")
+	formatCmd.Flags().BoolVarP(&recursive, "recursive", "r", false, "Run the command recursively on all subdirectories. By default, only the given directory (or current directory) is processed.")
+	formatCmd.Flags().DurationVarP(&timeout, "timeout", "t", 0, "Timeout for the formatting process (e.g., 30s, 2m, 1h). Zero means no timeout.")
 	stfCmd.AddCommand(formatCmd)
 }

cmd/stf/provision.go

@@ -10,7 +10,7 @@ var varNameValue []string
 var varFile []string
 var lock bool
 var upgrade bool
-var provisionDir string // Define provisionDir variable
+var provisionDir string
 
 var provisionCmd = &cobra.Command{
 	Use:          "provision",
@@ -37,14 +37,15 @@ var provisionCmd = &cobra.Command{
 	},
 	Example: `
 	smurf stf provision
-	smurf stf provision --dir=/path/to/terraform/files
+	smurf stf provision --dir=/path/to/terraform/files --auto-approve
 	`,
 }
 
 func init() {
 	provisionCmd.Flags().StringSliceVar(&varNameValue, "var", []string{}, "Specify a variable in 'NAME=VALUE' format")
 	provisionCmd.Flags().StringArrayVar(&varFile, "var-file", []string{}, "Specify a file containing variables")
 	provisionCmd.Flags().BoolVar(&provisionApprove, "approve", true, "Skip interactive approval of plan before applying")
+	provisionCmd.Flags().BoolVar(&applyAutoApprove, "auto-approve", false, "Skip interactive approval of plan before applying")
 	provisionCmd.Flags().BoolVar(&lock, "lock", false, "Don't hold a state lock during the operation. This is dangerous if others might concurrently run commands against the same workspace.")
 	provisionCmd.Flags().BoolVar(&upgrade, "upgrade", false, "Upgrade the Terraform modules and plugins to the latest versions")
 	provisionCmd.Flags().StringVar(&provisionDir, "dir", "", "Specify the directory for Terraform operations")

internal/terraform/format.go

@@ -8,6 +8,7 @@ import (
 	"os/exec"
 	"path/filepath"
 	"strings"
+	"time"
 
 	"github.com/hashicorp/terraform-exec/tfexec"
 )
@@ -99,81 +100,102 @@ func (cf *CustomFormatter) FormatWithDetails(ctx context.Context, dir string, re
 		return nil
 	}
 
-	formatted := []string{}
-	var formatErrors []FormatError
+	// Find files that need formatting
+	filesNeedFormatting := []string{}
+	timeoutReached := false
+	processedCount := 0
 
 	for _, file := range files {
+		// Check if context has been cancelled (timeout reached)
+		select {
+		case <-ctx.Done():
+			timeoutReached = true
+			break
+		default:
+			// Continue processing
+		}
+
+		if timeoutReached {
+			break
+		}
+
+		processedCount++
+
 		content, err := os.ReadFile(file)
 		if err != nil {
-			formatErrors = append(formatErrors, FormatError{
-				ErrorType:   "File read failed",
-				Description: err.Error(),
-				Location:    file,
-				HelpText:    "Failed to read file for formatting check",
-			})
 			continue
 		}
 
 		fileDir := filepath.Dir(file)
 		tf, err := tfexec.NewTerraform(fileDir, cf.tf.ExecPath())
 		if err != nil {
-			formatErrors = append(formatErrors, FormatError{
-				ErrorType:   "Terraform init failed",
-				Description: err.Error(),
-				Location:    file,
-				HelpText:    "Failed to initialize Terraform for formatting",
-			})
 			continue
 		}
 
 		var outputBuffer bytes.Buffer
 		err = tf.Format(ctx, bytes.NewReader(content), &outputBuffer)
 		if err != nil {
-			formatErrors = append(formatErrors, cf.parseFormatError(err, file))
+			if ctx.Err() == context.DeadlineExceeded {
+				timeoutReached = true
+				break
+			}
 			continue
 		}
 
-		if bytes.Equal(content, outputBuffer.Bytes()) {
-			continue // Already properly formatted
-		}
+		// Check if file needs formatting
+		if !bytes.Equal(content, outputBuffer.Bytes()) {
+			filesNeedFormatting = append(filesNeedFormatting, file)
 
-		err = os.WriteFile(file, outputBuffer.Bytes(), 0644)
-		if err != nil {
-			formatErrors = append(formatErrors, FormatError{
-				ErrorType:   "File write failed",
-				Description: err.Error(),
-				Location:    file,
-				HelpText:    "Failed to write formatted content to file",
-			})
-			continue
+			// Apply formatting if we haven't timed out yet
+			if !timeoutReached {
+				os.WriteFile(file, outputBuffer.Bytes(), 0644)
+			}
 		}
-
-		formatted = append(formatted, file)
 	}
 
-	if len(formatErrors) > 0 {
-		for _, e := range formatErrors {
-			fmt.Print(cf.formatError(e))
+	// Show files that need formatting
+	if len(filesNeedFormatting) > 0 {
+		fmt.Println("\nYou need to format following files:")
+		for i, file := range filesNeedFormatting {
+			relPath, err := filepath.Rel(cf.workDir, file)
+			if err != nil {
+				relPath = file
+			}
+			// Show numbering starting from 1
+			fmt.Printf("  %d. %s\n", i+1, CyanText(relPath))
 		}
-		Error("Formatting failed with %d errors", len(formatErrors))
-		return fmt.Errorf("formatting failed with %d errors", len(formatErrors))
-	}
 
-	if len(formatted) > 0 {
-		Success("Terraform files formatted successfully ✅")
-		Info("Formatted files:")
-		for _, file := range formatted {
-			fmt.Printf("   %s\n", CyanText(file))
+		// Only show "formatted" message if we actually formatted them
+		if !timeoutReached {
+			Success("\nFormatted %d file(s).", len(filesNeedFormatting))
 		}
 	} else {
-		Success("No Terraform file changes detected")
+		Success("No Terraform files need formatting.")
+	}
+
+	// Show timeout message if reached
+	if timeoutReached {
+		fmt.Println() // Empty line before timeout message
+		Warn("Timeout reached after processing %d/%d files. Some files may have been skipped.",
+			processedCount, len(files))
 	}
 
-	return nil
+	return nil // Always return success
 }
 
 // parseFormatError converts terraform-exec errors into our FormatError type
 func (cf *CustomFormatter) parseFormatError(err error, file string) FormatError {
+	// Check if it's a timeout error from terraform-exec
+	if strings.Contains(err.Error(), "timeout") || strings.Contains(err.Error(), "deadline") {
+		return FormatError{
+			ErrorType:   "Processing Timeout",
+			Description: "File processing took too long",
+			Location:    file,
+			LineNumber:  1,
+			HelpText:    "This file may be very large or complex. Consider formatting it separately.",
+		}
+	}
+
 	return FormatError{
 		ErrorType:   "Format Error",
 		Description: err.Error(),
@@ -206,8 +228,8 @@ func GetFmtTerraform() (*tfexec.Terraform, error) {
 	return tf, nil
 }
 
-// Format applies canonical formatting to all Terraform files.
-func Format(recursive bool) error {
+// Format applies canonical formatting to all Terraform files with optional timeout.
+func Format(recursive bool, timeout time.Duration) error {
 	tf, err := GetFmtTerraform()
 	if err != nil {
 		return err
@@ -220,5 +242,16 @@ func Format(recursive bool) error {
 	}
 
 	formatter := NewCustomFormatter(tf, workDir)
-	return formatter.FormatWithDetails(context.Background(), ".", recursive)
+
+	// Create context with timeout if specified
+	ctx := context.Background()
+	if timeout > 0 {
+		var cancel context.CancelFunc
+		ctx, cancel = context.WithTimeout(context.Background(), timeout)
+		defer cancel()
+
+		Info("Formatting with timeout: %v", timeout)
+	}
+
+	return formatter.FormatWithDetails(ctx, ".", recursive)
 }

internal/terraform/output.go

@@ -23,15 +23,12 @@ func Output(dir string, useAI bool) error {
 	tf.SetStderr(os.Stderr)
 
 	pterm.Info.Println("Refreshing Infrastructure state...")
-	spinner, _ := pterm.DefaultSpinner.Start("Refreshing Infrastructure state...")
 	err = tf.Refresh(context.Background())
 	if err != nil {
-		spinner.Fail("Error refreshing  state")
 		pterm.Error.Printf("Error refreshing  state: %v\n", err)
 		ai.AIExplainError(useAI, err.Error())
 		return err
 	}
-	spinner.Success("State refreshed successfully.")
 
 	outputs, err := tf.Output(context.Background())
 	if err != nil {