parse

package
v1.6.6 Latest Latest
Warning

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

 Go to latest Published: Nov 21, 2024 License: AGPL-3.0 Imports: 48 Imported by: 2

Documentation

Index

Constants

View Source 
const RootDependencyNode = "RootDependencyNode"

Variables

View Source 
var BaseNotifierCtyType = cty.Capsule("BaseNotifierCtyType", reflect.TypeOf(&modconfig.NotifierImpl{}))
View Source 
var BenchmarkBlockSchema = &hcl.BodySchema{
	Attributes: []hcl.AttributeSchema{
		{Name: "children"},
		{Name: "description"},
		{Name: "documentation"},
		{Name: "tags"},
		{Name: "title"},

		{Name: "width"},
		{Name: "base"},
		{Name: "type"},
		{Name: "display"},
	},
}
View Source 
var ConnectionBlockSchema = &hcl.BodySchema{
	Attributes: []hcl.AttributeSchema{
		{
			Name:     "plugin",
			Required: true,
		},
		{
			Name: "type",
		},
		{
			Name: "connections",
		},
		{
			Name: "import_schema",
		},
	},
	Blocks: []hcl.BlockHeaderSchema{
		{
			Type:       "options",
			LabelNames: []string{schema.LabelType},
		},
	},
}
View Source 
var DashboardBlockSchema = &hcl.BodySchema{
	Blocks: []hcl.BlockHeaderSchema{
		{
			Type:       schema.BlockTypeInput,
			LabelNames: []string{schema.LabelName},
		},
		{
			Type:       schema.BlockTypeParam,
			LabelNames: []string{schema.LabelName},
		},
		{
			Type: schema.BlockTypeWith,
		},
		{
			Type: schema.BlockTypeContainer,
		},
		{
			Type: schema.BlockTypeCard,
		},
		{
			Type: schema.BlockTypeChart,
		},
		{
			Type: schema.BlockTypeBenchmark,
		},
		{
			Type: schema.BlockTypeControl,
		},
		{
			Type: schema.BlockTypeFlow,
		},
		{
			Type: schema.BlockTypeGraph,
		},
		{
			Type: schema.BlockTypeHierarchy,
		},
		{
			Type: schema.BlockTypeImage,
		},
		{
			Type: schema.BlockTypeTable,
		},
		{
			Type: schema.BlockTypeText,
		},
	},
}

DashboardBlockSchema is only used to validate the blocks of a Dashboard

View Source 
var DashboardContainerBlockSchema = &hcl.BodySchema{
	Blocks: []hcl.BlockHeaderSchema{
		{
			Type:       schema.BlockTypeInput,
			LabelNames: []string{schema.LabelName},
		},
		{
			Type:       schema.BlockTypeParam,
			LabelNames: []string{schema.LabelName},
		},
		{
			Type: schema.BlockTypeContainer,
		},
		{
			Type: schema.BlockTypeCard,
		},
		{
			Type: schema.BlockTypeChart,
		},
		{
			Type: schema.BlockTypeBenchmark,
		},
		{
			Type: schema.BlockTypeControl,
		},
		{
			Type: schema.BlockTypeFlow,
		},
		{
			Type: schema.BlockTypeGraph,
		},
		{
			Type: schema.BlockTypeHierarchy,
		},
		{
			Type: schema.BlockTypeImage,
		},
		{
			Type: schema.BlockTypeTable,
		},
		{
			Type: schema.BlockTypeText,
		},
	},
}

DashboardContainerBlockSchema is only used to validate the blocks of a DashboardContainer

View Source 
var FlowpipeConfigBlockSchema = &hcl.BodySchema{
	Attributes: []hcl.AttributeSchema{},
	Blocks: []hcl.BlockHeaderSchema{
		{

			Type:       schema.BlockTypeConnection,
			LabelNames: []string{schema.LabelType, schema.LabelName},
		},
		{
			Type:       schema.BlockTypeOptions,
			LabelNames: []string{"type"},
		},
		{
			Type:       schema.BlockTypeWorkspaceProfile,
			LabelNames: []string{schema.LabelName},
		},
		{
			Type:       schema.BlockTypeCredential,
			LabelNames: []string{schema.LabelType, schema.LabelName},
		},
		{
			Type:       schema.BlockTypeCredentialImport,
			LabelNames: []string{schema.LabelName},
		},
		{
			Type:       schema.BlockTypeConnectionImport,
			LabelNames: []string{schema.LabelName},
		},
		{
			Type:       schema.BlockTypeIntegration,
			LabelNames: []string{schema.LabelType, schema.LabelName},
		},
		{
			Type:       schema.BlockTypeNotifier,
			LabelNames: []string{schema.LabelName},
		},
		{
			Type:       schema.BlockTypeOptions,
			LabelNames: []string{"type"},
		},
		{
			Type:       schema.BlockTypeWorkspaceProfile,
			LabelNames: []string{"name"},
		},
	},
}

