update vendor and go.modadd_contact_groups

6 files changed, 83 insertions, 29 deletions

diff --git a/vendor/github.com/hashicorp/terraform/helper/schema/field_reader_config.go b/vendor/github.com/hashicorp/terraform/helper/schema/field_reader_config.go
index 808375c..6ad3f13 100644
--- a/vendor/github.com/hashicorp/terraform/helper/schema/field_reader_config.go
+++ b/vendor/github.com/hashicorp/terraform/helper/schema/field_reader_config.go
@@ -219,6 +219,9 @@ func (r *ConfigFieldReader) readMap(k string, schema *Schema) (FieldReadResult,
                         v, _ := r.Config.Get(key)
                         result[ik] = v
                 }
+        case nil:
+                // the map may have been empty on the configuration, so we leave the
+                // empty result
         default:
                 panic(fmt.Sprintf("unknown type: %#v", mraw))
         }
diff --git a/vendor/github.com/hashicorp/terraform/helper/schema/field_reader_diff.go b/vendor/github.com/hashicorp/terraform/helper/schema/field_reader_diff.go
index ae35b4a..3e70acf 100644
--- a/vendor/github.com/hashicorp/terraform/helper/schema/field_reader_diff.go
+++ b/vendor/github.com/hashicorp/terraform/helper/schema/field_reader_diff.go
@@ -95,7 +95,9 @@ func (r *DiffFieldReader) readMap(
                 return FieldReadResult{}, err
         }
         if source.Exists {
-                result = source.Value.(map[string]interface{})
+                // readMap may return a nil value, or an unknown value placeholder in
+                // some cases, causing the type assertion to panic if we don't assign the ok value
+                result, _ = source.Value.(map[string]interface{})
                 resultSet = true
         }
 
diff --git a/vendor/github.com/hashicorp/terraform/helper/schema/resource.go b/vendor/github.com/hashicorp/terraform/helper/schema/resource.go
index b5e3065..b59e4e8 100644
--- a/vendor/github.com/hashicorp/terraform/helper/schema/resource.go
+++ b/vendor/github.com/hashicorp/terraform/helper/schema/resource.go
@@ -95,9 +95,10 @@ type Resource struct {
         //
         // Exists is a function that is called to check if a resource still
         // exists. If this returns false, then this will affect the diff
-        // accordingly. If this function isn't set, it will not be called. It
-        // is highly recommended to set it. The *ResourceData passed to Exists
-        // should _not_ be modified.
+        // accordingly. If this function isn't set, it will not be called. You
+        // can also signal existence in the Read method by calling d.SetId("")
+        // if the Resource is no longer present and should be removed from state.
+        // The *ResourceData passed to Exists should _not_ be modified.
         Create CreateFunc
         Read   ReadFunc
         Update UpdateFunc
@@ -329,21 +330,13 @@ func (r *Resource) simpleDiff(
         c *terraform.ResourceConfig,
         meta interface{}) (*terraform.InstanceDiff, error) {
 
-        t := &ResourceTimeout{}
-        err := t.ConfigDecode(r, c)
-
-        if err != nil {
-                return nil, fmt.Errorf("[ERR] Error decoding timeout: %s", err)
-        }
-
         instanceDiff, err := schemaMap(r.Schema).Diff(s, c, r.CustomizeDiff, meta, false)
         if err != nil {
                 return instanceDiff, err
         }
 
         if instanceDiff == nil {
-                log.Printf("[DEBUG] Instance Diff is nil in SimpleDiff()")
-                return nil, err
+                instanceDiff = terraform.NewInstanceDiff()
         }
 
         // Make sure the old value is set in each of the instance diffs.
@@ -357,10 +350,7 @@ func (r *Resource) simpleDiff(
                 }
         }
 
-        if err := t.DiffEncode(instanceDiff); err != nil {
-                log.Printf("[ERR] Error encoding timeout to instance diff: %s", err)
-        }
-        return instanceDiff, err
+        return instanceDiff, nil
 }
 
 // Validate validates the resource configuration against the schema.
