hcl

package
v0.0.0-...-55ed90b Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 11, 2024 License: Apache-2.0 Imports: 33 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var TypeData = Type{
	// contains filtered or unexported fields
}
View Source 
var TypeLocal = Type{
	// contains filtered or unexported fields
}
View Source 
var TypeModule = Type{
	// contains filtered or unexported fields
}
View Source 
var TypeOutput = Type{
	// contains filtered or unexported fields
}
View Source 
var TypeProvider = Type{
	// contains filtered or unexported fields
}
View Source 
var TypeResource = Type{
	// contains filtered or unexported fields
}
View Source 
var TypeTerraform = Type{
	// contains filtered or unexported fields
}
View Source 
var TypeVariable = Type{
	// contains filtered or unexported fields
}
View Source 
var ValidTypes = []Type{
	TypeData,
	TypeLocal,
	TypeModule,
	TypeOutput,
	TypeProvider,
	TypeResource,
	TypeTerraform,
	TypeVariable,
}

Functions

func ExpFunctions 

func ExpFunctions(baseDir string, logger zerolog.Logger) map[string]function.Function

ExpFunctions returns the set of functions that should be used to when evaluating expressions in the receiving scope.

func SetUUIDAttributes 

func SetUUIDAttributes(address string, moduleBlock *Block, block *hcl.Block)

SetUUIDAttributes adds commonly used identifiers to the block so that it can be referenced by other blocks in context evaluation. The identifiers are only set if they don't already exist as attributes on the block.

Types

type Attribute 

type Attribute struct {
	// HCLAttr is the underlying hcl.Attribute that the Attribute references.
	HCLAttr *hcl.Attribute
	// Ctx is the context that the Attribute should be evaluated against. This propagates
	// any references from variables into the attribute.
	Ctx *Context
	// Verbose defines if the attribute should log verbose diagnostics messages to debug.
	Verbose bool
	Logger  zerolog.Logger
	// contains filtered or unexported fields
}

Attribute provides a wrapper struct around hcl.Attribute it provides helper methods and functionality for common interactions with hcl.Attribute.

Attributes are key/value pairs that are part of a Block. For example take the following Block: 

		resource "aws_instance" "t3_standard" {
		  	ami           = "fake_ami"
 		instance_type = "t3.medium"

 		credit_specification {
   			cpu_credits = "standard"
 		}
		}

"ami" & "instance_type" are the Attributes of this Block, "credit_specification" is a child Block see Block.Children for more info.

func (*Attribute) AllReferences 

func (attr *Attribute) AllReferences() []*Reference

AllReferences returns a list of References for the given Attribute. This can include the main Value Reference (see Reference method) and also a list of references used in conditional evaluation and templating.

func (*Attribute) AsInt 

func (attr *Attribute) AsInt() int64

AsInt returns the Attribute value as a int64. If the cty.Value is not a type that can be converted to integer, this method returns 0.

func (*Attribute) AsString 

func (attr *Attribute) AsString() string

AsString returns the Attribute value as a string. If the cty.Value is not a type that can be converted to string, this method returns an empty string.

func (*Attribute) Equals 

func (attr *Attribute) Equals(val interface{}) bool

Equals checks that val matches the underlying Attribute cty.Type.

func (*Attribute) HasChanged 

func (attr *Attribute) HasChanged() (change bool)

HasChanged returns if the Attribute Value has changed since Value was last called.

func (*Attribute) IsIterable 

func (attr *Attribute) IsIterable() bool

IsIterable returns if the attribute can be ranged over.

func (*Attribute) Name 

func (attr *Attribute) Name() string

Name is a helper method to return the underlying hcl.Attribute Name

func (*Attribute) Reference 

func (attr *Attribute) Reference() (*Reference, error)

Reference returns the pointer to a Reference struct that holds information about the Attributes referenced block. Reference achieves this by traversing the Attribute Expression in order to find the parent block. E.g. with the following HCL 

resource "aws_launch_template" "foo2" {
	name = "foo2"
}

resource "some_resource" "example_with_launch_template_3" {
	...
	name    = aws_launch_template.foo2.name
}

The Attribute some_resource.name would have a reference of 

Reference {
	blockType: Type{
		name:                  "resource",
		removeTypeInReference: true,
	}
	typeLabel: "aws_launch_template"
	nameLabel: "foo2"
}

