Update atmos.yaml config for Terraform/OpenTofu to enable passing the generated varfile to tofu init

atmos.yaml

@@ -41,6 +41,9 @@ components:
     init_run_reconfigure: true
     # Can also be set using 'ATMOS_COMPONENTS_TERRAFORM_AUTO_GENERATE_BACKEND_FILE' ENV var, or '--auto-generate-backend-file' command-line argument
     auto_generate_backend_file: false
+    init:
+      # Can also be set using 'ATMOS_COMPONENTS_TERRAFORM_INIT_PASS_VARS' ENV var, or '--init-pass-vars' command-line argument
+      pass_vars: false
   helmfile:
     # Can also be set using 'ATMOS_COMPONENTS_HELMFILE_BASE_PATH' ENV var, or '--helmfile-dir' command-line argument
     # Supports both absolute and relative paths

internal/exec/atmos.go

@@ -41,7 +41,7 @@ func ExecuteAtmosCmd() error {
 
 	// Get a map of stacks and components in the stacks
 	// Don't process `Go` templates and YAML functions in Atmos stack manifests since we just need to display the stack and component names in the TUI
-	stacksMap, err := ExecuteDescribeStacks(atmosConfig, "", nil, nil, nil, false, false, false, false, nil)
+	stacksMap, err := ExecuteDescribeStacks(atmosConfig, "", nil, nil, nil, false, true, true, false, nil)
 	if err != nil {
 		return err
 	}
@@ -147,6 +147,8 @@ func ExecuteAtmosCmd() error {
 		configAndStacksInfo.ComponentFromArg = selectedComponent
 		configAndStacksInfo.Stack = selectedStack
 		configAndStacksInfo.SubCommand = subcommand
+		configAndStacksInfo.ProcessTemplates = true
+		configAndStacksInfo.ProcessFunctions = true
 		err = ExecuteTerraform(configAndStacksInfo)
 		if err != nil {
 			return err

internal/exec/describe_stacks.go

@@ -375,7 +375,8 @@ func ExecuteDescribeStacks(
 								}
 
 								componentSectionProcessed, err := ProcessTmplWithDatasources(
-									atmosConfig,
+									&atmosConfig,
+									&configAndStacksInfo,
 									settingsSectionStruct,
 									"describe-stacks-all-sections",
 									componentSectionStr,
@@ -576,7 +577,8 @@ func ExecuteDescribeStacks(
 								}
 
 								componentSectionProcessed, err := ProcessTmplWithDatasources(
-									atmosConfig,
+									&atmosConfig,
+									&configAndStacksInfo,
 									settingsSectionStruct,
 									"templates-describe-stacks-all-atmos-sections",
 									componentSectionStr,

internal/exec/template_funcs.go

@@ -16,24 +16,30 @@ import (
 )
 
 // FuncMap creates and returns a map of template functions
-func FuncMap(atmosConfig schema.AtmosConfiguration, ctx context.Context, gomplateData *data.Data) template.FuncMap {
-	atmosFuncs := &AtmosFuncs{atmosConfig, ctx, gomplateData}
+func FuncMap(
+	atmosConfig *schema.AtmosConfiguration,
+	configAndStacksInfo *schema.ConfigAndStacksInfo,
+	ctx context.Context,
+	gomplateData *data.Data,
+) template.FuncMap {
+	atmosFuncs := &AtmosFuncs{atmosConfig, configAndStacksInfo, ctx, gomplateData}
 
 	return map[string]any{
 		"atmos": func() any { return atmosFuncs },
 	}
 }
 
 type AtmosFuncs struct {
-	atmosConfig  schema.AtmosConfiguration
-	ctx          context.Context
-	gomplateData *data.Data
+	atmosConfig         *schema.AtmosConfiguration
+	configAndStacksInfo *schema.ConfigAndStacksInfo
+	ctx                 context.Context
+	gomplateData        *data.Data
 }
 
 func (f AtmosFuncs) Component(component string, stack string) (any, error) {
-	return componentFunc(f.atmosConfig, component, stack)
+	return componentFunc(f.atmosConfig, f.configAndStacksInfo, component, stack)
 }
 
 func (f AtmosFuncs) GomplateDatasource(alias string, args ...string) (any, error) {
-	return gomplateDatasourceFunc(f.atmosConfig, alias, f.gomplateData, args...)
+	return gomplateDatasourceFunc(alias, f.gomplateData, args...)
 }

internal/exec/template_funcs_component.go

@@ -4,33 +4,38 @@
 	"fmt"
 	"sync"
 
+	log "github.com/charmbracelet/log"
 	"github.com/samber/lo"
 
+	cfg "github.com/cloudposse/atmos/pkg/config"
 	"github.com/cloudposse/atmos/pkg/schema"
 	u "github.com/cloudposse/atmos/pkg/utils"
 )
 
 var componentFuncSyncMap = sync.Map{}
 
-func componentFunc(atmosConfig schema.AtmosConfiguration, component string, stack string) (any, error) {
-	u.LogTrace(fmt.Sprintf("Executing template function 'atmos.Component(%s, %s)'", component, stack))
-
+func componentFunc(
+	atmosConfig *schema.AtmosConfiguration,
+	configAndStacksInfo *schema.ConfigAndStacksInfo,
+	component string,
+	stack string,
+) (any, error) {
+	functionName := fmt.Sprintf("atmos.Component(%s, %s)", component, stack)
 	stackSlug := fmt.Sprintf("%s-%s", stack, component)
 
+	log.Debug("Executing template function", "function", functionName)
+
 	// If the result for the component in the stack already exists in the cache, return it
 	existingSections, found := componentFuncSyncMap.Load(stackSlug)
 	if found && existingSections != nil {
-		if atmosConfig.Logs.Level == u.LogLevelTrace {
-			u.LogTrace(fmt.Sprintf("Found the result of the template function 'atmos.Component(%s, %s)' in the cache", component, stack))
-
-			if outputsSection, ok := existingSections.(map[string]any)["outputs"]; ok {
-				u.LogTrace("'outputs' section:")
-				y, err2 := u.ConvertToYAML(outputsSection)
-				if err2 != nil {
-					u.LogError(err2)
-				} else {
-					u.LogTrace(y)
-				}
+		log.Debug("Cache hit for template function", "function", functionName)
+
+		if outputsSection, ok := existingSections.(map[string]any)["outputs"]; ok {
+			y, err2 := u.ConvertToYAML(outputsSection)
+			if err2 != nil {
+				log.Error(err2)
+			} else {
+				log.Debug("Result of the template function", "function", functionName, "outputs", y)
 			}
 		}
 
@@ -42,41 +47,45 @@
 		return nil, err
 	}
 
+	// Process Terraform remote state
 	var terraformOutputs map[string]any
-
-	// Check if the component in the stack is configured with the 'static' remote state backend,
-	// in which case get the `output` from the static remote state instead of executing `terraform output`
-	remoteStateBackendStaticTypeOutputs, err := GetComponentRemoteStateBackendStaticType(sections)
-	if err != nil {
-		return nil, err
-	}
-
-	if remoteStateBackendStaticTypeOutputs != nil {
-		terraformOutputs = remoteStateBackendStaticTypeOutputs
-	} else {
-		// Execute `terraform output`
-		terraformOutputs, err = execTerraformOutput(&atmosConfig, component, stack, sections)
+	if configAndStacksInfo.ComponentType == cfg.TerraformComponentType {
+		// Check if the component in the stack is configured with the 'static' remote state backend,
+		// in which case get the `output` from the static remote state instead of executing `terraform output`
+		remoteStateBackendStaticTypeOutputs, err := GetComponentRemoteStateBackendStaticType(sections)
 		if err != nil {
 			return nil, err
 		}
-	}
 
-	outputs := map[string]any{
-		"outputs": terraformOutputs,
-	}
+		if remoteStateBackendStaticTypeOutputs != nil {
+			// Return the static backend outputs
+			terraformOutputs = remoteStateBackendStaticTypeOutputs
+		} else {
+			// Execute `terraform output`
+			terraformOutputs, err = execTerraformOutput(atmosConfig, component, stack, sections)
+			if err != nil {
+				return nil, err
+			}
+		}
 
-	sections = lo.Assign(sections, outputs)
+		outputs := map[string]any{
+			"outputs": terraformOutputs,
+		}
+
+		sections = lo.Assign(sections, outputs)
+	}
 
 	// Cache the result
 	componentFuncSyncMap.Store(stackSlug, sections)
 
-	if atmosConfig.Logs.Level == u.LogLevelTrace {
-		u.LogTrace(fmt.Sprintf("Executed template function 'atmos.Component(%s, %s)'\n\n'outputs' section:", component, stack))
+	log.Debug("Executed template function", "function", functionName)
+
+	if configAndStacksInfo.ComponentType == cfg.TerraformComponentType {
 		y, err2 := u.ConvertToYAML(terraformOutputs)
 		if err2 != nil {
-			u.LogError(err2)
+			log.Error(err2)
 		} else {
-			u.LogTrace(y)
+			log.Debug("Result of the template function", "function", functionName, "outputs", y)
 		}
 	}
 

internal/exec/template_funcs_component_test.go

@@ -0,0 +1,74 @@
+package exec
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	log "github.com/charmbracelet/log"
+	"github.com/stretchr/testify/assert"
+
+	cfg "github.com/cloudposse/atmos/pkg/config"
+	"github.com/cloudposse/atmos/pkg/schema"
+	u "github.com/cloudposse/atmos/pkg/utils"
+)
+
+func TestComponentFunc(t *testing.T) {
+	log.SetLevel(log.DebugLevel)
+	log.SetOutput(os.Stdout)
+
+	// Capture the starting working directory
+	startingDir, err := os.Getwd()
+	if err != nil {
+		t.Fatalf("Failed to get the current working directory: %v", err)
+	}
+
+	defer func() {
+		// Delete the generated files and folders after the test
+		err := os.RemoveAll(filepath.Join("components", "terraform", "mock", ".terraform"))
+		assert.NoError(t, err)
+
+		err = os.RemoveAll(filepath.Join("components", "terraform", "mock", "terraform.tfstate.d"))
+		assert.NoError(t, err)
+
+		// Change back to the original working directory after the test
+		if err = os.Chdir(startingDir); err != nil {
+			t.Fatalf("Failed to change back to the starting directory: %v", err)
+		}
+	}()
+
+	// Define the working directory
+	workDir := "../../tests/fixtures/scenarios/stack-templates-3"
+	if err := os.Chdir(workDir); err != nil {
+		t.Fatalf("Failed to change directory to %q: %v", workDir, err)
+	}
+
+	info := schema.ConfigAndStacksInfo{
+		StackFromArg:     "",
+		Stack:            "nonprod",
+		StackFile:        "",
+		ComponentType:    "terraform",
+		ComponentFromArg: "component-1",
+		SubCommand:       "deploy",
+		ProcessTemplates: true,
+		ProcessFunctions: true,
+	}
+
+	err = ExecuteTerraform(info)
+	if err != nil {
+		t.Fatalf("Failed to execute 'ExecuteTerraform': %v", err)
+	}
+
+	atmosConfig, err := cfg.InitCliConfig(info, true)
+	assert.NoError(t, err)
+
+	d, err := componentFunc(&atmosConfig, &info, "component-2", "nonprod")
+	assert.NoError(t, err)
+
+	y, err := u.ConvertToYAML(d)
+	assert.NoError(t, err)
+
+	assert.Contains(t, y, "foo: component-1-a")
+	assert.Contains(t, y, "bar: component-1-b")
+	assert.Contains(t, y, "baz: component-1-b--component-1-c")
+}