ansible-collections/google.cloud
1
0
Fork 0
mirror of https://github.com/ansible-collections/google.cloud.git synced 2025-04-06 19:00:27 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

tests: enabling gcp_compute_backend_service test

Browse source 
with #393 merged, it is now possible to enable gcp_compute_backend_test.

Adding a temporary fix for server-normalized value of capacity_scaler,
which is resolving into perma-diff due to "1.0" != "1".
This commit is contained in:
Yusuke Tsutsumi 2022-11-05 18:49:50 +00:00 • committed by Yusuke Tsutsumi
parent da28bcb845
commit 5ea5ecda34
2 changed files with 421 additions and 272 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

690
plugins/modules/gcp_compute_backend_service.py
View file

@ -25,9 +25,13 @@ __metaclass__ = type
# Documentation # Documentation
################################################################################ ################################################################################
ANSIBLE_METADATA = {'metadata_version': '1.1', 'status': ["preview"], 'supported_by': 'community'} ANSIBLE_METADATA = {
"metadata_version": "1.1",
"status": ["preview"],
"supported_by": "community",
}
DOCUMENTATION = ''' DOCUMENTATION = """
--- ---
module: gcp_compute_backend_service module: gcp_compute_backend_service
description: description:
@ -736,9 +740,9 @@ notes:
- For authentication, you can set scopes using the C(GCP_SCOPES) env variable. - For authentication, you can set scopes using the C(GCP_SCOPES) env variable.
- Environment variables values will only be used if the playbook values are not set. - Environment variables values will only be used if the playbook values are not set.
- The I(service_account_email) and I(service_account_file) options are mutually exclusive. - The I(service_account_email) and I(service_account_file) options are mutually exclusive.
''' """
EXAMPLES = ''' EXAMPLES = """
- name: create a instance group - name: create a instance group
google.cloud.gcp_compute_instance_group: google.cloud.gcp_compute_instance_group:
name: instancegroup-backendservice name: instancegroup-backendservice
@ -774,9 +778,9 @@ EXAMPLES = '''
auth_kind: serviceaccount auth_kind: serviceaccount
service_account_file: "/tmp/auth.pem" service_account_file: "/tmp/auth.pem"
state: present state: present
''' """
RETURN = ''' RETURN = """
affinityCookieTtlSec: affinityCookieTtlSec:
description: description:
- Lifetime of cookies in seconds if session_affinity is GENERATED_COOKIE. If set - Lifetime of cookies in seconds if session_affinity is GENERATED_COOKIE. If set
@ -1394,7 +1398,7 @@ logConfig:
- The default value is 1.0. - The default value is 1.0.
returned: success returned: success
type: str type: str
''' """
################################################################################ ################################################################################
# Imports # Imports
@ -1421,128 +1425,159 @@ def main():
module = GcpModule( module = GcpModule(
argument_spec=dict( argument_spec=dict(
state=dict(default='present', choices=['present', 'absent'], type='str'), state=dict(default="present", choices=["present", "absent"], type="str"),
affinity_cookie_ttl_sec=dict(type='int'), affinity_cookie_ttl_sec=dict(type="int"),
fingerprint=dict(type='str'), fingerprint=dict(type="str"),
backends=dict( backends=dict(
type='list', type="list",
elements='dict', elements="dict",
options=dict( options=dict(
balancing_mode=dict(default='UTILIZATION', type='str'), balancing_mode=dict(default="UTILIZATION", type="str"),
capacity_scaler=dict(default=1.0, type='str'), # TODO: capacity_scaler does some value normalization
description=dict(type='str'), # server-side, so there needs to be a way to do proper
group=dict(required=True, type='str'), # value comparison.
max_connections=dict(type='int'), capacity_scaler=dict(default="1", type="str"),
max_connections_per_instance=dict(type='int'), description=dict(type="str"),
max_connections_per_endpoint=dict(type='int'), group=dict(required=True, type="str"),
max_rate=dict(type='int'), max_connections=dict(type="int"),
max_rate_per_instance=dict(type='str'), max_connections_per_instance=dict(type="int"),
max_rate_per_endpoint=dict(type='str'), max_connections_per_endpoint=dict(type="int"),
max_utilization=dict(type='str'), max_rate=dict(type="int"),
max_rate_per_instance=dict(type="str"),
max_rate_per_endpoint=dict(type="str"),
max_utilization=dict(type="str"),
), ),
), ),
circuit_breakers=dict( circuit_breakers=dict(
type='dict', type="dict",
options=dict( options=dict(
max_requests_per_connection=dict(type='int'), max_requests_per_connection=dict(type="int"),
max_connections=dict(default=1024, type='int'), max_connections=dict(default=1024, type="int"),
max_pending_requests=dict(default=1024, type='int'), max_pending_requests=dict(default=1024, type="int"),
max_requests=dict(default=1024, type='int'), max_requests=dict(default=1024, type="int"),
max_retries=dict(default=3, type='int'), max_retries=dict(default=3, type="int"),
), ),
), ),
consistent_hash=dict( consistent_hash=dict(
type='dict', type="dict",
options=dict( options=dict(
http_cookie=dict( http_cookie=dict(
type='dict', type="dict",
options=dict( options=dict(
ttl=dict(type='dict', options=dict(seconds=dict(required=True, type='int'), nanos=dict(type='int'))), ttl=dict(
name=dict(type='str'), type="dict",
path=dict(type='str'), options=dict(
seconds=dict(required=True, type="int"),
nanos=dict(type="int"),
),
),
name=dict(type="str"),
path=dict(type="str"),
), ),
), ),
http_header_name=dict(type='str'), http_header_name=dict(type="str"),
minimum_ring_size=dict(default=1024, type='int'), minimum_ring_size=dict(default=1024, type="int"),
), ),
), ),
cdn_policy=dict( cdn_policy=dict(
type='dict', type="dict",
options=dict( options=dict(
cache_key_policy=dict( cache_key_policy=dict(
type='dict', type="dict",
options=dict( options=dict(
include_host=dict(type='bool'), include_host=dict(type="bool"),
include_protocol=dict(type='bool'), include_protocol=dict(type="bool"),
include_query_string=dict(type='bool'), include_query_string=dict(type="bool"),
query_string_blacklist=dict(type='list', elements='str'), query_string_blacklist=dict(type="list", elements="str"),
query_string_whitelist=dict(type='list', elements='str'), query_string_whitelist=dict(type="list", elements="str"),
), ),
), ),
signed_url_cache_max_age_sec=dict(default=3600, type='int'), signed_url_cache_max_age_sec=dict(default=3600, type="int"),
default_ttl=dict(type='int'), default_ttl=dict(type="int"),
max_ttl=dict(type='int'), max_ttl=dict(type="int"),
client_ttl=dict(type='int'), client_ttl=dict(type="int"),
negative_caching=dict(type='bool'), negative_caching=dict(type="bool"),
negative_caching_policy=dict(type='list', elements='dict', options=dict(code=dict(type='int'), ttl=dict(type='int'))), negative_caching_policy=dict(
cache_mode=dict(type='str'), type="list",
serve_while_stale=dict(type='int'), elements="dict",
options=dict(code=dict(type="int"), ttl=dict(type="int")),
),
cache_mode=dict(type="str"),
serve_while_stale=dict(type="int"),
), ),
), ),
connection_draining=dict(type='dict', options=dict(draining_timeout_sec=dict(default=300, type='int'))), connection_draining=dict(
custom_request_headers=dict(type='list', elements='str'), type="dict",
custom_response_headers=dict(type='list', elements='str'), options=dict(draining_timeout_sec=dict(default=300, type="int")),
description=dict(type='str'), ),
enable_cdn=dict(type='bool'), custom_request_headers=dict(type="list", elements="str"),
health_checks=dict(type='list', elements='str'), custom_response_headers=dict(type="list", elements="str"),
description=dict(type="str"),
enable_cdn=dict(type="bool"),
health_checks=dict(type="list", elements="str"),
iap=dict( iap=dict(
type='dict', type="dict",
options=dict( options=dict(
enabled=dict(type='bool'), enabled=dict(type="bool"),
oauth2_client_id=dict(required=True, type='str'), oauth2_client_id=dict(required=True, type="str"),
oauth2_client_secret=dict(required=True, type='str', no_log=True), oauth2_client_secret=dict(required=True, type="str", no_log=True),
), ),
), ),
load_balancing_scheme=dict(default='EXTERNAL', type='str'), load_balancing_scheme=dict(default="EXTERNAL", type="str"),
locality_lb_policy=dict(type='str'), locality_lb_policy=dict(type="str"),
name=dict(required=True, type='str'), name=dict(required=True, type="str"),
outlier_detection=dict( outlier_detection=dict(
type='dict', type="dict",
options=dict( options=dict(
base_ejection_time=dict(type='dict', options=dict(seconds=dict(required=True, type='int'), nanos=dict(type='int'))), base_ejection_time=dict(
consecutive_errors=dict(default=5, type='int'), type="dict",
consecutive_gateway_failure=dict(default=5, type='int'), options=dict(
enforcing_consecutive_errors=dict(default=100, type='int'), seconds=dict(required=True, type="int"),
enforcing_consecutive_gateway_failure=dict(default=0, type='int'), nanos=dict(type="int"),
enforcing_success_rate=dict(default=100, type='int'), ),
interval=dict(type='dict', options=dict(seconds=dict(required=True, type='int'), nanos=dict(type='int'))), ),
max_ejection_percent=dict(default=10, type='int'), consecutive_errors=dict(default=5, type="int"),
success_rate_minimum_hosts=dict(default=5, type='int'), consecutive_gateway_failure=dict(default=5, type="int"),
success_rate_request_volume=dict(default=100, type='int'), enforcing_consecutive_errors=dict(default=100, type="int"),
success_rate_stdev_factor=dict(default=1900, type='int'), enforcing_consecutive_gateway_failure=dict(default=0, type="int"),
enforcing_success_rate=dict(default=100, type="int"),
interval=dict(
type="dict",
options=dict(
seconds=dict(required=True, type="int"),
nanos=dict(type="int"),
),
),
max_ejection_percent=dict(default=10, type="int"),
success_rate_minimum_hosts=dict(default=5, type="int"),
success_rate_request_volume=dict(default=100, type="int"),
success_rate_stdev_factor=dict(default=1900, type="int"),
), ),
), ),
port_name=dict(type='str'), port_name=dict(type="str"),
protocol=dict(type='str'), protocol=dict(type="str"),
security_policy=dict(type='str'), security_policy=dict(type="str"),
session_affinity=dict(type='str'), session_affinity=dict(type="str"),
timeout_sec=dict(type='int', aliases=['timeout_seconds']), timeout_sec=dict(type="int", aliases=["timeout_seconds"]),
log_config=dict(type='dict', options=dict(enable=dict(type='bool'), sample_rate=dict(type='str'))), log_config=dict(
type="dict",
options=dict(enable=dict(type="bool"), sample_rate=dict(type="str")),
),
) )
) )
if not module.params['scopes']: if not module.params["scopes"]:
module.params['scopes'] = ['https://www.googleapis.com/auth/compute'] module.params["scopes"] = ["https://www.googleapis.com/auth/compute"]
state = module.params['state'] state = module.params["state"]
kind = 'compute#backendService' kind = "compute#backendService"
fetch = fetch_resource(module, self_link(module), kind) fetch = fetch_resource(module, self_link(module), kind)
changed = False changed = False
if fetch: if fetch:
module.params['fingerprint'] = fetch['fingerprint'] module.params["fingerprint"] = fetch["fingerprint"]
if state == 'present': if state == "present":
if is_different(module, fetch): if is_different(module, fetch):
update(module, self_link(module), kind) update(module, self_link(module), kind)
fetch = fetch_resource(module, self_link(module), kind) fetch = fetch_resource(module, self_link(module), kind)
@ -1552,58 +1587,72 @@ def main():
fetch = {} fetch = {}
changed = True changed = True
else: else:
if state == 'present': if state == "present":
fetch = create(module, collection(module), kind) fetch = create(module, collection(module), kind)
changed = True changed = True
else: else:
fetch = {} fetch = {}
fetch.update({'changed': changed}) fetch.update({"changed": changed})
module.exit_json(**fetch) module.exit_json(**fetch)
def create(module, link, kind): def create(module, link, kind):
auth = GcpSession(module, 'compute') auth = GcpSession(module, "compute")
return wait_for_operation(module, auth.post(link, resource_to_request(module))) return wait_for_operation(module, auth.post(link, resource_to_request(module)))
def update(module, link, kind): def update(module, link, kind):
auth = GcpSession(module, 'compute') auth = GcpSession(module, "compute")
return wait_for_operation(module, auth.put(link, resource_to_request(module))) return wait_for_operation(module, auth.put(link, resource_to_request(module)))
def delete(module, link, kind): def delete(module, link, kind):
auth = GcpSession(module, 'compute') auth = GcpSession(module, "compute")
return wait_for_operation(module, auth.delete(link)) return wait_for_operation(module, auth.delete(link))
def resource_to_request(module): def resource_to_request(module):
request = { request = {
u'kind': 'compute#backendService', "kind": "compute#backendService",
u'affinityCookieTtlSec': module.params.get('affinity_cookie_ttl_sec'), "affinityCookieTtlSec": module.params.get("affinity_cookie_ttl_sec"),
u'backends': BackendServiceBackendsArray(module.params.get('backends', []), module).to_request(), "backends": BackendServiceBackendsArray(
u'circuitBreakers': BackendServiceCircuitbreakers(module.params.get('circuit_breakers', {}), module).to_request(), module.params.get("backends", []), module
u'consistentHash': BackendServiceConsistenthash(module.params.get('consistent_hash', {}), module).to_request(), ).to_request(),
u'cdnPolicy': BackendServiceCdnpolicy(module.params.get('cdn_policy', {}), module).to_request(), "circuitBreakers": BackendServiceCircuitbreakers(
u'connectionDraining': BackendServiceConnectiondraining(module.params.get('connection_draining', {}), module).to_request(), module.params.get("circuit_breakers", {}), module
u'customRequestHeaders': module.params.get('custom_request_headers'), ).to_request(),
u'customResponseHeaders': module.params.get('custom_response_headers'), "consistentHash": BackendServiceConsistenthash(
u'description': module.params.get('description'), module.params.get("consistent_hash", {}), module
u'enableCDN': module.params.get('enable_cdn'), ).to_request(),
u'healthChecks': module.params.get('health_checks'), "cdnPolicy": BackendServiceCdnpolicy(
u'iap': BackendServiceIap(module.params.get('iap', {}), module).to_request(), module.params.get("cdn_policy", {}), module
u'loadBalancingScheme': module.params.get('load_balancing_scheme'), ).to_request(),
u'localityLbPolicy': module.params.get('locality_lb_policy'), "connectionDraining": BackendServiceConnectiondraining(
u'name': module.params.get('name'), module.params.get("connection_draining", {}), module
u'outlierDetection': BackendServiceOutlierdetection(module.params.get('outlier_detection', {}), module).to_request(), ).to_request(),
u'portName': module.params.get('port_name'), "customRequestHeaders": module.params.get("custom_request_headers"),
u'protocol': module.params.get('protocol'), "customResponseHeaders": module.params.get("custom_response_headers"),
u'securityPolicy': module.params.get('security_policy'), "description": module.params.get("description"),
u'sessionAffinity': module.params.get('session_affinity'), "enableCDN": module.params.get("enable_cdn"),
u'timeoutSec': module.params.get('timeout_sec'), "healthChecks": module.params.get("health_checks"),
u'logConfig': BackendServiceLogconfig(module.params.get('log_config', {}), module).to_request(), "iap": BackendServiceIap(module.params.get("iap", {}), module).to_request(),
u'fingerprint': module.params.get('fingerprint') "loadBalancingScheme": module.params.get("load_balancing_scheme"),
"localityLbPolicy": module.params.get("locality_lb_policy"),
"name": module.params.get("name"),
"outlierDetection": BackendServiceOutlierdetection(
module.params.get("outlier_detection", {}), module
).to_request(),
"portName": module.params.get("port_name"),
"protocol": module.params.get("protocol"),
"securityPolicy": module.params.get("security_policy"),
"sessionAffinity": module.params.get("session_affinity"),
"timeoutSec": module.params.get("timeout_sec"),
"logConfig": BackendServiceLogconfig(
module.params.get("log_config", {}), module
).to_request(),
"fingerprint": module.params.get("fingerprint"),
} }
return_vals = {} return_vals = {}
for k, v in request.items(): for k, v in request.items():
@ -1614,16 +1663,20 @@ def resource_to_request(module):
def fetch_resource(module, link, kind, allow_not_found=True): def fetch_resource(module, link, kind, allow_not_found=True):
auth = GcpSession(module, 'compute') auth = GcpSession(module, "compute")
return return_if_object(module, auth.get(link), kind, allow_not_found) return return_if_object(module, auth.get(link), kind, allow_not_found)
def self_link(module): def self_link(module):
return "https://compute.googleapis.com/compute/v1/projects/{project}/global/backendServices/{name}".format(**module.params) return "https://compute.googleapis.com/compute/v1/projects/{project}/global/backendServices/{name}".format(
**module.params
)
def collection(module): def collection(module):
return "https://compute.googleapis.com/compute/v1/projects/{project}/global/backendServices".format(**module.params) return "https://compute.googleapis.com/compute/v1/projects/{project}/global/backendServices".format(
**module.params
)
def return_if_object(module, response, kind, allow_not_found=False): def return_if_object(module, response, kind, allow_not_found=False):
@ -1638,11 +1691,11 @@ def return_if_object(module, response, kind, allow_not_found=False):
try: try:
module.raise_for_status(response) module.raise_for_status(response)
result = response.json() result = response.json()
except getattr(json.decoder, 'JSONDecodeError', ValueError): except getattr(json.decoder, "JSONDecodeError", ValueError):
module.fail_json(msg="Invalid JSON response with error: %s" % response.text) module.fail_json(msg="Invalid JSON response with error: %s" % response.text)
if navigate_hash(result, ['error', 'errors']): if navigate_hash(result, ["error", "errors"]):
module.fail_json(msg=navigate_hash(result, ['error', 'errors'])) module.fail_json(msg=navigate_hash(result, ["error", "errors"]))
return result return result
@ -1662,6 +1715,9 @@ def is_different(module, response):
if k in response: if k in response:
request_vals[k] = v request_vals[k] = v
# req = GcpRequest(request_vals)
# res = GcpRequest(response_vals)
# import epdb; epdb.serve()
return GcpRequest(request_vals) != GcpRequest(response_vals) return GcpRequest(request_vals) != GcpRequest(response_vals)
@ -1669,31 +1725,45 @@ def is_different(module, response):
# This is for doing comparisons with Ansible's current parameters. # This is for doing comparisons with Ansible's current parameters.
def response_to_hash(module, response): def response_to_hash(module, response):
return { return {
u'affinityCookieTtlSec': response.get(u'affinityCookieTtlSec'), "affinityCookieTtlSec": response.get("affinityCookieTtlSec"),
u'backends': BackendServiceBackendsArray(response.get(u'backends', []), module).from_response(), "backends": BackendServiceBackendsArray(
u'circuitBreakers': BackendServiceCircuitbreakers(response.get(u'circuitBreakers', {}), module).from_response(), response.get("backends", []), module
u'consistentHash': BackendServiceConsistenthash(response.get(u'consistentHash', {}), module).from_response(), ).from_response(),
u'cdnPolicy': BackendServiceCdnpolicy(response.get(u'cdnPolicy', {}), module).from_response(), "circuitBreakers": BackendServiceCircuitbreakers(
u'connectionDraining': BackendServiceConnectiondraining(response.get(u'connectionDraining', {}), module).from_response(), response.get("circuitBreakers", {}), module
u'creationTimestamp': response.get(u'creationTimestamp'), ).from_response(),
u'customRequestHeaders': response.get(u'customRequestHeaders'), "consistentHash": BackendServiceConsistenthash(
u'customResponseHeaders': response.get(u'customResponseHeaders'), response.get("consistentHash", {}), module
u'fingerprint': response.get(u'fingerprint'), ).from_response(),
u'description': response.get(u'description'), "cdnPolicy": BackendServiceCdnpolicy(
u'enableCDN': response.get(u'enableCDN'), response.get("cdnPolicy", {}), module
u'healthChecks': response.get(u'healthChecks'), ).from_response(),
u'id': response.get(u'id'), "connectionDraining": BackendServiceConnectiondraining(
u'iap': BackendServiceIap(response.get(u'iap', {}), module).from_response(), response.get("connectionDraining", {}), module
u'loadBalancingScheme': module.params.get('load_balancing_scheme'), ).from_response(),
u'localityLbPolicy': response.get(u'localityLbPolicy'), "creationTimestamp": response.get("creationTimestamp"),
u'name': module.params.get('name'), "customRequestHeaders": response.get("customRequestHeaders"),
u'outlierDetection': BackendServiceOutlierdetection(response.get(u'outlierDetection', {}), module).from_response(), "customResponseHeaders": response.get("customResponseHeaders"),
u'portName': response.get(u'portName'), "fingerprint": response.get("fingerprint"),
u'protocol': response.get(u'protocol'), "description": response.get("description"),
u'securityPolicy': response.get(u'securityPolicy'), "enableCDN": response.get("enableCDN"),
u'sessionAffinity': response.get(u'sessionAffinity'), "healthChecks": response.get("healthChecks"),
u'timeoutSec': response.get(u'timeoutSec'), "id": response.get("id"),
u'logConfig': BackendServiceLogconfig(response.get(u'logConfig', {}), module).from_response(), "iap": BackendServiceIap(response.get("iap", {}), module).from_response(),
"loadBalancingScheme": module.params.get("load_balancing_scheme"),
"localityLbPolicy": response.get("localityLbPolicy"),
"name": module.params.get("name"),
"outlierDetection": BackendServiceOutlierdetection(
response.get("outlierDetection", {}), module
).from_response(),
"portName": response.get("portName"),
"protocol": response.get("protocol"),
"securityPolicy": response.get("securityPolicy"),
"sessionAffinity": response.get("sessionAffinity"),
"timeoutSec": response.get("timeoutSec"),
"logConfig": BackendServiceLogconfig(
response.get("logConfig", {}), module
).from_response(),
} }
@ -1707,22 +1777,24 @@ def async_op_url(module, extra_data=None):
def wait_for_operation(module, response): def wait_for_operation(module, response):
op_result = return_if_object(module, response, 'compute#operation') op_result = return_if_object(module, response, "compute#operation")
if op_result is None: if op_result is None:
return {} return {}
status = navigate_hash(op_result, ['status']) status = navigate_hash(op_result, ["status"])
wait_done = wait_for_completion(status, op_result, module) wait_done = wait_for_completion(status, op_result, module)
return fetch_resource(module, navigate_hash(wait_done, ['targetLink']), 'compute#backendService') return fetch_resource(
module, navigate_hash(wait_done, ["targetLink"]), "compute#backendService"
)
def wait_for_completion(status, op_result, module): def wait_for_completion(status, op_result, module):
op_id = navigate_hash(op_result, ['name']) op_id = navigate_hash(op_result, ["name"])
op_uri = async_op_url(module, {'op_id': op_id}) op_uri = async_op_url(module, {"op_id": op_id})
while status != 'DONE': while status != "DONE":
raise_if_errors(op_result, ['error', 'errors'], module) raise_if_errors(op_result, ["error", "errors"], module)
time.sleep(1.0) time.sleep(1.0)
op_result = fetch_resource(module, op_uri, 'compute#operation', False) op_result = fetch_resource(module, op_uri, "compute#operation", False)
status = navigate_hash(op_result, ['status']) status = navigate_hash(op_result, ["status"])
return op_result return op_result
@ -1755,34 +1827,34 @@ class BackendServiceBackendsArray(object):
def _request_for_item(self, item): def _request_for_item(self, item):
return remove_nones_from_dict( return remove_nones_from_dict(
{ {
u'balancingMode': item.get('balancing_mode'), "balancingMode": item.get("balancing_mode"),
u'capacityScaler': item.get('capacity_scaler'), "capacityScaler": item.get("capacity_scaler"),
u'description': item.get('description'), "description": item.get("description"),
u'group': item.get('group'), "group": item.get("group"),
u'maxConnections': item.get('max_connections'), "maxConnections": item.get("max_connections"),
u'maxConnectionsPerInstance': item.get('max_connections_per_instance'), "maxConnectionsPerInstance": item.get("max_connections_per_instance"),
u'maxConnectionsPerEndpoint': item.get('max_connections_per_endpoint'), "maxConnectionsPerEndpoint": item.get("max_connections_per_endpoint"),
u'maxRate': item.get('max_rate'), "maxRate": item.get("max_rate"),
u'maxRatePerInstance': item.get('max_rate_per_instance'), "maxRatePerInstance": item.get("max_rate_per_instance"),
u'maxRatePerEndpoint': item.get('max_rate_per_endpoint'), "maxRatePerEndpoint": item.get("max_rate_per_endpoint"),
u'maxUtilization': item.get('max_utilization'), "maxUtilization": item.get("max_utilization"),
} }
) )
def _response_from_item(self, item): def _response_from_item(self, item):
return remove_nones_from_dict( return remove_nones_from_dict(
{ {
u'balancingMode': item.get(u'balancingMode'), "balancingMode": item.get("balancingMode"),
u'capacityScaler': item.get(u'capacityScaler'), "capacityScaler": item.get("capacityScaler"),
u'description': item.get(u'description'), "description": item.get("description"),
u'group': item.get(u'group'), "group": item.get("group"),
u'maxConnections': item.get(u'maxConnections'), "maxConnections": item.get("maxConnections"),
u'maxConnectionsPerInstance': item.get(u'maxConnectionsPerInstance'), "maxConnectionsPerInstance": item.get("maxConnectionsPerInstance"),
u'maxConnectionsPerEndpoint': item.get(u'maxConnectionsPerEndpoint'), "maxConnectionsPerEndpoint": item.get("maxConnectionsPerEndpoint"),
u'maxRate': item.get(u'maxRate'), "maxRate": item.get("maxRate"),
u'maxRatePerInstance': item.get(u'maxRatePerInstance'), "maxRatePerInstance": item.get("maxRatePerInstance"),
u'maxRatePerEndpoint': item.get(u'maxRatePerEndpoint'), "maxRatePerEndpoint": item.get("maxRatePerEndpoint"),
u'maxUtilization': item.get(u'maxUtilization'), "maxUtilization": item.get("maxUtilization"),
} }
) )
@ -1798,22 +1870,26 @@ class BackendServiceCircuitbreakers(object):
def to_request(self): def to_request(self):
return remove_nones_from_dict( return remove_nones_from_dict(
{ {
u'maxRequestsPerConnection': self.request.get('max_requests_per_connection'), "maxRequestsPerConnection": self.request.get(
u'maxConnections': self.request.get('max_connections'), "max_requests_per_connection"
u'maxPendingRequests': self.request.get('max_pending_requests'), ),
u'maxRequests': self.request.get('max_requests'), "maxConnections": self.request.get("max_connections"),
u'maxRetries': self.request.get('max_retries'), "maxPendingRequests": self.request.get("max_pending_requests"),
"maxRequests": self.request.get("max_requests"),
"maxRetries": self.request.get("max_retries"),
} }
) )
def from_response(self): def from_response(self):
return remove_nones_from_dict( return remove_nones_from_dict(
{ {
u'maxRequestsPerConnection': self.request.get(u'maxRequestsPerConnection'), "maxRequestsPerConnection": self.request.get(
u'maxConnections': self.request.get(u'maxConnections'), "maxRequestsPerConnection"
u'maxPendingRequests': self.request.get(u'maxPendingRequests'), ),
u'maxRequests': self.request.get(u'maxRequests'), "maxConnections": self.request.get("maxConnections"),
u'maxRetries': self.request.get(u'maxRetries'), "maxPendingRequests": self.request.get("maxPendingRequests"),
"maxRequests": self.request.get("maxRequests"),
"maxRetries": self.request.get("maxRetries"),
} }
) )
@ -1829,18 +1905,22 @@ class BackendServiceConsistenthash(object):
def to_request(self): def to_request(self):
return remove_nones_from_dict( return remove_nones_from_dict(
{ {
u'httpCookie': BackendServiceHttpcookie(self.request.get('http_cookie', {}), self.module).to_request(), "httpCookie": BackendServiceHttpcookie(
u'httpHeaderName': self.request.get('http_header_name'), self.request.get("http_cookie", {}), self.module
u'minimumRingSize': self.request.get('minimum_ring_size'), ).to_request(),
"httpHeaderName": self.request.get("http_header_name"),
"minimumRingSize": self.request.get("minimum_ring_size"),
} }
) )
def from_response(self): def from_response(self):
return remove_nones_from_dict( return remove_nones_from_dict(
{ {
u'httpCookie': BackendServiceHttpcookie(self.request.get(u'httpCookie', {}), self.module).from_response(), "httpCookie": BackendServiceHttpcookie(
u'httpHeaderName': self.request.get(u'httpHeaderName'), self.request.get("httpCookie", {}), self.module
u'minimumRingSize': self.request.get(u'minimumRingSize'), ).from_response(),
"httpHeaderName": self.request.get("httpHeaderName"),
"minimumRingSize": self.request.get("minimumRingSize"),
} }
) )
@ -1856,18 +1936,22 @@ class BackendServiceHttpcookie(object):
def to_request(self): def to_request(self):
return remove_nones_from_dict( return remove_nones_from_dict(
{ {
u'ttl': BackendServiceTtl(self.request.get('ttl', {}), self.module).to_request(), "ttl": BackendServiceTtl(
u'name': self.request.get('name'), self.request.get("ttl", {}), self.module
u'path': self.request.get('path'), ).to_request(),
"name": self.request.get("name"),
"path": self.request.get("path"),
} }
) )
def from_response(self): def from_response(self):
return remove_nones_from_dict( return remove_nones_from_dict(
{ {
u'ttl': BackendServiceTtl(self.request.get(u'ttl', {}), self.module).from_response(), "ttl": BackendServiceTtl(
u'name': self.request.get(u'name'), self.request.get("ttl", {}), self.module
u'path': self.request.get(u'path'), ).from_response(),
"name": self.request.get("name"),
"path": self.request.get("path"),
} }
) )
@ -1881,10 +1965,14 @@ class BackendServiceTtl(object):
self.request = {} self.request = {}
def to_request(self): def to_request(self):
return remove_nones_from_dict({u'seconds': self.request.get('seconds'), u'nanos': self.request.get('nanos')}) return remove_nones_from_dict(
{"seconds": self.request.get("seconds"), "nanos": self.request.get("nanos")}
)
def from_response(self): def from_response(self):
return remove_nones_from_dict({u'seconds': self.request.get(u'seconds'), u'nanos': self.request.get(u'nanos')}) return remove_nones_from_dict(
{"seconds": self.request.get("seconds"), "nanos": self.request.get("nanos")}
)
class BackendServiceCdnpolicy(object): class BackendServiceCdnpolicy(object):
@ -1898,30 +1986,40 @@ class BackendServiceCdnpolicy(object):
def to_request(self): def to_request(self):
return remove_nones_from_dict( return remove_nones_from_dict(
{ {
u'cacheKeyPolicy': BackendServiceCachekeypolicy(self.request.get('cache_key_policy', {}), self.module).to_request(), "cacheKeyPolicy": BackendServiceCachekeypolicy(
u'signedUrlCacheMaxAgeSec': self.request.get('signed_url_cache_max_age_sec'), self.request.get("cache_key_policy", {}), self.module
u'defaultTtl': self.request.get('default_ttl'), ).to_request(),
u'maxTtl': self.request.get('max_ttl'), "signedUrlCacheMaxAgeSec": self.request.get(
u'clientTtl': self.request.get('client_ttl'), "signed_url_cache_max_age_sec"
u'negativeCaching': self.request.get('negative_caching'), ),
u'negativeCachingPolicy': BackendServiceNegativecachingpolicyArray(self.request.get('negative_caching_policy', []), self.module).to_request(), "defaultTtl": self.request.get("default_ttl"),
u'cacheMode': self.request.get('cache_mode'), "maxTtl": self.request.get("max_ttl"),
u'serveWhileStale': self.request.get('serve_while_stale'), "clientTtl": self.request.get("client_ttl"),
"negativeCaching": self.request.get("negative_caching"),
"negativeCachingPolicy": BackendServiceNegativecachingpolicyArray(
self.request.get("negative_caching_policy", []), self.module
).to_request(),
"cacheMode": self.request.get("cache_mode"),
"serveWhileStale": self.request.get("serve_while_stale"),
} }
) )
def from_response(self): def from_response(self):
return remove_nones_from_dict( return remove_nones_from_dict(
{ {
u'cacheKeyPolicy': BackendServiceCachekeypolicy(self.request.get(u'cacheKeyPolicy', {}), self.module).from_response(), "cacheKeyPolicy": BackendServiceCachekeypolicy(
u'signedUrlCacheMaxAgeSec': self.request.get(u'signedUrlCacheMaxAgeSec'), self.request.get("cacheKeyPolicy", {}), self.module
u'defaultTtl': self.request.get(u'defaultTtl'), ).from_response(),
u'maxTtl': self.request.get(u'maxTtl'), "signedUrlCacheMaxAgeSec": self.request.get("signedUrlCacheMaxAgeSec"),
u'clientTtl': self.request.get(u'clientTtl'), "defaultTtl": self.request.get("defaultTtl"),
u'negativeCaching': self.request.get(u'negativeCaching'), "maxTtl": self.request.get("maxTtl"),
u'negativeCachingPolicy': BackendServiceNegativecachingpolicyArray(self.request.get(u'negativeCachingPolicy', []), self.module).from_response(), "clientTtl": self.request.get("clientTtl"),
u'cacheMode': self.request.get(u'cacheMode'), "negativeCaching": self.request.get("negativeCaching"),
u'serveWhileStale': self.request.get(u'serveWhileStale'), "negativeCachingPolicy": BackendServiceNegativecachingpolicyArray(
self.request.get("negativeCachingPolicy", []), self.module
).from_response(),
"cacheMode": self.request.get("cacheMode"),
"serveWhileStale": self.request.get("serveWhileStale"),
} }
) )
@ -1937,22 +2035,22 @@ class BackendServiceCachekeypolicy(object):
def to_request(self): def to_request(self):
return remove_nones_from_dict( return remove_nones_from_dict(
{ {
u'includeHost': self.request.get('include_host'), "includeHost": self.request.get("include_host"),
u'includeProtocol': self.request.get('include_protocol'), "includeProtocol": self.request.get("include_protocol"),
u'includeQueryString': self.request.get('include_query_string'), "includeQueryString": self.request.get("include_query_string"),
u'queryStringBlacklist': self.request.get('query_string_blacklist'), "queryStringBlacklist": self.request.get("query_string_blacklist"),
u'queryStringWhitelist': self.request.get('query_string_whitelist'), "queryStringWhitelist": self.request.get("query_string_whitelist"),
} }
) )
def from_response(self): def from_response(self):
return remove_nones_from_dict( return remove_nones_from_dict(
{ {
u'includeHost': self.request.get(u'includeHost'), "includeHost": self.request.get("includeHost"),
u'includeProtocol': self.request.get(u'includeProtocol'), "includeProtocol": self.request.get("includeProtocol"),
u'includeQueryString': self.request.get(u'includeQueryString'), "includeQueryString": self.request.get("includeQueryString"),
u'queryStringBlacklist': self.request.get(u'queryStringBlacklist'), "queryStringBlacklist": self.request.get("queryStringBlacklist"),
u'queryStringWhitelist': self.request.get(u'queryStringWhitelist'), "queryStringWhitelist": self.request.get("queryStringWhitelist"),
} }
) )
@ -1978,10 +2076,14 @@ class BackendServiceNegativecachingpolicyArray(object):
return items return items
def _request_for_item(self, item): def _request_for_item(self, item):
return remove_nones_from_dict({u'code': item.get('code'), u'ttl': item.get('ttl')}) return remove_nones_from_dict(
{"code": item.get("code"), "ttl": item.get("ttl")}
)
def _response_from_item(self, item): def _response_from_item(self, item):
return remove_nones_from_dict({u'code': item.get(u'code'), u'ttl': item.get(u'ttl')}) return remove_nones_from_dict(
{"code": item.get("code"), "ttl": item.get("ttl")}
)
class BackendServiceConnectiondraining(object): class BackendServiceConnectiondraining(object):
@ -1993,10 +2095,14 @@ class BackendServiceConnectiondraining(object):
self.request = {} self.request = {}
def to_request(self): def to_request(self):
return remove_nones_from_dict({u'drainingTimeoutSec': self.request.get('draining_timeout_sec')}) return remove_nones_from_dict(
{"drainingTimeoutSec": self.request.get("draining_timeout_sec")}
)
def from_response(self): def from_response(self):
return remove_nones_from_dict({u'drainingTimeoutSec': self.request.get(u'drainingTimeoutSec')}) return remove_nones_from_dict(
{"drainingTimeoutSec": self.request.get("drainingTimeoutSec")}
)
class BackendServiceIap(object): class BackendServiceIap(object):
@ -2010,18 +2116,18 @@ class BackendServiceIap(object):
def to_request(self): def to_request(self):
return remove_nones_from_dict( return remove_nones_from_dict(
{ {
u'enabled': self.request.get('enabled'), "enabled": self.request.get("enabled"),
u'oauth2ClientId': self.request.get('oauth2_client_id'), "oauth2ClientId": self.request.get("oauth2_client_id"),
u'oauth2ClientSecret': self.request.get('oauth2_client_secret'), "oauth2ClientSecret": self.request.get("oauth2_client_secret"),
} }
) )
def from_response(self): def from_response(self):
return remove_nones_from_dict( return remove_nones_from_dict(
{ {
u'enabled': self.request.get(u'enabled'), "enabled": self.request.get("enabled"),
u'oauth2ClientId': self.request.get(u'oauth2ClientId'), "oauth2ClientId": self.request.get("oauth2ClientId"),
u'oauth2ClientSecret': self.request.get(u'oauth2ClientSecret'), "oauth2ClientSecret": self.request.get("oauth2ClientSecret"),
} }
) )
@ -2037,34 +2143,60 @@ class BackendServiceOutlierdetection(object):
def to_request(self): def to_request(self):
return remove_nones_from_dict( return remove_nones_from_dict(
{ {
u'baseEjectionTime': BackendServiceBaseejectiontime(self.request.get('base_ejection_time', {}), self.module).to_request(), "baseEjectionTime": BackendServiceBaseejectiontime(
u'consecutiveErrors': self.request.get('consecutive_errors'), self.request.get("base_ejection_time", {}), self.module
u'consecutiveGatewayFailure': self.request.get('consecutive_gateway_failure'), ).to_request(),
u'enforcingConsecutiveErrors': self.request.get('enforcing_consecutive_errors'), "consecutiveErrors": self.request.get("consecutive_errors"),
u'enforcingConsecutiveGatewayFailure': self.request.get('enforcing_consecutive_gateway_failure'), "consecutiveGatewayFailure": self.request.get(
u'enforcingSuccessRate': self.request.get('enforcing_success_rate'), "consecutive_gateway_failure"
u'interval': BackendServiceInterval(self.request.get('interval', {}), self.module).to_request(), ),
u'maxEjectionPercent': self.request.get('max_ejection_percent'), "enforcingConsecutiveErrors": self.request.get(
u'successRateMinimumHosts': self.request.get('success_rate_minimum_hosts'), "enforcing_consecutive_errors"
u'successRateRequestVolume': self.request.get('success_rate_request_volume'), ),
u'successRateStdevFactor': self.request.get('success_rate_stdev_factor'), "enforcingConsecutiveGatewayFailure": self.request.get(
"enforcing_consecutive_gateway_failure"
),
"enforcingSuccessRate": self.request.get("enforcing_success_rate"),
"interval": BackendServiceInterval(
self.request.get("interval", {}), self.module
).to_request(),
"maxEjectionPercent": self.request.get("max_ejection_percent"),
"successRateMinimumHosts": self.request.get(
"success_rate_minimum_hosts"
),
"successRateRequestVolume": self.request.get(
"success_rate_request_volume"
),
"successRateStdevFactor": self.request.get("success_rate_stdev_factor"),
} }
) )
def from_response(self): def from_response(self):
return remove_nones_from_dict( return remove_nones_from_dict(
{ {
u'baseEjectionTime': BackendServiceBaseejectiontime(self.request.get(u'baseEjectionTime', {}), self.module).from_response(), "baseEjectionTime": BackendServiceBaseejectiontime(
u'consecutiveErrors': self.request.get(u'consecutiveErrors'), self.request.get("baseEjectionTime", {}), self.module
u'consecutiveGatewayFailure': self.request.get(u'consecutiveGatewayFailure'), ).from_response(),
u'enforcingConsecutiveErrors': self.request.get(u'enforcingConsecutiveErrors'), "consecutiveErrors": self.request.get("consecutiveErrors"),
u'enforcingConsecutiveGatewayFailure': self.request.get(u'enforcingConsecutiveGatewayFailure'), "consecutiveGatewayFailure": self.request.get(
u'enforcingSuccessRate': self.request.get(u'enforcingSuccessRate'), "consecutiveGatewayFailure"
u'interval': BackendServiceInterval(self.request.get(u'interval', {}), self.module).from_response(), ),
u'maxEjectionPercent': self.request.get(u'maxEjectionPercent'), "enforcingConsecutiveErrors": self.request.get(
u'successRateMinimumHosts': self.request.get(u'successRateMinimumHosts'), "enforcingConsecutiveErrors"
u'successRateRequestVolume': self.request.get(u'successRateRequestVolume'), ),
u'successRateStdevFactor': self.request.get(u'successRateStdevFactor'), "enforcingConsecutiveGatewayFailure": self.request.get(
"enforcingConsecutiveGatewayFailure"
),
"enforcingSuccessRate": self.request.get("enforcingSuccessRate"),
"interval": BackendServiceInterval(
self.request.get("interval", {}), self.module
).from_response(),
"maxEjectionPercent": self.request.get("maxEjectionPercent"),
"successRateMinimumHosts": self.request.get("successRateMinimumHosts"),
"successRateRequestVolume": self.request.get(
"successRateRequestVolume"
),
"successRateStdevFactor": self.request.get("successRateStdevFactor"),
} }
) )
@ -2078,10 +2210,14 @@ class BackendServiceBaseejectiontime(object):
self.request = {} self.request = {}
def to_request(self): def to_request(self):
return remove_nones_from_dict({u'seconds': self.request.get('seconds'), u'nanos': self.request.get('nanos')}) return remove_nones_from_dict(
{"seconds": self.request.get("seconds"), "nanos": self.request.get("nanos")}
)
def from_response(self): def from_response(self):
return remove_nones_from_dict({u'seconds': self.request.get(u'seconds'), u'nanos': self.request.get(u'nanos')}) return remove_nones_from_dict(
{"seconds": self.request.get("seconds"), "nanos": self.request.get("nanos")}
)
class BackendServiceInterval(object): class BackendServiceInterval(object):
@ -2093,10 +2229,14 @@ class BackendServiceInterval(object):
self.request = {} self.request = {}
def to_request(self): def to_request(self):
return remove_nones_from_dict({u'seconds': self.request.get('seconds'), u'nanos': self.request.get('nanos')}) return remove_nones_from_dict(
{"seconds": self.request.get("seconds"), "nanos": self.request.get("nanos")}
)
def from_response(self): def from_response(self):
return remove_nones_from_dict({u'seconds': self.request.get(u'seconds'), u'nanos': self.request.get(u'nanos')}) return remove_nones_from_dict(
{"seconds": self.request.get("seconds"), "nanos": self.request.get("nanos")}
)
class BackendServiceLogconfig(object): class BackendServiceLogconfig(object):
@ -2108,11 +2248,21 @@ class BackendServiceLogconfig(object):
self.request = {} self.request = {}
def to_request(self): def to_request(self):
return remove_nones_from_dict({u'enable': self.request.get('enable'), u'sampleRate': self.request.get('sample_rate')}) return remove_nones_from_dict(
{
"enable": self.request.get("enable"),
"sampleRate": self.request.get("sample_rate"),
}
)
def from_response(self): def from_response(self):
return remove_nones_from_dict({u'enable': self.request.get(u'enable'), u'sampleRate': self.request.get(u'sampleRate')}) return remove_nones_from_dict(
{
"enable": self.request.get("enable"),
"sampleRate": self.request.get("sampleRate"),
}
)
if __name__ == '__main__': if __name__ == "__main__":
main() main()

1
tests/integration/targets/gcp_compute_backend_service/aliases
View file

@ -1,2 +1 @@
cloud/gcp cloud/gcp
unsupported