Adding IP Collection To Forwarding Rule (#12914) (#21188)

[upstream:7a23ebbfcffa06209ce0cb85cbd3988edaa24063]

Signed-off-by: Modular Magician <[email protected]>

Author: modular-magician

.changelog/12914.txt

@@ -0,0 +1,3 @@
+```release-note:enhancement
+compute: added `ip_collection` field to `google_compute_forwarding_rule ` resource
+```

google/acctest/test_utils.go

@@ -136,6 +136,21 @@ func RandInt(t *testing.T) int {
 	return rand.New(s.source).Int()
 }
 
+func RandIntRange(t *testing.T, minInt int, maxInt int) int {
+	if !IsVcrEnabled() {
+		return acctest.RandIntRange(minInt, maxInt)
+	}
+	envPath := os.Getenv("VCR_PATH")
+	vcrMode := os.Getenv("VCR_MODE")
+	s, err := vcrSource(t, envPath, vcrMode)
+	if err != nil {
+		// At this point we haven't created any resources, so fail fast
+		t.Fatal(err)
+	}
+
+	return rand.New(s.source).Intn(maxInt-minInt) + minInt
+}
+
 // ProtoV5ProviderFactories returns a muxed ProviderServer that uses the provider code from this repo (SDK and plugin-framework).
 // Used to set ProtoV5ProviderFactories in a resource.TestStep within an acceptance test.
 func ProtoV5ProviderFactories(t *testing.T) map[string]func() (tfprotov5.ProviderServer, error) {

google/services/compute/resource_compute_forwarding_rule.go

@@ -59,6 +59,24 @@ func PortRangeDiffSuppress(k, old, new string, d *schema.ResourceData) bool {
 	return old == new+"-"+new
 }
 
+// Compare only the relative path from 'regions' of two IP collection links
+func IpCollectionDiffSuppress(_, old, new string, d *schema.ResourceData) bool {
+	oldStripped, err := GetRelativePathFromRegions(old)
+	if err != nil {
+		return false
+	}
+
+	newStripped, err := GetRelativePathFromRegions(new)
+	if err != nil {
+		return false
+	}
+
+	if oldStripped == newStripped {
+		return true
+	}
+	return false
+}
+
 // Suppresses diff for IPv4 and IPv6 different formats.
 // It also suppresses diffs if an IP is changing to a reference.
 func InternalIpDiffSuppress(_, old, new string, _ *schema.ResourceData) bool {
@@ -103,6 +121,15 @@ func InternalIpDiffSuppress(_, old, new string, _ *schema.ResourceData) bool {
 	return addr_equality && netmask_equality
 }
 
+func GetRelativePathFromRegions(resourceLink string) (string, error) {
+	stringParts := strings.SplitAfterN(resourceLink, "regions/", 2)
+	if len(stringParts) != 2 {
+		return "", fmt.Errorf("String is not a valid link: %s", resourceLink)
+	}
+
+	return "regions/" + stringParts[1], nil
+}
+
 func ResourceComputeForwardingRule() *schema.Resource {
 	return &schema.Resource{
 		Create: resourceComputeForwardingRuleCreate,
@@ -266,6 +293,21 @@ must be omitted for all other load balancer types.`,
 				ForceNew: true,
 				Description: `An optional description of this resource. Provide this property when
 you create the resource.`,
+			},
+			"ip_collection": {
+				Type:             schema.TypeString,
+				Optional:         true,
+				ForceNew:         true,
+				DiffSuppressFunc: IpCollectionDiffSuppress,
+				Description: `Resource reference of a PublicDelegatedPrefix. The PDP must be a sub-PDP
+in EXTERNAL_IPV6_FORWARDING_RULE_CREATION mode.
+Use one of the following formats to specify a sub-PDP when creating an
+IPv6 NetLB forwarding rule using BYOIP:
+Full resource URL, as in:
+  * 'https://www.googleapis.com/compute/v1/projects/{{projectId}}/regions/{{region}}/publicDelegatedPrefixes/{{sub-pdp-name}}'
+Partial URL, as in:
+  * 'projects/{{projectId}}/regions/region/publicDelegatedPrefixes/{{sub-pdp-name}}'
+  * 'regions/{{region}}/publicDelegatedPrefixes/{{sub-pdp-name}}'`,
 			},
 			"ip_version": {
 				Type:         schema.TypeString,
@@ -723,6 +765,12 @@ func resourceComputeForwardingRuleCreate(d *schema.ResourceData, meta interface{
 	} else if v, ok := d.GetOkExists("ip_version"); !tpgresource.IsEmptyValue(reflect.ValueOf(ipVersionProp)) && (ok || !reflect.DeepEqual(v, ipVersionProp)) {
 		obj["ipVersion"] = ipVersionProp
 	}
+	ipCollectionProp, err := expandComputeForwardingRuleIpCollection(d.Get("ip_collection"), d, config)
+	if err != nil {
+		return err
+	} else if v, ok := d.GetOkExists("ip_collection"); !tpgresource.IsEmptyValue(reflect.ValueOf(ipCollectionProp)) && (ok || !reflect.DeepEqual(v, ipCollectionProp)) {
+		obj["ipCollection"] = ipCollectionProp
+	}
 	labelsProp, err := expandComputeForwardingRuleEffectiveLabels(d.Get("effective_labels"), d, config)
 	if err != nil {
 		return err
@@ -990,6 +1038,9 @@ func resourceComputeForwardingRuleRead(d *schema.ResourceData, meta interface{})
 	if err := d.Set("ip_version", flattenComputeForwardingRuleIpVersion(res["ipVersion"], d, config)); err != nil {
 		return fmt.Errorf("Error reading ForwardingRule: %s", err)
 	}
+	if err := d.Set("ip_collection", flattenComputeForwardingRuleIpCollection(res["ipCollection"], d, config)); err != nil {
+		return fmt.Errorf("Error reading ForwardingRule: %s", err)
+	}
 	if err := d.Set("terraform_labels", flattenComputeForwardingRuleTerraformLabels(res["labels"], d, config)); err != nil {
 		return fmt.Errorf("Error reading ForwardingRule: %s", err)
 	}
@@ -1491,6 +1542,10 @@ func flattenComputeForwardingRuleIpVersion(v interface{}, d *schema.ResourceData
 	return v
 }
 
+func flattenComputeForwardingRuleIpCollection(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
+	return v
+}
+
 func flattenComputeForwardingRuleTerraformLabels(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
 	if v == nil {
 		return v
@@ -1704,6 +1759,10 @@ func expandComputeForwardingRuleIpVersion(v interface{}, d tpgresource.Terraform
 	return v, nil
 }
 
+func expandComputeForwardingRuleIpCollection(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
+	return v, nil
+}
+
 func expandComputeForwardingRuleEffectiveLabels(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (map[string]string, error) {
 	if v == nil {
 		return map[string]string{}, nil

google/services/compute/resource_compute_forwarding_rule_generated_meta.yaml

@@ -16,6 +16,7 @@ fields:
   - field: 'forwarding_rule_id'
     api_field: 'id'
   - field: 'ip_address'
+  - field: 'ip_collection'
   - field: 'ip_protocol'
   - field: 'ip_version'
   - field: 'is_mirroring_collector'

google/services/compute/resource_compute_forwarding_rule_generated_test.go

@@ -30,6 +30,70 @@ import (
 	transport_tpg "github.com/hashicorp/terraform-provider-google/google/transport"
 )
 
+func TestAccComputeForwardingRule_forwardingRuleExternallbByoipv6Example(t *testing.T) {
+	t.Parallel()
+
+	context := map[string]interface{}{
+		"ip_address":        fmt.Sprintf("2600:1901:4457:1:%d:%d::/96", acctest.RandIntRange(t, 0, 9999), acctest.RandIntRange(t, 0, 9999)),
+		"ip_collection_url": "projects/tf-static-byoip/regions/us-central1/publicDelegatedPrefixes/tf-test-forwarding-rule-mode-pdp",
+		"random_suffix":     acctest.RandString(t, 10),
+	}
+
+	acctest.VcrTest(t, resource.TestCase{
+		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
+		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
+		CheckDestroy:             testAccCheckComputeForwardingRuleDestroyProducer(t),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccComputeForwardingRule_forwardingRuleExternallbByoipv6Example(context),
+			},
+			{
+				ResourceName:            "google_compute_forwarding_rule.default",
+				ImportState:             true,
+				ImportStateVerify:       true,
+				ImportStateVerifyIgnore: []string{"backend_service", "labels", "network", "no_automate_dns_zone", "port_range", "region", "subnetwork", "terraform_labels"},
+			},
+		},
+	})
+}
+
+func testAccComputeForwardingRule_forwardingRuleExternallbByoipv6Example(context map[string]interface{}) string {
+	return acctest.Nprintf(`
+// Forwarding rule for External Network Load Balancing using Backend Services with IP Collection
+
+resource "google_compute_forwarding_rule" "default" {
+  name                  = "tf-test-byoipv6-forwarding-rule%{random_suffix}"
+  region                = "us-central1"
+  port_range            = 80
+  ip_protocol           = "TCP"
+  ip_version            = "IPV6"
+  load_balancing_scheme = "EXTERNAL"
+  ip_address            = "%{ip_address}"
+  network_tier          = "PREMIUM"
+  backend_service       = google_compute_region_backend_service.backend.id
+  ip_collection         = "%{ip_collection_url}"
+}
+
+resource "google_compute_region_backend_service" "backend" {
+  name                  = "tf-test-website-backend%{random_suffix}"
+  region                = "us-central1"
+  load_balancing_scheme = "EXTERNAL"
+  health_checks         = [google_compute_region_health_check.hc.id]
+}
+
+resource "google_compute_region_health_check" "hc" {
+  name               = "tf-test-website-backend%{random_suffix}"
+  check_interval_sec = 1
+  timeout_sec        = 1
+  region             = "us-central1"
+
+  tcp_health_check {
+    port = "80"
+  }
+}
+`, context)
+}
+
 func TestAccComputeForwardingRule_forwardingRuleGlobalInternallbExample(t *testing.T) {
 	t.Parallel()
 

website/docs/r/compute_forwarding_rule.html.markdown

@@ -453,6 +453,48 @@ resource "google_compute_region_health_check" "hc" {
   }
 }
 ```
+<div class = "oics-button" style="float: right; margin: 0 0 -15px">
+  <a href="https://console.cloud.google.com/cloudshell/open?cloudshell_git_repo=https%3A%2F%2Fgithub.com%2Fterraform-google-modules%2Fdocs-examples.git&cloudshell_image=gcr.io%2Fcloudshell-images%2Fcloudshell%3Alatest&cloudshell_print=.%2Fmotd&cloudshell_tutorial=.%2Ftutorial.md&cloudshell_working_dir=forwarding_rule_externallb_byoipv6&open_in_editor=main.tf" target="_blank">
+    <img alt="Open in Cloud Shell" src="//gstatic.com/cloudssh/images/open-btn.svg" style="max-height: 44px; margin: 32px auto; max-width: 100%;">
+  </a>
+</div>
+## Example Usage - Forwarding Rule Externallb Byoipv6
+
+
+```hcl
+// Forwarding rule for External Network Load Balancing using Backend Services with IP Collection
+
+resource "google_compute_forwarding_rule" "default" {
+  name                  = "byoipv6-forwarding-rule"
+  region                = "us-central1"
+  port_range            = 80
+  ip_protocol           = "TCP"
+  ip_version            = "IPV6"
+  load_balancing_scheme = "EXTERNAL"
+  ip_address            = ""2600:1901:4457:1::/96""
+  network_tier          = "PREMIUM"
+  backend_service       = google_compute_region_backend_service.backend.id
+  ip_collection         = ""projects/tf-static-byoip/regions/us-central1/publicDelegatedPrefixes/tf-test-forwarding-rule-mode-pdp""
+}
+
+resource "google_compute_region_backend_service" "backend" {
+  name                  = "website-backend"
+  region                = "us-central1"
+  load_balancing_scheme = "EXTERNAL"
+  health_checks         = [google_compute_region_health_check.hc.id]
+}
+
+resource "google_compute_region_health_check" "hc" {
+  name               = "website-backend"
+  check_interval_sec = 1
+  timeout_sec        = 1
+  region             = "us-central1"
+
+  tcp_health_check {
+    port = "80"
+  }
+}
+```
 <div class = "oics-button" style="float: right; margin: 0 0 -15px">
   <a href="https://console.cloud.google.com/cloudshell/open?cloudshell_git_repo=https%3A%2F%2Fgithub.com%2Fterraform-google-modules%2Fdocs-examples.git&cloudshell_image=gcr.io%2Fcloudshell-images%2Fcloudshell%3Alatest&cloudshell_print=.%2Fmotd&cloudshell_tutorial=.%2Ftutorial.md&cloudshell_working_dir=forwarding_rule_global_internallb&open_in_editor=main.tf" target="_blank">
     <img alt="Open in Cloud Shell" src="//gstatic.com/cloudssh/images/open-btn.svg" style="max-height: 44px; margin: 32px auto; max-width: 100%;">
@@ -1565,6 +1607,18 @@ The following arguments are supported:
   If not set, the IPv4 address will be used by default.
   Possible values are: `IPV4`, `IPV6`.
 
+* `ip_collection` -
+  (Optional)
+  Resource reference of a PublicDelegatedPrefix. The PDP must be a sub-PDP
+  in EXTERNAL_IPV6_FORWARDING_RULE_CREATION mode.
+  Use one of the following formats to specify a sub-PDP when creating an
+  IPv6 NetLB forwarding rule using BYOIP:
+  Full resource URL, as in:
+    * `https://www.googleapis.com/compute/v1/projects/{{projectId}}/regions/{{region}}/publicDelegatedPrefixes/{{sub-pdp-name}}`
+  Partial URL, as in:
+    * `projects/{{projectId}}/regions/region/publicDelegatedPrefixes/{{sub-pdp-name}}`
+    * `regions/{{region}}/publicDelegatedPrefixes/{{sub-pdp-name}}`
+
 * `region` -
   (Optional)
   A reference to the region where the regional forwarding rule resides.