feat: Modularize providers and add new Terraform commands

- Updated providers.tf.tmpl to include a dynamic backend block, allowing support for multiple backend types by specifying backend type and parameters in the configuration.
- Enhanced main.go to remove the -backend-config flag from the Terraform init command.
- Added support for new Terraform commands: validate and destroy.
- Modified the build command to sequentially execute init, validate, plan, and apply.
- Updated terraform-generator.json structure to accommodate dynamic backend configurations.

This commit enhances the flexibility and scalability of the Terraform code generation process, allowing easier integration of various providers and backends.

Author: Samyak Rout

infra_as_code/terraform_generator/backend/main.go

@@ -15,25 +15,31 @@ import (
 )
 
 func main() {
+	// Define subcommands
 	generateCmd := flag.NewFlagSet("generate", flag.ExitOnError)
+	terraformCmd := flag.NewFlagSet("terraform", flag.ExitOnError)
+
+	// Define flags for 'generate' subcommand
 	company := generateCmd.String("company", "", "Company name (required)")
 	product := generateCmd.String("product", "", "Product name (required)")
 	provider := generateCmd.String("provider", "", "Provider name (required)")
 	modules := generateCmd.String("modules", "", "Comma-separated list of modules")
 	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, print)")
+	// Define flags for 'terraform' subcommand
+	tfCommand := terraformCmd.String("command", "", "Terraform command to execute (init, validate, plan, apply, build, destroy, 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)")
 
+	// Ensure a subcommand is provided
 	if len(os.Args) < 2 {
 		fmt.Println("Expected 'generate' or 'terraform' subcommands")
 		os.Exit(1)
 	}
 
+	// Parse subcommands
 	switch os.Args[1] {
 	case "generate":
 		generateCmd.Parse(os.Args[2:])
@@ -53,12 +59,15 @@ func main() {
 	}
 }
 
+// handleGenerateCommand processes the 'generate' subcommand
 func handleGenerateCommand(company, product, provider, modules, customers string) {
+	// Validate required flags
 	if company == "" || product == "" || provider == "" {
 		fmt.Println("Error: --company, --product, and --provider are required")
 		os.Exit(1)
 	}
 
+	// Create a GenerateRequest
 	req := models.GenerateRequest{
 		OrganisationName: company,
 		ProductName:      product,
@@ -82,6 +91,7 @@ func handleGenerateCommand(company, product, provider, modules, customers string
 		}
 	}
 
+	// Generate Terraform code
 	if err := services.GenerateTerraform(&req); err != nil {
 		fmt.Printf("Error generating Terraform code: %v\n", err)
 		os.Exit(1)
@@ -90,41 +100,51 @@ func handleGenerateCommand(company, product, provider, modules, customers string
 	fmt.Println("Terraform code generated successfully")
 }
 
+// handleTerraformCommand processes the 'terraform' subcommand
 func handleTerraformCommand(command, company, product, provider, infratype string) {
+	// Validate required flags
 	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")
+	// Certain commands require 'infratype'
+	if (command == "init" || command == "build" || command == "print" || command == "validate") && infratype == "" {
+		fmt.Println("Error: --infratype is required for 'init', 'build', 'print', and 'validate' commands")
 		os.Exit(1)
 	}
 
+	// Handle 'print' command separately
 	if command == "print" {
 		printTerraformCommands(command, company, product, provider, infratype)
 	} else {
+		// Execute other Terraform commands
 		if err := runTerraformCommand(command, company, product, provider, infratype); err != nil {
 			log.Fatalf("Error executing Terraform command: %v\n", err)
 		}
 	}
 }
 
+// runTerraformCommand executes the specified Terraform command
 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)
 	}
 
 	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)}
+		// Removed -backend-config
+		args := []string{"init", "-no-color", "-get=true", "-force-copy"}
+		return executeCommand("terraform", args)
+
+	case "validate":
+		args := []string{"validate", "-no-color"}
 		return executeCommand("terraform", args)
 
 	case "plan":
@@ -135,10 +155,15 @@ func runTerraformCommand(command, company, product, provider, infratype string)
 		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 "destroy":
+		args := []string{"destroy", "-no-color", "-auto-approve=true", "-var-file=./vars.tfvars"}
+		return executeCommand("terraform", args)
+
 	case "build":
-		backendConfig := fmt.Sprintf("backend/%s_%s.tfvars", product, strings.ToLower(infratype))
+		// Sequentially execute init, validate, plan, and apply
 		buildCommands := [][]string{
-			{"init", "-no-color", "-get=true", "-force-copy", fmt.Sprintf("-backend-config=%s", backendConfig)},
+			{"init", "-no-color", "-get=true", "-force-copy"},
+			{"validate", "-no-color"},
 			{"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"},
 		}
