terraform/states/state_deepcopy.go

233 lines
7.6 KiB
Go

package states
import (
"github.com/hashicorp/terraform/addrs"
"github.com/zclconf/go-cty/cty"
)
// Taking deep copies of states is an important operation because state is
// otherwise a mutable data structure that is challenging to share across
// many separate callers. It is important that the DeepCopy implementations
// in this file comprehensively copy all parts of the state data structure
// that could be mutated via pointers.
// DeepCopy returns a new state that contains equivalent data to the reciever
// but shares no backing memory in common.
//
// As with all methods on State, this method is not safe to use concurrently
// with writing to any portion of the recieving data structure. It is the
// caller's responsibility to ensure mutual exclusion for the duration of the
// operation, but may then freely modify the receiver and the returned copy
// independently once this method returns.
func (s *State) DeepCopy() *State {
if s == nil {
return nil
}
modules := make(map[string]*Module, len(s.Modules))
for k, m := range s.Modules {
modules[k] = m.DeepCopy()
}
return &State{
Modules: modules,
}
}
// DeepCopy returns a new module state that contains equivalent data to the
// receiver but shares no backing memory in common.
//
// As with all methods on Module, this method is not safe to use concurrently
// with writing to any portion of the recieving data structure. It is the
// caller's responsibility to ensure mutual exclusion for the duration of the
// operation, but may then freely modify the receiver and the returned copy
// independently once this method returns.
func (ms *Module) DeepCopy() *Module {
if ms == nil {
return nil
}
resources := make(map[string]*Resource, len(ms.Resources))
for k, r := range ms.Resources {
resources[k] = r.DeepCopy()
}
outputValues := make(map[string]*OutputValue, len(ms.OutputValues))
for k, v := range ms.OutputValues {
outputValues[k] = v.DeepCopy()
}
localValues := make(map[string]cty.Value, len(ms.LocalValues))
for k, v := range ms.LocalValues {
// cty.Value is immutable, so we don't need to copy these.
localValues[k] = v
}
return &Module{
Addr: ms.Addr, // technically mutable, but immutable by convention
Resources: resources,
OutputValues: outputValues,
LocalValues: localValues,
}
}
// DeepCopy returns a new resource state that contains equivalent data to the
// receiver but shares no backing memory in common.
//
// As with all methods on Resource, this method is not safe to use concurrently
// with writing to any portion of the recieving data structure. It is the
// caller's responsibility to ensure mutual exclusion for the duration of the
// operation, but may then freely modify the receiver and the returned copy
// independently once this method returns.
func (rs *Resource) DeepCopy() *Resource {
if rs == nil {
return nil
}
instances := make(map[addrs.InstanceKey]*ResourceInstance, len(rs.Instances))
for k, i := range rs.Instances {
instances[k] = i.DeepCopy()
}
return &Resource{
Addr: rs.Addr,
Instances: instances,
ProviderConfig: rs.ProviderConfig, // technically mutable, but immutable by convention
}
}
// DeepCopy returns a new resource instance state that contains equivalent data
// to the receiver but shares no backing memory in common.
//
// As with all methods on ResourceInstance, this method is not safe to use
// concurrently with writing to any portion of the recieving data structure. It
// is the caller's responsibility to ensure mutual exclusion for the duration
// of the operation, but may then freely modify the receiver and the returned
// copy independently once this method returns.
func (i *ResourceInstance) DeepCopy() *ResourceInstance {
if i == nil {
return nil
}
deposed := make(map[DeposedKey]*ResourceInstanceObjectSrc, len(i.Deposed))
for k, obj := range i.Deposed {
deposed[k] = obj.DeepCopy()
}
return &ResourceInstance{
Current: i.Current.DeepCopy(),
Deposed: deposed,
}
}
// DeepCopy returns a new resource instance object that contains equivalent data
// to the receiver but shares no backing memory in common.
//
// As with all methods on ResourceInstanceObjectSrc, this method is not safe to
// use concurrently with writing to any portion of the recieving data structure.
// It is the caller's responsibility to ensure mutual exclusion for the duration
// of the operation, but may then freely modify the receiver and the returned
// copy independently once this method returns.
func (os *ResourceInstanceObjectSrc) DeepCopy() *ResourceInstanceObjectSrc {
if os == nil {
return nil
}
var attrsFlat map[string]string
if os.AttrsFlat != nil {
attrsFlat = make(map[string]string, len(os.AttrsFlat))
for k, v := range os.AttrsFlat {
attrsFlat[k] = v
}
}
var attrsJSON []byte
if os.AttrsJSON != nil {
attrsJSON = make([]byte, len(os.AttrsJSON))
copy(attrsJSON, os.AttrsJSON)
}
var attrPaths []cty.PathValueMarks
if os.AttrSensitivePaths != nil {
attrPaths = make([]cty.PathValueMarks, len(os.AttrSensitivePaths))
copy(attrPaths, os.AttrSensitivePaths)
}
var private []byte
if os.Private != nil {
private = make([]byte, len(os.Private))
copy(private, os.Private)
}
// Some addrs.Referencable implementations are technically mutable, but
// we treat them as immutable by convention and so we don't deep-copy here.
var dependencies []addrs.ConfigResource
if os.Dependencies != nil {
dependencies = make([]addrs.ConfigResource, len(os.Dependencies))
copy(dependencies, os.Dependencies)
}
return &ResourceInstanceObjectSrc{
Status: os.Status,
SchemaVersion: os.SchemaVersion,
Private: private,
AttrsFlat: attrsFlat,
AttrsJSON: attrsJSON,
AttrSensitivePaths: attrPaths,
Dependencies: dependencies,
CreateBeforeDestroy: os.CreateBeforeDestroy,
}
}
// DeepCopy returns a new resource instance object that contains equivalent data
// to the receiver but shares no backing memory in common.
//
// As with all methods on ResourceInstanceObject, this method is not safe to use
// concurrently with writing to any portion of the recieving data structure. It
// is the caller's responsibility to ensure mutual exclusion for the duration
// of the operation, but may then freely modify the receiver and the returned
// copy independently once this method returns.
func (o *ResourceInstanceObject) DeepCopy() *ResourceInstanceObject {
if o == nil {
return nil
}
var private []byte
if o.Private != nil {
private = make([]byte, len(o.Private))
copy(private, o.Private)
}
// Some addrs.Referenceable implementations are technically mutable, but
// we treat them as immutable by convention and so we don't deep-copy here.
var dependencies []addrs.ConfigResource
if o.Dependencies != nil {
dependencies = make([]addrs.ConfigResource, len(o.Dependencies))
copy(dependencies, o.Dependencies)
}
return &ResourceInstanceObject{
Value: o.Value,
Status: o.Status,
Private: private,
Dependencies: dependencies,
}
}
// DeepCopy returns a new output value state that contains equivalent data
// to the receiver but shares no backing memory in common.
//
// As with all methods on OutputValue, this method is not safe to use
// concurrently with writing to any portion of the recieving data structure. It
// is the caller's responsibility to ensure mutual exclusion for the duration
// of the operation, but may then freely modify the receiver and the returned
// copy independently once this method returns.
func (os *OutputValue) DeepCopy() *OutputValue {
if os == nil {
return nil
}
return &OutputValue{
Addr: os.Addr,
Value: os.Value,
Sensitive: os.Sensitive,
}
}