Reference is used to build up a Terraform JSON configuration file that holds information about the expressions and their parents. Infracost uses these references in resource evaluation to lookup connecting resource information.

func (*Attribute) Value 

func (attr *Attribute) Value() cty.Value

Value returns the Attribute with the underlying hcl.Expression of the hcl.Attribute evaluated with the Attribute Context. This returns a cty.Value with the values filled from any variables or references that the Context carries.

type Block 

type Block struct {
	Filename  string
	StartLine int
	EndLine   int
	// contains filtered or unexported fields
}

Block wraps a hcl.Block type with additional methods and context. A Block is a core piece of HCL schema and represents a set of data. Most importantly a Block directly corresponds to a schema.Resource.

Blocks can represent a number of different types - see terraformSchemaV012 for a list of potential HCL blocks available.

e.g. a type resource block could look like this in HCL: 

		resource "aws_lb" "lb1" {
  		load_balancer_type = "application"
		}

A Block can also have a set number of child Blocks, these child Blocks in turn can also have children. Blocks are recursive. The following example is represents a resource Block with child Blocks: 

		resource "aws_instance" "t3_standard_cpuCredits" {
		  	ami           = "fake_ami"
 		instance_type = "t3.medium"

			# child Block starts here
 		credit_specification {
   			cpu_credits = "standard"
 		}
		}

See Attribute for more info about how the values of Blocks are evaluated with their Context and returned.

func (*Block) AttributesAsMap 

func (b *Block) AttributesAsMap() map[string]*Attribute

AttributesAsMap returns the Attributes of this block as a map with the attribute name as the key and the value as the Attribute.

func (*Block) CallDetails 

func (b *Block) CallDetails() []ModuleMetadata

CallDetails returns the tree of module calls that were used to create this resource. Each step of the tree contains a full file path and block name that were used to create the resource.

CallDetails returns a list of ModuleMetadata that are ordered by appearance in the Terraform config tree.

func (*Block) Children 

func (b *Block) Children() Blocks

Children returns all the child Blocks associated with this Block.

func (*Block) Context 

func (b *Block) Context() *Context

func (*Block) FullName 

func (b *Block) FullName() string

FullName returns the fully qualified Reference name as it relates to the Blocks position in the entire Terraform config tree. This includes module name. e.g.

The following resource residing in a module named "web_app": 

		resource "aws_instance" "t3_standard" {
		  	ami           = "fake_ami"
 		instance_type = var.instance_type
		}

Would have its FullName as module.web_app.aws_instance.t3_standard FullName is what Terraform uses in its JSON output file.

func (*Block) GetAttribute 

func (b *Block) GetAttribute(name string) *Attribute

GetAttribute returns the given attribute with the provided name. It will return nil if the attribute is not found. If we take the following Block example: 

		resource "aws_instance" "t3_standard_cpuCredits" {
		  	ami           = "fake_ami"
 		instance_type = "t3.medium"

 		credit_specification {
   			cpu_credits = "standard"
 		}
		}

ami & instance_type are both valid Attribute names that can be used to lookup Block Attributes.

func (*Block) GetAttributes 

func (b *Block) GetAttributes() []*Attribute

GetAttributes returns a list of Attribute for this Block. Attributes are key value specification on a given Block. For example take the following hcl: 

		resource "aws_instance" "t3_standard_cpuCredits" {
		  	ami           = "fake_ami"
 		instance_type = "t3.medium"

 		credit_specification {
   			cpu_credits = "standard"
 		}
		}

ami & instance_type are the Attributes of this Block and credit_specification is a child Block.

func (*Block) GetChildBlock 

func (b *Block) GetChildBlock(name string) *Block

GetChildBlock is a helper method around GetChildBlocks. It returns the first non nil child block matching name.

func (*Block) GetChildBlocks 

func (b *Block) GetChildBlocks(name string) []*Block

GetChildBlocks returns all the child Block that match the name provided. e.g: If the current Block looks like such: 

		resource "aws_instance" "t3_standard_cpuCredits" {
		  	ami           = "fake_ami"
 		instance_type = "t3.medium"

 		credit_specification {
   			cpu_credits = "standard"
 		}

			ebs_block_device {
				device_name = "xvdj"
			}
		}

Then "credit_specification" & "ebs_block_device" would be valid names that could be used to retrieve child Blocks.

func (*Block) HasChild 

func (b *Block) HasChild(childElement string) bool

