options

Documentation

Index

• Constants
• Variables
• func DefaultWorkingAndDownloadDirs(terragruntConfigPath string) (string, string, error)
• func GetDefaultIAMAssumeRoleSessionName() string
• type IAMRoleOptions
  • func MergeIAMRoleOptions(target IAMRoleOptions, source IAMRoleOptions) IAMRoleOptions
• type TerraformImplementationType
• type TerragruntOptions
  • func NewTerragruntOptions() *TerragruntOptions
  • func NewTerragruntOptionsForTest(terragruntConfigPath string) (*TerragruntOptions, error)
  • func NewTerragruntOptionsWithConfigPath(terragruntConfigPath string) (*TerragruntOptions, error)
  • func (opts *TerragruntOptions) AppendTerraformCliArgs(argsToAppend ...string)
  • func (opts *TerragruntOptions) Clone(terragruntConfigPath string) *TerragruntOptions
  • func (opts *TerragruntOptions) DataDir() string
  • func (opts *TerragruntOptions) InsertTerraformCliArgs(argsToInsert ...string)
  • func (opts *TerragruntOptions) OptionsFromContext(ctx context.Context) *TerragruntOptions
  • func (opts *TerragruntOptions) TerraformDataDir() string

Constants

const (
	DefaultMaxFoldersToCheck = 100

	// no limits on parallelism by default (limited by GOPROCS)
	DefaultParallelism = math.MaxInt32

	// TofuDefaultPath command to run tofu
	TofuDefaultPath = "tofu"

	// TerraformDefaultPath just takes terraform from the path
	TerraformDefaultPath = "terraform"

	// Default to naming it `terragrunt_rendered.json` in the terragrunt config directory.
	DefaultJSONOutName = "terragrunt_rendered.json"

	DefaultTFDataDir = ".terraform"

	DefaultIAMAssumeRoleDuration = 3600
)

const ContextKey ctxKey = iota

const DEFAULT_RETRY_MAX_ATTEMPTS = 3

const DEFAULT_RETRY_SLEEP_INTERVAL_SEC = 5 * time.Second

Variables

var DEFAULT_RETRYABLE_ERRORS = []string{
	"(?s).*Failed to load state.*tcp.*timeout.*",
	"(?s).*Failed to load backend.*TLS handshake timeout.*",
	"(?s).*Creating metric alarm failed.*request to update this alarm is in progress.*",
	"(?s).*Error installing provider.*TLS handshake timeout.*",
	"(?s).*Error configuring the backend.*TLS handshake timeout.*",
	"(?s).*Error installing provider.*tcp.*timeout.*",
	"(?s).*Error installing provider.*tcp.*connection reset by peer.*",
	"NoSuchBucket: The specified bucket does not exist",
	"(?s).*Error creating SSM parameter: TooManyUpdates:.*",
	"(?s).*app.terraform.io.*: 429 Too Many Requests.*",
	"(?s).*ssh_exchange_identification.*Connection closed by remote host.*",
	"(?s).*Client\\.Timeout exceeded while awaiting headers.*",
	"(?s).*Could not download module.*The requested URL returned error: 429.*",
}

List of recurring transient errors encountered when calling terraform If any of these match, we'll retry the command

var DefaultWrappedPath = identifyDefaultWrappedExecutable()

var RunTerragruntCommandNotSet = fmt.Errorf("The RunTerragrunt option has not been set on this TerragruntOptions object") //nolint:staticcheck // renaming would break public API consumers

var TERRAFORM_COMMANDS_WITH_SUBCOMMAND = []string{
	"debug",
	"force-unlock",
	"state",
}

Functions

func DefaultWorkingAndDownloadDirs

func DefaultWorkingAndDownloadDirs(terragruntConfigPath string) (string, string, error)

Get the default working and download directories for the given Terragrunt config path

func GetDefaultIAMAssumeRoleSessionName

func GetDefaultIAMAssumeRoleSessionName() string

Get the default IAM assume role session name.

Types

type IAMRoleOptions

type IAMRoleOptions struct {
	// The ARN of an IAM Role to assume. Used when accessing AWS, both internally and through terraform.
	RoleARN string

	// Duration of the STS Session when assuming the role.
	AssumeRoleDuration int64

	// STS Session name when assuming the role.
	AssumeRoleSessionName string
}

IAMOptions represents options that are used by Terragrunt to assume an IAM role.

func MergeIAMRoleOptions

func MergeIAMRoleOptions(target IAMRoleOptions, source IAMRoleOptions) IAMRoleOptions

type TerraformImplementationType

type TerraformImplementationType string

const (
	TerraformImpl TerraformImplementationType = "terraform"
	OpenTofuImpl  TerraformImplementationType = "tofu"
	UnknownImpl   TerraformImplementationType = "unknown"
)

type TerragruntOptions

