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, choices=[ "PROVISIONING", "IMPORTING", "AVAILABLE", "EXPORTING", "DISABLED", "DELETED", ], ), 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 = dict((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_taggable_arg_spec(supports_create=True, supports_wait=True) module_args.update( dict( compartment_id=dict(type="str", required=False), certificate_id=dict(type="str", required=False), display_name=dict(type="str", required=False), certificate_data=dict(type="str", required=False), private_key_data=dict(type="str", required=False, no_log=True), is_trust_verification_disabled=dict(type="bool", required=False), state=dict( type="str", required=False, default="present", choices=["absent", "present"], ), )) module = AnsibleModule( argument_spec=module_args, supports_check_mode=False, mutually_exclusive=[("compartment_id", "certificate_id")], ) waas_client = oci_utils.create_service_client(module, WaasClient) exclude_attributes = {} state = module.params["state"] certificate_id = module.params.get("certificate_id") if state == "absent": if not certificate_id: module.fail_json( msg= "Specify certificate_id with state as 'absent' to delete the certificate." ) result = delete_certificate(waas_client, module) else: if certificate_id: result = update_certificate(waas_client, module) else: result = oci_utils.check_and_create_resource( resource_type=RESOURCE_TYPE, create_fn=create_certificate, kwargs_create={ "waas_client": waas_client, "module": module }, list_fn=waas_client.list_certificates, kwargs_list={ "compartment_id": module.params["compartment_id"] }, module=module, model=CreateCertificateDetails(), exclude_attributes=exclude_attributes, get_resource_from_summary_fn=oci_waas_utils. get_waas_certificate_from_summary_resource, get_resource_from_summary_fn_kwargs={ "waas_client": waas_client }, ) module.exit_json(**result)
def main(): module_args = oci_utils.get_common_arg_spec(supports_wait=True) module_args.update( dict(instance_id=dict(type='str', required=False), state=dict(type='str', required=False, default='present', choices=['absent', 'present']), boot_volume_id=dict(type='str', required=False), boot_volume_attachment_id=dict(type='str', required=False, aliases=['id']), display_name=dict(type='str', required=False, aliases=['name']))) module = AnsibleModule( argument_spec=module_args, supports_check_mode=False, required_if=[['state', 'absent', ['boot_volume_attachment_id']], ['state', 'present', ['instance_id', 'boot_volume_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) exclude_attributes = {'display_name': True} state = module.params['state'] if state == 'absent': result = oci_utils.delete_and_wait( resource_type=RESOURCE_NAME, client=compute_client, get_fn=compute_client.get_boot_volume_attachment, kwargs_get={ "boot_volume_attachment_id": module.params["boot_volume_attachment_id"] }, delete_fn=compute_client.detach_boot_volume, kwargs_delete={ "boot_volume_attachment_id": module.params["boot_volume_attachment_id"] }, module=module) else: instance = compute_client.get_instance( module.params["instance_id"]).data result = oci_utils.check_and_create_resource( resource_type=RESOURCE_NAME, create_fn=attach_boot_volume, kwargs_create={ "compute_client": compute_client, "module": module }, list_fn=compute_client.list_boot_volume_attachments, kwargs_list={ "availability_domain": instance.availability_domain, "compartment_id": instance.compartment_id, "instance_id": module.params['instance_id'], "boot_volume_id": module.params['boot_volume_id'] }, exclude_attributes=exclude_attributes, module=module, model=AttachBootVolumeDetails()) module.exit_json(**result)
def main(): module_args = oci_utils.get_common_arg_spec(supports_create=True, supports_wait=True) module_args.update( dict( compartment_id=dict(type="str", required=False), name=dict(type="str", required=False, aliases=["zone_name"]), zone_id=dict(type="str", required=False, aliases=["id"]), zone_type=dict(type="str", required=False, choices=["PRIMARY", "SECONDARY"]), external_masters=dict(type="list", required=False), state=dict( type="str", required=False, default="present", choices=["absent", "present"], ), )) module = AnsibleModule( argument_spec=module_args, supports_check_mode=False, mutually_exclusive=["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) state = module.params["state"] zone_id = module.params["zone_id"] if state == "absent": result = delete_zone(dns_client, module) else: if zone_id is not None: module.params["zone_name_or_id"] = get_zone_name_or_id(module) result = update_zone(dns_client, module) # XXX: also handle case where zone name is specified else: if module.params["zone_type"] is None: module.fail_json( msg="Zone_type must be specified while creating a Zone") kwargs_list = {"compartment_id": module.params["compartment_id"]} result = oci_utils.check_and_create_resource( resource_type="zone", create_fn=create_zone, kwargs_create={ "dns_client": dns_client, "module": module }, list_fn=dns_client.list_zones, kwargs_list=kwargs_list, module=module, model=CreateZoneDetails(), exclude_attributes=None, ) module.exit_json(**result)
def main(): module_args = oci_utils.get_taggable_arg_spec(supports_create=True, supports_wait=True) module_args.update( dict( availability_domain=dict(type="str", required=False), backup_policy_id=dict(type="str", required=False), compartment_id=dict(type="str", required=False), volume_id=dict(type="str", required=False, aliases=["id"]), display_name=dict(type="str", required=False, aliases=["name"]), size_in_gbs=dict(type="int", required=False, default=50), state=dict( type="str", required=False, default="present", choices=["absent", "present"], ), source_details=dict(type="dict", required=False), lookup_all_attached_instances=dict(type="bool", required=False, default="no"), )) module = AnsibleModule( argument_spec=module_args, supports_check_mode=False, required_together=[["availability_domain", "compartment_id"]], required_if=[["state", "absent", ["volume_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) state = module.params["state"] volume_id = module.params["volume_id"] if state == "absent": result = handle_delete_volume(block_storage_client, module) else: if volume_id is None: # Exclude size_in_mbs as it is deprecated but still in the CreateVolumeDetails. # Though the documentation # (https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/api/index.html#id194) says # volumes are by default 1 TB but volumes get created with 50 GB size. exclude_attributes = {"size_in_mbs": True, "display_name": True} default_attribute_values = { "source_details": None, "size_in_gbs": 50 } # If a user expects volume to be created from a volume backup or from an another volume using option # `source_details` and doesn't specify the option `size_in_gbs`, the default for `size_in_gbs` option should # be set to None and this option should be excluded while matching with existing volumes. if module.params["source_details"]: if not oci_utils.has_user_provided_value_for_option( module, "size_in_gbs"): module.params["size_in_gbs"] = None exclude_attributes["size_in_gbs"] = True result = oci_utils.check_and_create_resource( resource_type="volume", create_fn=handle_create_volume, kwargs_create={ "block_storage_client": block_storage_client, "module": module, }, list_fn=block_storage_client.list_volumes, kwargs_list={ "compartment_id": module.params["compartment_id"] }, module=module, model=CreateVolumeDetails(), exclude_attributes=exclude_attributes, default_attribute_values=default_attribute_values, ) else: result = handle_update_volume(block_storage_client, module) add_attached_instance_info(module, result, module.params["lookup_all_attached_instances"]) module.exit_json(**result)
def main(): logger = oci_utils.get_logger("oci_preauthenticated_request") set_logger(logger) module_args = oci_utils.get_common_arg_spec(supports_create=True, supports_wait=True) module_args.update( dict( namespace_name=dict(type="str", required=True), bucket_name=dict(type="str", required=True), par_id=dict(type="str", required=False, aliases=["id"]), name=dict(type="str", required=False, aliases=["display_name"]), object_name=dict(type="str", required=False), time_expires=dict(type="str", required=False), access_type=dict( type="str", required=False, choices=[ "ObjectRead", "ObjectWrite", "ObjectReadWrite", "AnyObjectWrite", ], ), state=dict( type="str", required=False, default="present", choices=["present", "absent"], ), )) module = AnsibleModule(argument_spec=module_args) if not HAS_OCI_PY_SDK: module.fail_json(msg="oci python sdk required for this module") object_storage_client = oci_utils.create_service_client( module, ObjectStorageClient) state = module.params["state"] if state == "present": try: result = oci_utils.check_and_create_resource( resource_type="preauthenticated_request", create_fn=create_preauthenticated_request, kwargs_create={ "object_storage_client": object_storage_client, "module": module, }, list_fn=object_storage_client.list_preauthenticated_requests, kwargs_list={ "namespace_name": module.params.get("namespace_name"), "bucket_name": module.params.get("bucket_name"), }, module=module, model=CreatePreauthenticatedRequestDetails(), ) except ServiceError as ex: get_logger().error( "Unable to create Preauthenticated Request due to: %s", ex.message) module.fail_json(msg=ex.message) except ClientError as ex: get_logger().error( "Unable to create Preauthenticated Request due to: %s", str(ex)) module.fail_json(msg=str(ex)) elif state == "absent": result = delete_preauthenticated_request(object_storage_client, module) module.exit_json(**result)
def main(): module_args = oci_utils.get_taggable_arg_spec(supports_create=True, supports_wait=True) module_args.update( dict( availability_domain=dict(type="str", required=False), compartment_id=dict(type="str", required=False), volume_group_id=dict(type="str", required=False, aliases=["id"]), display_name=dict(type="str", required=False, aliases=["name"]), state=dict( type="str", required=False, default="present", choices=["absent", "present"], ), volume_ids=dict(type="list", required=False), source_details=dict(type="dict", required=False), )) module = AnsibleModule( argument_spec=module_args, supports_check_mode=False, required_if=[["state", "absent", ["volume_group_id"]]], mutually_exclusive=[["volume_ids", "source_details"]], ) 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) state = module.params["state"] volume_group_id = module.params["volume_group_id"] if state == "absent": result = handle_delete_volume_group(block_storage_client, module) else: if volume_group_id is None: result = oci_utils.check_and_create_resource( resource_type="volume_group", create_fn=handle_create_volume_group, kwargs_create={ "block_storage_client": block_storage_client, "module": module, }, list_fn=block_storage_client.list_volume_groups, kwargs_list={ "compartment_id": module.params["compartment_id"], "availability_domain": module.params["availability_domain"], }, module=module, model=CreateVolumeGroupDetails(), ) else: result = handle_update_volume_group(block_storage_client, module) module.exit_json(**result)
def main(): module_args = oci_utils.get_common_arg_spec(supports_create=True, supports_wait=True) module_args.update( dict( compartment_id=dict(type="str", required=False), display_name=dict(type="str", required=False, aliases=["name"]), state=dict( type="str", required=False, default="present", choices=["absent", "present"], ), remote_peering_connection_id=dict(type="str", required=False, aliases=["id"]), peer_region_name=dict(type="str", required=False), peer_id=dict(type="str", required=False), drg_id=dict(type="str", required=False), )) module = AnsibleModule( argument_spec=module_args, supports_check_mode=False, required_if=[("state", "absent", ["remote_peering_connection_id"])], required_together=[["peer_id", "peer_region_name"]], ) 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) exclude_attributes = {"display_name": True} state = module.params["state"] if state == "absent": result = delete_remote_peering_connection(virtual_network_client, module) else: remote_peering_connection_id = module.params[ "remote_peering_connection_id"] if remote_peering_connection_id is not None: result = update_remote_peering_connection(virtual_network_client, module) # A RPC can be connected to another RPC. Perform this operation when peer_id is specified along with # remote_peering_connection_id. if module.params["peer_id"] is not None: result_of_connect_rpc = connect_rpc(virtual_network_client, module) result["changed"] = (result["changed"] or result_of_connect_rpc["changed"]) result["remote_peering_connection"] = result_of_connect_rpc[ "remote_peering_connection"] else: result = oci_utils.check_and_create_resource( resource_type="remote_peering_connection", create_fn=create_remote_peering_connection, kwargs_create={ "virtual_network_client": virtual_network_client, "module": module, }, list_fn=virtual_network_client.list_remote_peering_connections, kwargs_list={ "compartment_id": module.params["compartment_id"], "drg_id": module.params["drg_id"], }, module=module, model=CreateRemotePeeringConnectionDetails(), exclude_attributes=exclude_attributes, ) module.exit_json(**result)
def main(): my_logger = oci_utils.get_logger("oci_instance") set_logger(my_logger) module_args = oci_utils.get_taggable_arg_spec(supports_create=True, supports_wait=True) module_args.update( dict( compartment_id=dict(type="str", required=False), name=dict(type="str", required=False, aliases=["display_name"]), image_id=dict(type="str", required=False, aliases=["id"]), instance_id=dict(type="str", required=False), image_source_details=dict(type="dict", required=False), state=dict( type="str", required=False, default="present", choices=["present", "absent"], ), )) module = AnsibleModule( argument_spec=module_args, supports_check_mode=False, mutually_exclusive=["instance_id", "image_source_details"], required_if=[("state", "absent", ["image_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) state = module.params["state"] result = dict(changed=False) id = module.params.get("image_id", None) exclude_attributes = {"display_name": True, "launch_mode": True} debug("Id is " + str(id)) if id is not None: image_resp = _get_image_from_id(compute_client, id, module) if state == "absent": debug("Delete " + id + " requested") if image_resp.data is not None: debug("Deleting " + image_resp.data.id) result = delete_image(compute_client, id, module) else: debug("Image " + id + " already deleted.") elif state == "present": display_name = module.params["name"] current_image = image_resp.data attrs_equal = oci_utils.are_attrs_equal( current_image, module, ["display_name", "freeform_tags", "defined_tags"]) if not attrs_equal: result = update_image(compute_client, id, display_name, module) else: result = oci_utils.check_and_create_resource( resource_type="image", create_fn=create_image, kwargs_create={ "compute_client": compute_client, "module": module }, list_fn=compute_client.list_images, kwargs_list={"compartment_id": module.params["compartment_id"]}, module=module, model=CreateImageDetails(), exclude_attributes=exclude_attributes, ) module.exit_json(**result)
def main(): module_args = oci_utils.get_taggable_arg_spec( supports_wait=True, supports_create=True ) module_args.update( dict( boot_volume_id=dict(type="str", required=False, aliases=["id"]), display_name=dict(type="str", required=False, aliases=["name"]), state=dict( type="str", required=False, default="present", choices=["absent", "present"], ), lookup_attached_instance=dict(type="bool", required=False, default="no"), availability_domain=dict(type="str", required=False), backup_policy_id=dict(type="str", required=False), compartment_id=dict(type="str", required=False), kms_key_id=dict(type="str", required=False), size_in_gbs=dict(type="int", required=False), source_details=dict(type=dict, required=False), ) ) module = AnsibleModule( argument_spec=module_args, supports_check_mode=False, required_if=[["state", "absent", ["boot_volume_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) state = module.params["state"] if state == "absent": result = handle_delete_boot_volume(block_storage_client, module) else: if module.params["boot_volume_id"]: result = handle_update_boot_volume(block_storage_client, module) else: default_attribute_values = {"size_in_gbs": 47} result = oci_utils.check_and_create_resource( resource_type="boot_volume", create_fn=handle_create_boot_volume, kwargs_create={ "block_storage_client": block_storage_client, "module": module, }, list_fn=block_storage_client.list_boot_volumes, kwargs_list={ "compartment_id": module.params["compartment_id"], "availability_domain": module.params["availability_domain"], }, module=module, model=CreateBootVolumeDetails(), default_attribute_values=default_attribute_values, ) add_attached_instance_info( module, result, module.params["lookup_attached_instance"] ) module.exit_json(**result)
def main(): module_args = oci_utils.get_taggable_arg_spec(supports_create=True, supports_wait=True) module_args.update( dict( instance_id=dict(type="str", required=False), public_key=dict(type="str", required=False), instance_console_connection_id=dict(type="str", required=False, aliases=["id"]), state=dict( type="str", required=False, default="present", choices=["absent", "present"], ), )) module = AnsibleModule( argument_spec=module_args, supports_check_mode=False, mutually_exclusive=[("instance_console_connection_id", "instance_id")], required_if=[ ("state", "absent", ["instance_console_connection_id"]), ("state", "present", ["instance_id", "public_key"]), ], ) 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) state = module.params["state"] if state == "absent": result = delete_instance_console_connection(compute_client, module) else: # Replace value of `public_key` key by content of file pointed to by the `public_key` param module.params["public_key"] = get_file_content( module.params["public_key"]) instance_id = module.params["instance_id"] kwargs_list = { "instance_id": instance_id, "compartment_id": _get_compartment_of_instance(compute_client, instance_id), } result = oci_utils.check_and_create_resource( resource_type="instance_console_connection", create_fn=create_instance_console_connection, kwargs_create={ "compute_client": compute_client, "module": module }, list_fn=compute_client.list_instance_console_connections, kwargs_list=kwargs_list, module=module, model=CreateInstanceConsoleConnectionDetails(), exclude_attributes=None, ) module.exit_json(**result)
def main(): module_args = oci_utils.get_taggable_arg_spec(supports_wait=True, supports_create=True) module_args.update( dict(boot_volume_id=dict(type='str', required=False, aliases=['id']), display_name=dict(type='str', required=False, aliases=['name']), state=dict(type='str', required=False, default='present', choices=['absent', 'present']), lookup_attached_instance=dict(type='bool', required=False, default='no'), availability_domain=dict(type='str', required=False), backup_policy_id=dict(type='str', required=False), compartment_id=dict(type='str', required=False), kms_key_id=dict(type='str', required=False), size_in_gbs=dict(type='int', required=False), source_details=dict(type=dict, required=False))) module = AnsibleModule( argument_spec=module_args, supports_check_mode=False, required_if=[['state', 'absent', ['boot_volume_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) state = module.params['state'] if state == 'absent': result = handle_delete_boot_volume(block_storage_client, module) else: if module.params["boot_volume_id"]: result = handle_update_boot_volume(block_storage_client, module) else: default_attribute_values = {"size_in_gbs": 47} result = oci_utils.check_and_create_resource( resource_type='boot_volume', create_fn=handle_create_boot_volume, kwargs_create={ 'block_storage_client': block_storage_client, 'module': module }, list_fn=block_storage_client.list_boot_volumes, kwargs_list={ 'compartment_id': module.params['compartment_id'], 'availability_domain': module.params['availability_domain'] }, module=module, model=CreateBootVolumeDetails(), default_attribute_values=default_attribute_values) add_attached_instance_info(module, result, module.params['lookup_attached_instance']) module.exit_json(**result)
def main(): module_args = oci_utils.get_common_arg_spec(supports_create=True, supports_wait=True) module_args.update( dict( compartment_id=dict(type="str", required=False), node_pool_id=dict(type="str", required=False, aliases=["id"]), cluster_id=dict(type="str", required=False), kubernetes_version=dict(type="str", required=False), name=dict(type="str", required=False), initial_node_labels=dict(type=list, required=False), subnet_ids=dict(type=list, required=False), node_config_details=dict( type="dict", options=dict( size=dict(type="int"), placement_configs=dict( type="list", elements="dict", options=dict( availability_domain=dict(type="str", required=True), subnet_id=dict(type="str", required=True), ), ), ), required=False, ), state=dict( type="str", required=False, default="present", choices=["absent", "present"], ), node_image_name=dict(type="str", required=False), node_shape=dict(type="str", required=False), quantity_per_subnet=dict(type="int", required=False), ssh_public_key=dict(type="str", required=False), count_of_nodes_to_wait=dict(type=int, required=False, default=1), wait_until=dict(type="str", required=False, default="ACTIVE"), )) module = AnsibleModule( argument_spec=module_args, supports_check_mode=False, required_if=[("state", "absent", ["node_pool_id"])], ) 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) state = module.params["state"] node_pool_id = module.params["node_pool_id"] if state == "absent": result = delete_node_pool(container_engine_client, module) else: if node_pool_id is not None: result = update_node_pool(container_engine_client, module) else: kwargs_list = {"compartment_id": module.params["compartment_id"]} exclude_attributes = {"name": True} result = oci_utils.check_and_create_resource( resource_type="node_pool", create_fn=create_node_pool, kwargs_create={ "container_engine_client": container_engine_client, "module": module, }, list_fn=container_engine_client.list_node_pools, kwargs_list=kwargs_list, module=module, model=CreateNodePoolDetails(), exclude_attributes=exclude_attributes, ) module.exit_json(**result)
def main(): module_args = oci_utils.get_taggable_arg_spec(supports_create=True, supports_wait=True) module_args.update( dict(block_traffic=dict(type='bool', required=False, default=False), service_id=dict(type='str', required=False), vcn_id=dict(type='str', required=False), services=dict(type='list', required=False), compartment_id=dict(type='str', required=False), display_name=dict(type='str', required=False, aliases=['name']), state=dict(type='str', required=False, default='present', choices=['absent', 'present']), service_gateway_id=dict(type='str', required=False, aliases=['id']))) module = AnsibleModule(argument_spec=module_args, supports_check_mode=False, required_if=[('state', 'absent', ['service_gateway_id'])], mutually_exclusive=[['service_id', 'services']]) 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) exclude_attributes = {'display_name': True} state = module.params['state'] if state == 'absent': if module.params['service_id']: # Detach service from service gateway. result = handle_service_id_request(virtual_network_client, module, False) else: # Delete service gateway. result = delete_service_gateway(virtual_network_client, module) else: service_gateway_id = module.params['service_gateway_id'] if service_gateway_id is not None: # Update service gateway details. result = update_service_gateway(virtual_network_client, module) if module.params['service_id']: # Attach/detach service to service gateway. serviceid_request_result = handle_service_id_request( virtual_network_client, module, True) result['changed'] = serviceid_request_result[ 'changed'] or result['changed'] result['service_gateway'] = serviceid_request_result[ 'service_gateway'] else: # Create service gateway. result = oci_utils.check_and_create_resource( resource_type='service_gateway', create_fn=create_service_gateway, kwargs_create={ 'virtual_network_client': virtual_network_client, 'module': module }, list_fn=virtual_network_client.list_service_gateways, kwargs_list={ 'compartment_id': module.params['compartment_id'], 'vcn_id': module.params['vcn_id'] }, module=module, model=CreateServiceGatewayDetails(), exclude_attributes=exclude_attributes) module.exit_json(**result)
def main(): logger = oci_utils.get_logger("oci_db_system") set_logger(logger) module_args = oci_utils.get_taggable_arg_spec( supports_create=True, supports_wait=True ) module_args.update( dict( compartment_id=dict(type="str", required=False), db_system_id=dict(type="str", required=False, aliases=["id"]), availability_domain=dict(type="str", required=False), backup_subnet_id=dict(type="str", required=False), cluster_name=dict(type="str", required=False), cpu_core_count=dict(type=int, required=False), data_storage_percentage=dict(type=int, required=False), database_edition=dict( type="str", required=False, choices=[ "STANDARD_EDITION", "ENTERPRISE_EDITION", "ENTERPRISE_EDITION_EXTREME_PERFORMANCE", "ENTERPRISE_EDITION_HIGH_PERFORMANCE", ], ), state=dict( type="str", required=False, default="present", choices=["present", "absent"], ), db_home=dict(type=dict, required=False), disk_redundancy=dict( type="str", required=False, choices=["HIGH", "NORMAL"] ), display_name=dict(type="str", required=False), domain=dict(type="str", required=False), hostname=dict(type="str", required=False), initial_data_storage_size_in_gb=dict(type=int, required=False), data_storage_size_in_gbs=dict(type=int, required=False), license_model=dict( type="str", required=False, choices=["LICENSE_INCLUDED", "BRING_YOUR_OWN_LICENSE"], ), node_count=dict(type=int, required=False), shape=dict(type="str", required=False), ssh_public_keys=dict(type=list, required=False), subnet_id=dict(type="str", required=False), purge_ssh_public_keys=dict( type=bool, required=False, default=True, choices=[True, False] ), delete_ssh_public_keys=dict( type=bool, required=False, default=False, choices=[True, False] ), version=dict(type=dict, required=False), source=dict( type="str", required=False, default="NONE", choices=["DB_BACKUP", "NONE"], ), ) ) module = AnsibleModule( argument_spec=module_args, mutually_exclusive=[["purge_ssh_public_keys", "delete_ssh_public_keys"]], ) if not HAS_OCI_PY_SDK: module.fail_json(msg="oci python sdk required for this module") db_client = oci_utils.create_service_client(module, DatabaseClient) if os.environ.get("OCI_DB_MOCK") is not None: db_client.base_client.session.headers.update( {"opc-host-serial": "FakeHostSerial"} ) state = module.params["state"] if state == "present": result = launch_or_update_db_system(db_client, module) elif state == "absent": result = delete_db_system(db_client, module) module.exit_json(**result)
def main(): set_logger(oci_utils.get_logger("oci_customer_secret_key")) module_args = oci_utils.get_common_arg_spec(supports_create=True) module_args.update( dict(user_id=dict(type='str', required=True), customer_secret_key_id=dict(type='str', required=False, aliases=['id']), name=dict(type='str', required=False, aliases=['display_name']), state=dict(type='str', required=False, default='present', choices=['present', 'absent']))) module = AnsibleModule( argument_spec=module_args, supports_check_mode=False, required_if=[('state', 'absent', ['customer_secret_key_id'])], ) if not HAS_OCI_PY_SDK: module.fail_json(msg='oci python sdk required for this module.') identity_client = oci_utils.create_service_client(module, IdentityClient) state = module.params['state'] result = dict(changed=False) user_id = module.params.get("user_id", None) secret_key_id = module.params.get("customer_secret_key_id", None) name = module.params.get('name', None) get_logger().debug("Id is " + str(secret_key_id)) if secret_key_id is not None: secret_key = _get_customer_secret_key_from_id(identity_client, user_id, secret_key_id, module) if state == 'absent': get_logger().debug( "Delete Customer Secret Key %s for user %s requested", secret_key_id, user_id) if secret_key is not None: get_logger().debug("Deleting %s", secret_key.id) result = delete_customer_secret_key(identity_client, user_id, secret_key_id, module) else: get_logger().debug("Customer secret key %s already deleted.", secret_key_id) elif state == 'present': if secret_key.display_name != name: result = update_customer_secret_key(identity_client, user_id, secret_key_id, name, module) else: # No change needed, return existing customer secret key details result[RESOURCE_NAME] = to_dict(secret_key) else: result = oci_utils.check_and_create_resource( resource_type=RESOURCE_NAME, create_fn=create_customer_secret_key, kwargs_create={ "identity_client": identity_client, "user_id": user_id, "display_name": name, "module": module }, list_fn=identity_client.list_customer_secret_keys, kwargs_list={"user_id": user_id}, module=module, model=CreateCustomerSecretKeyDetails()) module.exit_json(**result)
def main(): module_args = oci_utils.get_taggable_arg_spec( supports_create=True, supports_wait=True ) module_args.update( dict( instance_id=dict(type="str", required=False), name=dict(type="str", required=False, aliases=["display_name"]), instance_console_history_id=dict( type="str", required=False, aliases=["id"] ), state=dict( type="str", required=False, default="present", choices=["absent", "present"], ), ) ) module = AnsibleModule( argument_spec=module_args, supports_check_mode=False, mutually_exclusive=["console_history_id", "instance_id"], required_if=[("state", "absent", ["instance_console_history_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) state = module.params["state"] if state == "absent": result = delete_console_history(compute_client, module) else: console_history_id = module.params["instance_console_history_id"] if console_history_id is not None: # Update service gateway details. result = update_console_history(compute_client, module) else: instance_id = module.params["instance_id"] kwargs_list = { "instance_id": instance_id, "compartment_id": _get_compartment_of_instance( compute_client, instance_id ), } result = oci_utils.check_and_create_resource( resource_type="console_history", create_fn=capture_console_history, kwargs_create={"compute_client": compute_client, "module": module}, list_fn=compute_client.list_console_histories, kwargs_list=kwargs_list, module=module, model=CaptureConsoleHistoryDetails(), ) module.exit_json(**result)
def main(): logger = oci_utils.get_logger("oci_idp_group_mapping") set_logger(logger) module_args = oci_utils.get_common_arg_spec() module_args.update( dict( mapping_id=dict(type="str", required=False, aliases=["id"]), identity_provider_id=dict(type="str", required=True), idp_group_name=dict(type="str", required=False), group_id=dict(type="str", required=False), state=dict( type="str", required=False, default="present", choices=["present", "absent"], ), )) 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.") identity_client = oci_utils.create_service_client(module, IdentityClient) state = module.params["state"] idp_group_mapping_id = module.params.get("mapping_id") if state == "present": try: if idp_group_mapping_id: operation_display_text = "update" result = update_idp_group_mapping(identity_client, module) else: operation_display_text = "create" result = oci_utils.check_and_create_resource( resource_type="idp_group_mapping", create_fn=create_idp_group_mapping, kwargs_create={ "identity_client": identity_client, "module": module, }, list_fn=identity_client.list_idp_group_mappings, kwargs_list={ "identity_provider_id": module.params.get("identity_provider_id") }, module=module, model=CreateIdpGroupMappingDetails(), ) except ServiceError as ex: get_logger().error( "Unable to %s IdpGroupMapping due to: %s", operation_display_text, ex.message, ) module.fail_json(msg=ex.message) except ClientError as ex: get_logger().error( "Unable to %s IdpGroupMapping due to: %s", operation_display_text, str(ex), ) module.fail_json(msg=str(ex)) elif state == "absent": result = delete_idp_group_mapping(identity_client, module) module.exit_json(**result)
def main(): module_args = oci_utils.get_facts_module_arg_spec() module_args.update( dict( availability_domain=dict(type="str", required=False), compartment_id=dict(type="str", required=False), boot_volume_id=dict(type="str", required=False, aliases=["id"]), lookup_attached_instance=dict(type="bool", required=False, default="no"), volume_group_id=dict(type="str", required=False), )) module = AnsibleModule( argument_spec=module_args, supports_check_mode=False, mutually_exclusive=[["availability_domain", "boot_volume_id"]], required_one_of=[ ["compartment_id", "boot_volume_id"], ["availability_domain", "boot_volume_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) boot_volume_id = module.params["boot_volume_id"] try: if boot_volume_id is not None: result = [ to_dict( oci_utils.call_with_backoff( block_storage_client.get_boot_volume, boot_volume_id=boot_volume_id, ).data) ] else: availability_domain = module.params["availability_domain"] compartment_id = module.params["compartment_id"] optional_list_method_params = ["display_name", "volume_group_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_boot_volumes, compartment_id=compartment_id, availability_domain=availability_domain, **optional_kwargs)) except ServiceError as ex: module.fail_json(msg=ex.message) add_attached_instance_info(module, result, module.params["lookup_attached_instance"]) module.exit_json(boot_volumes=result)
def main(): my_logger = oci_utils.get_logger("oci_local_peering_gateway") set_logger(my_logger) module_args = oci_utils.get_taggable_arg_spec(supports_create=True, supports_wait=True) module_args.update( dict( compartment_id=dict(type="str", required=False), display_name=dict(type="str", required=False, aliases=["name"]), state=dict( type="str", required=False, default="present", choices=["absent", "present"], ), local_peering_gateway_id=dict(type="str", required=False, aliases=["id"]), peer_id=dict(type="str", required=False), vcn_id=dict(type="str", required=False), route_table_id=dict(type="str", required=False), skip_exhaustive_search_for_lpg_peerings=dict(type=bool, required=False, default=False), )) module = AnsibleModule( argument_spec=module_args, supports_check_mode=False, required_if=[ ("state", "absent", ["local_peering_gateway_id"]), ("peer_id", not None, ["local_peering_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) exclude_attributes = {"display_name": True} state = module.params["state"] if state == "absent": result = delete_local_peering_gateway(virtual_network_client, module) else: local_peering_gateway_id = module.params["local_peering_gateway_id"] if local_peering_gateway_id is not None: result = update_local_peering_gateway(virtual_network_client, module) # A LPG can be connected to another LPG. Perform this operation when peer_id is specified along with # local_peering_gateway_id. if module.params["peer_id"] is not None: result_of_connect_lpg = connect_lpg(virtual_network_client, module) result["changed"] = (result["changed"] or result_of_connect_lpg["changed"]) result["local_peering_gateway"] = result_of_connect_lpg[ "local_peering_gateway"] else: result = oci_utils.check_and_create_resource( resource_type="local_peering_gateway", create_fn=create_local_peering_gateway, kwargs_create={ "virtual_network_client": virtual_network_client, "module": module, }, list_fn=virtual_network_client.list_local_peering_gateways, kwargs_list={ "compartment_id": module.params["compartment_id"], "vcn_id": module.params["vcn_id"], }, module=module, model=CreateLocalPeeringGatewayDetails(), exclude_attributes=exclude_attributes, default_attribute_values={"route_table_id": None}, ) module.exit_json(**result)
def main(): logger = oci_utils.get_logger("oci_instance_facts") set_logger(logger) 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, choices=[ "PROVISIONING", "RUNNING", "STARTING", "STOPPING", "STOPPED", "CREATING_IMAGE", "TERMINATING", "TERMINATED", ], ), )) 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) network_client = oci_utils.create_service_client(module, VirtualNetworkClient) compartment_id = module.params["compartment_id"] id = module.params["instance_id"] result = dict(changed=False) if compartment_id: result = list_instances(compute_client, network_client, module) add_primary_ips(compute_client, network_client, result, 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) add_primary_ips(compute_client, network_client, result, module) except ServiceError as ex: module.fail_json(msg=ex.message) module.exit_json(instances=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), lifecycle_state=dict( type="str", required=False, choices=[ "PROVISIONING", "AVAILABLE", "TERMINATING", "TERMINATED" ], ), )) 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: 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_subnets, compartment_id=compartment_id, vcn_id=vcn_id, **optional_kwargs)) 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 main(): module_args = oci_utils.get_taggable_arg_spec(supports_create=True, supports_wait=True) module_args.update( dict( cidr_block=dict(type="str", required=False), compartment_id=dict(type="str", required=False), display_name=dict(type="str", required=False, aliases=["name"]), dns_label=dict(type="str", required=False), state=dict( type="str", required=False, default="present", choices=["absent", "present"], ), vcn_id=dict(type="str", required=False, aliases=["id"]), )) module = AnsibleModule( argument_spec=module_args, supports_check_mode=False, mutually_exclusive=[["compartment_id", "vcn_id"]], ) if not HAS_OCI_PY_SDK: module.fail_json(msg=missing_required_lib("oci")) virtual_network_client = oci_utils.create_service_client( module, VirtualNetworkClient) exclude_attributes = {"display_name": True, "dns_label": True} state = module.params["state"] vcn_id = module.params["vcn_id"] if state == "absent": if vcn_id is not None: result = delete_vcn(virtual_network_client, module) else: module.fail_json( msg="Specify vcn_id with state as 'absent' to delete a VCN.") else: if vcn_id is not None: result = update_vcn(virtual_network_client, module) else: result = oci_utils.check_and_create_resource( resource_type="vcn", create_fn=create_vcn, kwargs_create={ "virtual_network_client": virtual_network_client, "module": module, }, list_fn=virtual_network_client.list_vcns, kwargs_list={ "compartment_id": module.params["compartment_id"] }, module=module, model=CreateVcnDetails(), exclude_attributes=exclude_attributes, ) module.exit_json(**result)
def main(): module_args = oci_utils.get_facts_module_arg_spec() module_args.update( dict( availability_domain=dict(type="str", required=False), compartment_id=dict(type="str", required=False), volume_id=dict(type="str", required=False, aliases=["id"]), lookup_all_attached_instances=dict(type="bool", required=False, default="no"), lifecycle_state=dict( type="str", required=False, choices=[ "PROVISIONING", "RESTORING", "AVAILABLE", "TERMINATING", "TERMINATED", "FAULTY", ], ), volume_group_id=dict(type="str", required=False), )) module = AnsibleModule( argument_spec=module_args, supports_check_mode=False, mutually_exclusive=[["compartment_id", "volume_id"]], required_one_of=[["compartment_id", "volume_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_id = module.params["volume_id"] try: if volume_id is not None: result = [ to_dict( oci_utils.call_with_backoff( block_storage_client.get_volume, volume_id=volume_id).data) ] else: compartment_id = module.params["compartment_id"] availability_domain = module.params["availability_domain"] if availability_domain is not None: result = to_dict( oci_utils.list_all_resources( block_storage_client.list_volumes, compartment_id=compartment_id, availability_domain=availability_domain, display_name=module.params["display_name"], )) else: optional_list_method_params = [ "display_name", "lifecycle_state", "volume_group_id", ] optional_kwargs = dict((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_volumes, compartment_id=compartment_id, **optional_kwargs)) except ServiceError as ex: module.fail_json(msg=ex.message) add_attached_instance_info(module, result, module.params["lookup_all_attached_instances"]) module.exit_json(volumes=result)
def main(): module_args = oci_utils.get_common_arg_spec() module_args.update( dict(namespace_name=dict(type='str', required=True, aliases=['namespace']), bucket_name=dict(type='str', required=True, aliases=['bucket']), object_name=dict(type='str', required=False, aliases=['name', 'object']), prefix=dict(type='str', required=False), start=dict(type='str', required=False), end=dict(type='str', required=False), delimiter=dict(type='str', required=False, choices=['/']), fields=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') object_storage_client = oci_utils.create_service_client( module, ObjectStorageClient) namespace = module.params['namespace_name'] bucket = module.params['bucket_name'] object_name = module.params['object_name'] fields_to_retrieve = ",".join(['name', 'size', 'timeCreated', 'md5']) try: if object_name is not None: result = to_dict( oci_utils.list_all_resources( object_storage_client.list_objects, namespace_name=namespace, bucket_name=bucket, prefix=object_name, fields=fields_to_retrieve).objects) else: optional_list_method_params = [ 'prefix', 'start', 'end', 'delimiter', 'fields' ] optional_kwargs = { param: module.params[param] for param in optional_list_method_params if module.params.get(param) is not None } # if the user hasn't specified a preference for fields, use the default "fields_to_retrieve" if optional_kwargs.get('fields') is None: optional_kwargs['fields'] = fields_to_retrieve result = to_dict( oci_utils.list_all_resources( object_storage_client.list_objects, namespace_name=namespace, bucket_name=bucket, **optional_kwargs).objects) except ServiceError as ex: module.fail_json(msg=ex.message) module.exit_json(objects=result)
def main(): module_args = oci_utils.get_facts_module_arg_spec() module_args.update( dict( public_ip_id=dict(type="str", required=False, aliases=["id"]), private_ip_id=dict(type="str", required=False), ip_address=dict(type="str", required=False), scope=dict(type="str", required=False, choices=["REGION", "AVAILABILITY_DOMAIN"]), compartment_id=dict(type="str", required=False), availability_domain=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) public_ip_id = module.params["public_ip_id"] try: if public_ip_id is not None: result = [ to_dict( oci_utils.call_with_backoff( virtual_network_client.get_public_ip, public_ip_id=public_ip_id).data) ] elif module.params["private_ip_id"] is not None: pvt_ip_id_details = GetPublicIpByPrivateIpIdDetails( private_ip_id=module.params["private_ip_id"]) result = [ to_dict( oci_utils.call_with_backoff( virtual_network_client.get_public_ip_by_private_ip_id, get_public_ip_by_private_ip_id_details= pvt_ip_id_details, ).data) ] elif module.params["ip_address"] is not None: ip_address_details = GetPublicIpByIpAddressDetails( ip_address=module.params["ip_address"]) result = [ to_dict( oci_utils.call_with_backoff( virtual_network_client.get_public_ip_by_ip_address, get_public_ip_by_ip_address_details=ip_address_details, ).data) ] elif module.params["scope"] is not None: list_args = { "scope": module.params["scope"], "compartment_id": module.params["compartment_id"], "display_name": module.params["display_name"], } if module.params["availability_domain"] is not None: list_args["availability_domain"] = module.params[ "availability_domain"] result = to_dict( oci_utils.list_all_resources( virtual_network_client.list_public_ips, **list_args)) else: module.fail_json( msg= "Specify scope along with compartment_id to list all public IPs or one of" "public_ip_id/private_ip_id/ip_address.") except ServiceError as ex: module.fail_json(msg=ex.message) module.exit_json(public_ips=result)
def main(): module_args = oci_utils.get_taggable_arg_spec(supports_create=True, supports_wait=True) module_args.update(dict( availability_domain=dict(type='str', required=False), backup_policy_id=dict(type='str', required=False), compartment_id=dict(type='str', required=False), volume_id=dict(type='str', required=False, aliases=['id']), display_name=dict(type='str', required=False, aliases=['name']), size_in_gbs=dict(type='int', required=False, default=50), state=dict(type='str', required=False, default='present', choices=['absent', 'present']), source_details=dict(type='dict', required=False), lookup_all_attached_instances=dict(type='bool', required=False, default='no') )) module = AnsibleModule( argument_spec=module_args, supports_check_mode=False, required_together=[ ['availability_domain', 'compartment_id'] ], required_if=[ ['state', 'absent', ['volume_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) state = module.params['state'] volume_id = module.params['volume_id'] if state == 'absent': result = handle_delete_volume(block_storage_client, module) else: if volume_id is None: # Exclude size_in_mbs as it is deprecated but still in the CreateVolumeDetails. # Though the documentation # (https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/api/index.html#id194) says # volumes are by default 1 TB but volumes get created with 50 GB size. exclude_attributes = {"size_in_mbs": True, "display_name": True} default_attribute_values = {"source_details": None, "size_in_gbs": 50} result = oci_utils.check_and_create_resource(resource_type='volume', create_fn=handle_create_volume, kwargs_create={'block_storage_client': block_storage_client, 'module': module}, list_fn=block_storage_client.list_volumes, kwargs_list={'compartment_id': module.params['compartment_id'] }, module=module, model=CreateVolumeDetails(), exclude_attributes=exclude_attributes, default_attribute_values=default_attribute_values) else: result = handle_update_volume(block_storage_client, module) add_attached_instance_info(module, result, module.params['lookup_all_attached_instances']) module.exit_json(**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_type=dict( type="str", required=False, choices=["PRIMARY", "SECONDARY"] ), name_contains=dict(type="str", required=False), time_created_greater_than_or_equal_to=dict(type="str", required=False), time_created_less_than=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=[["zone_id", "compartment_id"]], ) 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) zone_id = module.params["zone_id"] compartment_id = module.params["compartment_id"] try: if zone_id is not None: result = [ to_dict( oci_utils.call_with_backoff( dns_client.get_zone, zone_name_or_id=get_zone_name_or_id(module) ).data ) ] elif compartment_id is not None: optional_list_method_params = [ "compartment_id", "name", "zone_type", "name_contains", "time_created_greater_than_or_equal_to", "time_created_less_than", "lifecycle_state", ] optional_kwargs = dict( (param, module.params[param]) for param in optional_list_method_params if module.params.get(param) is not None ) zone_summaries = to_dict( oci_utils.list_all_resources(dns_client.list_zones, **optional_kwargs) ) # Get Zone model from zone-summaries returned by `list_zones` result = to_dict( [ oci_utils.call_with_backoff( dns_client.get_zone, zone_name_or_id=z["id"] ).data for z in zone_summaries ] ) except ServiceError as ex: module.fail_json(msg=ex.message) module.exit_json(zones=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, choices=[ "CREATING", "AVAILABLE", "TERMINATING", "TERMINATED", "FAULTY", "REQUEST_RECEIVED", ], ), )) 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 = dict((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(): logger = oci_utils.get_logger("oci_data_guard_association") set_logger(logger) module_args = oci_utils.get_common_arg_spec(supports_create=True, supports_wait=True) module_args.update( dict( database_id=dict(type="str", required=True), data_guard_association_id=dict(type="str", required=False, aliases=["id"]), display_name=dict(type="str", required=False), hostname=dict(type="str", required=False), availability_domain=dict(type="str", required=False), subnet_id=dict(type="str", required=False), creation_type=dict( type="str", required=False, default="ExistingDbSystem", choices=["ExistingDbSystem", "NewDbSystem"], ), database_admin_password=dict(type="str", required=False, no_log=True), shape=dict(type="str", required=False), protection_mode=dict( type="str", required=False, choices=[ "MAXIMUM_AVAILABILITY", "MAXIMUM_PERFORMANCE", "MAXIMUM_PROTECTION", ], ), transport_type=dict(type="str", required=False, choices=["SYNC", "ASYNC", "FASTSYNC"]), peer_db_system_id=dict(type="str", required=False), state=dict( type="str", required=False, default="present", choices=["present", "switchover", "failover", "reinstate"], ), )) module = AnsibleModule(argument_spec=module_args) if not HAS_OCI_PY_SDK: module.fail_json(msg="oci python sdk required for this module") db_client = oci_utils.create_service_client(module, DatabaseClient) state = module.params["state"] if state == "present": result = oci_utils.check_and_create_resource( resource_type="data_guard_association", create_fn=create_data_guard_association, kwargs_create={ "db_client": db_client, "module": module }, list_fn=db_client.list_data_guard_associations, kwargs_list={"database_id": module.params["database_id"]}, module=module, model=get_creation_type_instance(module), ) else: result = perform_data_guard_operations(db_client, module) module.exit_json(**result)