Add field httpKeepAliveTimeoutSec to resources google_compute_region_target_http_proxy and google_compute_region_target_https_proxy

.changelog/11634.txt

@@ -0,0 +1,6 @@
+```release-note:enhancement
+compute: added field `http_keep_alive_timeout_sec` to resource `google_region_compute_target_http_proxy`
+```
+```release-note:enhancement
+compute: added field `http_keep_alive_timeout_sec` to resource `google_region_compute_target_https_proxy`
+```

google-beta/services/compute/resource_compute_region_target_http_proxy.go

@@ -78,6 +78,16 @@ to the BackendService.`,
 				ForceNew:    true,
 				Description: `An optional description of this resource.`,
 			},
+			"http_keep_alive_timeout_sec": {
+				Type:     schema.TypeInt,
+				Optional: true,
+				ForceNew: true,
+				Description: `Specifies how long to keep a connection open, after completing a response,
+while there is no matching traffic (in seconds). If an HTTP keepalive is
+not specified, a default value (600 seconds) will be used. For Regional
+HTTP(S) load balancer, the minimum allowed value is 5 seconds and the
+maximum allowed value is 600 seconds.`,
+			},
 			"region": {
 				Type:             schema.TypeString,
 				Computed:         true,
@@ -138,6 +148,12 @@ func resourceComputeRegionTargetHttpProxyCreate(d *schema.ResourceData, meta int
 	} else if v, ok := d.GetOkExists("url_map"); !tpgresource.IsEmptyValue(reflect.ValueOf(urlMapProp)) && (ok || !reflect.DeepEqual(v, urlMapProp)) {
 		obj["urlMap"] = urlMapProp
 	}
+	httpKeepAliveTimeoutSecProp, err := expandComputeRegionTargetHttpProxyHttpKeepAliveTimeoutSec(d.Get("http_keep_alive_timeout_sec"), d, config)
+	if err != nil {
+		return err
+	} else if v, ok := d.GetOkExists("http_keep_alive_timeout_sec"); !tpgresource.IsEmptyValue(reflect.ValueOf(httpKeepAliveTimeoutSecProp)) && (ok || !reflect.DeepEqual(v, httpKeepAliveTimeoutSecProp)) {
+		obj["httpKeepAliveTimeoutSec"] = httpKeepAliveTimeoutSecProp
+	}
 	regionProp, err := expandComputeRegionTargetHttpProxyRegion(d.Get("region"), d, config)
 	if err != nil {
 		return err
@@ -258,6 +274,9 @@ func resourceComputeRegionTargetHttpProxyRead(d *schema.ResourceData, meta inter
 	if err := d.Set("url_map", flattenComputeRegionTargetHttpProxyUrlMap(res["urlMap"], d, config)); err != nil {
 		return fmt.Errorf("Error reading RegionTargetHttpProxy: %s", err)
 	}
+	if err := d.Set("http_keep_alive_timeout_sec", flattenComputeRegionTargetHttpProxyHttpKeepAliveTimeoutSec(res["httpKeepAliveTimeoutSec"], d, config)); err != nil {
+		return fmt.Errorf("Error reading RegionTargetHttpProxy: %s", err)
+	}
 	if err := d.Set("region", flattenComputeRegionTargetHttpProxyRegion(res["region"], d, config)); err != nil {
 		return fmt.Errorf("Error reading RegionTargetHttpProxy: %s", err)
 	}
@@ -449,6 +468,23 @@ func flattenComputeRegionTargetHttpProxyUrlMap(v interface{}, d *schema.Resource
 	return tpgresource.ConvertSelfLinkToV1(v.(string))
 }
 
+func flattenComputeRegionTargetHttpProxyHttpKeepAliveTimeoutSec(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 flattenComputeRegionTargetHttpProxyRegion(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
 	if v == nil {
 		return v
@@ -472,6 +508,10 @@ func expandComputeRegionTargetHttpProxyUrlMap(v interface{}, d tpgresource.Terra
 	return f.RelativeLink(), nil
 }
 
+func expandComputeRegionTargetHttpProxyHttpKeepAliveTimeoutSec(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
+	return v, nil
+}
+
 func expandComputeRegionTargetHttpProxyRegion(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_region_target_http_proxy_generated_test.go

@@ -104,6 +104,83 @@ resource "google_compute_region_health_check" "default" {
 `, context)
 }
 