FlowpipeConfigBlockSchema defines the config schema for Flowpipe config blocks. The connection block setup is different, Steampipe only has one label while Pipelingconnections has 2 labels. Credential, CredentialImport, Integration and Notifer are specific to Flowpipe

View Source 
var NodeAndEdgeProviderSchema = &hcl.BodySchema{
	Attributes: []hcl.AttributeSchema{
		{Name: "args"},
	},
	Blocks: []hcl.BlockHeaderSchema{
		{
			Type:       "param",
			LabelNames: []string{schema.LabelName},
		},
		{
			Type:       "category",
			LabelNames: []string{schema.LabelName},
		},
		{
			Type:       "with",
			LabelNames: []string{schema.LabelName},
		},
		{
			Type: schema.BlockTypeNode,
		},
		{
			Type: schema.BlockTypeEdge,
		},
	},
}

NodeAndEdgeProviderSchema is used to decode graph/hierarchy/flow (EXCEPT categories)

View Source 
var ParamDefBlockSchema = &hcl.BodySchema{
	Attributes: []hcl.AttributeSchema{
		{Name: "description"},
		{Name: "default"},
	},
}
View Source 
var PluginBlockSchema = &hcl.BodySchema{
	Attributes: []hcl.AttributeSchema{},
	Blocks: []hcl.BlockHeaderSchema{
		{
			Type:       schema.BlockTypeRateLimiter,
			LabelNames: []string{schema.LabelName},
		},
	},
}
View Source 
var PowerpipeConfigBlockSchema = &hcl.BodySchema{
	Attributes: []hcl.AttributeSchema{},
	Blocks: []hcl.BlockHeaderSchema{
		{

			Type:       schema.BlockTypeConnection,
			LabelNames: []string{schema.LabelType, schema.LabelName},
		},
		{
			Type:       schema.BlockTypeWorkspaceProfile,
			LabelNames: []string{"name"},
		},
	},
}

PowerpipeConfigBlockSchema defines the config schema for Flowpipe config blocks. The connection block setup is different, Steampipe only has one label while Pipelingconnections has 2 labels. Credential, CredentialImport, Integration and Notifer are specific to Flowpipe

View Source 
var QueryProviderBlockSchema = &hcl.BodySchema{
	Attributes: []hcl.AttributeSchema{
		{Name: "args"},
	},
	Blocks: []hcl.BlockHeaderSchema{
		{
			Type:       "param",
			LabelNames: []string{schema.LabelName},
		},
		{
			Type:       "with",
			LabelNames: []string{schema.LabelName},
		},
	},
}

QueryProviderBlockSchema schema for all blocks satisfying QueryProvider interface NOTE: these are just the blocks/attributes that are explicitly decoded other query provider properties are implicitly decoded using tags

