Skip to content

Commit a839621

Browse files
modular-magicianmodular-magician
authored
Add stateful_ips to region_per_instance_config and per_instance_config (#7316) (#5256)
* Add stateful_ips to region_per_instance_config and per_instance_config * Change network resource name to random strings * Update update tests, remove is_set for stateful_ips Signed-off-by: Modular Magician <[email protected]>
1 parent 7b604e0 commit a839621

7 files changed

+1087
-0
lines changed

‎.changelog/7316.txt‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,3 @@
1+
```release-note:enhancement
2+
compute: added `internal_ip` and `external_ip` to `google_compute_per_instance_config` and `google_compute_region_per_instance_config` (beta)
3+
```

‎google-beta/resource_compute_per_instance_config.go‎

Lines changed: 296 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -68,6 +68,78 @@ func ResourceComputePerInstanceConfig() *schema.Resource {
6868
Elem: computePerInstanceConfigPreservedStateDiskSchema(),
6969
// Default schema.HashSchema is used.
7070
},
71+
"external_ip": {
72+
Type: schema.TypeSet,
73+
Optional: true,
74+
Description: `Preserved external IPs defined for this instance. This map is keyed with the name of the network interface.`,
75+
Elem: &schema.Resource{
76+
Schema: map[string]*schema.Schema{
77+
"interface_name": {
78+
Type: schema.TypeString,
79+
Required: true,
80+
},
81+
"auto_delete": {
82+
Type: schema.TypeString,
83+
Optional: true,
84+
ValidateFunc: validateEnum([]string{"NEVER", "ON_PERMANENT_INSTANCE_DELETION", ""}),
85+
Description: `These stateful IPs will never be released during autohealing, update or VM instance recreate operations. This flag is used to configure if the IP reservation should be deleted after it is no longer used by the group, e.g. when the given instance or the whole group is deleted. Default value: "NEVER" Possible values: ["NEVER", "ON_PERMANENT_INSTANCE_DELETION"]`,
86+
Default: "NEVER",
87+
},
88+
"ip_address": {
89+
Type: schema.TypeList,
90+
Optional: true,
91+
Description: `Ip address representation`,
92+
MaxItems: 1,
93+
Elem: &schema.Resource{
94+
Schema: map[string]*schema.Schema{
95+
"address": {
96+
Type: schema.TypeString,
97+
Optional: true,
98+
DiffSuppressFunc: compareSelfLinkOrResourceName,
99+
Description: `The URL of the reservation for this IP address.`,
100+
},
101+
},
102+
},
103+
},
104+
},
105+
},
106+
},
107+
"internal_ip": {
108+
Type: schema.TypeSet,
109+
Optional: true,
110+
Description: `Preserved internal IPs defined for this instance. This map is keyed with the name of the network interface.`,
111+
Elem: &schema.Resource{
112+
Schema: map[string]*schema.Schema{
113+
"interface_name": {
114+
Type: schema.TypeString,
115+
Required: true,
116+
},
117+
"auto_delete": {
118+
Type: schema.TypeString,
119+
Optional: true,
120+
ValidateFunc: validateEnum([]string{"NEVER", "ON_PERMANENT_INSTANCE_DELETION", ""}),
121+
Description: `These stateful IPs will never be released during autohealing, update or VM instance recreate operations. This flag is used to configure if the IP reservation should be deleted after it is no longer used by the group, e.g. when the given instance or the whole group is deleted. Default value: "NEVER" Possible values: ["NEVER", "ON_PERMANENT_INSTANCE_DELETION"]`,
122+
Default: "NEVER",
123+
},
124+
"ip_address": {
125+
Type: schema.TypeList,
126+
Optional: true,
127+
Description: `Ip address representation`,
128+
MaxItems: 1,
129+
Elem: &schema.Resource{
130+
Schema: map[string]*schema.Schema{
131+
"address": {
132+
Type: schema.TypeString,
133+
Optional: true,
134+
DiffSuppressFunc: compareSelfLinkOrResourceName,
135+
Description: `The URL of the reservation for this IP address.`,
136+
},
137+
},
138+
},
139+
},
140+
},
141+
},
142+
},
71143
"metadata": {
72144
Type: schema.TypeMap,
73145
Optional: true,
@@ -558,6 +630,10 @@ func flattenNestedComputePerInstanceConfigPreservedState(v interface{}, d *schem
558630
flattenNestedComputePerInstanceConfigPreservedStateMetadata(original["metadata"], d, config)
559631
transformed["disk"] =
560632
flattenNestedComputePerInstanceConfigPreservedStateDisk(original["disks"], d, config)
633+
transformed["internal_ip"] =
634+
flattenNestedComputePerInstanceConfigPreservedStateInternalIp(original["internalIPs"], d, config)
635+
transformed["external_ip"] =
636+
flattenNestedComputePerInstanceConfigPreservedStateExternalIp(original["externalIPs"], d, config)
561637
return []interface{}{transformed}
562638
}
563639
func flattenNestedComputePerInstanceConfigPreservedStateMetadata(v interface{}, d *schema.ResourceData, config *Config) interface{} {
@@ -586,6 +662,86 @@ func flattenNestedComputePerInstanceConfigPreservedStateDisk(v interface{}, d *s
586662
return transformed
587663
}
588664

665+
func flattenNestedComputePerInstanceConfigPreservedStateInternalIp(v interface{}, d *schema.ResourceData, config *Config) interface{} {
666+
if v == nil {
667+
return v
668+
}
669+
l := v.(map[string]interface{})
670+
transformed := make([]interface{}, 0, len(l))
671+
for k, raw := range l {
672+
original := raw.(map[string]interface{})
673+
transformed = append(transformed, map[string]interface{}{
674+
"interface_name": k,
675+
"auto_delete": flattenNestedComputePerInstanceConfigPreservedStateInternalIpAutoDelete(original["autoDelete"], d, config),
676+
"ip_address": flattenNestedComputePerInstanceConfigPreservedStateInternalIpIpAddress(original["ipAddress"], d, config),
677+
})
678+
}
679+
return transformed
680+
}
681+
func flattenNestedComputePerInstanceConfigPreservedStateInternalIpAutoDelete(v interface{}, d *schema.ResourceData, config *Config) interface{} {
682+
return v
683+
}
684+
685+
func flattenNestedComputePerInstanceConfigPreservedStateInternalIpIpAddress(v interface{}, d *schema.ResourceData, config *Config) interface{} {
686+
if v == nil {
687+
return nil
688+
}
689+
original := v.(map[string]interface{})
690+
if len(original) == 0 {
691+
return nil
692+
}
693+
transformed := make(map[string]interface{})
694+
transformed["address"] =
695+
flattenNestedComputePerInstanceConfigPreservedStateInternalIpIpAddressAddress(original["address"], d, config)
696+
return []interface{}{transformed}
697+
}
698+
func flattenNestedComputePerInstanceConfigPreservedStateInternalIpIpAddressAddress(v interface{}, d *schema.ResourceData, config *Config) interface{} {
699+
if v == nil {
700+
return v
701+
}
702+
return ConvertSelfLinkToV1(v.(string))
703+
}
704+
705+
func flattenNestedComputePerInstanceConfigPreservedStateExternalIp(v interface{}, d *schema.ResourceData, config *Config) interface{} {
706+
if v == nil {
707+
return v
708+
}
709+
l := v.(map[string]interface{})
710+
transformed := make([]interface{}, 0, len(l))
711+
for k, raw := range l {
712+
original := raw.(map[string]interface{})
713+
transformed = append(transformed, map[string]interface{}{
714+
"interface_name": k,
715+
"auto_delete": flattenNestedComputePerInstanceConfigPreservedStateExternalIpAutoDelete(original["autoDelete"], d, config),
716+
"ip_address": flattenNestedComputePerInstanceConfigPreservedStateExternalIpIpAddress(original["ipAddress"], d, config),
717+
})
718+
}
719+
return transformed
720+
}
721+
func flattenNestedComputePerInstanceConfigPreservedStateExternalIpAutoDelete(v interface{}, d *schema.ResourceData, config *Config) interface{} {
722+
return v
723+
}
724+
725+
func flattenNestedComputePerInstanceConfigPreservedStateExternalIpIpAddress(v interface{}, d *schema.ResourceData, config *Config) interface{} {
726+
if v == nil {
727+
return nil
728+
}
729+
original := v.(map[string]interface{})
730+
if len(original) == 0 {
731+
return nil
732+
}
733+
transformed := make(map[string]interface{})
734+
transformed["address"] =
735+
flattenNestedComputePerInstanceConfigPreservedStateExternalIpIpAddressAddress(original["address"], d, config)
736+
return []interface{}{transformed}
737+
}
738+
func flattenNestedComputePerInstanceConfigPreservedStateExternalIpIpAddressAddress(v interface{}, d *schema.ResourceData, config *Config) interface{} {
739+
if v == nil {
740+
return v
741+
}
742+
return ConvertSelfLinkToV1(v.(string))
743+
}
744+
589745
func expandNestedComputePerInstanceConfigName(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
590746
return v, nil
591747
}
@@ -613,6 +769,20 @@ func expandNestedComputePerInstanceConfigPreservedState(v interface{}, d Terrafo
613769
transformed["disks"] = transformedDisk
614770
}
615771

772+
transformedInternalIp, err := expandNestedComputePerInstanceConfigPreservedStateInternalIp(original["internal_ip"], d, config)
773+
if err != nil {
774+
return nil, err
775+
} else if val := reflect.ValueOf(transformedInternalIp); val.IsValid() && !isEmptyValue(val) {
776+
transformed["internalIPs"] = transformedInternalIp
777+
}
778+
779+
transformedExternalIp, err := expandNestedComputePerInstanceConfigPreservedStateExternalIp(original["external_ip"], d, config)
780+
if err != nil {
781+
return nil, err
782+
} else if val := reflect.ValueOf(transformedExternalIp); val.IsValid() && !isEmptyValue(val) {
783+
transformed["externalIPs"] = transformedExternalIp
784+
}
785+
616786
return transformed, nil
617787
}
618788

@@ -657,6 +827,132 @@ func expandNestedComputePerInstanceConfigPreservedStateDisk(v interface{}, d Ter
657827
return req, nil
658828
}
659829

830+
func expandNestedComputePerInstanceConfigPreservedStateInternalIp(v interface{}, d TerraformResourceData, config *Config) (map[string]interface{}, error) {
831+
if v == nil {
832+
return map[string]interface{}{}, nil
833+
}
834+
m := make(map[string]interface{})
835+
for _, raw := range v.(*schema.Set).List() {
836+
original := raw.(map[string]interface{})
837+
transformed := make(map[string]interface{})
838+
839+
transformedAutoDelete, err := expandNestedComputePerInstanceConfigPreservedStateInternalIpAutoDelete(original["auto_delete"], d, config)
840+
if err != nil {
841+
return nil, err
842+
} else if val := reflect.ValueOf(transformedAutoDelete); val.IsValid() && !isEmptyValue(val) {
843+
transformed["autoDelete"] = transformedAutoDelete
844+
}
845+
846+
transformedIpAddress, err := expandNestedComputePerInstanceConfigPreservedStateInternalIpIpAddress(original["ip_address"], d, config)
847+
if err != nil {
848+
return nil, err
849+
} else if val := reflect.ValueOf(transformedIpAddress); val.IsValid() && !isEmptyValue(val) {
850+
transformed["ipAddress"] = transformedIpAddress
851+
}
852+
853+
transformedInterfaceName, err := expandString(original["interface_name"], d, config)
854+
if err != nil {
855+
return nil, err
856+
}
857+
m[transformedInterfaceName] = transformed
858+
}
859+
return m, nil
860+
}
861+
862+
func expandNestedComputePerInstanceConfigPreservedStateInternalIpAutoDelete(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
863+
return v, nil
864+
}
865+
866+
func expandNestedComputePerInstanceConfigPreservedStateInternalIpIpAddress(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
867+
l := v.([]interface{})
868+
if len(l) == 0 || l[0] == nil {
869+
return nil, nil
870+
}
871+
raw := l[0]
872+
original := raw.(map[string]interface{})
873+
transformed := make(map[string]interface{})
874+
875+
transformedAddress, err := expandNestedComputePerInstanceConfigPreservedStateInternalIpIpAddressAddress(original["address"], d, config)
876+
if err != nil {
877+
return nil, err
878+
} else if val := reflect.ValueOf(transformedAddress); val.IsValid() && !isEmptyValue(val) {
879+
transformed["address"] = transformedAddress
880+
}
881+
882+
return transformed, nil
883+
}
884+
885+
func expandNestedComputePerInstanceConfigPreservedStateInternalIpIpAddressAddress(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
886+
f, err := parseRegionalFieldValue("addresses", v.(string), "project", "region", "zone", d, config, true)
887+
if err != nil {
888+
return nil, fmt.Errorf("Invalid value for address: %s", err)
889+
}
890+
return f.RelativeLink(), nil
891+
}
892+
893+
func expandNestedComputePerInstanceConfigPreservedStateExternalIp(v interface{}, d TerraformResourceData, config *Config) (map[string]interface{}, error) {
894+
if v == nil {
895+
return map[string]interface{}{}, nil
896+
}
897+
m := make(map[string]interface{})
898+
for _, raw := range v.(*schema.Set).List() {
899+
original := raw.(map[string]interface{})
900+
transformed := make(map[string]interface{})
901+
902+
transformedAutoDelete, err := expandNestedComputePerInstanceConfigPreservedStateExternalIpAutoDelete(original["auto_delete"], d, config)
903+
if err != nil {
904+
return nil, err
905+
} else if val := reflect.ValueOf(transformedAutoDelete); val.IsValid() && !isEmptyValue(val) {
906+
transformed["autoDelete"] = transformedAutoDelete
907+
}
908+
909+
transformedIpAddress, err := expandNestedComputePerInstanceConfigPreservedStateExternalIpIpAddress(original["ip_address"], d, config)
910+
if err != nil {
911+
return nil, err
912+
} else if val := reflect.ValueOf(transformedIpAddress); val.IsValid() && !isEmptyValue(val) {
913+
transformed["ipAddress"] = transformedIpAddress
914+
}
915+
916+
transformedInterfaceName, err := expandString(original["interface_name"], d, config)
917+
if err != nil {
918+
return nil, err
919+
}
920+
m[transformedInterfaceName] = transformed
921+
}
922+
return m, nil
923+
}
924+
925+
func expandNestedComputePerInstanceConfigPreservedStateExternalIpAutoDelete(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
926+
return v, nil
927+
}
928+
929+
func expandNestedComputePerInstanceConfigPreservedStateExternalIpIpAddress(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
930+
l := v.([]interface{})
931+
if len(l) == 0 || l[0] == nil {
932+
return nil, nil
933+
}
934+
raw := l[0]
935+
original := raw.(map[string]interface{})
936+
transformed := make(map[string]interface{})
937+
938+
transformedAddress, err := expandNestedComputePerInstanceConfigPreservedStateExternalIpIpAddressAddress(original["address"], d, config)
939+
if err != nil {
940+
return nil, err
941+
} else if val := reflect.ValueOf(transformedAddress); val.IsValid() && !isEmptyValue(val) {
942+
transformed["address"] = transformedAddress
943+
}
944+
945+
return transformed, nil
946+
}
947+
948+
func expandNestedComputePerInstanceConfigPreservedStateExternalIpIpAddressAddress(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
949+
f, err := parseRegionalFieldValue("addresses", v.(string), "project", "region", "zone", d, config, true)
950+
if err != nil {
951+
return nil, fmt.Errorf("Invalid value for address: %s", err)
952+
}
953+
return f.RelativeLink(), nil
954+
}
955+
660956
func resourceComputePerInstanceConfigEncoder(d *schema.ResourceData, meta interface{}, obj map[string]interface{}) (map[string]interface{}, error) {
661957
wrappedReq := map[string]interface{}{
662958
"instances": []interface{}{obj},

0 commit comments

Comments
 (0)