+func TestAccComputeRegionTargetHttpProxy_regionTargetHttpProxyHttpKeepAliveTimeoutExample(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.ProtoV5ProviderFactories(t),
+		CheckDestroy:             testAccCheckComputeRegionTargetHttpProxyDestroyProducer(t),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccComputeRegionTargetHttpProxy_regionTargetHttpProxyHttpKeepAliveTimeoutExample(context),
+			},
+			{
+				ResourceName:            "google_compute_region_target_http_proxy.default",
+				ImportState:             true,
+				ImportStateVerify:       true,
+				ImportStateVerifyIgnore: []string{"region", "url_map"},
+			},
+		},
+	})
+}
+
+func testAccComputeRegionTargetHttpProxy_regionTargetHttpProxyHttpKeepAliveTimeoutExample(context map[string]interface{}) string {
+	return acctest.Nprintf(`
+resource "google_compute_region_target_http_proxy" "default" {
+  region                      = "us-central1"
+  name                        = "tf-test-test-http-keep-alive-timeout-proxy%{random_suffix}"
+  http_keep_alive_timeout_sec = 600
+  url_map                     = google_compute_region_url_map.default.id
+}
+
+resource "google_compute_region_url_map" "default" {
+  region          = "us-central1"
+  name            = "tf-test-url-map%{random_suffix}"
+  default_service = google_compute_region_backend_service.default.id
+
+  host_rule {
+    hosts        = ["mysite.com"]
+    path_matcher = "allpaths"
+  }
+
+  path_matcher {
+    name            = "allpaths"
+    default_service = google_compute_region_backend_service.default.id
+
+    path_rule {
+      paths   = ["/*"]
+      service = google_compute_region_backend_service.default.id
+    }
+  }
+}
+
+resource "google_compute_region_backend_service" "default" {
+  region                = "us-central1"
+  name                  = "tf-test-backend-service%{random_suffix}"
+  port_name             = "http"
+  protocol              = "HTTP"
+  timeout_sec           = 10
+  load_balancing_scheme = "INTERNAL_MANAGED"
+
+  health_checks = [google_compute_region_health_check.default.id]
+}
+
+resource "google_compute_region_health_check" "default" {
+  region = "us-central1"
+  name   = "tf-test-http-health-check%{random_suffix}"
+
+  http_health_check {
+    port = 80
+  }
+}
+`, context)
+}
+
 func TestAccComputeRegionTargetHttpProxy_regionTargetHttpProxyHttpsRedirectExample(t *testing.T) {
 	t.Parallel()
 

google-beta/services/compute/resource_compute_region_target_https_proxy.go

@@ -92,6 +92,16 @@ Accepted format is '//certificatemanager.googleapis.com/projects/{project}/locat
 				ForceNew:    true,
 				Description: `An optional description of this resource.`,
 			},
