1 files changed, 42 insertions, 24 deletions

diff --git a/vendor/github.com/hashicorp/terraform/terraform/state.go b/vendor/github.com/hashicorp/terraform/terraform/state.go
index 074b682..0c46194 100644
--- a/vendor/github.com/hashicorp/terraform/terraform/state.go
+++ b/vendor/github.com/hashicorp/terraform/terraform/state.go
@@ -533,6 +533,43 @@ func (s *State) equal(other *State) bool {
         return true
 }
 
+// MarshalEqual is similar to Equal but provides a stronger definition of
+// "equal", where two states are equal if and only if their serialized form
+// is byte-for-byte identical.
+//
+// This is primarily useful for callers that are trying to save snapshots
+// of state to persistent storage, allowing them to detect when a new
+// snapshot must be taken.
+//
+// Note that the serial number and lineage are included in the serialized form,
+// so it's the caller's responsibility to properly manage these attributes
+// so that this method is only called on two states that have the same
+// serial and lineage, unless detecting such differences is desired.
+func (s *State) MarshalEqual(other *State) bool {
+        if s == nil && other == nil {
+                return true
+        } else if s == nil || other == nil {
+                return false
+        }
+
+        recvBuf := &bytes.Buffer{}
+        otherBuf := &bytes.Buffer{}
+
+        err := WriteState(s, recvBuf)
+        if err != nil {
+                // should never happen, since we're writing to a buffer
+                panic(err)
+        }
+
+        err = WriteState(other, otherBuf)
+        if err != nil {
+                // should never happen, since we're writing to a buffer
+                panic(err)
+        }
+
+        return bytes.Equal(recvBuf.Bytes(), otherBuf.Bytes())
+}
+
 type StateAgeComparison int
 
 const (
@@ -603,6 +640,10 @@ func (s *State) SameLineage(other *State) bool {
 // DeepCopy performs a deep copy of the state structure and returns
 // a new structure.
 func (s *State) DeepCopy() *State {
+        if s == nil {
+                return nil
+        }
+
         copy, err := copystructure.Config{Lock: true}.Copy(s)
         if err != nil {
                 panic(err)
@@ -611,30 +652,6 @@ func (s *State) DeepCopy() *State {
         return copy.(*State)
 }
 
-// IncrementSerialMaybe increments the serial number of this state
-// if it different from the other state.
-func (s *State) IncrementSerialMaybe(other *State) {
-        if s == nil {
-                return
-        }
-        if other == nil {
-                return
-        }
-        s.Lock()
-        defer s.Unlock()
-
-        if s.Serial > other.Serial {
-                return
-        }
-        if other.TFVersion != s.TFVersion || !s.equal(other) {
-                if other.Serial > s.Serial {
-                        s.Serial = other.Serial
-                }
-
-                s.Serial++
-        }
-}
-
 // FromFutureTerraform checks if this state was written by a Terraform
 // version from the future.
 func (s *State) FromFutureTerraform() bool {
@@ -660,6 +677,7 @@ func (s *State) init() {
         if s.Version == 0 {
                 s.Version = StateVersion
         }
+
         if s.moduleByPath(rootModulePath) == nil {
                 s.addModule(rootModulePath)
         }