Feature gap: Add backends.preference, maxStreamDuration and cdnPolicy.requestCoalescing to BackendService (#13561) (#22391)

[upstream:5063ef377573e2e28e93e7959797bd7b8bd2fd12]

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

Author: modular-magician

.changelog/13561.txt

@@ -0,0 +1,3 @@
+```release-note:enhancement
+compute: added `log_config.optional_mode`, `log_config.optional_fields`, `backend.preference`, `max_stream_duration` and `cdn_policy.request_coalescing` fields to `google_compute_backend_service` resource
+```

google/services/compute/resource_compute_backend_service.go

@@ -400,6 +400,13 @@ can be specified as values, and you cannot specify a status code more than once.
 								},
 							},
 						},
+						"request_coalescing": {
+							Type:     schema.TypeBool,
+							Computed: true,
+							Optional: true,
+							Description: `If true then Cloud CDN will combine multiple concurrent cache fill requests into a small number of requests
+to the origin.`,
+						},
 						"serve_while_stale": {
 							Type:        schema.TypeInt,
 							Computed:    true,
@@ -890,6 +897,25 @@ If logging is enabled, logs will be exported to Stackdriver.`,
 							Description:  `Whether to enable logging for the load balancer traffic served by this backend service.`,
 							AtLeastOneOf: []string{"log_config.0.enable", "log_config.0.sample_rate"},
 						},
+						"optional_fields": {
+							Type:     schema.TypeList,
+							Optional: true,
+							Description: `This field can only be specified if logging is enabled for this backend service and "logConfig.optionalMode"
+was set to CUSTOM. Contains a list of optional fields you want to include in the logs.
+For example: serverInstance, serverGkeDetails.cluster, serverGkeDetails.pod.podNamespace`,
+							Elem: &schema.Schema{
+								Type: schema.TypeString,
+							},
+						},
+						"optional_mode": {
+							Type:         schema.TypeString,
+							Computed:     true,
+							Optional:     true,
+							ValidateFunc: verify.ValidateEnum([]string{"INCLUDE_ALL_OPTIONAL", "EXCLUDE_ALL_OPTIONAL", "CUSTOM", ""}),
+							Description: `Specifies the optional logging mode for the load balancer traffic.
+Supported values: INCLUDE_ALL_OPTIONAL, EXCLUDE_ALL_OPTIONAL, CUSTOM. Possible values: ["INCLUDE_ALL_OPTIONAL", "EXCLUDE_ALL_OPTIONAL", "CUSTOM"]`,
+							AtLeastOneOf: []string{"log_config.0.enable", "log_config.0.sample_rate", "log_config.0.optional_mode"},
+						},
 						"sample_rate": {
 							Type:             schema.TypeFloat,
 							Optional:         true,
@@ -904,6 +930,33 @@ The default value is 1.0.`,
 					},
 				},
 			},