diff --git a/vendor/github.com/hashicorp/terraform/helper/schema/resource_timeout.go b/vendor/github.com/hashicorp/terraform/helper/schema/resource_timeout.go
index 9e422c1..222b2cc 100644
--- a/vendor/github.com/hashicorp/terraform/helper/schema/resource_timeout.go
+++ b/vendor/github.com/hashicorp/terraform/helper/schema/resource_timeout.go
@@ -5,7 +5,7 @@ import (
         "log"
         "time"
 
-        "github.com/hashicorp/terraform/config"
+        "github.com/hashicorp/terraform/config/hcl2shim"
         "github.com/hashicorp/terraform/terraform"
         "github.com/mitchellh/copystructure"
 )
@@ -70,7 +70,7 @@ func (t *ResourceTimeout) ConfigDecode(s *Resource, c *terraform.ResourceConfig)
                 case []map[string]interface{}:
                         rawTimeouts = raw
                 case string:
-                        if raw == config.UnknownVariableValue {
+                        if raw == hcl2shim.UnknownVariableValue {
                                 // Timeout is not defined in the config
                                 // Defaults will be used instead
                                 return nil
diff --git a/vendor/github.com/hashicorp/terraform/helper/schema/schema.go b/vendor/github.com/hashicorp/terraform/helper/schema/schema.go
index 6a3c15a..bcc8e4b 100644
--- a/vendor/github.com/hashicorp/terraform/helper/schema/schema.go
+++ b/vendor/github.com/hashicorp/terraform/helper/schema/schema.go
@@ -22,7 +22,7 @@ import (
         "strings"
         "sync"
 
-        "github.com/hashicorp/terraform/config"
+        "github.com/hashicorp/terraform/config/hcl2shim"
         "github.com/hashicorp/terraform/terraform"
         "github.com/mitchellh/copystructure"
         "github.com/mitchellh/mapstructure"
@@ -1365,10 +1365,15 @@ func (m schemaMap) validate(
                         "%q: this field cannot be set", k)}
         }
 
-        if raw == config.UnknownVariableValue {
-                // If the value is unknown then we can't validate it yet.
-                // In particular, this avoids spurious type errors where downstream
-                // validation code sees UnknownVariableValue as being just a string.
+        // If the value is unknown then we can't validate it yet.
+        // In particular, this avoids spurious type errors where downstream
+        // validation code sees UnknownVariableValue as being just a string.
+        // The SDK has to allow the unknown value through initially, so that
+        // Required fields set via an interpolated value are accepted.
+        if !isWhollyKnown(raw) {
+                if schema.Deprecated != "" {
+                        return []string{fmt.Sprintf("%q: [DEPRECATED] %s", k, schema.Deprecated)}, nil
+                }
                 return nil, nil
         }
 
@@ -1380,6 +1385,28 @@ func (m schemaMap) validate(
         return m.validateType(k, raw, schema, c)
 }
 
+// isWhollyKnown returns false if the argument contains an UnknownVariableValue
+func isWhollyKnown(raw interface{}) bool {
+        switch raw := raw.(type) {
+        case string:
+                if raw == hcl2shim.UnknownVariableValue {
+                        return false
+                }
+        case []interface{}:
+                for _, v := range raw {
+                        if !isWhollyKnown(v) {
+                                return false
+                        }
+                }
+        case map[string]interface{}:
+                for _, v := range raw {
+                        if !isWhollyKnown(v) {
+                                return false
+                        }
+                }
+        }
+        return true
+}
 func (m schemaMap) validateConflictingAttributes(
         k string,
         schema *Schema,
@@ -1391,7 +1418,7 @@ func (m schemaMap) validateConflictingAttributes(
 
         for _, conflictingKey := range schema.ConflictsWith {
                 if raw, ok := c.Get(conflictingKey); ok {
-                        if raw == config.UnknownVariableValue {
+                        if raw == hcl2shim.UnknownVariableValue {
                                 // An unknown value might become unset (null) once known, so
                                 // we must defer validation until it's known.
                                 continue
@@ -1411,11 +1438,16 @@ func (m schemaMap) validateList(
         c *terraform.ResourceConfig) ([]string, []error) {
         // first check if the list is wholly unknown
         if s, ok := raw.(string); ok {
-                if s == config.UnknownVariableValue {
+                if s == hcl2shim.UnknownVariableValue {
                         return nil, nil
                 }
         }
 
+        // schemaMap can't validate nil
+        if raw == nil {
+                return nil, nil
+        }
+
         // We use reflection to verify the slice because you can't
         // case to []interface{} unless the slice is exactly that type.
         rawV := reflect.ValueOf(raw)
@@ -1432,6 +1464,15 @@ func (m schemaMap) validateList(
                         "%s: should be a list", k)}
         }
 
+        // We can't validate list length if this came from a dynamic block.
+        // Since there's no way to determine if something was from a dynamic block
+        // at this point, we're going to skip validation in the new protocol if
+        // there are any unknowns. Validate will eventually be called again once
+        // all values are known.
+        if isProto5() && !isWhollyKnown(raw) {
+                return nil, nil
+        }
+
         // Validate length
         if schema.MaxItems > 0 && rawV.Len() > schema.MaxItems {
                 return nil, []error{fmt.Errorf(
@@ -1489,11 +1530,15 @@ func (m schemaMap) validateMap(
         c *terraform.ResourceConfig) ([]string, []error) {
         // first check if the list is wholly unknown
         if s, ok := raw.(string); ok {
-                if s == config.UnknownVariableValue {
+                if s == hcl2shim.UnknownVariableValue {
                         return nil, nil
                 }
         }
 
+        // schemaMap can't validate nil
+        if raw == nil {
+                return nil, nil
+        }
         // We use reflection to verify the slice because you can't
         // case to []interface{} unless the slice is exactly that type.
         rawV := reflect.ValueOf(raw)
@@ -1620,6 +1665,12 @@ func (m schemaMap) validateObject(
         schema map[string]*Schema,
         c *terraform.ResourceConfig) ([]string, []error) {
         raw, _ := c.Get(k)
+
+        // schemaMap can't validate nil
+        if raw == nil {
+                return nil, nil
+        }
+
         if _, ok := raw.(map[string]interface{}); !ok && !c.IsComputed(k) {
                 return nil, []error{fmt.Errorf(
                         "%s: expected object, got %s",
@@ -1664,6 +1715,14 @@ func (m schemaMap) validatePrimitive(
         raw interface{},
         schema *Schema,
         c *terraform.ResourceConfig) ([]string, []error) {
+
+        // a nil value shouldn't happen in the old protocol, and in the new
+        // protocol the types have already been validated. Either way, we can't
+        // reflect on nil, so don't panic.
+        if raw == nil {
+                return nil, nil
+        }
+
         // Catch if the user gave a complex type where a primitive was
         // expected, so we can return a friendly error message that
         // doesn't contain Go type system terminology.
diff --git a/vendor/github.com/hashicorp/terraform/helper/schema/shims.go b/vendor/github.com/hashicorp/terraform/helper/schema/shims.go
index 203d017..988573e 100644
--- a/vendor/github.com/hashicorp/terraform/helper/schema/shims.go
+++ b/vendor/github.com/hashicorp/terraform/helper/schema/shims.go
@@ -6,7 +6,7 @@ import (
         "github.com/zclconf/go-cty/cty"
         ctyjson "github.com/zclconf/go-cty/cty/json"
 
-        "github.com/hashicorp/terraform/config"
+        "github.com/hashicorp/terraform/config/hcl2shim"
         "github.com/hashicorp/terraform/configs/configschema"
         "github.com/hashicorp/terraform/terraform"
 )
@@ -50,7 +50,7 @@ func removeConfigUnknowns(cfg map[string]interface{}) {
         for k, v := range cfg {
                 switch v := v.(type) {
                 case string:
-                        if v == config.UnknownVariableValue {
+                        if v == hcl2shim.UnknownVariableValue {
                                 delete(cfg, k)
                         }
                 case []interface{}: