Upgrade to 0.12

2 files changed, 286 insertions, 0 deletions

diff --git a/vendor/github.com/hashicorp/terraform/plugin/convert/diagnostics.go b/vendor/github.com/hashicorp/terraform/plugin/convert/diagnostics.go
new file mode 100644
index 0000000..51cb2fe
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/plugin/convert/diagnostics.go
@@ -0,0 +1,132 @@
+package convert
+
+import (
+        proto "github.com/hashicorp/terraform/internal/tfplugin5"
+        "github.com/hashicorp/terraform/tfdiags"
+        "github.com/zclconf/go-cty/cty"
+)
+
+// WarnsAndErrorsToProto converts the warnings and errors return by the legacy
+// provider to protobuf diagnostics.
+func WarnsAndErrsToProto(warns []string, errs []error) (diags []*proto.Diagnostic) {
+        for _, w := range warns {
+                diags = AppendProtoDiag(diags, w)
+        }
+
+        for _, e := range errs {
+                diags = AppendProtoDiag(diags, e)
+        }
+
+        return diags
+}
+
+// AppendProtoDiag appends a new diagnostic from a warning string or an error.
+// This panics if d is not a string or error.
+func AppendProtoDiag(diags []*proto.Diagnostic, d interface{}) []*proto.Diagnostic {
+        switch d := d.(type) {
+        case cty.PathError:
+                ap := PathToAttributePath(d.Path)
+                diags = append(diags, &proto.Diagnostic{
+                        Severity:  proto.Diagnostic_ERROR,
+                        Summary:   d.Error(),
+                        Attribute: ap,
+                })
+        case error:
+                diags = append(diags, &proto.Diagnostic{
+                        Severity: proto.Diagnostic_ERROR,
+                        Summary:  d.Error(),
+                })
+        case string:
+                diags = append(diags, &proto.Diagnostic{
+                        Severity: proto.Diagnostic_WARNING,
+                        Summary:  d,
+                })
+        case *proto.Diagnostic:
+                diags = append(diags, d)
+        case []*proto.Diagnostic:
+                diags = append(diags, d...)
+        }
+        return diags
+}
+
+// ProtoToDiagnostics converts a list of proto.Diagnostics to a tf.Diagnostics.
+func ProtoToDiagnostics(ds []*proto.Diagnostic) tfdiags.Diagnostics {
+        var diags tfdiags.Diagnostics
+        for _, d := range ds {
+                var severity tfdiags.Severity
+
+                switch d.Severity {
+                case proto.Diagnostic_ERROR:
+                        severity = tfdiags.Error
+                case proto.Diagnostic_WARNING:
+                        severity = tfdiags.Warning
+                }
+
+                var newDiag tfdiags.Diagnostic
+
+                // if there's an attribute path, we need to create a AttributeValue diagnostic
+                if d.Attribute != nil {
+                        path := AttributePathToPath(d.Attribute)
+                        newDiag = tfdiags.AttributeValue(severity, d.Summary, d.Detail, path)
+                } else {
+                        newDiag = tfdiags.WholeContainingBody(severity, d.Summary, d.Detail)
+                }
+
+                diags = diags.Append(newDiag)
+        }
+
+        return diags
+}
+
+// AttributePathToPath takes the proto encoded path and converts it to a cty.Path
+func AttributePathToPath(ap *proto.AttributePath) cty.Path {
+        var p cty.Path
+        for _, step := range ap.Steps {
+                switch selector := step.Selector.(type) {
+                case *proto.AttributePath_Step_AttributeName:
+                        p = p.GetAttr(selector.AttributeName)
+                case *proto.AttributePath_Step_ElementKeyString:
+                        p = p.Index(cty.StringVal(selector.ElementKeyString))
+                case *proto.AttributePath_Step_ElementKeyInt:
+                        p = p.Index(cty.NumberIntVal(selector.ElementKeyInt))
+                }
+        }
+        return p
+}
+
+// AttributePathToPath takes a cty.Path and converts it to a proto-encoded path.
+func PathToAttributePath(p cty.Path) *proto.AttributePath {
+        ap := &proto.AttributePath{}
+        for _, step := range p {
+                switch selector := step.(type) {
+                case cty.GetAttrStep:
+                        ap.Steps = append(ap.Steps, &proto.AttributePath_Step{
+                                Selector: &proto.AttributePath_Step_AttributeName{
+                                        AttributeName: selector.Name,
+                                },
+                        })
+                case cty.IndexStep:
+                        key := selector.Key
+                        switch key.Type() {
+                        case cty.String:
+                                ap.Steps = append(ap.Steps, &proto.AttributePath_Step{
+                                        Selector: &proto.AttributePath_Step_ElementKeyString{
+                                                ElementKeyString: key.AsString(),
+                                        },
+                                })
+                        case cty.Number:
+                                v, _ := key.AsBigFloat().Int64()
+                                ap.Steps = append(ap.Steps, &proto.AttributePath_Step{
+                                        Selector: &proto.AttributePath_Step_ElementKeyInt{
+                                                ElementKeyInt: v,
+                                        },
+                                })
+                        default:
+                                // We'll bail early if we encounter anything else, and just
+                                // return the valid prefix.
+                                return ap
+                        }
+                }
+        }
+        return ap
+}
diff --git a/vendor/github.com/hashicorp/terraform/plugin/convert/schema.go b/vendor/github.com/hashicorp/terraform/plugin/convert/schema.go
new file mode 100644
index 0000000..6a45f54
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/plugin/convert/schema.go
@@ -0,0 +1,154 @@
+package convert
+
+import (
+        "encoding/json"
+        "reflect"
+        "sort"
+
+        "github.com/hashicorp/terraform/configs/configschema"
+        proto "github.com/hashicorp/terraform/internal/tfplugin5"
+        "github.com/hashicorp/terraform/providers"
+)
+
+// ConfigSchemaToProto takes a *configschema.Block and converts it to a
+// proto.Schema_Block for a grpc response.
+func ConfigSchemaToProto(b *configschema.Block) *proto.Schema_Block {
+        block := &proto.Schema_Block{}
+
+        for _, name := range sortedKeys(b.Attributes) {
+                a := b.Attributes[name]
+                attr := &proto.Schema_Attribute{
+                        Name:        name,
+                        Description: a.Description,
+                        Optional:    a.Optional,
+                        Computed:    a.Computed,
+                        Required:    a.Required,
+                        Sensitive:   a.Sensitive,
+                }
+
+                ty, err := json.Marshal(a.Type)
+                if err != nil {
+                        panic(err)
+                }
+
+                attr.Type = ty
+
+                block.Attributes = append(block.Attributes, attr)
+        }
+
+        for _, name := range sortedKeys(b.BlockTypes) {
+                b := b.BlockTypes[name]
+                block.BlockTypes = append(block.BlockTypes, protoSchemaNestedBlock(name, b))
+        }
+
+        return block
+}
+
+func protoSchemaNestedBlock(name string, b *configschema.NestedBlock) *proto.Schema_NestedBlock {
+        var nesting proto.Schema_NestedBlock_NestingMode
+        switch b.Nesting {
+        case configschema.NestingSingle:
+                nesting = proto.Schema_NestedBlock_SINGLE
+        case configschema.NestingGroup:
+                nesting = proto.Schema_NestedBlock_GROUP
+        case configschema.NestingList:
+                nesting = proto.Schema_NestedBlock_LIST
+        case configschema.NestingSet:
+                nesting = proto.Schema_NestedBlock_SET
+        case configschema.NestingMap:
+                nesting = proto.Schema_NestedBlock_MAP
+        default:
+                nesting = proto.Schema_NestedBlock_INVALID
+        }
+        return &proto.Schema_NestedBlock{
+                TypeName: name,
+                Block:    ConfigSchemaToProto(&b.Block),
+                Nesting:  nesting,
+                MinItems: int64(b.MinItems),
+                MaxItems: int64(b.MaxItems),
+        }
+}
+
+// ProtoToProviderSchema takes a proto.Schema and converts it to a providers.Schema.
+func ProtoToProviderSchema(s *proto.Schema) providers.Schema {
+        return providers.Schema{
+                Version: s.Version,
+                Block:   ProtoToConfigSchema(s.Block),
+        }
+}
+
+// ProtoToConfigSchema takes the GetSchcema_Block from a grpc response and converts it
+// to a terraform *configschema.Block.
+func ProtoToConfigSchema(b *proto.Schema_Block) *configschema.Block {
+        block := &configschema.Block{
+                Attributes: make(map[string]*configschema.Attribute),
+                BlockTypes: make(map[string]*configschema.NestedBlock),
+        }
+
+        for _, a := range b.Attributes {
+                attr := &configschema.Attribute{
+                        Description: a.Description,
+                        Required:    a.Required,
+                        Optional:    a.Optional,
+                        Computed:    a.Computed,
+                        Sensitive:   a.Sensitive,
+                }
+
+                if err := json.Unmarshal(a.Type, &attr.Type); err != nil {
+                        panic(err)
+                }
+
+                block.Attributes[a.Name] = attr
+        }
+
+        for _, b := range b.BlockTypes {
+                block.BlockTypes[b.TypeName] = schemaNestedBlock(b)
+        }
+
+        return block
+}
+
+func schemaNestedBlock(b *proto.Schema_NestedBlock) *configschema.NestedBlock {
+        var nesting configschema.NestingMode
+        switch b.Nesting {
+        case proto.Schema_NestedBlock_SINGLE:
+                nesting = configschema.NestingSingle
+        case proto.Schema_NestedBlock_GROUP:
+                nesting = configschema.NestingGroup
+        case proto.Schema_NestedBlock_LIST:
+                nesting = configschema.NestingList
+        case proto.Schema_NestedBlock_MAP:
+                nesting = configschema.NestingMap
+        case proto.Schema_NestedBlock_SET:
+                nesting = configschema.NestingSet
+        default:
+                // In all other cases we'll leave it as the zero value (invalid) and
+                // let the caller validate it and deal with this.
+        }
+
+        nb := &configschema.NestedBlock{
+                Nesting:  nesting,
+                MinItems: int(b.MinItems),
+                MaxItems: int(b.MaxItems),
+        }
+
+        nested := ProtoToConfigSchema(b.Block)
+        nb.Block = *nested
+        return nb
+}
+
+// sortedKeys returns the lexically sorted keys from the given map. This is
+// used to make schema conversions are deterministic. This panics if map keys
+// are not a string.
+func sortedKeys(m interface{}) []string {
+        v := reflect.ValueOf(m)
+        keys := make([]string, v.Len())
+
+        mapKeys := v.MapKeys()
+        for i, k := range mapKeys {
+                keys[i] = k.Interface().(string)
+        }
+
+        sort.Strings(keys)
+        return keys
+}