/
structure_core.go
153 lines (131 loc) · 4.7 KB
/
structure_core.go
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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
package stackpath
import (
"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
"github.com/stackpath/terraform-provider-stackpath/v2/stackpath/api/ipam/ipam_models"
"github.com/stackpath/terraform-provider-stackpath/v2/stackpath/api/workload/workload_models"
)
func convertComputeMatchExpression(data []interface{}) []*workload_models.V1MatchExpression {
selectors := make([]*workload_models.V1MatchExpression, len(data))
for i, s := range data {
selector := s.(map[string]interface{})
vals := make([]string, len(selector["values"].([]interface{})))
for j, v := range selector["values"].([]interface{}) {
vals[j] = v.(string)
}
selectors[i] = &workload_models.V1MatchExpression{
Key: selector["key"].(string),
Operator: selector["operator"].(string),
Values: vals,
}
}
return selectors
}
func convertToStringMap(data map[string]interface{}) workload_models.V1StringMapEntry {
stringMap := make(workload_models.V1StringMapEntry, len(data))
for k, v := range data {
stringMap[k] = v.(string)
}
return stringMap
}
func convertToStringArray(data []interface{}) []string {
s := make([]string, len(data))
for i, c := range data {
s[i] = c.(string)
}
return s
}
func convertSetToStringArray(data *schema.Set) []string {
return convertToStringArray(data.List())
}
func convertWorkloadToIPAMMatchExpression(selectors []*workload_models.V1MatchExpression) []*ipam_models.NetworkMatchExpression {
converted := make([]*ipam_models.NetworkMatchExpression, len(selectors))
for i, selector := range selectors {
converted[i] = &ipam_models.NetworkMatchExpression{
Key: selector.Key,
Operator: selector.Operator,
Values: selector.Values,
}
}
return converted
}
func convertIPAMToWorkloadMatchExpression(selectors []*ipam_models.NetworkMatchExpression) []*workload_models.V1MatchExpression {
converted := make([]*workload_models.V1MatchExpression, len(selectors))
for i, selector := range selectors {
converted[i] = &workload_models.V1MatchExpression{
Key: selector.Key,
Operator: selector.Operator,
Values: selector.Values,
}
}
return converted
}
func convertWorkloadToIPAMStringMapEntry(mapEntries workload_models.V1StringMapEntry) ipam_models.NetworkStringMapEntry {
converted := make(ipam_models.NetworkStringMapEntry, len(mapEntries))
for k, v := range mapEntries {
converted[k] = v
}
return converted
}
func convertIPAMToWorkloadStringMapEntry(mapEntries ipam_models.NetworkStringMapEntry) workload_models.V1StringMapEntry {
converted := make(workload_models.V1StringMapEntry, len(mapEntries))
for k, v := range mapEntries {
converted[k] = v
}
return converted
}
// flattenComputeMatchExpressionsOrdered flattens the provided workload match expressions
// with respect to the order of any existing match expressions defined in the provided
// ResourceData. The prefix should be the flattened key of the list of match expressions
// in the ResourceData.
func flattenComputeMatchExpressionsOrdered(prefix string, data *schema.ResourceData, selectors []*workload_models.V1MatchExpression) []interface{} {
ordered := make(map[string]int, len(selectors))
for i, selector := range selectors {
ordered[selector.Key] = i
}
flattened := make([]interface{}, len(selectors))
for _, selector := range selectors {
data := map[string]interface{}{
"key": selector.Key,
"operator": selector.Operator,
"values": flattenStringArray(selector.Values),
}
flattened[ordered[selector.Key]] = data
}
return flattened
}
// flattenComputeMatchExpressions flattens the provided workload match expressions
// as given with no respect to ordering. If the order of the resulting match expressions
// is important, eg when using for diff logic, then flattenComputeMatchExpressionsOrdered
// should be used.
func flattenComputeMatchExpressions(selectors []*workload_models.V1MatchExpression) []interface{} {
flattened := make([]interface{}, len(selectors))
for i, selector := range selectors {
flattened[i] = map[string]interface{}{
"key": selector.Key,
"operator": selector.Operator,
"values": flattenStringArray(selector.Values),
}
}
return flattened
}
func flattenIPFamilies(ipFamilies []*workload_models.V1IPFamily) []interface{} {
ipFamiliesStrList := make([]string, len(ipFamilies))
for i, ipFamily := range ipFamilies {
ipFamiliesStrList[i] = string(*ipFamily)
}
return flattenStringArray(ipFamiliesStrList)
}
func flattenStringMap(stringMap workload_models.V1StringMapEntry) map[string]interface{} {
m := make(map[string]interface{}, len(stringMap))
for k, v := range stringMap {
m[k] = v
}
return m
}
func flattenStringArray(arr []string) []interface{} {
a := make([]interface{}, len(arr))
for i, s := range arr {
a[i] = s
}
return a
}