+			"http_keep_alive_timeout_sec": {
+				Type:     schema.TypeInt,
+				Optional: true,
+				ForceNew: true,
+				Description: `Specifies how long to keep a connection open, after completing a response,
+while there is no matching traffic (in seconds). If an HTTP keepalive is
+not specified, a default value (600 seconds) will be used. For Regioanl
+HTTP(S) load balancer, the minimum allowed value is 5 seconds and the
+maximum allowed value is 600 seconds.`,
+			},
 			"region": {
 				Type:             schema.TypeString,
 				Computed:         true,
@@ -209,6 +219,12 @@ func resourceComputeRegionTargetHttpsProxyCreate(d *schema.ResourceData, meta in
 	} else if v, ok := d.GetOkExists("url_map"); !tpgresource.IsEmptyValue(reflect.ValueOf(urlMapProp)) && (ok || !reflect.DeepEqual(v, urlMapProp)) {
 		obj["urlMap"] = urlMapProp
 	}
+	httpKeepAliveTimeoutSecProp, err := expandComputeRegionTargetHttpsProxyHttpKeepAliveTimeoutSec(d.Get("http_keep_alive_timeout_sec"), d, config)
+	if err != nil {
+		return err
+	} else if v, ok := d.GetOkExists("http_keep_alive_timeout_sec"); !tpgresource.IsEmptyValue(reflect.ValueOf(httpKeepAliveTimeoutSecProp)) && (ok || !reflect.DeepEqual(v, httpKeepAliveTimeoutSecProp)) {
+		obj["httpKeepAliveTimeoutSec"] = httpKeepAliveTimeoutSecProp
+	}
 	serverTlsPolicyProp, err := expandComputeRegionTargetHttpsProxyServerTlsPolicy(d.Get("server_tls_policy"), d, config)
 	if err != nil {
 		return err
@@ -361,6 +377,9 @@ func resourceComputeRegionTargetHttpsProxyRead(d *schema.ResourceData, meta inte
 	if err := d.Set("url_map", flattenComputeRegionTargetHttpsProxyUrlMap(res["urlMap"], d, config)); err != nil {
 		return fmt.Errorf("Error reading RegionTargetHttpsProxy: %s", err)
 	}
+	if err := d.Set("http_keep_alive_timeout_sec", flattenComputeRegionTargetHttpsProxyHttpKeepAliveTimeoutSec(res["httpKeepAliveTimeoutSec"], d, config)); err != nil {
+		return fmt.Errorf("Error reading RegionTargetHttpsProxy: %s", err)
+	}
 	if err := d.Set("server_tls_policy", flattenComputeRegionTargetHttpsProxyServerTlsPolicy(res["serverTlsPolicy"], d, config)); err != nil {
 		return fmt.Errorf("Error reading RegionTargetHttpsProxy: %s", err)
 	}
@@ -780,6 +799,23 @@ func flattenComputeRegionTargetHttpsProxyUrlMap(v interface{}, d *schema.Resourc
 	return tpgresource.ConvertSelfLinkToV1(v.(string))
 }
 
+func flattenComputeRegionTargetHttpsProxyHttpKeepAliveTimeoutSec(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 flattenComputeRegionTargetHttpsProxyServerTlsPolicy(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
 	if v == nil {
 		return v
@@ -859,6 +895,10 @@ func expandComputeRegionTargetHttpsProxyUrlMap(v interface{}, d tpgresource.Terr
 	return f.RelativeLink(), nil
 }
 
+func expandComputeRegionTargetHttpsProxyHttpKeepAliveTimeoutSec(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
+	return v, nil
+}
+
 func expandComputeRegionTargetHttpsProxyServerTlsPolicy(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
 	return v, nil
 }

google-beta/services/compute/resource_compute_region_target_https_proxy_generated_test.go

@@ -114,6 +114,93 @@ resource "google_compute_region_health_check" "default" {
 `, context)
 }
 
+func TestAccComputeRegionTargetHttpsProxy_regionTargetHttpsProxyHttpKeepAliveTimeoutExample(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.ProtoV5ProviderFactories(t),
+		CheckDestroy:             testAccCheckComputeRegionTargetHttpsProxyDestroyProducer(t),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccComputeRegionTargetHttpsProxy_regionTargetHttpsProxyHttpKeepAliveTimeoutExample(context),
+			},
+			{
+				ResourceName:            "google_compute_region_target_https_proxy.default",
+				ImportState:             true,
+				ImportStateVerify:       true,
+				ImportStateVerifyIgnore: []string{"region", "server_tls_policy", "ssl_policy", "url_map"},
+			},
+		},
+	})
+}
+
+func testAccComputeRegionTargetHttpsProxy_regionTargetHttpsProxyHttpKeepAliveTimeoutExample(context map[string]interface{}) string {
+	return acctest.Nprintf(`
+resource "google_compute_region_target_https_proxy" "default" {
+  region                      = "us-central1"
+  name                        = "tf-test-test-http-keep-alive-timeout-proxy%{random_suffix}"
+  http_keep_alive_timeout_sec = 600
+  url_map                     = google_compute_region_url_map.default.id
+  ssl_certificates            = [google_compute_region_ssl_certificate.default.id]
+}
+
+resource "google_compute_region_ssl_certificate" "default" {
+  region      = "us-central1"
+  name        = "tf-test-my-certificate%{random_suffix}"
+  private_key = file("test-fixtures/test.key")
+  certificate = file("test-fixtures/test.crt")
+}
+
+resource "google_compute_region_url_map" "default" {
+  region      = "us-central1"
+  name        = "tf-test-url-map%{random_suffix}"
+  description = "a description"
+
+  default_service = google_compute_region_backend_service.default.id
+
+  host_rule {
+    hosts        = ["mysite.com"]
+    path_matcher = "allpaths"
+  }
+
+  path_matcher {
+    name            = "allpaths"
+    default_service = google_compute_region_backend_service.default.id
+
+    path_rule {
+      paths   = ["/*"]
+      service = google_compute_region_backend_service.default.id
+    }
+  }
+}
+
+resource "google_compute_region_backend_service" "default" {
+  region                = "us-central1"
+  name                  = "tf-test-backend-service%{random_suffix}"
+  port_name             = "http"
+  protocol              = "HTTP"
+  timeout_sec           = 10
+  load_balancing_scheme = "INTERNAL_MANAGED"
+
+  health_checks = [google_compute_region_health_check.default.id]
+}
+
+resource "google_compute_region_health_check" "default" {
+  region = "us-central1"
+  name   = "tf-test-http-health-check%{random_suffix}"
+
+  http_health_check {
+    port = 80
+  }
+}
+`, context)
+}
+
 func TestAccComputeRegionTargetHttpsProxy_regionTargetHttpsProxyMtlsExample(t *testing.T) {
 	t.Parallel()
 

google-beta/services/compute/resource_compute_target_http_proxy.go

@@ -84,10 +84,13 @@ to the BackendService.`,
 				ForceNew: true,
 				Description: `Specifies how long to keep a connection open, after completing a response,
 while there is no matching traffic (in seconds). If an HTTP keepalive is
-not specified, a default value (610 seconds) will be used. For Global
-external HTTP(S) load balancer, the minimum allowed value is 5 seconds and
-the maximum allowed value is 1200 seconds. For Global external HTTP(S)
-load balancer (classic), this option is not available publicly.`,
+not specified, a default value will be used. For Global
+external HTTP(S) load balancer, the default value is 610 seconds, the
+minimum allowed value is 5 seconds and the maximum allowed value is 1200
+seconds. For cross-region internal HTTP(S) load balancer, the default
+value is 600 seconds, the minimum allowed value is 5 seconds, and the
+maximum allowed value is 600 seconds. For Global external HTTP(S) load
+balancer (classic), this option is not available publicly.`,
 			},
 			"proxy_bind": {
 				Type:     schema.TypeBool,

google-beta/services/compute/resource_compute_target_https_proxy.go

@@ -109,10 +109,13 @@ Accepted format is '//certificatemanager.googleapis.com/projects/{project}/locat
 				ForceNew: true,
 				Description: `Specifies how long to keep a connection open, after completing a response,
 while there is no matching traffic (in seconds). If an HTTP keepalive is
-not specified, a default value (610 seconds) will be used. For Global
-external HTTP(S) load balancer, the minimum allowed value is 5 seconds and
-the maximum allowed value is 1200 seconds. For Global external HTTP(S)
-load balancer (classic), this option is not available publicly.`,
+not specified, a default value will be used. For Global
+external HTTP(S) load balancer, the default value is 610 seconds, the
+minimum allowed value is 5 seconds and the maximum allowed value is 1200
+seconds. For cross-region internal HTTP(S) load balancer, the default
+value is 600 seconds, the minimum allowed value is 5 seconds, and the
+maximum allowed value is 600 seconds. For Global external HTTP(S) load
+balancer (classic), this option is not available publicly.`,
 			},
 			"proxy_bind": {
 				Type:     schema.TypeBool,