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