def main():
"""Main function"""
module = GcpModule(
argument_spec=dict(
state=dict(default='present', choices=['present', 'absent'], type='str'),
name=dict(type='str')
)
)
state = module.params['state']
fetch = fetch_resource(module, self_link(module))
changed = False
if fetch:
if state == 'present':
if is_different(module, fetch):
fetch = update(module, self_link(module))
changed = True
else:
delete(module, self_link(module))
fetch = {}
changed = True
else:
if state == 'present':
fetch = create(module, self_link(module))
changed = True
else:
fetch = {}
fetch.update({'changed': changed})
module.exit_json(**fetch)
def main():
"""Main function"""
module = GcpModule(
argument_spec=dict(
state=dict(default='present', choices=['present', 'absent'], type='str'),
dest_range=dict(type='str'),
name=dict(type='str'),
network=dict(type='dict'),
priority=dict(type='int'),
tags=dict(type='list', elements='str'),
next_hop_gateway=dict(type='str'),
next_hop_instance=dict(type='str'),
next_hop_ip=dict(type='str'),
next_hop_vpn_tunnel=dict(type='str')
)
)
state = module.params['state']
kind = 'compute#route'
fetch = fetch_resource(module, self_link(module), kind)
changed = False
if fetch:
if state == 'present':
if is_different(module, fetch):
fetch = update(module, self_link(module), kind)
changed = True
else:
delete(module, self_link(module), kind)
fetch = {}
changed = True
else:
if state == 'present':
fetch = create(module, collection(module), kind)
changed = True
else:
fetch = {}
fetch.update({'changed': changed})
module.exit_json(**fetch)
def main():
"""Main function"""
module = GcpModule(
argument_spec=dict(
state=dict(default='present', choices=['present', 'absent'], type='str'),
check_interval_sec=dict(type='int'),
description=dict(type='str'),
healthy_threshold=dict(type='int'),
host=dict(type='str'),
name=dict(required=True, type='str'),
port=dict(type='int'),
request_path=dict(type='str'),
timeout_sec=dict(type='int', aliases=['timeout_seconds']),
unhealthy_threshold=dict(type='int')
)
)
state = module.params['state']
kind = 'compute#httpsHealthCheck'
fetch = fetch_resource(module, self_link(module), kind)
changed = False
if fetch:
if state == 'present':
if is_different(module, fetch):
fetch = update(module, self_link(module), kind, fetch)
changed = True
else:
delete(module, self_link(module), kind, fetch)
fetch = {}
changed = True
else:
if state == 'present':
fetch = create(module, collection(module), kind)
changed = True
else:
fetch = {}
fetch.update({'changed': changed})
module.exit_json(**fetch)
def main():
"""Main function"""
module = GcpModule(
argument_spec=dict(
state=dict(default='present', choices=['present', 'absent'], type='str'),
name=dict(required=True, type='str'),
type=dict(required=True, type='str', choices=['A', 'AAAA', 'CAA', 'CNAME', 'MX', 'NAPTR', 'NS', 'PTR', 'SOA', 'SPF', 'SRV', 'TXT']),
ttl=dict(type='int'),
target=dict(type='list', elements='str'),
managed_zone=dict(required=True, type='dict')
)
)
state = module.params['state']
kind = 'dns#resourceRecordSet'
fetch = fetch_wrapped_resource(module, 'dns#resourceRecordSet',
'dns#resourceRecordSetsListResponse',
'rrsets')
changed = False
if fetch:
if state == 'present':
if is_different(module, fetch):
fetch = update(module, self_link(module), kind, fetch)
changed = True
else:
delete(module, self_link(module), kind, fetch)
fetch = {}
changed = True
else:
if state == 'present':
fetch = create(module, collection(module), kind)
changed = True
else:
fetch = {}
fetch.update({'changed': changed})
module.exit_json(**fetch)
def main():
"""Main function"""
module = GcpModule(
argument_spec=dict(
state=dict(default='present', choices=['present', 'absent'], type='str'),
description=dict(type='str'),
gateway_address=dict(type='str'),
ip_cidr_range=dict(type='str'),
name=dict(type='str'),
network=dict(type='dict'),
private_ip_google_access=dict(type='bool'),
region=dict(required=True, type='str')
)
)
state = module.params['state']
kind = 'compute#subnetwork'
fetch = fetch_resource(module, self_link(module), kind)
changed = False
if fetch:
if state == 'present':
if is_different(module, fetch):
fetch = update(module, self_link(module), kind, fetch)
changed = True
else:
delete(module, self_link(module), kind, fetch)
fetch = {}
changed = True
else:
if state == 'present':
fetch = create(module, collection(module), kind)
changed = True
else:
fetch = {}
fetch.update({'changed': changed})
module.exit_json(**fetch)
def main():
"""Main function"""
module = GcpModule(
argument_spec=dict(
state=dict(default='present', choices=['present', 'absent'], type='str'),
bucket_name=dict(required=True, type='str'),
description=dict(type='str'),
enable_cdn=dict(type='bool'),
name=dict(required=True, type='str')
)
)
state = module.params['state']
kind = 'compute#backendBucket'
fetch = fetch_resource(module, self_link(module), kind)
changed = False
if fetch:
if state == 'present':
if is_different(module, fetch):
fetch = update(module, self_link(module), kind, fetch)
changed = True
else:
delete(module, self_link(module), kind, fetch)
fetch = {}
changed = True
else:
if state == 'present':
fetch = create(module, collection(module), kind)
changed = True
else:
fetch = {}
fetch.update({'changed': changed})
module.exit_json(**fetch)
def main():
"""Main function"""
module = GcpModule(
argument_spec=dict(
state=dict(default='present', choices=['present', 'absent'], type='str'),
description=dict(type='str'),
dns_name=dict(type='str'),
name=dict(required=True, type='str'),
name_server_set=dict(type='list', elements='str')
)
)
state = module.params['state']
kind = 'dns#managedZone'
fetch = fetch_resource(module, self_link(module), kind)
changed = False
if fetch:
if state == 'present':
if is_different(module, fetch):
fetch = update(module, self_link(module), kind)
changed = True
else:
delete(module, self_link(module), kind)
fetch = {}
changed = True
else:
if state == 'present':
fetch = create(module, collection(module), kind)
changed = True
else:
fetch = {}
fetch.update({'changed': changed})
module.exit_json(**fetch)
def main():
"""Main function"""
module = GcpModule(
argument_spec=dict(
state=dict(default='present', choices=['present', 'absent'], type='str'),
default_service=dict(required=True),
description=dict(type='str'),
host_rules=dict(type='list', elements='dict', options=dict(
description=dict(type='str'),
hosts=dict(required=True, type='list', elements='str'),
path_matcher=dict(required=True, type='str')
)),
name=dict(required=True, type='str'),
path_matchers=dict(type='list', elements='dict', options=dict(
default_service=dict(required=True),
description=dict(type='str'),
name=dict(required=True, type='str'),
path_rules=dict(type='list', elements='dict', options=dict(
paths=dict(required=True, type='list', elements='str'),
service=dict(required=True)
))
)),
tests=dict(type='list', elements='dict', options=dict(
description=dict(type='str'),
host=dict(required=True, type='str'),
path=dict(required=True, type='str'),
service=dict(required=True)
))
)
)
if not module.params['scopes']:
module.params['scopes'] = ['https://www.googleapis.com/auth/compute']
state = module.params['state']
kind = 'compute#urlMap'
fetch = fetch_resource(module, self_link(module), kind)
changed = False
if fetch:
if state == 'present':
if is_different(module, fetch):
update(module, self_link(module), kind)
fetch = fetch_resource(module, self_link(module), kind)
changed = True
else:
delete(module, self_link(module), kind)
fetch = {}
changed = True
else:
if state == 'present':
fetch = create(module, collection(module), kind)
changed = True
else:
fetch = {}
fetch.update({'changed': changed})
module.exit_json(**fetch)
def main():
"""Main function"""
module = GcpModule(argument_spec=dict(
state=dict(
default='present', choices=['present', 'absent'], type='str'),
backend_type=dict(type='str',
choices=['FIRST_GEN', 'SECOND_GEN', 'EXTERNAL']),
connection_name=dict(type='str'),
database_version=dict(
type='str',
choices=['MYSQL_5_5', 'MYSQL_5_6', 'MYSQL_5_7', 'POSTGRES_9_6']),
failover_replica=dict(type='dict',
options=dict(available=dict(type='bool'),
name=dict(type='str'))),
instance_type=dict(type='str',
choices=[
'CLOUD_SQL_INSTANCE', 'ON_PREMISES_INSTANCE',
'READ_REPLICA_INSTANCE'
]),
ipv6_address=dict(type='str'),
master_instance_name=dict(type='str'),
max_disk_size=dict(type='int'),
name=dict(required=True, type='str'),
region=dict(type='str'),
replica_configuration=dict(
type='dict',
options=dict(failover_target=dict(type='bool'),
mysql_replica_configuration=dict(
type='dict',
options=dict(ca_certificate=dict(type='str'),
client_certificate=dict(type='str'),
client_key=dict(type='str'),
connect_retry_interval=dict(
type='int'),
dump_file_path=dict(type='str'),
master_heartbeat_period=dict(
type='int'),
password=dict(type='str'),
ssl_cipher=dict(type='str'),
username=dict(type='str'),
verify_server_certificate=dict(
type='bool'))),
replica_names=dict(type='list', elements='str'),
service_account_email_address=dict(type='str'))),
settings=dict(type='dict',
options=dict(ip_configuration=dict(
type='dict',
options=dict(ipv4_enabled=dict(type='bool'),
authorized_networks=dict(
type='list',
elements='dict',
options=dict(expiration_time=dict(
type='str'),
name=dict(type='str'),
value=dict(
type='str'))),
require_ssl=dict(type='bool'))),
tier=dict(type='str'),
settings_version=dict(type='int')))))
if not module.params['scopes']:
module.params['scopes'] = [
'https://www.googleapis.com/auth/sqlservice.admin'
]
state = module.params['state']
kind = 'sql#instance'
fetch = fetch_resource(module, self_link(module), kind)
changed = False
if fetch:
if state == 'present':
if is_different(module, fetch):
update(module, self_link(module), kind, fetch)
fetch = fetch_resource(module, self_link(module), kind)
changed = True
else:
delete(module, self_link(module), kind, fetch)
fetch = {}
changed = True
else:
if state == 'present':
fetch = create(module, collection(module), kind)
changed = True
else:
fetch = {}
fetch.update({'changed': changed})
module.exit_json(**fetch)
def main():
"""Main function"""
module = GcpModule(
argument_spec=dict(
state=dict(default='present', choices=['present', 'absent'], type='str'),
id=dict(type='str'),
description=dict(type='str'),
disabled=dict(type='bool'),
substitutions=dict(type='dict'),
filename=dict(type='str'),
ignored_files=dict(type='list', elements='str'),
included_files=dict(type='list', elements='str'),
trigger_template=dict(
type='dict',
options=dict(
project_id=dict(type='str'),
repo_name=dict(default='default', type='str'),
dir=dict(type='str'),
branch_name=dict(type='str'),
tag_name=dict(type='str'),
commit_sha=dict(type='str'),
),
),
build=dict(
type='dict',
options=dict(
tags=dict(type='list', elements='str'),
images=dict(type='list', elements='str'),
steps=dict(
type='list',
elements='dict',
options=dict(
name=dict(type='str'),
args=dict(type='list', elements='str'),
env=dict(type='list', elements='str'),
id=dict(type='str'),
entrypoint=dict(type='str'),
dir=dict(type='str'),
secret_env=dict(type='list', elements='str'),
timeout=dict(type='str'),
timing=dict(type='str'),
volumes=dict(type='list', elements='dict', options=dict(name=dict(type='str'), path=dict(type='str'))),
wait_for=dict(type='list', elements='str'),
),
),
),
),
),
mutually_exclusive=[['build', 'filename']],
)
if not module.params['scopes']:
module.params['scopes'] = ['https://www.googleapis.com/auth/cloud-platform']
state = module.params['state']
if module.params['id']:
fetch = fetch_resource(module, self_link(module))
else:
fetch = {}
changed = False
if fetch:
if state == 'present':
if is_different(module, fetch):
update(module, self_link(module))
fetch = fetch_resource(module, self_link(module))
changed = True
else:
delete(module, self_link(module))
fetch = {}
changed = True
else:
if state == 'present':
fetch = create(module, collection(module))
changed = True
else:
fetch = {}
fetch.update({'changed': changed})
module.exit_json(**fetch)
def main():
"""Main function"""
module = GcpModule(
argument_spec=dict(
state=dict(default='present', choices=['present', 'absent'], type='str'),
name=dict(type='str'),
description=dict(type='str'),
initial_node_count=dict(required=True, type='int'),
node_config=dict(type='dict', options=dict(
machine_type=dict(type='str'),
disk_size_gb=dict(type='int'),
oauth_scopes=dict(type='list', elements='str'),
service_account=dict(type='str'),
metadata=dict(type='dict'),
image_type=dict(type='str'),
labels=dict(type='dict'),
local_ssd_count=dict(type='int'),
tags=dict(type='list', elements='str'),
preemptible=dict(type='bool')
)),
master_auth=dict(type='dict', options=dict(
username=dict(type='str'),
password=dict(type='str'),
cluster_ca_certificate=dict(type='str'),
client_certificate=dict(type='str'),
client_key=dict(type='str')
)),
logging_service=dict(type='str', choices=['logging.googleapis.com', 'none']),
monitoring_service=dict(type='str', choices=['monitoring.googleapis.com', 'none']),
network=dict(type='str'),
cluster_ipv4_cidr=dict(type='str'),
addons_config=dict(type='dict', options=dict(
http_load_balancing=dict(type='dict', options=dict(
disabled=dict(type='bool')
)),
horizontal_pod_autoscaling=dict(type='dict', options=dict(
disabled=dict(type='bool')
))
)),
subnetwork=dict(type='str'),
location=dict(type='list', elements='str'),
zone=dict(required=True, type='str')
)
)
state = module.params['state']
fetch = fetch_resource(module, self_link(module))
changed = False
if fetch:
if state == 'present':
if is_different(module, fetch):
fetch = update(module, self_link(module), fetch)
changed = True
else:
delete(module, self_link(module), fetch)
fetch = {}
changed = True
else:
if state == 'present':
fetch = create(module, collection(module))
changed = True
else:
fetch = {}
fetch.update({'changed': changed})
module.exit_json(**fetch)
def main():
"""Main function"""
module = GcpModule(
argument_spec=dict(
state=dict(default='present', choices=['present', 'absent'], type='str'),
check_interval_sec=dict(default=5, type='int'),
description=dict(type='str'),
healthy_threshold=dict(type='int'),
name=dict(type='str'),
timeout_sec=dict(default=5, type='int', aliases=['timeout_seconds']),
unhealthy_threshold=dict(default=2, type='int'),
type=dict(type='str', choices=['TCP', 'SSL', 'HTTP']),
http_health_check=dict(type='dict', options=dict(
host=dict(type='str'),
request_path=dict(type='str'),
port=dict(type='int'),
port_name=dict(type='str'),
proxy_header=dict(type='str', choices=['NONE', 'PROXY_V1'])
)),
https_health_check=dict(type='dict', options=dict(
host=dict(type='str'),
request_path=dict(type='str'),
port=dict(type='int'),
port_name=dict(type='str'),
proxy_header=dict(type='str', choices=['NONE', 'PROXY_V1'])
)),
tcp_health_check=dict(type='dict', options=dict(
request=dict(type='str'),
response=dict(type='str'),
port=dict(type='int'),
port_name=dict(type='str'),
proxy_header=dict(type='str', choices=['NONE', 'PROXY_V1'])
)),
ssl_health_check=dict(type='dict', options=dict(
request=dict(type='str'),
response=dict(type='str'),
port=dict(type='int'),
port_name=dict(type='str'),
proxy_header=dict(type='str', choices=['NONE', 'PROXY_V1'])
))
)
)
state = module.params['state']
kind = 'compute#healthCheck'
fetch = fetch_resource(module, self_link(module), kind)
changed = False
if fetch:
if state == 'present':
if is_different(module, fetch):
fetch = update(module, self_link(module), kind)
changed = True
else:
delete(module, self_link(module), kind)
fetch = {}
changed = True
else:
if state == 'present':
fetch = create(module, collection(module), kind)
changed = True
else:
fetch = {}
fetch.update({'changed': changed})
module.exit_json(**fetch)
def main():
"""Main function"""
module = GcpModule(argument_spec=dict(
state=dict(
default='present', choices=['present', 'absent'], type='str'),
action=dict(type='str'),
overwrite=dict(type='bool'),
src=dict(type='path'),
dest=dict(type='path'),
bucket=dict(type='str'),
))
if not module.params['scopes']:
module.params['scopes'] = [
'https://www.googleapis.com/auth/devstorage.full_control'
]
remote_object = fetch_resource(module, self_link(module))
local_file_exists = os.path.isfile(local_file_path(module))
# Check if files exist.
if module.params['action'] == 'download' and not remote_object:
module.fail_json(msg="File does not exist in bucket")
if module.params['action'] == 'upload' and not local_file_exists:
module.fail_json(msg="File does not exist on disk")
# Check if we'll be overwriting files.
if not module.params['overwrite']:
remote_object['changed'] = False
if module.params['action'] == 'download' and local_file_exists:
# If files differ, throw an error
if get_md5_local(
local_file_path(module)) != remote_object['md5Hash']:
module.fail_json(
msg="Local file is different than remote file")
# If files are the same, module is done running.
else:
module.exit_json(**remote_object)
elif module.params['action'] == 'upload' and remote_object:
# If files differ, throw an error
if get_md5_local(
local_file_path(module)) != remote_object['md5Hash']:
module.fail_json(
msg="Local file is different than remote file")
# If files are the same, module is done running.
else:
module.exit_json(**remote_object)
# Upload/download the files
auth = GcpSession(module, 'storage')
if module.params['action'] == 'download':
results = download_file(module)
else:
results = upload_file(module)
module.exit_json(**results)
def main():
"""Main function"""
module = GcpModule(argument_spec=dict(
state=dict(
default='present', choices=['present', 'absent'], type='str'),
affinity_cookie_ttl_sec=dict(type='int'),
backends=dict(
type='list',
elements='dict',
options=dict(balancing_mode=dict(
type='str', choices=['UTILIZATION', 'RATE', 'CONNECTION']),
capacity_scaler=dict(type='str'),
description=dict(type='str'),
group=dict(type='dict'),
max_connections=dict(type='int'),
max_connections_per_instance=dict(type='int'),
max_rate=dict(type='int'),
max_rate_per_instance=dict(type='str'),
max_utilization=dict(type='str'))),
cdn_policy=dict(type='dict',
options=dict(cache_key_policy=dict(
type='dict',
options=dict(include_host=dict(type='bool'),
include_protocol=dict(type='bool'),
include_query_string=dict(
type='bool'),
query_string_blacklist=dict(
type='list', elements='str'),
query_string_whitelist=dict(
type='list', elements='str'))))),
connection_draining=dict(
type='dict', options=dict(draining_timeout_sec=dict(type='int'))),
description=dict(type='str'),
enable_cdn=dict(type='bool'),
health_checks=dict(type='list', elements='str'),
name=dict(type='str'),
port_name=dict(type='str'),
protocol=dict(type='str', choices=['HTTP', 'HTTPS', 'TCP', 'SSL']),
region=dict(type='str'),
session_affinity=dict(type='str',
choices=[
'NONE', 'CLIENT_IP', 'GENERATED_COOKIE',
'CLIENT_IP_PROTO', 'CLIENT_IP_PORT_PROTO'
]),
timeout_sec=dict(type='int', aliases=['timeout_seconds'])))
state = module.params['state']
kind = 'compute#backendService'
fetch = fetch_resource(module, self_link(module), kind)
changed = False
if fetch:
if state == 'present':
if is_different(module, fetch):
fetch = update(module, self_link(module), kind, fetch)
changed = True
else:
delete(module, self_link(module), kind, fetch)
fetch = {}
changed = True
else:
if state == 'present':
fetch = create(module, collection(module), kind)
changed = True
else:
fetch = {}
fetch.update({'changed': changed})
module.exit_json(**fetch)
def main():
"""Main function"""
module = GcpModule(
argument_spec=dict(
state=dict(default='present', choices=['present', 'absent'], type='str'),
name=dict(required=True, type='str'),
description=dict(type='str'),
filter=dict(required=True, type='str'),
metric_descriptor=dict(
required=True,
type='dict',
options=dict(
unit=dict(default='1', type='str'),
value_type=dict(required=True, type='str'),
metric_kind=dict(required=True, type='str'),
labels=dict(
type='list',
elements='dict',
options=dict(key=dict(required=True, type='str'), description=dict(type='str'), value_type=dict(default='STRING', type='str')),
),
display_name=dict(type='str'),
),
),
label_extractors=dict(type='dict'),
value_extractor=dict(type='str'),
bucket_options=dict(
type='dict',
options=dict(
linear_buckets=dict(type='dict', options=dict(num_finite_buckets=dict(type='int'), width=dict(type='int'), offset=dict(type='str'))),
exponential_buckets=dict(
type='dict', options=dict(num_finite_buckets=dict(type='int'), growth_factor=dict(type='int'), scale=dict(type='str'))
),
explicit_buckets=dict(type='dict', options=dict(bounds=dict(type='list', elements='str'))),
),
),
)
)
if not module.params['scopes']:
module.params['scopes'] = ['https://www.googleapis.com/auth/cloud-platform']
state = module.params['state']
fetch = fetch_resource(module, self_link(module))
changed = False
if fetch:
if state == 'present':
if is_different(module, fetch):
update(module, self_link(module))
fetch = fetch_resource(module, self_link(module))
changed = True
else:
delete(module, self_link(module))
fetch = {}
changed = True
else:
if state == 'present':
fetch = create(module, collection(module))
changed = True
else:
fetch = {}
fetch.update({'changed': changed})
module.exit_json(**fetch)
def main():
"""Main function"""
module = GcpModule(argument_spec=dict(
state=dict(
default='present', choices=['present', 'absent'], type='str'),
acl=dict(
type='list',
elements='dict',
options=dict(
bucket=dict(required=True, type='dict'),
entity=dict(required=True, type='str'),
entity_id=dict(type='str'),
project_team=dict(
type='dict',
options=dict(
project_number=dict(type='str'),
team=dict(type='str',
choices=['editors', 'owners', 'viewers']))),
role=dict(type='str', choices=['OWNER', 'READER', 'WRITER']),
),
),
cors=dict(
type='list',
elements='dict',
options=dict(
max_age_seconds=dict(type='int'),
method=dict(type='list', elements='str'),
origin=dict(type='list', elements='str'),
response_header=dict(type='list', elements='str'),
),
),
default_object_acl=dict(
type='list',
elements='dict',
options=dict(
bucket=dict(required=True, type='dict'),
entity=dict(required=True, type='str'),
object=dict(type='str'),
role=dict(
required=True, type='str', choices=['OWNER', 'READER']),
),
),
lifecycle=dict(
type='dict',
options=dict(rule=dict(
type='list',
elements='dict',
options=dict(
action=dict(
type='dict',
options=dict(
storage_class=dict(type='str'),
type=dict(type='str',
choices=['Delete', 'SetStorageClass']))),
condition=dict(
type='dict',
options=dict(
age_days=dict(type='int'),
created_before=dict(type='str'),
is_live=dict(type='bool'),
matches_storage_class=dict(type='list',
elements='str'),
num_newer_versions=dict(type='int'),
),
),
),
)),
),
location=dict(type='str'),
logging=dict(type='dict',
options=dict(log_bucket=dict(type='str'),
log_object_prefix=dict(type='str'))),
metageneration=dict(type='int'),
name=dict(type='str'),
owner=dict(type='dict', options=dict(entity=dict(type='str'))),
storage_class=dict(
type='str',
choices=[
'MULTI_REGIONAL', 'REGIONAL', 'STANDARD', 'NEARLINE',
'COLDLINE', 'DURABLE_REDUCED_AVAILABILITY'
]),
versioning=dict(type='dict', options=dict(enabled=dict(type='bool'))),
website=dict(type='dict',
options=dict(main_page_suffix=dict(type='str'),
not_found_page=dict(type='str'))),
project=dict(type='str'),
predefined_default_object_acl=dict(
type='str',
choices=[
'authenticatedRead', 'bucketOwnerFullControl',
'bucketOwnerRead', 'private', 'projectPrivate', 'publicRead'
]),
))
if not module.params['scopes']:
module.params['scopes'] = [
'https://www.googleapis.com/auth/devstorage.full_control'
]
state = module.params['state']
kind = 'storage#bucket'
fetch = fetch_resource(module, self_link(module), kind)
changed = False
if fetch:
if state == 'present':
if is_different(module, fetch):
update(module, self_link(module), kind)
fetch = fetch_resource(module, self_link(module), kind)
changed = True
else:
delete(module, self_link(module), kind)
fetch = {}
changed = True
else:
if state == 'present':
fetch = create(module, collection(module), kind)
changed = True
else:
fetch = {}
fetch.update({'changed': changed})
module.exit_json(**fetch)
def main():
"""Main function"""
module = GcpModule(argument_spec=dict(
state=dict(
default='present', choices=['present', 'absent'], type='str'),
backends=dict(
type='list',
elements='dict',
options=dict(
balancing_mode=dict(default='CONNECTION', type='str'),
capacity_scaler=dict(type='str'),
description=dict(type='str'),
group=dict(required=True, type='str'),
max_connections=dict(type='int'),
max_connections_per_instance=dict(type='int'),
max_connections_per_endpoint=dict(type='int'),
max_rate=dict(type='int'),
max_rate_per_instance=dict(type='str'),
max_rate_per_endpoint=dict(type='str'),
max_utilization=dict(type='str'),
),
),
connection_draining=dict(type='dict',
options=dict(draining_timeout_sec=dict(
default=300, type='int'))),
description=dict(type='str'),
health_checks=dict(required=True, type='list', elements='str'),
load_balancing_scheme=dict(default='INTERNAL', type='str'),
name=dict(required=True, type='str'),
protocol=dict(type='str'),
session_affinity=dict(type='str'),
timeout_sec=dict(type='int'),
region=dict(required=True, type='str'),
))
if not module.params['scopes']:
module.params['scopes'] = ['https://www.googleapis.com/auth/compute']
state = module.params['state']
kind = 'compute#backendService'
fetch = fetch_resource(module, self_link(module), kind)
changed = False
if fetch:
if state == 'present':
if is_different(module, fetch):
update(module, self_link(module), kind)
fetch = fetch_resource(module, self_link(module), kind)
changed = True
else:
delete(module, self_link(module), kind)
fetch = {}
changed = True
else:
if state == 'present':
fetch = create(module, collection(module), kind)
changed = True
else:
fetch = {}
fetch.update({'changed': changed})
module.exit_json(**fetch)
def main():
"""Main function"""
module = GcpModule(argument_spec=dict(
state=dict(
default='present', choices=['present', 'absent'], type='str'),
name=dict(required=True, type='str'),
description=dict(type='str'),
autoscaling_policy=dict(
required=True,
type='dict',
options=dict(
min_num_replicas=dict(type='int', aliases=['minReplicas']),
max_num_replicas=dict(
required=True, type='int', aliases=['maxReplicas']),
cool_down_period_sec=dict(
default=60, type='int', aliases=['cooldownPeriod']),
cpu_utilization=dict(type='dict',
options=dict(utilization_target=dict(
type='str', aliases=['target']))),
custom_metric_utilizations=dict(
type='list',
elements='dict',
aliases=['metric'],
options=dict(
metric=dict(
required=True, type='str', aliases=['name']),
utilization_target=dict(type='str', aliases=['target'
]),
utilization_target_type=dict(type='str',
aliases=['type']),
),
),
load_balancing_utilization=dict(
type='dict',
options=dict(utilization_target=dict(type='str',
aliases=['target']))),
),
),
target=dict(required=True, type='dict'),
zone=dict(required=True, type='str'),
))
if not module.params['scopes']:
module.params['scopes'] = ['https://www.googleapis.com/auth/compute']
state = module.params['state']
kind = 'compute#autoscaler'
fetch = fetch_resource(module, self_link(module), kind)
changed = False
if fetch:
if state == 'present':
if is_different(module, fetch):
update(module, self_link(module), kind)
fetch = fetch_resource(module, self_link(module), kind)
changed = True
else:
delete(module, self_link(module), kind)
fetch = {}
changed = True
else:
if state == 'present':
fetch = create(module, collection(module), kind)
changed = True
else:
fetch = {}
fetch.update({'changed': changed})
module.exit_json(**fetch)
def main():
"""Main function"""
module = GcpModule(argument_spec=dict(
state=dict(
default='present', choices=['present', 'absent'], type='str'),
name=dict(required=True, type='str'),
snapshot_schedule_policy=dict(
type='dict',
options=dict(
schedule=dict(
required=True,
type='dict',
options=dict(
hourly_schedule=dict(
type='dict',
options=dict(
hours_in_cycle=dict(required=True, type='int'),
start_time=dict(required=True, type='str'))),
daily_schedule=dict(
type='dict',
options=dict(
days_in_cycle=dict(required=True, type='int'),
start_time=dict(required=True, type='str'))),
weekly_schedule=dict(
type='dict',
options=dict(day_of_weeks=dict(
required=True,
type='list',
elements='dict',
options=dict(
start_time=dict(required=True, type='str'),
day=dict(required=True, type='str')),
)),
),
),
),
retention_policy=dict(
type='dict',
options=dict(
max_retention_days=dict(required=True, type='int'),
on_source_disk_delete=dict(
default='KEEP_AUTO_SNAPSHOTS', type='str')),
),
snapshot_properties=dict(
type='dict',
options=dict(labels=dict(type='dict'),
storage_locations=dict(type='list',
elements='str'),
guest_flush=dict(type='bool'))),
),
),
region=dict(required=True, type='str'),
))
if not module.params['scopes']:
module.params['scopes'] = ['https://www.googleapis.com/auth/compute']
state = module.params['state']
kind = 'compute#resourcePolicy'
fetch = fetch_resource(module, self_link(module), kind)
changed = False
if fetch:
if state == 'present':
if is_different(module, fetch):
update(module, self_link(module), kind)
fetch = fetch_resource(module, self_link(module), kind)
changed = True
else:
delete(module, self_link(module), kind)
fetch = {}
changed = True
else:
if state == 'present':
fetch = create(module, collection(module), kind)
changed = True
else:
fetch = {}
fetch.update({'changed': changed})
module.exit_json(**fetch)
def main():
"""Main function"""
module = GcpModule(argument_spec=dict(
state=dict(
default='present', choices=['present', 'absent'], type='str'),
name=dict(type='str'),
app_engine_routing_override=dict(type='dict',
options=dict(service=dict(type='str'),
version=dict(type='str'),
instance=dict(
type='str'))),
rate_limits=dict(type='dict',
options=dict(max_dispatches_per_second=dict(
type='int'),
max_concurrent_dispatches=dict(
type='int'))),
retry_config=dict(
type='dict',
options=dict(
max_attempts=dict(type='int'),
max_retry_duration=dict(type='str'),
min_backoff=dict(type='str'),
max_backoff=dict(type='str'),
max_doublings=dict(type='int'),
),
),
status=dict(type='str'),
location=dict(required=True, type='str'),
))
if not module.params['scopes']:
module.params['scopes'] = [
'https://www.googleapis.com/auth/cloud-platform'
]
state = module.params['state']
fetch = fetch_resource(module, self_link(module))
changed = False
if fetch:
if state == 'present':
if is_different(module, fetch):
update(module, self_link(module))
fetch = fetch_resource(module, self_link(module))
changed = True
else:
delete(module, self_link(module))
fetch = {}
changed = True
else:
if state == 'present':
fetch = create(module, collection(module))
changed = True
else:
fetch = {}
if fetch:
instance = QueueStatus(module, fetch.get('state'))
instance.run()
if module.params.get('status'):
fetch.update({'status': module.params['status']})
fetch.update({'changed': changed})
module.exit_json(**fetch)
def main():
"""Main function"""
module = GcpModule(
argument_spec=dict(
state=dict(default='present', choices=['present', 'absent'], type='str'),
acl=dict(type='list', elements='dict', options=dict(
bucket=dict(required=True, type='dict'),
domain=dict(type='str'),
email=dict(type='str'),
entity=dict(required=True, type='str'),
entity_id=dict(type='str'),
id=dict(type='str'),
project_team=dict(type='dict', options=dict(
project_number=dict(type='str'),
team=dict(type='str', choices=['editors', 'owners', 'viewers'])
)),
role=dict(type='str', choices=['OWNER', 'READER', 'WRITER'])
)),
cors=dict(type='list', elements='dict', options=dict(
max_age_seconds=dict(type='int'),
method=dict(type='list', elements='str'),
origin=dict(type='list', elements='str'),
response_header=dict(type='list', elements='str')
)),
lifecycle=dict(type='dict', options=dict(
rule=dict(type='list', elements='dict', options=dict(
action=dict(type='dict', options=dict(
storage_class=dict(type='str'),
type=dict(type='str', choices=['Delete', 'SetStorageClass'])
)),
condition=dict(type='dict', options=dict(
age_days=dict(type='int'),
created_before=dict(type='str'),
is_live=dict(type='bool'),
matches_storage_class=dict(type='list', elements='str'),
num_newer_versions=dict(type='int')
))
))
)),
location=dict(type='str'),
logging=dict(type='dict', options=dict(
log_bucket=dict(type='str'),
log_object_prefix=dict(type='str')
)),
metageneration=dict(type='int'),
name=dict(type='str'),
owner=dict(type='dict', options=dict(
entity=dict(type='str'),
entity_id=dict(type='str')
)),
storage_class=dict(type='str', choices=['MULTI_REGIONAL', 'REGIONAL', 'STANDARD', 'NEARLINE', 'COLDLINE', 'DURABLE_REDUCED_AVAILABILITY']),
versioning=dict(type='dict', options=dict(
enabled=dict(type='bool')
)),
website=dict(type='dict', options=dict(
main_page_suffix=dict(type='str'),
not_found_page=dict(type='str')
)),
project=dict(type='str'),
predefined_default_object_acl=dict(type='str', choices=['authenticatedRead',
'bucketOwnerFullControl',
'bucketOwnerRead',
'private',
'projectPrivate',
'publicRead'])
)
)
state = module.params['state']
kind = 'storage#bucket'
fetch = fetch_resource(module, self_link(module), kind)
changed = False
if fetch:
if state == 'present':
if is_different(module, fetch):
fetch = update(module, self_link(module), kind)
changed = True
else:
delete(module, self_link(module), kind)
fetch = {}
changed = True
else:
if state == 'present':
fetch = create(module, collection(module), kind)
changed = True
else:
fetch = {}
fetch.update({'changed': changed})
module.exit_json(**fetch)
def main():
"""Main function"""
module = GcpModule(argument_spec=dict(
state=dict(
default='present', choices=['present', 'absent'], type='str'),
name=dict(type='str'),
access=dict(
type='list',
elements='dict',
options=dict(
domain=dict(type='str'),
group_by_email=dict(type='str'),
role=dict(type='str', choices=['READER', 'WRITER', 'OWNER']),
special_group=dict(type='str'),
user_by_email=dict(type='str'),
view=dict(
type='dict',
options=dict(dataset_id=dict(required=True, type='str'),
project_id=dict(required=True, type='str'),
table_id=dict(required=True, type='str')),
),
),
),
dataset_reference=dict(required=True,
type='dict',
options=dict(dataset_id=dict(required=True,
type='str'),
project_id=dict(type='str'))),
default_table_expiration_ms=dict(type='int'),
description=dict(type='str'),
friendly_name=dict(type='str'),
labels=dict(type='dict'),
location=dict(default='US', type='str'),
))
if not module.params['scopes']:
module.params['scopes'] = ['https://www.googleapis.com/auth/bigquery']
state = module.params['state']
kind = 'bigquery#dataset'
fetch = fetch_resource(module, self_link(module), kind)
changed = False
if fetch:
if state == 'present':
if is_different(module, fetch):
update(module, self_link(module), kind)
fetch = fetch_resource(module, self_link(module), kind)
changed = True
else:
delete(module, self_link(module), kind)
fetch = {}
changed = True
else:
if state == 'present':
fetch = create(module, collection(module), kind)
changed = True
else:
fetch = {}
fetch.update({'changed': changed})
module.exit_json(**fetch)
def main():
"""Main function"""
module = GcpModule(
argument_spec=dict(
state=dict(default='present', choices=['present', 'absent'], type='str'),
name=dict(required=True, type='str'),
description=dict(type='str'),
schedule=dict(type='str'),
time_zone=dict(default='Etc/UTC', type='str'),
retry_config=dict(
type='dict',
options=dict(
retry_count=dict(type='int'),
max_retry_duration=dict(type='str'),
min_backoff_duration=dict(type='str'),
max_backoff_duration=dict(type='str'),
max_doublings=dict(type='int'),
),
),
pubsub_target=dict(type='dict', options=dict(topic_name=dict(required=True, type='str'), data=dict(type='str'), attributes=dict(type='dict'))),
app_engine_http_target=dict(
type='dict',
options=dict(
http_method=dict(type='str'),
app_engine_routing=dict(type='dict', options=dict(service=dict(type='str'), version=dict(type='str'), instance=dict(type='str'))),
relative_uri=dict(required=True, type='str'),
body=dict(type='str'),
headers=dict(type='dict'),
),
),
http_target=dict(
type='dict',
options=dict(
uri=dict(required=True, type='str'),
http_method=dict(type='str'),
body=dict(type='str'),
headers=dict(type='dict'),
oauth_token=dict(type='dict', options=dict(service_account_email=dict(type='str'), scope=dict(type='str'))),
oidc_token=dict(type='dict', options=dict(service_account_email=dict(type='str'), audience=dict(type='str'))),
),
),
region=dict(required=True, type='str'),
),
mutually_exclusive=[['app_engine_http_target', 'http_target', 'pubsub_target']],
)
if not module.params['scopes']:
module.params['scopes'] = ['https://www.googleapis.com/auth/cloud-platform']
state = module.params['state']
fetch = fetch_resource(module, self_link(module))
changed = False
if fetch:
if state == 'present':
if is_different(module, fetch):
update(module, self_link(module))
fetch = fetch_resource(module, self_link(module))
changed = True
else:
delete(module, self_link(module))
fetch = {}
changed = True
else:
if state == 'present':
fetch = create(module, collection(module))
changed = True
else:
fetch = {}
fetch.update({'changed': changed})
module.exit_json(**fetch)
def main():
"""Main function"""
module = GcpModule(argument_spec=dict(
state=dict(
default='present', choices=['present', 'absent'], type='str'),
name=dict(type='str'),
config=dict(
type='dict',
options=dict(
machine_type=dict(type='str'),
disk_size_gb=dict(type='int'),
oauth_scopes=dict(type='list', elements='str'),
service_account=dict(type='str'),
metadata=dict(type='dict'),
image_type=dict(type='str'),
labels=dict(type='dict'),
local_ssd_count=dict(type='int'),
tags=dict(type='list', elements='str'),
preemptible=dict(type='bool'),
accelerators=dict(type='list',
elements='dict',
options=dict(accelerator_count=dict(
type='int'),
accelerator_type=dict(
type='str'))),
disk_type=dict(type='str'),
min_cpu_platform=dict(type='str'),
taints=dict(type='list',
elements='dict',
options=dict(key=dict(type='str'),
value=dict(type='str'),
effect=dict(type='str'))),
),
),
initial_node_count=dict(required=True, type='int'),
version=dict(type='str'),
autoscaling=dict(type='dict',
options=dict(enabled=dict(type='bool'),
min_node_count=dict(type='int'),
max_node_count=dict(type='int'))),
management=dict(type='dict',
options=dict(auto_upgrade=dict(type='bool'),
auto_repair=dict(type='bool'),
upgrade_options=dict(type='dict',
options=dict()))),
max_pods_constraint=dict(
type='dict', options=dict(max_pods_per_node=dict(type='int'))),
conditions=dict(
type='list', elements='dict', options=dict(code=dict(type='str'))),
cluster=dict(required=True, type='dict'),
location=dict(required=True, type='str', aliases=['region', 'zone']),
))
if not module.params['scopes']:
module.params['scopes'] = [
'https://www.googleapis.com/auth/cloud-platform'
]
state = module.params['state']
fetch = fetch_resource(module, self_link(module))
changed = False
if fetch:
if state == 'present':
if is_different(module, fetch):
update(module, self_link(module))
fetch = fetch_resource(module, self_link(module))
changed = True
else:
delete(module, self_link(module))
fetch = {}
changed = True
else:
if state == 'present':
fetch = create(module, collection(module))
changed = True
else:
fetch = {}
fetch.update({'changed': changed})
module.exit_json(**fetch)
def main():
"""Main function"""
module = GcpModule(argument_spec=dict(
state=dict(
default='present', choices=['present', 'absent'], type='str'),
name=dict(type='str'),
description=dict(type='str'),
initial_node_count=dict(required=True, type='int'),
node_config=dict(type='dict',
options=dict(machine_type=dict(type='str'),
disk_size_gb=dict(type='int'),
oauth_scopes=dict(type='list',
elements='str'),
service_account=dict(type='str'),
metadata=dict(type='dict'),
image_type=dict(type='str'),
labels=dict(type='dict'),
local_ssd_count=dict(type='int'),
tags=dict(type='list', elements='str'),
preemptible=dict(type='bool'))),
master_auth=dict(type='dict',
options=dict(username=dict(type='str'),
password=dict(type='str'),
cluster_ca_certificate=dict(type='str'),
client_certificate=dict(type='str'),
client_key=dict(type='str'))),
logging_service=dict(type='str',
choices=['logging.googleapis.com', 'none']),
monitoring_service=dict(type='str',
choices=['monitoring.googleapis.com', 'none']),
network=dict(type='str'),
cluster_ipv4_cidr=dict(type='str'),
addons_config=dict(
type='dict',
options=dict(http_load_balancing=dict(
type='dict', options=dict(disabled=dict(type='bool'))),
horizontal_pod_autoscaling=dict(
type='dict',
options=dict(disabled=dict(type='bool'))))),
subnetwork=dict(type='str'),
location=dict(type='list', elements='str'),
zone=dict(required=True, type='str')))
state = module.params['state']
fetch = fetch_resource(module, self_link(module))
changed = False
if fetch:
if state == 'present':
if is_different(module, fetch):
fetch = update(module, self_link(module), fetch)
changed = True
else:
delete(module, self_link(module), fetch)
fetch = {}
changed = True
else:
if state == 'present':
fetch = create(module, collection(module))
changed = True
else:
fetch = {}
fetch.update({'changed': changed})
module.exit_json(**fetch)
def main():
"""Main function"""
module = GcpModule(
argument_spec=dict(
state=dict(default='present',
choices=['present', 'absent'],
type='str'),
allowed=dict(type='list',
elements='dict',
options=dict(ip_protocol=dict(required=True,
type='str'),
ports=dict(type='list',
elements='str'))),
denied=dict(type='list',
elements='dict',
options=dict(ip_protocol=dict(required=True,
type='str'),
ports=dict(type='list', elements='str'))),
description=dict(type='str'),
destination_ranges=dict(type='list', elements='str'),
direction=dict(type='str'),
disabled=dict(type='bool'),
name=dict(required=True, type='str'),
network=dict(default=dict(selfLink='global/networks/default'),
type='dict'),
priority=dict(default=1000, type='int'),
source_ranges=dict(type='list', elements='str'),
source_service_accounts=dict(type='list', elements='str'),
source_tags=dict(type='list', elements='str'),
target_service_accounts=dict(type='list', elements='str'),
target_tags=dict(type='list', elements='str'),
),
mutually_exclusive=[
['allowed', 'denied'],
['destination_ranges', 'source_ranges', 'source_tags'],
['destination_ranges', 'source_ranges'],
['source_service_accounts', 'source_tags', 'target_tags'],
[
'destination_ranges', 'source_service_accounts', 'source_tags',
'target_service_accounts'
],
['source_tags', 'target_service_accounts', 'target_tags'],
[
'source_service_accounts', 'target_service_accounts',
'target_tags'
],
],
)
if not module.params['scopes']:
module.params['scopes'] = ['https://www.googleapis.com/auth/compute']
state = module.params['state']
kind = 'compute#firewall'
fetch = fetch_resource(module, self_link(module), kind)
changed = False
if fetch:
if state == 'present':
if is_different(module, fetch):
update(module, self_link(module), kind)
fetch = fetch_resource(module, self_link(module), kind)
changed = True
else:
delete(module, self_link(module), kind)
fetch = {}
changed = True
else:
if state == 'present':
fetch = create(module, collection(module), kind)
changed = True
else:
fetch = {}
fetch.update({'changed': changed})
module.exit_json(**fetch)
def main():
"""Main function"""
module = GcpModule(argument_spec=dict(
state=dict(
default='present', choices=['present', 'absent'], type='str'),
name=dict(required=True, type='str'),
description=dict(type='str'),
entry_point=dict(type='str'),
runtime=dict(type='str'),
timeout=dict(type='str'),
available_memory_mb=dict(type='int'),
labels=dict(type='dict'),
environment_variables=dict(type='dict'),
source_archive_url=dict(type='str'),
source_upload_url=dict(type='str'),
source_repository=dict(
type='dict', options=dict(url=dict(required=True, type='str'))),
https_trigger=dict(type='dict', options=dict()),
event_trigger=dict(type='dict',
options=dict(
event_type=dict(required=True, type='str'),
resource=dict(required=True, type='str'),
service=dict(type='str'))),
location=dict(required=True, type='str'),
trigger_http=dict(type='bool'),
))
if not module.params['scopes']:
module.params['scopes'] = [
'https://www.googleapis.com/auth/cloud-platform'
]
state = module.params['state']
fetch = fetch_resource(module, self_link(module))
changed = False
# Need to set triggerHttps to {} if boolean true.
if fetch and fetch.get('httpsTrigger') and module.params['trigger_http']:
module.params['https_trigger'] = fetch.get('httpsTrigger')
elif module.params['trigger_http']:
module.params['https_trigger'] = {}
if fetch:
if state == 'present':
if is_different(module, fetch):
update(module, self_link(module), fetch)
fetch = fetch_resource(module, self_link(module))
changed = True
else:
delete(module, self_link(module))
fetch = {}
changed = True
else:
if state == 'present':
fetch = create(module, collection(module))
changed = True
else:
fetch = {}
fetch.update({'changed': changed})
module.exit_json(**fetch)
def main():
"""Main function"""
module = GcpModule(
argument_spec=dict(
state=dict(default='present', choices=['present', 'absent'], type='str'),
acl=dict(
type='list',
elements='dict',
options=dict(
bucket=dict(required=True, type='dict'),
entity=dict(required=True, type='str'),
entity_id=dict(type='str'),
project_team=dict(type='dict', options=dict(project_number=dict(type='str'), team=dict(type='str'))),
role=dict(type='str'),
),
),
cors=dict(
type='list',
elements='dict',
options=dict(
max_age_seconds=dict(type='int'),
method=dict(type='list', elements='str'),
origin=dict(type='list', elements='str'),
response_header=dict(type='list', elements='str'),
),
),
default_event_based_hold=dict(type='bool'),
default_object_acl=dict(
type='list',
elements='dict',
options=dict(
bucket=dict(required=True, type='dict'),
entity=dict(required=True, type='str'),
object=dict(type='str'),
role=dict(required=True, type='str'),
),
),
lifecycle=dict(
type='dict',
options=dict(
rule=dict(
type='list',
elements='dict',
options=dict(
action=dict(type='dict', options=dict(storage_class=dict(type='str'), type=dict(type='str'))),
condition=dict(
type='dict',
options=dict(
age_days=dict(type='int'),
created_before=dict(type='str'),
is_live=dict(type='bool'),
matches_storage_class=dict(type='list', elements='str'),
num_newer_versions=dict(type='int'),
),
),
),
)
),
),
location=dict(type='str'),
logging=dict(type='dict', options=dict(log_bucket=dict(type='str'), log_object_prefix=dict(type='str'))),
metageneration=dict(type='int'),
name=dict(type='str'),
owner=dict(type='dict', options=dict(entity=dict(type='str'))),
storage_class=dict(type='str'),
versioning=dict(type='dict', options=dict(enabled=dict(type='bool'))),
website=dict(type='dict', options=dict(main_page_suffix=dict(type='str'), not_found_page=dict(type='str'))),
project=dict(type='str'),
predefined_default_object_acl=dict(type='str'),
)
)
if not module.params['scopes']:
module.params['scopes'] = ['https://www.googleapis.com/auth/devstorage.full_control']
state = module.params['state']
kind = 'storage#bucket'
fetch = fetch_resource(module, self_link(module), kind)
changed = False
if fetch:
if state == 'present':
if is_different(module, fetch):
update(module, self_link(module), kind)
fetch = fetch_resource(module, self_link(module), kind)
changed = True
else:
delete(module, self_link(module), kind)
fetch = {}
changed = True
else:
if state == 'present':
fetch = create(module, collection(module), kind)
changed = True
else:
fetch = {}
fetch.update({'changed': changed})
module.exit_json(**fetch)
def main():
"""Main function"""
module = GcpModule(argument_spec=dict(
state=dict(
default='present', choices=['present', 'absent'], type='str'),
description=dict(type='str'),
labels=dict(type='dict'),
licenses=dict(type='list', elements='str'),
name=dict(required=True, type='str'),
size_gb=dict(type='int'),
type=dict(type='str'),
source_image=dict(type='str'),
zone=dict(required=True, type='str'),
source_image_encryption_key=dict(type='dict',
options=dict(raw_key=dict(type='str'),
sha256=dict(type='str'),
kms_key_name=dict(
type='str'))),
disk_encryption_key=dict(type='dict',
options=dict(raw_key=dict(type='str'),
sha256=dict(type='str'),
kms_key_name=dict(type='str'))),
source_snapshot=dict(),
source_snapshot_encryption_key=dict(type='dict',
options=dict(raw_key=dict(
type='str'),
kms_key_name=dict(
type='str'),
sha256=dict(
type='str'))),
))
if not module.params['scopes']:
module.params['scopes'] = ['https://www.googleapis.com/auth/compute']
state = module.params['state']
kind = 'compute#disk'
fetch = fetch_resource(module, self_link(module), kind)
changed = False
if fetch:
if state == 'present':
if is_different(module, fetch):
update(module, self_link(module), kind, fetch)
fetch = fetch_resource(module, self_link(module), kind)
changed = True
else:
delete(module, self_link(module), kind)
fetch = {}
changed = True
else:
if state == 'present':
fetch = create(module, collection(module), kind)
changed = True
else:
fetch = {}
fetch.update({'changed': changed})
module.exit_json(**fetch)
def main():
"""Main function"""
module = GcpModule(argument_spec=dict(
action=dict(type="str", choices=["download", "upload", "delete"]),
src=dict(type="path"),
dest=dict(type="path"),
bucket=dict(type="str"),
))
if not HAS_GOOGLE_STORAGE_LIBRARY:
module.fail_json(
msg="Please install the google-cloud-storage Python library")
if not module.params["scopes"]:
module.params["scopes"] = [
"https://www.googleapis.com/auth/devstorage.full_control"
]
creds = GcpSession(module, "storage")._credentials()
client = storage.Client(
project=module.params['project'],
credentials=creds,
client_info=ClientInfo(user_agent="Google-Ansible-MM-object"))
bucket = client.get_bucket(module.params['bucket'])
remote_file_exists = Blob(remote_file_path(module), bucket).exists()
local_file_exists = os.path.isfile(local_file_path(module))
# Check if files exist.
results = {}
if module.params["action"] == "delete" and not remote_file_exists:
module.fail_json(msg="File does not exist in bucket")
if module.params["action"] == "download" and not remote_file_exists:
module.fail_json(msg="File does not exist in bucket")
if module.params["action"] == "upload" and not local_file_exists:
module.fail_json(msg="File does not exist on disk")
if module.params["action"] == "delete":
if remote_file_exists:
results = delete_file(module, client, module.params["src"])
results["changed"] = True
module.params["changed"] = True
elif module.params["action"] == "download":
results = download_file(module, client, module.params["src"],
module.params["dest"])
results["changed"] = True
# Upload
else:
results = upload_file(module, client, module.params["src"],
module.params["dest"])
results["changed"] = True
module.exit_json(**results)
def main():
"""Main function"""
module = GcpModule(
argument_spec=dict(
state=dict(default='present',
choices=['present', 'absent'],
type='str'),
check_interval_sec=dict(default=5, type='int'),
description=dict(type='str'),
healthy_threshold=dict(default=2, type='int'),
name=dict(required=True, type='str'),
timeout_sec=dict(default=5,
type='int',
aliases=['timeout_seconds']),
unhealthy_threshold=dict(default=2, type='int'),
type=dict(type='str', choices=['TCP', 'SSL', 'HTTP', 'HTTPS']),
http_health_check=dict(
type='dict',
options=dict(
host=dict(type='str'),
request_path=dict(default='/', type='str'),
response=dict(type='str'),
port=dict(type='int'),
port_name=dict(type='str'),
proxy_header=dict(default='NONE',
type='str',
choices=['NONE', 'PROXY_V1']),
),
),
https_health_check=dict(
type='dict',
options=dict(
host=dict(type='str'),
request_path=dict(default='/', type='str'),
response=dict(type='str'),
port=dict(type='int'),
port_name=dict(type='str'),
proxy_header=dict(default='NONE',
type='str',
choices=['NONE', 'PROXY_V1']),
),
),
tcp_health_check=dict(
type='dict',
options=dict(
request=dict(type='str'),
response=dict(type='str'),
port=dict(type='int'),
port_name=dict(type='str'),
proxy_header=dict(default='NONE',
type='str',
choices=['NONE', 'PROXY_V1']),
),
),
ssl_health_check=dict(
type='dict',
options=dict(
request=dict(type='str'),
response=dict(type='str'),
port=dict(type='int'),
port_name=dict(type='str'),
proxy_header=dict(default='NONE',
type='str',
choices=['NONE', 'PROXY_V1']),
),
),
),
mutually_exclusive=[[
'http_health_check', 'https_health_check', 'ssl_health_check',
'tcp_health_check'
]],
)
if not module.params['scopes']:
module.params['scopes'] = ['https://www.googleapis.com/auth/compute']
state = module.params['state']
kind = 'compute#healthCheck'
fetch = fetch_resource(module, self_link(module), kind)
changed = False
if fetch:
if state == 'present':
if is_different(module, fetch):
update(module, self_link(module), kind)
fetch = fetch_resource(module, self_link(module), kind)
changed = True
else:
delete(module, self_link(module), kind)
fetch = {}
changed = True
else:
if state == 'present':
fetch = create(module, collection(module), kind)
changed = True
else:
fetch = {}
fetch.update({'changed': changed})
module.exit_json(**fetch)
def main():
"""Main function"""
module = GcpModule(
argument_spec=dict(
state=dict(default='present', choices=['present', 'absent'], type='str'),
description=dict(type='str'),
name=dict(required=True, type='str'),
specific_reservation_required=dict(type='bool'),
specific_reservation=dict(
required=True,
type='dict',
options=dict(
count=dict(required=True, type='int'),
instance_properties=dict(
required=True,
type='dict',
options=dict(
machine_type=dict(required=True, type='str'),
min_cpu_platform=dict(type='str'),
guest_accelerators=dict(
type='list',
elements='dict',
options=dict(accelerator_type=dict(required=True, type='str'), accelerator_count=dict(required=True, type='int')),
),
local_ssds=dict(
type='list',
elements='dict',
options=dict(interface=dict(default='SCSI', type='str'), disk_size_gb=dict(required=True, type='int')),
),
),
),
),
),
zone=dict(required=True, type='str'),
)
)
if not module.params['scopes']:
module.params['scopes'] = ['https://www.googleapis.com/auth/compute']
state = module.params['state']
fetch = fetch_resource(module, self_link(module))
changed = False
if fetch:
if state == 'present':
if is_different(module, fetch):
update(module, self_link(module))
fetch = fetch_resource(module, self_link(module))
changed = True
else:
delete(module, self_link(module))
fetch = {}
changed = True
else:
if state == 'present':
fetch = create(module, collection(module))
changed = True
else:
fetch = {}
fetch.update({'changed': changed})
module.exit_json(**fetch)
def main():
"""Main function"""
module = GcpModule(argument_spec=dict(
state=dict(
default='present', choices=['present', 'absent'], type='str'),
description=dict(type='str'),
disk_size_gb=dict(type='int'),
family=dict(type='str'),
guest_os_features=dict(
type='list',
elements='dict',
options=dict(
type=dict(type='str', choices=['VIRTIO_SCSI_MULTIQUEUE']))),
image_encryption_key=dict(type='dict',
options=dict(raw_key=dict(type='str'),
sha256=dict(type='str'))),
labels=dict(type='dict'),
licenses=dict(type='list', elements='str'),
name=dict(required=True, type='str'),
raw_disk=dict(
type='dict',
options=dict(container_type=dict(type='str', choices=['TAR']),
sha1_checksum=dict(type='str'),
source=dict(required=True, type='str')),
),
source_disk=dict(),
source_disk_encryption_key=dict(type='dict',
options=dict(raw_key=dict(type='str'),
sha256=dict(type='str'))),
source_disk_id=dict(type='str'),
source_type=dict(type='str', choices=['RAW']),
))
if not module.params['scopes']:
module.params['scopes'] = ['https://www.googleapis.com/auth/compute']
state = module.params['state']
kind = 'compute#image'
fetch = fetch_resource(module, self_link(module), kind)
changed = False
if fetch:
if state == 'present':
if is_different(module, fetch):
update(module, self_link(module), kind, fetch)
fetch = fetch_resource(module, self_link(module), kind)
changed = True
else:
delete(module, self_link(module), kind)
fetch = {}
changed = True
else:
if state == 'present':
fetch = create(module, collection(module), kind)
changed = True
else:
fetch = {}
fetch.update({'changed': changed})
module.exit_json(**fetch)
def main():
"""Main function"""
module = GcpModule(
argument_spec=dict(
state=dict(default='present', choices=['present', 'absent'], type='str'),
affinity_cookie_ttl_sec=dict(type='int'),
backends=dict(
type='list',
elements='dict',
options=dict(
balancing_mode=dict(default='UTILIZATION', type='str'),
capacity_scaler=dict(default=1.0, type='str'),
description=dict(type='str'),
group=dict(type='str'),
max_connections=dict(type='int'),
max_connections_per_instance=dict(type='int'),
max_connections_per_endpoint=dict(type='int'),
max_rate=dict(type='int'),
max_rate_per_instance=dict(type='str'),
max_rate_per_endpoint=dict(type='str'),
max_utilization=dict(default=0.8, type='str'),
),
),
cdn_policy=dict(
type='dict',
options=dict(
cache_key_policy=dict(
type='dict',
options=dict(
include_host=dict(type='bool'),
include_protocol=dict(type='bool'),
include_query_string=dict(type='bool'),
query_string_blacklist=dict(type='list', elements='str'),
query_string_whitelist=dict(type='list', elements='str'),
),
),
signed_url_cache_max_age_sec=dict(default=3600, type='int'),
),
),
connection_draining=dict(type='dict', options=dict(draining_timeout_sec=dict(default=300, type='int'))),
description=dict(type='str'),
enable_cdn=dict(type='bool'),
health_checks=dict(required=True, type='list', elements='str'),
iap=dict(
type='dict',
options=dict(enabled=dict(type='bool'), oauth2_client_id=dict(required=True, type='str'), oauth2_client_secret=dict(required=True, type='str')),
),
load_balancing_scheme=dict(default='EXTERNAL', type='str'),
name=dict(required=True, type='str'),
port_name=dict(type='str'),
protocol=dict(type='str'),
security_policy=dict(type='str'),
session_affinity=dict(type='str'),
timeout_sec=dict(type='int', aliases=['timeout_seconds']),
)
)
if not module.params['scopes']:
module.params['scopes'] = ['https://www.googleapis.com/auth/compute']
state = module.params['state']
kind = 'compute#backendService'
fetch = fetch_resource(module, self_link(module), kind)
changed = False
if fetch:
if state == 'present':
if is_different(module, fetch):
update(module, self_link(module), kind, fetch)
fetch = fetch_resource(module, self_link(module), kind)
changed = True
else:
delete(module, self_link(module), kind)
fetch = {}
changed = True
else:
if state == 'present':
fetch = create(module, collection(module), kind)
changed = True
else:
fetch = {}
fetch.update({'changed': changed})
module.exit_json(**fetch)
def main():
"""Main function"""
module = GcpModule(argument_spec=dict(
state=dict(
default='present', choices=['present', 'absent'], type='str'),
description=dict(required=True, type='str'),
dns_name=dict(required=True, type='str'),
dnssec_config=dict(
type='dict',
options=dict(
kind=dict(default='dns#managedZoneDnsSecConfig', type='str'),
non_existence=dict(type='str'),
state=dict(type='str'),
default_key_specs=dict(
type='list',
elements='dict',
options=dict(algorithm=dict(type='str'),
key_length=dict(type='int'),
key_type=dict(type='str'),
kind=dict(default='dns#dnsKeySpec',
type='str')),
),
),
),
name=dict(required=True, type='str'),
name_server_set=dict(type='str'),
labels=dict(type='dict'),
visibility=dict(default='public', type='str'),
private_visibility_config=dict(type='dict',
options=dict(networks=dict(
required=True,
type='list',
elements='dict',
options=dict(network_url=dict(
required=True, type='str'))))),
))
if not module.params['scopes']:
module.params['scopes'] = [
'https://www.googleapis.com/auth/ndev.clouddns.readwrite'
]
state = module.params['state']
kind = 'dns#managedZone'
fetch = fetch_resource(module, self_link(module), kind)
changed = False
if fetch:
if state == 'present':
if is_different(module, fetch):
update(module, self_link(module), kind, fetch)
fetch = fetch_resource(module, self_link(module), kind)
changed = True
else:
delete(module, self_link(module), kind)
fetch = {}
changed = True
else:
if state == 'present':
fetch = create(module, collection(module), kind)
changed = True
else:
fetch = {}
fetch.update({'changed': changed})
module.exit_json(**fetch)
def main():
"""Main function"""
module = GcpModule(
argument_spec=dict(
state=dict(default='present', choices=['present', 'absent'], type='str'),
affinity_cookie_ttl_sec=dict(type='int'),
backends=dict(type='list', elements='dict', options=dict(
balancing_mode=dict(type='str', choices=['UTILIZATION', 'RATE', 'CONNECTION']),
capacity_scaler=dict(type='str'),
description=dict(type='str'),
group=dict(type='dict'),
max_connections=dict(type='int'),
max_connections_per_instance=dict(type='int'),
max_rate=dict(type='int'),
max_rate_per_instance=dict(type='str'),
max_utilization=dict(type='str')
)),
cdn_policy=dict(type='dict', options=dict(
cache_key_policy=dict(type='dict', options=dict(
include_host=dict(type='bool'),
include_protocol=dict(type='bool'),
include_query_string=dict(type='bool'),
query_string_blacklist=dict(type='list', elements='str'),
query_string_whitelist=dict(type='list', elements='str')
))
)),
connection_draining=dict(type='dict', options=dict(
draining_timeout_sec=dict(type='int')
)),
description=dict(type='str'),
enable_cdn=dict(type='bool'),
health_checks=dict(type='list', elements='str'),
name=dict(type='str'),
port_name=dict(type='str'),
protocol=dict(type='str', choices=['HTTP', 'HTTPS', 'TCP', 'SSL']),
region=dict(type='str'),
session_affinity=dict(type='str', choices=['NONE', 'CLIENT_IP', 'GENERATED_COOKIE', 'CLIENT_IP_PROTO', 'CLIENT_IP_PORT_PROTO']),
timeout_sec=dict(type='int', aliases=['timeout_seconds'])
)
)
state = module.params['state']
kind = 'compute#backendService'
fetch = fetch_resource(module, self_link(module), kind)
changed = False
if fetch:
if state == 'present':
if is_different(module, fetch):
fetch = update(module, self_link(module), kind, fetch)
changed = True
else:
delete(module, self_link(module), kind, fetch)
fetch = {}
changed = True
else:
if state == 'present':
fetch = create(module, collection(module), kind)
changed = True
else:
fetch = {}
fetch.update({'changed': changed})
module.exit_json(**fetch)
