| // Copyright (c) HashiCorp, Inc. |
| // SPDX-License-Identifier: MPL-2.0 |
| |
| // ---------------------------------------------------------------------------- |
| // |
| // *** AUTO GENERATED CODE *** Type: MMv1 *** |
| // |
| // ---------------------------------------------------------------------------- |
| // |
| // This file is automatically generated by Magic Modules and manual |
| // changes will be clobbered when the file is regenerated. |
| // |
| // Please read more about how to change this file in |
| // .github/CONTRIBUTING.md. |
| // |
| // ---------------------------------------------------------------------------- |
| |
| package compute |
| |
| import ( |
| "context" |
| "fmt" |
| "log" |
| "reflect" |
| "time" |
| |
| "github.com/hashicorp/terraform-plugin-sdk/v2/helper/customdiff" |
| "github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema" |
| |
| "github.com/hashicorp/terraform-provider-google-beta/google-beta/tpgresource" |
| transport_tpg "github.com/hashicorp/terraform-provider-google-beta/google-beta/transport" |
| "github.com/hashicorp/terraform-provider-google-beta/google-beta/verify" |
| |
| "google.golang.org/api/googleapi" |
| ) |
| |
| // Fields in "backends" that are not allowed for non-managed backend services |
| // (loadBalancingScheme) - the API returns an error if they are set at all |
| // in the request. |
| var backendServiceOnlyManagedFieldNames = []string{ |
| "capacity_scaler", |
| "max_connections", |
| "max_connections_per_instance", |
| "max_connections_per_endpoint", |
| "max_rate", |
| "max_rate_per_instance", |
| "max_rate_per_endpoint", |
| "max_utilization", |
| } |
| |
| // validateManagedBackendServiceBackends ensures capacity_scaler is set for each backend in a managed |
| // backend service. To prevent a permadiff, we decided to override the API behavior and require the |
| // capacity_scaler value in this case. |
| // |
| // The API: |
| // - requires the sum of the backends' capacity_scalers be > 0 |
| // - defaults to 1 if capacity_scaler is omitted from the request |
| // |
| // However, the schema.Set Hash function defaults to 0 if not given, which we chose because it's the default |
| // float and because non-managed backends can't have the value set, so there will be a permadiff for a |
| // situational non-zero default returned from the API. We can't diff suppress or customdiff a |
| // field inside a set object in ResourceDiff, since the value also determines the hash for that set object. |
| func validateManagedBackendServiceBackends(backends []interface{}, d *schema.ResourceDiff) error { |
| sum := 0.0 |
| |
| for _, b := range backends { |
| if b == nil { |
| continue |
| } |
| backend := b.(map[string]interface{}) |
| if v, ok := backend["capacity_scaler"]; ok && v != nil { |
| sum += v.(float64) |
| } else { |
| return fmt.Errorf("capacity_scaler is required for each backend in managed backend service") |
| } |
| } |
| if sum == 0.0 { |
| return fmt.Errorf("managed backend service must have at least one non-zero capacity_scaler for backends") |
| } |
| return nil |
| } |
| |
| // If INTERNAL or EXTERNAL, make sure the user did not provide values for any of the fields that cannot be sent. |
| // We ignore these values regardless when sent to the API, but this adds plan-time validation if a |
| // user sets the value to non-zero. We can't validate for empty but set because |
| // of how the SDK handles set objects (on any read, nil fields will get set to empty values) |
| func validateNonManagedBackendServiceBackends(backends []interface{}, d *schema.ResourceDiff) error { |
| for _, b := range backends { |
| if b == nil { |
| continue |
| } |
| backend := b.(map[string]interface{}) |
| for _, fn := range backendServiceOnlyManagedFieldNames { |
| if v, ok := backend[fn]; ok && !tpgresource.IsEmptyValue(reflect.ValueOf(v)) { |
| return fmt.Errorf("%q cannot be set for non-managed backend service, found value %v", fn, v) |
| } |
| } |
| } |
| return nil |
| } |
| |
| func customDiffRegionBackendService(_ context.Context, d *schema.ResourceDiff, meta interface{}) error { |
| v, ok := d.GetOk("backend") |
| if !ok { |
| return nil |
| } |
| if v == nil { |
| return nil |
| } |
| |
| backends := v.(*schema.Set).List() |
| if len(backends) == 0 { |
| return nil |
| } |
| |
| switch d.Get("load_balancing_scheme").(string) { |
| case "INTERNAL", "EXTERNAL": |
| return validateNonManagedBackendServiceBackends(backends, d) |
| case "INTERNAL_MANAGED": |
| return nil |
| default: |
| return validateManagedBackendServiceBackends(backends, d) |
| } |
| } |
| |
| func ResourceComputeRegionBackendService() *schema.Resource { |
| return &schema.Resource{ |
| Create: resourceComputeRegionBackendServiceCreate, |
| Read: resourceComputeRegionBackendServiceRead, |
| Update: resourceComputeRegionBackendServiceUpdate, |
| Delete: resourceComputeRegionBackendServiceDelete, |
| |
| Importer: &schema.ResourceImporter{ |
| State: resourceComputeRegionBackendServiceImport, |
| }, |
| |
| Timeouts: &schema.ResourceTimeout{ |
| Create: schema.DefaultTimeout(20 * time.Minute), |
| Update: schema.DefaultTimeout(20 * time.Minute), |
| Delete: schema.DefaultTimeout(20 * time.Minute), |
| }, |
| |
| SchemaVersion: 1, |
| MigrateState: tpgresource.MigrateStateNoop, |
| CustomizeDiff: customdiff.All( |
| customDiffRegionBackendService, |
| tpgresource.DefaultProviderProject, |
| ), |
| |
| Schema: map[string]*schema.Schema{ |
| "name": { |
| Type: schema.TypeString, |
| Required: true, |
| ForceNew: true, |
| Description: `Name of the resource. Provided by the client when the resource is |
| created. The name must be 1-63 characters long, and comply with |
| RFC1035. Specifically, the name must be 1-63 characters long and match |
| the regular expression '[a-z]([-a-z0-9]*[a-z0-9])?' which means the |
| first character must be a lowercase letter, and all following |
| characters must be a dash, lowercase letter, or digit, except the last |
| character, which cannot be a dash.`, |
| }, |
| "affinity_cookie_ttl_sec": { |
| Type: schema.TypeInt, |
| Optional: true, |
| Description: `Lifetime of cookies in seconds if session_affinity is |
| GENERATED_COOKIE. If set to 0, the cookie is non-persistent and lasts |
| only until the end of the browser session (or equivalent). The |
| maximum allowed value for TTL is one day. |
| |
| When the load balancing scheme is INTERNAL, this field is not used.`, |
| }, |
| "backend": { |
| Type: schema.TypeSet, |
| Optional: true, |
| Description: `The set of backends that serve this RegionBackendService.`, |
| Elem: computeRegionBackendServiceBackendSchema(), |
| Set: resourceGoogleComputeBackendServiceBackendHash, |
| }, |
| "cdn_policy": { |
| Type: schema.TypeList, |
| Computed: true, |
| Optional: true, |
| Description: `Cloud CDN configuration for this BackendService.`, |
| MaxItems: 1, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "cache_key_policy": { |
| Type: schema.TypeList, |
| Optional: true, |
| Description: `The CacheKeyPolicy for this CdnPolicy.`, |
| MaxItems: 1, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "include_host": { |
| Type: schema.TypeBool, |
| Optional: true, |
| Description: `If true requests to different hosts will be cached separately.`, |
| AtLeastOneOf: []string{"cdn_policy.0.cache_key_policy.0.include_host", "cdn_policy.0.cache_key_policy.0.include_protocol", "cdn_policy.0.cache_key_policy.0.include_query_string", "cdn_policy.0.cache_key_policy.0.query_string_blacklist", "cdn_policy.0.cache_key_policy.0.query_string_whitelist", "cdn_policy.0.cache_key_policy.0.include_named_cookies"}, |
| }, |
| "include_named_cookies": { |
| Type: schema.TypeList, |
| Optional: true, |
| Description: `Names of cookies to include in cache keys.`, |
| Elem: &schema.Schema{ |
| Type: schema.TypeString, |
| }, |
| AtLeastOneOf: []string{"cdn_policy.0.cache_key_policy.0.include_host", "cdn_policy.0.cache_key_policy.0.include_protocol", "cdn_policy.0.cache_key_policy.0.include_query_string", "cdn_policy.0.cache_key_policy.0.query_string_blacklist", "cdn_policy.0.cache_key_policy.0.query_string_whitelist", "cdn_policy.0.cache_key_policy.0.include_named_cookies"}, |
| }, |
| "include_protocol": { |
| Type: schema.TypeBool, |
| Optional: true, |
| Description: `If true, http and https requests will be cached separately.`, |
| AtLeastOneOf: []string{"cdn_policy.0.cache_key_policy.0.include_host", "cdn_policy.0.cache_key_policy.0.include_protocol", "cdn_policy.0.cache_key_policy.0.include_query_string", "cdn_policy.0.cache_key_policy.0.query_string_blacklist", "cdn_policy.0.cache_key_policy.0.query_string_whitelist", "cdn_policy.0.cache_key_policy.0.include_named_cookies"}, |
| }, |
| "include_query_string": { |
| Type: schema.TypeBool, |
| Optional: true, |
| Description: `If true, include query string parameters in the cache key |
| according to query_string_whitelist and |
| query_string_blacklist. If neither is set, the entire query |
| string will be included. |
| |
| If false, the query string will be excluded from the cache |
| key entirely.`, |
| AtLeastOneOf: []string{"cdn_policy.0.cache_key_policy.0.include_host", "cdn_policy.0.cache_key_policy.0.include_protocol", "cdn_policy.0.cache_key_policy.0.include_query_string", "cdn_policy.0.cache_key_policy.0.query_string_blacklist", "cdn_policy.0.cache_key_policy.0.query_string_whitelist", "cdn_policy.0.cache_key_policy.0.include_named_cookies"}, |
| }, |
| "query_string_blacklist": { |
| Type: schema.TypeSet, |
| Optional: true, |
| Description: `Names of query string parameters to exclude in cache keys. |
| |
| All other parameters will be included. Either specify |
| query_string_whitelist or query_string_blacklist, not both. |
| '&' and '=' will be percent encoded and not treated as |
| delimiters.`, |
| Elem: &schema.Schema{ |
| Type: schema.TypeString, |
| }, |
| Set: schema.HashString, |
| AtLeastOneOf: []string{"cdn_policy.0.cache_key_policy.0.include_host", "cdn_policy.0.cache_key_policy.0.include_protocol", "cdn_policy.0.cache_key_policy.0.include_query_string", "cdn_policy.0.cache_key_policy.0.query_string_blacklist", "cdn_policy.0.cache_key_policy.0.query_string_whitelist", "cdn_policy.0.cache_key_policy.0.include_named_cookies"}, |
| }, |
| "query_string_whitelist": { |
| Type: schema.TypeSet, |
| Optional: true, |
| Description: `Names of query string parameters to include in cache keys. |
| |
| All other parameters will be excluded. Either specify |
| query_string_whitelist or query_string_blacklist, not both. |
| '&' and '=' will be percent encoded and not treated as |
| delimiters.`, |
| Elem: &schema.Schema{ |
| Type: schema.TypeString, |
| }, |
| Set: schema.HashString, |
| AtLeastOneOf: []string{"cdn_policy.0.cache_key_policy.0.include_host", "cdn_policy.0.cache_key_policy.0.include_protocol", "cdn_policy.0.cache_key_policy.0.include_query_string", "cdn_policy.0.cache_key_policy.0.query_string_blacklist", "cdn_policy.0.cache_key_policy.0.query_string_whitelist", "cdn_policy.0.cache_key_policy.0.include_named_cookies"}, |
| }, |
| }, |
| }, |
| AtLeastOneOf: []string{"cdn_policy.0.cache_key_policy", "cdn_policy.0.signed_url_cache_max_age_sec"}, |
| }, |
| "cache_mode": { |
| Type: schema.TypeString, |
| Computed: true, |
| Optional: true, |
| ValidateFunc: verify.ValidateEnum([]string{"USE_ORIGIN_HEADERS", "FORCE_CACHE_ALL", "CACHE_ALL_STATIC", ""}), |
| Description: `Specifies the cache setting for all responses from this backend. |
| The possible values are: USE_ORIGIN_HEADERS, FORCE_CACHE_ALL and CACHE_ALL_STATIC Possible values: ["USE_ORIGIN_HEADERS", "FORCE_CACHE_ALL", "CACHE_ALL_STATIC"]`, |
| }, |
| "client_ttl": { |
| Type: schema.TypeInt, |
| Computed: true, |
| Optional: true, |
| Description: `Specifies the maximum allowed TTL for cached content served by this origin.`, |
| }, |
| "default_ttl": { |
| Type: schema.TypeInt, |
| Computed: true, |
| Optional: true, |
| Description: `Specifies the default TTL for cached content served by this origin for responses |
| that do not have an existing valid TTL (max-age or s-max-age).`, |
| }, |
| "max_ttl": { |
| Type: schema.TypeInt, |
| Computed: true, |
| Optional: true, |
| Description: `Specifies the maximum allowed TTL for cached content served by this origin.`, |
| }, |
| "negative_caching": { |
| Type: schema.TypeBool, |
| Computed: true, |
| Optional: true, |
| Description: `Negative caching allows per-status code TTLs to be set, in order to apply fine-grained caching for common errors or redirects.`, |
| }, |
| "negative_caching_policy": { |
| Type: schema.TypeList, |
| Optional: true, |
| Description: `Sets a cache TTL for the specified HTTP status code. negativeCaching must be enabled to configure negativeCachingPolicy. |
| Omitting the policy and leaving negativeCaching enabled will use Cloud CDN's default cache TTLs.`, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "code": { |
| Type: schema.TypeInt, |
| Optional: true, |
| Description: `The HTTP status code to define a TTL against. Only HTTP status codes 300, 301, 308, 404, 405, 410, 421, 451 and 501 |
| can be specified as values, and you cannot specify a status code more than once.`, |
| }, |
| "ttl": { |
| Type: schema.TypeInt, |
| Optional: true, |
| Description: `The TTL (in seconds) for which to cache responses with the corresponding status code. The maximum allowed value is 1800s |
| (30 minutes), noting that infrequently accessed objects may be evicted from the cache before the defined TTL.`, |
| }, |
| }, |
| }, |
| }, |
| "serve_while_stale": { |
| Type: schema.TypeInt, |
| Computed: true, |
| Optional: true, |
| Description: `Serve existing content from the cache (if available) when revalidating content with the origin, or when an error is encountered when refreshing the cache.`, |
| }, |
| "signed_url_cache_max_age_sec": { |
| Type: schema.TypeInt, |
| Optional: true, |
| Description: `Maximum number of seconds the response to a signed URL request |
| will be considered fresh, defaults to 1hr (3600s). After this |
| time period, the response will be revalidated before |
| being served. |
| |
| When serving responses to signed URL requests, Cloud CDN will |
| internally behave as though all responses from this backend had a |
| "Cache-Control: public, max-age=[TTL]" header, regardless of any |
| existing Cache-Control header. The actual headers served in |
| responses will not be altered.`, |
| Default: 3600, |
| AtLeastOneOf: []string{"cdn_policy.0.cache_key_policy", "cdn_policy.0.signed_url_cache_max_age_sec"}, |
| }, |
| }, |
| }, |
| }, |
| "circuit_breakers": { |
| Type: schema.TypeList, |
| Optional: true, |
| Description: `Settings controlling the volume of connections to a backend service. This field |
| is applicable only when the 'load_balancing_scheme' is set to INTERNAL_MANAGED |
| and the 'protocol' is set to HTTP, HTTPS, or HTTP2.`, |
| MaxItems: 1, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "connect_timeout": { |
| Type: schema.TypeList, |
| Optional: true, |
| Description: `The timeout for new network connections to hosts.`, |
| MaxItems: 1, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "seconds": { |
| Type: schema.TypeInt, |
| Required: true, |
| Description: `Span of time at a resolution of a second. |
| Must be from 0 to 315,576,000,000 inclusive.`, |
| }, |
| "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.`, |
| }, |
| }, |
| }, |
| AtLeastOneOf: []string{"circuit_breakers.0.connect_timeout", "circuit_breakers.0.max_requests_per_connection", "circuit_breakers.0.max_connections", "circuit_breakers.0.max_pending_requests", "circuit_breakers.0.max_requests", "circuit_breakers.0.max_retries"}, |
| }, |
| "max_connections": { |
| Type: schema.TypeInt, |
| Optional: true, |
| Description: `The maximum number of connections to the backend cluster. |
| Defaults to 1024.`, |
| Default: 1024, |
| AtLeastOneOf: []string{"circuit_breakers.0.connect_timeout", "circuit_breakers.0.max_requests_per_connection", "circuit_breakers.0.max_connections", "circuit_breakers.0.max_pending_requests", "circuit_breakers.0.max_requests", "circuit_breakers.0.max_retries"}, |
| }, |
| "max_pending_requests": { |
| Type: schema.TypeInt, |
| Optional: true, |
| Description: `The maximum number of pending requests to the backend cluster. |
| Defaults to 1024.`, |
| Default: 1024, |
| AtLeastOneOf: []string{"circuit_breakers.0.connect_timeout", "circuit_breakers.0.max_requests_per_connection", "circuit_breakers.0.max_connections", "circuit_breakers.0.max_pending_requests", "circuit_breakers.0.max_requests", "circuit_breakers.0.max_retries"}, |
| }, |
| "max_requests": { |
| Type: schema.TypeInt, |
| Optional: true, |
| Description: `The maximum number of parallel requests to the backend cluster. |
| Defaults to 1024.`, |
| Default: 1024, |
| AtLeastOneOf: []string{"circuit_breakers.0.connect_timeout", "circuit_breakers.0.max_requests_per_connection", "circuit_breakers.0.max_connections", "circuit_breakers.0.max_pending_requests", "circuit_breakers.0.max_requests", "circuit_breakers.0.max_retries"}, |
| }, |
| "max_requests_per_connection": { |
| Type: schema.TypeInt, |
| Optional: true, |
| Description: `Maximum requests for a single backend connection. This parameter |
| is respected by both the HTTP/1.1 and HTTP/2 implementations. If |
| not specified, there is no limit. Setting this parameter to 1 |
| will effectively disable keep alive.`, |
| AtLeastOneOf: []string{"circuit_breakers.0.connect_timeout", "circuit_breakers.0.max_requests_per_connection", "circuit_breakers.0.max_connections", "circuit_breakers.0.max_pending_requests", "circuit_breakers.0.max_requests", "circuit_breakers.0.max_retries"}, |
| }, |
| "max_retries": { |
| Type: schema.TypeInt, |
| Optional: true, |
| Description: `The maximum number of parallel retries to the backend cluster. |
| Defaults to 3.`, |
| Default: 3, |
| AtLeastOneOf: []string{"circuit_breakers.0.connect_timeout", "circuit_breakers.0.max_requests_per_connection", "circuit_breakers.0.max_connections", "circuit_breakers.0.max_pending_requests", "circuit_breakers.0.max_requests", "circuit_breakers.0.max_retries"}, |
| }, |
| }, |
| }, |
| }, |
| "connection_draining_timeout_sec": { |
| Type: schema.TypeInt, |
| Optional: true, |
| Description: `Time for which instance will be drained (not accept new |
| connections, but still work to finish started).`, |
| Default: 0, |
| }, |
| |
| "connection_tracking_policy": { |
| Type: schema.TypeList, |
| Optional: true, |
| Description: `Connection Tracking configuration for this BackendService. |
| This is available only for Layer 4 Internal Load Balancing and |
| Network Load Balancing.`, |
| MaxItems: 1, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "connection_persistence_on_unhealthy_backends": { |
| Type: schema.TypeString, |
| Optional: true, |
| ValidateFunc: verify.ValidateEnum([]string{"DEFAULT_FOR_PROTOCOL", "NEVER_PERSIST", "ALWAYS_PERSIST", ""}), |
| Description: `Specifies connection persistence when backends are unhealthy. |
| |
| If set to 'DEFAULT_FOR_PROTOCOL', the existing connections persist on |
| unhealthy backends only for connection-oriented protocols (TCP and SCTP) |
| and only if the Tracking Mode is PER_CONNECTION (default tracking mode) |
| or the Session Affinity is configured for 5-tuple. They do not persist |
| for UDP. |
| |
| If set to 'NEVER_PERSIST', after a backend becomes unhealthy, the existing |
| connections on the unhealthy backend are never persisted on the unhealthy |
| backend. They are always diverted to newly selected healthy backends |
| (unless all backends are unhealthy). |
| |
| If set to 'ALWAYS_PERSIST', existing connections always persist on |
| unhealthy backends regardless of protocol and session affinity. It is |
| generally not recommended to use this mode overriding the default. Default value: "DEFAULT_FOR_PROTOCOL" Possible values: ["DEFAULT_FOR_PROTOCOL", "NEVER_PERSIST", "ALWAYS_PERSIST"]`, |
| Default: "DEFAULT_FOR_PROTOCOL", |
| }, |
| "enable_strong_affinity": { |
| Type: schema.TypeBool, |
| Optional: true, |
| Description: `Enable Strong Session Affinity for Network Load Balancing. This option is not available publicly.`, |
| }, |
| "idle_timeout_sec": { |
| Type: schema.TypeInt, |
| Computed: true, |
| Optional: true, |
| Description: `Specifies how long to keep a Connection Tracking entry while there is |
| no matching traffic (in seconds). |
| |
| For L4 ILB the minimum(default) is 10 minutes and maximum is 16 hours. |
| |
| For NLB the minimum(default) is 60 seconds and the maximum is 16 hours.`, |
| }, |
| "tracking_mode": { |
| Type: schema.TypeString, |
| Optional: true, |
| ValidateFunc: verify.ValidateEnum([]string{"PER_CONNECTION", "PER_SESSION", ""}), |
| Description: `Specifies the key used for connection tracking. There are two options: |
| 'PER_CONNECTION': The Connection Tracking is performed as per the |
| Connection Key (default Hash Method) for the specific protocol. |
| |
| 'PER_SESSION': The Connection Tracking is performed as per the |
| configured Session Affinity. It matches the configured Session Affinity. Default value: "PER_CONNECTION" Possible values: ["PER_CONNECTION", "PER_SESSION"]`, |
| Default: "PER_CONNECTION", |
| }, |
| }, |
| }, |
| }, |
| "consistent_hash": { |
| Type: schema.TypeList, |
| Optional: true, |
| Description: `Consistent Hash-based load balancing can be used to provide soft session |
| affinity based on HTTP headers, cookies or other properties. This load balancing |
| policy is applicable only for HTTP connections. The affinity to a particular |
| destination host will be lost when one or more hosts are added/removed from the |
| destination service. This field specifies parameters that control consistent |
| hashing. |
| This field only applies when all of the following are true - |
| * 'load_balancing_scheme' is set to INTERNAL_MANAGED |
| * 'protocol' is set to HTTP, HTTPS, or HTTP2 |
| * 'locality_lb_policy' is set to MAGLEV or RING_HASH`, |
| MaxItems: 1, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "http_cookie": { |
| Type: schema.TypeList, |
| Optional: true, |
| Description: `Hash is based on HTTP Cookie. This field describes a HTTP cookie |
| that will be used as the hash key for the consistent hash load |
| balancer. If the cookie is not present, it will be generated. |
| This field is applicable if the sessionAffinity is set to HTTP_COOKIE.`, |
| MaxItems: 1, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "name": { |
| Type: schema.TypeString, |
| Optional: true, |
| Description: `Name of the cookie.`, |
| AtLeastOneOf: []string{"consistent_hash.0.http_cookie.0.ttl", "consistent_hash.0.http_cookie.0.name", "consistent_hash.0.http_cookie.0.path"}, |
| }, |
| "path": { |
| Type: schema.TypeString, |
| Optional: true, |
| Description: `Path to set for the cookie.`, |
| AtLeastOneOf: []string{"consistent_hash.0.http_cookie.0.ttl", "consistent_hash.0.http_cookie.0.name", "consistent_hash.0.http_cookie.0.path"}, |
| }, |
| "ttl": { |
| Type: schema.TypeList, |
| Optional: true, |
| Description: `Lifetime of the cookie.`, |
| MaxItems: 1, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "seconds": { |
| Type: schema.TypeInt, |
| Required: true, |
| Description: `Span of time at a resolution of a second. |
| Must be from 0 to 315,576,000,000 inclusive.`, |
| }, |
| "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.`, |
| }, |
| }, |
| }, |
| AtLeastOneOf: []string{"consistent_hash.0.http_cookie.0.ttl", "consistent_hash.0.http_cookie.0.name", "consistent_hash.0.http_cookie.0.path"}, |
| }, |
| }, |
| }, |
| AtLeastOneOf: []string{"consistent_hash.0.http_cookie", "consistent_hash.0.http_header_name", "consistent_hash.0.minimum_ring_size"}, |
| }, |
| "http_header_name": { |
| Type: schema.TypeString, |
| Optional: true, |
| Description: `The hash based on the value of the specified header field. |
| This field is applicable if the sessionAffinity is set to HEADER_FIELD.`, |
| AtLeastOneOf: []string{"consistent_hash.0.http_cookie", "consistent_hash.0.http_header_name", "consistent_hash.0.minimum_ring_size"}, |
| }, |
| "minimum_ring_size": { |
| Type: schema.TypeInt, |
| Optional: true, |
| Description: `The minimum number of virtual nodes to use for the hash ring. |
| Larger ring sizes result in more granular load |
| distributions. If the number of hosts in the load balancing pool |
| is larger than the ring size, each host will be assigned a single |
| virtual node. |
| Defaults to 1024.`, |
| Default: 1024, |
| AtLeastOneOf: []string{"consistent_hash.0.http_cookie", "consistent_hash.0.http_header_name", "consistent_hash.0.minimum_ring_size"}, |
| }, |
| }, |
| }, |
| }, |
| "description": { |
| Type: schema.TypeString, |
| Optional: true, |
| Description: `An optional description of this resource.`, |
| }, |
| "enable_cdn": { |
| Type: schema.TypeBool, |
| Optional: true, |
| Description: `If true, enable Cloud CDN for this RegionBackendService.`, |
| }, |
| "failover_policy": { |
| Type: schema.TypeList, |
| Optional: true, |
| Description: `Policy for failovers.`, |
| MaxItems: 1, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "disable_connection_drain_on_failover": { |
| Type: schema.TypeBool, |
| Computed: true, |
| Optional: true, |
| Description: `On failover or failback, this field indicates whether connection drain |
| will be honored. Setting this to true has the following effect: connections |
| to the old active pool are not drained. Connections to the new active pool |
| use the timeout of 10 min (currently fixed). Setting to false has the |
| following effect: both old and new connections will have a drain timeout |
| of 10 min. |
| This can be set to true only if the protocol is TCP. |
| The default is false.`, |
| AtLeastOneOf: []string{"failover_policy.0.disable_connection_drain_on_failover", "failover_policy.0.drop_traffic_if_unhealthy", "failover_policy.0.failover_ratio"}, |
| }, |
| "drop_traffic_if_unhealthy": { |
| Type: schema.TypeBool, |
| Computed: true, |
| Optional: true, |
| Description: `This option is used only when no healthy VMs are detected in the primary |
| and backup instance groups. When set to true, traffic is dropped. When |
| set to false, new connections are sent across all VMs in the primary group. |
| The default is false.`, |
| AtLeastOneOf: []string{"failover_policy.0.disable_connection_drain_on_failover", "failover_policy.0.drop_traffic_if_unhealthy", "failover_policy.0.failover_ratio"}, |
| }, |
| "failover_ratio": { |
| Type: schema.TypeFloat, |
| Optional: true, |
| Description: `The value of the field must be in [0, 1]. If the ratio of the healthy |
| VMs in the primary backend is at or below this number, traffic arriving |
| at the load-balanced IP will be directed to the failover backend. |
| In case where 'failoverRatio' is not set or all the VMs in the backup |
| backend are unhealthy, the traffic will be directed back to the primary |
| backend in the "force" mode, where traffic will be spread to the healthy |
| VMs with the best effort, or to all VMs when no VM is healthy. |
| This field is only used with l4 load balancing.`, |
| AtLeastOneOf: []string{"failover_policy.0.disable_connection_drain_on_failover", "failover_policy.0.drop_traffic_if_unhealthy", "failover_policy.0.failover_ratio"}, |
| }, |
| }, |
| }, |
| }, |
| "health_checks": { |
| Type: schema.TypeSet, |
| Optional: true, |
| Description: `The set of URLs to HealthCheck resources for health checking |
| this RegionBackendService. Currently at most one health |
| check can be specified. |
| |
| A health check must be specified unless the backend service uses an internet |
| or serverless NEG as a backend.`, |
| MinItems: 1, |
| MaxItems: 1, |
| Elem: &schema.Schema{ |
| Type: schema.TypeString, |
| }, |
| Set: tpgresource.SelfLinkRelativePathHash, |
| }, |
| "iap": { |
| Type: schema.TypeList, |
| Optional: true, |
| Description: `Settings for enabling Cloud Identity Aware Proxy`, |
| MaxItems: 1, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "oauth2_client_id": { |
| Type: schema.TypeString, |
| Required: true, |
| Description: `OAuth2 Client ID for IAP`, |
| }, |
| "oauth2_client_secret": { |
| Type: schema.TypeString, |
| Required: true, |
| Description: `OAuth2 Client Secret for IAP`, |
| Sensitive: true, |
| }, |
| "oauth2_client_secret_sha256": { |
| Type: schema.TypeString, |
| Computed: true, |
| Description: `OAuth2 Client Secret SHA-256 for IAP`, |
| Sensitive: true, |
| }, |
| }, |
| }, |
| }, |
| "load_balancing_scheme": { |
| Type: schema.TypeString, |
| Optional: true, |
| ForceNew: true, |
| ValidateFunc: verify.ValidateEnum([]string{"EXTERNAL", "EXTERNAL_MANAGED", "INTERNAL", "INTERNAL_MANAGED", ""}), |
| Description: `Indicates what kind of load balancing this regional backend service |
| will be used for. A backend service created for one type of load |
| balancing cannot be used with the other(s). For more information, refer to |
| [Choosing a load balancer](https://cloud.google.com/load-balancing/docs/backend-service). Default value: "INTERNAL" Possible values: ["EXTERNAL", "EXTERNAL_MANAGED", "INTERNAL", "INTERNAL_MANAGED"]`, |
| Default: "INTERNAL", |
| }, |
| "locality_lb_policy": { |
| Type: schema.TypeString, |
| Optional: true, |
| ValidateFunc: verify.ValidateEnum([]string{"ROUND_ROBIN", "LEAST_REQUEST", "RING_HASH", "RANDOM", "ORIGINAL_DESTINATION", "MAGLEV", "WEIGHTED_MAGLEV", ""}), |
| Description: `The load balancing algorithm used within the scope of the locality. |
| The possible values are: |
| |
| * 'ROUND_ROBIN': This is a simple policy in which each healthy backend |
| is selected in round robin order. |
| |
| * 'LEAST_REQUEST': An O(1) algorithm which selects two random healthy |
| hosts and picks the host which has fewer active requests. |
| |
| * 'RING_HASH': The ring/modulo hash load balancer implements consistent |
| hashing to backends. The algorithm has the property that the |
| addition/removal of a host from a set of N hosts only affects |
| 1/N of the requests. |
| |
| * 'RANDOM': The load balancer selects a random healthy host. |
| |
| * 'ORIGINAL_DESTINATION': Backend host is selected based on the client |
| connection metadata, i.e., connections are opened |
| to the same address as the destination address of |
| the incoming connection before the connection |
| was redirected to the load balancer. |
| |
| * 'MAGLEV': used as a drop in replacement for the ring hash load balancer. |
| Maglev is not as stable as ring hash but has faster table lookup |
| build times and host selection times. For more information about |
| Maglev, refer to https://ai.google/research/pubs/pub44824 |
| |
| * 'WEIGHTED_MAGLEV': Per-instance weighted Load Balancing via health check |
| reported weights. If set, the Backend Service must |
| configure a non legacy HTTP-based Health Check, and |
| health check replies are expected to contain |
| non-standard HTTP response header field |
| X-Load-Balancing-Endpoint-Weight to specify the |
| per-instance weights. If set, Load Balancing is weight |
| based on the per-instance weights reported in the last |
| processed health check replies, as long as every |
| instance either reported a valid weight or had |
| UNAVAILABLE_WEIGHT. Otherwise, Load Balancing remains |
| equal-weight. |
| |
| |
| This field is applicable to either: |
| |
| * A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, |
| and loadBalancingScheme set to INTERNAL_MANAGED. |
| * A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. |
| * A regional backend service with loadBalancingScheme set to EXTERNAL (External Network |
| Load Balancing). Only MAGLEV and WEIGHTED_MAGLEV values are possible for External |
| Network Load Balancing. The default is MAGLEV. |
| |
| |
| If session_affinity is not NONE, and this field is not set to MAGLEV, WEIGHTED_MAGLEV, |
| or RING_HASH, session affinity settings will not take effect. |
| |
| Only ROUND_ROBIN and RING_HASH are supported when the backend service is referenced |
| by a URL map that is bound to target gRPC proxy that has validate_for_proxyless |
| field set to true. Possible values: ["ROUND_ROBIN", "LEAST_REQUEST", "RING_HASH", "RANDOM", "ORIGINAL_DESTINATION", "MAGLEV", "WEIGHTED_MAGLEV"]`, |
| }, |
| "log_config": { |
| Type: schema.TypeList, |
| Computed: true, |
| Optional: true, |
| Description: `This field denotes the logging options for the load balancer traffic served by this backend service. |
| If logging is enabled, logs will be exported to Stackdriver.`, |
| MaxItems: 1, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "enable": { |
| Type: schema.TypeBool, |
| Optional: true, |
| 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"}, |
| }, |
| "sample_rate": { |
| Type: schema.TypeFloat, |
| Optional: true, |
| DiffSuppressFunc: suppressWhenDisabled, |
| Description: `This field can only be specified if logging is enabled for this backend service. The value of |
| the field must be in [0, 1]. This configures the sampling rate of requests to the load balancer |
| where 1.0 means all logged requests are reported and 0.0 means no logged requests are reported. |
| The default value is 1.0.`, |
| Default: 1.0, |
| AtLeastOneOf: []string{"log_config.0.enable", "log_config.0.sample_rate"}, |
| }, |
| }, |
| }, |
| }, |
| "network": { |
| Type: schema.TypeString, |
| Optional: true, |
| DiffSuppressFunc: tpgresource.CompareSelfLinkOrResourceName, |
| Description: `The URL of the network to which this backend service belongs. |
| This field can only be specified when the load balancing scheme is set to INTERNAL.`, |
| }, |
| "outlier_detection": { |
| Type: schema.TypeList, |
| Optional: true, |
| Description: `Settings controlling eviction of unhealthy hosts from the load balancing pool. |
| This field is applicable only when the 'load_balancing_scheme' is set |
| to INTERNAL_MANAGED and the 'protocol' is set to HTTP, HTTPS, or HTTP2.`, |
| MaxItems: 1, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "base_ejection_time": { |
| Type: schema.TypeList, |
| Optional: true, |
| Description: `The base time that a host is ejected for. The real time is equal to the base |
| time multiplied by the number of times the host has been ejected. Defaults to |
| 30000ms or 30s.`, |
| MaxItems: 1, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "seconds": { |
| Type: schema.TypeInt, |
| Required: true, |
| Description: `Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 |
| inclusive.`, |
| }, |
| "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.`, |
| }, |
| }, |
| }, |
| AtLeastOneOf: []string{"outlier_detection.0.base_ejection_time", "outlier_detection.0.consecutive_errors", "outlier_detection.0.consecutive_gateway_failure", "outlier_detection.0.enforcing_consecutive_errors", "outlier_detection.0.enforcing_consecutive_gateway_failure", "outlier_detection.0.enforcing_success_rate", "outlier_detection.0.interval", "outlier_detection.0.max_ejection_percent", "outlier_detection.0.success_rate_minimum_hosts", "outlier_detection.0.success_rate_request_volume", "outlier_detection.0.success_rate_stdev_factor"}, |
| }, |
| "consecutive_errors": { |
| Type: schema.TypeInt, |
| Optional: true, |
| Description: `Number of errors before a host is ejected from the connection pool. When the |
| backend host is accessed over HTTP, a 5xx return code qualifies as an error. |
| Defaults to 5.`, |
| Default: 5, |
| AtLeastOneOf: []string{"outlier_detection.0.base_ejection_time", "outlier_detection.0.consecutive_errors", "outlier_detection.0.consecutive_gateway_failure", "outlier_detection.0.enforcing_consecutive_errors", "outlier_detection.0.enforcing_consecutive_gateway_failure", "outlier_detection.0.enforcing_success_rate", "outlier_detection.0.interval", "outlier_detection.0.max_ejection_percent", "outlier_detection.0.success_rate_minimum_hosts", "outlier_detection.0.success_rate_request_volume", "outlier_detection.0.success_rate_stdev_factor"}, |
| }, |
| "consecutive_gateway_failure": { |
| Type: schema.TypeInt, |
| Optional: true, |
| Description: `The number of consecutive gateway failures (502, 503, 504 status or connection |
| errors that are mapped to one of those status codes) before a consecutive |
| gateway failure ejection occurs. Defaults to 5.`, |
| Default: 5, |
| AtLeastOneOf: []string{"outlier_detection.0.base_ejection_time", "outlier_detection.0.consecutive_errors", "outlier_detection.0.consecutive_gateway_failure", "outlier_detection.0.enforcing_consecutive_errors", "outlier_detection.0.enforcing_consecutive_gateway_failure", "outlier_detection.0.enforcing_success_rate", "outlier_detection.0.interval", "outlier_detection.0.max_ejection_percent", "outlier_detection.0.success_rate_minimum_hosts", "outlier_detection.0.success_rate_request_volume", "outlier_detection.0.success_rate_stdev_factor"}, |
| }, |
| "enforcing_consecutive_errors": { |
| Type: schema.TypeInt, |
| Optional: true, |
| Description: `The percentage chance that a host will be actually ejected when an outlier |
| status is detected through consecutive 5xx. This setting can be used to disable |
| ejection or to ramp it up slowly. Defaults to 100.`, |
| Default: 100, |
| AtLeastOneOf: []string{"outlier_detection.0.base_ejection_time", "outlier_detection.0.consecutive_errors", "outlier_detection.0.consecutive_gateway_failure", "outlier_detection.0.enforcing_consecutive_errors", "outlier_detection.0.enforcing_consecutive_gateway_failure", "outlier_detection.0.enforcing_success_rate", "outlier_detection.0.interval", "outlier_detection.0.max_ejection_percent", "outlier_detection.0.success_rate_minimum_hosts", "outlier_detection.0.success_rate_request_volume", "outlier_detection.0.success_rate_stdev_factor"}, |
| }, |
| "enforcing_consecutive_gateway_failure": { |
| Type: schema.TypeInt, |
| Optional: true, |
| Description: `The percentage chance that a host will be actually ejected when an outlier |
| status is detected through consecutive gateway failures. This setting can be |
| used to disable ejection or to ramp it up slowly. Defaults to 0.`, |
| Default: 0, |
| AtLeastOneOf: []string{"outlier_detection.0.base_ejection_time", "outlier_detection.0.consecutive_errors", "outlier_detection.0.consecutive_gateway_failure", "outlier_detection.0.enforcing_consecutive_errors", "outlier_detection.0.enforcing_consecutive_gateway_failure", "outlier_detection.0.enforcing_success_rate", "outlier_detection.0.interval", "outlier_detection.0.max_ejection_percent", "outlier_detection.0.success_rate_minimum_hosts", "outlier_detection.0.success_rate_request_volume", "outlier_detection.0.success_rate_stdev_factor"}, |
| }, |
| "enforcing_success_rate": { |
| Type: schema.TypeInt, |
| Optional: true, |
| Description: `The percentage chance that a host will be actually ejected when an outlier |
| status is detected through success rate statistics. This setting can be used to |
| disable ejection or to ramp it up slowly. Defaults to 100.`, |
| Default: 100, |
| AtLeastOneOf: []string{"outlier_detection.0.base_ejection_time", "outlier_detection.0.consecutive_errors", "outlier_detection.0.consecutive_gateway_failure", "outlier_detection.0.enforcing_consecutive_errors", "outlier_detection.0.enforcing_consecutive_gateway_failure", "outlier_detection.0.enforcing_success_rate", "outlier_detection.0.interval", "outlier_detection.0.max_ejection_percent", "outlier_detection.0.success_rate_minimum_hosts", "outlier_detection.0.success_rate_request_volume", "outlier_detection.0.success_rate_stdev_factor"}, |
| }, |
| "interval": { |
| Type: schema.TypeList, |
| Optional: true, |
| Description: `Time interval between ejection sweep analysis. This can result in both new |
| ejections as well as hosts being returned to service. Defaults to 10 seconds.`, |
| MaxItems: 1, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "seconds": { |
| Type: schema.TypeInt, |
| Required: true, |
| Description: `Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 |
| inclusive.`, |
| }, |
| "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.`, |
| }, |
| }, |
| }, |
| AtLeastOneOf: []string{"outlier_detection.0.base_ejection_time", "outlier_detection.0.consecutive_errors", "outlier_detection.0.consecutive_gateway_failure", "outlier_detection.0.enforcing_consecutive_errors", "outlier_detection.0.enforcing_consecutive_gateway_failure", "outlier_detection.0.enforcing_success_rate", "outlier_detection.0.interval", "outlier_detection.0.max_ejection_percent", "outlier_detection.0.success_rate_minimum_hosts", "outlier_detection.0.success_rate_request_volume", "outlier_detection.0.success_rate_stdev_factor"}, |
| }, |
| "max_ejection_percent": { |
| Type: schema.TypeInt, |
| Optional: true, |
| Description: `Maximum percentage of hosts in the load balancing pool for the backend service |
| that can be ejected. Defaults to 10%.`, |
| Default: 10, |
| AtLeastOneOf: []string{"outlier_detection.0.base_ejection_time", "outlier_detection.0.consecutive_errors", "outlier_detection.0.consecutive_gateway_failure", "outlier_detection.0.enforcing_consecutive_errors", "outlier_detection.0.enforcing_consecutive_gateway_failure", "outlier_detection.0.enforcing_success_rate", "outlier_detection.0.interval", "outlier_detection.0.max_ejection_percent", "outlier_detection.0.success_rate_minimum_hosts", "outlier_detection.0.success_rate_request_volume", "outlier_detection.0.success_rate_stdev_factor"}, |
| }, |
| "success_rate_minimum_hosts": { |
| Type: schema.TypeInt, |
| Optional: true, |
| Description: `The number of hosts in a cluster that must have enough request volume to detect |
| success rate outliers. If the number of hosts is less than this setting, outlier |
| detection via success rate statistics is not performed for any host in the |
| cluster. Defaults to 5.`, |
| Default: 5, |
| AtLeastOneOf: []string{"outlier_detection.0.base_ejection_time", "outlier_detection.0.consecutive_errors", "outlier_detection.0.consecutive_gateway_failure", "outlier_detection.0.enforcing_consecutive_errors", "outlier_detection.0.enforcing_consecutive_gateway_failure", "outlier_detection.0.enforcing_success_rate", "outlier_detection.0.interval", "outlier_detection.0.max_ejection_percent", "outlier_detection.0.success_rate_minimum_hosts", "outlier_detection.0.success_rate_request_volume", "outlier_detection.0.success_rate_stdev_factor"}, |
| }, |
| "success_rate_request_volume": { |
| Type: schema.TypeInt, |
| Optional: true, |
| Description: `The minimum number of total requests that must be collected in one interval (as |
| defined by the interval duration above) to include this host in success rate |
| based outlier detection. If the volume is lower than this setting, outlier |
| detection via success rate statistics is not performed for that host. Defaults |
| to 100.`, |
| Default: 100, |
| AtLeastOneOf: []string{"outlier_detection.0.base_ejection_time", "outlier_detection.0.consecutive_errors", "outlier_detection.0.consecutive_gateway_failure", "outlier_detection.0.enforcing_consecutive_errors", "outlier_detection.0.enforcing_consecutive_gateway_failure", "outlier_detection.0.enforcing_success_rate", "outlier_detection.0.interval", "outlier_detection.0.max_ejection_percent", "outlier_detection.0.success_rate_minimum_hosts", "outlier_detection.0.success_rate_request_volume", "outlier_detection.0.success_rate_stdev_factor"}, |
| }, |
| "success_rate_stdev_factor": { |
| Type: schema.TypeInt, |
| Optional: true, |
| Description: `This factor is used to determine the ejection threshold for success rate outlier |
| ejection. The ejection threshold is the difference between the mean success |
| rate, and the product of this factor and the standard deviation of the mean |
| success rate: mean - (stdev * success_rate_stdev_factor). This factor is divided |
| by a thousand to get a double. That is, if the desired factor is 1.9, the |
| runtime value should be 1900. Defaults to 1900.`, |
| Default: 1900, |
| AtLeastOneOf: []string{"outlier_detection.0.base_ejection_time", "outlier_detection.0.consecutive_errors", "outlier_detection.0.consecutive_gateway_failure", "outlier_detection.0.enforcing_consecutive_errors", "outlier_detection.0.enforcing_consecutive_gateway_failure", "outlier_detection.0.enforcing_success_rate", "outlier_detection.0.interval", "outlier_detection.0.max_ejection_percent", "outlier_detection.0.success_rate_minimum_hosts", "outlier_detection.0.success_rate_request_volume", "outlier_detection.0.success_rate_stdev_factor"}, |
| }, |
| }, |
| }, |
| }, |
| "port_name": { |
| Type: schema.TypeString, |
| Computed: true, |
| Optional: true, |
| Description: `A named port on a backend instance group representing the port for |
| communication to the backend VMs in that group. Required when the |
| loadBalancingScheme is EXTERNAL, EXTERNAL_MANAGED, INTERNAL_MANAGED, or INTERNAL_SELF_MANAGED |
| and the backends are instance groups. The named port must be defined on each |
| backend instance group. This parameter has no meaning if the backends are NEGs. API sets a |
| default of "http" if not given. |
| Must be omitted when the loadBalancingScheme is INTERNAL (Internal TCP/UDP Load Balancing).`, |
| }, |
| "protocol": { |
| Type: schema.TypeString, |
| Computed: true, |
| Optional: true, |
| ValidateFunc: verify.ValidateEnum([]string{"HTTP", "HTTPS", "HTTP2", "SSL", "TCP", "UDP", "GRPC", "UNSPECIFIED", ""}), |
| Description: `The protocol this RegionBackendService uses to communicate with backends. |
| The default is HTTP. **NOTE**: HTTP2 is only valid for beta HTTP/2 load balancer |
| types and may result in errors if used with the GA API. Possible values: ["HTTP", "HTTPS", "HTTP2", "SSL", "TCP", "UDP", "GRPC", "UNSPECIFIED"]`, |
| }, |
| "region": { |
| Type: schema.TypeString, |
| Computed: true, |
| Optional: true, |
| DiffSuppressFunc: tpgresource.CompareSelfLinkOrResourceName, |
| Description: `The Region in which the created backend service should reside. |
| If it is not provided, the provider region is used.`, |
| }, |
| "security_policy": { |
| Type: schema.TypeString, |
| Optional: true, |
| DiffSuppressFunc: tpgresource.CompareSelfLinkOrResourceName, |
| Description: `The security policy associated with this backend service.`, |
| }, |
| "session_affinity": { |
| Type: schema.TypeString, |
| Computed: true, |
| Optional: true, |
| ValidateFunc: verify.ValidateEnum([]string{"NONE", "CLIENT_IP", "CLIENT_IP_PORT_PROTO", "CLIENT_IP_PROTO", "GENERATED_COOKIE", "HEADER_FIELD", "HTTP_COOKIE", "CLIENT_IP_NO_DESTINATION", ""}), |
| Description: `Type of session affinity to use. The default is NONE. Session affinity is |
| not applicable if the protocol is UDP. Possible values: ["NONE", "CLIENT_IP", "CLIENT_IP_PORT_PROTO", "CLIENT_IP_PROTO", "GENERATED_COOKIE", "HEADER_FIELD", "HTTP_COOKIE", "CLIENT_IP_NO_DESTINATION"]`, |
| }, |
| "subsetting": { |
| Type: schema.TypeList, |
| Optional: true, |
| Description: `Subsetting configuration for this BackendService. Currently this is applicable only for Internal TCP/UDP load balancing and Internal HTTP(S) load balancing.`, |
| MaxItems: 1, |
| Elem: &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "policy": { |
| Type: schema.TypeString, |
| Required: true, |
| ValidateFunc: verify.ValidateEnum([]string{"CONSISTENT_HASH_SUBSETTING"}), |
| Description: `The algorithm used for subsetting. Possible values: ["CONSISTENT_HASH_SUBSETTING"]`, |
| }, |
| }, |
| }, |
| }, |
| "timeout_sec": { |
| Type: schema.TypeInt, |
| Computed: true, |
| Optional: true, |
| Description: `How many seconds to wait for the backend before considering it a |
| failed request. Default is 30 seconds. Valid range is [1, 86400].`, |
| }, |
| "creation_timestamp": { |
| Type: schema.TypeString, |
| Computed: true, |
| Description: `Creation timestamp in RFC3339 text format.`, |
| }, |
| "fingerprint": { |
| Type: schema.TypeString, |
| Computed: true, |
| Description: `Fingerprint of this resource. A hash of the contents stored in this |
| object. This field is used in optimistic locking.`, |
| }, |
| "project": { |
| Type: schema.TypeString, |
| Optional: true, |
| Computed: true, |
| ForceNew: true, |
| }, |
| "self_link": { |
| Type: schema.TypeString, |
| Computed: true, |
| }, |
| }, |
| UseJSONNumber: true, |
| } |
| } |
| |
| func computeRegionBackendServiceBackendSchema() *schema.Resource { |
| return &schema.Resource{ |
| Schema: map[string]*schema.Schema{ |
| "group": { |
| Type: schema.TypeString, |
| Required: true, |
| DiffSuppressFunc: tpgresource.CompareSelfLinkRelativePaths, |
| Description: `The fully-qualified URL of an Instance Group or Network Endpoint |
| Group resource. In case of instance group this defines the list |
| of instances that serve traffic. Member virtual machine |
| instances from each instance group must live in the same zone as |
| the instance group itself. No two backends in a backend service |
| are allowed to use same Instance Group resource. |
| |
| For Network Endpoint Groups this defines list of endpoints. All |
| endpoints of Network Endpoint Group must be hosted on instances |
| located in the same zone as the Network Endpoint Group. |
| |
| Backend services cannot mix Instance Group and |
| Network Endpoint Group backends. |
| |
| When the 'load_balancing_scheme' is INTERNAL, only instance groups |
| are supported. |
| |
| Note that you must specify an Instance Group or Network Endpoint |
| Group resource using the fully-qualified URL, rather than a |
| partial URL.`, |
| }, |
| "balancing_mode": { |
| Type: schema.TypeString, |
| Optional: true, |
| ValidateFunc: verify.ValidateEnum([]string{"UTILIZATION", "RATE", "CONNECTION", ""}), |
| Description: `Specifies the balancing mode for this backend. |
| |
| See the [Backend Services Overview](https://cloud.google.com/load-balancing/docs/backend-service#balancing-mode) |
| for an explanation of load balancing modes. Default value: "CONNECTION" Possible values: ["UTILIZATION", "RATE", "CONNECTION"]`, |
| Default: "CONNECTION", |
| }, |
| "capacity_scaler": { |
| Type: schema.TypeFloat, |
| Optional: true, |
| Description: `A multiplier applied to the group's maximum servicing capacity |
| (based on UTILIZATION, RATE or CONNECTION). |
| |
| ~>**NOTE**: This field cannot be set for |
| INTERNAL region backend services (default loadBalancingScheme), |
| but is required for non-INTERNAL backend service. The total |
| capacity_scaler for all backends must be non-zero. |
| |
| A setting of 0 means the group is completely drained, offering |
| 0% of its available Capacity. Valid range is [0.0,1.0].`, |
| }, |
| "description": { |
| Type: schema.TypeString, |
| Optional: true, |
| Description: `An optional description of this resource. |
| Provide this property when you create the resource.`, |
| }, |
| "failover": { |
| Type: schema.TypeBool, |
| Computed: true, |
| Optional: true, |
| Description: `This field designates whether this is a failover backend. More |
| than one failover backend can be configured for a given RegionBackendService.`, |
| }, |
| "max_connections": { |
| Type: schema.TypeInt, |
| Optional: true, |
| Description: `The max number of simultaneous connections for the group. Can |
| be used with either CONNECTION or UTILIZATION balancing modes. |
| Cannot be set for INTERNAL backend services. |
| |
| For CONNECTION mode, either maxConnections or one |
| of maxConnectionsPerInstance or maxConnectionsPerEndpoint, |
| as appropriate for group type, must be set.`, |
| }, |
| "max_connections_per_endpoint": { |
| Type: schema.TypeInt, |
| Optional: true, |
| Description: `The max number of simultaneous connections that a single backend |
| network endpoint can handle. Cannot be set |
| for INTERNAL backend services. |
| |
| This is used to calculate the capacity of the group. Can be |
| used in either CONNECTION or UTILIZATION balancing modes. For |
| CONNECTION mode, either maxConnections or |
| maxConnectionsPerEndpoint must be set.`, |
| }, |
| "max_connections_per_instance": { |
| Type: schema.TypeInt, |
| Optional: true, |
| Description: `The max number of simultaneous connections that a single |
| backend instance can handle. Cannot be set for INTERNAL backend |
| services. |
| |
| This is used to calculate the capacity of the group. |
| Can be used in either CONNECTION or UTILIZATION balancing modes. |
| For CONNECTION mode, either maxConnections or |
| maxConnectionsPerInstance must be set.`, |
| }, |
| "max_rate": { |
| Type: schema.TypeInt, |
| Optional: true, |
| Description: `The max requests per second (RPS) of the group. Cannot be set |
| for INTERNAL backend services. |
| |
| Can be used with either RATE or UTILIZATION balancing modes, |
| but required if RATE mode. Either maxRate or one |
| of maxRatePerInstance or maxRatePerEndpoint, as appropriate for |
| group type, must be set.`, |
| }, |
| "max_rate_per_endpoint": { |
| Type: schema.TypeFloat, |
| Optional: true, |
| Description: `The max requests per second (RPS) that a single backend network |
| endpoint can handle. This is used to calculate the capacity of |
| the group. Can be used in either balancing mode. For RATE mode, |
| either maxRate or maxRatePerEndpoint must be set. Cannot be set |
| for INTERNAL backend services.`, |
| }, |
| "max_rate_per_instance": { |
| Type: schema.TypeFloat, |
| Optional: true, |
| Description: `The max requests per second (RPS) that a single backend |
| instance can handle. This is used to calculate the capacity of |
| the group. Can be used in either balancing mode. For RATE mode, |
| either maxRate or maxRatePerInstance must be set. Cannot be set |
| for INTERNAL backend services.`, |
| }, |
| "max_utilization": { |
| Type: schema.TypeFloat, |
| Optional: true, |
| Description: `Used when balancingMode is UTILIZATION. This ratio defines the |
| CPU utilization target for the group. Valid range is [0.0, 1.0]. |
| Cannot be set for INTERNAL backend services.`, |
| }, |
| }, |
| } |
| } |
| |
| func resourceComputeRegionBackendServiceCreate(d *schema.ResourceData, meta interface{}) error { |
| config := meta.(*transport_tpg.Config) |
| userAgent, err := tpgresource.GenerateUserAgentString(d, config.UserAgent) |
| if err != nil { |
| return err |
| } |
| |
| obj := make(map[string]interface{}) |
| affinityCookieTtlSecProp, err := expandComputeRegionBackendServiceAffinityCookieTtlSec(d.Get("affinity_cookie_ttl_sec"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("affinity_cookie_ttl_sec"); !tpgresource.IsEmptyValue(reflect.ValueOf(affinityCookieTtlSecProp)) && (ok || !reflect.DeepEqual(v, affinityCookieTtlSecProp)) { |
| obj["affinityCookieTtlSec"] = affinityCookieTtlSecProp |
| } |
| backendsProp, err := expandComputeRegionBackendServiceBackend(d.Get("backend"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("backend"); !tpgresource.IsEmptyValue(reflect.ValueOf(backendsProp)) && (ok || !reflect.DeepEqual(v, backendsProp)) { |
| obj["backends"] = backendsProp |
| } |
| circuitBreakersProp, err := expandComputeRegionBackendServiceCircuitBreakers(d.Get("circuit_breakers"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("circuit_breakers"); !tpgresource.IsEmptyValue(reflect.ValueOf(circuitBreakersProp)) && (ok || !reflect.DeepEqual(v, circuitBreakersProp)) { |
| obj["circuitBreakers"] = circuitBreakersProp |
| } |
| consistentHashProp, err := expandComputeRegionBackendServiceConsistentHash(d.Get("consistent_hash"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("consistent_hash"); !tpgresource.IsEmptyValue(reflect.ValueOf(consistentHashProp)) && (ok || !reflect.DeepEqual(v, consistentHashProp)) { |
| obj["consistentHash"] = consistentHashProp |
| } |
| cdnPolicyProp, err := expandComputeRegionBackendServiceCdnPolicy(d.Get("cdn_policy"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("cdn_policy"); !tpgresource.IsEmptyValue(reflect.ValueOf(cdnPolicyProp)) && (ok || !reflect.DeepEqual(v, cdnPolicyProp)) { |
| obj["cdnPolicy"] = cdnPolicyProp |
| } |
| connectionDrainingProp, err := expandComputeRegionBackendServiceConnectionDraining(nil, d, config) |
| if err != nil { |
| return err |
| } else if !tpgresource.IsEmptyValue(reflect.ValueOf(connectionDrainingProp)) { |
| obj["connectionDraining"] = connectionDrainingProp |
| } |
| descriptionProp, err := expandComputeRegionBackendServiceDescription(d.Get("description"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("description"); !tpgresource.IsEmptyValue(reflect.ValueOf(descriptionProp)) && (ok || !reflect.DeepEqual(v, descriptionProp)) { |
| obj["description"] = descriptionProp |
| } |
| failoverPolicyProp, err := expandComputeRegionBackendServiceFailoverPolicy(d.Get("failover_policy"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("failover_policy"); !tpgresource.IsEmptyValue(reflect.ValueOf(failoverPolicyProp)) && (ok || !reflect.DeepEqual(v, failoverPolicyProp)) { |
| obj["failoverPolicy"] = failoverPolicyProp |
| } |
| enableCDNProp, err := expandComputeRegionBackendServiceEnableCDN(d.Get("enable_cdn"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("enable_cdn"); !tpgresource.IsEmptyValue(reflect.ValueOf(enableCDNProp)) && (ok || !reflect.DeepEqual(v, enableCDNProp)) { |
| obj["enableCDN"] = enableCDNProp |
| } |
| fingerprintProp, err := expandComputeRegionBackendServiceFingerprint(d.Get("fingerprint"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("fingerprint"); !tpgresource.IsEmptyValue(reflect.ValueOf(fingerprintProp)) && (ok || !reflect.DeepEqual(v, fingerprintProp)) { |
| obj["fingerprint"] = fingerprintProp |
| } |
| healthChecksProp, err := expandComputeRegionBackendServiceHealthChecks(d.Get("health_checks"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("health_checks"); !tpgresource.IsEmptyValue(reflect.ValueOf(healthChecksProp)) && (ok || !reflect.DeepEqual(v, healthChecksProp)) { |
| obj["healthChecks"] = healthChecksProp |
| } |
| iapProp, err := expandComputeRegionBackendServiceIap(d.Get("iap"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("iap"); ok || !reflect.DeepEqual(v, iapProp) { |
| obj["iap"] = iapProp |
| } |
| loadBalancingSchemeProp, err := expandComputeRegionBackendServiceLoadBalancingScheme(d.Get("load_balancing_scheme"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("load_balancing_scheme"); !tpgresource.IsEmptyValue(reflect.ValueOf(loadBalancingSchemeProp)) && (ok || !reflect.DeepEqual(v, loadBalancingSchemeProp)) { |
| obj["loadBalancingScheme"] = loadBalancingSchemeProp |
| } |
| localityLbPolicyProp, err := expandComputeRegionBackendServiceLocalityLbPolicy(d.Get("locality_lb_policy"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("locality_lb_policy"); !tpgresource.IsEmptyValue(reflect.ValueOf(localityLbPolicyProp)) && (ok || !reflect.DeepEqual(v, localityLbPolicyProp)) { |
| obj["localityLbPolicy"] = localityLbPolicyProp |
| } |
| nameProp, err := expandComputeRegionBackendServiceName(d.Get("name"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("name"); !tpgresource.IsEmptyValue(reflect.ValueOf(nameProp)) && (ok || !reflect.DeepEqual(v, nameProp)) { |
| obj["name"] = nameProp |
| } |
| outlierDetectionProp, err := expandComputeRegionBackendServiceOutlierDetection(d.Get("outlier_detection"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("outlier_detection"); !tpgresource.IsEmptyValue(reflect.ValueOf(outlierDetectionProp)) && (ok || !reflect.DeepEqual(v, outlierDetectionProp)) { |
| obj["outlierDetection"] = outlierDetectionProp |
| } |
| portNameProp, err := expandComputeRegionBackendServicePortName(d.Get("port_name"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("port_name"); !tpgresource.IsEmptyValue(reflect.ValueOf(portNameProp)) && (ok || !reflect.DeepEqual(v, portNameProp)) { |
| obj["portName"] = portNameProp |
| } |
| protocolProp, err := expandComputeRegionBackendServiceProtocol(d.Get("protocol"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("protocol"); !tpgresource.IsEmptyValue(reflect.ValueOf(protocolProp)) && (ok || !reflect.DeepEqual(v, protocolProp)) { |
| obj["protocol"] = protocolProp |
| } |
| securityPolicyProp, err := expandComputeRegionBackendServiceSecurityPolicy(d.Get("security_policy"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("security_policy"); !tpgresource.IsEmptyValue(reflect.ValueOf(securityPolicyProp)) && (ok || !reflect.DeepEqual(v, securityPolicyProp)) { |
| obj["securityPolicy"] = securityPolicyProp |
| } |
| sessionAffinityProp, err := expandComputeRegionBackendServiceSessionAffinity(d.Get("session_affinity"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("session_affinity"); !tpgresource.IsEmptyValue(reflect.ValueOf(sessionAffinityProp)) && (ok || !reflect.DeepEqual(v, sessionAffinityProp)) { |
| obj["sessionAffinity"] = sessionAffinityProp |
| } |
| connectionTrackingPolicyProp, err := expandComputeRegionBackendServiceConnectionTrackingPolicy(d.Get("connection_tracking_policy"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("connection_tracking_policy"); !tpgresource.IsEmptyValue(reflect.ValueOf(connectionTrackingPolicyProp)) && (ok || !reflect.DeepEqual(v, connectionTrackingPolicyProp)) { |
| obj["connectionTrackingPolicy"] = connectionTrackingPolicyProp |
| } |
| timeoutSecProp, err := expandComputeRegionBackendServiceTimeoutSec(d.Get("timeout_sec"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("timeout_sec"); !tpgresource.IsEmptyValue(reflect.ValueOf(timeoutSecProp)) && (ok || !reflect.DeepEqual(v, timeoutSecProp)) { |
| obj["timeoutSec"] = timeoutSecProp |
| } |
| logConfigProp, err := expandComputeRegionBackendServiceLogConfig(d.Get("log_config"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("log_config"); !tpgresource.IsEmptyValue(reflect.ValueOf(logConfigProp)) && (ok || !reflect.DeepEqual(v, logConfigProp)) { |
| obj["logConfig"] = logConfigProp |
| } |
| networkProp, err := expandComputeRegionBackendServiceNetwork(d.Get("network"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("network"); !tpgresource.IsEmptyValue(reflect.ValueOf(networkProp)) && (ok || !reflect.DeepEqual(v, networkProp)) { |
| obj["network"] = networkProp |
| } |
| subsettingProp, err := expandComputeRegionBackendServiceSubsetting(d.Get("subsetting"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("subsetting"); !tpgresource.IsEmptyValue(reflect.ValueOf(subsettingProp)) && (ok || !reflect.DeepEqual(v, subsettingProp)) { |
| obj["subsetting"] = subsettingProp |
| } |
| regionProp, err := expandComputeRegionBackendServiceRegion(d.Get("region"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("region"); !tpgresource.IsEmptyValue(reflect.ValueOf(regionProp)) && (ok || !reflect.DeepEqual(v, regionProp)) { |
| obj["region"] = regionProp |
| } |
| |
| obj, err = resourceComputeRegionBackendServiceEncoder(d, meta, obj) |
| if err != nil { |
| return err |
| } |
| |
| url, err := tpgresource.ReplaceVars(d, config, "{{ComputeBasePath}}projects/{{project}}/regions/{{region}}/backendServices") |
| if err != nil { |
| return err |
| } |
| |
| log.Printf("[DEBUG] Creating new RegionBackendService: %#v", obj) |
| billingProject := "" |
| |
| project, err := tpgresource.GetProject(d, config) |
| if err != nil { |
| return fmt.Errorf("Error fetching project for RegionBackendService: %s", err) |
| } |
| billingProject = project |
| |
| // err == nil indicates that the billing_project value was found |
| if bp, err := tpgresource.GetBillingProject(d, config); err == nil { |
| billingProject = bp |
| } |
| |
| res, err := transport_tpg.SendRequest(transport_tpg.SendRequestOptions{ |
| Config: config, |
| Method: "POST", |
| Project: billingProject, |
| RawURL: url, |
| UserAgent: userAgent, |
| Body: obj, |
| Timeout: d.Timeout(schema.TimeoutCreate), |
| }) |
| if err != nil { |
| return fmt.Errorf("Error creating RegionBackendService: %s", err) |
| } |
| |
| // Store the ID now |
| id, err := tpgresource.ReplaceVars(d, config, "projects/{{project}}/regions/{{region}}/backendServices/{{name}}") |
| if err != nil { |
| return fmt.Errorf("Error constructing id: %s", err) |
| } |
| d.SetId(id) |
| |
| err = ComputeOperationWaitTime( |
| config, res, project, "Creating RegionBackendService", userAgent, |
| d.Timeout(schema.TimeoutCreate)) |
| |
| if err != nil { |
| // The resource didn't actually create |
| d.SetId("") |
| return fmt.Errorf("Error waiting to create RegionBackendService: %s", err) |
| } |
| |
| // security_policy isn't set by Create |
| if v, ok := d.GetOkExists("security_policy"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, securityPolicyProp)) { |
| err = resourceComputeRegionBackendServiceRead(d, meta) |
| if err != nil { |
| return err |
| } |
| |
| obj := make(map[string]interface{}) |
| securityPolicyProp, err := expandComputeRegionBackendServiceSecurityPolicy(v, d, config) |
| if err != nil { |
| return err |
| } |
| obj["security_policy"] = securityPolicyProp |
| |
| url, err := tpgresource.ReplaceVars(d, config, "{{ComputeBasePath}}projects/{{project}}/regions/{{region}}/backendServices/{{name}}/setSecurityPolicy") |
| if err != nil { |
| return err |
| } |
| |
| res, err = transport_tpg.SendRequest(transport_tpg.SendRequestOptions{ |
| Config: config, |
| Method: "POST", |
| Project: project, |
| RawURL: url, |
| UserAgent: userAgent, |
| Body: obj, |
| }) |
| |
| if err != nil { |
| return fmt.Errorf("Error adding SecurityPolicy to RegionBackendService %q: %s", d.Id(), err) |
| } |
| |
| err = ComputeOperationWaitTime(config, res, project, "Updating RegionBackendService SecurityPolicy", userAgent, d.Timeout(schema.TimeoutUpdate)) |
| if err != nil { |
| return err |
| } |
| } |
| |
| log.Printf("[DEBUG] Finished creating RegionBackendService %q: %#v", d.Id(), res) |
| |
| return resourceComputeRegionBackendServiceRead(d, meta) |
| } |
| |
| func resourceComputeRegionBackendServiceRead(d *schema.ResourceData, meta interface{}) error { |
| config := meta.(*transport_tpg.Config) |
| userAgent, err := tpgresource.GenerateUserAgentString(d, config.UserAgent) |
| if err != nil { |
| return err |
| } |
| |
| url, err := tpgresource.ReplaceVars(d, config, "{{ComputeBasePath}}projects/{{project}}/regions/{{region}}/backendServices/{{name}}") |
| if err != nil { |
| return err |
| } |
| |
| billingProject := "" |
| |
| project, err := tpgresource.GetProject(d, config) |
| if err != nil { |
| return fmt.Errorf("Error fetching project for RegionBackendService: %s", err) |
| } |
| billingProject = project |
| |
| // err == nil indicates that the billing_project value was found |
| if bp, err := tpgresource.GetBillingProject(d, config); err == nil { |
| billingProject = bp |
| } |
| |
| res, err := transport_tpg.SendRequest(transport_tpg.SendRequestOptions{ |
| Config: config, |
| Method: "GET", |
| Project: billingProject, |
| RawURL: url, |
| UserAgent: userAgent, |
| }) |
| if err != nil { |
| return transport_tpg.HandleNotFoundError(err, d, fmt.Sprintf("ComputeRegionBackendService %q", d.Id())) |
| } |
| |
| res, err = resourceComputeRegionBackendServiceDecoder(d, meta, res) |
| if err != nil { |
| return err |
| } |
| |
| if res == nil { |
| // Decoding the object has resulted in it being gone. It may be marked deleted |
| log.Printf("[DEBUG] Removing ComputeRegionBackendService because it no longer exists.") |
| d.SetId("") |
| return nil |
| } |
| |
| if err := d.Set("project", project); err != nil { |
| return fmt.Errorf("Error reading RegionBackendService: %s", err) |
| } |
| |
| if err := d.Set("affinity_cookie_ttl_sec", flattenComputeRegionBackendServiceAffinityCookieTtlSec(res["affinityCookieTtlSec"], d, config)); err != nil { |
| return fmt.Errorf("Error reading RegionBackendService: %s", err) |
| } |
| if err := d.Set("backend", flattenComputeRegionBackendServiceBackend(res["backends"], d, config)); err != nil { |
| return fmt.Errorf("Error reading RegionBackendService: %s", err) |
| } |
| if err := d.Set("circuit_breakers", flattenComputeRegionBackendServiceCircuitBreakers(res["circuitBreakers"], d, config)); err != nil { |
| return fmt.Errorf("Error reading RegionBackendService: %s", err) |
| } |
| if err := d.Set("consistent_hash", flattenComputeRegionBackendServiceConsistentHash(res["consistentHash"], d, config)); err != nil { |
| return fmt.Errorf("Error reading RegionBackendService: %s", err) |
| } |
| if err := d.Set("cdn_policy", flattenComputeRegionBackendServiceCdnPolicy(res["cdnPolicy"], d, config)); err != nil { |
| return fmt.Errorf("Error reading RegionBackendService: %s", err) |
| } |
| // Terraform must set the top level schema field, but since this object contains collapsed properties |
| // it's difficult to know what the top level should be. Instead we just loop over the map returned from flatten. |
| if flattenedProp := flattenComputeRegionBackendServiceConnectionDraining(res["connectionDraining"], d, config); flattenedProp != nil { |
| if gerr, ok := flattenedProp.(*googleapi.Error); ok { |
| return fmt.Errorf("Error reading RegionBackendService: %s", gerr) |
| } |
| casted := flattenedProp.([]interface{})[0] |
| if casted != nil { |
| for k, v := range casted.(map[string]interface{}) { |
| if err := d.Set(k, v); err != nil { |
| return fmt.Errorf("Error setting %s: %s", k, err) |
| } |
| } |
| } |
| } |
| if err := d.Set("creation_timestamp", flattenComputeRegionBackendServiceCreationTimestamp(res["creationTimestamp"], d, config)); err != nil { |
| return fmt.Errorf("Error reading RegionBackendService: %s", err) |
| } |
| if err := d.Set("description", flattenComputeRegionBackendServiceDescription(res["description"], d, config)); err != nil { |
| return fmt.Errorf("Error reading RegionBackendService: %s", err) |
| } |
| if err := d.Set("failover_policy", flattenComputeRegionBackendServiceFailoverPolicy(res["failoverPolicy"], d, config)); err != nil { |
| return fmt.Errorf("Error reading RegionBackendService: %s", err) |
| } |
| if err := d.Set("enable_cdn", flattenComputeRegionBackendServiceEnableCDN(res["enableCDN"], d, config)); err != nil { |
| return fmt.Errorf("Error reading RegionBackendService: %s", err) |
| } |
| if err := d.Set("fingerprint", flattenComputeRegionBackendServiceFingerprint(res["fingerprint"], d, config)); err != nil { |
| return fmt.Errorf("Error reading RegionBackendService: %s", err) |
| } |
| if err := d.Set("health_checks", flattenComputeRegionBackendServiceHealthChecks(res["healthChecks"], d, config)); err != nil { |
| return fmt.Errorf("Error reading RegionBackendService: %s", err) |
| } |
| if err := d.Set("iap", flattenComputeRegionBackendServiceIap(res["iap"], d, config)); err != nil { |
| return fmt.Errorf("Error reading RegionBackendService: %s", err) |
| } |
| if err := d.Set("load_balancing_scheme", flattenComputeRegionBackendServiceLoadBalancingScheme(res["loadBalancingScheme"], d, config)); err != nil { |
| return fmt.Errorf("Error reading RegionBackendService: %s", err) |
| } |
| if err := d.Set("locality_lb_policy", flattenComputeRegionBackendServiceLocalityLbPolicy(res["localityLbPolicy"], d, config)); err != nil { |
| return fmt.Errorf("Error reading RegionBackendService: %s", err) |
| } |
| if err := d.Set("name", flattenComputeRegionBackendServiceName(res["name"], d, config)); err != nil { |
| return fmt.Errorf("Error reading RegionBackendService: %s", err) |
| } |
| if err := d.Set("outlier_detection", flattenComputeRegionBackendServiceOutlierDetection(res["outlierDetection"], d, config)); err != nil { |
| return fmt.Errorf("Error reading RegionBackendService: %s", err) |
| } |
| if err := d.Set("port_name", flattenComputeRegionBackendServicePortName(res["portName"], d, config)); err != nil { |
| return fmt.Errorf("Error reading RegionBackendService: %s", err) |
| } |
| if err := d.Set("protocol", flattenComputeRegionBackendServiceProtocol(res["protocol"], d, config)); err != nil { |
| return fmt.Errorf("Error reading RegionBackendService: %s", err) |
| } |
| if err := d.Set("security_policy", flattenComputeRegionBackendServiceSecurityPolicy(res["securityPolicy"], d, config)); err != nil { |
| return fmt.Errorf("Error reading RegionBackendService: %s", err) |
| } |
| if err := d.Set("session_affinity", flattenComputeRegionBackendServiceSessionAffinity(res["sessionAffinity"], d, config)); err != nil { |
| return fmt.Errorf("Error reading RegionBackendService: %s", err) |
| } |
| if err := d.Set("connection_tracking_policy", flattenComputeRegionBackendServiceConnectionTrackingPolicy(res["connectionTrackingPolicy"], d, config)); err != nil { |
| return fmt.Errorf("Error reading RegionBackendService: %s", err) |
| } |
| if err := d.Set("timeout_sec", flattenComputeRegionBackendServiceTimeoutSec(res["timeoutSec"], d, config)); err != nil { |
| return fmt.Errorf("Error reading RegionBackendService: %s", err) |
| } |
| if err := d.Set("log_config", flattenComputeRegionBackendServiceLogConfig(res["logConfig"], d, config)); err != nil { |
| return fmt.Errorf("Error reading RegionBackendService: %s", err) |
| } |
| if err := d.Set("network", flattenComputeRegionBackendServiceNetwork(res["network"], d, config)); err != nil { |
| return fmt.Errorf("Error reading RegionBackendService: %s", err) |
| } |
| if err := d.Set("subsetting", flattenComputeRegionBackendServiceSubsetting(res["subsetting"], d, config)); err != nil { |
| return fmt.Errorf("Error reading RegionBackendService: %s", err) |
| } |
| if err := d.Set("region", flattenComputeRegionBackendServiceRegion(res["region"], d, config)); err != nil { |
| return fmt.Errorf("Error reading RegionBackendService: %s", err) |
| } |
| if err := d.Set("self_link", tpgresource.ConvertSelfLinkToV1(res["selfLink"].(string))); err != nil { |
| return fmt.Errorf("Error reading RegionBackendService: %s", err) |
| } |
| |
| return nil |
| } |
| |
| func resourceComputeRegionBackendServiceUpdate(d *schema.ResourceData, meta interface{}) error { |
| config := meta.(*transport_tpg.Config) |
| userAgent, err := tpgresource.GenerateUserAgentString(d, config.UserAgent) |
| if err != nil { |
| return err |
| } |
| |
| billingProject := "" |
| |
| project, err := tpgresource.GetProject(d, config) |
| if err != nil { |
| return fmt.Errorf("Error fetching project for RegionBackendService: %s", err) |
| } |
| billingProject = project |
| |
| obj := make(map[string]interface{}) |
| affinityCookieTtlSecProp, err := expandComputeRegionBackendServiceAffinityCookieTtlSec(d.Get("affinity_cookie_ttl_sec"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("affinity_cookie_ttl_sec"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, affinityCookieTtlSecProp)) { |
| obj["affinityCookieTtlSec"] = affinityCookieTtlSecProp |
| } |
| backendsProp, err := expandComputeRegionBackendServiceBackend(d.Get("backend"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("backend"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, backendsProp)) { |
| obj["backends"] = backendsProp |
| } |
| circuitBreakersProp, err := expandComputeRegionBackendServiceCircuitBreakers(d.Get("circuit_breakers"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("circuit_breakers"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, circuitBreakersProp)) { |
| obj["circuitBreakers"] = circuitBreakersProp |
| } |
| consistentHashProp, err := expandComputeRegionBackendServiceConsistentHash(d.Get("consistent_hash"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("consistent_hash"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, consistentHashProp)) { |
| obj["consistentHash"] = consistentHashProp |
| } |
| cdnPolicyProp, err := expandComputeRegionBackendServiceCdnPolicy(d.Get("cdn_policy"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("cdn_policy"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, cdnPolicyProp)) { |
| obj["cdnPolicy"] = cdnPolicyProp |
| } |
| connectionDrainingProp, err := expandComputeRegionBackendServiceConnectionDraining(nil, d, config) |
| if err != nil { |
| return err |
| } else if !tpgresource.IsEmptyValue(reflect.ValueOf(connectionDrainingProp)) { |
| obj["connectionDraining"] = connectionDrainingProp |
| } |
| descriptionProp, err := expandComputeRegionBackendServiceDescription(d.Get("description"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("description"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, descriptionProp)) { |
| obj["description"] = descriptionProp |
| } |
| failoverPolicyProp, err := expandComputeRegionBackendServiceFailoverPolicy(d.Get("failover_policy"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("failover_policy"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, failoverPolicyProp)) { |
| obj["failoverPolicy"] = failoverPolicyProp |
| } |
| enableCDNProp, err := expandComputeRegionBackendServiceEnableCDN(d.Get("enable_cdn"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("enable_cdn"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, enableCDNProp)) { |
| obj["enableCDN"] = enableCDNProp |
| } |
| fingerprintProp, err := expandComputeRegionBackendServiceFingerprint(d.Get("fingerprint"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("fingerprint"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, fingerprintProp)) { |
| obj["fingerprint"] = fingerprintProp |
| } |
| healthChecksProp, err := expandComputeRegionBackendServiceHealthChecks(d.Get("health_checks"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("health_checks"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, healthChecksProp)) { |
| obj["healthChecks"] = healthChecksProp |
| } |
| iapProp, err := expandComputeRegionBackendServiceIap(d.Get("iap"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("iap"); ok || !reflect.DeepEqual(v, iapProp) { |
| obj["iap"] = iapProp |
| } |
| loadBalancingSchemeProp, err := expandComputeRegionBackendServiceLoadBalancingScheme(d.Get("load_balancing_scheme"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("load_balancing_scheme"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, loadBalancingSchemeProp)) { |
| obj["loadBalancingScheme"] = loadBalancingSchemeProp |
| } |
| localityLbPolicyProp, err := expandComputeRegionBackendServiceLocalityLbPolicy(d.Get("locality_lb_policy"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("locality_lb_policy"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, localityLbPolicyProp)) { |
| obj["localityLbPolicy"] = localityLbPolicyProp |
| } |
| nameProp, err := expandComputeRegionBackendServiceName(d.Get("name"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("name"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, nameProp)) { |
| obj["name"] = nameProp |
| } |
| outlierDetectionProp, err := expandComputeRegionBackendServiceOutlierDetection(d.Get("outlier_detection"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("outlier_detection"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, outlierDetectionProp)) { |
| obj["outlierDetection"] = outlierDetectionProp |
| } |
| portNameProp, err := expandComputeRegionBackendServicePortName(d.Get("port_name"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("port_name"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, portNameProp)) { |
| obj["portName"] = portNameProp |
| } |
| protocolProp, err := expandComputeRegionBackendServiceProtocol(d.Get("protocol"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("protocol"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, protocolProp)) { |
| obj["protocol"] = protocolProp |
| } |
| sessionAffinityProp, err := expandComputeRegionBackendServiceSessionAffinity(d.Get("session_affinity"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("session_affinity"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, sessionAffinityProp)) { |
| obj["sessionAffinity"] = sessionAffinityProp |
| } |
| connectionTrackingPolicyProp, err := expandComputeRegionBackendServiceConnectionTrackingPolicy(d.Get("connection_tracking_policy"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("connection_tracking_policy"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, connectionTrackingPolicyProp)) { |
| obj["connectionTrackingPolicy"] = connectionTrackingPolicyProp |
| } |
| timeoutSecProp, err := expandComputeRegionBackendServiceTimeoutSec(d.Get("timeout_sec"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("timeout_sec"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, timeoutSecProp)) { |
| obj["timeoutSec"] = timeoutSecProp |
| } |
| logConfigProp, err := expandComputeRegionBackendServiceLogConfig(d.Get("log_config"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("log_config"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, logConfigProp)) { |
| obj["logConfig"] = logConfigProp |
| } |
| networkProp, err := expandComputeRegionBackendServiceNetwork(d.Get("network"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("network"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, networkProp)) { |
| obj["network"] = networkProp |
| } |
| subsettingProp, err := expandComputeRegionBackendServiceSubsetting(d.Get("subsetting"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("subsetting"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, subsettingProp)) { |
| obj["subsetting"] = subsettingProp |
| } |
| regionProp, err := expandComputeRegionBackendServiceRegion(d.Get("region"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("region"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, regionProp)) { |
| obj["region"] = regionProp |
| } |
| |
| obj, err = resourceComputeRegionBackendServiceEncoder(d, meta, obj) |
| if err != nil { |
| return err |
| } |
| |
| url, err := tpgresource.ReplaceVars(d, config, "{{ComputeBasePath}}projects/{{project}}/regions/{{region}}/backendServices/{{name}}") |
| if err != nil { |
| return err |
| } |
| |
| log.Printf("[DEBUG] Updating RegionBackendService %q: %#v", d.Id(), obj) |
| |
| // err == nil indicates that the billing_project value was found |
| if bp, err := tpgresource.GetBillingProject(d, config); err == nil { |
| billingProject = bp |
| } |
| |
| res, err := transport_tpg.SendRequest(transport_tpg.SendRequestOptions{ |
| Config: config, |
| Method: "PUT", |
| Project: billingProject, |
| RawURL: url, |
| UserAgent: userAgent, |
| Body: obj, |
| Timeout: d.Timeout(schema.TimeoutUpdate), |
| }) |
| |
| if err != nil { |
| return fmt.Errorf("Error updating RegionBackendService %q: %s", d.Id(), err) |
| } else { |
| log.Printf("[DEBUG] Finished updating RegionBackendService %q: %#v", d.Id(), res) |
| } |
| |
| err = ComputeOperationWaitTime( |
| config, res, project, "Updating RegionBackendService", userAgent, |
| d.Timeout(schema.TimeoutUpdate)) |
| |
| if err != nil { |
| return err |
| } |
| d.Partial(true) |
| |
| if d.HasChange("security_policy") { |
| obj := make(map[string]interface{}) |
| |
| securityPolicyProp, err := expandComputeRegionBackendServiceSecurityPolicy(d.Get("security_policy"), d, config) |
| if err != nil { |
| return err |
| } else if v, ok := d.GetOkExists("security_policy"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, securityPolicyProp)) { |
| obj["securityPolicy"] = securityPolicyProp |
| } |
| |
| url, err := tpgresource.ReplaceVars(d, config, "{{ComputeBasePath}}projects/{{project}}/regions/{{region}}/backendServices/{{name}}/setSecurityPolicy") |
| if err != nil { |
| return err |
| } |
| |
| // err == nil indicates that the billing_project value was found |
| if bp, err := tpgresource.GetBillingProject(d, config); err == nil { |
| billingProject = bp |
| } |
| |
| res, err := transport_tpg.SendRequest(transport_tpg.SendRequestOptions{ |
| Config: config, |
| Method: "POST", |
| Project: billingProject, |
| RawURL: url, |
| UserAgent: userAgent, |
| Body: obj, |
| Timeout: d.Timeout(schema.TimeoutUpdate), |
| }) |
| if err != nil { |
| return fmt.Errorf("Error updating RegionBackendService %q: %s", d.Id(), err) |
| } else { |
| log.Printf("[DEBUG] Finished updating RegionBackendService %q: %#v", d.Id(), res) |
| } |
| |
| err = ComputeOperationWaitTime( |
| config, res, project, "Updating RegionBackendService", userAgent, |
| d.Timeout(schema.TimeoutUpdate)) |
| if err != nil { |
| return err |
| } |
| } |
| |
| d.Partial(false) |
| |
| return resourceComputeRegionBackendServiceRead(d, meta) |
| } |
| |
| func resourceComputeRegionBackendServiceDelete(d *schema.ResourceData, meta interface{}) error { |
| config := meta.(*transport_tpg.Config) |
| userAgent, err := tpgresource.GenerateUserAgentString(d, config.UserAgent) |
| if err != nil { |
| return err |
| } |
| |
| billingProject := "" |
| |
| project, err := tpgresource.GetProject(d, config) |
| if err != nil { |
| return fmt.Errorf("Error fetching project for RegionBackendService: %s", err) |
| } |
| billingProject = project |
| |
| url, err := tpgresource.ReplaceVars(d, config, "{{ComputeBasePath}}projects/{{project}}/regions/{{region}}/backendServices/{{name}}") |
| if err != nil { |
| return err |
| } |
| |
| var obj map[string]interface{} |
| log.Printf("[DEBUG] Deleting RegionBackendService %q", d.Id()) |
| |
| // err == nil indicates that the billing_project value was found |
| if bp, err := tpgresource.GetBillingProject(d, config); err == nil { |
| billingProject = bp |
| } |
| |
| res, err := transport_tpg.SendRequest(transport_tpg.SendRequestOptions{ |
| Config: config, |
| Method: "DELETE", |
| Project: billingProject, |
| RawURL: url, |
| UserAgent: userAgent, |
| Body: obj, |
| Timeout: d.Timeout(schema.TimeoutDelete), |
| }) |
| if err != nil { |
| return transport_tpg.HandleNotFoundError(err, d, "RegionBackendService") |
| } |
| |
| err = ComputeOperationWaitTime( |
| config, res, project, "Deleting RegionBackendService", userAgent, |
| d.Timeout(schema.TimeoutDelete)) |
| |
| if err != nil { |
| return err |
| } |
| |
| log.Printf("[DEBUG] Finished deleting RegionBackendService %q: %#v", d.Id(), res) |
| return nil |
| } |
| |
| func resourceComputeRegionBackendServiceImport(d *schema.ResourceData, meta interface{}) ([]*schema.ResourceData, error) { |
| config := meta.(*transport_tpg.Config) |
| if err := tpgresource.ParseImportId([]string{ |
| "^projects/(?P<project>[^/]+)/regions/(?P<region>[^/]+)/backendServices/(?P<name>[^/]+)$", |
| "^(?P<project>[^/]+)/(?P<region>[^/]+)/(?P<name>[^/]+)$", |
| "^(?P<region>[^/]+)/(?P<name>[^/]+)$", |
| "^(?P<name>[^/]+)$", |
| }, d, config); err != nil { |
| return nil, err |
| } |
| |
| // Replace import id for the resource id |
| id, err := tpgresource.ReplaceVars(d, config, "projects/{{project}}/regions/{{region}}/backendServices/{{name}}") |
| if err != nil { |
| return nil, fmt.Errorf("Error constructing id: %s", err) |
| } |
| d.SetId(id) |
| |
| return []*schema.ResourceData{d}, nil |
| } |
| |
| func flattenComputeRegionBackendServiceAffinityCookieTtlSec(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 flattenComputeRegionBackendServiceBackend(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| if v == nil { |
| return v |
| } |
| l := v.([]interface{}) |
| transformed := schema.NewSet(resourceGoogleComputeBackendServiceBackendHash, []interface{}{}) |
| for _, raw := range l { |
| original := raw.(map[string]interface{}) |
| if len(original) < 1 { |
| // Do not include empty json objects coming back from the api |
| continue |
| } |
| transformed.Add(map[string]interface{}{ |
| "balancing_mode": flattenComputeRegionBackendServiceBackendBalancingMode(original["balancingMode"], d, config), |
| "capacity_scaler": flattenComputeRegionBackendServiceBackendCapacityScaler(original["capacityScaler"], d, config), |
| "description": flattenComputeRegionBackendServiceBackendDescription(original["description"], d, config), |
| "failover": flattenComputeRegionBackendServiceBackendFailover(original["failover"], d, config), |
| "group": flattenComputeRegionBackendServiceBackendGroup(original["group"], d, config), |
| "max_connections": flattenComputeRegionBackendServiceBackendMaxConnections(original["maxConnections"], d, config), |
| "max_connections_per_instance": flattenComputeRegionBackendServiceBackendMaxConnectionsPerInstance(original["maxConnectionsPerInstance"], d, config), |
| "max_connections_per_endpoint": flattenComputeRegionBackendServiceBackendMaxConnectionsPerEndpoint(original["maxConnectionsPerEndpoint"], d, config), |
| "max_rate": flattenComputeRegionBackendServiceBackendMaxRate(original["maxRate"], d, config), |
| "max_rate_per_instance": flattenComputeRegionBackendServiceBackendMaxRatePerInstance(original["maxRatePerInstance"], d, config), |
| "max_rate_per_endpoint": flattenComputeRegionBackendServiceBackendMaxRatePerEndpoint(original["maxRatePerEndpoint"], d, config), |
| "max_utilization": flattenComputeRegionBackendServiceBackendMaxUtilization(original["maxUtilization"], d, config), |
| }) |
| } |
| return transformed |
| } |
| func flattenComputeRegionBackendServiceBackendBalancingMode(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenComputeRegionBackendServiceBackendCapacityScaler(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenComputeRegionBackendServiceBackendDescription(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenComputeRegionBackendServiceBackendFailover(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenComputeRegionBackendServiceBackendGroup(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| if v == nil { |
| return v |
| } |
| return tpgresource.ConvertSelfLinkToV1(v.(string)) |
| } |
| |
| func flattenComputeRegionBackendServiceBackendMaxConnections(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 flattenComputeRegionBackendServiceBackendMaxConnectionsPerInstance(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 flattenComputeRegionBackendServiceBackendMaxConnectionsPerEndpoint(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 flattenComputeRegionBackendServiceBackendMaxRate(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 flattenComputeRegionBackendServiceBackendMaxRatePerInstance(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenComputeRegionBackendServiceBackendMaxRatePerEndpoint(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenComputeRegionBackendServiceBackendMaxUtilization(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenComputeRegionBackendServiceCircuitBreakers(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["connect_timeout"] = |
| flattenComputeRegionBackendServiceCircuitBreakersConnectTimeout(original["connectTimeout"], d, config) |
| transformed["max_requests_per_connection"] = |
| flattenComputeRegionBackendServiceCircuitBreakersMaxRequestsPerConnection(original["maxRequestsPerConnection"], d, config) |
| transformed["max_connections"] = |
| flattenComputeRegionBackendServiceCircuitBreakersMaxConnections(original["maxConnections"], d, config) |
| transformed["max_pending_requests"] = |
| flattenComputeRegionBackendServiceCircuitBreakersMaxPendingRequests(original["maxPendingRequests"], d, config) |
| transformed["max_requests"] = |
| flattenComputeRegionBackendServiceCircuitBreakersMaxRequests(original["maxRequests"], d, config) |
| transformed["max_retries"] = |
| flattenComputeRegionBackendServiceCircuitBreakersMaxRetries(original["maxRetries"], d, config) |
| return []interface{}{transformed} |
| } |
| func flattenComputeRegionBackendServiceCircuitBreakersConnectTimeout(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"] = |
| flattenComputeRegionBackendServiceCircuitBreakersConnectTimeoutSeconds(original["seconds"], d, config) |
| transformed["nanos"] = |
| flattenComputeRegionBackendServiceCircuitBreakersConnectTimeoutNanos(original["nanos"], d, config) |
| return []interface{}{transformed} |
| } |
| func flattenComputeRegionBackendServiceCircuitBreakersConnectTimeoutSeconds(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 flattenComputeRegionBackendServiceCircuitBreakersConnectTimeoutNanos(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 flattenComputeRegionBackendServiceCircuitBreakersMaxRequestsPerConnection(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 flattenComputeRegionBackendServiceCircuitBreakersMaxConnections(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 flattenComputeRegionBackendServiceCircuitBreakersMaxPendingRequests(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 flattenComputeRegionBackendServiceCircuitBreakersMaxRequests(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 flattenComputeRegionBackendServiceCircuitBreakersMaxRetries(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 flattenComputeRegionBackendServiceConsistentHash(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["http_cookie"] = |
| flattenComputeRegionBackendServiceConsistentHashHttpCookie(original["httpCookie"], d, config) |
| transformed["http_header_name"] = |
| flattenComputeRegionBackendServiceConsistentHashHttpHeaderName(original["httpHeaderName"], d, config) |
| transformed["minimum_ring_size"] = |
| flattenComputeRegionBackendServiceConsistentHashMinimumRingSize(original["minimumRingSize"], d, config) |
| return []interface{}{transformed} |
| } |
| func flattenComputeRegionBackendServiceConsistentHashHttpCookie(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["ttl"] = |
| flattenComputeRegionBackendServiceConsistentHashHttpCookieTtl(original["ttl"], d, config) |
| transformed["name"] = |
| flattenComputeRegionBackendServiceConsistentHashHttpCookieName(original["name"], d, config) |
| transformed["path"] = |
| flattenComputeRegionBackendServiceConsistentHashHttpCookiePath(original["path"], d, config) |
| return []interface{}{transformed} |
| } |
| func flattenComputeRegionBackendServiceConsistentHashHttpCookieTtl(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"] = |
| flattenComputeRegionBackendServiceConsistentHashHttpCookieTtlSeconds(original["seconds"], d, config) |
| transformed["nanos"] = |
| flattenComputeRegionBackendServiceConsistentHashHttpCookieTtlNanos(original["nanos"], d, config) |
| return []interface{}{transformed} |
| } |
| func flattenComputeRegionBackendServiceConsistentHashHttpCookieTtlSeconds(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 flattenComputeRegionBackendServiceConsistentHashHttpCookieTtlNanos(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 flattenComputeRegionBackendServiceConsistentHashHttpCookieName(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenComputeRegionBackendServiceConsistentHashHttpCookiePath(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenComputeRegionBackendServiceConsistentHashHttpHeaderName(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenComputeRegionBackendServiceConsistentHashMinimumRingSize(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 flattenComputeRegionBackendServiceCdnPolicy(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["cache_key_policy"] = |
| flattenComputeRegionBackendServiceCdnPolicyCacheKeyPolicy(original["cacheKeyPolicy"], d, config) |
| transformed["signed_url_cache_max_age_sec"] = |
| flattenComputeRegionBackendServiceCdnPolicySignedUrlCacheMaxAgeSec(original["signedUrlCacheMaxAgeSec"], d, config) |
| transformed["default_ttl"] = |
| flattenComputeRegionBackendServiceCdnPolicyDefaultTtl(original["defaultTtl"], d, config) |
| transformed["max_ttl"] = |
| flattenComputeRegionBackendServiceCdnPolicyMaxTtl(original["maxTtl"], d, config) |
| transformed["client_ttl"] = |
| flattenComputeRegionBackendServiceCdnPolicyClientTtl(original["clientTtl"], d, config) |
| transformed["negative_caching"] = |
| flattenComputeRegionBackendServiceCdnPolicyNegativeCaching(original["negativeCaching"], d, config) |
| transformed["negative_caching_policy"] = |
| flattenComputeRegionBackendServiceCdnPolicyNegativeCachingPolicy(original["negativeCachingPolicy"], d, config) |
| transformed["cache_mode"] = |
| flattenComputeRegionBackendServiceCdnPolicyCacheMode(original["cacheMode"], d, config) |
| transformed["serve_while_stale"] = |
| flattenComputeRegionBackendServiceCdnPolicyServeWhileStale(original["serveWhileStale"], d, config) |
| return []interface{}{transformed} |
| } |
| func flattenComputeRegionBackendServiceCdnPolicyCacheKeyPolicy(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["include_host"] = |
| flattenComputeRegionBackendServiceCdnPolicyCacheKeyPolicyIncludeHost(original["includeHost"], d, config) |
| transformed["include_protocol"] = |
| flattenComputeRegionBackendServiceCdnPolicyCacheKeyPolicyIncludeProtocol(original["includeProtocol"], d, config) |
| transformed["include_query_string"] = |
| flattenComputeRegionBackendServiceCdnPolicyCacheKeyPolicyIncludeQueryString(original["includeQueryString"], d, config) |
| transformed["query_string_blacklist"] = |
| flattenComputeRegionBackendServiceCdnPolicyCacheKeyPolicyQueryStringBlacklist(original["queryStringBlacklist"], d, config) |
| transformed["query_string_whitelist"] = |
| flattenComputeRegionBackendServiceCdnPolicyCacheKeyPolicyQueryStringWhitelist(original["queryStringWhitelist"], d, config) |
| transformed["include_named_cookies"] = |
| flattenComputeRegionBackendServiceCdnPolicyCacheKeyPolicyIncludeNamedCookies(original["includeNamedCookies"], d, config) |
| return []interface{}{transformed} |
| } |
| func flattenComputeRegionBackendServiceCdnPolicyCacheKeyPolicyIncludeHost(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenComputeRegionBackendServiceCdnPolicyCacheKeyPolicyIncludeProtocol(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenComputeRegionBackendServiceCdnPolicyCacheKeyPolicyIncludeQueryString(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenComputeRegionBackendServiceCdnPolicyCacheKeyPolicyQueryStringBlacklist(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| if v == nil { |
| return v |
| } |
| return schema.NewSet(schema.HashString, v.([]interface{})) |
| } |
| |
| func flattenComputeRegionBackendServiceCdnPolicyCacheKeyPolicyQueryStringWhitelist(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| if v == nil { |
| return v |
| } |
| return schema.NewSet(schema.HashString, v.([]interface{})) |
| } |
| |
| func flattenComputeRegionBackendServiceCdnPolicyCacheKeyPolicyIncludeNamedCookies(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenComputeRegionBackendServiceCdnPolicySignedUrlCacheMaxAgeSec(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 flattenComputeRegionBackendServiceCdnPolicyDefaultTtl(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 flattenComputeRegionBackendServiceCdnPolicyMaxTtl(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 flattenComputeRegionBackendServiceCdnPolicyClientTtl(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 flattenComputeRegionBackendServiceCdnPolicyNegativeCaching(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenComputeRegionBackendServiceCdnPolicyNegativeCachingPolicy(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| if v == nil { |
| return v |
| } |
| l := v.([]interface{}) |
| transformed := make([]interface{}, 0, len(l)) |
| for _, raw := range l { |
| original := raw.(map[string]interface{}) |
| if len(original) < 1 { |
| // Do not include empty json objects coming back from the api |
| continue |
| } |
| transformed = append(transformed, map[string]interface{}{ |
| "code": flattenComputeRegionBackendServiceCdnPolicyNegativeCachingPolicyCode(original["code"], d, config), |
| "ttl": flattenComputeRegionBackendServiceCdnPolicyNegativeCachingPolicyTtl(original["ttl"], d, config), |
| }) |
| } |
| return transformed |
| } |
| func flattenComputeRegionBackendServiceCdnPolicyNegativeCachingPolicyCode(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 flattenComputeRegionBackendServiceCdnPolicyNegativeCachingPolicyTtl(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 flattenComputeRegionBackendServiceCdnPolicyCacheMode(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenComputeRegionBackendServiceCdnPolicyServeWhileStale(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 flattenComputeRegionBackendServiceConnectionDraining(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["connection_draining_timeout_sec"] = |
| flattenComputeRegionBackendServiceConnectionDrainingConnectionDrainingTimeoutSec(original["drainingTimeoutSec"], d, config) |
| return []interface{}{transformed} |
| } |
| func flattenComputeRegionBackendServiceConnectionDrainingConnectionDrainingTimeoutSec(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 flattenComputeRegionBackendServiceCreationTimestamp(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenComputeRegionBackendServiceDescription(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenComputeRegionBackendServiceFailoverPolicy(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["disable_connection_drain_on_failover"] = |
| flattenComputeRegionBackendServiceFailoverPolicyDisableConnectionDrainOnFailover(original["disableConnectionDrainOnFailover"], d, config) |
| transformed["drop_traffic_if_unhealthy"] = |
| flattenComputeRegionBackendServiceFailoverPolicyDropTrafficIfUnhealthy(original["dropTrafficIfUnhealthy"], d, config) |
| transformed["failover_ratio"] = |
| flattenComputeRegionBackendServiceFailoverPolicyFailoverRatio(original["failoverRatio"], d, config) |
| return []interface{}{transformed} |
| } |
| func flattenComputeRegionBackendServiceFailoverPolicyDisableConnectionDrainOnFailover(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenComputeRegionBackendServiceFailoverPolicyDropTrafficIfUnhealthy(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenComputeRegionBackendServiceFailoverPolicyFailoverRatio(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenComputeRegionBackendServiceEnableCDN(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenComputeRegionBackendServiceFingerprint(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenComputeRegionBackendServiceHealthChecks(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| if v == nil { |
| return v |
| } |
| return tpgresource.ConvertAndMapStringArr(v.([]interface{}), tpgresource.ConvertSelfLinkToV1) |
| } |
| |
| func flattenComputeRegionBackendServiceIap(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["oauth2_client_id"] = |
| flattenComputeRegionBackendServiceIapOauth2ClientId(original["oauth2ClientId"], d, config) |
| transformed["oauth2_client_secret"] = |
| flattenComputeRegionBackendServiceIapOauth2ClientSecret(original["oauth2ClientSecret"], d, config) |
| transformed["oauth2_client_secret_sha256"] = |
| flattenComputeRegionBackendServiceIapOauth2ClientSecretSha256(original["oauth2ClientSecretSha256"], d, config) |
| return []interface{}{transformed} |
| } |
| func flattenComputeRegionBackendServiceIapOauth2ClientId(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenComputeRegionBackendServiceIapOauth2ClientSecret(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return d.Get("iap.0.oauth2_client_secret") |
| } |
| |
| func flattenComputeRegionBackendServiceIapOauth2ClientSecretSha256(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenComputeRegionBackendServiceLoadBalancingScheme(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenComputeRegionBackendServiceLocalityLbPolicy(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenComputeRegionBackendServiceName(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenComputeRegionBackendServiceOutlierDetection(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["base_ejection_time"] = |
| flattenComputeRegionBackendServiceOutlierDetectionBaseEjectionTime(original["baseEjectionTime"], d, config) |
| transformed["consecutive_errors"] = |
| flattenComputeRegionBackendServiceOutlierDetectionConsecutiveErrors(original["consecutiveErrors"], d, config) |
| transformed["consecutive_gateway_failure"] = |
| flattenComputeRegionBackendServiceOutlierDetectionConsecutiveGatewayFailure(original["consecutiveGatewayFailure"], d, config) |
| transformed["enforcing_consecutive_errors"] = |
| flattenComputeRegionBackendServiceOutlierDetectionEnforcingConsecutiveErrors(original["enforcingConsecutiveErrors"], d, config) |
| transformed["enforcing_consecutive_gateway_failure"] = |
| flattenComputeRegionBackendServiceOutlierDetectionEnforcingConsecutiveGatewayFailure(original["enforcingConsecutiveGatewayFailure"], d, config) |
| transformed["enforcing_success_rate"] = |
| flattenComputeRegionBackendServiceOutlierDetectionEnforcingSuccessRate(original["enforcingSuccessRate"], d, config) |
| transformed["interval"] = |
| flattenComputeRegionBackendServiceOutlierDetectionInterval(original["interval"], d, config) |
| transformed["max_ejection_percent"] = |
| flattenComputeRegionBackendServiceOutlierDetectionMaxEjectionPercent(original["maxEjectionPercent"], d, config) |
| transformed["success_rate_minimum_hosts"] = |
| flattenComputeRegionBackendServiceOutlierDetectionSuccessRateMinimumHosts(original["successRateMinimumHosts"], d, config) |
| transformed["success_rate_request_volume"] = |
| flattenComputeRegionBackendServiceOutlierDetectionSuccessRateRequestVolume(original["successRateRequestVolume"], d, config) |
| transformed["success_rate_stdev_factor"] = |
| flattenComputeRegionBackendServiceOutlierDetectionSuccessRateStdevFactor(original["successRateStdevFactor"], d, config) |
| return []interface{}{transformed} |
| } |
| func flattenComputeRegionBackendServiceOutlierDetectionBaseEjectionTime(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"] = |
| flattenComputeRegionBackendServiceOutlierDetectionBaseEjectionTimeSeconds(original["seconds"], d, config) |
| transformed["nanos"] = |
| flattenComputeRegionBackendServiceOutlierDetectionBaseEjectionTimeNanos(original["nanos"], d, config) |
| return []interface{}{transformed} |
| } |
| func flattenComputeRegionBackendServiceOutlierDetectionBaseEjectionTimeSeconds(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 flattenComputeRegionBackendServiceOutlierDetectionBaseEjectionTimeNanos(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 flattenComputeRegionBackendServiceOutlierDetectionConsecutiveErrors(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 flattenComputeRegionBackendServiceOutlierDetectionConsecutiveGatewayFailure(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 flattenComputeRegionBackendServiceOutlierDetectionEnforcingConsecutiveErrors(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 flattenComputeRegionBackendServiceOutlierDetectionEnforcingConsecutiveGatewayFailure(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 flattenComputeRegionBackendServiceOutlierDetectionEnforcingSuccessRate(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 flattenComputeRegionBackendServiceOutlierDetectionInterval(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"] = |
| flattenComputeRegionBackendServiceOutlierDetectionIntervalSeconds(original["seconds"], d, config) |
| transformed["nanos"] = |
| flattenComputeRegionBackendServiceOutlierDetectionIntervalNanos(original["nanos"], d, config) |
| return []interface{}{transformed} |
| } |
| func flattenComputeRegionBackendServiceOutlierDetectionIntervalSeconds(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 flattenComputeRegionBackendServiceOutlierDetectionIntervalNanos(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 flattenComputeRegionBackendServiceOutlierDetectionMaxEjectionPercent(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 flattenComputeRegionBackendServiceOutlierDetectionSuccessRateMinimumHosts(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 flattenComputeRegionBackendServiceOutlierDetectionSuccessRateRequestVolume(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 flattenComputeRegionBackendServiceOutlierDetectionSuccessRateStdevFactor(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 flattenComputeRegionBackendServicePortName(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenComputeRegionBackendServiceProtocol(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenComputeRegionBackendServiceSecurityPolicy(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenComputeRegionBackendServiceSessionAffinity(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenComputeRegionBackendServiceConnectionTrackingPolicy(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["idle_timeout_sec"] = |
| flattenComputeRegionBackendServiceConnectionTrackingPolicyIdleTimeoutSec(original["idleTimeoutSec"], d, config) |
| transformed["tracking_mode"] = |
| flattenComputeRegionBackendServiceConnectionTrackingPolicyTrackingMode(original["trackingMode"], d, config) |
| transformed["connection_persistence_on_unhealthy_backends"] = |
| flattenComputeRegionBackendServiceConnectionTrackingPolicyConnectionPersistenceOnUnhealthyBackends(original["connectionPersistenceOnUnhealthyBackends"], d, config) |
| transformed["enable_strong_affinity"] = |
| flattenComputeRegionBackendServiceConnectionTrackingPolicyEnableStrongAffinity(original["enableStrongAffinity"], d, config) |
| return []interface{}{transformed} |
| } |
| func flattenComputeRegionBackendServiceConnectionTrackingPolicyIdleTimeoutSec(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 flattenComputeRegionBackendServiceConnectionTrackingPolicyTrackingMode(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenComputeRegionBackendServiceConnectionTrackingPolicyConnectionPersistenceOnUnhealthyBackends(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenComputeRegionBackendServiceConnectionTrackingPolicyEnableStrongAffinity(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenComputeRegionBackendServiceTimeoutSec(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 flattenComputeRegionBackendServiceLogConfig(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["enable"] = |
| flattenComputeRegionBackendServiceLogConfigEnable(original["enable"], d, config) |
| transformed["sample_rate"] = |
| flattenComputeRegionBackendServiceLogConfigSampleRate(original["sampleRate"], d, config) |
| return []interface{}{transformed} |
| } |
| func flattenComputeRegionBackendServiceLogConfigEnable(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenComputeRegionBackendServiceLogConfigSampleRate(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenComputeRegionBackendServiceNetwork(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| if v == nil { |
| return v |
| } |
| return tpgresource.ConvertSelfLinkToV1(v.(string)) |
| } |
| |
| func flattenComputeRegionBackendServiceSubsetting(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["policy"] = |
| flattenComputeRegionBackendServiceSubsettingPolicy(original["policy"], d, config) |
| return []interface{}{transformed} |
| } |
| func flattenComputeRegionBackendServiceSubsettingPolicy(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| return v |
| } |
| |
| func flattenComputeRegionBackendServiceRegion(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { |
| if v == nil { |
| return v |
| } |
| return tpgresource.NameFromSelfLinkStateFunc(v) |
| } |
| |
| func expandComputeRegionBackendServiceAffinityCookieTtlSec(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceBackend(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| v = v.(*schema.Set).List() |
| l := v.([]interface{}) |
| req := make([]interface{}, 0, len(l)) |
| for _, raw := range l { |
| if raw == nil { |
| continue |
| } |
| original := raw.(map[string]interface{}) |
| transformed := make(map[string]interface{}) |
| |
| transformedBalancingMode, err := expandComputeRegionBackendServiceBackendBalancingMode(original["balancing_mode"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedBalancingMode); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["balancingMode"] = transformedBalancingMode |
| } |
| |
| transformedCapacityScaler, err := expandComputeRegionBackendServiceBackendCapacityScaler(original["capacity_scaler"], d, config) |
| if err != nil { |
| return nil, err |
| } else { |
| transformed["capacityScaler"] = transformedCapacityScaler |
| } |
| |
| transformedDescription, err := expandComputeRegionBackendServiceBackendDescription(original["description"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedDescription); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["description"] = transformedDescription |
| } |
| |
| transformedFailover, err := expandComputeRegionBackendServiceBackendFailover(original["failover"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedFailover); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["failover"] = transformedFailover |
| } |
| |
| transformedGroup, err := expandComputeRegionBackendServiceBackendGroup(original["group"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedGroup); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["group"] = transformedGroup |
| } |
| |
| transformedMaxConnections, err := expandComputeRegionBackendServiceBackendMaxConnections(original["max_connections"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedMaxConnections); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["maxConnections"] = transformedMaxConnections |
| } |
| |
| transformedMaxConnectionsPerInstance, err := expandComputeRegionBackendServiceBackendMaxConnectionsPerInstance(original["max_connections_per_instance"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedMaxConnectionsPerInstance); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["maxConnectionsPerInstance"] = transformedMaxConnectionsPerInstance |
| } |
| |
| transformedMaxConnectionsPerEndpoint, err := expandComputeRegionBackendServiceBackendMaxConnectionsPerEndpoint(original["max_connections_per_endpoint"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedMaxConnectionsPerEndpoint); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["maxConnectionsPerEndpoint"] = transformedMaxConnectionsPerEndpoint |
| } |
| |
| transformedMaxRate, err := expandComputeRegionBackendServiceBackendMaxRate(original["max_rate"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedMaxRate); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["maxRate"] = transformedMaxRate |
| } |
| |
| transformedMaxRatePerInstance, err := expandComputeRegionBackendServiceBackendMaxRatePerInstance(original["max_rate_per_instance"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedMaxRatePerInstance); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["maxRatePerInstance"] = transformedMaxRatePerInstance |
| } |
| |
| transformedMaxRatePerEndpoint, err := expandComputeRegionBackendServiceBackendMaxRatePerEndpoint(original["max_rate_per_endpoint"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedMaxRatePerEndpoint); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["maxRatePerEndpoint"] = transformedMaxRatePerEndpoint |
| } |
| |
| transformedMaxUtilization, err := expandComputeRegionBackendServiceBackendMaxUtilization(original["max_utilization"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedMaxUtilization); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["maxUtilization"] = transformedMaxUtilization |
| } |
| |
| req = append(req, transformed) |
| } |
| return req, nil |
| } |
| |
| func expandComputeRegionBackendServiceBackendBalancingMode(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceBackendCapacityScaler(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceBackendDescription(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceBackendFailover(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceBackendGroup(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceBackendMaxConnections(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceBackendMaxConnectionsPerInstance(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceBackendMaxConnectionsPerEndpoint(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceBackendMaxRate(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceBackendMaxRatePerInstance(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceBackendMaxRatePerEndpoint(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceBackendMaxUtilization(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceCircuitBreakers(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{}) |
| |
| transformedConnectTimeout, err := expandComputeRegionBackendServiceCircuitBreakersConnectTimeout(original["connect_timeout"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedConnectTimeout); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["connectTimeout"] = transformedConnectTimeout |
| } |
| |
| transformedMaxRequestsPerConnection, err := expandComputeRegionBackendServiceCircuitBreakersMaxRequestsPerConnection(original["max_requests_per_connection"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedMaxRequestsPerConnection); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["maxRequestsPerConnection"] = transformedMaxRequestsPerConnection |
| } |
| |
| transformedMaxConnections, err := expandComputeRegionBackendServiceCircuitBreakersMaxConnections(original["max_connections"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedMaxConnections); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["maxConnections"] = transformedMaxConnections |
| } |
| |
| transformedMaxPendingRequests, err := expandComputeRegionBackendServiceCircuitBreakersMaxPendingRequests(original["max_pending_requests"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedMaxPendingRequests); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["maxPendingRequests"] = transformedMaxPendingRequests |
| } |
| |
| transformedMaxRequests, err := expandComputeRegionBackendServiceCircuitBreakersMaxRequests(original["max_requests"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedMaxRequests); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["maxRequests"] = transformedMaxRequests |
| } |
| |
| transformedMaxRetries, err := expandComputeRegionBackendServiceCircuitBreakersMaxRetries(original["max_retries"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedMaxRetries); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["maxRetries"] = transformedMaxRetries |
| } |
| |
| return transformed, nil |
| } |
| |
| func expandComputeRegionBackendServiceCircuitBreakersConnectTimeout(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 := expandComputeRegionBackendServiceCircuitBreakersConnectTimeoutSeconds(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 := expandComputeRegionBackendServiceCircuitBreakersConnectTimeoutNanos(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 expandComputeRegionBackendServiceCircuitBreakersConnectTimeoutSeconds(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceCircuitBreakersConnectTimeoutNanos(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceCircuitBreakersMaxRequestsPerConnection(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceCircuitBreakersMaxConnections(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceCircuitBreakersMaxPendingRequests(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceCircuitBreakersMaxRequests(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceCircuitBreakersMaxRetries(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceConsistentHash(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{}) |
| |
| transformedHttpCookie, err := expandComputeRegionBackendServiceConsistentHashHttpCookie(original["http_cookie"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedHttpCookie); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["httpCookie"] = transformedHttpCookie |
| } |
| |
| transformedHttpHeaderName, err := expandComputeRegionBackendServiceConsistentHashHttpHeaderName(original["http_header_name"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedHttpHeaderName); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["httpHeaderName"] = transformedHttpHeaderName |
| } |
| |
| transformedMinimumRingSize, err := expandComputeRegionBackendServiceConsistentHashMinimumRingSize(original["minimum_ring_size"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedMinimumRingSize); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["minimumRingSize"] = transformedMinimumRingSize |
| } |
| |
| return transformed, nil |
| } |
| |
| func expandComputeRegionBackendServiceConsistentHashHttpCookie(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{}) |
| |
| transformedTtl, err := expandComputeRegionBackendServiceConsistentHashHttpCookieTtl(original["ttl"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedTtl); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["ttl"] = transformedTtl |
| } |
| |
| transformedName, err := expandComputeRegionBackendServiceConsistentHashHttpCookieName(original["name"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedName); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["name"] = transformedName |
| } |
| |
| transformedPath, err := expandComputeRegionBackendServiceConsistentHashHttpCookiePath(original["path"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedPath); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["path"] = transformedPath |
| } |
| |
| return transformed, nil |
| } |
| |
| func expandComputeRegionBackendServiceConsistentHashHttpCookieTtl(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 := expandComputeRegionBackendServiceConsistentHashHttpCookieTtlSeconds(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 := expandComputeRegionBackendServiceConsistentHashHttpCookieTtlNanos(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 expandComputeRegionBackendServiceConsistentHashHttpCookieTtlSeconds(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceConsistentHashHttpCookieTtlNanos(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceConsistentHashHttpCookieName(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceConsistentHashHttpCookiePath(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceConsistentHashHttpHeaderName(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceConsistentHashMinimumRingSize(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceCdnPolicy(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{}) |
| |
| transformedCacheKeyPolicy, err := expandComputeRegionBackendServiceCdnPolicyCacheKeyPolicy(original["cache_key_policy"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedCacheKeyPolicy); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["cacheKeyPolicy"] = transformedCacheKeyPolicy |
| } |
| |
| transformedSignedUrlCacheMaxAgeSec, err := expandComputeRegionBackendServiceCdnPolicySignedUrlCacheMaxAgeSec(original["signed_url_cache_max_age_sec"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedSignedUrlCacheMaxAgeSec); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["signedUrlCacheMaxAgeSec"] = transformedSignedUrlCacheMaxAgeSec |
| } |
| |
| transformedDefaultTtl, err := expandComputeRegionBackendServiceCdnPolicyDefaultTtl(original["default_ttl"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedDefaultTtl); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["defaultTtl"] = transformedDefaultTtl |
| } |
| |
| transformedMaxTtl, err := expandComputeRegionBackendServiceCdnPolicyMaxTtl(original["max_ttl"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedMaxTtl); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["maxTtl"] = transformedMaxTtl |
| } |
| |
| transformedClientTtl, err := expandComputeRegionBackendServiceCdnPolicyClientTtl(original["client_ttl"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedClientTtl); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["clientTtl"] = transformedClientTtl |
| } |
| |
| transformedNegativeCaching, err := expandComputeRegionBackendServiceCdnPolicyNegativeCaching(original["negative_caching"], d, config) |
| if err != nil { |
| return nil, err |
| } else { |
| transformed["negativeCaching"] = transformedNegativeCaching |
| } |
| |
| transformedNegativeCachingPolicy, err := expandComputeRegionBackendServiceCdnPolicyNegativeCachingPolicy(original["negative_caching_policy"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedNegativeCachingPolicy); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["negativeCachingPolicy"] = transformedNegativeCachingPolicy |
| } |
| |
| transformedCacheMode, err := expandComputeRegionBackendServiceCdnPolicyCacheMode(original["cache_mode"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedCacheMode); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["cacheMode"] = transformedCacheMode |
| } |
| |
| transformedServeWhileStale, err := expandComputeRegionBackendServiceCdnPolicyServeWhileStale(original["serve_while_stale"], d, config) |
| if err != nil { |
| return nil, err |
| } else { |
| transformed["serveWhileStale"] = transformedServeWhileStale |
| } |
| |
| return transformed, nil |
| } |
| |
| func expandComputeRegionBackendServiceCdnPolicyCacheKeyPolicy(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{}) |
| |
| transformedIncludeHost, err := expandComputeRegionBackendServiceCdnPolicyCacheKeyPolicyIncludeHost(original["include_host"], d, config) |
| if err != nil { |
| return nil, err |
| } else { |
| transformed["includeHost"] = transformedIncludeHost |
| } |
| |
| transformedIncludeProtocol, err := expandComputeRegionBackendServiceCdnPolicyCacheKeyPolicyIncludeProtocol(original["include_protocol"], d, config) |
| if err != nil { |
| return nil, err |
| } else { |
| transformed["includeProtocol"] = transformedIncludeProtocol |
| } |
| |
| transformedIncludeQueryString, err := expandComputeRegionBackendServiceCdnPolicyCacheKeyPolicyIncludeQueryString(original["include_query_string"], d, config) |
| if err != nil { |
| return nil, err |
| } else { |
| transformed["includeQueryString"] = transformedIncludeQueryString |
| } |
| |
| transformedQueryStringBlacklist, err := expandComputeRegionBackendServiceCdnPolicyCacheKeyPolicyQueryStringBlacklist(original["query_string_blacklist"], d, config) |
| if err != nil { |
| return nil, err |
| } else { |
| transformed["queryStringBlacklist"] = transformedQueryStringBlacklist |
| } |
| |
| transformedQueryStringWhitelist, err := expandComputeRegionBackendServiceCdnPolicyCacheKeyPolicyQueryStringWhitelist(original["query_string_whitelist"], d, config) |
| if err != nil { |
| return nil, err |
| } else { |
| transformed["queryStringWhitelist"] = transformedQueryStringWhitelist |
| } |
| |
| transformedIncludeNamedCookies, err := expandComputeRegionBackendServiceCdnPolicyCacheKeyPolicyIncludeNamedCookies(original["include_named_cookies"], d, config) |
| if err != nil { |
| return nil, err |
| } else { |
| transformed["includeNamedCookies"] = transformedIncludeNamedCookies |
| } |
| |
| return transformed, nil |
| } |
| |
| func expandComputeRegionBackendServiceCdnPolicyCacheKeyPolicyIncludeHost(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceCdnPolicyCacheKeyPolicyIncludeProtocol(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceCdnPolicyCacheKeyPolicyIncludeQueryString(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceCdnPolicyCacheKeyPolicyQueryStringBlacklist(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| v = v.(*schema.Set).List() |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceCdnPolicyCacheKeyPolicyQueryStringWhitelist(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| v = v.(*schema.Set).List() |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceCdnPolicyCacheKeyPolicyIncludeNamedCookies(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceCdnPolicySignedUrlCacheMaxAgeSec(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceCdnPolicyDefaultTtl(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceCdnPolicyMaxTtl(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceCdnPolicyClientTtl(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceCdnPolicyNegativeCaching(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceCdnPolicyNegativeCachingPolicy(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| l := v.([]interface{}) |
| req := make([]interface{}, 0, len(l)) |
| for _, raw := range l { |
| if raw == nil { |
| continue |
| } |
| original := raw.(map[string]interface{}) |
| transformed := make(map[string]interface{}) |
| |
| transformedCode, err := expandComputeRegionBackendServiceCdnPolicyNegativeCachingPolicyCode(original["code"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedCode); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["code"] = transformedCode |
| } |
| |
| transformedTtl, err := expandComputeRegionBackendServiceCdnPolicyNegativeCachingPolicyTtl(original["ttl"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedTtl); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["ttl"] = transformedTtl |
| } |
| |
| req = append(req, transformed) |
| } |
| return req, nil |
| } |
| |
| func expandComputeRegionBackendServiceCdnPolicyNegativeCachingPolicyCode(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceCdnPolicyNegativeCachingPolicyTtl(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceCdnPolicyCacheMode(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceCdnPolicyServeWhileStale(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceConnectionDraining(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| transformed := make(map[string]interface{}) |
| transformedConnectionDrainingTimeoutSec, err := expandComputeRegionBackendServiceConnectionDrainingConnectionDrainingTimeoutSec(d.Get("connection_draining_timeout_sec"), d, config) |
| if err != nil { |
| return nil, err |
| } else { |
| transformed["drainingTimeoutSec"] = transformedConnectionDrainingTimeoutSec |
| } |
| |
| return transformed, nil |
| } |
| |
| func expandComputeRegionBackendServiceConnectionDrainingConnectionDrainingTimeoutSec(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceDescription(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceFailoverPolicy(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{}) |
| |
| transformedDisableConnectionDrainOnFailover, err := expandComputeRegionBackendServiceFailoverPolicyDisableConnectionDrainOnFailover(original["disable_connection_drain_on_failover"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedDisableConnectionDrainOnFailover); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["disableConnectionDrainOnFailover"] = transformedDisableConnectionDrainOnFailover |
| } |
| |
| transformedDropTrafficIfUnhealthy, err := expandComputeRegionBackendServiceFailoverPolicyDropTrafficIfUnhealthy(original["drop_traffic_if_unhealthy"], d, config) |
| if err != nil { |
| return nil, err |
| } else { |
| transformed["dropTrafficIfUnhealthy"] = transformedDropTrafficIfUnhealthy |
| } |
| |
| transformedFailoverRatio, err := expandComputeRegionBackendServiceFailoverPolicyFailoverRatio(original["failover_ratio"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedFailoverRatio); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["failoverRatio"] = transformedFailoverRatio |
| } |
| |
| return transformed, nil |
| } |
| |
| func expandComputeRegionBackendServiceFailoverPolicyDisableConnectionDrainOnFailover(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceFailoverPolicyDropTrafficIfUnhealthy(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceFailoverPolicyFailoverRatio(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceEnableCDN(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceFingerprint(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceHealthChecks(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| v = v.(*schema.Set).List() |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceIap(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{}) |
| |
| transformedOauth2ClientId, err := expandComputeRegionBackendServiceIapOauth2ClientId(original["oauth2_client_id"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedOauth2ClientId); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["oauth2ClientId"] = transformedOauth2ClientId |
| } |
| |
| transformedOauth2ClientSecret, err := expandComputeRegionBackendServiceIapOauth2ClientSecret(original["oauth2_client_secret"], d, config) |
| if err != nil { |
| return nil, err |
| } else { |
| transformed["oauth2ClientSecret"] = transformedOauth2ClientSecret |
| } |
| |
| transformedOauth2ClientSecretSha256, err := expandComputeRegionBackendServiceIapOauth2ClientSecretSha256(original["oauth2_client_secret_sha256"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedOauth2ClientSecretSha256); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["oauth2ClientSecretSha256"] = transformedOauth2ClientSecretSha256 |
| } |
| |
| return transformed, nil |
| } |
| |
| func expandComputeRegionBackendServiceIapOauth2ClientId(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceIapOauth2ClientSecret(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceIapOauth2ClientSecretSha256(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceLoadBalancingScheme(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceLocalityLbPolicy(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceName(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceOutlierDetection(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{}) |
| |
| transformedBaseEjectionTime, err := expandComputeRegionBackendServiceOutlierDetectionBaseEjectionTime(original["base_ejection_time"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedBaseEjectionTime); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["baseEjectionTime"] = transformedBaseEjectionTime |
| } |
| |
| transformedConsecutiveErrors, err := expandComputeRegionBackendServiceOutlierDetectionConsecutiveErrors(original["consecutive_errors"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedConsecutiveErrors); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["consecutiveErrors"] = transformedConsecutiveErrors |
| } |
| |
| transformedConsecutiveGatewayFailure, err := expandComputeRegionBackendServiceOutlierDetectionConsecutiveGatewayFailure(original["consecutive_gateway_failure"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedConsecutiveGatewayFailure); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["consecutiveGatewayFailure"] = transformedConsecutiveGatewayFailure |
| } |
| |
| transformedEnforcingConsecutiveErrors, err := expandComputeRegionBackendServiceOutlierDetectionEnforcingConsecutiveErrors(original["enforcing_consecutive_errors"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedEnforcingConsecutiveErrors); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["enforcingConsecutiveErrors"] = transformedEnforcingConsecutiveErrors |
| } |
| |
| transformedEnforcingConsecutiveGatewayFailure, err := expandComputeRegionBackendServiceOutlierDetectionEnforcingConsecutiveGatewayFailure(original["enforcing_consecutive_gateway_failure"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedEnforcingConsecutiveGatewayFailure); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["enforcingConsecutiveGatewayFailure"] = transformedEnforcingConsecutiveGatewayFailure |
| } |
| |
| transformedEnforcingSuccessRate, err := expandComputeRegionBackendServiceOutlierDetectionEnforcingSuccessRate(original["enforcing_success_rate"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedEnforcingSuccessRate); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["enforcingSuccessRate"] = transformedEnforcingSuccessRate |
| } |
| |
| transformedInterval, err := expandComputeRegionBackendServiceOutlierDetectionInterval(original["interval"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedInterval); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["interval"] = transformedInterval |
| } |
| |
| transformedMaxEjectionPercent, err := expandComputeRegionBackendServiceOutlierDetectionMaxEjectionPercent(original["max_ejection_percent"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedMaxEjectionPercent); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["maxEjectionPercent"] = transformedMaxEjectionPercent |
| } |
| |
| transformedSuccessRateMinimumHosts, err := expandComputeRegionBackendServiceOutlierDetectionSuccessRateMinimumHosts(original["success_rate_minimum_hosts"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedSuccessRateMinimumHosts); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["successRateMinimumHosts"] = transformedSuccessRateMinimumHosts |
| } |
| |
| transformedSuccessRateRequestVolume, err := expandComputeRegionBackendServiceOutlierDetectionSuccessRateRequestVolume(original["success_rate_request_volume"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedSuccessRateRequestVolume); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["successRateRequestVolume"] = transformedSuccessRateRequestVolume |
| } |
| |
| transformedSuccessRateStdevFactor, err := expandComputeRegionBackendServiceOutlierDetectionSuccessRateStdevFactor(original["success_rate_stdev_factor"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedSuccessRateStdevFactor); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["successRateStdevFactor"] = transformedSuccessRateStdevFactor |
| } |
| |
| return transformed, nil |
| } |
| |
| func expandComputeRegionBackendServiceOutlierDetectionBaseEjectionTime(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 := expandComputeRegionBackendServiceOutlierDetectionBaseEjectionTimeSeconds(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 := expandComputeRegionBackendServiceOutlierDetectionBaseEjectionTimeNanos(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 expandComputeRegionBackendServiceOutlierDetectionBaseEjectionTimeSeconds(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceOutlierDetectionBaseEjectionTimeNanos(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceOutlierDetectionConsecutiveErrors(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceOutlierDetectionConsecutiveGatewayFailure(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceOutlierDetectionEnforcingConsecutiveErrors(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceOutlierDetectionEnforcingConsecutiveGatewayFailure(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceOutlierDetectionEnforcingSuccessRate(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceOutlierDetectionInterval(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 := expandComputeRegionBackendServiceOutlierDetectionIntervalSeconds(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 := expandComputeRegionBackendServiceOutlierDetectionIntervalNanos(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 expandComputeRegionBackendServiceOutlierDetectionIntervalSeconds(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceOutlierDetectionIntervalNanos(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceOutlierDetectionMaxEjectionPercent(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceOutlierDetectionSuccessRateMinimumHosts(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceOutlierDetectionSuccessRateRequestVolume(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceOutlierDetectionSuccessRateStdevFactor(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServicePortName(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceProtocol(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceSecurityPolicy(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceSessionAffinity(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceConnectionTrackingPolicy(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{}) |
| |
| transformedIdleTimeoutSec, err := expandComputeRegionBackendServiceConnectionTrackingPolicyIdleTimeoutSec(original["idle_timeout_sec"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedIdleTimeoutSec); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["idleTimeoutSec"] = transformedIdleTimeoutSec |
| } |
| |
| transformedTrackingMode, err := expandComputeRegionBackendServiceConnectionTrackingPolicyTrackingMode(original["tracking_mode"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedTrackingMode); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["trackingMode"] = transformedTrackingMode |
| } |
| |
| transformedConnectionPersistenceOnUnhealthyBackends, err := expandComputeRegionBackendServiceConnectionTrackingPolicyConnectionPersistenceOnUnhealthyBackends(original["connection_persistence_on_unhealthy_backends"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedConnectionPersistenceOnUnhealthyBackends); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["connectionPersistenceOnUnhealthyBackends"] = transformedConnectionPersistenceOnUnhealthyBackends |
| } |
| |
| transformedEnableStrongAffinity, err := expandComputeRegionBackendServiceConnectionTrackingPolicyEnableStrongAffinity(original["enable_strong_affinity"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedEnableStrongAffinity); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["enableStrongAffinity"] = transformedEnableStrongAffinity |
| } |
| |
| return transformed, nil |
| } |
| |
| func expandComputeRegionBackendServiceConnectionTrackingPolicyIdleTimeoutSec(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceConnectionTrackingPolicyTrackingMode(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceConnectionTrackingPolicyConnectionPersistenceOnUnhealthyBackends(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceConnectionTrackingPolicyEnableStrongAffinity(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceTimeoutSec(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceLogConfig(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{}) |
| |
| transformedEnable, err := expandComputeRegionBackendServiceLogConfigEnable(original["enable"], d, config) |
| if err != nil { |
| return nil, err |
| } else { |
| transformed["enable"] = transformedEnable |
| } |
| |
| transformedSampleRate, err := expandComputeRegionBackendServiceLogConfigSampleRate(original["sample_rate"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedSampleRate); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["sampleRate"] = transformedSampleRate |
| } |
| |
| return transformed, nil |
| } |
| |
| func expandComputeRegionBackendServiceLogConfigEnable(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceLogConfigSampleRate(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceNetwork(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| f, err := tpgresource.ParseGlobalFieldValue("networks", v.(string), "project", d, config, true) |
| if err != nil { |
| return nil, fmt.Errorf("Invalid value for network: %s", err) |
| } |
| return f.RelativeLink(), nil |
| } |
| |
| func expandComputeRegionBackendServiceSubsetting(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{}) |
| |
| transformedPolicy, err := expandComputeRegionBackendServiceSubsettingPolicy(original["policy"], d, config) |
| if err != nil { |
| return nil, err |
| } else if val := reflect.ValueOf(transformedPolicy); val.IsValid() && !tpgresource.IsEmptyValue(val) { |
| transformed["policy"] = transformedPolicy |
| } |
| |
| return transformed, nil |
| } |
| |
| func expandComputeRegionBackendServiceSubsettingPolicy(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { |
| return v, nil |
| } |
| |
| func expandComputeRegionBackendServiceRegion(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 { |
| return nil, fmt.Errorf("Invalid value for region: %s", err) |
| } |
| return f.RelativeLink(), nil |
| } |
| |
| func resourceComputeRegionBackendServiceEncoder(d *schema.ResourceData, meta interface{}, obj map[string]interface{}) (map[string]interface{}, error) { |
| // The RegionBackendService API's Update / PUT API is badly formed and behaves like |
| // a PATCH field for at least IAP. When sent a `null` `iap` field, the API |
| // doesn't disable an existing field. To work around this, we need to emulate |
| // the old Terraform behaviour of always sending the block (at both update and |
| // create), and force sending each subfield as empty when the block isn't |
| // present in config. |
| |
| iapVal := obj["iap"] |
| if iapVal == nil { |
| data := map[string]interface{}{} |
| data["enabled"] = false |
| obj["iap"] = data |
| } else { |
| iap := iapVal.(map[string]interface{}) |
| iap["enabled"] = true |
| obj["iap"] = iap |
| } |
| |
| if d.Get("load_balancing_scheme").(string) == "EXTERNAL_MANAGED" || d.Get("load_balancing_scheme").(string) == "INTERNAL_MANAGED" { |
| return obj, nil |
| } |
| |
| // To remove subsetting on an ILB, "NONE" must be specified. If subsetting |
| // isn't specified, we set the value to NONE to make this use case work. |
| _, ok := obj["subsetting"] |
| if !ok { |
| loadBalancingScheme, ok := obj["loadBalancingScheme"] |
| // External load balancing scheme does not support subsetting |
| if !ok || loadBalancingScheme.(string) != "EXTERNAL" { |
| data := map[string]interface{}{} |
| data["policy"] = "NONE" |
| obj["subsetting"] = data |
| } |
| } |
| |
| backendServiceOnlyManagedApiFieldNames := []string{ |
| "capacityScaler", |
| "maxConnections", |
| "maxConnectionsPerInstance", |
| "maxConnectionsPerEndpoint", |
| "maxRate", |
| "maxRatePerInstance", |
| "maxRatePerEndpoint", |
| "maxUtilization", |
| } |
| |
| var backends []interface{} |
| if lsV := obj["backends"]; lsV != nil { |
| backends = lsV.([]interface{}) |
| } |
| for idx, v := range backends { |
| if v == nil { |
| continue |
| } |
| backend := v.(map[string]interface{}) |
| // Remove fields from backends that cannot be sent for non-managed |
| // backend services |
| for _, k := range backendServiceOnlyManagedApiFieldNames { |
| log.Printf("[DEBUG] Removing field %q for request for non-managed backend service %s", k, d.Get("name")) |
| delete(backend, k) |
| } |
| backends[idx] = backend |
| } |
| |
| obj["backends"] = backends |
| return obj, nil |
| } |
| |
| func resourceComputeRegionBackendServiceDecoder(d *schema.ResourceData, meta interface{}, res map[string]interface{}) (map[string]interface{}, error) { |
| // We need to pretend IAP isn't there if it's disabled for Terraform to maintain |
| // BC behaviour with the handwritten resource. |
| v, ok := res["iap"] |
| if !ok || v == nil { |
| delete(res, "iap") |
| return res, nil |
| } |
| m := v.(map[string]interface{}) |
| if ok && m["enabled"] == false { |
| delete(res, "iap") |
| } |
| |
| // Since we add in a NONE subsetting policy, we need to remove it in some |
| // cases for backwards compatibility with the config |
| v, ok = res["subsetting"] |
| if ok && v != nil { |
| subsetting := v.(map[string]interface{}) |
| policy, ok := subsetting["policy"] |
| if ok && policy == "NONE" { |
| delete(res, "subsetting") |
| } |
| } |
| |
| // Requests with consistentHash will error for specific values of |
| // localityLbPolicy. However, the API will not remove it if the backend |
| // service is updated to from supporting to non-supporting localityLbPolicy |
| // (e.g. RING_HASH to RANDOM), which causes an error on subsequent update. |
| // In order to prevent errors, we ignore any consistentHash returned |
| // from the API when the localityLbPolicy doesn't support it. |
| if v, ok := res["localityLbPolicy"]; ok { |
| lbPolicy := v.(string) |
| if lbPolicy != "MAGLEV" && lbPolicy != "RING_HASH" { |
| delete(res, "consistentHash") |
| } |
| } |
| |
| return res, nil |
| } |
