mirror of
https://github.com/opentofu/opentofu.git
synced 2025-02-25 18:45:20 -06:00
71e989ba3e
The value-conversion machinery is also needed in the main "terraform" package to help us populate our HCL2 evaluation scope, so a subset of the shim functions move here into a new package where they can be public. Some of them remain private within the config package since they depend on some other symbols in the config package, and they are not needed by outside callers anyway.
463 lines
12 KiB
Go
463 lines
12 KiB
Go
package config
|
|
|
|
import (
|
|
"fmt"
|
|
"sort"
|
|
"strings"
|
|
|
|
gohcl2 "github.com/hashicorp/hcl2/gohcl"
|
|
hcl2 "github.com/hashicorp/hcl2/hcl"
|
|
hcl2parse "github.com/hashicorp/hcl2/hclparse"
|
|
"github.com/hashicorp/terraform/config/hcl2shim"
|
|
"github.com/zclconf/go-cty/cty"
|
|
)
|
|
|
|
// hcl2Configurable is an implementation of configurable that knows
|
|
// how to turn a HCL Body into a *Config object.
|
|
type hcl2Configurable struct {
|
|
SourceFilename string
|
|
Body hcl2.Body
|
|
}
|
|
|
|
// hcl2Loader is a wrapper around a HCL parser that provides a fileLoaderFunc.
|
|
type hcl2Loader struct {
|
|
Parser *hcl2parse.Parser
|
|
}
|
|
|
|
// For the moment we'll just have a global loader since we don't have anywhere
|
|
// better to stash this.
|
|
// TODO: refactor the loader API so that it uses some sort of object we can
|
|
// stash the parser inside.
|
|
var globalHCL2Loader = newHCL2Loader()
|
|
|
|
// newHCL2Loader creates a new hcl2Loader containing a new HCL Parser.
|
|
//
|
|
// HCL parsers retain information about files that are loaded to aid in
|
|
// producing diagnostic messages, so all files within a single configuration
|
|
// should be loaded with the same parser to ensure the availability of
|
|
// full diagnostic information.
|
|
func newHCL2Loader() hcl2Loader {
|
|
return hcl2Loader{
|
|
Parser: hcl2parse.NewParser(),
|
|
}
|
|
}
|
|
|
|
// loadFile is a fileLoaderFunc that knows how to read a HCL2 file and turn it
|
|
// into a hcl2Configurable.
|
|
func (l hcl2Loader) loadFile(filename string) (configurable, []string, error) {
|
|
var f *hcl2.File
|
|
var diags hcl2.Diagnostics
|
|
if strings.HasSuffix(filename, ".json") {
|
|
f, diags = l.Parser.ParseJSONFile(filename)
|
|
} else {
|
|
f, diags = l.Parser.ParseHCLFile(filename)
|
|
}
|
|
if diags.HasErrors() {
|
|
// Return diagnostics as an error; callers may type-assert this to
|
|
// recover the original diagnostics, if it doesn't end up wrapped
|
|
// in another error.
|
|
return nil, nil, diags
|
|
}
|
|
|
|
return &hcl2Configurable{
|
|
SourceFilename: filename,
|
|
Body: f.Body,
|
|
}, nil, nil
|
|
}
|
|
|
|
func (t *hcl2Configurable) Config() (*Config, error) {
|
|
config := &Config{}
|
|
|
|
// these structs are used only for the initial shallow decoding; we'll
|
|
// expand this into the main, public-facing config structs afterwards.
|
|
type atlas struct {
|
|
Name string `hcl:"name"`
|
|
Include *[]string `hcl:"include"`
|
|
Exclude *[]string `hcl:"exclude"`
|
|
}
|
|
type module struct {
|
|
Name string `hcl:"name,label"`
|
|
Source string `hcl:"source,attr"`
|
|
Config hcl2.Body `hcl:",remain"`
|
|
}
|
|
type provider struct {
|
|
Name string `hcl:"name,label"`
|
|
Alias *string `hcl:"alias,attr"`
|
|
Version *string `hcl:"version,attr"`
|
|
Config hcl2.Body `hcl:",remain"`
|
|
}
|
|
type resourceLifecycle struct {
|
|
CreateBeforeDestroy *bool `hcl:"create_before_destroy,attr"`
|
|
PreventDestroy *bool `hcl:"prevent_destroy,attr"`
|
|
IgnoreChanges *[]string `hcl:"ignore_changes,attr"`
|
|
}
|
|
type connection struct {
|
|
Config hcl2.Body `hcl:",remain"`
|
|
}
|
|
type provisioner struct {
|
|
Type string `hcl:"type,label"`
|
|
|
|
When *string `hcl:"when,attr"`
|
|
OnFailure *string `hcl:"on_failure,attr"`
|
|
|
|
Connection *connection `hcl:"connection,block"`
|
|
Config hcl2.Body `hcl:",remain"`
|
|
}
|
|
type managedResource struct {
|
|
Type string `hcl:"type,label"`
|
|
Name string `hcl:"name,label"`
|
|
|
|
CountExpr hcl2.Expression `hcl:"count,attr"`
|
|
Provider *string `hcl:"provider,attr"`
|
|
DependsOn *[]string `hcl:"depends_on,attr"`
|
|
|
|
Lifecycle *resourceLifecycle `hcl:"lifecycle,block"`
|
|
Provisioners []provisioner `hcl:"provisioner,block"`
|
|
Connection *connection `hcl:"connection,block"`
|
|
|
|
Config hcl2.Body `hcl:",remain"`
|
|
}
|
|
type dataResource struct {
|
|
Type string `hcl:"type,label"`
|
|
Name string `hcl:"name,label"`
|
|
|
|
CountExpr hcl2.Expression `hcl:"count,attr"`
|
|
Provider *string `hcl:"provider,attr"`
|
|
DependsOn *[]string `hcl:"depends_on,attr"`
|
|
|
|
Config hcl2.Body `hcl:",remain"`
|
|
}
|
|
type variable struct {
|
|
Name string `hcl:"name,label"`
|
|
|
|
DeclaredType *string `hcl:"type,attr"`
|
|
Default *cty.Value `hcl:"default,attr"`
|
|
Description *string `hcl:"description,attr"`
|
|
Sensitive *bool `hcl:"sensitive,attr"`
|
|
}
|
|
type output struct {
|
|
Name string `hcl:"name,label"`
|
|
|
|
ValueExpr hcl2.Expression `hcl:"value,attr"`
|
|
DependsOn *[]string `hcl:"depends_on,attr"`
|
|
Description *string `hcl:"description,attr"`
|
|
Sensitive *bool `hcl:"sensitive,attr"`
|
|
}
|
|
type locals struct {
|
|
Definitions hcl2.Attributes `hcl:",remain"`
|
|
}
|
|
type backend struct {
|
|
Type string `hcl:"type,label"`
|
|
Config hcl2.Body `hcl:",remain"`
|
|
}
|
|
type terraform struct {
|
|
RequiredVersion *string `hcl:"required_version,attr"`
|
|
Backend *backend `hcl:"backend,block"`
|
|
}
|
|
type topLevel struct {
|
|
Atlas *atlas `hcl:"atlas,block"`
|
|
Datas []dataResource `hcl:"data,block"`
|
|
Modules []module `hcl:"module,block"`
|
|
Outputs []output `hcl:"output,block"`
|
|
Providers []provider `hcl:"provider,block"`
|
|
Resources []managedResource `hcl:"resource,block"`
|
|
Terraform *terraform `hcl:"terraform,block"`
|
|
Variables []variable `hcl:"variable,block"`
|
|
Locals []*locals `hcl:"locals,block"`
|
|
}
|
|
|
|
var raw topLevel
|
|
diags := gohcl2.DecodeBody(t.Body, nil, &raw)
|
|
if diags.HasErrors() {
|
|
// Do some minimal decoding to see if we can at least get the
|
|
// required Terraform version, which might help explain why we
|
|
// couldn't parse the rest.
|
|
if raw.Terraform != nil && raw.Terraform.RequiredVersion != nil {
|
|
config.Terraform = &Terraform{
|
|
RequiredVersion: *raw.Terraform.RequiredVersion,
|
|
}
|
|
}
|
|
|
|
// We return the diags as an implementation of error, which the
|
|
// caller than then type-assert if desired to recover the individual
|
|
// diagnostics.
|
|
// FIXME: The current API gives us no way to return warnings in the
|
|
// absense of any errors.
|
|
return config, diags
|
|
}
|
|
|
|
if raw.Terraform != nil {
|
|
var reqdVersion string
|
|
var backend *Backend
|
|
|
|
if raw.Terraform.RequiredVersion != nil {
|
|
reqdVersion = *raw.Terraform.RequiredVersion
|
|
}
|
|
if raw.Terraform.Backend != nil {
|
|
backend = new(Backend)
|
|
backend.Type = raw.Terraform.Backend.Type
|
|
|
|
// We don't permit interpolations or nested blocks inside the
|
|
// backend config, so we can decode the config early here and
|
|
// get direct access to the values, which is important for the
|
|
// config hashing to work as expected.
|
|
var config map[string]string
|
|
configDiags := gohcl2.DecodeBody(raw.Terraform.Backend.Config, nil, &config)
|
|
diags = append(diags, configDiags...)
|
|
|
|
raw := make(map[string]interface{}, len(config))
|
|
for k, v := range config {
|
|
raw[k] = v
|
|
}
|
|
|
|
var err error
|
|
backend.RawConfig, err = NewRawConfig(raw)
|
|
if err != nil {
|
|
diags = append(diags, &hcl2.Diagnostic{
|
|
Severity: hcl2.DiagError,
|
|
Summary: "Invalid backend configuration",
|
|
Detail: fmt.Sprintf("Error in backend configuration: %s", err),
|
|
})
|
|
}
|
|
}
|
|
|
|
config.Terraform = &Terraform{
|
|
RequiredVersion: reqdVersion,
|
|
Backend: backend,
|
|
}
|
|
}
|
|
|
|
if raw.Atlas != nil {
|
|
var include, exclude []string
|
|
if raw.Atlas.Include != nil {
|
|
include = *raw.Atlas.Include
|
|
}
|
|
if raw.Atlas.Exclude != nil {
|
|
exclude = *raw.Atlas.Exclude
|
|
}
|
|
config.Atlas = &AtlasConfig{
|
|
Name: raw.Atlas.Name,
|
|
Include: include,
|
|
Exclude: exclude,
|
|
}
|
|
}
|
|
|
|
for _, rawM := range raw.Modules {
|
|
m := &Module{
|
|
Name: rawM.Name,
|
|
Source: rawM.Source,
|
|
RawConfig: NewRawConfigHCL2(rawM.Config),
|
|
}
|
|
config.Modules = append(config.Modules, m)
|
|
}
|
|
|
|
for _, rawV := range raw.Variables {
|
|
v := &Variable{
|
|
Name: rawV.Name,
|
|
}
|
|
if rawV.DeclaredType != nil {
|
|
v.DeclaredType = *rawV.DeclaredType
|
|
}
|
|
if rawV.Default != nil {
|
|
v.Default = hcl2shim.ConfigValueFromHCL2(*rawV.Default)
|
|
}
|
|
if rawV.Description != nil {
|
|
v.Description = *rawV.Description
|
|
}
|
|
|
|
config.Variables = append(config.Variables, v)
|
|
}
|
|
|
|
for _, rawO := range raw.Outputs {
|
|
o := &Output{
|
|
Name: rawO.Name,
|
|
}
|
|
|
|
if rawO.Description != nil {
|
|
o.Description = *rawO.Description
|
|
}
|
|
if rawO.DependsOn != nil {
|
|
o.DependsOn = *rawO.DependsOn
|
|
}
|
|
if rawO.Sensitive != nil {
|
|
o.Sensitive = *rawO.Sensitive
|
|
}
|
|
|
|
// The result is expected to be a map like map[string]interface{}{"value": something},
|
|
// so we'll fake that with our hcl2shim.SingleAttrBody shim.
|
|
o.RawConfig = NewRawConfigHCL2(hcl2shim.SingleAttrBody{
|
|
Name: "value",
|
|
Expr: rawO.ValueExpr,
|
|
})
|
|
|
|
config.Outputs = append(config.Outputs, o)
|
|
}
|
|
|
|
for _, rawR := range raw.Resources {
|
|
r := &Resource{
|
|
Mode: ManagedResourceMode,
|
|
Type: rawR.Type,
|
|
Name: rawR.Name,
|
|
}
|
|
if rawR.Lifecycle != nil {
|
|
var l ResourceLifecycle
|
|
if rawR.Lifecycle.CreateBeforeDestroy != nil {
|
|
l.CreateBeforeDestroy = *rawR.Lifecycle.CreateBeforeDestroy
|
|
}
|
|
if rawR.Lifecycle.PreventDestroy != nil {
|
|
l.PreventDestroy = *rawR.Lifecycle.PreventDestroy
|
|
}
|
|
if rawR.Lifecycle.IgnoreChanges != nil {
|
|
l.IgnoreChanges = *rawR.Lifecycle.IgnoreChanges
|
|
}
|
|
r.Lifecycle = l
|
|
}
|
|
if rawR.Provider != nil {
|
|
r.Provider = *rawR.Provider
|
|
}
|
|
if rawR.DependsOn != nil {
|
|
r.DependsOn = *rawR.DependsOn
|
|
}
|
|
|
|
var defaultConnInfo *RawConfig
|
|
if rawR.Connection != nil {
|
|
defaultConnInfo = NewRawConfigHCL2(rawR.Connection.Config)
|
|
}
|
|
|
|
for _, rawP := range rawR.Provisioners {
|
|
p := &Provisioner{
|
|
Type: rawP.Type,
|
|
}
|
|
|
|
switch {
|
|
case rawP.When == nil:
|
|
p.When = ProvisionerWhenCreate
|
|
case *rawP.When == "create":
|
|
p.When = ProvisionerWhenCreate
|
|
case *rawP.When == "destroy":
|
|
p.When = ProvisionerWhenDestroy
|
|
default:
|
|
p.When = ProvisionerWhenInvalid
|
|
}
|
|
|
|
switch {
|
|
case rawP.OnFailure == nil:
|
|
p.OnFailure = ProvisionerOnFailureFail
|
|
case *rawP.When == "fail":
|
|
p.OnFailure = ProvisionerOnFailureFail
|
|
case *rawP.When == "continue":
|
|
p.OnFailure = ProvisionerOnFailureContinue
|
|
default:
|
|
p.OnFailure = ProvisionerOnFailureInvalid
|
|
}
|
|
|
|
if rawP.Connection != nil {
|
|
p.ConnInfo = NewRawConfigHCL2(rawP.Connection.Config)
|
|
} else {
|
|
p.ConnInfo = defaultConnInfo
|
|
}
|
|
|
|
p.RawConfig = NewRawConfigHCL2(rawP.Config)
|
|
|
|
r.Provisioners = append(r.Provisioners, p)
|
|
}
|
|
|
|
// The old loader records the count expression as a weird RawConfig with
|
|
// a single-element map inside. Since the rest of the world is assuming
|
|
// that, we'll mimic it here.
|
|
{
|
|
countBody := hcl2shim.SingleAttrBody{
|
|
Name: "count",
|
|
Expr: rawR.CountExpr,
|
|
}
|
|
|
|
r.RawCount = NewRawConfigHCL2(countBody)
|
|
r.RawCount.Key = "count"
|
|
}
|
|
|
|
r.RawConfig = NewRawConfigHCL2(rawR.Config)
|
|
|
|
config.Resources = append(config.Resources, r)
|
|
|
|
}
|
|
|
|
for _, rawR := range raw.Datas {
|
|
r := &Resource{
|
|
Mode: DataResourceMode,
|
|
Type: rawR.Type,
|
|
Name: rawR.Name,
|
|
}
|
|
|
|
if rawR.Provider != nil {
|
|
r.Provider = *rawR.Provider
|
|
}
|
|
if rawR.DependsOn != nil {
|
|
r.DependsOn = *rawR.DependsOn
|
|
}
|
|
|
|
// The old loader records the count expression as a weird RawConfig with
|
|
// a single-element map inside. Since the rest of the world is assuming
|
|
// that, we'll mimic it here.
|
|
{
|
|
countBody := hcl2shim.SingleAttrBody{
|
|
Name: "count",
|
|
Expr: rawR.CountExpr,
|
|
}
|
|
|
|
r.RawCount = NewRawConfigHCL2(countBody)
|
|
r.RawCount.Key = "count"
|
|
}
|
|
|
|
r.RawConfig = NewRawConfigHCL2(rawR.Config)
|
|
|
|
config.Resources = append(config.Resources, r)
|
|
}
|
|
|
|
for _, rawP := range raw.Providers {
|
|
p := &ProviderConfig{
|
|
Name: rawP.Name,
|
|
}
|
|
|
|
if rawP.Alias != nil {
|
|
p.Alias = *rawP.Alias
|
|
}
|
|
if rawP.Version != nil {
|
|
p.Version = *rawP.Version
|
|
}
|
|
|
|
// The result is expected to be a map like map[string]interface{}{"value": something},
|
|
// so we'll fake that with our hcl2shim.SingleAttrBody shim.
|
|
p.RawConfig = NewRawConfigHCL2(rawP.Config)
|
|
|
|
config.ProviderConfigs = append(config.ProviderConfigs, p)
|
|
}
|
|
|
|
for _, rawL := range raw.Locals {
|
|
names := make([]string, 0, len(rawL.Definitions))
|
|
for n := range rawL.Definitions {
|
|
names = append(names, n)
|
|
}
|
|
sort.Strings(names)
|
|
for _, n := range names {
|
|
attr := rawL.Definitions[n]
|
|
l := &Local{
|
|
Name: n,
|
|
RawConfig: NewRawConfigHCL2(hcl2shim.SingleAttrBody{
|
|
Name: "value",
|
|
Expr: attr.Expr,
|
|
}),
|
|
}
|
|
config.Locals = append(config.Locals, l)
|
|
}
|
|
}
|
|
|
|
// FIXME: The current API gives us no way to return warnings in the
|
|
// absense of any errors.
|
|
var err error
|
|
if diags.HasErrors() {
|
|
err = diags
|
|
}
|
|
|
|
return config, err
|
|
}
|