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

1 files changed, 32 insertions, 0 deletions

diff --git a/vendor/github.com/hashicorp/terraform/helper/schema/field_writer_map.go b/vendor/github.com/hashicorp/terraform/helper/schema/field_writer_map.go
index 689ed8d..814c7ba 100644
--- a/vendor/github.com/hashicorp/terraform/helper/schema/field_writer_map.go
+++ b/vendor/github.com/hashicorp/terraform/helper/schema/field_writer_map.go
@@ -39,6 +39,19 @@ func (w *MapFieldWriter) unsafeWriteField(addr string, value string) {
         w.result[addr] = value
 }
 
+// clearTree clears a field and any sub-fields of the given address out of the
+// map. This should be used to reset some kind of complex structures (namely
+// sets) before writing to make sure that any conflicting data is removed (for
+// example, if the set was previously written to the writer's layer).
+func (w *MapFieldWriter) clearTree(addr []string) {
+        prefix := strings.Join(addr, ".") + "."
+        for k := range w.result {
+                if strings.HasPrefix(k, prefix) {
+                        delete(w.result, k)
+                }
+        }
+}
+
 func (w *MapFieldWriter) WriteField(addr []string, value interface{}) error {
         w.lock.Lock()
         defer w.lock.Unlock()
@@ -115,6 +128,14 @@ func (w *MapFieldWriter) setList(
                 return fmt.Errorf("%s: %s", k, err)
         }
 
+        // Wipe the set from the current writer prior to writing if it exists.
+        // Multiple writes to the same layer is a lot safer for lists than sets due
+        // to the fact that indexes are always deterministic and the length will
+        // always be updated with the current length on the last write, but making
+        // sure we have a clean namespace removes any chance for edge cases to pop up
+        // and ensures that the last write to the set is the correct value.
+        w.clearTree(addr)
+
         // Set the entire list.
         var err error
         for i, elem := range vs {
@@ -162,6 +183,10 @@ func (w *MapFieldWriter) setMap(
                 vs[mk.String()] = mv.Interface()
         }
 
+        // Wipe this address tree. The contents of the map should always reflect the
+        // last write made to it.
+        w.clearTree(addr)
+
         // Remove the pure key since we're setting the full map value
         delete(w.result, k)
 
@@ -308,6 +333,13 @@ func (w *MapFieldWriter) setSet(
                 value = s
         }
 
+        // Clear any keys that match the set address first. This is necessary because
+        // it's always possible and sometimes may be necessary to write to a certain
+        // writer layer more than once with different set data each time, which will
+        // lead to different keys being inserted, which can lead to determinism
+        // problems when the old data isn't wiped first.
+        w.clearTree(addr)
+
         for code, elem := range value.(*Set).m {
                 if err := w.set(append(addrCopy, code), elem); err != nil {
                         return err