feat: Enhance Terraform code generation and command execution workflow

This commit includes significant improvements to the Terraform code generation and command execution logic, ensuring better handling of modules, variables, and backend configurations.

Changes:
- Updated `main.go`:
  - Added support for Terraform commands (`init`, `plan`, `apply`, `build`, and `print`).
  - Integrated dynamic backend configuration and variable file support for `vars.tfvars`.
  - Enhanced command execution with detailed outputs for debugging.

- Updated `handlers/generate.go`:
  - Improved module dependency resolution and variable mapping.
  - Streamlined template data preparation for Terraform files.
  - Added functionality to generate module-specific files (main.tf, variables.tf, outputs.tf).

- Updated `models/config.go`:
  - Defined models for modules, variables, and provider configurations.
  - Added support for backend-specific fields like `access_key`.

- Updated `utils/filesystem.go`:
  - Enhanced template generation logic with custom helper functions (e.g., `add`).
  - Improved file and directory handling for consistent output structure.

Highlights:
- `vars.tfvars.tmpl` now correctly maps lists, maps, and other variable types.
- Backend configurations dynamically adjust based on `infratype` (prod/nonprod).
- `terraform-generator.json` configuration fully supports module and provider settings.

These updates ensure better modularity, robustness, and usability of the Terraform generation and execution workflow.

Author: Samyak Rout

infra_as_code/terraform_generator/backend/handlers/generate.go

@@ -39,48 +39,41 @@ func GenerateTerraform(req *models.GenerateRequest) error {
 	// Load configuration from terraform-generator.json
 	config, err := utils.LoadConfig("configs/terraform-generator.json")
 	if err != nil {
-		return err
+		return fmt.Errorf("error loading configuration: %w", err)
 	}
 
 	// Filter provider data based on the input provider
 	providerData := filterProviderData(config.Providers, req.Provider)
 	if providerData == nil {
-		return errors.New("specified provider not found in configuration")
+		return fmt.Errorf("specified provider '%s' not found in configuration", req.Provider)
 	}
 
 	// Resolve module dependencies
-	moduleNames := make([]string, len(req.Modules))
-	for i, moduleName := range req.Modules {
-		moduleNames[i] = strings.TrimSpace(moduleName)
-	}
-	modules, err := resolveModuleDependencies(moduleNames, config.Modules)
+	modules, err := resolveModuleDependencies(req.Modules, config.Modules)
 	if err != nil {
-		return err
+		return fmt.Errorf("error resolving module dependencies: %w", err)
 	}
 
 	// Update basePath to include 'output' directory
 	basePath := filepath.Join("output", "terraform", req.OrganisationName)
 
 	// Generate module files
 	if err := generateModuleFiles(basePath, modules, req.Provider); err != nil {
-		return err
+		return fmt.Errorf("error generating module files: %w", err)
 	}
 
+	// Generate files for a single product or customers
 	if len(req.Customers) > 0 {
 		return processCustomers(req, config, basePath, providerData, modules)
 	}
 
-	// Process for a single product
+	// Generate product-specific files
 	productPath := filepath.Join(basePath, req.ProductName)
 	if err := utils.CreateDirectories([]string{filepath.Join(productPath, "backend")}); err != nil {
-		return err
+		return fmt.Errorf("error creating directories for product: %w", err)
 	}
 
-	if err := generateProductFiles(req, config, productPath, providerData, modules); err != nil {
-		return err
-	}
-
-	return nil
+	return generateProductFiles(req, config, productPath, providerData, modules)
 }
 
 // filterProviderData filters provider details based on the specified provider name.
@@ -159,7 +152,6 @@ func generateModuleFiles(basePath string, modules []models.Module, provider stri
 			"ResourceName": module.ModuleName,
 		}
 
-		// Prepare list of files to generate
 		files := []struct {
 			Template string
 			Dest     string
@@ -188,7 +180,7 @@ func generateModuleFiles(basePath string, modules []models.Module, provider stri
 		// Generate files
 		for _, file := range files {
 			if err := utils.GenerateFileFromTemplate(file.Template, file.Dest, data); err != nil {
-				return err
+				return fmt.Errorf("error generating file %s: %w", file.Dest, err)
 			}
 		}
 	}
@@ -254,7 +246,7 @@ func prepareTemplateData(req *models.GenerateRequest, config *models.Config, pro
 	for _, module := range modules {
 		vars := make(map[string]string)
 		for varName, varDef := range module.Variables {
-			vars[varName] = varDef.Value // Use the 'value' field for module calls
+			vars[varName] = fmt.Sprintf("%v", varDef.Value) // Convert value to string
 		}
 		moduleVariables[module.ModuleName] = vars
 	}
@@ -263,14 +255,14 @@ func prepareTemplateData(req *models.GenerateRequest, config *models.Config, pro
 		"Provider":         provider,
 		"TerraformVersion": config.TerraformVersion,
 		"Modules":          modules,
-		"ModuleVariables":  moduleVariables,
+		"ModuleVariables":  moduleVariables, // Include populated module variables
 		"OrganisationName": req.OrganisationName,
 		"ProductName":      req.ProductName,
 		"CustomerName":     customerName,
 		"Region":           config.Region,
 		"Environment":      config.Environment,
 		"Backend":          config.Backend,
-		"Variables":        genericVariables, // Only generic variables
+		"Variables":        genericVariables,
 	}
 }
 

infra_as_code/terraform_generator/backend/main.go

@@ -23,10 +23,11 @@ func main() {
 	customers := generateCmd.String("customers", "", "Comma-separated list of customers")
 
 	terraformCmd := flag.NewFlagSet("terraform", flag.ExitOnError)
-	tfCommand := terraformCmd.String("command", "", "Terraform command to execute (init, plan, apply, build)")
+	tfCommand := terraformCmd.String("command", "", "Terraform command to execute (init, plan, apply, build, print)")
 	tfCompany := terraformCmd.String("company", "", "Company name (required)")
 	tfProduct := terraformCmd.String("product", "", "Product name (required)")
 	tfProvider := terraformCmd.String("provider", "", "Provider name (required)")
+	tfInfratype := terraformCmd.String("infratype", "", "Infrastructure type (prod or nonprod)")
 
 	if len(os.Args) < 2 {
 		fmt.Println("Expected 'generate' or 'terraform' subcommands")
@@ -37,61 +38,13 @@ func main() {
 	case "generate":
 		generateCmd.Parse(os.Args[2:])
 		if generateCmd.Parsed() {
-			if *company == "" || *product == "" || *provider == "" {
-				fmt.Println("Error: --company, --product, and --provider are required")
-				generateCmd.Usage()
-				os.Exit(1)
-			}
-
-			// Prepare the request data
-			req := models.GenerateRequest{
-				OrganisationName: *company,
-				ProductName:      *product,
-				Provider:         *provider,
-				Modules:          []string{},
-			}
-
-			// Handle modules
-			if *modules != "" {
-				moduleNames := strings.Split(*modules, ",")
-				for _, moduleName := range moduleNames {
-					moduleName = strings.TrimSpace(moduleName)
-					req.Modules = append(req.Modules, moduleName)
-				}
-			}
-
-			// Handle customers
-			if *customers != "" {
-				req.Customers = strings.Split(*customers, ",")
-				for i, customer := range req.Customers {
-					req.Customers[i] = strings.TrimSpace(customer)
-				}
-			}
-
-			// Call the generation logic
-			err := handlers.GenerateTerraform(&req)
-			if err != nil {
-				fmt.Printf("Error generating Terraform code: %v\n", err)
-				os.Exit(1)
-			}
-
-			fmt.Println("Terraform code generated successfully")
+			handleGenerateCommand(*company, *product, *provider, *modules, *customers)
 		}
 
 	case "terraform":
 		terraformCmd.Parse(os.Args[2:])
 		if terraformCmd.Parsed() {
-			if *tfCommand == "" || *tfCompany == "" || *tfProduct == "" || *tfProvider == "" {
-				fmt.Println("Error: --command, --company, --product, and --provider are required")
-				terraformCmd.Usage()
-				os.Exit(1)
-			}
-
-			// Run the Terraform command
-			err := runTerraformCommand(*tfCommand, *tfCompany, *tfProduct, *tfProvider)
-			if err != nil {
-				log.Fatalf("Error executing Terraform command: %v\n", err)
-			}
+			handleTerraformCommand(*tfCommand, *tfCompany, *tfProduct, *tfProvider, *tfInfratype)
 		}
 
 	default:
@@ -100,45 +53,123 @@ func main() {
 	}
 }
 
-// runTerraformCommand executes Terraform commands (init, plan, apply, build)
-func runTerraformCommand(command, company, product, provider string) error {
-	// Determine the working directory
+func handleGenerateCommand(company, product, provider, modules, customers string) {
+	if company == "" || product == "" || provider == "" {
+		fmt.Println("Error: --company, --product, and --provider are required")
+		os.Exit(1)
+	}
+
+	req := models.GenerateRequest{
+		OrganisationName: company,
+		ProductName:      product,
+		Provider:         provider,
+		Modules:          []string{},
+	}
+
+	// Handle modules
+	if modules != "" {
+		moduleNames := strings.Split(modules, ",")
+		for _, moduleName := range moduleNames {
+			req.Modules = append(req.Modules, strings.TrimSpace(moduleName))
+		}
+	}
+
+	// Handle customers
+	if customers != "" {
+		req.Customers = strings.Split(customers, ",")
+		for i := range req.Customers {
+			req.Customers[i] = strings.TrimSpace(req.Customers[i])
+		}
+	}
+
+	if err := handlers.GenerateTerraform(&req); err != nil {
+		fmt.Printf("Error generating Terraform code: %v\n", err)
+		os.Exit(1)
+	}
+
+	fmt.Println("Terraform code generated successfully")
+}
+
+func handleTerraformCommand(command, company, product, provider, infratype string) {
+	if command == "" || company == "" || product == "" || provider == "" {
+		fmt.Println("Error: --command, --company, --product, and --provider are required")
+		os.Exit(1)
+	}
+
+	// 'init', 'build', and 'print' commands require '--infratype'
+	if (command == "init" || command == "build" || command == "print") && infratype == "" {
+		fmt.Println("Error: --infratype is required for 'init', 'build', and 'print' commands")
+		os.Exit(1)
+	}
+
+	if command == "print" {
+		printTerraformCommands(command, company, product, provider, infratype)
+	} else {
+		if err := runTerraformCommand(command, company, product, provider, infratype); err != nil {
+			log.Fatalf("Error executing Terraform command: %v\n", err)
+		}
+	}
+}
+
+func runTerraformCommand(command, company, product, provider, infratype string) error {
 	terraformDir := filepath.Join("output", "terraform", company, product)
 	if _, err := os.Stat(terraformDir); os.IsNotExist(err) {
 		return fmt.Errorf("Terraform directory %s does not exist", terraformDir)
 	}
 
-	// Change to the Terraform directory
 	if err := os.Chdir(terraformDir); err != nil {
 		return fmt.Errorf("error changing directory to %s: %v", terraformDir, err)
 	}
 
-	// Map of commands to Terraform actions
-	tfCommands := map[string][]string{
-		"init":  {"init"},
-		"plan":  {"plan"},
-		"apply": {"apply", "-auto-approve"},
-		"build": {"init", "plan", "apply", "-auto-approve"},
-	}
+	switch command {
+	case "init":
+		backendConfig := fmt.Sprintf("backend/%s_%s.tfvars", product, strings.ToLower(infratype))
+		args := []string{"init", "-no-color", "-get=true", "-force-copy", fmt.Sprintf("-backend-config=%s", backendConfig)}
+		return executeCommand("terraform", args)
+
+	case "plan":
+		args := []string{"plan", "-no-color", "-input=false", "-lock=true", "-refresh=true", "-var-file=./vars.tfvars"}
+		return executeCommand("terraform", args)
+
+	case "apply":
+		args := []string{"apply", "-no-color", "-input=false", "-auto-approve=true", "-lock=true", "-lock-timeout=7200s", "-refresh=true", "-var-file=./vars.tfvars"}
+		return executeCommand("terraform", args)
+
+	case "build":
+		backendConfig := fmt.Sprintf("backend/%s_%s.tfvars", product, strings.ToLower(infratype))
+		buildCommands := [][]string{
+			{"init", "-no-color", "-get=true", "-force-copy", fmt.Sprintf("-backend-config=%s", backendConfig)},
+			{"plan", "-no-color", "-input=false", "-lock=true", "-refresh=true", "-var-file=./vars.tfvars"},
+			{"apply", "-no-color", "-input=false", "-auto-approve=true", "-lock=true", "-lock-timeout=7200s", "-refresh=true", "-var-file=./vars.tfvars"},
+		}
 
-	// Get the commands for the specified action
-	actions, ok := tfCommands[command]
-	if !ok {
+		for _, args := range buildCommands {
+			if err := executeCommand("terraform", args); err != nil {
+				return err
+			}
+		}
+
+	default:
 		return fmt.Errorf("unsupported Terraform command: %s", command)
 	}
 
-	// Execute the commands in sequence
-	for i := 0; i < len(actions); i++ {
-		cmd := exec.Command("terraform", actions[i])
-		cmd.Stdout = os.Stdout
-		cmd.Stderr = os.Stderr
+	return nil
+}
 
-		fmt.Printf("Running Terraform command: terraform %s\n", actions[i])
+func printTerraformCommands(command, company, product, provider, infratype string) {
+	terraformDir := filepath.Join("output", "terraform", company, product)
+	fmt.Printf("Working directory: %s\n", terraformDir)
 
-		if err := cmd.Run(); err != nil {
-			return fmt.Errorf("error running Terraform command '%s': %v", actions[i], err)
-		}
-	}
+	backendConfig := fmt.Sprintf("backend/%s_%s.tfvars", product, strings.ToLower(infratype))
+	fmt.Printf("terraform init -no-color -get=true -force-copy -backend-config=%s\n", backendConfig)
+	fmt.Println("terraform plan -no-color -input=false -lock=true -refresh=true -var-file=./vars.tfvars")
+	fmt.Println("terraform apply -no-color -input=false -auto-approve=true -lock=true -lock-timeout=7200s -refresh=true -var-file=./vars.tfvars")
+}
 
-	return nil
+func executeCommand(command string, args []string) error {
+	cmd := exec.Command(command, args...)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	fmt.Printf("Running command: %s %s\n", command, strings.Join(args, " "))
+	return cmd.Run()
 }

infra_as_code/terraform_generator/backend/templates/azure/main.tf.tmpl

@@ -7,10 +7,8 @@ module "{{ $module.ModuleName }}" {
   {{- end }}
   {{- if $module.DependsOn }}
   depends_on = [
-    {{- $deps := $module.DependsOn }}
-    {{- $depsLen := len $deps }}
-    {{- range $index, $dependency := $deps }}
-    module.{{ $dependency }}{{ if lt (add $index 1) $depsLen }},{{ end }}
+    {{- range $index, $dependency := $module.DependsOn }}
+    module.{{ $dependency }}{{ if lt (add $index 1) (len $module.DependsOn) }},{{ end }}
     {{- end }}
   ]
   {{- end }}

infra_as_code/terraform_generator/backend/templates/generic/vars.tfvars.tmpl

@@ -1,3 +1,13 @@
 {{- range $key, $metadata := .Variables }}
-{{ $key }}: "{{ $metadata.Value }}"
+{{- if eq $metadata.Type "list(string)" }}
+{{ $key }} = {{ toJSON $metadata.Value }}
+{{- else if eq $metadata.Type "map(string)" }}
+{{ $key }} = {
+{{- range $mapKey, $mapValue := $metadata.Value }}
+  {{ $mapKey }} = "{{ $mapValue }}"
+{{- end }}
+}
+{{- else }}
+{{ $key }} = "{{ $metadata.Value }}"
+{{- end }}
 {{- end }}