View Source 
var SteampipeConfigBlockSchema = &hcl.BodySchema{
	Attributes: []hcl.AttributeSchema{},
	Blocks: []hcl.BlockHeaderSchema{
		{
			Type:       schema.BlockTypeConnection,
			LabelNames: []string{schema.LabelName},
		},
		{
			Type:       schema.BlockTypePlugin,
			LabelNames: []string{schema.LabelName},
		},
		{
			Type:       schema.BlockTypeOptions,
			LabelNames: []string{"type"},
		},
		{
			Type:       schema.BlockTypeWorkspaceProfile,
			LabelNames: []string{schema.LabelName},
		},
		{
			Type:       schema.BlockTypePartition,
			LabelNames: []string{schema.LabelType, schema.LabelName},
		},
	},
}
View Source 
var VariableBlockSchema = &hcl.BodySchema{
	Attributes: []hcl.AttributeSchema{
		{
			Name: schema.AttributeTypeTitle,
		},
		{
			Name: schema.AttributeTypeDescription,
		},
		{
			Name: schema.AttributeTypeDefault,
		},
		{
			Name: schema.AttributeTypeType,
		},
		{
			Name: schema.AttributeTypeSensitive,
		},
		{
			Name: schema.AttributeTypeTags,
		},
		{
			Name: schema.AttributeTypeEnum,
		},
		{
			Name: schema.AttributeTypeFormat,
		},
	},
	Blocks: []hcl.BlockHeaderSchema{
		{
			Type: "validation",
		},
	},
}
View Source 
var WorkspaceBlockSchema = &hcl.BodySchema{
	Attributes: []hcl.AttributeSchema{},
	Blocks: []hcl.BlockHeaderSchema{
		{
			Type:       string(schema.BlockTypeMod),
			LabelNames: []string{schema.LabelName},
		},
		{
			Type:       schema.BlockTypeVariable,
			LabelNames: []string{schema.LabelName},
		},
		{
			Type:       schema.BlockTypeQuery,
			LabelNames: []string{schema.LabelName},
		},
		{
			Type:       schema.BlockTypeControl,
			LabelNames: []string{schema.LabelName},
		},
		{
			Type:       schema.BlockTypeBenchmark,
			LabelNames: []string{schema.LabelName},
		},
		{
			Type:       schema.BlockTypeDashboard,
			LabelNames: []string{schema.LabelName},
		},
		{
			Type:       schema.BlockTypeCard,
			LabelNames: []string{schema.LabelName},
		},
		{
			Type:       schema.BlockTypeChart,
			LabelNames: []string{schema.LabelName},
		},
		{
			Type:       schema.BlockTypeFlow,
			LabelNames: []string{schema.LabelName},
		},
		{
			Type:       schema.BlockTypeGraph,
			LabelNames: []string{schema.LabelName},
		},
		{
			Type:       schema.BlockTypeHierarchy,
			LabelNames: []string{schema.LabelName},
		},
		{
			Type:       schema.BlockTypeImage,
			LabelNames: []string{schema.LabelName},
		},
		{
			Type:       schema.BlockTypeInput,
			LabelNames: []string{schema.LabelName},
		},
		{
			Type:       schema.BlockTypeTable,
			LabelNames: []string{schema.LabelName},
		},
		{
			Type:       schema.BlockTypeText,
			LabelNames: []string{schema.LabelName},
		},
		{
			Type:       schema.BlockTypeNode,
			LabelNames: []string{schema.LabelName},
		},
		{
			Type:       schema.BlockTypeEdge,
			LabelNames: []string{schema.LabelName},
		},
		{
			Type: schema.BlockTypeLocals,
		},
		{
			Type:       schema.BlockTypeCategory,
			LabelNames: []string{schema.LabelName},
		},

		{
			Type:       schema.BlockTypePipeline,
			LabelNames: []string{schema.LabelName},
		},
		{
			Type:       schema.BlockTypeTrigger,
			LabelNames: []string{schema.LabelType, schema.LabelName},
		},
		{
			Type:       schema.BlockTypeIntegration,
			LabelNames: []string{schema.LabelType, schema.LabelName},
		},
	},
}

WorkspaceBlockSchema is the top level schema for all workspace resources

View Source 
var WorkspaceProfileBlockSchema = &hcl.BodySchema{

	Blocks: []hcl.BlockHeaderSchema{
		{
			Type:       "options",
			LabelNames: []string{schema.LabelType},
		},
	},
}

Functions

func AddReferences 

func AddReferences(resource modconfig.HclResource, block *hcl.Block, parseCtx *ModParseContext) hcl.Diagnostics

AddReferences populates the 'References' resource field, used for the introspection tables

func AddResourceMetadata added in v1.0.2 

func AddResourceMetadata(resourceWithMetadata modconfig.ResourceWithMetadata, srcRange hcl.Range, parseCtx *ModParseContext) hcl.Diagnostics

func BuildNotifierMapForEvalContext added in v1.6.0 

func BuildNotifierMapForEvalContext(notifiers map[string]modconfig.Notifier) (map[string]cty.Value, error)

func BuildTemporaryConnectionMapForEvalContext added in v1.6.0 

