diff --git a/.changelog/6584.txt b/.changelog/6584.txt new file mode 100644 index 0000000000..4e9d1ff5cb --- /dev/null +++ b/.changelog/6584.txt @@ -0,0 +1,3 @@ +```release-note:enhancement +compute: added support for `compression_mode` field in `google_compute_backend_bucket` and `google_compute_backend_service` resource +``` diff --git a/google/resource_compute_backend_bucket.go b/google/resource_compute_backend_bucket.go index 01e23712d1..ed50a77c80 100644 --- a/google/resource_compute_backend_bucket.go +++ b/google/resource_compute_backend_bucket.go @@ -195,6 +195,12 @@ header. The actual headers served in responses will not be altered.`, }, }, }, + "compression_mode": { + Type: schema.TypeString, + Optional: true, + ValidateFunc: validateEnum([]string{"AUTOMATIC", "DISABLED", ""}), + Description: `Compress text responses using Brotli or gzip compression, based on the client's Accept-Encoding header. Possible values: ["AUTOMATIC", "DISABLED"]`, + }, "custom_response_headers": { Type: schema.TypeList, Optional: true, @@ -260,6 +266,12 @@ func resourceComputeBackendBucketCreate(d *schema.ResourceData, meta interface{} } else if v, ok := d.GetOkExists("cdn_policy"); !isEmptyValue(reflect.ValueOf(cdnPolicyProp)) && (ok || !reflect.DeepEqual(v, cdnPolicyProp)) { obj["cdnPolicy"] = cdnPolicyProp } + compressionModeProp, err := expandComputeBackendBucketCompressionMode(d.Get("compression_mode"), d, config) + if err != nil { + return err + } else if v, ok := d.GetOkExists("compression_mode"); !isEmptyValue(reflect.ValueOf(compressionModeProp)) && (ok || !reflect.DeepEqual(v, compressionModeProp)) { + obj["compressionMode"] = compressionModeProp + } edgeSecurityPolicyProp, err := expandComputeBackendBucketEdgeSecurityPolicy(d.Get("edge_security_policy"), d, config) if err != nil { return err @@ -397,6 +409,9 @@ func resourceComputeBackendBucketRead(d *schema.ResourceData, meta interface{}) if err := d.Set("cdn_policy", flattenComputeBackendBucketCdnPolicy(res["cdnPolicy"], d, config)); err != nil { return fmt.Errorf("Error reading BackendBucket: %s", err) } + if err := d.Set("compression_mode", flattenComputeBackendBucketCompressionMode(res["compressionMode"], d, config)); err != nil { + return fmt.Errorf("Error reading BackendBucket: %s", err) + } if err := d.Set("edge_security_policy", flattenComputeBackendBucketEdgeSecurityPolicy(res["edgeSecurityPolicy"], d, config)); err != nil { return fmt.Errorf("Error reading BackendBucket: %s", err) } @@ -450,6 +465,12 @@ func resourceComputeBackendBucketUpdate(d *schema.ResourceData, meta interface{} } else if v, ok := d.GetOkExists("cdn_policy"); !isEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, cdnPolicyProp)) { obj["cdnPolicy"] = cdnPolicyProp } + compressionModeProp, err := expandComputeBackendBucketCompressionMode(d.Get("compression_mode"), d, config) + if err != nil { + return err + } else if v, ok := d.GetOkExists("compression_mode"); !isEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, compressionModeProp)) { + obj["compressionMode"] = compressionModeProp + } edgeSecurityPolicyProp, err := expandComputeBackendBucketEdgeSecurityPolicy(d.Get("edge_security_policy"), d, config) if err != nil { return err @@ -828,6 +849,10 @@ func flattenComputeBackendBucketCdnPolicyBypassCacheOnRequestHeadersHeaderName(v return v } +func flattenComputeBackendBucketCompressionMode(v interface{}, d *schema.ResourceData, config *Config) interface{} { + return v +} + func flattenComputeBackendBucketEdgeSecurityPolicy(v interface{}, d *schema.ResourceData, config *Config) interface{} { return v } @@ -1074,6 +1099,10 @@ func expandComputeBackendBucketCdnPolicyBypassCacheOnRequestHeadersHeaderName(v return v, nil } +func expandComputeBackendBucketCompressionMode(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) { + return v, nil +} + func expandComputeBackendBucketEdgeSecurityPolicy(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) { return v, nil } diff --git a/google/resource_compute_backend_bucket_test.go b/google/resource_compute_backend_bucket_test.go index e9ae29772c..a84b253c95 100644 --- a/google/resource_compute_backend_bucket_test.go +++ b/google/resource_compute_backend_bucket_test.go @@ -126,6 +126,45 @@ func TestAccComputeBackendBucket_withSecurityPolicy(t *testing.T) { }) } +func TestAccComputeBackendBucket_withCompressionMode(t *testing.T) { + t.Parallel() + + backendName := fmt.Sprintf("tf-test-%s", randString(t, 10)) + storageName := fmt.Sprintf("tf-test-%s", randString(t, 10)) + + vcrTest(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckComputeBackendServiceDestroyProducer(t), + Steps: []resource.TestStep{ + { + Config: testAccComputeBackendBucket_withCompressionMode(backendName, storageName, "DISABLED"), + }, + { + ResourceName: "google_compute_backend_bucket.foobar", + ImportState: true, + ImportStateVerify: true, + }, + { + Config: testAccComputeBackendBucket_withCompressionMode(backendName, storageName, "AUTOMATIC"), + }, + { + ResourceName: "google_compute_backend_bucket.foobar", + ImportState: true, + ImportStateVerify: true, + }, + { + Config: testAccComputeBackendBucket_basic(backendName, storageName), + }, + { + ResourceName: "google_compute_backend_bucket.foobar", + ImportState: true, + ImportStateVerify: true, + }, + }, + }) +} + func testAccComputeBackendBucket_basic(backendName, storageName string) string { return fmt.Sprintf(` resource "google_compute_backend_bucket" "foobar" { @@ -256,3 +295,19 @@ resource "google_compute_security_policy" "policy" { } `, bucketName, polLink, bucketName, polName) } + +func testAccComputeBackendBucket_withCompressionMode(backendName, storageName, compressionMode string) string { + return fmt.Sprintf(` +resource "google_compute_backend_bucket" "foobar" { + name = "%s" + bucket_name = google_storage_bucket.bucket_one.name + enable_cdn = true + compression_mode = "%s" +} + +resource "google_storage_bucket" "bucket_one" { + name = "%s" + location = "EU" +} +`, backendName, compressionMode, storageName) +} diff --git a/google/resource_compute_backend_service.go b/google/resource_compute_backend_service.go index d59c0d0e50..38c739700e 100644 --- a/google/resource_compute_backend_service.go +++ b/google/resource_compute_backend_service.go @@ -437,6 +437,12 @@ Defaults to 3.`, }, }, }, + "compression_mode": { + Type: schema.TypeString, + Optional: true, + ValidateFunc: validateEnum([]string{"AUTOMATIC", "DISABLED", ""}), + Description: `Compress text responses using Brotli or gzip compression, based on the client's Accept-Encoding header. Possible values: ["AUTOMATIC", "DISABLED"]`, + }, "connection_draining_timeout_sec": { Type: schema.TypeInt, Optional: true, @@ -1094,6 +1100,12 @@ func resourceComputeBackendServiceCreate(d *schema.ResourceData, meta interface{ } else if v, ok := d.GetOkExists("circuit_breakers"); !isEmptyValue(reflect.ValueOf(circuitBreakersProp)) && (ok || !reflect.DeepEqual(v, circuitBreakersProp)) { obj["circuitBreakers"] = circuitBreakersProp } + compressionModeProp, err := expandComputeBackendServiceCompressionMode(d.Get("compression_mode"), d, config) + if err != nil { + return err + } else if v, ok := d.GetOkExists("compression_mode"); !isEmptyValue(reflect.ValueOf(compressionModeProp)) && (ok || !reflect.DeepEqual(v, compressionModeProp)) { + obj["compressionMode"] = compressionModeProp + } consistentHashProp, err := expandComputeBackendServiceConsistentHash(d.Get("consistent_hash"), d, config) if err != nil { return err @@ -1347,6 +1359,9 @@ func resourceComputeBackendServiceRead(d *schema.ResourceData, meta interface{}) if err := d.Set("circuit_breakers", flattenComputeBackendServiceCircuitBreakers(res["circuitBreakers"], d, config)); err != nil { return fmt.Errorf("Error reading BackendService: %s", err) } + if err := d.Set("compression_mode", flattenComputeBackendServiceCompressionMode(res["compressionMode"], d, config)); err != nil { + return fmt.Errorf("Error reading BackendService: %s", err) + } if err := d.Set("consistent_hash", flattenComputeBackendServiceConsistentHash(res["consistentHash"], d, config)); err != nil { return fmt.Errorf("Error reading BackendService: %s", err) } @@ -1466,6 +1481,12 @@ func resourceComputeBackendServiceUpdate(d *schema.ResourceData, meta interface{ } else if v, ok := d.GetOkExists("circuit_breakers"); !isEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, circuitBreakersProp)) { obj["circuitBreakers"] = circuitBreakersProp } + compressionModeProp, err := expandComputeBackendServiceCompressionMode(d.Get("compression_mode"), d, config) + if err != nil { + return err + } else if v, ok := d.GetOkExists("compression_mode"); !isEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, compressionModeProp)) { + obj["compressionMode"] = compressionModeProp + } consistentHashProp, err := expandComputeBackendServiceConsistentHash(d.Get("consistent_hash"), d, config) if err != nil { return err @@ -1963,6 +1984,10 @@ func flattenComputeBackendServiceCircuitBreakersMaxRetries(v interface{}, d *sch return v // let terraform core handle it otherwise } +func flattenComputeBackendServiceCompressionMode(v interface{}, d *schema.ResourceData, config *Config) interface{} { + return v +} + func flattenComputeBackendServiceConsistentHash(v interface{}, d *schema.ResourceData, config *Config) interface{} { if v == nil { return nil @@ -2985,6 +3010,10 @@ func expandComputeBackendServiceCircuitBreakersMaxRetries(v interface{}, d Terra return v, nil } +func expandComputeBackendServiceCompressionMode(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) { + return v, nil +} + func expandComputeBackendServiceConsistentHash(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) { l := v.([]interface{}) if len(l) == 0 || l[0] == nil { diff --git a/google/resource_compute_backend_service_test.go b/google/resource_compute_backend_service_test.go index bdd593230f..3045e60a78 100644 --- a/google/resource_compute_backend_service_test.go +++ b/google/resource_compute_backend_service_test.go @@ -657,6 +657,45 @@ func TestAccComputeBackendService_trafficDirectorUpdateBasic(t *testing.T) { }) } +func TestAccComputeBackendService_withCompressionMode(t *testing.T) { + t.Parallel() + + backendName := fmt.Sprintf("foo-%s", randString(t, 10)) + checkName := fmt.Sprintf("bar-%s", randString(t, 10)) + + vcrTest(t, resource.TestCase{ + PreCheck: func() { testAccPreCheck(t) }, + Providers: testAccProviders, + CheckDestroy: testAccCheckComputeBackendServiceDestroyProducer(t), + Steps: []resource.TestStep{ + { + Config: testAccComputeBackendService_withCompressionMode(backendName, checkName, "DISABLED"), + }, + { + ResourceName: "google_compute_backend_service.foobar", + ImportState: true, + ImportStateVerify: true, + }, + { + Config: testAccComputeBackendService_withCompressionMode(backendName, checkName, "AUTOMATIC"), + }, + { + ResourceName: "google_compute_backend_service.foobar", + ImportState: true, + ImportStateVerify: true, + }, + { + Config: testAccComputeBackendService_basic(backendName, checkName), + }, + { + ResourceName: "google_compute_backend_service.foobar", + ImportState: true, + ImportStateVerify: true, + }, + }, + }) +} + func testAccComputeBackendService_trafficDirectorBasic(serviceName, checkName string) string { return fmt.Sprintf(` resource "google_compute_backend_service" "foobar" { @@ -1471,3 +1510,21 @@ resource "google_compute_http_health_check" "zero" { } `, serviceName, enabled, checkName) } + +func testAccComputeBackendService_withCompressionMode(serviceName, checkName, compressionMode string) string { + return fmt.Sprintf(` +resource "google_compute_backend_service" "foobar" { + name = "%s" + health_checks = [google_compute_http_health_check.zero.self_link] + enable_cdn = true + compression_mode = "%s" +} + +resource "google_compute_http_health_check" "zero" { + name = "%s" + request_path = "/" + check_interval_sec = 1 + timeout_sec = 1 +} +`, serviceName, compressionMode, checkName) +} diff --git a/website/docs/r/compute_backend_bucket.html.markdown b/website/docs/r/compute_backend_bucket.html.markdown index 5874fb7610..6a0e00429d 100644 --- a/website/docs/r/compute_backend_bucket.html.markdown +++ b/website/docs/r/compute_backend_bucket.html.markdown @@ -166,6 +166,11 @@ The following arguments are supported: Cloud CDN configuration for this Backend Bucket. Structure is [documented below](#nested_cdn_policy). +* `compression_mode` - + (Optional) + Compress text responses using Brotli or gzip compression, based on the client's Accept-Encoding header. + Possible values are `AUTOMATIC` and `DISABLED`. + * `edge_security_policy` - (Optional) The security policy associated with this backend bucket. diff --git a/website/docs/r/compute_backend_service.html.markdown b/website/docs/r/compute_backend_service.html.markdown index 84abcf7bdb..2888cbad45 100644 --- a/website/docs/r/compute_backend_service.html.markdown +++ b/website/docs/r/compute_backend_service.html.markdown @@ -309,6 +309,11 @@ The following arguments are supported: is applicable only when the load_balancing_scheme is set to INTERNAL_SELF_MANAGED. Structure is [documented below](#nested_circuit_breakers). +* `compression_mode` - + (Optional) + Compress text responses using Brotli or gzip compression, based on the client's Accept-Encoding header. + Possible values are `AUTOMATIC` and `DISABLED`. + * `consistent_hash` - (Optional) Consistent Hash-based load balancing can be used to provide soft session