def main():
module_args = oci_utils.get_facts_module_arg_spec()
module_args.update(
dict(compartment_id=dict(type='str', required=False),
drg_id=dict(type='str', required=False),
remote_peering_connection_id=dict(type='str',
required=False,
aliases=['id'])))
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=False,
required_one_of=[['remote_peering_connection_id', 'compartment_id']])
if not HAS_OCI_PY_SDK:
module.fail_json(msg='oci python sdk required for this module.')
virtual_network_client = oci_utils.create_service_client(
module, VirtualNetworkClient)
remote_peering_connection_id = module.params[
'remote_peering_connection_id']
result = []
try:
if remote_peering_connection_id is not None:
result = [
to_dict(
oci_utils.call_with_backoff(
virtual_network_client.get_remote_peering_connection,
remote_peering_connection_id=
remote_peering_connection_id).data)
]
else:
result = to_dict(
oci_utils.list_all_resources(
virtual_network_client.list_remote_peering_connections,
display_name=module.params['display_name'],
drg_id=module.params['drg_id'],
compartment_id=module.params['compartment_id']))
except ServiceError as ex:
module.fail_json(msg=ex.message)
module.exit_json(remote_peering_connections=result)
def main():
module_args = oci_utils.get_facts_module_arg_spec()
module_args.update(dict(
compartment_id=dict(type='str', required=False),
volume_backup_id=dict(type='str', required=False, aliases=['id']),
volume_id=dict(type='str', required=False),
lifecycle_state=dict(type='str', required=False)
))
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=False,
mutually_exclusive=[
['compartment_id', 'volume_backup_id']
],
required_one_of=[
['compartment_id', 'volume_backup_id']
]
)
if not HAS_OCI_PY_SDK:
module.fail_json(msg='oci python sdk required for this module.')
block_storage_client = oci_utils.create_service_client(module, BlockstorageClient)
volume_backup_id = module.params['volume_backup_id']
try:
if volume_backup_id is not None:
result = [to_dict(oci_utils.call_with_backoff(block_storage_client.get_volume_backup,
volume_backup_id=volume_backup_id).data)]
else:
compartment_id = module.params['compartment_id']
optional_list_method_params = ['display_name', 'lifecycle_state', 'volume_id']
optional_kwargs = {param: module.params[param] for param in optional_list_method_params
if module.params.get(param) is not None}
result = to_dict(oci_utils.list_all_resources(block_storage_client.list_volume_backups,
compartment_id=compartment_id,
**optional_kwargs))
except ServiceError as ex:
module.fail_json(msg=ex.message)
module.exit_json(volume_backups=result)
def main():
module_args = oci_utils.get_common_arg_spec()
module_args.update(
dict(
compartment_id=dict(type="str", required=True),
instance_pool_id=dict(type="str", required=True, aliases=["id"]),
)
)
module = AnsibleModule(argument_spec=module_args, supports_check_mode=False)
if not HAS_OCI_PY_SDK:
module.fail_json(msg="oci python sdk required for this module.")
compute_management_client = oci_utils.create_service_client(
module, ComputeManagementClient
)
compute_client = oci_utils.create_service_client(module, ComputeClient)
try:
compartment_id = module.params["compartment_id"]
instance_pool_id = module.params["instance_pool_id"]
instance_summaries = to_dict(
oci_utils.list_all_resources(
compute_management_client.list_instance_pool_instances,
compartment_id=compartment_id,
instance_pool_id=instance_pool_id,
)
)
# Get model from summaries returned by `list_instance_pools_instances`
result = to_dict(
[
oci_utils.call_with_backoff(
compute_client.get_instance, instance_id=inst_summ["id"]
).data
for inst_summ in instance_summaries
]
)
except ServiceError as ex:
module.fail_json(msg=ex.message)
module.exit_json(instance_pool_instances=result)
def get_load_balancer_backend_set_health(lb_client, module):
result = dict(backend_set_health='')
load_balancer_id = module.params.get('load_balancer_id')
backend_set_name = module.params.get('backend_set_name')
get_logger().info(
'Retrieving Backend Set Health for Backend Set %s in Load Balancer %s',
backend_set_name, load_balancer_id)
try:
response = oci_utils.call_with_backoff(
lb_client.get_backend_set_health,
load_balancer_id=load_balancer_id,
backend_set_name=backend_set_name)
result['backend_set_health'] = to_dict(response.data)
except ServiceError as ex:
get_logger().error("Unable to get backend set health due to: %s",
ex.message)
module.fail_json(msg=ex.message)
return result
def list_tag_namespaces(identity_client, compartment_id, tag_namespace_id,
module):
try:
if tag_namespace_id:
tag_ns = oci_utils.call_with_backoff(
identity_client.get_tag_namespace,
tag_namespace_id=tag_namespace_id).data
return to_dict([tag_ns])
optional_list_method_params = ["include_subcompartments", "name"]
optional_kwargs = dict((param, module.params[param])
for param in optional_list_method_params
if module.params.get(param) is not None)
return to_dict(
oci_utils.list_all_resources(identity_client.list_tag_namespaces,
compartment_id=compartment_id,
**optional_kwargs))
except ServiceError as ex:
module.fail_json(msg=ex.message)
def list_dhcp_options(virtual_network_client, module):
result = dict()
compartment_id = module.params.get('compartment_id')
vcn_id = module.params.get('vcn_id')
dhcp_id = module.params.get('dhcp_id')
try:
if compartment_id and vcn_id:
existing_dhcp_options = oci_utils.list_all_resources(
virtual_network_client.list_dhcp_options,
compartment_id=compartment_id,
vcn_id=vcn_id)
elif dhcp_id:
response = oci_utils.call_with_backoff(
virtual_network_client.get_dhcp_options, dhcp_id=dhcp_id)
existing_dhcp_options = [response.data]
except ServiceError as ex:
module.fail_json(msg=ex.message)
result['dhcp_options_list'] = to_dict(existing_dhcp_options)
return result
def main():
module_args = oci_utils.get_facts_module_arg_spec()
module_args.update(dict(
compartment_id=dict(type='str', required=False),
availability_domain=dict(type='str', required=False),
instance_id=dict(type='str', required=False),
vnic_attachment_id=dict(type='str', required=False, aliases=['id']),
vnic_id=dict(type='str', required=False)
))
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=False,
mutually_exclusive=['id', 'compartment_id']
)
if not HAS_OCI_PY_SDK:
module.fail_json(msg='oci python sdk required for this module.')
compute_client = oci_utils.create_service_client(module, ComputeClient)
compartment_id = module.params.get('compartment_id', None)
id = module.params['vnic_attachment_id']
result = dict()
try:
if compartment_id:
# filter and get only key:values that have been provided by the user
optional_list_method_params = ['availability_domain', "instance_id", "display_name", "vnic_id"]
optional_kwargs = {param: module.params[param] for param in optional_list_method_params
if module.params.get(param) is not None}
inst = oci_utils.list_all_resources(compute_client.list_vnic_attachments, compartment_id=compartment_id,
**optional_kwargs)
result = to_dict(inst)
else:
inst = oci_utils.call_with_backoff(compute_client.get_vnic_attachment, vnic_attachment_id=id).data
result = to_dict([inst])
except ServiceError as ex:
module.fail_json(msg=ex.message)
except MaximumWaitTimeExceeded as mwte:
module.fail_json(msg=str(mwte))
module.exit_json(vnic_attachments=result)
def get_waas_certificate_from_summary_resource(waas_certificate_summary,
waas_client=None):
logger.debug("Waas certificate summary resource: %s",
waas_certificate_summary)
if not waas_certificate_summary:
return None
if not waas_client:
raise Exception(
"waas client required to get waas certificate from summary resource."
)
if isinstance(waas_certificate_summary, dict):
waas_certificate_id = waas_certificate_summary.get("id")
else:
waas_certificate_id = getattr(waas_certificate_summary, "id", None)
if not waas_certificate_id:
raise Exception(
"The waas certificate summary resource does not have a valid id.")
return oci_utils.call_with_backoff(waas_client.get_certificate,
certificate_id=waas_certificate_id).data
def list_route_tables(virtual_network_client, module):
result = dict(route_tables='')
compartment_id = module.params.get('compartment_id')
vcn_id = module.params.get('vcn_id')
rt_id = module.params.get('rt_id')
try:
if compartment_id and vcn_id:
existing_route_tables = oci_utils.list_all_resources(
virtual_network_client.list_route_tables,
compartment_id=compartment_id,
vcn_id=vcn_id)
elif rt_id:
response = oci_utils.call_with_backoff(
virtual_network_client.get_route_table, rt_id=rt_id)
existing_route_tables = [response.data]
except ServiceError as ex:
module.fail_json(msg=ex.message)
result['route_tables'] = to_dict(existing_route_tables)
return result
def main():
module_args = oci_utils.get_facts_module_arg_spec()
module_args.update(dict(
compartment_id=dict(type='str', required=False),
image_id=dict(type='str', required=False, aliases=['id']),
operating_system=dict(type='str', required=False),
operating_system_version=dict(type='str', required=False),
lifecycle_state=dict(type='str', required=False),
shape=dict(type='str', required=False)
))
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=False,
mutually_exclusive=['id', 'compartment_id']
)
if not HAS_OCI_PY_SDK:
module.fail_json(msg='oci python sdk required for this module.')
compute_client = oci_utils.create_service_client(module, ComputeClient)
compartment_id = module.params['compartment_id']
id = module.params['image_id']
result = dict(changed=False)
try:
if compartment_id:
optional_list_method_params = ['operating_system', 'operating_system_version', 'lifecycle_state', 'shape']
optional_kwargs = {param: module.params[param] for param in optional_list_method_params
if module.params.get(param) is not None}
inst = oci_utils.list_all_resources(compute_client.list_images, compartment_id=compartment_id,
**optional_kwargs)
result = to_dict(inst)
else:
inst = oci_utils.call_with_backoff(compute_client.get_image, image_id=id).data
result = to_dict([inst])
except ServiceError as ex:
module.fail_json(msg=ex.message)
except MaximumWaitTimeExceeded as mwte:
module.fail_json(msg=str(mwte))
module.exit_json(images=result)
def main():
module_args = oci_utils.get_common_arg_spec()
module_args.update(
dict(
zone_id=dict(type="str", required=False, aliases=["id"]),
name=dict(type="str", required=False, aliases=["zone_name"]),
compartment_id=dict(type="str", required=False),
domain=dict(type="str", required=True),
zone_version=dict(type="str", required=False),
rtype=dict(type="str", required=True),
))
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=False,
required_one_of=[["zone_id", "name"]],
)
if not HAS_OCI_PY_SDK:
module.fail_json(msg="oci python sdk required for this module.")
dns_client = oci_utils.create_service_client(module, DnsClient)
try:
zone_name_or_id = get_zone_name_or_id(module)
key_list = ["compartment_id", "zone_version"]
kwargs = {
k: v
for (k, v) in six.iteritems(module.params)
if k in key_list and v is not None
}
result = to_dict(
oci_utils.call_with_backoff(dns_client.get_rr_set,
zone_name_or_id=zone_name_or_id,
domain=module.params["domain"],
rtype=module.params["rtype"],
**kwargs).data.items)
except ServiceError as ex:
module.fail_json(msg=ex.message)
module.exit_json(rrset=result)
def main():
module_args = oci_utils.get_facts_module_arg_spec()
module_args.update(dict(
compartment_id=dict(type='str', required=False),
availability_domain=dict(type='str', required=False),
instance_id=dict(type='str', required=False, aliases=['id']),
lifecycle_state=dict(type='str', required=False)
))
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=False,
mutually_exclusive=['id', 'compartment_id']
)
if not HAS_OCI_PY_SDK:
module.fail_json(msg='oci python sdk required for this module.')
compute_client = oci_utils.create_service_client(module, ComputeClient)
compartment_id = module.params['compartment_id']
id = module.params['instance_id']
result = dict(changed=False)
if compartment_id:
result = list_instances(compute_client, module)
else:
try:
inst = oci_utils.call_with_backoff(compute_client.get_instance, instance_id=id).data
result = to_dict([inst])
except ServiceError as ex:
module.fail_json(msg=ex.message)
# For each instance in the result, add related volume_attachments and boot_volume_attachment facts
try:
add_volume_attachment_facts(compute_client, result)
add_boot_volume_attachment_facts(compute_client, result)
except ServiceError as ex:
module.fail_json(msg=ex.message)
module.exit_json(instances=result)
def main():
module_args = oci_utils.get_common_arg_spec()
module_args.update(
dict(compartment_id=dict(type='str', required=False),
vcn_id=dict(type='str', required=False)))
module = AnsibleModule(argument_spec=module_args,
supports_check_mode=False)
if not HAS_OCI_PY_SDK:
module.fail_json(msg='oci python sdk required for this module.')
config = oci_utils.get_oci_config(module)
virtual_network_client = VirtualNetworkClient(config)
vcn_id = module.params['vcn_id']
compartment_id = module.params['compartment_id']
result = []
if vcn_id is not None:
try:
result = [
to_dict(
oci_utils.call_with_backoff(virtual_network_client.get_vcn,
vcn_id=vcn_id).data)
]
except ServiceError as ex:
module.fail_json(msg=ex.message)
elif compartment_id is not None:
try:
result = to_dict(
oci_utils.list_all_resources(virtual_network_client.list_vcns,
compartment_id=compartment_id))
except ServiceError as ex:
module.fail_json(msg=ex.message)
else:
module.fail_json(
msg=
"Specify a compartment_id to get all the VCNs in the compartment or a vcn_id to retrieve \
a specific VCN")
module.exit_json(vcns=result)
def main():
module_args = oci_utils.get_common_arg_spec()
module_args.update(
dict(
instance_console_connection_id=dict(type='str',
required=False,
aliases=['id']),
compartment_id=dict(type='str', required=False),
))
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=False,
required_one_of=[['instance_console_connection_id', 'compartment_id']])
if not HAS_OCI_PY_SDK:
module.fail_json(msg='oci python sdk required for this module.')
compute_client = oci_utils.create_service_client(module, ComputeClient)
instance_console_connection_id = module.params[
'instance_console_connection_id']
compartment_id = module.params['compartment_id']
try:
if instance_console_connection_id is not None:
result = [
to_dict(
oci_utils.call_with_backoff(
compute_client.get_instance_console_connection,
instance_console_connection_id=
instance_console_connection_id).data)
]
elif compartment_id is not None:
result = to_dict(
oci_utils.list_all_resources(
compute_client.list_instance_console_connections,
compartment_id=compartment_id))
except ServiceError as ex:
module.fail_json(msg=ex.message)
module.exit_json(instance_console_connections=result)
def main():
module_args = oci_utils.get_common_arg_spec()
module_args.update(
dict(zone_id=dict(type='str', required=False, aliases=['id']),
name=dict(type='str', required=False, aliases=['zone_name']),
compartment_id=dict(type='str', required=False),
zone_version=dict(type='str', required=False),
domain=dict(type='str', required=False),
domain_contains=dict(type='str', required=False),
rtype=dict(type='str', required=False)))
module = AnsibleModule(argument_spec=module_args,
supports_check_mode=False,
required_one_of=[['zone_id', 'name']])
if not HAS_OCI_PY_SDK:
module.fail_json(msg='oci python sdk required for this module.')
config = oci_utils.get_oci_config(module)
dns_client = DnsClient(config)
try:
zone_name_or_id = get_zone_name_or_id(module)
key_list = [
"compartment_id", "zone_version", "domain", "domain_contains",
"rtype"
]
kwargs = {
k: v
for (k, v) in six.iteritems(module.params)
if k in key_list and v is not None
}
result = to_dict(
oci_utils.call_with_backoff(dns_client.get_zone_records,
zone_name_or_id=zone_name_or_id,
**kwargs).data.items)
except ServiceError as ex:
module.fail_json(msg=ex.message)
module.exit_json(zone_records=result)
def main():
module_args = oci_utils.get_facts_module_arg_spec()
module_args.update(
dict(
compartment_id=dict(type="str", required=False),
drg_id=dict(type="str", required=False, aliases=["id"]),
))
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=False,
required_one_of=[["compartment_id", "drg_id"]],
)
if not HAS_OCI_PY_SDK:
module.fail_json(msg="oci python sdk required for this module.")
virtual_network_client = oci_utils.create_service_client(
module, VirtualNetworkClient)
drg_id = module.params["drg_id"]
compartment_id = module.params["compartment_id"]
result = []
try:
if drg_id is not None:
result = [
to_dict(
oci_utils.call_with_backoff(virtual_network_client.get_drg,
drg_id=drg_id).data)
]
else:
result = to_dict(
oci_utils.list_all_resources(
virtual_network_client.list_drgs,
display_name=module.params["display_name"],
compartment_id=compartment_id,
))
except ServiceError as ex:
module.fail_json(msg=ex.message)
module.exit_json(drgs=result)
def main():
module_args = oci_utils.get_facts_module_arg_spec(filter_by_name=True)
module_args.update(
dict(cluster_id=dict(type='str', required=False, aliases=['id']),
compartment_id=dict(type='str', required=False),
lifecycle_state=dict(type='list', required=False)))
module = AnsibleModule(argument_spec=module_args,
supports_check_mode=False)
if not HAS_OCI_PY_SDK:
module.fail_json(msg='oci python sdk required for this module.')
container_engine_client = oci_utils.create_service_client(
module, ContainerEngineClient)
cluster_id = module.params['cluster_id']
try:
if cluster_id is not None:
result = [
to_dict(
oci_utils.call_with_backoff(
container_engine_client.get_cluster,
cluster_id=cluster_id).data)
]
else:
optional_list_method_params = ['name', 'lifecycle_state']
optional_kwargs = {
param: module.params[param]
for param in optional_list_method_params
if module.params.get(param) is not None
}
result = to_dict(
oci_utils.list_all_resources(
container_engine_client.list_clusters,
compartment_id=module.params['compartment_id'],
**optional_kwargs))
except ServiceError as ex:
module.fail_json(msg=ex.message)
module.exit_json(clusters=result)
def main():
module_args = oci_utils.get_facts_module_arg_spec()
module_args.update(dict(
compartment_id=dict(type='str', required=False),
subnet_id=dict(type='str', required=False),
vcn_id=dict(type='str', required=False)
))
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=False
)
if not HAS_OCI_PY_SDK:
module.fail_json(msg='oci python sdk required for this module.')
virtual_network_client = oci_utils.create_service_client(module, VirtualNetworkClient)
subnet_id = module.params['subnet_id']
vcn_id = module.params['vcn_id']
compartment_id = module.params['compartment_id']
result = []
if subnet_id is not None:
try:
result = [
to_dict(oci_utils.call_with_backoff(virtual_network_client.get_subnet, subnet_id=subnet_id).data)]
except ServiceError as ex:
module.fail_json(msg=ex.message)
elif compartment_id is not None and vcn_id is not None:
try:
result = to_dict(oci_utils.list_all_resources(
virtual_network_client.list_subnets,
compartment_id=compartment_id, vcn_id=vcn_id,
display_name=module.params['display_name']))
except ServiceError as ex:
module.fail_json(msg=ex.message)
else:
module.fail_json(msg="Specify a compartment_id and a vcn_id to get all the subnets in the compartment and the \
VCN or a subnet_id to retrieve a specific subnet")
module.exit_json(subnets=result)
def list_work_requests(waas_client, module):
if not (module.params.get("waas_policy_id")
and module.params.get("compartment_id")):
module.fail_json(
msg=
"waas_policy_id and compartment_id are required to list work requests."
)
optional_list_method_params = ["sort_by", "sort_order"]
optional_kwargs = dict((param, module.params[param])
for param in optional_list_method_params
if module.params.get(param) is not None)
return to_dict([
oci_utils.call_with_backoff(waas_client.get_work_request,
work_request_id=work_request.id).data
for work_request in oci_utils.list_all_resources(
waas_client.list_work_requests,
waas_policy_id=module.params["waas_policy_id"],
compartment_id=module.params["compartment_id"],
**optional_kwargs)
])
def list_idp_group_mappings(identity_client, module):
try:
idp_id = module.params["identity_provider_id"]
idp_group_mapping_id = module.params["mapping_id"]
if idp_group_mapping_id:
idp_group_mappings = [
oci_utils.call_with_backoff(
identity_client.get_idp_group_mapping,
identity_provider_id=idp_id,
mapping_id=idp_group_mapping_id,
).data
]
else:
idp_group_mappings = oci_utils.list_all_resources(
identity_client.list_idp_group_mappings,
identity_provider_id=idp_id)
except ServiceError as ex:
module.fail_json(msg=ex.message)
return to_dict(idp_group_mappings)
def main():
module_args = oci_utils.get_common_arg_spec()
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=False
)
if not HAS_OCI_PY_SDK:
module.fail_json(msg='oci python sdk required for this module.')
virtual_network_client = oci_utils.create_service_client(module, VirtualNetworkClient)
try:
result = to_dict(oci_utils.call_with_backoff(
virtual_network_client.list_allowed_peer_regions_for_remote_peering).data)
except ServiceError as ex:
module.fail_json(msg=ex.message)
module.exit_json(peer_region_for_remote_peering=result)
def list_internet_gateways(virtual_network_client, module):
result = dict(internet_gateways='')
compartment_id = module.params.get('compartment_id')
vcn_id = module.params.get('vcn_id')
ig_id = module.params.get('ig_id')
try:
if compartment_id and vcn_id:
existing_igs = oci_utils.list_all_resources(
virtual_network_client.list_internet_gateways,
compartment_id=compartment_id,
vcn_id=vcn_id,
display_name=module.params['display_name'])
elif ig_id:
response = oci_utils.call_with_backoff(
virtual_network_client.get_internet_gateway, ig_id=ig_id)
existing_igs = [response.data]
except ServiceError as ex:
module.fail_json(msg=ex.message)
result['internet_gateways'] = to_dict(existing_igs)
return result
def get_certificate(lb_client, module, lb_id, name):
existing_certificate = None
logger.debug("Trying to get Certificate %s in Load Balancer %s", name,
lb_id)
try:
response = oci_utils.call_with_backoff(lb_client.list_certificates,
load_balancer_id=lb_id)
certificates = response.data
certificate = next((certificate for certificate in certificates
if certificate.certificate_name == name), None)
if certificate:
existing_certificate = certificate
except ServiceError as ex:
logger.error("Failed to perform checking existing Certificates",
exc_info=True)
module.fail_json(msg=ex.message)
if existing_certificate is None:
logger.debug("Certificate %s does not exist in load balancer %s", name,
lb_id)
return existing_certificate
def main():
module_args = oci_utils.get_facts_module_arg_spec()
module_args.update(dict(
compartment_id=dict(type='str', required=False),
nat_gateway_id=dict(type='str', required=False, aliases=['id']),
vcn_id=dict(type='str', required=False),
lifecycle_state=dict(type='str', required=False)
))
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=False,
required_one_of=[
['compartment_id', 'nat_gateway_id']
]
)
if not HAS_OCI_PY_SDK:
module.fail_json(msg='oci python sdk required for this module.')
virtual_network_client = oci_utils.create_service_client(module, VirtualNetworkClient)
nat_gateway_id = module.params['nat_gateway_id']
compartment_id = module.params['compartment_id']
result = []
try:
if nat_gateway_id is not None:
result = [to_dict(oci_utils.call_with_backoff(virtual_network_client.get_nat_gateway,
nat_gateway_id=nat_gateway_id).data)]
else:
optional_list_method_params = ['display_name', 'lifecycle_state', 'vcn_id']
optional_kwargs = {param: module.params[param] for param in optional_list_method_params
if module.params.get(param) is not None}
result = to_dict(oci_utils.list_all_resources(virtual_network_client.list_nat_gateways,
compartment_id=compartment_id,
**optional_kwargs))
except ServiceError as ex:
module.fail_json(msg=ex.message)
module.exit_json(nat_gateways=result)
def update_path_route_set(lb_client, module, lb_id, path_route_set, name):
update_path_route_set_details = UpdatePathRouteSetDetails()
purge_path_routes = module.params.get('purge_path_routes')
input_path_routes = oci_lb_utils.create_path_routes(
module.params.get('path_routes', None))
existing_path_routes = oci_utils.get_hashed_object_list(
PathRoute,
path_route_set.path_routes,
attributes_class_type=[PathMatchType])
get_logger().info("Updating path route set %s in the load balancer %s",
name, lb_id)
changed = False
if input_path_routes is not None:
path_routes, changed = oci_lb_utils.check_and_return_component_list_difference(
input_path_routes, existing_path_routes, purge_path_routes)
if changed:
update_path_route_set_details.path_routes = path_routes
else:
update_path_route_set_details.path_routes = existing_path_routes
if changed:
response = oci_utils.call_with_backoff(
lb_client.update_path_route_set,
update_path_route_set_details=update_path_route_set_details,
load_balancer_id=lb_id,
path_route_set_name=name)
oci_lb_utils.verify_work_request(lb_client, response)
path_route_set = oci_utils.get_existing_resource(
lb_client.get_path_route_set,
module,
load_balancer_id=lb_id,
path_route_set_name=name)
get_logger().info(
"Successfully updated path route set %s in the load balancer %s",
name, lb_id)
else:
get_logger().info(
"No update on path route set %s in the load balancer %s as no attribute changed",
name, lb_id)
return changed, path_route_set
def main():
module_args = oci_utils.get_facts_module_arg_spec()
module_args.update(dict(
compartment_id=dict(type='str', required=False),
vcn_id=dict(type='str', required=False),
lifecycle_state=dict(type='str', required=False)
))
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=False
)
if not HAS_OCI_PY_SDK:
module.fail_json(msg='oci python sdk required for this module.')
virtual_network_client = oci_utils.create_service_client(module, VirtualNetworkClient)
vcn_id = module.params['vcn_id']
compartment_id = module.params['compartment_id']
result = []
if vcn_id is not None:
try:
result = [to_dict(oci_utils.call_with_backoff(virtual_network_client.get_vcn, vcn_id=vcn_id).data)]
except ServiceError as ex:
module.fail_json(msg=ex.message)
elif compartment_id is not None:
try:
optional_list_method_params = ['display_name', 'lifecycle_state']
optional_kwargs = {param: module.params[param] for param in optional_list_method_params
if module.params.get(param) is not None}
result = to_dict(oci_utils.list_all_resources(virtual_network_client.list_vcns,
compartment_id=compartment_id, **optional_kwargs))
except ServiceError as ex:
module.fail_json(msg=ex.message)
else:
module.fail_json(msg="Specify a compartment_id to get all the VCNs in the compartment or a vcn_id to retrieve \
a specific VCN")
module.exit_json(vcns=result)
def update_health_checker(lb_client, module):
health_checker = None
result = dict(
changed=False,
health_checker=''
)
load_balancer_id = module.params.get('load_balancer_id')
backend_set_name = module.params.get('backend_set_name')
health_checker = get_existing_health_checker(
lb_client, module, load_balancer_id, backend_set_name)
try:
if health_checker:
changed = False
get_logger().info("Updating healtch checker details for backendset %s in load balancer %s",
backend_set_name, load_balancer_id)
input_health_checker = UpdateHealthCheckerDetails()
for attribute in input_health_checker.attribute_map.keys():
input_attribute_value = module.params.get(attribute)
changed = oci_utils.check_and_update_attributes(
input_health_checker, attribute, input_attribute_value,
getattr(health_checker, attribute), changed)
get_logger().debug("Existing health checker property values: %s, input property values: %s",
health_checker, input_health_checker)
if changed:
response = oci_utils.call_with_backoff(lb_client.update_health_checker, health_checker=input_health_checker,
load_balancer_id=load_balancer_id, backend_set_name=backend_set_name)
oci_lb_utils.verify_work_request(lb_client, response)
health_checker = get_existing_health_checker(
lb_client, module, load_balancer_id, backend_set_name)
get_logger().info("Successfully updated health checker for backendset %s \
in load balancer %s", backend_set_name, load_balancer_id)
except ServiceError as ex:
get_logger().error("Unable to create/update listener due to: %s", ex.message)
module.fail_json(msg=ex.message)
except ClientError as ex:
get_logger().error("Unable to create/update listener due to: %s", str(ex))
module.fail_json(msg=str(ex))
result['changed'] = changed
result['health_checker'] = to_dict(health_checker)
return result
def create_tag(identity_client, tag_namespace_id, name, description, module):
result = {}
try:
ctd = CreateTagDetails()
ctd.name = name
ctd.description = description
create_response = oci_utils.call_with_backoff(
identity_client.create_tag,
tag_namespace_id=tag_namespace_id,
create_tag_details=ctd)
get_logger().info("Created tag definition %s",
to_dict(create_response.data))
result['tag'] = to_dict(create_response.data)
result['changed'] = True
return result
except ServiceError as ex:
module.fail_json(msg=ex.message)
except MaximumWaitTimeExceeded as mwte:
module.fail_json(msg=str(mwte))
def get_existing_backend(lb_client, module, lb_id, backend_set_name):
existing_backend = None
backend_name = (module.params['ip_address'] + ':' +
str(module.params['port']))
get_logger().debug("Trying to get Backend %s in backend sets %s",
backend_name, backend_set_name)
try:
response = oci_utils.call_with_backoff(
lb_client.get_backend,
load_balancer_id=lb_id,
backend_set_name=backend_set_name,
backend_name=backend_name)
existing_backend = response.data
except ServiceError as ex:
if ex.status != 404:
get_logger().error("Failed to perform checking existing backend",
exc_info=True)
module.fail_json(msg=ex.message)
get_logger().debug("Backend %s does not exist in backend sets %s",
backend_name, backend_set_name)
return existing_backend
def list_security_lists(virtual_network_client, module):
result = dict(
security_lists=''
)
compartment_id = module.params.get('compartment_id')
vcn_id = module.params.get('vcn_id')
security_list_id = module.params.get('security_list_id')
try:
if compartment_id and vcn_id:
existing_security_lists = oci_utils.list_all_resources(
virtual_network_client.list_security_lists,
compartment_id=compartment_id, vcn_id=vcn_id,
display_name=module.params['display_name'])
elif security_list_id:
response = oci_utils.call_with_backoff(
virtual_network_client.get_security_list, security_list_id=security_list_id)
existing_security_lists = [response.data]
except ServiceError as ex:
module.fail_json(msg=ex.message)
result['security_lists'] = to_dict(existing_security_lists)
return result