type TerragruntOptions struct {
	// Location of the Terragrunt config file
	TerragruntConfigPath string

	// Location of the original Terragrunt config file. This is primarily useful when one Terragrunt config is being
	// read from another: e.g., if /terraform-code/terragrunt.hcl calls read_terragrunt_config("/foo/bar.hcl"),
	// and within bar.hcl, you call get_original_terragrunt_dir(), you'll get back /terraform-code.
	OriginalTerragruntConfigPath string

	// Version of terragrunt
	TerragruntVersion *version.Version

	// Location of the terraform binary
	TerraformPath string

	// Current Terraform command being executed by Terragrunt
	TerraformCommand string

	// Original Terraform command being executed by Terragrunt. Used to track command evolution as terragrunt chains
	// different commands together. For example, when retrieving dependencies, terragrunt will change the
	// TerraformCommand to `output` to run `terraform output`, which loses the context of the original command that was
	// run to fetch the dependency. This is a problem when mock_outputs is configured and we only allow mocks to be
	// returned on specific commands.
	// NOTE: For `xxx-all` commands, this will be set to the Terraform command, which would be `xxx`. For example,
	// if you run `apply-all` (which is a terragrunt command), this variable will be set to `apply`.
	OriginalTerraformCommand string

	// Terraform implementation tool (e.g. terraform, tofu) that terragrunt is wrapping
	TerraformImplementation TerraformImplementationType

	// Version of terraform (obtained by running 'terraform version')
	TerraformVersion *version.Version

	// Whether we should prompt the user for confirmation or always assume "yes"
	NonInteractive bool

	// Whether we should automatically run terraform init if necessary when executing other commands
	AutoInit bool

	// Whether we should automatically run terraform with -auto-apply in run-all mode.
	RunAllAutoApprove bool

	// CLI args that are intended for Terraform (i.e. all the CLI args except the --terragrunt ones)
	TerraformCliArgs []string

	// The working directory in which to run Terraform
	WorkingDir string

	// Basic log entry
	Logger *logrus.Entry

	// Disalabe Terragrunt colors
	DisableLogColors bool

	// Log level
	LogLevel logrus.Level

	// Raw log level value
	LogLevelStr string

	// ValidateStrict mode for the validate-inputs command
	ValidateStrict bool

	// Environment variables at runtime
	Env map[string]string

	// Download Terraform configurations from the specified source location into a temporary folder and run
	// Terraform in that temporary folder
	Source string

	// Map to replace terraform source locations. This will replace occurrences of the given source with the target
	// value.
	SourceMap map[string]string

	// If set to true, delete the contents of the temporary folder before downloading Terraform source code into it
	SourceUpdate bool

	// Download Terraform configurations specified in the Source parameter into this folder
	DownloadDir string

	// IAM Role options set from command line. This is used to differentiate between the options set from the config and
	// CLI.
	OriginalIAMRoleOptions IAMRoleOptions

	// IAM Role options that should be used when authenticating to AWS.
	IAMRoleOptions IAMRoleOptions

	// If set to true, continue running *-all commands even if a dependency has errors. This is mostly useful for 'output-all <some_variable>'. See https://github.com/c3xdev/c3x/internal/hclstack/issues/193
	IgnoreDependencyErrors bool

	// If set to true, ignore the dependency order when running *-all command.
	IgnoreDependencyOrder bool

	// If set to true, skip any external dependencies when running *-all commands
	IgnoreExternalDependencies bool

	// If set to true, apply all external dependencies when running *-all commands
	IncludeExternalDependencies bool

	// If you want stdout to go somewhere other than os.stdout
	Writer io.Writer

	// If you want stderr to go somewhere other than os.stderr
	ErrWriter io.Writer

	// When searching the directory tree, this is the max folders to check before exiting with an error. This is
	// exposed here primarily so we can set it to a low value at test time.
	MaxFoldersToCheck int

	// Whether we should automatically retry errored Terraform commands
	AutoRetry bool

	// Maximum number of times to retry errors matching RetryableErrors
	RetryMaxAttempts int

	// The duration in seconds to wait before retrying
	RetrySleepIntervalSec time.Duration //nolint:staticcheck // public API, renaming would break consumers

	// RetryableErrors is an array of regular expressions with RE2 syntax (https://github.com/google/re2/wiki/Syntax) that qualify for retrying
	RetryableErrors []string

	// Unix-style glob of directories to exclude when running *-all commands
	ExcludeDirs []string

	// Unix-style glob of directories to include when running *-all commands
	IncludeDirs []string

	// If set to true, do not include dependencies when processing IncludeDirs (unless they are in the included dirs)
	StrictInclude bool

	// Parallelism limits the number of commands to run concurrently during *-all commands
	Parallelism int

	// Enable check mode, by default it's disabled.
	Check bool

	// Show diff, by default it's disabled.
	Diff bool

	// The file which hclfmt should be specifically run on
	HclFile string

	// The file path that terragrunt should use when rendering the terragrunt.hcl config as json.
	JSONOut string

	// When used with `run-all`, restrict the modules in the stack to only those that include at least one of the files
	// in this list.
	ModulesThatInclude []string

	// A command that can be used to run Terragrunt with the given options. This is useful for running Terragrunt
	// multiple times (e.g. when spinning up a stack of Terraform modules). The actual command is normally defined
	// in the cli package, which depends on almost all other packages, so we declare it here so that other
	// packages can use the command without a direct reference back to the cli package (which would create a
	// circular dependency).
	RunTerragrunt func(*TerragruntOptions) error

	// True if terragrunt should run in debug mode, writing terragrunt-debug.tfvars to working folder to help
	// root-cause issues.
	Debug bool

	// Attributes to override in AWS provider nested within modules as part of the aws-provider-patch command. See that
	// command for more info.
	AwsProviderPatchOverrides map[string]string

	// True if is required to show dependent modules and confirm action
	CheckDependentModules bool

	// This is an experimental feature, used to speed up dependency processing by getting the output from the state
	FetchDependencyOutputFromState bool

	// Enables caching of includes during partial parsing operations.
	UsePartialParseConfigCache bool

	// Include fields metadata in render-json
	RenderJsonWithMetadata bool

	// Prefix for shell commands' outputs
	OutputPrefix string

	// Controls if a module prefix will be prepended to TF outputs
	IncludeModulePrefix bool

	// Functions is an optional field which provides a way to add extra functions to the Terragrunt Evaluation Context.
	// It specifies a function which will be called with the directory of the terragrunt.hcl which is being evaluated.
	// It should return a map where keys are the names of Terragrunt functions, and values are the corresponding function
	// implementations. These functions are incorporated into the hcl.EvalContext prior to evaluation.
	// They always supersede the base functions from Terraform or Terragrunt. This means that the
	// Functions field can be utilized to overwrite any base functions, which can be particularly
	// beneficial for testing or cases where certain functions should not be executed.
	Functions func(baseDir string) map[string]function.Function

	// Fail execution if is required to create S3 bucket
	FailIfBucketCreationRequired bool

	// Controls if s3 bucket should be updated or skipped
	DisableBucketUpdate bool

	// Disalbes validation terraform command
	DisableCommandValidation bool

	// GetOutputs is a function that returns the outputs of a module. It is used to
	// get the outputs of a module when executing the Terragrunt command is not
	// possible. This is useful in environments where Terragrunt is not installed and
	// outputs are orchestrated by a different method.
	GetOutputs func(targetConfig string, ops *TerragruntOptions) (*cty.Value, bool, error)

	// DownloadSource is function for fetching the source of the module
	DownloadSource func(downloadDir string, url string, ops *TerragruntOptions) error

	// DiagnosticsFunc is a function that is called when there is a error parsing a Terragrunt config for a given
	// path. This function is called with the error, the filename, the config, and the evaluation context.
	// Use this function when you want to provide custom error handling for the config parsing and
	// augment the partial config with additional information.
	//
	// Note: config will be a type *config.TerragruntConfigFile but is left as an interface{} to avoid a circular dependency
	// on the config package. Use type assertions if you need to access the config type. e.g. f := config.(*config.TerragruntConfigFile)
	DiagnosticsFunc func(err error, filename string, config interface{}, evalContext *hcl.EvalContext)
}

