630 lines
22 KiB
Go
630 lines
22 KiB
Go
package objchange
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
"github.com/zclconf/go-cty/cty"
|
|
|
|
"github.com/hashicorp/terraform/internal/configs/configschema"
|
|
)
|
|
|
|
// ProposedNew constructs a proposed new object value by combining the
|
|
// computed attribute values from "prior" with the configured attribute values
|
|
// from "config".
|
|
//
|
|
// Both value must conform to the given schema's implied type, or this function
|
|
// will panic.
|
|
//
|
|
// The prior value must be wholly known, but the config value may be unknown
|
|
// or have nested unknown values.
|
|
//
|
|
// The merging of the two objects includes the attributes of any nested blocks,
|
|
// which will be correlated in a manner appropriate for their nesting mode.
|
|
// Note in particular that the correlation for blocks backed by sets is a
|
|
// heuristic based on matching non-computed attribute values and so it may
|
|
// produce strange results with more "extreme" cases, such as a nested set
|
|
// block where _all_ attributes are computed.
|
|
func ProposedNew(schema *configschema.Block, prior, config cty.Value) cty.Value {
|
|
// If the config and prior are both null, return early here before
|
|
// populating the prior block. The prevents non-null blocks from appearing
|
|
// the proposed state value.
|
|
if config.IsNull() && prior.IsNull() {
|
|
return prior
|
|
}
|
|
|
|
if prior.IsNull() {
|
|
// In this case, we will construct a synthetic prior value that is
|
|
// similar to the result of decoding an empty configuration block,
|
|
// which simplifies our handling of the top-level attributes/blocks
|
|
// below by giving us one non-null level of object to pull values from.
|
|
prior = AllBlockAttributesNull(schema)
|
|
}
|
|
return proposedNew(schema, prior, config)
|
|
}
|
|
|
|
// PlannedDataResourceObject is similar to proposedNewBlock but tailored for
|
|
// planning data resources in particular. Specifically, it replaces the values
|
|
// of any Computed attributes not set in the configuration with an unknown
|
|
// value, which serves as a placeholder for a value to be filled in by the
|
|
// provider when the data resource is finally read.
|
|
//
|
|
// Data resources are different because the planning of them is handled
|
|
// entirely within Terraform Core and not subject to customization by the
|
|
// provider. This function is, in effect, producing an equivalent result to
|
|
// passing the proposedNewBlock result into a provider's PlanResourceChange
|
|
// function, assuming a fixed implementation of PlanResourceChange that just
|
|
// fills in unknown values as needed.
|
|
func PlannedDataResourceObject(schema *configschema.Block, config cty.Value) cty.Value {
|
|
// Our trick here is to run the proposedNewBlock logic with an
|
|
// entirely-unknown prior value. Because of cty's unknown short-circuit
|
|
// behavior, any operation on prior returns another unknown, and so
|
|
// unknown values propagate into all of the parts of the resulting value
|
|
// that would normally be filled in by preserving the prior state.
|
|
prior := cty.UnknownVal(schema.ImpliedType())
|
|
return proposedNew(schema, prior, config)
|
|
}
|
|
|
|
func proposedNew(schema *configschema.Block, prior, config cty.Value) cty.Value {
|
|
if config.IsNull() || !config.IsKnown() {
|
|
// This is a weird situation, but we'll allow it anyway to free
|
|
// callers from needing to specifically check for these cases.
|
|
return prior
|
|
}
|
|
if (!prior.Type().IsObjectType()) || (!config.Type().IsObjectType()) {
|
|
panic("ProposedNew only supports object-typed values")
|
|
}
|
|
|
|
// From this point onwards, we can assume that both values are non-null
|
|
// object types, and that the config value itself is known (though it
|
|
// may contain nested values that are unknown.)
|
|
newAttrs := proposedNewAttributes(schema.Attributes, prior, config)
|
|
|
|
// Merging nested blocks is a little more complex, since we need to
|
|
// correlate blocks between both objects and then recursively propose
|
|
// a new object for each. The correlation logic depends on the nesting
|
|
// mode for each block type.
|
|
for name, blockType := range schema.BlockTypes {
|
|
priorV := prior.GetAttr(name)
|
|
configV := config.GetAttr(name)
|
|
newAttrs[name] = proposedNewNestedBlock(blockType, priorV, configV)
|
|
}
|
|
|
|
return cty.ObjectVal(newAttrs)
|
|
}
|
|
|
|
func proposedNewNestedBlock(schema *configschema.NestedBlock, prior, config cty.Value) cty.Value {
|
|
// The only time we should encounter an entirely unknown block is from the
|
|
// use of dynamic with an unknown for_each expression.
|
|
if !config.IsKnown() {
|
|
return config
|
|
}
|
|
|
|
var newV cty.Value
|
|
|
|
switch schema.Nesting {
|
|
|
|
case configschema.NestingSingle, configschema.NestingGroup:
|
|
newV = ProposedNew(&schema.Block, prior, config)
|
|
|
|
case configschema.NestingList:
|
|
// Nested blocks are correlated by index.
|
|
configVLen := 0
|
|
if !config.IsNull() {
|
|
configVLen = config.LengthInt()
|
|
}
|
|
if configVLen > 0 {
|
|
newVals := make([]cty.Value, 0, configVLen)
|
|
for it := config.ElementIterator(); it.Next(); {
|
|
idx, configEV := it.Element()
|
|
if prior.IsKnown() && (prior.IsNull() || !prior.HasIndex(idx).True()) {
|
|
// If there is no corresponding prior element then
|
|
// we just take the config value as-is.
|
|
newVals = append(newVals, configEV)
|
|
continue
|
|
}
|
|
priorEV := prior.Index(idx)
|
|
|
|
newEV := ProposedNew(&schema.Block, priorEV, configEV)
|
|
newVals = append(newVals, newEV)
|
|
}
|
|
// Despite the name, a NestingList might also be a tuple, if
|
|
// its nested schema contains dynamically-typed attributes.
|
|
if config.Type().IsTupleType() {
|
|
newV = cty.TupleVal(newVals)
|
|
} else {
|
|
newV = cty.ListVal(newVals)
|
|
}
|
|
} else {
|
|
// Despite the name, a NestingList might also be a tuple, if
|
|
// its nested schema contains dynamically-typed attributes.
|
|
if config.Type().IsTupleType() {
|
|
newV = cty.EmptyTupleVal
|
|
} else {
|
|
newV = cty.ListValEmpty(schema.ImpliedType())
|
|
}
|
|
}
|
|
|
|
case configschema.NestingMap:
|
|
// Despite the name, a NestingMap may produce either a map or
|
|
// object value, depending on whether the nested schema contains
|
|
// dynamically-typed attributes.
|
|
if config.Type().IsObjectType() {
|
|
// Nested blocks are correlated by key.
|
|
configVLen := 0
|
|
if config.IsKnown() && !config.IsNull() {
|
|
configVLen = config.LengthInt()
|
|
}
|
|
if configVLen > 0 {
|
|
newVals := make(map[string]cty.Value, configVLen)
|
|
atys := config.Type().AttributeTypes()
|
|
for name := range atys {
|
|
configEV := config.GetAttr(name)
|
|
if !prior.IsKnown() || prior.IsNull() || !prior.Type().HasAttribute(name) {
|
|
// If there is no corresponding prior element then
|
|
// we just take the config value as-is.
|
|
newVals[name] = configEV
|
|
continue
|
|
}
|
|
priorEV := prior.GetAttr(name)
|
|
|
|
newEV := ProposedNew(&schema.Block, priorEV, configEV)
|
|
newVals[name] = newEV
|
|
}
|
|
// Although we call the nesting mode "map", we actually use
|
|
// object values so that elements might have different types
|
|
// in case of dynamically-typed attributes.
|
|
newV = cty.ObjectVal(newVals)
|
|
} else {
|
|
newV = cty.EmptyObjectVal
|
|
}
|
|
} else {
|
|
configVLen := 0
|
|
if config.IsKnown() && !config.IsNull() {
|
|
configVLen = config.LengthInt()
|
|
}
|
|
if configVLen > 0 {
|
|
newVals := make(map[string]cty.Value, configVLen)
|
|
for it := config.ElementIterator(); it.Next(); {
|
|
idx, configEV := it.Element()
|
|
k := idx.AsString()
|
|
if prior.IsKnown() && (prior.IsNull() || !prior.HasIndex(idx).True()) {
|
|
// If there is no corresponding prior element then
|
|
// we just take the config value as-is.
|
|
newVals[k] = configEV
|
|
continue
|
|
}
|
|
priorEV := prior.Index(idx)
|
|
|
|
newEV := ProposedNew(&schema.Block, priorEV, configEV)
|
|
newVals[k] = newEV
|
|
}
|
|
newV = cty.MapVal(newVals)
|
|
} else {
|
|
newV = cty.MapValEmpty(schema.ImpliedType())
|
|
}
|
|
}
|
|
|
|
case configschema.NestingSet:
|
|
if !config.Type().IsSetType() {
|
|
panic("configschema.NestingSet value is not a set as expected")
|
|
}
|
|
|
|
// Nested blocks are correlated by comparing the element values
|
|
// after eliminating all of the computed attributes. In practice,
|
|
// this means that any config change produces an entirely new
|
|
// nested object, and we only propagate prior computed values
|
|
// if the non-computed attribute values are identical.
|
|
var cmpVals [][2]cty.Value
|
|
if prior.IsKnown() && !prior.IsNull() {
|
|
cmpVals = setElementCompareValues(&schema.Block, prior, false)
|
|
}
|
|
configVLen := 0
|
|
if config.IsKnown() && !config.IsNull() {
|
|
configVLen = config.LengthInt()
|
|
}
|
|
if configVLen > 0 {
|
|
used := make([]bool, len(cmpVals)) // track used elements in case multiple have the same compare value
|
|
newVals := make([]cty.Value, 0, configVLen)
|
|
for it := config.ElementIterator(); it.Next(); {
|
|
_, configEV := it.Element()
|
|
var priorEV cty.Value
|
|
for i, cmp := range cmpVals {
|
|
if used[i] {
|
|
continue
|
|
}
|
|
if cmp[1].RawEquals(configEV) {
|
|
priorEV = cmp[0]
|
|
used[i] = true // we can't use this value on a future iteration
|
|
break
|
|
}
|
|
}
|
|
if priorEV == cty.NilVal {
|
|
priorEV = cty.NullVal(schema.ImpliedType())
|
|
}
|
|
|
|
newEV := ProposedNew(&schema.Block, priorEV, configEV)
|
|
newVals = append(newVals, newEV)
|
|
}
|
|
newV = cty.SetVal(newVals)
|
|
} else {
|
|
newV = cty.SetValEmpty(schema.Block.ImpliedType())
|
|
}
|
|
|
|
default:
|
|
// Should never happen, since the above cases are comprehensive.
|
|
panic(fmt.Sprintf("unsupported block nesting mode %s", schema.Nesting))
|
|
}
|
|
return newV
|
|
}
|
|
|
|
func proposedNewAttributes(attrs map[string]*configschema.Attribute, prior, config cty.Value) map[string]cty.Value {
|
|
if prior.IsNull() {
|
|
prior = AllAttributesNull(attrs)
|
|
}
|
|
newAttrs := make(map[string]cty.Value, len(attrs))
|
|
for name, attr := range attrs {
|
|
priorV := prior.GetAttr(name)
|
|
configV := config.GetAttr(name)
|
|
var newV cty.Value
|
|
switch {
|
|
case attr.Computed && attr.Optional:
|
|
// This is the trickiest scenario: we want to keep the prior value
|
|
// if the config isn't overriding it. Note that due to some
|
|
// ambiguity here, setting an optional+computed attribute from
|
|
// config and then later switching the config to null in a
|
|
// subsequent change causes the initial config value to be "sticky"
|
|
// unless the provider specifically overrides it during its own
|
|
// plan customization step.
|
|
if configV.IsNull() {
|
|
newV = priorV
|
|
} else {
|
|
newV = configV
|
|
}
|
|
case attr.Computed:
|
|
// configV will always be null in this case, by definition.
|
|
// priorV may also be null, but that's okay.
|
|
newV = priorV
|
|
default:
|
|
if attr.NestedType != nil {
|
|
// For non-computed NestedType attributes, we need to descend
|
|
// into the individual nested attributes to build the final
|
|
// value, unless the entire nested attribute is unknown.
|
|
if !configV.IsKnown() {
|
|
newV = configV
|
|
} else {
|
|
newV = proposedNewNestedType(attr.NestedType, priorV, configV)
|
|
}
|
|
} else {
|
|
// For non-computed attributes, we always take the config value,
|
|
// even if it is null. If it's _required_ then null values
|
|
// should've been caught during an earlier validation step, and
|
|
// so we don't really care about that here.
|
|
newV = configV
|
|
}
|
|
}
|
|
newAttrs[name] = newV
|
|
}
|
|
return newAttrs
|
|
}
|
|
|
|
func proposedNewNestedType(schema *configschema.Object, prior, config cty.Value) cty.Value {
|
|
var newV cty.Value
|
|
switch schema.Nesting {
|
|
case configschema.NestingSingle:
|
|
newAttrs := proposedNewAttributes(schema.Attributes, prior, config)
|
|
newV = cty.ObjectVal(newAttrs)
|
|
|
|
case configschema.NestingList:
|
|
// Nested blocks are correlated by index.
|
|
configVLen := 0
|
|
if config.IsKnown() && !config.IsNull() {
|
|
configVLen = config.LengthInt()
|
|
}
|
|
if configVLen > 0 {
|
|
newVals := make([]cty.Value, 0, configVLen)
|
|
for it := config.ElementIterator(); it.Next(); {
|
|
idx, configEV := it.Element()
|
|
if prior.IsKnown() && (prior.IsNull() || !prior.HasIndex(idx).True()) {
|
|
// If there is no corresponding prior element then
|
|
// we just take the config value as-is.
|
|
newVals = append(newVals, configEV)
|
|
continue
|
|
}
|
|
priorEV := prior.Index(idx)
|
|
|
|
newEV := proposedNewAttributes(schema.Attributes, priorEV, configEV)
|
|
newVals = append(newVals, cty.ObjectVal(newEV))
|
|
}
|
|
// Despite the name, a NestingList might also be a tuple, if
|
|
// its nested schema contains dynamically-typed attributes.
|
|
if config.Type().IsTupleType() {
|
|
newV = cty.TupleVal(newVals)
|
|
} else {
|
|
newV = cty.ListVal(newVals)
|
|
}
|
|
} else {
|
|
newV = cty.NullVal(schema.ImpliedType())
|
|
}
|
|
|
|
case configschema.NestingMap:
|
|
// Despite the name, a NestingMap may produce either a map or
|
|
// object value, depending on whether the nested schema contains
|
|
// dynamically-typed attributes.
|
|
if config.Type().IsObjectType() {
|
|
// Nested blocks are correlated by key.
|
|
configVLen := 0
|
|
if config.IsKnown() && !config.IsNull() {
|
|
configVLen = config.LengthInt()
|
|
}
|
|
if configVLen > 0 {
|
|
newVals := make(map[string]cty.Value, configVLen)
|
|
atys := config.Type().AttributeTypes()
|
|
for name := range atys {
|
|
configEV := config.GetAttr(name)
|
|
if !prior.IsKnown() || prior.IsNull() || !prior.Type().HasAttribute(name) {
|
|
// If there is no corresponding prior element then
|
|
// we just take the config value as-is.
|
|
newVals[name] = configEV
|
|
continue
|
|
}
|
|
priorEV := prior.GetAttr(name)
|
|
newEV := proposedNewAttributes(schema.Attributes, priorEV, configEV)
|
|
newVals[name] = cty.ObjectVal(newEV)
|
|
}
|
|
// Although we call the nesting mode "map", we actually use
|
|
// object values so that elements might have different types
|
|
// in case of dynamically-typed attributes.
|
|
newV = cty.ObjectVal(newVals)
|
|
} else {
|
|
newV = cty.NullVal(schema.ImpliedType())
|
|
}
|
|
} else {
|
|
configVLen := 0
|
|
if config.IsKnown() && !config.IsNull() {
|
|
configVLen = config.LengthInt()
|
|
}
|
|
if configVLen > 0 {
|
|
newVals := make(map[string]cty.Value, configVLen)
|
|
for it := config.ElementIterator(); it.Next(); {
|
|
idx, configEV := it.Element()
|
|
k := idx.AsString()
|
|
if prior.IsKnown() && (prior.IsNull() || !prior.HasIndex(idx).True()) {
|
|
// If there is no corresponding prior element then
|
|
// we just take the config value as-is.
|
|
newVals[k] = configEV
|
|
continue
|
|
}
|
|
priorEV := prior.Index(idx)
|
|
|
|
newEV := proposedNewAttributes(schema.Attributes, priorEV, configEV)
|
|
newVals[k] = cty.ObjectVal(newEV)
|
|
}
|
|
newV = cty.MapVal(newVals)
|
|
} else {
|
|
newV = cty.NullVal(schema.ImpliedType())
|
|
}
|
|
}
|
|
|
|
case configschema.NestingSet:
|
|
// Nested blocks are correlated by comparing the element values
|
|
// after eliminating all of the computed attributes. In practice,
|
|
// this means that any config change produces an entirely new
|
|
// nested object, and we only propagate prior computed values
|
|
// if the non-computed attribute values are identical.
|
|
var cmpVals [][2]cty.Value
|
|
if prior.IsKnown() && !prior.IsNull() {
|
|
cmpVals = setElementCompareValuesFromObject(schema, prior)
|
|
}
|
|
configVLen := 0
|
|
if config.IsKnown() && !config.IsNull() {
|
|
configVLen = config.LengthInt()
|
|
}
|
|
if configVLen > 0 {
|
|
used := make([]bool, len(cmpVals)) // track used elements in case multiple have the same compare value
|
|
newVals := make([]cty.Value, 0, configVLen)
|
|
for it := config.ElementIterator(); it.Next(); {
|
|
_, configEV := it.Element()
|
|
var priorEV cty.Value
|
|
for i, cmp := range cmpVals {
|
|
if used[i] {
|
|
continue
|
|
}
|
|
if cmp[1].RawEquals(configEV) {
|
|
priorEV = cmp[0]
|
|
used[i] = true // we can't use this value on a future iteration
|
|
break
|
|
}
|
|
}
|
|
if priorEV == cty.NilVal {
|
|
newVals = append(newVals, configEV)
|
|
} else {
|
|
newEV := proposedNewAttributes(schema.Attributes, priorEV, configEV)
|
|
newVals = append(newVals, cty.ObjectVal(newEV))
|
|
}
|
|
}
|
|
newV = cty.SetVal(newVals)
|
|
} else {
|
|
newV = cty.NullVal(schema.ImpliedType())
|
|
}
|
|
}
|
|
|
|
return newV
|
|
}
|
|
|
|
// setElementCompareValues takes a known, non-null value of a cty.Set type and
|
|
// returns a table -- constructed of two-element arrays -- that maps original
|
|
// set element values to corresponding values that have all of the computed
|
|
// values removed, making them suitable for comparison with values obtained
|
|
// from configuration. The element type of the set must conform to the implied
|
|
// type of the given schema, or this function will panic.
|
|
//
|
|
// In the resulting slice, the zeroth element of each array is the original
|
|
// value and the one-indexed element is the corresponding "compare value".
|
|
//
|
|
// This is intended to help correlate prior elements with configured elements
|
|
// in proposedNewBlock. The result is a heuristic rather than an exact science,
|
|
// since e.g. two separate elements may reduce to the same value through this
|
|
// process. The caller must therefore be ready to deal with duplicates.
|
|
func setElementCompareValues(schema *configschema.Block, set cty.Value, isConfig bool) [][2]cty.Value {
|
|
ret := make([][2]cty.Value, 0, set.LengthInt())
|
|
for it := set.ElementIterator(); it.Next(); {
|
|
_, ev := it.Element()
|
|
ret = append(ret, [2]cty.Value{ev, setElementCompareValue(schema, ev, isConfig)})
|
|
}
|
|
return ret
|
|
}
|
|
|
|
// setElementCompareValue creates a new value that has all of the same
|
|
// non-computed attribute values as the one given but has all computed
|
|
// attribute values forced to null.
|
|
//
|
|
// If isConfig is true then non-null Optional+Computed attribute values will
|
|
// be preserved. Otherwise, they will also be set to null.
|
|
//
|
|
// The input value must conform to the schema's implied type, and the return
|
|
// value is guaranteed to conform to it.
|
|
func setElementCompareValue(schema *configschema.Block, v cty.Value, isConfig bool) cty.Value {
|
|
if v.IsNull() || !v.IsKnown() {
|
|
return v
|
|
}
|
|
|
|
attrs := map[string]cty.Value{}
|
|
for name, attr := range schema.Attributes {
|
|
switch {
|
|
case attr.Computed && attr.Optional:
|
|
if isConfig {
|
|
attrs[name] = v.GetAttr(name)
|
|
} else {
|
|
attrs[name] = cty.NullVal(attr.Type)
|
|
}
|
|
case attr.Computed:
|
|
attrs[name] = cty.NullVal(attr.Type)
|
|
default:
|
|
attrs[name] = v.GetAttr(name)
|
|
}
|
|
}
|
|
|
|
for name, blockType := range schema.BlockTypes {
|
|
elementType := blockType.Block.ImpliedType()
|
|
|
|
switch blockType.Nesting {
|
|
case configschema.NestingSingle, configschema.NestingGroup:
|
|
attrs[name] = setElementCompareValue(&blockType.Block, v.GetAttr(name), isConfig)
|
|
|
|
case configschema.NestingList, configschema.NestingSet:
|
|
cv := v.GetAttr(name)
|
|
if cv.IsNull() || !cv.IsKnown() {
|
|
attrs[name] = cv
|
|
continue
|
|
}
|
|
|
|
if l := cv.LengthInt(); l > 0 {
|
|
elems := make([]cty.Value, 0, l)
|
|
for it := cv.ElementIterator(); it.Next(); {
|
|
_, ev := it.Element()
|
|
elems = append(elems, setElementCompareValue(&blockType.Block, ev, isConfig))
|
|
}
|
|
|
|
switch {
|
|
case blockType.Nesting == configschema.NestingSet:
|
|
// SetValEmpty would panic if given elements that are not
|
|
// all of the same type, but that's guaranteed not to
|
|
// happen here because our input value was _already_ a
|
|
// set and we've not changed the types of any elements here.
|
|
attrs[name] = cty.SetVal(elems)
|
|
|
|
// NestingList cases
|
|
case elementType.HasDynamicTypes():
|
|
attrs[name] = cty.TupleVal(elems)
|
|
default:
|
|
attrs[name] = cty.ListVal(elems)
|
|
}
|
|
} else {
|
|
switch {
|
|
case blockType.Nesting == configschema.NestingSet:
|
|
attrs[name] = cty.SetValEmpty(elementType)
|
|
|
|
// NestingList cases
|
|
case elementType.HasDynamicTypes():
|
|
attrs[name] = cty.EmptyTupleVal
|
|
default:
|
|
attrs[name] = cty.ListValEmpty(elementType)
|
|
}
|
|
}
|
|
|
|
case configschema.NestingMap:
|
|
cv := v.GetAttr(name)
|
|
if cv.IsNull() || !cv.IsKnown() || cv.LengthInt() == 0 {
|
|
attrs[name] = cv
|
|
continue
|
|
}
|
|
elems := make(map[string]cty.Value)
|
|
for it := cv.ElementIterator(); it.Next(); {
|
|
kv, ev := it.Element()
|
|
elems[kv.AsString()] = setElementCompareValue(&blockType.Block, ev, isConfig)
|
|
}
|
|
|
|
switch {
|
|
case elementType.HasDynamicTypes():
|
|
attrs[name] = cty.ObjectVal(elems)
|
|
default:
|
|
attrs[name] = cty.MapVal(elems)
|
|
}
|
|
|
|
default:
|
|
// Should never happen, since the above cases are comprehensive.
|
|
panic(fmt.Sprintf("unsupported block nesting mode %s", blockType.Nesting))
|
|
}
|
|
}
|
|
|
|
return cty.ObjectVal(attrs)
|
|
}
|
|
|
|
// setElementCompareValues takes a known, non-null value of a cty.Set type and
|
|
// returns a table -- constructed of two-element arrays -- that maps original
|
|
// set element values to corresponding values that have all of the computed
|
|
// values removed, making them suitable for comparison with values obtained
|
|
// from configuration. The element type of the set must conform to the implied
|
|
// type of the given schema, or this function will panic.
|
|
//
|
|
// In the resulting slice, the zeroth element of each array is the original
|
|
// value and the one-indexed element is the corresponding "compare value".
|
|
//
|
|
// This is intended to help correlate prior elements with configured elements
|
|
// in proposedNewBlock. The result is a heuristic rather than an exact science,
|
|
// since e.g. two separate elements may reduce to the same value through this
|
|
// process. The caller must therefore be ready to deal with duplicates.
|
|
func setElementCompareValuesFromObject(schema *configschema.Object, set cty.Value) [][2]cty.Value {
|
|
ret := make([][2]cty.Value, 0, set.LengthInt())
|
|
for it := set.ElementIterator(); it.Next(); {
|
|
_, ev := it.Element()
|
|
ret = append(ret, [2]cty.Value{ev, setElementCompareValueFromObject(schema, ev)})
|
|
}
|
|
return ret
|
|
}
|
|
|
|
// setElementCompareValue creates a new value that has all of the same
|
|
// non-computed attribute values as the one given but has all computed
|
|
// attribute values forced to null.
|
|
//
|
|
// The input value must conform to the schema's implied type, and the return
|
|
// value is guaranteed to conform to it.
|
|
func setElementCompareValueFromObject(schema *configschema.Object, v cty.Value) cty.Value {
|
|
if v.IsNull() || !v.IsKnown() {
|
|
return v
|
|
}
|
|
attrs := map[string]cty.Value{}
|
|
|
|
for name, attr := range schema.Attributes {
|
|
attrV := v.GetAttr(name)
|
|
switch {
|
|
case attr.Computed:
|
|
attrs[name] = cty.NullVal(attr.Type)
|
|
default:
|
|
attrs[name] = attrV
|
|
}
|
|
}
|
|
|
|
return cty.ObjectVal(attrs)
|
|
}
|