github.com/danrjohnson/terraform@v0.7.0-rc2.0.20160627135212-d0fc1fa086ff/terraform/state_upgrade_v1_to_v2.go (about)

     1  package terraform
     2  
     3  import (
     4  	"fmt"
     5  	"github.com/mitchellh/copystructure"
     6  )
     7  
     8  // upgradeStateV1ToV2 is used to upgrade a V1 state representation
     9  // into a V2 state representation
    10  func upgradeStateV1ToV2(old *stateV1) (*State, error) {
    11  	if old == nil {
    12  		return nil, nil
    13  	}
    14  
    15  	remote, err := old.Remote.upgradeToV2()
    16  	if err != nil {
    17  		return nil, fmt.Errorf("Error upgrading State V1: %v", err)
    18  	}
    19  
    20  	modules := make([]*ModuleState, len(old.Modules))
    21  	for i, module := range old.Modules {
    22  		upgraded, err := module.upgradeToV2()
    23  		if err != nil {
    24  			return nil, fmt.Errorf("Error upgrading State V1: %v", err)
    25  		}
    26  		modules[i] = upgraded
    27  	}
    28  	if len(modules) == 0 {
    29  		modules = nil
    30  	}
    31  
    32  	newState := &State{
    33  		Version: 2,
    34  		Serial:  old.Serial,
    35  		Remote:  remote,
    36  		Modules: modules,
    37  	}
    38  
    39  	newState.sort()
    40  
    41  	return newState, nil
    42  }
    43  
    44  func (old *remoteStateV1) upgradeToV2() (*RemoteState, error) {
    45  	if old == nil {
    46  		return nil, nil
    47  	}
    48  
    49  	config, err := copystructure.Copy(old.Config)
    50  	if err != nil {
    51  		return nil, fmt.Errorf("Error upgrading RemoteState V1: %v", err)
    52  	}
    53  
    54  	return &RemoteState{
    55  		Type:   old.Type,
    56  		Config: config.(map[string]string),
    57  	}, nil
    58  }
    59  
    60  func (old *moduleStateV1) upgradeToV2() (*ModuleState, error) {
    61  	if old == nil {
    62  		return nil, nil
    63  	}
    64  
    65  	path, err := copystructure.Copy(old.Path)
    66  	if err != nil {
    67  		return nil, fmt.Errorf("Error upgrading ModuleState V1: %v", err)
    68  	}
    69  
    70  	// Outputs needs upgrading to use the new structure
    71  	outputs := make(map[string]*OutputState)
    72  	for key, output := range old.Outputs {
    73  		outputs[key] = &OutputState{
    74  			Type:      "string",
    75  			Value:     output,
    76  			Sensitive: false,
    77  		}
    78  	}
    79  	if len(outputs) == 0 {
    80  		outputs = nil
    81  	}
    82  
    83  	resources := make(map[string]*ResourceState)
    84  	for key, oldResource := range old.Resources {
    85  		upgraded, err := oldResource.upgradeToV2()
    86  		if err != nil {
    87  			return nil, fmt.Errorf("Error upgrading ModuleState V1: %v", err)
    88  		}
    89  		resources[key] = upgraded
    90  	}
    91  	if len(resources) == 0 {
    92  		resources = nil
    93  	}
    94  
    95  	dependencies, err := copystructure.Copy(old.Dependencies)
    96  	if err != nil {
    97  		return nil, fmt.Errorf("Error upgrading ModuleState V1: %v", err)
    98  	}
    99  
   100  	return &ModuleState{
   101  		Path:         path.([]string),
   102  		Outputs:      outputs,
   103  		Resources:    resources,
   104  		Dependencies: dependencies.([]string),
   105  	}, nil
   106  }
   107  
   108  func (old *resourceStateV1) upgradeToV2() (*ResourceState, error) {
   109  	if old == nil {
   110  		return nil, nil
   111  	}
   112  
   113  	dependencies, err := copystructure.Copy(old.Dependencies)
   114  	if err != nil {
   115  		return nil, fmt.Errorf("Error upgrading ResourceState V1: %v", err)
   116  	}
   117  
   118  	primary, err := old.Primary.upgradeToV2()
   119  	if err != nil {
   120  		return nil, fmt.Errorf("Error upgrading ResourceState V1: %v", err)
   121  	}
   122  
   123  	deposed := make([]*InstanceState, len(old.Deposed))
   124  	for i, v := range old.Deposed {
   125  		upgraded, err := v.upgradeToV2()
   126  		if err != nil {
   127  			return nil, fmt.Errorf("Error upgrading ResourceState V1: %v", err)
   128  		}
   129  		deposed[i] = upgraded
   130  	}
   131  	if len(deposed) == 0 {
   132  		deposed = nil
   133  	}
   134  
   135  	return &ResourceState{
   136  		Type:         old.Type,
   137  		Dependencies: dependencies.([]string),
   138  		Primary:      primary,
   139  		Deposed:      deposed,
   140  		Provider:     old.Provider,
   141  	}, nil
   142  }
   143  
   144  func (old *instanceStateV1) upgradeToV2() (*InstanceState, error) {
   145  	if old == nil {
   146  		return nil, nil
   147  	}
   148  
   149  	attributes, err := copystructure.Copy(old.Attributes)
   150  	if err != nil {
   151  		return nil, fmt.Errorf("Error upgrading InstanceState V1: %v", err)
   152  	}
   153  	ephemeral, err := old.Ephemeral.upgradeToV2()
   154  	if err != nil {
   155  		return nil, fmt.Errorf("Error upgrading InstanceState V1: %v", err)
   156  	}
   157  	meta, err := copystructure.Copy(old.Meta)
   158  	if err != nil {
   159  		return nil, fmt.Errorf("Error upgrading InstanceState V1: %v", err)
   160  	}
   161  
   162  	return &InstanceState{
   163  		ID:         old.ID,
   164  		Attributes: attributes.(map[string]string),
   165  		Ephemeral:  *ephemeral,
   166  		Meta:       meta.(map[string]string),
   167  	}, nil
   168  }
   169  
   170  func (old *ephemeralStateV1) upgradeToV2() (*EphemeralState, error) {
   171  	connInfo, err := copystructure.Copy(old.ConnInfo)
   172  	if err != nil {
   173  		return nil, fmt.Errorf("Error upgrading EphemeralState V1: %v", err)
   174  	}
   175  	return &EphemeralState{
   176  		ConnInfo: connInfo.(map[string]string),
   177  	}, nil
   178  }