terraform/config/loader_hcl2.go

463 lines
12 KiB
Go
Raw Normal View History

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
}