func BuildTemporaryConnectionMapForEvalContext(allConnections map[string]connection.PipelingConnection) map[string]cty.Value

**WARNING** this function has a specific use case do not use

The key word is "temporary"

func CoerceParams added in v1.6.0 

func CoerceParams(p modconfig.ResourceWithParam, inputParams map[string]string, evalCtx *hcl.EvalContext) (map[string]interface{}, []error)

This is inefficient because we are coercing the value from string -> Go using Cty (because that's how the pipeline is defined) and again we convert from Go -> Cty when we're executing the pipeline to build EvalContext when we're evaluating data are not resolved during parse time.

func ConnectionNameFromTemporaryConnectionMap added in v1.6.0 

func ConnectionNameFromTemporaryConnectionMap(valueMap map[string]cty.Value) (string, bool)

func ConnectionNamesValueFromCtyValue added in v1.6.0 

func ConnectionNamesValueFromCtyValue(v cty.Value) (cty.Value, bool)

ConnectionNamesValueFromCtyValue takes the cty value of a variable, and if the variable contains one or more temporary connections, it builds a list of the connection names and returns as a cty value

func DecodeConnection 

func DecodeConnection(block *hcl.Block) (*modconfig.SteampipeConnection, hcl.Diagnostics)

func DecodeConnectionImport added in v1.6.0 

func DecodeConnectionImport(configPath string, block *hcl.Block) (*modconfig.ConnectionImport, hcl.Diagnostics)

func DecodeCredential 

func DecodeCredential(configPath string, block *hcl.Block) (credential.Credential, hcl.Diagnostics)

func DecodeCredentialImport added in v0.3.0 

func DecodeCredentialImport(configPath string, block *hcl.Block) (*credential.CredentialImport, hcl.Diagnostics)

func DecodeHclBody added in v1.6.0 

func DecodeHclBody(body hcl.Body, evalCtx *hcl.EvalContext, resourceProvider modconfig.ResourceProvider, resource modconfig.HclResource) (diags hcl.Diagnostics)

func DecodeIntegration added in v0.3.0 

func DecodeIntegration(configPath string, block *hcl.Block) (modconfig.Integration, hcl.Diagnostics)

func DecodeLimiter 

func DecodeLimiter(block *hcl.Block) (*plugin.RateLimiter, hcl.Diagnostics)

func DecodeNotifier added in v0.3.0 

func DecodeNotifier(configPath string, block *hcl.Block, evalCtx *hcl.EvalContext) (*modconfig.NotifierImpl, hcl.Diagnostics)

func DecodeOptions 

func DecodeOptions(block *hcl.Block, blockFactory modconfig.OptionsBlockFactory) (options.Options, hcl.Diagnostics)

DecodeOptions decodes an options block

func DecodePipelingConnection added in v1.6.0 

func DecodePipelingConnection(configPath string, block *hcl.Block) (connection.PipelingConnection, hcl.Diagnostics)

func DecodePlugin 

func DecodePlugin(block *hcl.Block) (*plugin.Plugin, hcl.Diagnostics)

func DecodeRequire added in v1.3.0 

func DecodeRequire(block *hcl.Block, evalCtx *hcl.EvalContext) (*modconfig.Require, hcl.Diagnostics)

func DecodeVarFormat added in v1.6.0 

func DecodeVarFormat(ty cty.Type, attr *hcl.Attribute, parseCtx *ModParseContext) (string, hcl.Diagnostics)

func DecodeVariableBlock added in v1.6.0 

func DecodeVariableBlock(block *hcl.Block, content *hcl.BodyContent, parseCtx *ModParseContext) (*modconfig.RawVariable, hcl.Diagnostics)

func DefaultWorkspaceSampleFileName added in v1.6.0 

func DefaultWorkspaceSampleFileName() string

func GetIntegrationBlockSchema 

func GetIntegrationBlockSchema(integrationType string) *hcl.BodySchema

func GetMetadataForParsedResource 

func GetMetadataForParsedResource(resourceName string, srcRange hcl.Range, fileData map[string][]byte, mod *modconfig.Mod) (*modconfig.ResourceMetadata, error)

func GetNestedStructValsRecursive added in v1.6.0 

func GetNestedStructValsRecursive(val any) ([]any, hcl.Diagnostics)

func GetPipelineStepBlockSchema 

func GetPipelineStepBlockSchema(stepType string) *hcl.BodySchema

func GetTriggerBlockSchema 

func GetTriggerBlockSchema(triggerType string) *hcl.BodySchema

func LoadFileData 

func LoadFileData(paths ...string) (map[string][]byte, hcl.Diagnostics)

LoadFileData builds a map of filepath to file data

func LoadModfile 

func LoadModfile(modPath string) (*modconfig.Mod, error)

func LoadWorkspaceProfiles 

func LoadWorkspaceProfiles[T workspace_profile.WorkspaceProfile](workspaceProfilePath string) (profileMap map[string]T, err error)

func ModFileExists added in v0.3.0 

func ModFileExists(modPath string) (string, bool)

ModFileExists returns whether a mod file exists at the specified path and if so returns the filepath

func ParseConfig added in v1.6.0 

func ParseConfig(configString []byte, filename string, startPos hcl.Pos) (hcl.Body, hcl.Diagnostics)

func ParseHclFiles 

func ParseHclFiles(fileData map[string][]byte) (hcl.Body, hcl.Diagnostics)

ParseHclFiles parses hcl file data and returns the hcl body object

func ParseJsonConfig added in v1.6.0 

func ParseJsonConfig(configString []byte, filename string) (hcl.Body, hcl.Diagnostics)

func ParseMod 

func ParseMod(_ context.Context, fileData map[string][]byte, parseCtx *ModParseContext) (*modconfig.Mod, error_helpers.ErrorAndWarnings)

ParseMod parses all source hcl files for the mod path and associated resources, and returns the mod object NOTE: the mod definition has already been parsed (or a default created) and is in opts.RunCtx.RootMod

func ParseModRequireAndShortName added in v1.3.0 

func ParseModRequireAndShortName(modFilePath string) (*modconfig.Require, string, hcl.Diagnostics)

ParseModRequireAndShortName is used when migrating the workspace lock It loads the require block from the mod file and returns the require object, as well as the mod short name The migration occurs the first time the workspace lock is loaded - this will be when we load the variables the migration is done by simply installing the workspace dependencies At this point we have not yet loaded the full mod definition so the require block is not yet loaded - we need to manually load the require block, as well as the mod short name, which is used as a key in the workspace lock

func ParseQueryInvocation 

func ParseQueryInvocation(arg string) (string, *modconfig.QueryArgs, error)

ParseQueryInvocation parses a query invocation and extracts the args (if any) supported formats are:

1) positional args query.my_query("val1","val2")

