9 files changed, 457 insertions, 0 deletions

diff --git a/vendor/github.com/hashicorp/terraform/tfdiags/diagnostic.go b/vendor/github.com/hashicorp/terraform/tfdiags/diagnostic.go
new file mode 100644
index 0000000..2c23f76
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/tfdiags/diagnostic.go
@@ -0,0 +1,26 @@
+package tfdiags
+
+type Diagnostic interface {
+        Severity() Severity
+        Description() Description
+        Source() Source
+}
+
+type Severity rune
+
+//go:generate stringer -type=Severity
+
+const (
+        Error   Severity = 'E'
+        Warning Severity = 'W'
+)
+
+type Description struct {
+        Summary string
+        Detail  string
+}
+
+type Source struct {
+        Subject *SourceRange
+        Context *SourceRange
+}
diff --git a/vendor/github.com/hashicorp/terraform/tfdiags/diagnostics.go b/vendor/github.com/hashicorp/terraform/tfdiags/diagnostics.go
new file mode 100644
index 0000000..667ba80
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/tfdiags/diagnostics.go
@@ -0,0 +1,181 @@
+package tfdiags
+
+import (
+        "bytes"
+        "fmt"
+
+        "github.com/hashicorp/errwrap"
+        multierror "github.com/hashicorp/go-multierror"
+        "github.com/hashicorp/hcl2/hcl"
+)
+
+// Diagnostics is a list of diagnostics. Diagnostics is intended to be used
+// where a Go "error" might normally be used, allowing richer information
+// to be conveyed (more context, support for warnings).
+//
+// A nil Diagnostics is a valid, empty diagnostics list, thus allowing
+// heap allocation to be avoided in the common case where there are no
+// diagnostics to report at all.
+type Diagnostics []Diagnostic
+
+// Append is the main interface for constructing Diagnostics lists, taking
+// an existing list (which may be nil) and appending the new objects to it
+// after normalizing them to be implementations of Diagnostic.
+//
+// The usual pattern for a function that natively "speaks" diagnostics is:
+//
+//     // Create a nil Diagnostics at the start of the function
+//     var diags diag.Diagnostics
+//
+//     // At later points, build on it if errors / warnings occur:
+//     foo, err := DoSomethingRisky()
+//     if err != nil {
+//         diags = diags.Append(err)
+//     }
+//
+//     // Eventually return the result and diagnostics in place of error
+//     return result, diags
+//
+// Append accepts a variety of different diagnostic-like types, including
+// native Go errors and HCL diagnostics. It also knows how to unwrap
+// a multierror.Error into separate error diagnostics. It can be passed
+// another Diagnostics to concatenate the two lists. If given something
+// it cannot handle, this function will panic.
+func (diags Diagnostics) Append(new ...interface{}) Diagnostics {
+        for _, item := range new {
+                if item == nil {
+                        continue
+                }
+
+                switch ti := item.(type) {
+                case Diagnostic:
+                        diags = append(diags, ti)
+                case Diagnostics:
+                        diags = append(diags, ti...) // flatten
+                case diagnosticsAsError:
+                        diags = diags.Append(ti.Diagnostics) // unwrap
+                case hcl.Diagnostics:
+                        for _, hclDiag := range ti {
+                                diags = append(diags, hclDiagnostic{hclDiag})
+                        }
+                case *hcl.Diagnostic:
+                        diags = append(diags, hclDiagnostic{ti})
+                case *multierror.Error:
+                        for _, err := range ti.Errors {
+                                diags = append(diags, nativeError{err})
+                        }
+                case error:
+                        switch {
+                        case errwrap.ContainsType(ti, Diagnostics(nil)):
+                                // If we have an errwrap wrapper with a Diagnostics hiding
+                                // inside then we'll unpick it here to get access to the
+                                // individual diagnostics.
+                                diags = diags.Append(errwrap.GetType(ti, Diagnostics(nil)))
+                        case errwrap.ContainsType(ti, hcl.Diagnostics(nil)):
+                                // Likewise, if we have HCL diagnostics we'll unpick that too.
+                                diags = diags.Append(errwrap.GetType(ti, hcl.Diagnostics(nil)))
+                        default:
+                                diags = append(diags, nativeError{ti})
+                        }
+                default:
+                        panic(fmt.Errorf("can't construct diagnostic(s) from %T", item))
+                }
+        }
+
+        // Given the above, we should never end up with a non-nil empty slice
+        // here, but we'll make sure of that so callers can rely on empty == nil
+        if len(diags) == 0 {
+                return nil
+        }
+
+        return diags
+}
+
+// HasErrors returns true if any of the diagnostics in the list have
+// a severity of Error.
+func (diags Diagnostics) HasErrors() bool {
+        for _, diag := range diags {
+                if diag.Severity() == Error {
+                        return true
+                }
+        }
+        return false
+}
+
+// ForRPC returns a version of the receiver that has been simplified so that
+// it is friendly to RPC protocols.
+//
+// Currently this means that it can be serialized with encoding/gob and
+// subsequently re-inflated. It may later grow to include other serialization
+// formats.
+//
+// Note that this loses information about the original objects used to
+// construct the diagnostics, so e.g. the errwrap API will not work as
+// expected on an error-wrapped Diagnostics that came from ForRPC.
+func (diags Diagnostics) ForRPC() Diagnostics {
+        ret := make(Diagnostics, len(diags))
+        for i := range diags {
+                ret[i] = makeRPCFriendlyDiag(diags[i])
+        }
+        return ret
+}
+
+// Err flattens a diagnostics list into a single Go error, or to nil
+// if the diagnostics list does not include any error-level diagnostics.
+//
+// This can be used to smuggle diagnostics through an API that deals in
+// native errors, but unfortunately it will lose naked warnings (warnings
+// that aren't accompanied by at least one error) since such APIs have no
+// mechanism through which to report these.
+//
+//     return result, diags.Error()
+func (diags Diagnostics) Err() error {
+        if !diags.HasErrors() {
+                return nil
+        }
+        return diagnosticsAsError{diags}
+}
+
+type diagnosticsAsError struct {
+        Diagnostics
+}
+
+func (dae diagnosticsAsError) Error() string {
+        diags := dae.Diagnostics
+        switch {
+        case len(diags) == 0:
+                // should never happen, since we don't create this wrapper if
+                // there are no diagnostics in the list.
+                return "no errors"
+        case len(diags) == 1:
+                desc := diags[0].Description()
+                if desc.Detail == "" {
+                        return desc.Summary
+                }
+                return fmt.Sprintf("%s: %s", desc.Summary, desc.Detail)
+        default:
+                var ret bytes.Buffer
+                fmt.Fprintf(&ret, "%d problems:\n", len(diags))
+                for _, diag := range dae.Diagnostics {
+                        desc := diag.Description()
+                        if desc.Detail == "" {
+                                fmt.Fprintf(&ret, "\n- %s", desc.Summary)
+                        } else {
+                                fmt.Fprintf(&ret, "\n- %s: %s", desc.Summary, desc.Detail)
+                        }
+                }
+                return ret.String()
+        }
+}
+
+// WrappedErrors is an implementation of errwrap.Wrapper so that an error-wrapped
+// diagnostics object can be picked apart by errwrap-aware code.
+func (dae diagnosticsAsError) WrappedErrors() []error {
+        var errs []error
+        for _, diag := range dae.Diagnostics {
+                if wrapper, isErr := diag.(nativeError); isErr {
+                        errs = append(errs, wrapper.err)
+                }
+        }
+        return errs
+}
diff --git a/vendor/github.com/hashicorp/terraform/tfdiags/doc.go b/vendor/github.com/hashicorp/terraform/tfdiags/doc.go
new file mode 100644
index 0000000..c427879
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/tfdiags/doc.go
@@ -0,0 +1,16 @@
+// Package tfdiags is a utility package for representing errors and
+// warnings in a manner that allows us to produce good messages for the
+// user.
+//
+// "diag" is short for "diagnostics", and is meant as a general word for
+// feedback to a user about potential or actual problems.
+//
+// A design goal for this package is for it to be able to provide rich
+// messaging where possible but to also be pragmatic about dealing with
+// generic errors produced by system components that _can't_ provide
+// such rich messaging. As a consequence, the main types in this package --
+// Diagnostics and Diagnostic -- are designed so that they can be "smuggled"
+// over an error channel and then be unpacked at the other end, so that
+// error diagnostics (at least) can transit through APIs that are not
+// aware of this package.
+package tfdiags
diff --git a/vendor/github.com/hashicorp/terraform/tfdiags/error.go b/vendor/github.com/hashicorp/terraform/tfdiags/error.go
new file mode 100644
index 0000000..35edc30
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/tfdiags/error.go
@@ -0,0 +1,23 @@
+package tfdiags
+
+// nativeError is a Diagnostic implementation that wraps a normal Go error
+type nativeError struct {
+        err error
+}
+
+var _ Diagnostic = nativeError{}
+
+func (e nativeError) Severity() Severity {
+        return Error
+}
+
+func (e nativeError) Description() Description {
+        return Description{
+                Summary: e.err.Error(),
+        }
+}
+
+func (e nativeError) Source() Source {
+        // No source information available for a native error
+        return Source{}
+}
diff --git a/vendor/github.com/hashicorp/terraform/tfdiags/hcl.go b/vendor/github.com/hashicorp/terraform/tfdiags/hcl.go
new file mode 100644
index 0000000..24851f4
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/tfdiags/hcl.go
@@ -0,0 +1,77 @@
+package tfdiags
+
+import (
+        "github.com/hashicorp/hcl2/hcl"
+)
+
+// hclDiagnostic is a Diagnostic implementation that wraps a HCL Diagnostic
+type hclDiagnostic struct {
+        diag *hcl.Diagnostic
+}
+
+var _ Diagnostic = hclDiagnostic{}
+
+func (d hclDiagnostic) Severity() Severity {
+        switch d.diag.Severity {
+        case hcl.DiagWarning:
+                return Warning
+        default:
+                return Error
+        }
+}
+
+func (d hclDiagnostic) Description() Description {
+        return Description{
+                Summary: d.diag.Summary,
+                Detail:  d.diag.Detail,
+        }
+}
+
+func (d hclDiagnostic) Source() Source {
+        var ret Source
+        if d.diag.Subject != nil {
+                rng := SourceRangeFromHCL(*d.diag.Subject)
+                ret.Subject = &rng
+        }
+        if d.diag.Context != nil {
+                rng := SourceRangeFromHCL(*d.diag.Context)
+                ret.Context = &rng
+        }
+        return ret
+}
+
+// SourceRangeFromHCL constructs a SourceRange from the corresponding range
+// type within the HCL package.
+func SourceRangeFromHCL(hclRange hcl.Range) SourceRange {
+        return SourceRange{
+                Filename: hclRange.Filename,
+                Start: SourcePos{
+                        Line:   hclRange.Start.Line,
+                        Column: hclRange.Start.Column,
+                        Byte:   hclRange.Start.Byte,
+                },
+                End: SourcePos{
+                        Line:   hclRange.End.Line,
+                        Column: hclRange.End.Column,
+                        Byte:   hclRange.End.Byte,
+                },
+        }
+}
+
+// ToHCL constructs a HCL Range from the receiving SourceRange. This is the
+// opposite of SourceRangeFromHCL.
+func (r SourceRange) ToHCL() hcl.Range {
+        return hcl.Range{
+                Filename: r.Filename,
+                Start: hcl.Pos{
+                        Line:   r.Start.Line,
+                        Column: r.Start.Column,
+                        Byte:   r.Start.Byte,
+                },
+                End: hcl.Pos{
+                        Line:   r.End.Line,
+                        Column: r.End.Column,
+                        Byte:   r.End.Byte,
+                },
+        }
+}
diff --git a/vendor/github.com/hashicorp/terraform/tfdiags/rpc_friendly.go b/vendor/github.com/hashicorp/terraform/tfdiags/rpc_friendly.go
new file mode 100644
index 0000000..6cc95cc
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/tfdiags/rpc_friendly.go
@@ -0,0 +1,53 @@
+package tfdiags
+
+import (
+        "encoding/gob"
+)
+
+type rpcFriendlyDiag struct {
+        Severity_ Severity
+        Summary_  string
+        Detail_   string
+        Subject_  *SourceRange
+        Context_  *SourceRange
+}
+
+// rpcFriendlyDiag transforms a given diagnostic so that is more friendly to
+// RPC.
+//
+// In particular, it currently returns an object that can be serialized and
+// later re-inflated using gob. This definition may grow to include other
+// serializations later.
+func makeRPCFriendlyDiag(diag Diagnostic) Diagnostic {
+        desc := diag.Description()
+        source := diag.Source()
+        return &rpcFriendlyDiag{
+                Severity_: diag.Severity(),
+                Summary_:  desc.Summary,
+                Detail_:   desc.Detail,
+                Subject_:  source.Subject,
+                Context_:  source.Context,
+        }
+}
+
+func (d *rpcFriendlyDiag) Severity() Severity {
+        return d.Severity_
+}
+
+func (d *rpcFriendlyDiag) Description() Description {
+        return Description{
+                Summary: d.Summary_,
+                Detail:  d.Detail_,
+        }
+}
+
+func (d *rpcFriendlyDiag) Source() Source {
+        return Source{
+                Subject: d.Subject_,
+                Context: d.Context_,
+        }
+}
+
+func init() {
+        gob.Register((*rpcFriendlyDiag)(nil))
+}
diff --git a/vendor/github.com/hashicorp/terraform/tfdiags/severity_string.go b/vendor/github.com/hashicorp/terraform/tfdiags/severity_string.go
new file mode 100644
index 0000000..0b1249b
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/tfdiags/severity_string.go
@@ -0,0 +1,21 @@
+// Code generated by "stringer -type=Severity"; DO NOT EDIT.
+
+package tfdiags
+
+import "strconv"
+
+const (
+        _Severity_name_0 = "Error"
+        _Severity_name_1 = "Warning"
+)
+
+func (i Severity) String() string {
+        switch {
+        case i == 69:
+                return _Severity_name_0
+        case i == 87:
+                return _Severity_name_1
+        default:
+                return "Severity(" + strconv.FormatInt(int64(i), 10) + ")"
+        }
+}
diff --git a/vendor/github.com/hashicorp/terraform/tfdiags/simple_warning.go b/vendor/github.com/hashicorp/terraform/tfdiags/simple_warning.go
new file mode 100644
index 0000000..fb3ac98
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/tfdiags/simple_warning.go
@@ -0,0 +1,25 @@
+package tfdiags
+
+type simpleWarning string
+
+var _ Diagnostic = simpleWarning("")
+
+// SimpleWarning constructs a simple (summary-only) warning diagnostic.
+func SimpleWarning(msg string) Diagnostic {
+        return simpleWarning(msg)
+}
+
+func (e simpleWarning) Severity() Severity {
+        return Warning
+}
+
+func (e simpleWarning) Description() Description {
+        return Description{
+                Summary: string(e),
+        }
+}
+
+func (e simpleWarning) Source() Source {
+        // No source information available for a native error
+        return Source{}
+}
diff --git a/vendor/github.com/hashicorp/terraform/tfdiags/source_range.go b/vendor/github.com/hashicorp/terraform/tfdiags/source_range.go
new file mode 100644
index 0000000..3031168
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/tfdiags/source_range.go
@@ -0,0 +1,35 @@
+package tfdiags
+
+import (
+        "fmt"
+        "os"
+        "path/filepath"
+)
+
+type SourceRange struct {
+        Filename   string
+        Start, End SourcePos
+}
+
+type SourcePos struct {
+        Line, Column, Byte int
+}
+
+// StartString returns a string representation of the start of the range,
+// including the filename and the line and column numbers.
+func (r SourceRange) StartString() string {
+        filename := r.Filename
+
+        // We'll try to relative-ize our filename here so it's less verbose
+        // in the common case of being in the current working directory. If not,
+        // we'll just show the full path.
+        wd, err := os.Getwd()
+        if err == nil {
+                relFn, err := filepath.Rel(wd, filename)
+                if err == nil {
+                        filename = relFn
+                }
+        }
+
+        return fmt.Sprintf("%s:%d,%d", filename, r.Start.Line, r.Start.Column)
+}