Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Add stateful_ips to region_per_instance_config and per_instance_config #5256

Merged
merged 1 commit into from
Feb 27, 2023
Merged

Add stateful_ips to region_per_instance_config and per_instance_config #5256

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
3 changes: 3 additions & 0 deletions .changelog/7316.txt
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,3 @@
```release-note:enhancement
compute: added `internal_ip` and `external_ip` to `google_compute_per_instance_config` and `google_compute_region_per_instance_config` (beta)
```
296 changes: 296 additions & 0 deletions google-beta/resource_compute_per_instance_config.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -68,6 +68,78 @@ func ResourceComputePerInstanceConfig() *schema.Resource {
Elem: computePerInstanceConfigPreservedStateDiskSchema(),
// Default schema.HashSchema is used.
},
"external_ip": {
Type: schema.TypeSet,
Optional: true,
Description: `Preserved external IPs defined for this instance. This map is keyed with the name of the network interface.`,
Elem: &schema.Resource{
Schema: map[string]*schema.Schema{
"interface_name": {
Type: schema.TypeString,
Required: true,
},
"auto_delete": {
Type: schema.TypeString,
Optional: true,
ValidateFunc: validateEnum([]string{"NEVER", "ON_PERMANENT_INSTANCE_DELETION", ""}),
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"]`,
Default: "NEVER",
},
"ip_address": {
Type: schema.TypeList,
Optional: true,
Description: `Ip address representation`,
MaxItems: 1,
Elem: &schema.Resource{
Schema: map[string]*schema.Schema{
"address": {
Type: schema.TypeString,
Optional: true,
DiffSuppressFunc: compareSelfLinkOrResourceName,
Description: `The URL of the reservation for this IP address.`,
},
},
},
},
},
},
},
"internal_ip": {
Type: schema.TypeSet,
Optional: true,
Description: `Preserved internal IPs defined for this instance. This map is keyed with the name of the network interface.`,
Elem: &schema.Resource{
Schema: map[string]*schema.Schema{
"interface_name": {
Type: schema.TypeString,
Required: true,
},
"auto_delete": {
Type: schema.TypeString,
Optional: true,
ValidateFunc: validateEnum([]string{"NEVER", "ON_PERMANENT_INSTANCE_DELETION", ""}),
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"]`,
Default: "NEVER",
},
"ip_address": {
Type: schema.TypeList,
Optional: true,
Description: `Ip address representation`,
MaxItems: 1,
Elem: &schema.Resource{
Schema: map[string]*schema.Schema{
"address": {
Type: schema.TypeString,
Optional: true,
DiffSuppressFunc: compareSelfLinkOrResourceName,
Description: `The URL of the reservation for this IP address.`,
},
},
},
},
},
},
},
"metadata": {
Type: schema.TypeMap,
Optional: true,
Expand Down Expand Up @@ -558,6 +630,10 @@ func flattenNestedComputePerInstanceConfigPreservedState(v interface{}, d *schem
flattenNestedComputePerInstanceConfigPreservedStateMetadata(original["metadata"], d, config)
transformed["disk"] =
flattenNestedComputePerInstanceConfigPreservedStateDisk(original["disks"], d, config)
transformed["internal_ip"] =
flattenNestedComputePerInstanceConfigPreservedStateInternalIp(original["internalIPs"], d, config)
transformed["external_ip"] =
flattenNestedComputePerInstanceConfigPreservedStateExternalIp(original["externalIPs"], d, config)
return []interface{}{transformed}
}
func flattenNestedComputePerInstanceConfigPreservedStateMetadata(v interface{}, d *schema.ResourceData, config *Config) interface{} {
Expand Down Expand Up @@ -586,6 +662,86 @@ func flattenNestedComputePerInstanceConfigPreservedStateDisk(v interface{}, d *s
return transformed
}

func flattenNestedComputePerInstanceConfigPreservedStateInternalIp(v interface{}, d *schema.ResourceData, config *Config) interface{} {
if v == nil {
return v
}
l := v.(map[string]interface{})
transformed := make([]interface{}, 0, len(l))
for k, raw := range l {
original := raw.(map[string]interface{})
transformed = append(transformed, map[string]interface{}{
"interface_name": k,
"auto_delete": flattenNestedComputePerInstanceConfigPreservedStateInternalIpAutoDelete(original["autoDelete"], d, config),
"ip_address": flattenNestedComputePerInstanceConfigPreservedStateInternalIpIpAddress(original["ipAddress"], d, config),
})
}
return transformed
}
func flattenNestedComputePerInstanceConfigPreservedStateInternalIpAutoDelete(v interface{}, d *schema.ResourceData, config *Config) interface{} {
return v
}

func flattenNestedComputePerInstanceConfigPreservedStateInternalIpIpAddress(v interface{}, d *schema.ResourceData, config *Config) interface{} {
if v == nil {
return nil
}
original := v.(map[string]interface{})
if len(original) == 0 {
return nil
}
transformed := make(map[string]interface{})
transformed["address"] =
flattenNestedComputePerInstanceConfigPreservedStateInternalIpIpAddressAddress(original["address"], d, config)
return []interface{}{transformed}
}
func flattenNestedComputePerInstanceConfigPreservedStateInternalIpIpAddressAddress(v interface{}, d *schema.ResourceData, config *Config) interface{} {
if v == nil {
return v
}
return ConvertSelfLinkToV1(v.(string))
}

func flattenNestedComputePerInstanceConfigPreservedStateExternalIp(v interface{}, d *schema.ResourceData, config *Config) interface{} {
if v == nil {
return v
}
l := v.(map[string]interface{})
transformed := make([]interface{}, 0, len(l))
for k, raw := range l {
original := raw.(map[string]interface{})
transformed = append(transformed, map[string]interface{}{
"interface_name": k,
"auto_delete": flattenNestedComputePerInstanceConfigPreservedStateExternalIpAutoDelete(original["autoDelete"], d, config),
"ip_address": flattenNestedComputePerInstanceConfigPreservedStateExternalIpIpAddress(original["ipAddress"], d, config),
})
}
return transformed
}
func flattenNestedComputePerInstanceConfigPreservedStateExternalIpAutoDelete(v interface{}, d *schema.ResourceData, config *Config) interface{} {
return v
}

func flattenNestedComputePerInstanceConfigPreservedStateExternalIpIpAddress(v interface{}, d *schema.ResourceData, config *Config) interface{} {
if v == nil {
return nil
}
original := v.(map[string]interface{})
if len(original) == 0 {
return nil
}
transformed := make(map[string]interface{})
transformed["address"] =
flattenNestedComputePerInstanceConfigPreservedStateExternalIpIpAddressAddress(original["address"], d, config)
return []interface{}{transformed}
}
func flattenNestedComputePerInstanceConfigPreservedStateExternalIpIpAddressAddress(v interface{}, d *schema.ResourceData, config *Config) interface{} {
if v == nil {
return v
}
return ConvertSelfLinkToV1(v.(string))
}

func expandNestedComputePerInstanceConfigName(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
return v, nil
}
Expand Down Expand Up @@ -613,6 +769,20 @@ func expandNestedComputePerInstanceConfigPreservedState(v interface{}, d Terrafo
transformed["disks"] = transformedDisk
}

transformedInternalIp, err := expandNestedComputePerInstanceConfigPreservedStateInternalIp(original["internal_ip"], d, config)
if err != nil {
return nil, err
} else if val := reflect.ValueOf(transformedInternalIp); val.IsValid() && !isEmptyValue(val) {
transformed["internalIPs"] = transformedInternalIp
}

transformedExternalIp, err := expandNestedComputePerInstanceConfigPreservedStateExternalIp(original["external_ip"], d, config)
if err != nil {
return nil, err
} else if val := reflect.ValueOf(transformedExternalIp); val.IsValid() && !isEmptyValue(val) {
transformed["externalIPs"] = transformedExternalIp
}

return transformed, nil
}

Expand Down Expand Up @@ -657,6 +827,132 @@ func expandNestedComputePerInstanceConfigPreservedStateDisk(v interface{}, d Ter
return req, nil
}

func expandNestedComputePerInstanceConfigPreservedStateInternalIp(v interface{}, d TerraformResourceData, config *Config) (map[string]interface{}, error) {
if v == nil {
return map[string]interface{}{}, nil
}
m := make(map[string]interface{})
for _, raw := range v.(*schema.Set).List() {
original := raw.(map[string]interface{})
transformed := make(map[string]interface{})

transformedAutoDelete, err := expandNestedComputePerInstanceConfigPreservedStateInternalIpAutoDelete(original["auto_delete"], d, config)
if err != nil {
return nil, err
} else if val := reflect.ValueOf(transformedAutoDelete); val.IsValid() && !isEmptyValue(val) {
transformed["autoDelete"] = transformedAutoDelete
}

transformedIpAddress, err := expandNestedComputePerInstanceConfigPreservedStateInternalIpIpAddress(original["ip_address"], d, config)
if err != nil {
return nil, err
} else if val := reflect.ValueOf(transformedIpAddress); val.IsValid() && !isEmptyValue(val) {
transformed["ipAddress"] = transformedIpAddress
}

transformedInterfaceName, err := expandString(original["interface_name"], d, config)
if err != nil {
return nil, err
}
m[transformedInterfaceName] = transformed
}
return m, nil
}

func expandNestedComputePerInstanceConfigPreservedStateInternalIpAutoDelete(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
return v, nil
}

func expandNestedComputePerInstanceConfigPreservedStateInternalIpIpAddress(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
l := v.([]interface{})
if len(l) == 0 || l[0] == nil {
return nil, nil
}
raw := l[0]
original := raw.(map[string]interface{})
transformed := make(map[string]interface{})

transformedAddress, err := expandNestedComputePerInstanceConfigPreservedStateInternalIpIpAddressAddress(original["address"], d, config)
if err != nil {
return nil, err
} else if val := reflect.ValueOf(transformedAddress); val.IsValid() && !isEmptyValue(val) {
transformed["address"] = transformedAddress
}

return transformed, nil
}

func expandNestedComputePerInstanceConfigPreservedStateInternalIpIpAddressAddress(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
f, err := parseRegionalFieldValue("addresses", v.(string), "project", "region", "zone", d, config, true)
if err != nil {
return nil, fmt.Errorf("Invalid value for address: %s", err)
}
return f.RelativeLink(), nil
}

func expandNestedComputePerInstanceConfigPreservedStateExternalIp(v interface{}, d TerraformResourceData, config *Config) (map[string]interface{}, error) {
if v == nil {
return map[string]interface{}{}, nil
}
m := make(map[string]interface{})
for _, raw := range v.(*schema.Set).List() {
original := raw.(map[string]interface{})
transformed := make(map[string]interface{})

transformedAutoDelete, err := expandNestedComputePerInstanceConfigPreservedStateExternalIpAutoDelete(original["auto_delete"], d, config)
if err != nil {
return nil, err
} else if val := reflect.ValueOf(transformedAutoDelete); val.IsValid() && !isEmptyValue(val) {
transformed["autoDelete"] = transformedAutoDelete
}

transformedIpAddress, err := expandNestedComputePerInstanceConfigPreservedStateExternalIpIpAddress(original["ip_address"], d, config)
if err != nil {
return nil, err
} else if val := reflect.ValueOf(transformedIpAddress); val.IsValid() && !isEmptyValue(val) {
transformed["ipAddress"] = transformedIpAddress
}

transformedInterfaceName, err := expandString(original["interface_name"], d, config)
if err != nil {
return nil, err
}
m[transformedInterfaceName] = transformed
}
return m, nil
}

func expandNestedComputePerInstanceConfigPreservedStateExternalIpAutoDelete(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
return v, nil
}

func expandNestedComputePerInstanceConfigPreservedStateExternalIpIpAddress(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
l := v.([]interface{})
if len(l) == 0 || l[0] == nil {
return nil, nil
}
raw := l[0]
original := raw.(map[string]interface{})
transformed := make(map[string]interface{})

transformedAddress, err := expandNestedComputePerInstanceConfigPreservedStateExternalIpIpAddressAddress(original["address"], d, config)
if err != nil {
return nil, err
} else if val := reflect.ValueOf(transformedAddress); val.IsValid() && !isEmptyValue(val) {
transformed["address"] = transformedAddress
}

return transformed, nil
}

func expandNestedComputePerInstanceConfigPreservedStateExternalIpIpAddressAddress(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
f, err := parseRegionalFieldValue("addresses", v.(string), "project", "region", "zone", d, config, true)
if err != nil {
return nil, fmt.Errorf("Invalid value for address: %s", err)
}
return f.RelativeLink(), nil
}

func resourceComputePerInstanceConfigEncoder(d *schema.ResourceData, meta interface{}, obj map[string]interface{}) (map[string]interface{}, error) {
wrappedReq := map[string]interface{}{
"instances": []interface{}{obj},
Expand Down
Loading