2) named args query.my_query(my_arg1 => "test", my_arg2 => "test2")

func ResolveConnectionImportSource added in v1.6.0 

func ResolveConnectionImportSource(source *string) ([]string, error)

func ResolveCredentialImportSource added in v0.3.0 

func ResolveCredentialImportSource(source *string) ([]string, error)

func ValidateName added in v1.6.0 

func ValidateName(block *hcl.Block) hcl.Diagnostics

func ValidateParams added in v1.6.0 

func ValidateParams(p modconfig.ResourceWithParam, inputParams map[string]interface{}, evalCtx *hcl.EvalContext) []error

func VariableValueCtyMap 

func VariableValueCtyMap(variables map[string]*modconfig.Variable, supportLateBinding bool) (ret, lateBindingVars, lateBindingVarDeps map[string]cty.Value)

VariableValueCtyMap converts a map of variables to a map of the underlying cty value Note: if the variable type is a late binding type (i.e. PipelingConnection), DO NOT add to map

Types

type DecodeResult 

type DecodeResult struct {
	Diags   hcl.Diagnostics
	Depends map[string]*modconfig.ResourceDependency
}

struct to hold the result of a decoding operation

func NewDecodeResult added in v1.6.0 

func NewDecodeResult() *DecodeResult

func ParseModDefinition 

func ParseModDefinition(modFilePath string, evalCtx *hcl.EvalContext) (*modconfig.Mod, *DecodeResult)

ParseModDefinition parses the modfile only it is expected the calling code will have verified the existence of the modfile by calling ModfileExists this is called before parsing the workspace to, for example, identify dependency mods

This function only parse the "mod" block, and does not parse any resources in the mod file

func (*DecodeResult) AddDiags added in v1.6.0 

func (p *DecodeResult) AddDiags(diags hcl.Diagnostics)