func (*Block) HasModuleBlock 

func (b *Block) HasModuleBlock() bool

HasModuleBlock returns is the Block as a module associated with it. If it doesn't this means that this Block is part of the root Module.

func (*Block) Index 

func (b *Block) Index() *int64

Index returns the count index of the block using the name label. Index returns nil if the block has no count.

func (*Block) InjectBlock 

func (b *Block) InjectBlock(block *Block, name string)

InjectBlock takes a block and appends it to the Blocks childBlocks with the Block's attributes set as contextual values on the child. In most cases this is because we've expanded the block into further Blocks as part of a count or for_each.

func (*Block) IsCountExpanded 

func (b *Block) IsCountExpanded() bool

IsCountExpanded returns if the Block has been expanded as part of a for_each or count evaluation.

func (*Block) IsForEachReferencedExpanded 

func (b *Block) IsForEachReferencedExpanded(moduleBlocks Blocks) bool

IsForEachReferencedExpanded checks if the block referenced under the for_each has already been expanded. This is used to check is we can safely expand this block, expanding block prematurely can lead to output inconsistencies. It is advised to always check if that the block has any references that are yet to be expanded before expanding itself.

func (*Block) Key 

func (b *Block) Key() *string

Key returns the foreach key of the block using the name label. Key returns nil if the block has no each key.

func (*Block) Label 

func (b *Block) Label() string

func (*Block) Labels 

func (b *Block) Labels() []string

func (*Block) LocalName 

func (b *Block) LocalName() string

LocalName is the name relative to the current module

func (*Block) ModuleAddress 

func (b *Block) ModuleAddress() string

ModuleAddress returns the address of the module associated with this Block or "" if it is part of the root Module

func (*Block) ModuleName 

func (b *Block) ModuleName() string

ModuleName returns the name of the module associated with this Block or "" if it is part of the root Module

func (*Block) ModuleSource 

func (b *Block) ModuleSource() string

ModuleSource returns the "source" attribute from the associated Module or "" if it is part of the root Module

func (*Block) NameLabel 

func (b *Block) NameLabel() string

func (*Block) Provider 

func (b *Block) Provider() string

Provider returns the provider by first checking if it is explicitly set as an attribute, if it is not the first word in the snake_case name of the type is returned. E.g. the type 'aws_instance' would return provider 'aws'

func (*Block) Reference 

func (b *Block) Reference() *Reference

Reference returns a Reference to the given Block this can be used to when printing out full names of Blocks to stdout or a file.

func (*Block) RemoveDynamicBlocks 

func (b *Block) RemoveDynamicBlocks(name string)

RemoveDynamicBlocks removes all the child Blocks of type name that have a parent of type "dynamic".

func (*Block) SetContext 

func (b *Block) SetContext(ctx *Context)

SetContext sets the Block.context to the provided ctx. This ctx is also set on the child Blocks as a child Context. Meaning that it can be used in traversal evaluation when looking up Context variables.

func (*Block) ShouldExpand 

func (b *Block) ShouldExpand() bool

func (*Block) Type 

func (b *Block) Type() string

func (*Block) TypeLabel 

func (b *Block) TypeLabel() string

func (*Block) Values 

func (b *Block) Values() cty.Value

Values returns the Block as a cty.Value with all the Attributes evaluated with the Block Context. This means that any variables or references will be replaced by their actual value. For example: 

		variable "instance_type" {
			default = "t3.medium"
		}

		resource "aws_instance" "t3_standard_cpucredits" {
		  	ami           = "fake_ami"
 		instance_type = var.instance_type
		}

Would evaluate to a cty.Value of type Object with the instance_type Attribute holding the value "t3.medium".

type BlockBuilder 

type BlockBuilder struct {
	MockFunc      func(a *Attribute) cty.Value
	SetAttributes []SetAttributesFunc
	Logger        zerolog.Logger
}

BlockBuilder handles generating new Blocks as part of the parsing and evaluation process.

func (BlockBuilder) BuildModuleBlocks 

func (b BlockBuilder) BuildModuleBlocks(block *Block, modulePath string, rootPath string) (Blocks, error)

BuildModuleBlocks loads all the Blocks for the module at the given path

func (BlockBuilder) CloneBlock 

func (b BlockBuilder) CloneBlock(block *Block, index cty.Value) *Block

