Feature gap: Add workload_policy field (#13341) (#9599)

[upstream:a47bdc51b413d33c8d872b186b9f96d8a7dd64da]

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

Author: modular-magician

.changelog/13341.txt

@@ -0,0 +1,3 @@
+```release-note:enhancement
+compute: added `workload_policy.type`, `workload_policy.max_topology_distance` and `workload_policy.accelerator_topology` fields to `google_compute_resource_policy` resource
+```

google-beta/services/compute/resource_compute_resource_policy.go

@@ -365,6 +365,40 @@ with RFC1035.`,
 				},
 				ConflictsWith: []string{"group_placement_policy", "instance_schedule_policy", "disk_consistency_group_policy"},
 			},
+			"workload_policy": {
+				Type:        schema.TypeList,
+				Optional:    true,
+				Description: `Represents the workload policy.`,
+				MaxItems:    1,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"type": {
+							Type:         schema.TypeString,
+							Required:     true,
+							ForceNew:     true,
+							ValidateFunc: verify.ValidateEnum([]string{"HIGH_AVAILABILITY", "HIGH_THROUGHPUT"}),
+							Description:  `The type of workload policy. Possible values: ["HIGH_AVAILABILITY", "HIGH_THROUGHPUT"]`,
+						},
+						"accelerator_topology": {
+							Type:     schema.TypeString,
+							Optional: true,
+							ForceNew: true,
+							Description: `The accelerator topology. This field can be set only when the workload policy type is HIGH_THROUGHPUT
+and cannot be set if max topology distance is set.`,
+							ConflictsWith: []string{"workload_policy.0.max_topology_distance"},
+						},
+						"max_topology_distance": {
+							Type:         schema.TypeString,
+							Optional:     true,
+							ForceNew:     true,
+							ValidateFunc: verify.ValidateEnum([]string{"BLOCK", "CLUSTER", "SUBBLOCK", ""}),
+							Description: `The maximum topology distance. This field can be set only when the workload policy type is HIGH_THROUGHPUT
+and cannot be set if accelerator topology is set. Possible values: ["BLOCK", "CLUSTER", "SUBBLOCK"]`,
+							ConflictsWith: []string{"workload_policy.0.accelerator_topology"},
+						},
+					},
+				},
+			},
 			"project": {
 				Type:     schema.TypeString,
 				Optional: true,
@@ -443,6 +477,12 @@ func resourceComputeResourcePolicyCreate(d *schema.ResourceData, meta interface{
 	} else if v, ok := d.GetOkExists("disk_consistency_group_policy"); ok || !reflect.DeepEqual(v, diskConsistencyGroupPolicyProp) {
 		obj["diskConsistencyGroupPolicy"] = diskConsistencyGroupPolicyProp
 	}
+	workloadPolicyProp, err := expandComputeResourcePolicyWorkloadPolicy(d.Get("workload_policy"), d, config)
+	if err != nil {
+		return err
+	} else if v, ok := d.GetOkExists("workload_policy"); !tpgresource.IsEmptyValue(reflect.ValueOf(workloadPolicyProp)) && (ok || !reflect.DeepEqual(v, workloadPolicyProp)) {
+		obj["workloadPolicy"] = workloadPolicyProp
+	}
 	regionProp, err := expandComputeResourcePolicyRegion(d.Get("region"), d, config)
 	if err != nil {
 		return err
@@ -574,6 +614,9 @@ func resourceComputeResourcePolicyRead(d *schema.ResourceData, meta interface{})
 	if err := d.Set("disk_consistency_group_policy", flattenComputeResourcePolicyDiskConsistencyGroupPolicy(res["diskConsistencyGroupPolicy"], d, config)); err != nil {
 		return fmt.Errorf("Error reading ResourcePolicy: %s", err)
 	}
+	if err := d.Set("workload_policy", flattenComputeResourcePolicyWorkloadPolicy(res["workloadPolicy"], d, config)); err != nil {
+		return fmt.Errorf("Error reading ResourcePolicy: %s", err)
+	}
 	if err := d.Set("self_link", tpgresource.ConvertSelfLinkToV1(res["selfLink"].(string))); err != nil {
 		return fmt.Errorf("Error reading ResourcePolicy: %s", err)
 	}
@@ -633,6 +676,12 @@ func resourceComputeResourcePolicyUpdate(d *schema.ResourceData, meta interface{
 	} else if v, ok := d.GetOkExists("disk_consistency_group_policy"); ok || !reflect.DeepEqual(v, diskConsistencyGroupPolicyProp) {
 		obj["diskConsistencyGroupPolicy"] = diskConsistencyGroupPolicyProp
 	}
+	workloadPolicyProp, err := expandComputeResourcePolicyWorkloadPolicy(d.Get("workload_policy"), d, config)
+	if err != nil {
+		return err
+	} else if v, ok := d.GetOkExists("workload_policy"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, workloadPolicyProp)) {
+		obj["workloadPolicy"] = workloadPolicyProp
+	}
 
 	url, err := tpgresource.ReplaceVars(d, config, "{{ComputeBasePath}}projects/{{project}}/regions/{{region}}/resourcePolicies/{{name}}")
 	if err != nil {
@@ -1136,6 +1185,35 @@ func flattenComputeResourcePolicyDiskConsistencyGroupPolicy(v interface{}, d *sc
 	return []interface{}{transformed}
 }
 
+func flattenComputeResourcePolicyWorkloadPolicy(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
+	if v == nil {
+		return nil
+	}
+	original := v.(map[string]interface{})
+	if len(original) == 0 {
+		return nil
+	}
+	transformed := make(map[string]interface{})
+	transformed["type"] =
+		flattenComputeResourcePolicyWorkloadPolicyType(original["type"], d, config)
+	transformed["max_topology_distance"] =
+		flattenComputeResourcePolicyWorkloadPolicyMaxTopologyDistance(original["maxTopologyDistance"], d, config)
+	transformed["accelerator_topology"] =
+		flattenComputeResourcePolicyWorkloadPolicyAcceleratorTopology(original["acceleratorTopology"], d, config)
+	return []interface{}{transformed}
+}
+func flattenComputeResourcePolicyWorkloadPolicyType(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
+	return v
+}
+
+func flattenComputeResourcePolicyWorkloadPolicyMaxTopologyDistance(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
+	return v
+}
+
+func flattenComputeResourcePolicyWorkloadPolicyAcceleratorTopology(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
+	return v
+}
+
 func expandComputeResourcePolicyName(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
 	return v, nil
 }
@@ -1622,6 +1700,51 @@ func expandComputeResourcePolicyDiskConsistencyGroupPolicy(v interface{}, d tpgr
 	return transformed, nil
 }
 
+func expandComputeResourcePolicyWorkloadPolicy(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.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{})
+
+	transformedType, err := expandComputeResourcePolicyWorkloadPolicyType(original["type"], d, config)
+	if err != nil {
+		return nil, err
+	} else if val := reflect.ValueOf(transformedType); val.IsValid() && !tpgresource.IsEmptyValue(val) {
+		transformed["type"] = transformedType
+	}
+
+	transformedMaxTopologyDistance, err := expandComputeResourcePolicyWorkloadPolicyMaxTopologyDistance(original["max_topology_distance"], d, config)
+	if err != nil {
+		return nil, err
+	} else if val := reflect.ValueOf(transformedMaxTopologyDistance); val.IsValid() && !tpgresource.IsEmptyValue(val) {
+		transformed["maxTopologyDistance"] = transformedMaxTopologyDistance
+	}
+
+	transformedAcceleratorTopology, err := expandComputeResourcePolicyWorkloadPolicyAcceleratorTopology(original["accelerator_topology"], d, config)
+	if err != nil {
+		return nil, err
+	} else if val := reflect.ValueOf(transformedAcceleratorTopology); val.IsValid() && !tpgresource.IsEmptyValue(val) {
+		transformed["acceleratorTopology"] = transformedAcceleratorTopology
+	}
+
+	return transformed, nil
+}
+
+func expandComputeResourcePolicyWorkloadPolicyType(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
+	return v, nil
+}
+
+func expandComputeResourcePolicyWorkloadPolicyMaxTopologyDistance(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
+	return v, nil
+}
+
+func expandComputeResourcePolicyWorkloadPolicyAcceleratorTopology(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
+	return v, nil
+}
+
 func expandComputeResourcePolicyRegion(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
 	f, err := tpgresource.ParseGlobalFieldValue("regions", v.(string), "project", d, config, true)
 	if err != nil {

google-beta/services/compute/resource_compute_resource_policy_generated_meta.yaml

@@ -31,3 +31,6 @@ fields:
   - field: 'snapshot_schedule_policy.snapshot_properties.guest_flush'
   - field: 'snapshot_schedule_policy.snapshot_properties.labels'
   - field: 'snapshot_schedule_policy.snapshot_properties.storage_locations'
+  - field: 'workload_policy.accelerator_topology'
+  - field: 'workload_policy.max_topology_distance'
+  - field: 'workload_policy.type'

google-beta/services/compute/resource_compute_resource_policy_generated_test.go

@@ -381,6 +381,122 @@ resource "google_compute_resource_policy" "cgroup" {
 `, context)
 }
 