@@ -156,16 +181,33 @@ func runTerraformCommand(command, company, product, provider, infratype string)
 	return nil
 }
 
+// printTerraformCommands prints the Terraform commands without executing them
 func printTerraformCommands(command, company, product, provider, infratype string) {
 	terraformDir := filepath.Join("output", "terraform", company, product)
 	fmt.Printf("Working directory: %s\n", terraformDir)
 
-	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")
+	switch command {
+	case "init":
+		fmt.Println("terraform init -no-color -get=true -force-copy")
+	case "validate":
+		fmt.Println("terraform validate -no-color")
+	case "plan":
+		fmt.Println("terraform plan -no-color -input=false -lock=true -refresh=true -var-file=./vars.tfvars")
+	case "apply":
+		fmt.Println("terraform apply -no-color -input=false -auto-approve=true -lock=true -lock-timeout=7200s -refresh=true -var-file=./vars.tfvars")
+	case "destroy":
+		fmt.Println("terraform destroy -no-color -auto-approve=true -var-file=./vars.tfvars")
+	case "build":
+		fmt.Println("terraform init -no-color -get=true -force-copy")
+		fmt.Println("terraform validate -no-color")
+		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")
+	default:
+		fmt.Printf("Unsupported command: %s\n", command)
+	}
 }
 
+// executeCommand runs a shell command and streams its output
 func executeCommand(command string, args []string) error {
 	cmd := exec.Command(command, args...)
 	cmd.Stdout = os.Stdout

infra_as_code/terraform_generator/backend/models/config.go

@@ -20,14 +20,16 @@ type Provider struct {
 }
 
 type Backend struct {
-	ResourceGroupName  string `json:"resource_group_name"`
-	StorageAccountName string `json:"storage_account_name"`
-	ContainerName      string `json:"container_name"`
-	Key                string `json:"key"`
-	SubscriptionId     string `json:"subscription_id"`
-	TenantID           string `json:"tenant_id"`
-	ClientID           string `json:"client_id"`
-	AccessKey          string `json:"access_key"`
+	Type               string            `json:"type"`
+	Parameters         map[string]string `json:"parameters"`
+	ResourceGroupName  string            `json:"resource_group_name"`
+	StorageAccountName string            `json:"storage_account_name"`
+	ContainerName      string            `json:"container_name"`
+	Key                string            `json:"key"`
+	SubscriptionId     string            `json:"subscription_id"`
+	TenantID           string            `json:"tenant_id"`
+	ClientID           string            `json:"client_id"`
+	AccessKey          string            `json:"access_key"`
 }
 
 type Module struct {

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

@@ -1,16 +1,31 @@
-{{- range $module := .Modules }}
-module "{{ $module.ModuleName }}" {
-  source = "{{ $module.Source }}"
-  {{- $moduleVars := index $.ModuleVariables $module.ModuleName }}
+terraform {
+  backend "azurerm" {
+    resource_group_name  = "{{ .Backend.ResourceGroupName }}"
+    storage_account_name = "{{ .Backend.StorageAccountName }}"
+    container_name       = "{{ .Backend.ContainerName }}"
+    key                  = "{{ .Backend.Key }}"
+    access_key           = "{{ .Backend.AccessKey }}"
+    subscription_id      = "{{ .Backend.SubscriptionId }}"
+    tenant_id            = "{{ .Backend.TenantID }}"
+    client_id            = "{{ .Backend.ClientID }}"
+  }
+}
+
+{{- range .Modules }}
+module "{{ .ModuleName }}" {
+  source = "{{ .Source }}"
+  
+  {{- $moduleVars := index $.ModuleVariables .ModuleName }}
   {{- range $varName, $var := $moduleVars }}
   {{ $varName }} = {{ formatValue $var.Value $var.Type }}
   {{- end }}
-  {{- if $module.DependsOn }}
+
+  {{- if .DependsOn }}
   depends_on = [
-    {{- range $index, $dependency := $module.DependsOn }}
-    module.{{ $dependency }}{{ if lt (add $index 1) (len $module.DependsOn) }},{{ end }}
+    {{- range $index, $dependency := .DependsOn }}
+    module.{{ $dependency }}{{ if lt (add $index 1) (len .DependsOn) }},{{ end }}
     {{- end }}
   ]
   {{- end }}
 }
-{{ end }}
+{{- end }}