CloneBlock creates a duplicate of the block and sets the returned Block's Context to include the index provided. This is primarily used when Blocks are expanded as part of a count evaluation.

func (BlockBuilder) NewBlock 

func (b BlockBuilder) NewBlock(filename string, rootPath string, hclBlock *hcl.Block, ctx *Context, parent *Block, moduleBlock *Block) *Block

NewBlock returns a Block with Context and child Blocks initialised.

type BlockMatcher 

type BlockMatcher struct {
	Type       string
	Label      string
	StripCount bool
}

BlockMatcher defines a struct that can be used to filter a list of blocks to a single Block.

type BlockValueFunc 

type BlockValueFunc = func(b *Block) cty.Value

BlockValueFunc defines a type that returns a set of fake/mocked values for a given block type.

type Blocks 

type Blocks []*Block

Blocks is a helper type around a slice of blocks to provide easy access finding blocks of type.

func (Blocks) Matching 

func (blocks Blocks) Matching(pattern BlockMatcher) *Block

Matching returns a single block filtered from the given pattern. If more than one Block is filtered by the pattern, Matching returns the first Block found.

func (Blocks) ModuleBlocks 

func (blocks Blocks) ModuleBlocks() Blocks

ModuleBlocks is a wrapper around SortedByCaller that selects just Modules to be sorted.

func (Blocks) OfType 

func (blocks Blocks) OfType(t string) Blocks

OfType returns Blocks of the given type t. See terraformSchemaV012 for a list of possible types to lookup.

func (Blocks) Outputs 

func (blocks Blocks) Outputs(suppressNil bool) cty.Value

Outputs returns a map of all the evaluated outputs from the list of Blocks.

func (Blocks) SortedByCaller 

func (blocks Blocks) SortedByCaller() Blocks

SortedByCaller returns all the Blocks of type module. The returned Blocks are sorted in order of reference. Blocks that are referenced by others are the first in this list.

So if we start with a list of [A,B,C] and A references B the returned list will be [B,A,C].

This makes the list returned safe for context evaluation, as we evaluate modules that have outputs that other modules rely on first.

type Context 

type Context struct {
	// contains filtered or unexported fields
}

func NewContext 

func NewContext(ctx *hcl.EvalContext, parent *Context, logger zerolog.Logger) *Context

func (*Context) Get 

func (c *Context) Get(parts ...string) (val cty.Value)

func (*Context) Inner 

func (c *Context) Inner() *hcl.EvalContext

func (*Context) NewChild 

func (c *Context) NewChild() *Context

func (*Context) Parent 

func (c *Context) Parent() *Context

func (*Context) Root 

func (c *Context) Root() *Context

func (*Context) Set 

func (c *Context) Set(val cty.Value, parts ...string)

func (*Context) SetByDot 

func (c *Context) SetByDot(val cty.Value, path string)

type Evaluator 

type Evaluator struct {
	// contains filtered or unexported fields
}

Evaluator provides a set of given Blocks with contextual information. Evaluator is an important step in retrieving Block values that can be used in the schema.Resource cost retrieval. Without Evaluator the Blocks provided only have shallow information within attributes and won't contain any evaluated variables or references.

func NewEvaluator 

func NewEvaluator(
	module Module,
	workingDir string,
	inputVars map[string]cty.Value,
	moduleMetadata *modules.Manifest,
	visitedModules map[string]map[string]cty.Value,
	workspace string,
	blockBuilder BlockBuilder,
	logger zerolog.Logger,
	parentContext *Context,
) *Evaluator

NewEvaluator returns an Evaluator with Context initialised with top level variables. This Context is then passed to all Blocks as child Context so that variables built in Evaluation are propagated to the Block Attributes.

func (*Evaluator) MissingVars 

func (e *Evaluator) MissingVars() []string

MissingVars returns a list of names of the variable blocks with missing input values.

func (*Evaluator) Run 

func (e *Evaluator) Run() (*Module, error)

Run builds the Evaluator Context using all the provided Blocks. It will build up the Context to hold variable and reference information so that this can be used by Attribute evaluation. Run will also parse and build up and child modules that are referenced in the Blocks and runs child Evaluator on this Module.

type Module 

type Module struct {
	Name   string
	Source string

	Blocks Blocks
	// RawBlocks are the Blocks that were built when the module was loaded from the filesystem.
	// These are safe to pass to the child module calls as they are yet to be expanded.
	RawBlocks  Blocks
	RootPath   string
	ModulePath string

	Modules  []*Module
	Parent   *Module
	Warnings []Warning

	HasChanges         bool
	TerraformVarsPaths []string

	// ModuleSuffix is a unique name that can be optionally appended to the Module's project name.
	// This is only applicable to root modules.
	ModuleSuffix string
}

Module encapsulates all the Blocks that are part of a Module in a Terraform project.

func (*Module) Index 

func (m *Module) Index() *int64

Index returns the count index of the Module using the name. Index returns nil if the Module has no count.

func (*Module) Key 

func (m *Module) Key() *string

Key returns the foreach key of the Module using the name. Key returns nil if the Module has no each key.

type ModuleCall 

type ModuleCall struct {
	// Name the name of the module as specified a the point of definition.
	Name string
	// Path is the path to the local directory containing the HCL for the Module.
	Path string
	// Definition is the actual Block where the ModuleCall happens in a hcl.File
	Definition *Block
	// Module contains the parsed root module that represents this ModuleCall.
	Module *Module
}

ModuleCall represents a call to a defined Module by a parent Module.

type ModuleMetadata 

type ModuleMetadata struct {
	Filename  string `json:"filename"`
	BlockName string `json:"blockName"`
	StartLine int    `json:"startLine,omitempty"`
	EndLine   int    `json:"endLine,omitempty"`
}

type Option 

type Option func(p *Parser)

func OptionWithInputVars 

func OptionWithInputVars(vars map[string]string) Option

OptionWithInputVars takes cmd line var input values and converts them to cty.Value It sets these as the Parser starting inputVars which are used at the root module evaluation.

func OptionWithModuleSuffix 

func OptionWithModuleSuffix(suffix string) Option

OptionWithModuleSuffix sets an optional module suffix which will be added to the Module after it has finished parsing this can be used to augment auto-detected project path names and metadata.

func OptionWithPlanFlagVars 

func OptionWithPlanFlagVars(vs []string) Option

OptionWithPlanFlagVars takes TF var inputs specified in a command line string and converts them to cty.Value It sets these as the Parser starting inputVars which are used at the root module evaluation.

func OptionWithRawCtyInput 

func OptionWithRawCtyInput(input cty.Value) (op Option)

OptionWithRawCtyInput sets the input variables for the parser using a cty.Value. OptionWithRawCtyInput expects that this input is a ObjectValue that can be transformed to a map.

func OptionWithRemoteVarLoader 

func OptionWithRemoteVarLoader(host, token, localWorkspace string) Option

OptionWithRemoteVarLoader accepts Terraform Cloud/Enterprise host and token values to load remote execution variables.

func OptionWithTFEnvVars 

func OptionWithTFEnvVars(projectEnv map[string]string) Option

OptionWithTFEnvVars takes any TF_ENV_xxx=yyy from the environment and converts them to cty.Value It then sets these as the Parser starting tfEnvVars which are used at the root module evaluation.

func OptionWithTFVarsPaths 

func OptionWithTFVarsPaths(paths []string) Option

OptionWithTFVarsPaths takes a slice of paths and sets them on the parser relative to the Parser initialPath. Paths that don't exist will be ignored.

func OptionWithTerraformWorkspace 

func OptionWithTerraformWorkspace(name string) Option

OptionWithTerraformWorkspace informs the Parser to use the provided name as the workspace for context evaluation. The Parser exposes this workspace in the evaluation context under the variable named `terraform.workspace`. This is commonly used by users to specify different capacity/configuration in their Terraform, e.g: 

terraform.workspace == "prod" ? "m5.8xlarge" : "m5.4xlarge"

type Parser 

type Parser struct {
	// contains filtered or unexported fields
}

Parser is a tool for parsing terraform templates at a given file system location.

func LoadParsers 

func LoadParsers(ctx *config.ProjectContext, initialPath string, loader *modules.ModuleLoader, locatorConfig *ProjectLocatorConfig, logger zerolog.Logger, options ...Option) ([]*Parser, error)

LoadParsers inits a list of Parser with the provided option and initialPath. LoadParsers locates Terraform files in the given initialPath and returns a Parser for each directory it locates a Terraform project within. If the initialPath contains Terraform files at the top level parsers will be len 1.

func (*Parser) ParseDirectory 

func (p *Parser) ParseDirectory() (m *Module, err error)

ParseDirectory parses all the terraform files in the initialPath into Blocks and then passes them to an Evaluator to fill these Blocks with additional Context information. Parser does not parse any blocks outside the root Module. It instead leaves ModuleLoader to fetch these Modules on demand. See ModuleLoader.Load for more information.

ParseDirectory returns the root Module that represents the top of the Terraform Config tree.

func (*Parser) Path 

func (p *Parser) Path() string

Path returns the full path that the parser runs within.

type ProjectLocator 

type ProjectLocator struct {
	// contains filtered or unexported fields
}

ProjectLocator finds Terraform projects for given paths. It naively excludes folders that are imported as modules in other projects.

func NewProjectLocator 

func NewProjectLocator(logger zerolog.Logger, config *ProjectLocatorConfig) *ProjectLocator

NewProjectLocator returns safely initialized ProjectLocator.

func (*ProjectLocator) FindRootModules 

func (p *ProjectLocator) FindRootModules(fullPath string) []RootPath

FindRootModules returns a list of all directories that contain a full Terraform project under the given fullPath. This list excludes any Terraform modules that have been found (if they have been called by a Module source).

type ProjectLocatorConfig 

type ProjectLocatorConfig struct {
	ExcludedSubDirs []string
	ChangedObjects  []string
	UseAllPaths     bool
}

ProjectLocatorConfig provides configuration options on how the locator functions.

type Reference 

type Reference struct {
	// contains filtered or unexported fields
}

func (*Reference) JSONString 

func (r *Reference) JSONString() string

JSONString returns the reference so that it's possible to use in the plan JSON file. This strips any count keys from the reference.

func (*Reference) SetKey 

func (r *Reference) SetKey(key cty.Value)

func (*Reference) String 

func (r *Reference) String() string

type RemoteVariablesLoader 

type RemoteVariablesLoader struct {
	// contains filtered or unexported fields
}

RemoteVariablesLoader handles loading remote variables from Terraform Cloud.

func NewRemoteVariablesLoader 

func NewRemoteVariablesLoader(client *extclient.AuthedAPIClient, localWorkspace string, logger zerolog.Logger, opts ...RemoteVariablesLoaderOption) *RemoteVariablesLoader

NewRemoteVariablesLoader constructs a new loader for fetching remote variables.

func (*RemoteVariablesLoader) Load 

func (r *RemoteVariablesLoader) Load(blocks Blocks) (map[string]cty.Value, error)

Load fetches remote variables if terraform block contains organization and workspace name.

type RemoteVariablesLoaderOption 

type RemoteVariablesLoaderOption func(r *RemoteVariablesLoader)

RemoteVariablesLoaderOption defines a function that can set properties on an RemoteVariablesLoader.

type RootPath 

type RootPath struct {
	Path string
	// HasChanges contains information about whether the project has git changes associated with it.
	// This will show as true if one or more files/directories have changed in the Path, and also if
	// and local modules that are used by this project have changes.
	HasChanges bool
	// TerraformVarFiles are a list of any .tfvars or .tfvars.json files found at the root level.
	TerraformVarFiles []string
}

RootPath holds information about the root directory of a project, this is normally the top level Terraform containing provider blocks.

type SetAttributesFunc 

type SetAttributesFunc func(address string, moduleBlock *Block, block *hcl.Block)

SetAttributesFunc defines a function that sets required attributes on a hcl.Block. This is done so that identifiers that are normally propagated from a Terraform state/apply are set on the Block. This means they can be used properly in references and outputs.

type Type 

type Type struct {
	// contains filtered or unexported fields
}

func TypeFromRefName 

func TypeFromRefName(name string) (*Type, error)

func (Type) Name 

func (t Type) Name() string

func (Type) ShortName 

func (t Type) ShortName() string

type Warning 

type Warning struct {
	Code  WarningCode
	Title string
	Data  interface{}

	// FriendlyMessage should be used to display a readable message to the CLI user.
	FriendlyMessage string
}

Warning holds information about non-critical errors that occurred within a module evaluation.

func NewMissingVarsWarning 

func NewMissingVarsWarning(vars []string) Warning

NewMissingVarsWarning returns a Warning using the WarningMissingVars error code. It expects that vars is a list of Terraform variables that cannot be found in the evaluation context.

type WarningCode 

type WarningCode int

WarningCode is used to delineate warnings across Infracost. 

const (
	WarningMissingVars WarningCode = iota + 1
)

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.