+func TestAccComputeResourcePolicy_resourcePolicyWorkloadPolicyExample(t *testing.T) {
+	t.Parallel()
+
+	context := map[string]interface{}{
+		"random_suffix": acctest.RandString(t, 10),
+	}
+
+	acctest.VcrTest(t, resource.TestCase{
+		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
+		ProtoV5ProviderFactories: acctest.ProtoV5ProviderBetaFactories(t),
+		CheckDestroy:             testAccCheckComputeResourcePolicyDestroyProducer(t),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccComputeResourcePolicy_resourcePolicyWorkloadPolicyExample(context),
+			},
+			{
+				ResourceName:            "google_compute_resource_policy.bar",
+				ImportState:             true,
+				ImportStateVerify:       true,
+				ImportStateVerifyIgnore: []string{"region"},
+			},
+		},
+	})
+}
+
+func testAccComputeResourcePolicy_resourcePolicyWorkloadPolicyExample(context map[string]interface{}) string {
+	return acctest.Nprintf(`
+resource "google_compute_resource_policy" "bar" {
+  name   = "tf-test-gce-policy%{random_suffix}"
+  region = "europe-west1"
+  provider = google-beta
+  workload_policy {
+    type = "HIGH_AVAILABILITY"
+  }
+}
+`, context)
+}
+
+func TestAccComputeResourcePolicy_resourcePolicyWorkloadPolicyAcceleratorTopologyExample(t *testing.T) {
+	t.Parallel()
+
+	context := map[string]interface{}{
+		"random_suffix": acctest.RandString(t, 10),
+	}
+
+	acctest.VcrTest(t, resource.TestCase{
+		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
+		ProtoV5ProviderFactories: acctest.ProtoV5ProviderBetaFactories(t),
+		CheckDestroy:             testAccCheckComputeResourcePolicyDestroyProducer(t),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccComputeResourcePolicy_resourcePolicyWorkloadPolicyAcceleratorTopologyExample(context),
+			},
+			{
+				ResourceName:            "google_compute_resource_policy.bar",
+				ImportState:             true,
+				ImportStateVerify:       true,
+				ImportStateVerifyIgnore: []string{"region"},
+			},
+		},
+	})
+}
+
+func testAccComputeResourcePolicy_resourcePolicyWorkloadPolicyAcceleratorTopologyExample(context map[string]interface{}) string {
+	return acctest.Nprintf(`
+resource "google_compute_resource_policy" "bar" {
+  name   = "tf-test-gce-policy%{random_suffix}"
+  region = "europe-west1"
+  provider = google-beta
+  workload_policy {
+    type = "HIGH_THROUGHPUT"
+    accelerator_topology = "SOME NEW TOPOLOGY"
+  }
+}
+`, context)
+}
+
+func TestAccComputeResourcePolicy_resourcePolicyWorkloadPolicyMaxTopologyDistanceExample(t *testing.T) {
+	t.Parallel()
+
+	context := map[string]interface{}{
+		"random_suffix": acctest.RandString(t, 10),
+	}
+
+	acctest.VcrTest(t, resource.TestCase{
+		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
+		ProtoV5ProviderFactories: acctest.ProtoV5ProviderBetaFactories(t),
+		CheckDestroy:             testAccCheckComputeResourcePolicyDestroyProducer(t),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccComputeResourcePolicy_resourcePolicyWorkloadPolicyMaxTopologyDistanceExample(context),
+			},
+			{
+				ResourceName:            "google_compute_resource_policy.bar",
+				ImportState:             true,
+				ImportStateVerify:       true,
+				ImportStateVerifyIgnore: []string{"region"},
+			},
+		},
+	})
+}
+
+func testAccComputeResourcePolicy_resourcePolicyWorkloadPolicyMaxTopologyDistanceExample(context map[string]interface{}) string {
+	return acctest.Nprintf(`
+resource "google_compute_resource_policy" "bar" {
+  name   = "tf-test-gce-policy%{random_suffix}"
+  region = "europe-west1"
+  provider = google-beta
+  workload_policy {
+    type = "HIGH_THROUGHPUT"
+    max_topology_distance = "BLOCK"
+  }
+}
+`, context)
+}
+
 func TestAccComputeResourcePolicy_resourcePolicyPlacementPolicyGpuTopologyExample(t *testing.T) {
 	t.Parallel()
 

website/docs/r/compute_resource_policy.html.markdown

@@ -197,6 +197,62 @@ resource "google_compute_resource_policy" "cgroup" {
   }
 }
 ```
+<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.jpy.wang%2Fterraform-google-modules%2Fdocs-examples.git&cloudshell_image=gcr.io%2Fcloudshell-images%2Fcloudshell%3Alatest&cloudshell_print=.%2Fmotd&cloudshell_tutorial=.%2Ftutorial.md&cloudshell_working_dir=resource_policy_workload_policy&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 - Resource Policy Workload Policy
+
+
+```hcl
+resource "google_compute_resource_policy" "bar" {
+  name   = "gce-policy"
+  region = "europe-west1"
+  provider = google-beta
+  workload_policy {
+    type = "HIGH_AVAILABILITY"
+  }
+}
+```
+<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.jpy.wang%2Fterraform-google-modules%2Fdocs-examples.git&cloudshell_image=gcr.io%2Fcloudshell-images%2Fcloudshell%3Alatest&cloudshell_print=.%2Fmotd&cloudshell_tutorial=.%2Ftutorial.md&cloudshell_working_dir=resource_policy_workload_policy_accelerator_topology&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 - Resource Policy Workload Policy Accelerator Topology
+
+
+```hcl
+resource "google_compute_resource_policy" "bar" {
+  name   = "gce-policy"
+  region = "europe-west1"
+  provider = google-beta
+  workload_policy {
+    type = "HIGH_THROUGHPUT"
+    accelerator_topology = "SOME NEW TOPOLOGY"
+  }
+}
+```
+<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.jpy.wang%2Fterraform-google-modules%2Fdocs-examples.git&cloudshell_image=gcr.io%2Fcloudshell-images%2Fcloudshell%3Alatest&cloudshell_print=.%2Fmotd&cloudshell_tutorial=.%2Ftutorial.md&cloudshell_working_dir=resource_policy_workload_policy_max_topology_distance&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 - Resource Policy Workload Policy Max Topology Distance
+
+
+```hcl
+resource "google_compute_resource_policy" "bar" {
+  name   = "gce-policy"
+  region = "europe-west1"
+  provider = google-beta
+  workload_policy {
+    type = "HIGH_THROUGHPUT"
+    max_topology_distance = "BLOCK"
+  }
+}
+```
 <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.jpy.wang%2Fterraform-google-modules%2Fdocs-examples.git&cloudshell_image=gcr.io%2Fcloudshell-images%2Fcloudshell%3Alatest&cloudshell_print=.%2Fmotd&cloudshell_tutorial=.%2Ftutorial.md&cloudshell_working_dir=resource_policy_placement_policy_gpu_topology&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%;">
@@ -261,6 +317,11 @@ The following arguments are supported:
   Replication consistency group for asynchronous disk replication.
   Structure is [documented below](#nested_disk_consistency_group_policy).
 
+* `workload_policy` -
+  (Optional, [Beta](https://terraform.io/docs/providers/google/guides/provider_versions.html))
+  Represents the workload policy.
+  Structure is [documented below](#nested_workload_policy).
+
 * `region` -
   (Optional)
   Region where resource policy resides.
@@ -456,6 +517,24 @@ The following arguments are supported:
   (Required)
   Enable disk consistency on the resource policy.
 
+<a name="nested_workload_policy"></a>The `workload_policy` block supports:
+
+* `type` -
+  (Required)
+  The type of workload policy.
+  Possible values are: `HIGH_AVAILABILITY`, `HIGH_THROUGHPUT`.
+
+* `max_topology_distance` -
+  (Optional)
+  The maximum topology distance. This field can be set only when the workload policy type is HIGH_THROUGHPUT
+  and cannot be set if accelerator topology is set.
+  Possible values are: `BLOCK`, `CLUSTER`, `SUBBLOCK`.
+
+* `accelerator_topology` -
+  (Optional)
+  The accelerator topology. This field can be set only when the workload policy type is HIGH_THROUGHPUT
+  and cannot be set if max topology distance is set.
+
 ## Attributes Reference
 
 In addition to the arguments listed above, the following computed attributes are exported: