package objchange import ( "fmt" "github.com/zclconf/go-cty/cty" "github.com/hashicorp/terraform/configs/configschema" ) // ProposedNewObject 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 ProposedNewObject(schema *configschema.Block, prior, config cty.Value) cty.Value { 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 = AllAttributesNull(schema) } return proposedNewObject(schema, prior, config) } // PlannedDataResourceObject is similar to ProposedNewObject 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 ProposedNewObject 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 ProposedNewObject 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 proposedNewObject(schema, prior, config) } func proposedNewObject(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("ProposedNewObject 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 := map[string]cty.Value{} for name, attr := range schema.Attributes { 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: // 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 } // 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) var newV cty.Value switch blockType.Nesting { case configschema.NestingSingle: newV = ProposedNewObject(&blockType.Block, priorV, configV) case configschema.NestingList: // Nested blocks are correlated by index. configVLen := 0 if configV.IsKnown() && !configV.IsNull() { configVLen = configV.LengthInt() } if configVLen > 0 { newVals := make([]cty.Value, 0, configVLen) for it := configV.ElementIterator(); it.Next(); { idx, configEV := it.Element() if priorV.IsKnown() && (priorV.IsNull() || !priorV.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 := priorV.Index(idx) newEV := ProposedNewObject(&blockType.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 configV.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 configV.Type().IsTupleType() { newV = cty.EmptyTupleVal } else { newV = cty.ListValEmpty(blockType.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 configV.Type().IsObjectType() { // Nested blocks are correlated by key. configVLen := 0 if configV.IsKnown() && !configV.IsNull() { configVLen = configV.LengthInt() } if configVLen > 0 { newVals := make(map[string]cty.Value, configVLen) atys := configV.Type().AttributeTypes() for name := range atys { configEV := configV.GetAttr(name) if !priorV.Type().HasAttribute(name) { // If there is no corresponding prior element then // we just take the config value as-is. newVals[name] = configEV continue } priorEV := priorV.GetAttr(name) newEV := ProposedNewObject(&blockType.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 configV.IsKnown() && !configV.IsNull() { configVLen = configV.LengthInt() } if configVLen > 0 { newVals := make(map[string]cty.Value, configVLen) for it := configV.ElementIterator(); it.Next(); { idx, configEV := it.Element() k := idx.AsString() if priorV.IsKnown() && (priorV.IsNull() || !priorV.HasIndex(idx).True()) { // If there is no corresponding prior element then // we just take the config value as-is. newVals[k] = configEV continue } priorEV := priorV.Index(idx) newEV := ProposedNewObject(&blockType.Block, priorEV, configEV) newVals[k] = newEV } newV = cty.MapVal(newVals) } else { newV = cty.MapValEmpty(blockType.ImpliedType()) } } case configschema.NestingSet: if !configV.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 priorV.IsKnown() && !priorV.IsNull() { cmpVals = setElementCompareValues(&blockType.Block, priorV, false) } configVLen := 0 if configV.IsKnown() && !configV.IsNull() { configVLen = configV.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 := configV.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(blockType.ImpliedType()) } newEV := ProposedNewObject(&blockType.Block, priorEV, configEV) newVals = append(newVals, newEV) } newV = cty.SetVal(newVals) } else { newV = cty.SetValEmpty(blockType.Block.ImpliedType()) } default: // Should never happen, since the above cases are comprehensive. panic(fmt.Sprintf("unsupported block nesting mode %s", blockType.Nesting)) } newAttrs[name] = newV } return cty.ObjectVal(newAttrs) } // 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 ProposedNewObject. 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 { switch blockType.Nesting { case configschema.NestingSingle: 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)) } if 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) } else { attrs[name] = cty.TupleVal(elems) } } else { if blockType.Nesting == configschema.NestingSet { attrs[name] = cty.SetValEmpty(blockType.Block.ImpliedType()) } else { attrs[name] = cty.EmptyTupleVal } } case configschema.NestingMap: cv := v.GetAttr(name) if cv.IsNull() || !cv.IsKnown() { 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) } attrs[name] = cty.ObjectVal(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) }