1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
package plugin
import (
"fmt"
"github.com/hashicorp/terraform/configs/configschema"
"github.com/zclconf/go-cty/cty"
)
// SetUnknowns takes a cty.Value, and compares it to the schema setting any null
// values which are computed to unknown.
func SetUnknowns(val cty.Value, schema *configschema.Block) cty.Value {
if !val.IsKnown() {
return val
}
// If the object was null, we still need to handle the top level attributes
// which might be computed, but we don't need to expand the blocks.
if val.IsNull() {
objMap := map[string]cty.Value{}
allNull := true
for name, attr := range schema.Attributes {
switch {
case attr.Computed:
objMap[name] = cty.UnknownVal(attr.Type)
allNull = false
default:
objMap[name] = cty.NullVal(attr.Type)
}
}
// If this object has no unknown attributes, then we can leave it null.
if allNull {
return val
}
return cty.ObjectVal(objMap)
}
valMap := val.AsValueMap()
newVals := make(map[string]cty.Value)
for name, attr := range schema.Attributes {
v := valMap[name]
if attr.Computed && v.IsNull() {
newVals[name] = cty.UnknownVal(attr.Type)
continue
}
newVals[name] = v
}
for name, blockS := range schema.BlockTypes {
blockVal := valMap[name]
if blockVal.IsNull() || !blockVal.IsKnown() {
newVals[name] = blockVal
continue
}
blockValType := blockVal.Type()
blockElementType := blockS.Block.ImpliedType()
// This switches on the value type here, so we can correctly switch
// between Tuples/Lists and Maps/Objects.
switch {
case blockS.Nesting == configschema.NestingSingle || blockS.Nesting == configschema.NestingGroup:
// NestingSingle is the only exception here, where we treat the
// block directly as an object
newVals[name] = SetUnknowns(blockVal, &blockS.Block)
case blockValType.IsSetType(), blockValType.IsListType(), blockValType.IsTupleType():
listVals := blockVal.AsValueSlice()
newListVals := make([]cty.Value, 0, len(listVals))
for _, v := range listVals {
newListVals = append(newListVals, SetUnknowns(v, &blockS.Block))
}
switch {
case blockValType.IsSetType():
switch len(newListVals) {
case 0:
newVals[name] = cty.SetValEmpty(blockElementType)
default:
newVals[name] = cty.SetVal(newListVals)
}
case blockValType.IsListType():
switch len(newListVals) {
case 0:
newVals[name] = cty.ListValEmpty(blockElementType)
default:
newVals[name] = cty.ListVal(newListVals)
}
case blockValType.IsTupleType():
newVals[name] = cty.TupleVal(newListVals)
}
case blockValType.IsMapType(), blockValType.IsObjectType():
mapVals := blockVal.AsValueMap()
newMapVals := make(map[string]cty.Value)
for k, v := range mapVals {
newMapVals[k] = SetUnknowns(v, &blockS.Block)
}
switch {
case blockValType.IsMapType():
switch len(newMapVals) {
case 0:
newVals[name] = cty.MapValEmpty(blockElementType)
default:
newVals[name] = cty.MapVal(newMapVals)
}
case blockValType.IsObjectType():
if len(newMapVals) == 0 {
// We need to populate empty values to make a valid object.
for attr, ty := range blockElementType.AttributeTypes() {
newMapVals[attr] = cty.NullVal(ty)
}
}
newVals[name] = cty.ObjectVal(newMapVals)
}
default:
panic(fmt.Sprintf("failed to set unknown values for nested block %q:%#v", name, blockValType))
}
}
return cty.ObjectVal(newVals)
}
|
