Initial transfer of provider code

[github/fretlink/terraform-provider-statuscake.git] / vendor / github.com / hashicorp / terraform / terraform / state_upgrade_v1_to_v2.go

diff --git a/vendor/github.com/hashicorp/terraform/terraform/state_upgrade_v1_to_v2.go b/vendor/github.com/hashicorp/terraform/terraform/state_upgrade_v1_to_v2.go
new file mode 100644 (file)
index 0000000..aa13cce
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/terraform/state_upgrade_v1_to_v2.go
@@ -0,0 +1,189 @@
+package terraform
+
+import (
+       "fmt"
+
+       "github.com/mitchellh/copystructure"
+)
+
+// upgradeStateV1ToV2 is used to upgrade a V1 state representation
+// into a V2 state representation
+func upgradeStateV1ToV2(old *stateV1) (*State, error) {
+       if old == nil {
+               return nil, nil
+       }
+
+       remote, err := old.Remote.upgradeToV2()
+       if err != nil {
+               return nil, fmt.Errorf("Error upgrading State V1: %v", err)
+       }
+
+       modules := make([]*ModuleState, len(old.Modules))
+       for i, module := range old.Modules {
+               upgraded, err := module.upgradeToV2()
+               if err != nil {
+                       return nil, fmt.Errorf("Error upgrading State V1: %v", err)
+               }
+               modules[i] = upgraded
+       }
+       if len(modules) == 0 {
+               modules = nil
+       }
+
+       newState := &State{
+               Version: 2,
+               Serial:  old.Serial,
+               Remote:  remote,
+               Modules: modules,
+       }
+
+       newState.sort()
+       newState.init()
+
+       return newState, nil
+}
+
+func (old *remoteStateV1) upgradeToV2() (*RemoteState, error) {
+       if old == nil {
+               return nil, nil
+       }
+
+       config, err := copystructure.Copy(old.Config)
+       if err != nil {
+               return nil, fmt.Errorf("Error upgrading RemoteState V1: %v", err)
+       }
+
+       return &RemoteState{
+               Type:   old.Type,
+               Config: config.(map[string]string),
+       }, nil
+}
+
+func (old *moduleStateV1) upgradeToV2() (*ModuleState, error) {
+       if old == nil {
+               return nil, nil
+       }
+
+       pathRaw, err := copystructure.Copy(old.Path)
+       if err != nil {
+               return nil, fmt.Errorf("Error upgrading ModuleState V1: %v", err)
+       }
+       path, ok := pathRaw.([]string)
+       if !ok {
+               return nil, fmt.Errorf("Error upgrading ModuleState V1: path is not a list of strings")
+       }
+       if len(path) == 0 {
+               // We found some V1 states with a nil path. Assume root and catch
+               // duplicate path errors later (as part of Validate).
+               path = rootModulePath
+       }
+
+       // Outputs needs upgrading to use the new structure
+       outputs := make(map[string]*OutputState)
+       for key, output := range old.Outputs {
+               outputs[key] = &OutputState{
+                       Type:      "string",
+                       Value:     output,
+                       Sensitive: false,
+               }
+       }
+
+       resources := make(map[string]*ResourceState)
+       for key, oldResource := range old.Resources {
+               upgraded, err := oldResource.upgradeToV2()
+               if err != nil {
+                       return nil, fmt.Errorf("Error upgrading ModuleState V1: %v", err)
+               }
+               resources[key] = upgraded
+       }
+
+       dependencies, err := copystructure.Copy(old.Dependencies)
+       if err != nil {
+               return nil, fmt.Errorf("Error upgrading ModuleState V1: %v", err)
+       }
+
+       return &ModuleState{
+               Path:         path,
+               Outputs:      outputs,
+               Resources:    resources,
+               Dependencies: dependencies.([]string),
+       }, nil
+}
+
+func (old *resourceStateV1) upgradeToV2() (*ResourceState, error) {
+       if old == nil {
+               return nil, nil
+       }
+
+       dependencies, err := copystructure.Copy(old.Dependencies)
+       if err != nil {
+               return nil, fmt.Errorf("Error upgrading ResourceState V1: %v", err)
+       }
+
+       primary, err := old.Primary.upgradeToV2()
+       if err != nil {
+               return nil, fmt.Errorf("Error upgrading ResourceState V1: %v", err)
+       }
+
+       deposed := make([]*InstanceState, len(old.Deposed))
+       for i, v := range old.Deposed {
+               upgraded, err := v.upgradeToV2()
+               if err != nil {
+                       return nil, fmt.Errorf("Error upgrading ResourceState V1: %v", err)
+               }
+               deposed[i] = upgraded
+       }
+       if len(deposed) == 0 {
+               deposed = nil
+       }
+
+       return &ResourceState{
+               Type:         old.Type,
+               Dependencies: dependencies.([]string),
+               Primary:      primary,
+               Deposed:      deposed,
+               Provider:     old.Provider,
+       }, nil
+}
+
+func (old *instanceStateV1) upgradeToV2() (*InstanceState, error) {
+       if old == nil {
+               return nil, nil
+       }
+
+       attributes, err := copystructure.Copy(old.Attributes)
+       if err != nil {
+               return nil, fmt.Errorf("Error upgrading InstanceState V1: %v", err)
+       }
+       ephemeral, err := old.Ephemeral.upgradeToV2()
+       if err != nil {
+               return nil, fmt.Errorf("Error upgrading InstanceState V1: %v", err)
+       }
+
+       meta, err := copystructure.Copy(old.Meta)
+       if err != nil {
+               return nil, fmt.Errorf("Error upgrading InstanceState V1: %v", err)
+       }
+
+       newMeta := make(map[string]interface{})
+       for k, v := range meta.(map[string]string) {
+               newMeta[k] = v
+       }
+
+       return &InstanceState{
+               ID:         old.ID,
+               Attributes: attributes.(map[string]string),
+               Ephemeral:  *ephemeral,
+               Meta:       newMeta,
+       }, nil
+}
+
+func (old *ephemeralStateV1) upgradeToV2() (*EphemeralState, error) {
+       connInfo, err := copystructure.Copy(old.ConnInfo)
+       if err != nil {
+               return nil, fmt.Errorf("Error upgrading EphemeralState V1: %v", err)
+       }
+       return &EphemeralState{
+               ConnInfo: connInfo.(map[string]string),
+       }, nil
+}