func (*DecodeResult) HandleDecodeDiags added in v1.6.0 

func (p *DecodeResult) HandleDecodeDiags(diags hcl.Diagnostics)

HandleDecodeDiags adds dependencies to the result if the diags contains dependency errors, otherwise adds diags to the result

func (*DecodeResult) Merge 

func (p *DecodeResult) Merge(other *DecodeResult) *DecodeResult

Merge merges this decode result with another

func (*DecodeResult) Success 

func (p *DecodeResult) Success() bool

Success returns if the was parsing successful - true if there are no errors and no dependencies

func (*DecodeResult) VariableDependenciesToWarnings added in v1.6.0 

func (p *DecodeResult) VariableDependenciesToWarnings() []string

type InstalledMod 

type InstalledMod struct {
	Mod     *modconfig.Mod
	Version *semver.Version
}

type ModDependencyConfig 

type ModDependencyConfig struct {
	ModDependency  *versionmap.ResolvedVersionConstraint
	DependencyPath *string
}

func NewDependencyConfig 

func NewDependencyConfig(modDependency *versionmap.ResolvedVersionConstraint) *ModDependencyConfig

func (ModDependencyConfig) SetModProperties 

func (c ModDependencyConfig) SetModProperties(mod *modconfig.Mod)

type ModParseContext 

type ModParseContext struct {
	ParseContext

	// PipelineHcls map[string]*modconfig.Pipeline
	TriggerHcls     map[string]*modconfig.Trigger
	IntegrationHcls map[string]modconfig.Integration

	// the mod which is currently being parsed
	CurrentMod *modconfig.Mod
	// the workspace lock data
	WorkspaceLock *versionmap.WorkspaceLock

	Flags       ParseModFlag
	ListOptions filehelpers.ListOptions

	// Variables is a tree of maps of the variables in the current mod and child dependency mods
	Variables *modconfig.ModVariableMap

	// Credentials are something different, it's not part of the mod, it's not part of the workspace, it is at the same level
	// with mod and workspace. However it can be reference by the mod, so it needs to be in the parse context
	Credentials         map[string]credential.Credential
	CredentialImports   map[string]credential.CredentialImport
	PipelingConnections map[string]connection.PipelingConnection
	ConnectionImports   map[string]modconfig.ConnectionImport
	Integrations        map[string]modconfig.Integration
	Notifiers           map[string]modconfig.Notifier

	ParentParseCtx *ModParseContext

	// if we are loading dependency mod, this contains the details
	DependencyConfig *ModDependencyConfig
	// contains filtered or unexported fields
}

func NewChildModParseContext 

func NewChildModParseContext(parent *ModParseContext, modVersion *versionmap.ResolvedVersionConstraint, rootEvalPath string) (*ModParseContext, error)

func NewModParseContext 

func NewModParseContext(workspaceLock *versionmap.WorkspaceLock, rootEvalPath string, opts ...ModParseContextOption) (*ModParseContext, error)

func (*ModParseContext) AddDependencies 

func (m *ModParseContext) AddDependencies(block *hcl.Block, name string, dependencies map[string]*modconfig.ResourceDependency) hcl.Diagnostics

AddDependencies :: the block could not be resolved as it has dependencies 1) store block as unresolved 2) add dependencies to our tree of dependencies

func (*ModParseContext) AddInputVariableValues 

func (m *ModParseContext) AddInputVariableValues(inputVariables *modconfig.ModVariableMap)

AddInputVariableValues adds evaluated variables to the run context. This function is called for the root run context after loading all input variables

func (*ModParseContext) AddLoadedDependencyMod 

func (m *ModParseContext) AddLoadedDependencyMod(mod *modconfig.Mod)

func (*ModParseContext) AddModResources 

func (m *ModParseContext) AddModResources(mod *modconfig.Mod) hcl.Diagnostics

AddModResources is used to add mod resources to the eval context

func (*ModParseContext) AddPipeline 

func (m *ModParseContext) AddPipeline(pipelineHcl *modconfig.Pipeline) hcl.Diagnostics

TODO: transition period AddPipeline stores this resource as a variable to be added to the eval context. It alse

func (*ModParseContext) AddResource 

func (m *ModParseContext) AddResource(resource modconfig.HclResource) hcl.Diagnostics

AddResource stores this resource as a variable to be added to the eval context.

func (*ModParseContext) AddTrigger 

func (m *ModParseContext) AddTrigger(trigger *modconfig.Trigger) hcl.Diagnostics

func (*ModParseContext) AddVariablesToEvalContext 

func (m *ModParseContext) AddVariablesToEvalContext()

func (*ModParseContext) DetermineBlockName 

func (m *ModParseContext) DetermineBlockName(block *hcl.Block) string

DetermineBlockName determines if the block is anonymous, and if so, returns a unique name for the block, based on its type and parent

func (*ModParseContext) EnsureWorkspaceLock 

func (m *ModParseContext) EnsureWorkspaceLock(mod *modconfig.Mod) error

func (*ModParseContext) GetCachedBlockName 

func (m *ModParseContext) GetCachedBlockName(block *hcl.Block) (string, bool)

func (*ModParseContext) GetCachedBlockShortName 

func (m *ModParseContext) GetCachedBlockShortName(block *hcl.Block) (string, bool)

func (*ModParseContext) GetDecodedResourceForBlock 

func (m *ModParseContext) GetDecodedResourceForBlock(block *hcl.Block) (modconfig.HclResource, bool)

func (*ModParseContext) GetMod 

func (m *ModParseContext) GetMod(modShortName string) *modconfig.Mod

GetMod finds the mod with given short name, looking only in first level dependencies this is used to resolve resource references specifically when the 'children' property of dashboards and benchmarks refers to resource in a dependency mod

func (*ModParseContext) GetResource 

func (m *ModParseContext) GetResource(parsedName *modconfig.ParsedResourceName) (resource modconfig.HclResource, found bool)

func (*ModParseContext) GetResourceMaps 

func (m *ModParseContext) GetResourceMaps() *modconfig.ResourceMaps

func (*ModParseContext) GetTopLevelDependencyMods 

func (m *ModParseContext) GetTopLevelDependencyMods() modconfig.ModMap

GetTopLevelDependencyMods build a mod map of top level loaded dependencies, keyed by mod name

func (*ModParseContext) IsTopLevelBlock 

func (m *ModParseContext) IsTopLevelBlock(block *hcl.Block) bool

func (*ModParseContext) LoadVariablesOnly added in v1.0.0 

func (m *ModParseContext) LoadVariablesOnly() bool

LoadVariablesOnly returns whether we are ONLY loading variables

func (*ModParseContext) PeekParent 

func (m *ModParseContext) PeekParent() string

func (*ModParseContext) PopParent 

func (m *ModParseContext) PopParent() string

func (*ModParseContext) PushParent 

func (m *ModParseContext) PushParent(parent modconfig.ModTreeItem)

func (*ModParseContext) RebuildEvalContext added in v1.6.0 

func (m *ModParseContext) RebuildEvalContext()

RebuildEvalContext the eval context from the cached reference values

func (*ModParseContext) SetBlockTypeExclusions added in v1.0.0 

func (m *ModParseContext) SetBlockTypeExclusions(blockTypes ...string)

func (*ModParseContext) SetCurrentMod 

func (m *ModParseContext) SetCurrentMod(mod *modconfig.Mod) error

func (*ModParseContext) SetDecodeContent 

func (m *ModParseContext) SetDecodeContent(content *hcl.BodyContent, fileData map[string][]byte)

func (*ModParseContext) SetIncludeLateBindingResources added in v1.6.0 

func (m *ModParseContext) SetIncludeLateBindingResources(include bool)

SetIncludeLateBindingResources sets whether connections and notifiers should be included in the eval context and rebuilds the eval context

func (*ModParseContext) ShouldCreateDefaultMod 

func (m *ModParseContext) ShouldCreateDefaultMod() bool

ShouldCreateDefaultMod returns whether the flag is set to create a default mod if no mod definition exists

type ModParseContextOption added in v0.3.0 

type ModParseContextOption func(*ModParseContext)

func WithConnections added in v1.6.0 

func WithConnections(connections map[string]connection.PipelingConnection) ModParseContextOption

func WithLateBinding added in v1.6.0 

func WithLateBinding(enabled bool) ModParseContextOption

func WithListOptions added in v0.3.0 

func WithListOptions(listOptions filehelpers.ListOptions) ModParseContextOption

func WithParseFlags added in v0.3.0 

func WithParseFlags(flags ParseModFlag) ModParseContextOption

type ParseContext 

type ParseContext struct {
	UnresolvedBlocks map[string]*UnresolvedBlock
	FileData         map[string][]byte

	// the eval context used to decode references in HCL
	EvalCtx *hcl.EvalContext

	Diags hcl.Diagnostics

	RootEvalPath string

	DependencyGraph *topsort.Graph

	// function used to parse resource property path
	ResourceNameFromDependencyFunc func(propertyPath string) (string, error)
	// contains filtered or unexported fields
}

func NewParseContext 

func NewParseContext(rootEvalPath string) ParseContext

func (*ParseContext) AddDependencies 

func (p *ParseContext) AddDependencies(block *hcl.Block, name string, dependencies map[string]*modconfig.ResourceDependency) hcl.Diagnostics

AddDependencies is called when a block could not be resolved as it has dependencies 1) store block as unresolved 2) add dependencies to our tree of dependencies

func (*ParseContext) BlocksToDecode 

func (p *ParseContext) BlocksToDecode() (blocksToDecode hcl.Blocks, _ error)

BlocksToDecode builds a list of blocks to decode, the order of which is determined by the dependency order

func (*ParseContext) BuildEvalContext 

func (p *ParseContext) BuildEvalContext(variables map[string]cty.Value)

func (*ParseContext) ClearDependencies 

func (p *ParseContext) ClearDependencies()

func (*ParseContext) EvalComplete 

func (p *ParseContext) EvalComplete() bool

EvalComplete returns whether all elements in the dependency tree fully evaluated

func (*ParseContext) FormatDependencies 

func (p *ParseContext) FormatDependencies() string

func (*ParseContext) SetBlockTypes added in v1.6.0 

func (p *ParseContext) SetBlockTypes(blockTypes ...string)

func (*ParseContext) SetDecodeContent 

func (p *ParseContext) SetDecodeContent(content *hcl.BodyContent, fileData map[string][]byte)

type ParseModFlag 

type ParseModFlag uint32
const (
	CreateDefaultMod ParseModFlag = 1 << iota
)

type ReferenceTypeValueMap 

type ReferenceTypeValueMap map[string]map[string]cty.Value
ReferenceTypeValueMap is the raw data used to build the evaluation context

When resolving hcl references like : - query.q1 - var.v1 - mod1.query.my_query.sql

ReferenceTypeValueMap is keyed by resource type, then by resource name

type UnresolvedBlock added in v1.6.0 

type UnresolvedBlock struct {
	Name         string
	Block        *hcl.Block
	DeclRange    hcl.Range
	Dependencies map[string]*modconfig.ResourceDependency
}

func NewUnresolvedBlock added in v1.6.0 

func NewUnresolvedBlock(block *hcl.Block, name string, dependencies map[string]*modconfig.ResourceDependency) *UnresolvedBlock

func (UnresolvedBlock) String added in v1.6.0 

func (b UnresolvedBlock) String() string

type WorkspaceProfileLoader added in v1.6.0 

type WorkspaceProfileLoader[T workspace_profile.WorkspaceProfile] struct {
	DefaultProfile    T
	ConfiguredProfile T
	// contains filtered or unexported fields
}

func NewWorkspaceProfileLoader added in v1.6.0 

func NewWorkspaceProfileLoader[T workspace_profile.WorkspaceProfile](workspaceProfilePaths ...string) (*WorkspaceProfileLoader[T], error)

func (*WorkspaceProfileLoader[T]) GetActiveWorkspaceProfile added in v1.6.0 

func (l *WorkspaceProfileLoader[T]) GetActiveWorkspaceProfile() T

type WorkspaceProfileParseContext 

type WorkspaceProfileParseContext[T workspace_profile.WorkspaceProfile] struct {
	ParseContext
	// contains filtered or unexported fields
}

func NewWorkspaceProfileParseContext 

func NewWorkspaceProfileParseContext[T workspace_profile.WorkspaceProfile](rootEvalPath string) *WorkspaceProfileParseContext[T]

func (*WorkspaceProfileParseContext[T]) AddResource 

func (c *WorkspaceProfileParseContext[T]) AddResource(workspaceProfile T) hcl.Diagnostics

AddResource stores this resource as a variable to be added to the eval context. It alse

Source Files

View all Source files

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.