TerragruntOptions represents options that configure the behavior of the Terragrunt program

func NewTerragruntOptions

func NewTerragruntOptions() *TerragruntOptions

Create a new TerragruntOptions object with reasonable defaults for real usage

func NewTerragruntOptionsForTest

func NewTerragruntOptionsForTest(terragruntConfigPath string) (*TerragruntOptions, error)

Create a new TerragruntOptions object with reasonable defaults for test usage

func NewTerragruntOptionsWithConfigPath

func NewTerragruntOptionsWithConfigPath(terragruntConfigPath string) (*TerragruntOptions, error)

func (*TerragruntOptions) AppendTerraformCliArgs

func (opts *TerragruntOptions) AppendTerraformCliArgs(argsToAppend ...string)

Appends the given argsToAppend after the current TerraformCliArgs

func (*TerragruntOptions) Clone

func (opts *TerragruntOptions) Clone(terragruntConfigPath string) *TerragruntOptions

Create a copy of this TerragruntOptions, but with different values for the given variables. This is useful for creating a TerragruntOptions that behaves the same way, but is used for a Terraform module in a different folder.

func (*TerragruntOptions) DataDir

func (opts *TerragruntOptions) DataDir() string

DataDir returns the Terraform data directory prepended with the working directory path, or just the Terraform data directory if it is an absolute path.

func (*TerragruntOptions) InsertTerraformCliArgs

func (opts *TerragruntOptions) InsertTerraformCliArgs(argsToInsert ...string)

Inserts the given argsToInsert after the terraform command argument, but before the remaining args

func (*TerragruntOptions) OptionsFromContext

func (opts *TerragruntOptions) OptionsFromContext(ctx context.Context) *TerragruntOptions

OptionsFromContext tries to retrieve options from context, otherwise, returns its own instance.

func (*TerragruntOptions) TerraformDataDir

func (opts *TerragruntOptions) TerraformDataDir() string

TerraformDataDir returns Terraform data directory (.terraform by default, overridden by $TF_DATA_DIR envvar)