def main():
logger = oci_utils.get_logger("oci_db_node_facts")
set_logger(logger)
module_args = oci_utils.get_common_arg_spec()
module_args.update(dict(
compartment_id=dict(type='str', required=False),
db_node_id=dict(type='str', required=False, aliases=['id']),
db_system_id=dict(type='str', required=False)
))
module = AnsibleModule(
argument_spec=module_args,
mutually_exclusive=[
['compartment_id', 'db_node_id'],
['db_system_id', 'db_node_id']
]
)
if not HAS_OCI_PY_SDK:
module.fail_json(msg='oci python sdk required for this module')
oci_config = oci_utils.get_oci_config(module)
db_client = DatabaseClient(oci_config)
result = list_db_nodes(db_client, module)
module.exit_json(**result)
def main():
module_args = oci_utils.get_common_arg_spec()
module_args.update(dict(name=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.")
result = dict(changed=False)
resource_search_client = oci_utils.create_service_client(
module, ResourceSearchClient)
name = module.params.get("name")
res_coll = None
if name is not None:
res_coll = [
oci_utils.call_with_backoff(
resource_search_client.get_resource_type, name=name).data
]
else:
res_coll = oci_utils.call_with_backoff(
resource_search_client.list_resource_types).data
result["resource_types"] = oci_utils.to_dict(res_coll)
module.exit_json(**result)
def main():
module_args = oci_utils.get_common_arg_spec()
module_args.update(
dict(vnic_id=dict(type="str", required=False, aliases=["id"])))
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.")
virtnw_client = oci_utils.create_service_client(module,
VirtualNetworkClient)
id = module.params["vnic_id"]
result = dict()
try:
inst = oci_utils.call_with_backoff(virtnw_client.get_vnic,
vnic_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=result)
def main():
module_args = oci_utils.get_common_arg_spec()
module_args.update(
dict(instance_id=dict(type="str", required=True, aliases=["id"])))
module = AnsibleModule(argument_spec=module_args,
supports_check_mode=False)
if not HAS_OCI_PY_SDK:
module.fail_json(msg="oci python sdk required for this module.")
compute_client = oci_utils.create_service_client(module, ComputeClient)
instance_id = module.params["instance_id"]
result = dict(changed=False)
try:
result["instance_credentials"] = to_dict(
oci_utils.call_with_backoff(
compute_client.get_windows_instance_initial_credentials,
instance_id=instance_id,
).data)
except ServiceError as se:
module.fail_json(msg=se.message)
module.exit_json(**result)
def main():
logger = oci_utils.get_logger("oci_sender_facts")
set_logger(logger)
module_args = oci_utils.get_common_arg_spec()
module_args.update(
dict(
compartment_id=dict(type="str", required=False),
sender_id=dict(type="str", required=False, aliases=["id"]),
lifecycle_state=dict(
type="str",
required=False,
choices=["CREATING", "ACTIVE", "DELETING", "DELETED"],
),
email_address=dict(type=str, required=False),
)
)
module = AnsibleModule(
argument_spec=module_args, mutually_exclusive=[["compartment_id", "sender_id"]]
)
if not HAS_OCI_PY_SDK:
module.fail_json(msg="oci python sdk required for this module")
email_client = oci_utils.create_service_client(module, EmailClient)
result = list_senders(email_client, module)
module.exit_json(**result)
def main():
logger = oci_utils.get_logger("oci_db_node_facts")
set_logger(logger)
module_args = oci_utils.get_common_arg_spec()
module_args.update(
dict(
compartment_id=dict(type="str", required=False),
db_node_id=dict(type="str", required=False, aliases=["id"]),
db_system_id=dict(type="str", required=False),
)
)
module = AnsibleModule(
argument_spec=module_args,
mutually_exclusive=[
["compartment_id", "db_node_id"],
["db_system_id", "db_node_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_db_nodes(db_client, module)
module.exit_json(**result)
def main():
module_args = oci_utils.get_common_arg_spec()
module_args.update(
dict(
cluster_id=dict(type="str", required=True),
create_cluster_kubeconfig_content_details=dict(type="dict",
required=False),
dest=dict(type="str", required=False),
force=dict(type="bool",
required=False,
default=False,
aliases=["overwrite"]),
))
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=False,
required_if=[("force", True, ["dest"])],
)
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)
try:
result = create_kubeconfig(container_engine_client, module)
except ServiceError as ex:
module.fail_json(msg=ex.message)
module.exit_json(**result)
def main():
module_args = oci_utils.get_common_arg_spec()
module_args.update(
dict(work_request_id=dict(type='str', required=True),
compartment_id=dict(type='str', required=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.')
container_engine_client = oci_utils.create_service_client(
module, ContainerEngineClient)
try:
result = to_dict(
oci_utils.list_all_resources(
container_engine_client.list_work_request_errors,
compartment_id=module.params['compartment_id'],
work_request_id=module.params['work_request_id']))
except ServiceError as ex:
module.fail_json(msg=ex.message)
module.exit_json(work_request_errors=result)
def main():
logger = oci_utils.get_logger("oci_export")
set_logger(logger)
module_args = oci_utils.get_common_arg_spec(supports_create=True, supports_wait=True)
module_args.update(dict(
export_options=dict(type=list, required=False),
export_set_id=dict(type='str', required=False),
file_system_id=dict(type='str', required=False),
export_id=dict(type='str', required=False, aliases=['id']),
path=dict(type='str', required=False),
purge_export_options=dict(type='bool', required=False, default=True),
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')
file_storage_client = oci_utils.create_service_client(module, FileStorageClient)
state = module.params['state']
if state == 'present':
result = create_or_update_export(file_storage_client, module)
elif state == 'absent':
result = delete_export(file_storage_client, module)
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 = {
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():
logger = oci_utils.get_logger("oci_snapshot_facts")
set_logger(logger)
module_args = oci_utils.get_common_arg_spec()
module_args.update(
dict(
file_system_id=dict(type="str", required=False),
snapshot_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=[["file_system_id", "snapshot_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_snapshots(file_storage_client, module)
module.exit_json(**result)
def main():
module_args = oci_utils.get_common_arg_spec()
module_args.update(
dict(
namespace_name=dict(type="str", required=True),
compartment_id=dict(type="str", required=False),
name=dict(type="str", required=False, aliases=["bucket"]),
fields=dict(type="list", required=False, choices=["tags"]),
))
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=False,
required_one_of=[["compartment_id", "name"]],
)
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)
bucket_name = module.params["name"]
if bucket_name is not None:
try:
result = [
to_dict(
object_storage_client.get_bucket(
module.params["namespace_name"], bucket_name).data)
]
except ServiceError as ex:
module.fail_json(msg=ex.message)
else:
result = list_buckets(object_storage_client, module)
module.exit_json(buckets=result)
def main():
module_args = oci_utils.get_common_arg_spec(supports_wait=True)
module_args.update(
dict(
compartment_id=dict(type="str", required=False),
zone_id=dict(type="str", required=False, aliases=["id"]),
name=dict(type="str", required=False, aliases=["zone_name"]),
domain=dict(type="str", required=True),
update_items=dict(type="list", required=False),
patch_items=dict(type="list", required=False),
state=dict(type="str",
required=False,
default="present",
choices=["present"]),
))
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=False,
required_one_of=[["update_items", "patch_items"], ["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"]
if state == "present":
if module.params["update_items"] is not None:
result = update_domain_records(dns_client, module)
else:
result = patch_domain_records(dns_client, module)
module.exit_json(**result)
def main():
logger = oci_utils.get_logger("oci_smtp_credential")
set_logger(logger)
module_args = oci_utils.get_common_arg_spec(supports_create=True)
module_args.update(
dict(
user_id=dict(type="str", required=True),
smtp_credential_id=dict(type="str", required=False,
aliases=["id"]),
description=dict(type="str", required=False),
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")
identity_client = oci_utils.create_service_client(module, IdentityClient)
state = module.params["state"]
if state == "present":
result = create_or_update_smtp_credential(identity_client, module)
elif state == "absent":
result = delete_smtp_credential(identity_client, module)
module.exit_json(**result)
def main():
logger = oci_utils.get_logger("oci_bucket")
set_logger(logger)
module_args = oci_utils.get_common_arg_spec()
module_args.update(
dict(namespace_name=dict(type='str', required=True),
compartment_id=dict(type='str', required=False),
name=dict(type='str', required=True),
public_access_type=dict(type='str',
required=False,
default='NoPublicAccess',
choices=['NoPublicAccess', 'ObjectRead']),
metadata=dict(type='dict', default={}),
state=dict(type='str',
required=False,
default='present',
choices=['present', 'absent']),
force=dict(type='bool', required=False, default=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)
state = module.params['state']
if state == 'present':
result = create_or_update_bucket(object_storage_client, module)
elif state == 'absent':
result = delete_bucket(object_storage_client, module)
module.exit_json(**result)
def main():
module_args = oci_utils.get_common_arg_spec()
module_args.update(
dict(
listing_id=dict(type="str", required=True, aliases=["id"]),
resource_version=dict(type="str",
required=False,
aliases=["version"]),
))
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:
resource_version = module.params["resource_version"]
if resource_version:
result = get_app_catalog_listing_resource_version(
compute_client, module)
else:
result = list_app_catalog_listing_resource_versions(
compute_client, module)
except ServiceError as se:
module.fail_json(msg=se.message)
module.exit_json(app_catalog_listing_resource_versions=result)
def main():
module_args = oci_utils.get_common_arg_spec()
module_args.update(dict(
policy_assignment_id=dict(type='str', required=False, aliases=['id']),
asset_id=dict(type='str', required=False),
))
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=False,
required_one_of=[
['policy_assignment_id', 'asset_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)
policy_assignment_id = module.params['policy_assignment_id']
try:
if policy_assignment_id:
result = [to_dict(oci_utils.call_with_backoff(block_storage_client.get_volume_backup_policy_assignment,
policy_assignment_id=policy_assignment_id).data)]
else:
result = to_dict(oci_utils.call_with_backoff(block_storage_client.get_volume_backup_policy_asset_assignment,
asset_id=module.params['asset_id']).data)
except ServiceError as ex:
module.fail_json(msg=ex.message)
module.exit_json(volume_backup_policy_assignments=result)
def main():
logger = oci_utils.get_logger("oci_load_balancer_hostname")
set_logger(logger)
module_args = oci_utils.get_common_arg_spec(supports_wait=True)
module_args.update(
dict(name=dict(type='str', required=True),
load_balancer_id=dict(type='str', required=True, aliases=['id']),
hostname=dict(type='str', required=False),
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')
lb_client = LoadBalancerClient(oci_utils.get_oci_config(module))
state = module.params['state']
if state == 'present':
result = create_or_update_hostname(lb_client, module)
elif state == 'absent':
result = delete_hostname(lb_client, module)
module.exit_json(**result)
def main():
logger = oci_utils.get_logger("oci_load_balancer_path_route_set")
set_logger(logger)
module_args = oci_utils.get_common_arg_spec(supports_wait=True)
module_args.update(dict(
name=dict(type='str', required=True),
load_balancer_id=dict(type='str', required=True, aliases=['id']),
path_routes=dict(type='list', required=False),
purge_path_routes=dict(type='bool', required=False, default=True),
state=dict(type='str', required=False, default='present', choices=['present', 'absent'])
))
module = AnsibleModule(
argument_spec=module_args,
required_if=[
['state', 'present', ['path_routes']]
],
)
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)
state = module.params['state']
if state == 'present':
result = create_or_update_path_route_set(lb_client, module)
elif state == 'absent':
result = delete_path_route_set(lb_client, module)
module.exit_json(**result)
def main():
module_args = oci_utils.get_common_arg_spec()
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.')
config = oci_utils.get_oci_config(module)
identity_client = IdentityClient(config)
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']))
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():
module_args = oci_utils.get_common_arg_spec()
module_args.update(
dict(ipsc_id=dict(type="str", required=True, aliases=["id"])))
module = AnsibleModule(argument_spec=module_args,
supports_check_mode=False)
if not HAS_OCI_PY_SDK:
module.fail_json(msg="oci python sdk required for this module.")
virtual_network_client = oci_utils.create_service_client(
module, VirtualNetworkClient)
ip_sec_connection_id = module.params["ipsc_id"]
try:
result = to_dict(
oci_utils.call_with_backoff(
virtual_network_client.get_ip_sec_connection_device_status,
ipsc_id=ip_sec_connection_id,
).data)
except ServiceError as ex:
module.fail_json(msg=ex.message)
module.exit_json(ip_sec_connection_device_status=result)
def main():
logger = oci_utils.get_logger("oci_file_system_facts")
set_logger(logger)
module_args = oci_utils.get_common_arg_spec()
module_args.update(dict(
compartment_id=dict(type='str', required=False),
export_set_id=dict(type='str', required=False),
file_system_id=dict(type='str', required=False),
export_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'],
['export_set_id', 'file_system_id'],
['export_set_id', 'compartment_id'],
['export_id', 'compartment_id'],
['export_id', 'file_system_id'],
['export_id', 'export_set_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_exports(file_storage_client, module)
module.exit_json(**result)
def main():
module_args = oci_utils.get_common_arg_spec(supports_wait=True)
module_args.update(dict(
boot_volume_id=dict(type='str', required=True, 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')
))
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=False,
required_if=[
['state', 'present', ['display_name']]
]
)
if not HAS_OCI_PY_SDK:
module.fail_json(msg='oci python sdk required for this module.')
config = oci_utils.get_oci_config(module)
block_storage_client = BlockstorageClient(config)
state = module.params['state']
if state == 'absent':
result = handle_delete_boot_volume(block_storage_client, module)
else:
result = handle_update_boot_volume(block_storage_client, module)
add_attached_instance_info(config, module, result, module.params['lookup_attached_instance'])
module.exit_json(**result)
def main():
module_args = oci_utils.get_common_arg_spec()
module_args.update(
dict(compartment_id=dict(type='str', required=True),
instance_pool_id=dict(type='str', required=True, aliases=['id'])))
module = AnsibleModule(argument_spec=module_args,
supports_check_mode=False)
if not HAS_OCI_PY_SDK:
module.fail_json(msg='oci python sdk required for this module.')
compute_management_client = oci_utils.create_service_client(
module, ComputeManagementClient)
compute_client = oci_utils.create_service_client(module, ComputeClient)
try:
compartment_id = module.params['compartment_id']
instance_pool_id = module.params['instance_pool_id']
instance_summaries = to_dict(
oci_utils.list_all_resources(
compute_management_client.list_instance_pool_instances,
compartment_id=compartment_id,
instance_pool_id=instance_pool_id))
# Get model from summaries returned by `list_instance_pools_instances`
result = to_dict([
oci_utils.call_with_backoff(compute_client.get_instance,
instance_id=inst_summ['id']).data
for inst_summ in instance_summaries
])
except ServiceError as ex:
module.fail_json(msg=ex.message)
module.exit_json(instance_pool_instances=result)
def main():
module_args = oci_utils.get_common_arg_spec()
module_args.update(dict(
private_ip_id=dict(type='str', required=False, aliases=['id']),
subnet_id=dict(type='str', required=False),
ip_address=dict(type='str', required=False),
vnic_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:
optional_list_method_params = ['ip_address', 'subnet_id', 'vnic_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_private_ips,
**optional_kwargs))
except ServiceError as ex:
module.fail_json(msg=ex.message)
module.exit_json(private_ips=result)
def main():
my_logger = oci_utils.get_logger("oci_instance")
set_logger(my_logger)
module_args = oci_utils.get_common_arg_spec()
module_args.update(
dict(name=dict(type='str', required=False, aliases=['display_name']),
vnic_id=dict(type='str', required=False, aliases=['id']),
hostname_label=dict(type='str', required=False),
skip_source_dest_check=dict(type='bool',
required=False,
default=False),
state=dict(type='str',
required=False,
default='present',
choices=['present'])))
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=False,
required_if=[('state', 'present', ['id'])],
)
if not HAS_OCI_PY_SDK:
module.fail_json(msg='oci python sdk required for this module.')
virtnetwork_client = oci_utils.create_service_client(
module, VirtualNetworkClient)
result = dict(changed=False)
id = module.params['id']
debug("VNIC Id provided by user is " + str(id))
try:
vnic = oci_utils.call_with_backoff(virtnetwork_client.get_vnic,
vnic_id=id).data
if vnic is not None:
name = module.params['name']
hostname_label = module.params['hostname_label']
skip_source_dest_check = module.params['skip_source_dest_check']
if not oci_utils.are_attrs_equal(vnic, module,
vnic.attribute_map.keys()):
debug("Need to update VNIC " + str(id))
uvd = UpdateVnicDetails()
uvd.skip_source_dest_check = skip_source_dest_check
uvd.hostname_label = hostname_label
uvd.display_name = name
oci_utils.call_with_backoff(virtnetwork_client.update_vnic,
vnic_id=id,
update_vnic_details=uvd)
result['changed'] = True
resp = oci_utils.call_with_backoff(virtnetwork_client.get_vnic,
vnic_id=id)
result['vnic'] = to_dict(resp.data)
except ServiceError as ex:
module.fail_json(msg=ex.message)
module.exit_json(**result)
def main():
module_args = oci_utils.get_common_arg_spec(supports_wait=True)
module_args.update(
dict(compartment_id=dict(type='str', required=False),
zone_id=dict(type='str', required=False, aliases=['id']),
name=dict(type='str', required=False, aliases=['zone_name']),
update_items=dict(type='list', required=False),
patch_items=dict(type='list', required=False),
state=dict(type='str',
required=False,
default='present',
choices=['present'])))
module = AnsibleModule(argument_spec=module_args,
supports_check_mode=False,
required_one_of=[['update_items', 'patch_items'],
['zone_id', 'name']])
if not HAS_OCI_PY_SDK:
module.fail_json(msg='oci python sdk required for this module.')
config = oci_utils.get_oci_config(module)
dns_client = DnsClient(config)
state = module.params['state']
if state == 'present':
if module.params['update_items'] is not None:
result = update_zone_records(dns_client, module)
else:
result = patch_zone_records(dns_client, module)
module.exit_json(**result)
def main():
module_args = oci_utils.get_common_arg_spec()
module_args.update(
dict(compartment_id=dict(type='str', required=True),
availability_domain=dict(type='str', required=False),
image_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.')
compute_client = oci_utils.create_service_client(module, ComputeClient)
compartment_id = module.params['compartment_id']
result = dict(changed=False)
try:
optional_list_method_params = ['availability_domain', 'image_id']
optional_kwargs = {
param: module.params[param]
for param in optional_list_method_params
if module.params.get(param) is not None
}
shapes = oci_utils.list_all_resources(compute_client.list_shapes,
compartment_id=compartment_id,
**optional_kwargs)
result['shapes'] = to_dict(shapes)
except ServiceError as ex:
module.fail_json(msg=ex.message)
module.exit_json(shapes=result)
def main():
module_args = oci_utils.get_common_arg_spec()
module_args.update(
dict(namespace_name=dict(type='str', required=True),
compartment_id=dict(type='str', required=False),
name=dict(type='str', required=False, aliases=['bucket'])))
module = AnsibleModule(argument_spec=module_args,
supports_check_mode=False,
required_one_of=[['compartment_id', 'name']])
if not HAS_OCI_PY_SDK:
module.fail_json(msg='oci python sdk required for this module')
object_storage_client = ObjectStorageClient(
oci_utils.get_oci_config(module))
bucket_name = module.params['name']
if bucket_name is not None:
try:
result = [
to_dict(
object_storage_client.get_bucket(
module.params['namespace_name'], bucket_name).data)
]
except ServiceError as ex:
module.fail_json(msg=ex.message)
else:
result = list_buckets(object_storage_client, module)
module.exit_json(buckets=result)
def main():
logger = oci_utils.get_logger("oci_load_balancer_backend")
set_logger(logger)
module_args = oci_utils.get_common_arg_spec(supports_wait=True)
module_args.update(dict(
load_balancer_id=dict(type='str', required=True, aliases=['id']),
backend_set_name=dict(type='str', required=True),
backup=dict(type='bool', required=False),
ip_address=dict(type='str', required=True),
drain=dict(type='bool', required=False),
state=dict(type='str', required=False, default='present', choices=['present', 'absent']),
offline=dict(type='bool', required=False),
port=dict(type='int', required=True),
weight=dict(type='int', required=False)
))
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)
state = module.params['state']
if state == 'present':
result = create_or_update_backend(lb_client, module)
elif state == 'absent':
result = delete_backend(lb_client, module)
module.exit_json(**result)
