def main():
logger = oci_utils.get_logger("oci_mount_target_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),
mount_target_id=dict(type="str", required=False, aliases=["id"]),
lifecycle_state=dict(
type="str",
required=False,
choices=[
"CREATING", "ACTIVE", "DELETING", "DELETED", "FAILED"
],
),
))
module = AnsibleModule(
argument_spec=module_args,
mutually_exclusive=[
["compartment_id", "mount_target_id"],
["availability_domain", "mount_target_id"],
],
)
if not HAS_OCI_PY_SDK:
module.fail_json(msg="oci python sdk required for this module")
file_storage_client = oci_utils.create_service_client(
module, FileStorageClient)
result = list_mount_targets(file_storage_client, module)
module.exit_json(**result)
def main():
module_args = oci_utils.get_facts_module_arg_spec()
module_args.update(
dict(
compartment_id=dict(type="str", required=False),
nat_gateway_id=dict(type="str", required=False, aliases=["id"]),
vcn_id=dict(type="str", required=False),
lifecycle_state=dict(
type="str",
required=False,
choices=["PROVISIONING", "AVAILABLE", "TERMINATING", "TERMINATED"],
),
)
)
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=False,
required_one_of=[["compartment_id", "nat_gateway_id"]],
)
if not HAS_OCI_PY_SDK:
module.fail_json(msg="oci python sdk required for this module.")
virtual_network_client = oci_utils.create_service_client(
module, VirtualNetworkClient
)
nat_gateway_id = module.params["nat_gateway_id"]
compartment_id = module.params["compartment_id"]
result = []
try:
if nat_gateway_id is not None:
result = [
to_dict(
oci_utils.call_with_backoff(
virtual_network_client.get_nat_gateway,
nat_gateway_id=nat_gateway_id,
).data
)
]
else:
optional_list_method_params = ["display_name", "lifecycle_state", "vcn_id"]
optional_kwargs = {
param: module.params[param]
for param in optional_list_method_params
if module.params.get(param) is not None
}
result = to_dict(
oci_utils.list_all_resources(
virtual_network_client.list_nat_gateways,
compartment_id=compartment_id,
**optional_kwargs
)
)
except ServiceError as ex:
module.fail_json(msg=ex.message)
module.exit_json(nat_gateways=result)
def main():
module_args = oci_utils.get_facts_module_arg_spec(filter_by_name=True)
module_args.update(
dict(dynamic_group_id=dict(type='str', required=False, aliases=['id']),
compartment_id=dict(type='str', required=False)))
module = AnsibleModule(argument_spec=module_args,
supports_check_mode=False)
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)
dynamic_group_id = module.params['dynamic_group_id']
try:
if dynamic_group_id is not None:
result = [
to_dict(
oci_utils.call_with_backoff(
identity_client.get_dynamic_group,
dynamic_group_id=dynamic_group_id).data)
]
else:
result = to_dict(
oci_utils.list_all_resources(
identity_client.list_dynamic_groups,
compartment_id=module.params['compartment_id'],
name=module.params['name']))
except ServiceError as ex:
module.fail_json(msg=ex.message)
module.exit_json(dynamic_groups=result)
def main():
module_args = oci_utils.get_facts_module_arg_spec()
module_args.update(
dict(
compartment_id=dict(type="str", required=False),
virtual_circuit_id=dict(type="str", required=False,
aliases=["id"]),
lifecycle_state=dict(
type="str",
required=False,
choices=[
"PENDING_PROVIDER",
"VERIFYING",
"PROVISIONING",
"PROVISIONED",
"FAILED",
"INACTIVE",
"TERMINATING",
"TERMINATED",
],
),
))
module = AnsibleModule(argument_spec=module_args,
mutually_exclusive=[["compartment_id", "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)
result = list_virtual_circuits(virtual_network_client, module)
module.exit_json(**result)
def main():
logger = oci_utils.get_logger("oci_load_balancer_facts")
set_logger(logger)
module_args = oci_utils.get_facts_module_arg_spec()
module_args.update(
dict(
compartment_id=dict(type="str", required=False),
load_balancer_id=dict(type="str", required=False, aliases=["id"]),
lifecycle_state=dict(
type="str",
required=False,
choices=[
"CREATING", "FAILED", "ACTIVE", "DELETING", "DELETED"
],
),
detail=dict(type=str, required=False, choices=["full", "simple"]),
))
module = AnsibleModule(
argument_spec=module_args,
mutually_exclusive=[["compartment_id", "load_balancer_id"]],
)
if not HAS_OCI_PY_SDK:
module.fail_json(msg="oci python sdk required for this module")
lb_client = oci_utils.create_service_client(module, LoadBalancerClient)
result = list_load_balancers(lb_client, module)
module.exit_json(**result)
def main():
module_args = oci_utils.get_facts_module_arg_spec(filter_by_name=True)
module_args.update(
dict(service_id=dict(type="str", required=False, aliases=["id"])))
module = AnsibleModule(argument_spec=module_args,
supports_check_mode=False)
if not HAS_OCI_PY_SDK:
module.fail_json(msg="oci python sdk required for this module.")
virtual_network_client = oci_utils.create_service_client(
module, VirtualNetworkClient)
try:
if module.params["service_id"]:
result = [
to_dict(
oci_utils.call_with_backoff(
virtual_network_client.get_service,
service_id=module.params["service_id"],
).data)
]
else:
result = to_dict(
oci_utils.list_all_resources(
virtual_network_client.list_services,
name=module.params["name"]))
except ServiceError as ex:
module.fail_json(msg=ex.message)
module.exit_json(services=result)
def main():
module_args = oci_utils.get_facts_module_arg_spec()
module_args.update(dict(
policy_id=dict(type='str', required=False, aliases=['id']),
))
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=False,
)
if not HAS_OCI_PY_SDK:
module.fail_json(msg='oci python sdk required for this module.')
block_storage_client = oci_utils.create_service_client(module, BlockstorageClient)
policy_id = module.params['policy_id']
try:
if policy_id:
result = [to_dict(oci_utils.call_with_backoff(block_storage_client.get_volume_backup_policy,
policy_id=policy_id).data)]
else:
optional_list_method_params = ['display_name']
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.call_with_backoff(block_storage_client.list_volume_backup_policies,
**optional_kwargs).data)
except ServiceError as ex:
module.fail_json(msg=ex.message)
module.exit_json(volume_backup_policies=result)
def main():
module_args = oci_utils.get_facts_module_arg_spec()
module_args.update(
dict(
listing_id=dict(type="str", required=False, aliases=["id"]),
publisher_name=dict(type="str", required=False),
publisher_type=dict(
type="str",
required=False,
choices=["OCI", "ORACLE", "TRUSTED", "STANDARD"],
),
)
)
module = AnsibleModule(argument_spec=module_args, supports_check_mode=False)
if not HAS_OCI_PY_SDK:
module.fail_json(msg="oci python sdk required for this module.")
compute_client = oci_utils.create_service_client(module, ComputeClient)
try:
listing_id = module.params["listing_id"]
if listing_id:
result = get_app_catalog_listing(compute_client, module)
else:
result = list_app_catalog_listings(compute_client, module)
except ServiceError as se:
module.fail_json(msg=se.message)
module.exit_json(app_catalog_listings=result)
def main():
module_args = oci_utils.get_facts_module_arg_spec()
module_args.update(
dict(
compartment_id=dict(type="str", required=False),
instance_id=dict(type="str", required=False),
volume_id=dict(type="str", required=False),
volume_attachment_id=dict(type="str", required=False, aliases=["id"]),
availability_domain=dict(type="str", required=False),
)
)
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=False,
required_one_of=[["compartment_id", "volume_attachment_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)
volume_attachment_id = module.params["volume_attachment_id"]
try:
if volume_attachment_id is not None:
result = [
to_dict(
oci_utils.call_with_backoff(
compute_client.get_volume_attachment,
volume_attachment_id=volume_attachment_id,
).data
)
]
else:
key_list = [
"compartment_id",
"instance_id",
"volume_id",
"display_name",
"availability_domain",
]
param_map = dict(
(k, v)
for (k, v) in six.iteritems(module.params)
if k in key_list and v is not None
)
result = to_dict(
oci_utils.list_all_resources(
compute_client.list_volume_attachments, **param_map
)
)
except ServiceError as ex:
module.fail_json(msg=ex.message)
module.exit_json(volume_attachments=result)
def main():
logger = oci_utils.get_logger("oci_autonomous_data_warehouse_facts")
set_logger(logger)
module_args = oci_utils.get_facts_module_arg_spec()
module_args.update(
dict(
compartment_id=dict(type="str", required=False),
autonomous_data_warehouse_id=dict(
type="str", required=False, aliases=["id"]
),
)
)
module = AnsibleModule(
argument_spec=module_args,
mutually_exclusive=[["compartment_id", "autonomous_data_warehouse_id"]],
)
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)
result = list_autonomous_data_warehouses(db_client, module)
module.exit_json(**result)
def main():
module_args = oci_utils.get_facts_module_arg_spec()
module_args.update(
dict(private_ip_id=dict(type='str', required=False, aliases=['id']),
subnet_id=dict(type='str', required=False)))
module = AnsibleModule(argument_spec=module_args,
supports_check_mode=False)
if not HAS_OCI_PY_SDK:
module.fail_json(msg='oci python sdk required for this module.')
virtual_network_client = oci_utils.create_service_client(
module, VirtualNetworkClient)
private_ip_id = module.params['private_ip_id']
try:
if private_ip_id is not None:
result = [
to_dict(
oci_utils.call_with_backoff(
virtual_network_client.get_private_ip,
private_ip_id=private_ip_id).data)
]
else:
result = to_dict(
oci_utils.list_all_resources(
virtual_network_client.list_private_ips,
subnet_id=module.params['subnet_id'],
display_name=module.params['display_name']))
except ServiceError as ex:
module.fail_json(msg=ex.message)
module.exit_json(private_ips=result)
def main():
module_args = oci_utils.get_facts_module_arg_spec(filter_by_name=True)
module_args.update(
dict(
compartment_id=dict(type="str", required=False),
policy_id=dict(type="str", required=False, aliases=["id"]),
))
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=False,
required_one_of=[["compartment_id", "policy_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)
policy_id = module.params["policy_id"]
try:
if policy_id is None:
result = to_dict(
oci_utils.list_all_resources(
identity_client.list_policies,
compartment_id=module.params["compartment_id"],
name=module.params["name"],
))
else:
result = [to_dict(identity_client.get_policy(policy_id).data)]
except ServiceError as ex:
module.fail_json(msg=ex.message)
module.exit_json(policies=result)
def main():
logger = oci_utils.get_logger("oci_autonomous_database_backup_facts")
set_logger(logger)
module_args = oci_utils.get_facts_module_arg_spec()
module_args.update(
dict(compartment_id=dict(type='str', required=False),
autonomous_database_id=dict(type='str', required=False),
autonomous_database_backup_id=dict(type='str',
required=False,
aliases=['id'])))
module = AnsibleModule(argument_spec=module_args,
mutually_exclusive=[[
'compartment_id',
'autonomous_database_backup_id'
]])
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)
result = list_autonomous_database_backups(db_client, module)
module.exit_json(**result)
def main():
logger = oci_utils.get_logger("oci_file_system_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),
file_system_id=dict(type='str', required=False, aliases=['id']),
lifecycle_state=dict(type='str', required=False, choices=[
'CREATING', 'ACTIVE', 'DELETING', 'DELETED', 'FAILED'])
))
module = AnsibleModule(
argument_spec=module_args,
mutually_exclusive=[
['compartment_id', 'file_system_id'],
['availability_domain', 'file_system_id']
]
)
if not HAS_OCI_PY_SDK:
module.fail_json(msg='oci python sdk required for this module')
file_storage_client = oci_utils.create_service_client(module, FileStorageClient)
result = list_file_systems(file_storage_client, module)
module.exit_json(**result)
def main():
module_args = oci_utils.get_facts_module_arg_spec(filter_by_name=True)
module_args.update(
dict(
cluster_id=dict(type="str", required=False, aliases=["id"]),
compartment_id=dict(type="str", required=False),
lifecycle_state=dict(
type="list",
required=False,
choices=[
"CREATING",
"ACTIVE",
"FAILED",
"DELETING",
"DELETED",
"UPDATING",
],
),
)
)
module = AnsibleModule(argument_spec=module_args, supports_check_mode=False)
if not HAS_OCI_PY_SDK:
module.fail_json(msg="oci python sdk required for this module.")
container_engine_client = oci_utils.create_service_client(
module, ContainerEngineClient
)
cluster_id = module.params["cluster_id"]
try:
if cluster_id is not None:
result = [
to_dict(
oci_utils.call_with_backoff(
container_engine_client.get_cluster, cluster_id=cluster_id
).data
)
]
else:
optional_list_method_params = ["name", "lifecycle_state"]
optional_kwargs = 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(
container_engine_client.list_clusters,
compartment_id=module.params["compartment_id"],
**optional_kwargs
)
)
except ServiceError as ex:
module.fail_json(msg=ex.message)
module.exit_json(clusters=result)
def main():
module_args = oci_utils.get_facts_module_arg_spec()
module_args.update(
dict(
compartment_id=dict(type="str", required=False),
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)
vcn_id = module.params["vcn_id"]
compartment_id = module.params["compartment_id"]
result = []
if vcn_id is not None:
try:
result = [
to_dict(
oci_utils.call_with_backoff(virtual_network_client.get_vcn,
vcn_id=vcn_id).data)
]
except ServiceError as ex:
module.fail_json(msg=ex.message)
elif compartment_id is not None:
try:
optional_list_method_params = ["display_name", "lifecycle_state"]
optional_kwargs = {
param: module.params[param]
for param in optional_list_method_params
if module.params.get(param) is not None
}
result = to_dict(
oci_utils.list_all_resources(virtual_network_client.list_vcns,
compartment_id=compartment_id,
**optional_kwargs))
except ServiceError as ex:
module.fail_json(msg=ex.message)
else:
module.fail_json(
msg=
"Specify a compartment_id to get all the VCNs in the compartment or a vcn_id to retrieve \
a specific VCN")
module.exit_json(vcns=result)
def 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():
module_args = oci_utils.get_facts_module_arg_spec()
module_args.update(
dict(
compartment_id=dict(type="str", required=False),
availability_domain=dict(type="str", required=False),
instance_id=dict(type="str", required=False),
vnic_attachment_id=dict(type="str", required=False, aliases=["id"]),
vnic_id=dict(type="str", required=False),
)
)
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=False,
mutually_exclusive=[("id", "compartment_id")],
)
if not HAS_OCI_PY_SDK:
module.fail_json(msg="oci python sdk required for this module.")
compute_client = oci_utils.create_service_client(module, ComputeClient)
compartment_id = module.params.get("compartment_id", None)
id = module.params["vnic_attachment_id"]
result = dict()
try:
if compartment_id:
# filter and get only key:values that have been provided by the user
optional_list_method_params = [
"availability_domain",
"instance_id",
"display_name",
"vnic_id",
]
optional_kwargs = 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_vnic_attachments,
compartment_id=compartment_id,
**optional_kwargs
)
result = to_dict(inst)
else:
inst = oci_utils.call_with_backoff(
compute_client.get_vnic_attachment, vnic_attachment_id=id
).data
result = to_dict([inst])
except ServiceError as ex:
module.fail_json(msg=ex.message)
except MaximumWaitTimeExceeded as mwte:
module.fail_json(msg=str(mwte))
module.exit_json(vnic_attachments=result)
def main():
module_args = oci_utils.get_facts_module_arg_spec()
module_args.update(
dict(
compartment_id=dict(type="str", required=False),
availability_domain=dict(type="str", required=False),
instance_id=dict(type="str", required=False, aliases=["id"]),
lifecycle_state=dict(
type="str",
required=False,
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)
compartment_id = module.params["compartment_id"]
id = module.params["instance_id"]
result = dict(changed=False)
if compartment_id:
result = list_instances(compute_client, module)
else:
try:
inst = oci_utils.call_with_backoff(compute_client.get_instance,
instance_id=id).data
result = to_dict([inst])
except ServiceError as ex:
module.fail_json(msg=ex.message)
# For each instance in the result, add related volume_attachments and boot_volume_attachment facts
try:
add_volume_attachment_facts(compute_client, result)
add_boot_volume_attachment_facts(compute_client, result)
except ServiceError as ex:
module.fail_json(msg=ex.message)
module.exit_json(instances=result)
def main():
module_args = oci_utils.get_facts_module_arg_spec(
filter_by_display_name=False,
supports_sort=True,
sort_by_choices=[
"id",
"compartmentId",
"displayName",
"notValidAfter",
"timeCreated",
],
)
module_args.update(
dict(
certificate_id=dict(type="str"),
compartment_id=dict(type="str"),
display_name=dict(type="list"),
id=dict(type="list"),
lifecycle_state=dict(
type="list",
choices=[
"CREATING",
"ACTIVE",
"FAILED",
"UPDATING",
"DELETING",
"DELETED",
],
),
time_created_greater_than_or_equal_to=dict(type="str"),
time_created_less_than=dict(type="str"),
))
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=False,
mutually_exclusive=[["certificate_id", "compartment_id"]],
)
if not HAS_OCI_PY_SDK:
module.fail_json(msg="oci python sdk required for this module.")
waas_client = oci_utils.create_service_client(module, WaasClient)
try:
if module.params["certificate_id"]:
result = get_certificate(waas_client, module)
elif module.params["compartment_id"]:
result = list_certificates(waas_client, module)
else:
module.fail_json(
msg=
"Specify a compartment_id to get all the certificates in the compartment or certificate_id "
"to retrieve a specific certificate.")
except ServiceError as se:
module.fail_json(msg=se.message)
module.exit_json(waas_certificates=result)
def main():
module_args = oci_utils.get_facts_module_arg_spec()
module_args.update(
dict(
compartment_id=dict(type="str", required=False),
instance_configuration_id=dict(type="str",
required=False,
aliases=["id"]),
))
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=False,
required_one_of=[["compartment_id", "instance_configuration_id"]],
)
if not HAS_OCI_PY_SDK:
module.fail_json(msg="oci python sdk required for this module.")
compute_management_client = oci_utils.create_service_client(
module, ComputeManagementClient)
instance_configuration_id = module.params["instance_configuration_id"]
try:
if instance_configuration_id is not None:
result = [
to_dict(
oci_utils.call_with_backoff(
compute_management_client.get_instance_configuration,
instance_configuration_id=instance_configuration_id,
).data)
]
else:
compartment_id = module.params["compartment_id"]
inst_conf_summaries = to_dict(
oci_utils.list_all_resources(
compute_management_client.list_instance_configurations,
compartment_id=compartment_id,
))
# Get model from summaries returned by `list_instance_configurations`
result = to_dict([
oci_utils.call_with_backoff(
compute_management_client.get_instance_configuration,
instance_configuration_id=ic["id"],
).data for ic in inst_conf_summaries
])
except ServiceError as ex:
module.fail_json(msg=ex.message)
module.exit_json(instance_configurations=result)
def main():
module_args = oci_utils.get_facts_module_arg_spec()
module_args.update(
dict(
compartment_id=dict(type="str", required=False),
volume_group_backup_id=dict(type="str", required=False, aliases=["id"]),
volume_group_id=dict(type="str", required=False),
)
)
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=False,
required_one_of=[["compartment_id", "volume_group_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_group_backup_id = module.params["volume_group_backup_id"]
try:
if volume_group_backup_id is not None:
result = [
to_dict(
oci_utils.call_with_backoff(
block_storage_client.get_volume_group_backup,
volume_group_backup_id=volume_group_backup_id,
).data
)
]
else:
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_volume_group_backups,
compartment_id=compartment_id,
**optional_kwargs
)
)
except ServiceError as ex:
module.fail_json(msg=ex.message)
module.exit_json(volume_group_backups=result)
def main():
module_args = oci_utils.get_facts_module_arg_spec(filter_by_name=True)
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)
result = list_regions(identity_client, module)
module.exit_json(regions=result)
def main():
module_args = oci_utils.get_facts_module_arg_spec()
module_args.update(
dict(compartment_id=dict(type='str', required=False),
service_gateway_id=dict(type='str',
required=False,
aliases=['id']),
vcn_id=dict(type='str', required=False),
lifecycle_state=dict(type='str', required=False)))
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=False,
required_one_of=[['compartment_id', 'service_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)
service_gateway_id = module.params['service_gateway_id']
compartment_id = module.params['compartment_id']
result = []
try:
if service_gateway_id is not None:
result = [
to_dict(
oci_utils.call_with_backoff(
virtual_network_client.get_service_gateway,
service_gateway_id=service_gateway_id).data)
]
else:
optional_list_method_params = [
'display_name', 'lifecycle_state', 'vcn_id'
]
optional_kwargs = {
param: module.params[param]
for param in optional_list_method_params
if module.params.get(param) is not None
}
result = to_dict(
oci_utils.list_all_resources(
virtual_network_client.list_service_gateways,
compartment_id=compartment_id,
**optional_kwargs))
except ServiceError as ex:
module.fail_json(msg=ex.message)
module.exit_json(service_gateways=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),
lifecycle_state=dict(type='str', required=False),
volume_group_id=dict(type='str', required=False, aliases=['id'])))
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=False,
required_one_of=[['compartment_id', 'volume_group_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_group_id = module.params['volume_group_id']
try:
if volume_group_id is not None:
result = [
to_dict(
oci_utils.call_with_backoff(
block_storage_client.get_volume_group,
volume_group_id=volume_group_id).data)
]
else:
compartment_id = module.params['compartment_id']
optional_list_method_params = [
'display_name', 'lifecycle_state', 'availability_domain'
]
optional_kwargs = {
param: module.params[param]
for param in optional_list_method_params
if module.params.get(param) is not None
}
result = to_dict(
oci_utils.list_all_resources(
block_storage_client.list_volume_groups,
compartment_id=compartment_id,
**optional_kwargs))
except ServiceError as ex:
module.fail_json(msg=ex.message)
module.exit_json(volume_groups=result)
def main():
module_args = oci_utils.get_facts_module_arg_spec(
filter_by_display_name=False,
supports_sort=True,
sort_by_choices=[
"id",
"status",
"timeAccepted",
"timeStarted",
"timeFinished",
"operationType",
],
)
module_args.update(
dict(
work_request_id=dict(type="str"),
compartment_id=dict(type="str"),
waas_policy_id=dict(type="str"),
))
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=False,
mutually_exclusive=[
["work_request_id", "compartment_id"],
["work_request_id", "waas_policy_id"],
],
)
if not HAS_OCI_PY_SDK:
module.fail_json(msg="oci python sdk required for this module.")
waas_client = oci_utils.create_service_client(module, WaasClient)
try:
if module.params["work_request_id"]:
result = get_work_request(waas_client, module)
elif module.params["waas_policy_id"] and module.params[
"compartment_id"]:
result = list_work_requests(waas_client, module)
else:
module.fail_json(
msg=
"Specify waas_policy_id and compartment_id to get all the work requests for a waas policy in the"
"compartment or work_request_id to retrieve a specific work request."
)
except ServiceError as se:
module.fail_json(msg=se.message)
module.exit_json(waas_work_requests=result)
def main():
module_args = oci_utils.get_facts_module_arg_spec()
module_args.update(
dict(
compartment_id=dict(type="str", required=False),
vcn_id=dict(type="str", required=False),
local_peering_gateway_id=dict(type="str",
required=False,
aliases=["id"]),
))
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=False,
required_if=[[
"local_peering_gateway_id", None, ["vcn_id", "compartment_id"]
]],
)
if not HAS_OCI_PY_SDK:
module.fail_json(msg="oci python sdk required for this module.")
virtual_network_client = oci_utils.create_service_client(
module, VirtualNetworkClient)
local_peering_gateway_id = module.params["local_peering_gateway_id"]
result = []
try:
if local_peering_gateway_id is not None:
result = [
to_dict(
oci_utils.call_with_backoff(
virtual_network_client.get_local_peering_gateway,
local_peering_gateway_id=local_peering_gateway_id,
).data)
]
else:
result = to_dict(
oci_utils.list_all_resources(
virtual_network_client.list_local_peering_gateways,
display_name=module.params["display_name"],
vcn_id=module.params["vcn_id"],
compartment_id=module.params["compartment_id"],
))
except ServiceError as ex:
module.fail_json(msg=ex.message)
module.exit_json(local_peering_gateways=result)
def main():
logger = oci_utils.get_logger("oci_load_balancer_shape_facts")
set_logger(logger)
module_args = oci_utils.get_facts_module_arg_spec(filter_by_name=True)
module_args.update(
dict(compartment_id=dict(type='str', required=True, aliases=['id'])))
module = AnsibleModule(argument_spec=module_args, )
if not HAS_OCI_PY_SDK:
module.fail_json(msg='oci python sdk required for this module')
lb_client = oci_utils.create_service_client(module, LoadBalancerClient)
result = list_load_balancer_shapes(lb_client, module)
module.exit_json(**result)
def main():
module_args = oci_utils.get_facts_module_arg_spec(filter_by_name=True)
module_args.update(
dict(
node_pool_id=dict(type="str", required=False, aliases=["id"]),
cluster_id=dict(type="str", required=False),
compartment_id=dict(type="str", required=False),
))
module = AnsibleModule(argument_spec=module_args,
supports_check_mode=False)
if not HAS_OCI_PY_SDK:
module.fail_json(msg="oci python sdk required for this module.")
container_engine_client = oci_utils.create_service_client(
module, ContainerEngineClient)
node_pool_id = module.params["node_pool_id"]
try:
if node_pool_id is not None:
result = [
to_dict(
oci_utils.call_with_backoff(
container_engine_client.get_node_pool,
node_pool_id=node_pool_id).data)
]
else:
if module.params["cluster_id"]:
result = to_dict(
oci_utils.list_all_resources(
container_engine_client.list_node_pools,
compartment_id=module.params["compartment_id"],
cluster_id=module.params["cluster_id"],
name=module.params["name"],
))
else:
result = to_dict(
oci_utils.list_all_resources(
container_engine_client.list_node_pools,
compartment_id=module.params["compartment_id"],
name=module.params["name"],
))
except ServiceError as ex:
module.fail_json(msg=ex.message)
module.exit_json(node_pools=result)
def main():
logger = oci_utils.get_logger("oci_db_system_shape_facts")
set_logger(logger)
module_args = oci_utils.get_facts_module_arg_spec(filter_by_name=True)
module_args.update(
dict(compartment_id=dict(type='str', required=True),
availability_domain=dict(type='str', required=True)))
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)
result = list_db_system_shapes(db_client, module)
module.exit_json(**result)
