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, EachMode: rs.EachMode, 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 (is *ResourceInstance) DeepCopy() *ResourceInstance { if is == nil { return nil } deposed := make(map[DeposedKey]*ResourceInstanceObjectSrc, len(is.Deposed)) for k, obj := range is.Deposed { deposed[k] = obj.DeepCopy() } return &ResourceInstance{ Current: is.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 (obj *ResourceInstanceObjectSrc) DeepCopy() *ResourceInstanceObjectSrc { if obj == nil { return nil } var attrsFlat map[string]string if obj.AttrsFlat != nil { attrsFlat = make(map[string]string, len(obj.AttrsFlat)) for k, v := range obj.AttrsFlat { attrsFlat[k] = v } } var attrsJSON []byte if obj.AttrsJSON != nil { attrsJSON = make([]byte, len(obj.AttrsJSON)) copy(attrsJSON, obj.AttrsJSON) } var private []byte if obj.Private != nil { private = make([]byte, len(obj.Private)) copy(private, obj.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 obj.Dependencies != nil { dependencies = make([]addrs.ConfigResource, len(obj.Dependencies)) copy(dependencies, obj.Dependencies) } var dependsOn []addrs.Referenceable if obj.DependsOn != nil { dependsOn = make([]addrs.Referenceable, len(obj.DependsOn)) copy(dependsOn, obj.DependsOn) } return &ResourceInstanceObjectSrc{ Status: obj.Status, SchemaVersion: obj.SchemaVersion, Private: private, AttrsFlat: attrsFlat, AttrsJSON: attrsJSON, Dependencies: dependencies, DependsOn: dependsOn, CreateBeforeDestroy: obj.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 (obj *ResourceInstanceObject) DeepCopy() *ResourceInstanceObject { if obj == nil { return nil } var private []byte if obj.Private != nil { private = make([]byte, len(obj.Private)) copy(private, obj.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 obj.Dependencies != nil { dependencies = make([]addrs.ConfigResource, len(obj.Dependencies)) copy(dependencies, obj.Dependencies) } return &ResourceInstanceObject{ Value: obj.Value, Status: obj.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, } }