1 files changed, 95 insertions, 13 deletions

diff --git a/vendor/github.com/hashicorp/terraform/terraform/state.go b/vendor/github.com/hashicorp/terraform/terraform/state.go
index 0c46194..04b14a6 100644
--- a/vendor/github.com/hashicorp/terraform/terraform/state.go
+++ b/vendor/github.com/hashicorp/terraform/terraform/state.go
@@ -9,6 +9,7 @@ import (
         "io"
         "io/ioutil"
         "log"
+        "os"
         "reflect"
         "sort"
         "strconv"
@@ -16,10 +17,12 @@ import (
         "sync"
 
         "github.com/hashicorp/go-multierror"
+        "github.com/hashicorp/go-uuid"
         "github.com/hashicorp/go-version"
         "github.com/hashicorp/terraform/config"
         "github.com/mitchellh/copystructure"
-        "github.com/satori/go.uuid"
+
+        tfversion "github.com/hashicorp/terraform/version"
 )
 
 const (
@@ -664,7 +667,7 @@ func (s *State) FromFutureTerraform() bool {
         }
 
         v := version.Must(version.NewVersion(s.TFVersion))
-        return SemVersion.LessThan(v)
+        return tfversion.SemVer.LessThan(v)
 }
 
 func (s *State) Init() {
@@ -704,7 +707,11 @@ func (s *State) EnsureHasLineage() {
 
 func (s *State) ensureHasLineage() {
         if s.Lineage == "" {
-                s.Lineage = uuid.NewV4().String()
+                lineage, err := uuid.GenerateUUID()
+                if err != nil {
+                        panic(fmt.Errorf("Failed to generate lineage: %v", err))
+                }
+                s.Lineage = lineage
                 log.Printf("[DEBUG] New state was assigned lineage %q\n", s.Lineage)
         } else {
                 log.Printf("[TRACE] Preserving existing state lineage %q\n", s.Lineage)
@@ -977,6 +984,10 @@ type ModuleState struct {
         // always disjoint, so the path represents amodule tree
         Path []string `json:"path"`
 
+        // Locals are kept only transiently in-memory, because we can always
+        // re-compute them.
+        Locals map[string]interface{} `json:"-"`
+
         // Outputs declared by the module and maintained for each module
         // even though only the root module technically needs to be kept.
         // This allows operators to inspect values at the boundaries.
@@ -1083,7 +1094,7 @@ func (m *ModuleState) Orphans(c *config.Config) []string {
         defer m.Unlock()
 
         keys := make(map[string]struct{})
-        for k, _ := range m.Resources {
+        for k := range m.Resources {
                 keys[k] = struct{}{}
         }
 
@@ -1091,7 +1102,7 @@ func (m *ModuleState) Orphans(c *config.Config) []string {
                 for _, r := range c.Resources {
                         delete(keys, r.Id())
 
-                        for k, _ := range keys {
+                        for k := range keys {
                                 if strings.HasPrefix(k, r.Id()+".") {
                                         delete(keys, k)
                                 }
@@ -1100,7 +1111,32 @@ func (m *ModuleState) Orphans(c *config.Config) []string {
         }
 
         result := make([]string, 0, len(keys))
-        for k, _ := range keys {
+        for k := range keys {
+                result = append(result, k)
+        }
+
+        return result
+}
+
+// RemovedOutputs returns a list of outputs that are in the State but aren't
+// present in the configuration itself.
+func (m *ModuleState) RemovedOutputs(c *config.Config) []string {
+        m.Lock()
+        defer m.Unlock()
+
+        keys := make(map[string]struct{})
+        for k := range m.Outputs {
+                keys[k] = struct{}{}
+        }
+
+        if c != nil {
+                for _, o := range c.Outputs {
+                        delete(keys, o.Name)
+                }
+        }
+
+        result := make([]string, 0, len(keys))
+        for k := range keys {
                 result = append(result, k)
         }
 
@@ -1308,6 +1344,10 @@ func (m *ModuleState) String() string {
         return buf.String()
 }
 
+func (m *ModuleState) Empty() bool {
+        return len(m.Locals) == 0 && len(m.Outputs) == 0 && len(m.Resources) == 0
+}
+
 // ResourceStateKey is a structured representation of the key used for the
 // ModuleState.Resources mapping
 type ResourceStateKey struct {
@@ -1681,7 +1721,20 @@ func (s *InstanceState) Equal(other *InstanceState) bool {
                 // We only do the deep check if both are non-nil. If one is nil
                 // we treat it as equal since their lengths are both zero (check
                 // above).
-                if !reflect.DeepEqual(s.Meta, other.Meta) {
+                //
+                // Since this can contain numeric values that may change types during
+                // serialization, let's compare the serialized values.
+                sMeta, err := json.Marshal(s.Meta)
+                if err != nil {
+                        // marshaling primitives shouldn't ever error out
+                        panic(err)
+                }
+                otherMeta, err := json.Marshal(other.Meta)
+                if err != nil {
+                        panic(err)
+                }
+
+                if !bytes.Equal(sMeta, otherMeta) {
                         return false
                 }
         }
@@ -1824,11 +1877,19 @@ var ErrNoState = errors.New("no state")
 // ReadState reads a state structure out of a reader in the format that
 // was written by WriteState.
 func ReadState(src io.Reader) (*State, error) {
+        // check for a nil file specifically, since that produces a platform
+        // specific error if we try to use it in a bufio.Reader.
+        if f, ok := src.(*os.File); ok && f == nil {
+                return nil, ErrNoState
+        }
+
         buf := bufio.NewReader(src)
+
         if _, err := buf.Peek(1); err != nil {
-                // the error is either io.EOF or "invalid argument", and both are from
-                // an empty state.
-                return nil, ErrNoState
+                if err == io.EOF {
+                        return nil, ErrNoState
+                }
+                return nil, err
         }
 
         if err := testForV0State(buf); err != nil {
@@ -1891,7 +1952,7 @@ func ReadState(src io.Reader) (*State, error) {
                 result = v3State
         default:
                 return nil, fmt.Errorf("Terraform %s does not support state version %d, please update.",
-                        SemVersion.String(), versionIdentifier.Version)
+                        tfversion.SemVer.String(), versionIdentifier.Version)
         }
 
         // If we reached this place we must have a result set
@@ -1935,7 +1996,7 @@ func ReadStateV2(jsonBytes []byte) (*State, error) {
         // version that we don't understand
         if state.Version > StateVersion {
                 return nil, fmt.Errorf("Terraform %s does not support state version %d, please update.",
-                        SemVersion.String(), state.Version)
+                        tfversion.SemVer.String(), state.Version)
         }
 
         // Make sure the version is semantic
@@ -1970,7 +2031,7 @@ func ReadStateV3(jsonBytes []byte) (*State, error) {
         // version that we don't understand
         if state.Version > StateVersion {
                 return nil, fmt.Errorf("Terraform %s does not support state version %d, please update.",
-                        SemVersion.String(), state.Version)
+                        tfversion.SemVer.String(), state.Version)
         }
 
         // Make sure the version is semantic
@@ -2126,6 +2187,19 @@ func (s moduleStateSort) Swap(i, j int) {
         s[i], s[j] = s[j], s[i]
 }
 
+// StateCompatible returns an error if the state is not compatible with the
+// current version of terraform.
+func CheckStateVersion(state *State) error {
+        if state == nil {
+                return nil
+        }
+
+        if state.FromFutureTerraform() {
+                return fmt.Errorf(stateInvalidTerraformVersionErr, state.TFVersion)
+        }
+        return nil
+}
+
 const stateValidateErrMultiModule = `
 Multiple modules with the same path: %s
 
@@ -2134,3 +2208,11 @@ in your state file that point to the same module. This will cause Terraform
 to behave in unexpected and error prone ways and is invalid. Please back up
 and modify your state file manually to resolve this.
 `
+
+const stateInvalidTerraformVersionErr = `
+Terraform doesn't allow running any operations against a state
+that was written by a future Terraform version. The state is
+reporting it is written by Terraform '%s'
+
+Please run at least that version of Terraform to continue.
+`