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)
