1 files changed, 473 insertions, 0 deletions

diff --git a/vendor/github.com/hashicorp/terraform/config/loader_hcl2.go b/vendor/github.com/hashicorp/terraform/config/loader_hcl2.go
new file mode 100644
index 0000000..4f9f129
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/config/loader_hcl2.go
@@ -0,0 +1,473 @@
+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 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
+}