deps: github.com/hashicorp/terraform@sdk-v0.11-with-go-modules

Updated via: go get github.com/hashicorp/terraform@sdk-v0.11-with-go-modules and go mod tidy

6 files changed, 347 insertions, 0 deletions

diff --git a/vendor/github.com/hashicorp/terraform/config/configschema/decoder_spec.go b/vendor/github.com/hashicorp/terraform/config/configschema/decoder_spec.go
new file mode 100644
index 0000000..2b1b0ca
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/config/configschema/decoder_spec.go
@@ -0,0 +1,97 @@
+package configschema
+
+import (
+        "github.com/hashicorp/hcl2/hcldec"
+        "github.com/zclconf/go-cty/cty"
+)
+
+var mapLabelNames = []string{"key"}
+
+// DecoderSpec returns a hcldec.Spec that can be used to decode a HCL Body
+// using the facilities in the hcldec package.
+//
+// The returned specification is guaranteed to return a value of the same type
+// returned by method ImpliedType, but it may contain null or unknown values if
+// any of the block attributes are defined as optional and/or computed
+// respectively.
+func (b *Block) DecoderSpec() hcldec.Spec {
+        ret := hcldec.ObjectSpec{}
+        if b == nil {
+                return ret
+        }
+
+        for name, attrS := range b.Attributes {
+                switch {
+                case attrS.Computed && attrS.Optional:
+                        // In this special case we use an unknown value as a default
+                        // to get the intended behavior that the result is computed
+                        // unless it has been explicitly set in config.
+                        ret[name] = &hcldec.DefaultSpec{
+                                Primary: &hcldec.AttrSpec{
+                                        Name: name,
+                                        Type: attrS.Type,
+                                },
+                                Default: &hcldec.LiteralSpec{
+                                        Value: cty.UnknownVal(attrS.Type),
+                                },
+                        }
+                case attrS.Computed:
+                        ret[name] = &hcldec.LiteralSpec{
+                                Value: cty.UnknownVal(attrS.Type),
+                        }
+                default:
+                        ret[name] = &hcldec.AttrSpec{
+                                Name:     name,
+                                Type:     attrS.Type,
+                                Required: attrS.Required,
+                        }
+                }
+        }
+
+        for name, blockS := range b.BlockTypes {
+                if _, exists := ret[name]; exists {
+                        // This indicates an invalid schema, since it's not valid to
+                        // define both an attribute and a block type of the same name.
+                        // However, we don't raise this here since it's checked by
+                        // InternalValidate.
+                        continue
+                }
+
+                childSpec := blockS.Block.DecoderSpec()
+
+                switch blockS.Nesting {
+                case NestingSingle:
+                        ret[name] = &hcldec.BlockSpec{
+                                TypeName: name,
+                                Nested:   childSpec,
+                                Required: blockS.MinItems == 1 && blockS.MaxItems >= 1,
+                        }
+                case NestingList:
+                        ret[name] = &hcldec.BlockListSpec{
+                                TypeName: name,
+                                Nested:   childSpec,
+                                MinItems: blockS.MinItems,
+                                MaxItems: blockS.MaxItems,
+                        }
+                case NestingSet:
+                        ret[name] = &hcldec.BlockSetSpec{
+                                TypeName: name,
+                                Nested:   childSpec,
+                                MinItems: blockS.MinItems,
+                                MaxItems: blockS.MaxItems,
+                        }
+                case NestingMap:
+                        ret[name] = &hcldec.BlockMapSpec{
+                                TypeName:   name,
+                                Nested:     childSpec,
+                                LabelNames: mapLabelNames,
+                        }
+                default:
+                        // Invalid nesting type is just ignored. It's checked by
+                        // InternalValidate.
+                        continue
+                }
+        }
+
+        return ret
+}
diff --git a/vendor/github.com/hashicorp/terraform/config/configschema/doc.go b/vendor/github.com/hashicorp/terraform/config/configschema/doc.go
new file mode 100644
index 0000000..caf8d73
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/config/configschema/doc.go
@@ -0,0 +1,14 @@
+// Package configschema contains types for describing the expected structure
+// of a configuration block whose shape is not known until runtime.
+//
+// For example, this is used to describe the expected contents of a resource
+// configuration block, which is defined by the corresponding provider plugin
+// and thus not compiled into Terraform core.
+//
+// A configschema primarily describes the shape of configuration, but it is
+// also suitable for use with other structures derived from the configuration,
+// such as the cached state of a resource or a resource diff.
+//
+// This package should not be confused with the package helper/schema, which
+// is the higher-level helper library used to implement providers themselves.
+package configschema
diff --git a/vendor/github.com/hashicorp/terraform/config/configschema/implied_type.go b/vendor/github.com/hashicorp/terraform/config/configschema/implied_type.go
new file mode 100644
index 0000000..67324eb
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/config/configschema/implied_type.go
@@ -0,0 +1,21 @@
+package configschema
+
+import (
+        "github.com/hashicorp/hcl2/hcldec"
+        "github.com/zclconf/go-cty/cty"
+)
+
+// ImpliedType returns the cty.Type that would result from decoding a
+// configuration block using the receiving block schema.
+//
+// ImpliedType always returns a result, even if the given schema is
+// inconsistent. Code that creates configschema.Block objects should be
+// tested using the InternalValidate method to detect any inconsistencies
+// that would cause this method to fall back on defaults and assumptions.
+func (b *Block) ImpliedType() cty.Type {
+        if b == nil {
+                return cty.EmptyObject
+        }
+
+        return hcldec.ImpliedType(b.DecoderSpec())
+}
diff --git a/vendor/github.com/hashicorp/terraform/config/configschema/internal_validate.go b/vendor/github.com/hashicorp/terraform/config/configschema/internal_validate.go
new file mode 100644
index 0000000..33cbe88
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/config/configschema/internal_validate.go
@@ -0,0 +1,92 @@
+package configschema
+
+import (
+        "fmt"
+        "regexp"
+
+        "github.com/zclconf/go-cty/cty"
+
+        multierror "github.com/hashicorp/go-multierror"
+)
+
+var validName = regexp.MustCompile(`^[a-z0-9_]+$`)
+
+// InternalValidate returns an error if the receiving block and its child
+// schema definitions have any consistencies with the documented rules for
+// valid schema.
+//
+// This is intended to be used within unit tests to detect when a given
+// schema is invalid.
+func (b *Block) InternalValidate() error {
+        if b == nil {
+                return fmt.Errorf("top-level block schema is nil")
+        }
+        return b.internalValidate("", nil)
+
+}
+
+func (b *Block) internalValidate(prefix string, err error) error {
+        for name, attrS := range b.Attributes {
+                if attrS == nil {
+                        err = multierror.Append(err, fmt.Errorf("%s%s: attribute schema is nil", prefix, name))
+                        continue
+                }
+                if !validName.MatchString(name) {
+                        err = multierror.Append(err, fmt.Errorf("%s%s: name may contain only lowercase letters, digits and underscores", prefix, name))
+                }
+                if attrS.Optional == false && attrS.Required == false && attrS.Computed == false {
+                        err = multierror.Append(err, fmt.Errorf("%s%s: must set Optional, Required or Computed", prefix, name))
+                }
+                if attrS.Optional && attrS.Required {
+                        err = multierror.Append(err, fmt.Errorf("%s%s: cannot set both Optional and Required", prefix, name))
+                }
+                if attrS.Computed && attrS.Required {
+                        err = multierror.Append(err, fmt.Errorf("%s%s: cannot set both Computed and Required", prefix, name))
+                }
+                if attrS.Type == cty.NilType {
+                        err = multierror.Append(err, fmt.Errorf("%s%s: Type must be set to something other than cty.NilType", prefix, name))
+                }
+        }
+
+        for name, blockS := range b.BlockTypes {
+                if blockS == nil {
+                        err = multierror.Append(err, fmt.Errorf("%s%s: block schema is nil", prefix, name))
+                        continue
+                }
+
+                if _, isAttr := b.Attributes[name]; isAttr {
+                        err = multierror.Append(err, fmt.Errorf("%s%s: name defined as both attribute and child block type", prefix, name))
+                } else if !validName.MatchString(name) {
+                        err = multierror.Append(err, fmt.Errorf("%s%s: name may contain only lowercase letters, digits and underscores", prefix, name))
+                }
+
+                if blockS.MinItems < 0 || blockS.MaxItems < 0 {
+                        err = multierror.Append(err, fmt.Errorf("%s%s: MinItems and MaxItems must both be greater than zero", prefix, name))
+                }
+
+                switch blockS.Nesting {
+                case NestingSingle:
+                        switch {
+                        case blockS.MinItems != blockS.MaxItems:
+                                err = multierror.Append(err, fmt.Errorf("%s%s: MinItems and MaxItems must match in NestingSingle mode", prefix, name))
+                        case blockS.MinItems < 0 || blockS.MinItems > 1:
+                                err = multierror.Append(err, fmt.Errorf("%s%s: MinItems and MaxItems must be set to either 0 or 1 in NestingSingle mode", prefix, name))
+                        }
+                case NestingList, NestingSet:
+                        if blockS.MinItems > blockS.MaxItems && blockS.MaxItems != 0 {
+                                err = multierror.Append(err, fmt.Errorf("%s%s: MinItems must be less than or equal to MaxItems in %s mode", prefix, name, blockS.Nesting))
+                        }
+                case NestingMap:
+                        if blockS.MinItems != 0 || blockS.MaxItems != 0 {
+                                err = multierror.Append(err, fmt.Errorf("%s%s: MinItems and MaxItems must both be 0 in NestingMap mode", prefix, name))
+                        }
+                default:
+                        err = multierror.Append(err, fmt.Errorf("%s%s: invalid nesting mode %s", prefix, name, blockS.Nesting))
+                }
+
+                subPrefix := prefix + name + "."
+                err = blockS.Block.internalValidate(subPrefix, err)
+        }
+
+        return err
+}
diff --git a/vendor/github.com/hashicorp/terraform/config/configschema/nestingmode_string.go b/vendor/github.com/hashicorp/terraform/config/configschema/nestingmode_string.go
new file mode 100644
index 0000000..6cb9313
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/config/configschema/nestingmode_string.go
@@ -0,0 +1,16 @@
+// Code generated by "stringer -type=NestingMode"; DO NOT EDIT.
+
+package configschema
+
+import "strconv"
+
+const _NestingMode_name = "nestingModeInvalidNestingSingleNestingListNestingSetNestingMap"
+
+var _NestingMode_index = [...]uint8{0, 18, 31, 42, 52, 62}
+
+func (i NestingMode) String() string {
+        if i < 0 || i >= NestingMode(len(_NestingMode_index)-1) {
+                return "NestingMode(" + strconv.FormatInt(int64(i), 10) + ")"
+        }
+        return _NestingMode_name[_NestingMode_index[i]:_NestingMode_index[i+1]]
+}
diff --git a/vendor/github.com/hashicorp/terraform/config/configschema/schema.go b/vendor/github.com/hashicorp/terraform/config/configschema/schema.go
new file mode 100644
index 0000000..9a8ee55
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/config/configschema/schema.go
@@ -0,0 +1,107 @@
+package configschema
+
+import (
+        "github.com/zclconf/go-cty/cty"
+)
+
+// Block represents a configuration block.
+//
+// "Block" here is a logical grouping construct, though it happens to map
+// directly onto the physical block syntax of Terraform's native configuration
+// syntax. It may be a more a matter of convention in other syntaxes, such as
+// JSON.
+//
+// When converted to a value, a Block always becomes an instance of an object
+// type derived from its defined attributes and nested blocks
+type Block struct {
+        // Attributes describes any attributes that may appear directly inside
+        // the block.
+        Attributes map[string]*Attribute
+
+        // BlockTypes describes any nested block types that may appear directly
+        // inside the block.
+        BlockTypes map[string]*NestedBlock
+}
+
+// Attribute represents a configuration attribute, within a block.
+type Attribute struct {
+        // Type is a type specification that the attribute's value must conform to.
+        Type cty.Type
+
+        // Required, if set to true, specifies that an omitted or null value is
+        // not permitted.
+        Required bool
+
+        // Optional, if set to true, specifies that an omitted or null value is
+        // permitted. This field conflicts with Required.
+        Optional bool
+
+        // Computed, if set to true, specifies that the value comes from the
+        // provider rather than from configuration. If combined with Optional,
+        // then the config may optionally provide an overridden value.
+        Computed bool
+
+        // Sensitive, if set to true, indicates that an attribute may contain
+        // sensitive information.
+        //
+        // At present nothing is done with this information, but callers are
+        // encouraged to set it where appropriate so that it may be used in the
+        // future to help Terraform mask sensitive information. (Terraform
+        // currently achieves this in a limited sense via other mechanisms.)
+        Sensitive bool
+}
+
+// NestedBlock represents the embedding of one block within another.
+type NestedBlock struct {
+        // Block is the description of the block that's nested.
+        Block
+
+        // Nesting provides the nesting mode for the child block, which determines
+        // how many instances of the block are allowed, how many labels it expects,
+        // and how the resulting data will be converted into a data structure.
+        Nesting NestingMode
+
+        // MinItems and MaxItems set, for the NestingList and NestingSet nesting
+        // modes, lower and upper limits on the number of child blocks allowed
+        // of the given type. If both are left at zero, no limit is applied.
+        //
+        // As a special case, both values can be set to 1 for NestingSingle in
+        // order to indicate that a particular single block is required.
+        //
+        // These fields are ignored for other nesting modes and must both be left
+        // at zero.
+        MinItems, MaxItems int
+}
+
+// NestingMode is an enumeration of modes for nesting blocks inside other
+// blocks.
+type NestingMode int
+
+//go:generate stringer -type=NestingMode
+
+const (
+        nestingModeInvalid NestingMode = iota
+
+        // NestingSingle indicates that only a single instance of a given
+        // block type is permitted, with no labels, and its content should be
+        // provided directly as an object value.
+        NestingSingle
+
+        // NestingList indicates that multiple blocks of the given type are
+        // permitted, with no labels, and that their corresponding objects should
+        // be provided in a list.
+        NestingList
+
+        // NestingSet indicates that multiple blocks of the given type are
+        // permitted, with no labels, and that their corresponding objects should
+        // be provided in a set.
+        NestingSet
+
+        // NestingMap indicates that multiple blocks of the given type are
+        // permitted, each with a single label, and that their corresponding
+        // objects should be provided in a map whose keys are the labels.
+        //
+        // It's an error, therefore, to use the same label value on multiple
+        // blocks.
+        NestingMap
+)