+			"max_stream_duration": {
+				Type:     schema.TypeList,
+				Optional: true,
+				Description: `Specifies the default maximum duration (timeout) for streams to this service. Duration is computed from the
+beginning of the stream until the response has been completely processed, including all retries. A stream that
+does not complete in this duration is closed.
+If not specified, there will be no timeout limit, i.e. the maximum duration is infinite.
+This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service.
+This field is only allowed when the loadBalancingScheme of the backend service is INTERNAL_SELF_MANAGED.`,
+				MaxItems: 1,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"seconds": {
+							Type:        schema.TypeString,
+							Required:    true,
+							Description: `Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive. (int64 format)`,
+						},
+						"nanos": {
+							Type:     schema.TypeInt,
+							Optional: true,
+							Description: `Span of time that's a fraction of a second at nanosecond resolution.
+Durations less than one second are represented with a 0 seconds field and a positive nanos field.
+Must be from 0 to 999,999,999 inclusive.`,
+						},
+					},
+				},
+			},
 			"outlier_detection": {
 				Type:     schema.TypeList,
 				Optional: true,
@@ -1398,6 +1451,17 @@ either maxRate or maxRatePerInstance must be set.`,
 				Description: `Used when balancingMode is UTILIZATION. This ratio defines the
 CPU utilization target for the group. Valid range is [0.0, 1.0].`,
 			},
+			"preference": {
+				Type:         schema.TypeString,
+				Optional:     true,
+				ValidateFunc: verify.ValidateEnum([]string{"PREFERRED", "DEFAULT", ""}),
+				Description: `This field indicates whether this backend should be fully utilized before sending traffic to backends
+with default preference. This field cannot be set when loadBalancingScheme is set to 'EXTERNAL'. The possible values are:
+  - PREFERRED: Backends with this preference level will be filled up to their capacity limits first,
+    based on RTT.
+  - DEFAULT: If preferred backends don't have enough capacity, backends in this layer would be used and
+    traffic would be assigned based on the load balancing algorithm you use. This is the default Possible values: ["PREFERRED", "DEFAULT"]`,
+			},
 		},
 	}
 }
@@ -1596,6 +1660,12 @@ func resourceComputeBackendServiceCreate(d *schema.ResourceData, meta interface{
 	} else if v, ok := d.GetOkExists("service_lb_policy"); !tpgresource.IsEmptyValue(reflect.ValueOf(serviceLbPolicyProp)) && (ok || !reflect.DeepEqual(v, serviceLbPolicyProp)) {
 		obj["serviceLbPolicy"] = serviceLbPolicyProp
 	}
+	maxStreamDurationProp, err := expandComputeBackendServiceMaxStreamDuration(d.Get("max_stream_duration"), d, config)
+	if err != nil {
+		return err
+	} else if v, ok := d.GetOkExists("max_stream_duration"); !tpgresource.IsEmptyValue(reflect.ValueOf(maxStreamDurationProp)) && (ok || !reflect.DeepEqual(v, maxStreamDurationProp)) {
+		obj["maxStreamDuration"] = maxStreamDurationProp
+	}
 
 	obj, err = resourceComputeBackendServiceEncoder(d, meta, obj)
 	if err != nil {
@@ -1862,6 +1932,9 @@ func resourceComputeBackendServiceRead(d *schema.ResourceData, meta interface{})
 	if err := d.Set("service_lb_policy", flattenComputeBackendServiceServiceLbPolicy(res["serviceLbPolicy"], d, config)); err != nil {
 		return fmt.Errorf("Error reading BackendService: %s", err)
 	}
+	if err := d.Set("max_stream_duration", flattenComputeBackendServiceMaxStreamDuration(res["maxStreamDuration"], d, config)); err != nil {
+		return fmt.Errorf("Error reading BackendService: %s", err)
+	}
 	if err := d.Set("self_link", tpgresource.ConvertSelfLinkToV1(res["selfLink"].(string))); err != nil {
 		return fmt.Errorf("Error reading BackendService: %s", err)
 	}
@@ -2071,6 +2144,12 @@ func resourceComputeBackendServiceUpdate(d *schema.ResourceData, meta interface{
 	} else if v, ok := d.GetOkExists("service_lb_policy"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, serviceLbPolicyProp)) {
 		obj["serviceLbPolicy"] = serviceLbPolicyProp
 	}
+	maxStreamDurationProp, err := expandComputeBackendServiceMaxStreamDuration(d.Get("max_stream_duration"), d, config)
+	if err != nil {
+		return err
+	} else if v, ok := d.GetOkExists("max_stream_duration"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, maxStreamDurationProp)) {
+		obj["maxStreamDuration"] = maxStreamDurationProp
+	}
 
 	obj, err = resourceComputeBackendServiceEncoder(d, meta, obj)
 	if err != nil {
@@ -2264,6 +2343,7 @@ func flattenComputeBackendServiceBackend(v interface{}, d *schema.ResourceData,
 		transformed.Add(map[string]interface{}{
 			"balancing_mode":               flattenComputeBackendServiceBackendBalancingMode(original["balancingMode"], d, config),
 			"capacity_scaler":              flattenComputeBackendServiceBackendCapacityScaler(original["capacityScaler"], d, config),
+			"preference":                   flattenComputeBackendServiceBackendPreference(original["preference"], d, config),
 			"description":                  flattenComputeBackendServiceBackendDescription(original["description"], d, config),
 			"group":                        flattenComputeBackendServiceBackendGroup(original["group"], d, config),
 			"max_connections":              flattenComputeBackendServiceBackendMaxConnections(original["maxConnections"], d, config),
@@ -2286,6 +2366,10 @@ func flattenComputeBackendServiceBackendCapacityScaler(v interface{}, d *schema.
 	return v
 }
 
+func flattenComputeBackendServiceBackendPreference(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
+	return v
+}
+
 func flattenComputeBackendServiceBackendDescription(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
 	return v
 }
@@ -2640,6 +2724,8 @@ func flattenComputeBackendServiceCdnPolicy(v interface{}, d *schema.ResourceData
 		return nil
 	}
 	transformed := make(map[string]interface{})
+	transformed["request_coalescing"] =
+		flattenComputeBackendServiceCdnPolicyRequestCoalescing(original["requestCoalescing"], d, config)
 	transformed["cache_key_policy"] =
 		flattenComputeBackendServiceCdnPolicyCacheKeyPolicy(original["cacheKeyPolicy"], d, config)
 	transformed["signed_url_cache_max_age_sec"] =
@@ -2662,6 +2748,10 @@ func flattenComputeBackendServiceCdnPolicy(v interface{}, d *schema.ResourceData
 		flattenComputeBackendServiceCdnPolicyBypassCacheOnRequestHeaders(original["bypassCacheOnRequestHeaders"], d, config)
 	return []interface{}{transformed}
 }
+func flattenComputeBackendServiceCdnPolicyRequestCoalescing(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
+	return v
+}
+
 func flattenComputeBackendServiceCdnPolicyCacheKeyPolicy(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
 	if v == nil {
 		return nil
@@ -3581,6 +3671,10 @@ func flattenComputeBackendServiceLogConfig(v interface{}, d *schema.ResourceData
 		flattenComputeBackendServiceLogConfigEnable(original["enable"], d, config)
 	transformed["sample_rate"] =
 		flattenComputeBackendServiceLogConfigSampleRate(original["sampleRate"], d, config)
+	transformed["optional_mode"] =
+		flattenComputeBackendServiceLogConfigOptionalMode(original["optionalMode"], d, config)
+	transformed["optional_fields"] =
+		flattenComputeBackendServiceLogConfigOptionalFields(original["optionalFields"], d, config)
 	return []interface{}{transformed}
 }
 func flattenComputeBackendServiceLogConfigEnable(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
@@ -3591,10 +3685,54 @@ func flattenComputeBackendServiceLogConfigSampleRate(v interface{}, d *schema.Re
 	return v
 }
 
+func flattenComputeBackendServiceLogConfigOptionalMode(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
+	return v
+}
+
+func flattenComputeBackendServiceLogConfigOptionalFields(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
+	return v
+}
+
 func flattenComputeBackendServiceServiceLbPolicy(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
 	return v
 }
 
+func flattenComputeBackendServiceMaxStreamDuration(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["seconds"] =
+		flattenComputeBackendServiceMaxStreamDurationSeconds(original["seconds"], d, config)
+	transformed["nanos"] =
+		flattenComputeBackendServiceMaxStreamDurationNanos(original["nanos"], d, config)
+	return []interface{}{transformed}
+}
+func flattenComputeBackendServiceMaxStreamDurationSeconds(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
+	return v
+}
+
+func flattenComputeBackendServiceMaxStreamDurationNanos(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
+	// Handles the string fixed64 format
+	if strVal, ok := v.(string); ok {
+		if intVal, err := tpgresource.StringToFixed64(strVal); err == nil {
+			return intVal
+		}
+	}
+
+	// number values are represented as float64
+	if floatVal, ok := v.(float64); ok {
+		intVal := int(floatVal)
+		return intVal
+	}
+
+	return v // let terraform core handle it otherwise
+}
+
 func expandComputeBackendServiceAffinityCookieTtlSec(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
 	return v, nil
 }
@@ -3624,6 +3762,13 @@ func expandComputeBackendServiceBackend(v interface{}, d tpgresource.TerraformRe
 			transformed["capacityScaler"] = transformedCapacityScaler
 		}
 
+		transformedPreference, err := expandComputeBackendServiceBackendPreference(original["preference"], d, config)
+		if err != nil {
+			return nil, err
+		} else if val := reflect.ValueOf(transformedPreference); val.IsValid() && !tpgresource.IsEmptyValue(val) {
+			transformed["preference"] = transformedPreference
+		}
+
 		transformedDescription, err := expandComputeBackendServiceBackendDescription(original["description"], d, config)
 		if err != nil {
 			return nil, err
@@ -3707,6 +3852,10 @@ func expandComputeBackendServiceBackendCapacityScaler(v interface{}, d tpgresour
 	return v, nil
 }
 
+func expandComputeBackendServiceBackendPreference(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
+	return v, nil
+}
+
 func expandComputeBackendServiceBackendDescription(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
 	return v, nil
 }
@@ -3987,6 +4136,13 @@ func expandComputeBackendServiceCdnPolicy(v interface{}, d tpgresource.Terraform
 	original := raw.(map[string]interface{})
 	transformed := make(map[string]interface{})
 
+	transformedRequestCoalescing, err := expandComputeBackendServiceCdnPolicyRequestCoalescing(original["request_coalescing"], d, config)
+	if err != nil {
+		return nil, err
+	} else {
+		transformed["requestCoalescing"] = transformedRequestCoalescing
+	}
+
 	transformedCacheKeyPolicy, err := expandComputeBackendServiceCdnPolicyCacheKeyPolicy(original["cache_key_policy"], d, config)
 	if err != nil {
 		return nil, err
@@ -4060,6 +4216,10 @@ func expandComputeBackendServiceCdnPolicy(v interface{}, d tpgresource.Terraform
 	return transformed, nil
 }
 
+func expandComputeBackendServiceCdnPolicyRequestCoalescing(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
+	return v, nil
+}
+
 func expandComputeBackendServiceCdnPolicyCacheKeyPolicy(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
 	l := v.([]interface{})
 	if len(l) == 0 || l[0] == nil {
@@ -4892,6 +5052,20 @@ func expandComputeBackendServiceLogConfig(v interface{}, d tpgresource.Terraform
 		transformed["sampleRate"] = transformedSampleRate
 	}
 
+	transformedOptionalMode, err := expandComputeBackendServiceLogConfigOptionalMode(original["optional_mode"], d, config)
+	if err != nil {
+		return nil, err
+	} else if val := reflect.ValueOf(transformedOptionalMode); val.IsValid() && !tpgresource.IsEmptyValue(val) {
+		transformed["optionalMode"] = transformedOptionalMode
+	}
+
+	transformedOptionalFields, err := expandComputeBackendServiceLogConfigOptionalFields(original["optional_fields"], d, config)
+	if err != nil {
+		return nil, err
+	} else if val := reflect.ValueOf(transformedOptionalFields); val.IsValid() && !tpgresource.IsEmptyValue(val) {
+		transformed["optionalFields"] = transformedOptionalFields
+	}
+
 	return transformed, nil
 }
 
@@ -4903,10 +5077,52 @@ func expandComputeBackendServiceLogConfigSampleRate(v interface{}, d tpgresource
 	return v, nil
 }
 
+func expandComputeBackendServiceLogConfigOptionalMode(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
+	return v, nil
+}
+
+func expandComputeBackendServiceLogConfigOptionalFields(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
+	return v, nil
+}
+
 func expandComputeBackendServiceServiceLbPolicy(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
 	return v, nil
 }
 
+func expandComputeBackendServiceMaxStreamDuration(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{})
+
+	transformedSeconds, err := expandComputeBackendServiceMaxStreamDurationSeconds(original["seconds"], d, config)
+	if err != nil {
+		return nil, err
+	} else if val := reflect.ValueOf(transformedSeconds); val.IsValid() && !tpgresource.IsEmptyValue(val) {
+		transformed["seconds"] = transformedSeconds
+	}
+
+	transformedNanos, err := expandComputeBackendServiceMaxStreamDurationNanos(original["nanos"], d, config)
+	if err != nil {
+		return nil, err
+	} else if val := reflect.ValueOf(transformedNanos); val.IsValid() && !tpgresource.IsEmptyValue(val) {
+		transformed["nanos"] = transformedNanos
+	}
+
+	return transformed, nil
+}
+
+func expandComputeBackendServiceMaxStreamDurationSeconds(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
+	return v, nil
+}
+
+func expandComputeBackendServiceMaxStreamDurationNanos(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
+	return v, nil
+}
+
 func resourceComputeBackendServiceEncoder(d *schema.ResourceData, meta interface{}, obj map[string]interface{}) (map[string]interface{}, error) {
 	backendsRaw, ok := obj["backends"]
 	if !ok {

google/services/compute/resource_compute_backend_service_generated_meta.yaml

@@ -34,6 +34,8 @@ fields:
     api_field: 'backends.max_rate_per_instance'
   - field: 'backend.max_utilization'
     api_field: 'backends.max_utilization'
+  - field: 'backend.preference'
+    api_field: 'backends.preference'
   - field: 'cdn_policy.bypass_cache_on_request_headers.header_name'
   - field: 'cdn_policy.cache_key_policy.include_host'
   - field: 'cdn_policy.cache_key_policy.include_http_headers'
@@ -49,6 +51,7 @@ fields:
   - field: 'cdn_policy.negative_caching'
   - field: 'cdn_policy.negative_caching_policy.code'
   - field: 'cdn_policy.negative_caching_policy.ttl'
+  - field: 'cdn_policy.request_coalescing'
   - field: 'cdn_policy.serve_while_stale'
   - field: 'cdn_policy.signed_url_cache_max_age_sec'
   - field: 'circuit_breakers.max_connections'
@@ -88,7 +91,11 @@ fields:
   - field: 'locality_lb_policies.policy.name'
   - field: 'locality_lb_policy'
   - field: 'log_config.enable'
+  - field: 'log_config.optional_fields'
+  - field: 'log_config.optional_mode'
   - field: 'log_config.sample_rate'
+  - field: 'max_stream_duration.nanos'
+  - field: 'max_stream_duration.seconds'
   - field: 'name'
   - field: 'outlier_detection.base_ejection_time.nanos'
   - field: 'outlier_detection.base_ejection_time.seconds'