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/configs/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 provider struct { Name string `hcl:"name,label"` Alias *string `hcl:"alias,attr"` Version *string `hcl:"version,attr"` Config hcl2.Body `hcl:",remain"` } type module struct { Name string `hcl:"name,label"` Source string `hcl:"source,attr"` Version *string `hcl:"version,attr"` Providers *map[string]string `hcl:"providers,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), } if rawM.Version != nil { m.Version = *rawM.Version } if rawM.Providers != nil { m.Providers = *rawM.Providers } 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 }