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():
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')
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():
logger = oci_utils.get_logger("oci_file_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),
availability_domain=dict(type="str", required=False),
file_system_id=dict(type="str", required=False, aliases=["id"]),
display_name=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")
file_storage_client = oci_utils.create_service_client(
module, FileStorageClient)
state = module.params["state"]
if state == "present":
result = create_or_update_file_system(file_storage_client, module)
elif state == "absent":
result = delete_file_system(file_storage_client, module)
module.exit_json(**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)
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 = oci_utils.create_service_client(module, LoadBalancerClient)
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_suppression_facts")
set_logger(logger)
module_args = oci_utils.get_common_arg_spec()
module_args.update(
dict(
compartment_id=dict(type="str", required=False),
suppression_id=dict(type="str", required=False, aliases=["id"]),
time_created_greater_than_or_equal_to=dict(type="str", required=False),
time_created_less_than=dict(type="str", required=False),
email_address=dict(type=str, required=False),
)
)
module = AnsibleModule(
argument_spec=module_args,
mutually_exclusive=[["compartment_id", "suppression_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_suppressions(email_client, module)
module.exit_json(**result)
def main():
logger = oci_utils.get_logger("oci_load_balancer_backend_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']),
backends=dict(type=list, required=False),
health_checker=dict(type=dict, required=False),
policy=dict(type='str', required=False),
session_persistence_configuration=dict(type=dict, required=False),
ssl_configuration=dict(type=dict, required=False),
purge_backends=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')
lb_client = oci_utils.create_service_client(module, LoadBalancerClient)
state = module.params['state']
if state == 'present':
result = create_or_update_backend_set(lb_client, module)
elif state == 'absent':
result = delete_backend_set(lb_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():
logger = oci_utils.get_logger("oci_export_set")
set_logger(logger)
module_args = oci_utils.get_common_arg_spec(supports_wait=True)
module_args.update(
dict(max_fs_stat_bytes=dict(type=int, required=False),
max_fs_stat_files=dict(type=int, required=False),
export_set_id=dict(type='str', required=False, aliases=['id']),
display_name=dict(type='str', required=False),
state=dict(type='str',
required=False,
default='present',
choices=['present'])))
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 = update_export_set(file_storage_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():
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():
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():
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():
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():
logger = oci_utils.get_logger("oci_database")
set_logger(logger)
module_args = oci_utils.get_taggable_arg_spec(supports_wait=True)
module_args.update(dict(
database_id=dict(type='str', required=True, aliases=['id']),
database_scn=dict(type='str', required=False),
latest=dict(type=bool, required=False),
timestamp=dict(type='str', required=False),
db_backup_config=dict(type=dict, required=False),
state=dict(type='str', required=False, default='update', choices=['restore', 'update'])
))
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 = DatabaseClient(oci_utils.get_oci_config(module))
state = module.params['state']
if state == 'restore':
result = restore_database(db_client, module)
elif state == 'update':
result = update_database(db_client, module)
module.exit_json(**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_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():
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_load_balancer_health_checker")
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),
interval_in_millis=dict(type=int, required=False),
response_body_regex=dict(type='str', required=True),
protocol=dict(type='str', required=True),
port=dict(type=int, required=True),
retries=dict(type=int, required=True),
return_code=dict(type=int, required=True),
timeout_in_millis=dict(type=int, required=True),
url_path=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')
lb_client = oci_utils.create_service_client(module, LoadBalancerClient)
result = update_health_checker(lb_client, module)
module.exit_json(**result)
def main():
logger = oci_utils.get_logger("oci_database")
set_logger(logger)
module_args = oci_utils.get_taggable_arg_spec(supports_wait=True)
module_args.update(
dict(
database_id=dict(type="str", required=True, aliases=["id"]),
database_scn=dict(type="str", required=False),
latest=dict(type=bool, required=False),
timestamp=dict(type="str", required=False),
db_backup_config=dict(type=dict, required=False),
state=dict(
type="str",
required=False,
default="update",
choices=["restore", "update"],
),
)
)
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 == "restore":
result = restore_database(db_client, module)
elif state == "update":
result = update_database(db_client, module)
module.exit_json(**result)
def main():
logger = oci_utils.get_logger("oci_snapshot")
set_logger(logger)
module_args = oci_utils.get_taggable_arg_spec(supports_create=True,
supports_wait=True)
module_args.update(
dict(file_system_id=dict(type='str', required=False),
name=dict(type='str', required=False),
snapshot_id=dict(type='str', required=False, aliases=['id']),
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_snapshot(file_storage_client, module)
elif state == 'absent':
result = delete_snapshot(file_storage_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.')
config = oci_utils.get_oci_config(module)
identity_client = IdentityClient(config)
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():
logger = oci_utils.get_logger("oci_volume_backup")
set_logger(logger)
module_args = oci_utils.get_taggable_arg_spec(supports_create=True,
supports_wait=True)
module_args.update(
dict(display_name=dict(type='str', required=False, aliases=['name']),
state=dict(type='str',
required=False,
default='present',
choices=['absent', 'present']),
type=dict(type='str',
required=False,
default='INCREMENTAL',
choices=['FULL', 'INCREMENTAL']),
volume_backup_id=dict(type='str', required=False, aliases=['id']),
volume_id=dict(type='str', required=False)))
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=False,
required_if=[['state', 'absent', ['volume_backup_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)
block_storage_client = BlockstorageClient(config)
state = module.params['state']
volume_backup_id = module.params['volume_backup_id']
if state == 'absent':
result = delete_volume_backup(block_storage_client, module)
else:
if volume_backup_id is None:
# Get compartment_id of volume to list all the volume backups of the volume in that compartment.
compartment_id = block_storage_client.get_volume(
module.params['volume_id']).data.compartment_id
result = oci_utils.check_and_create_resource(
resource_type='volume_backup',
create_fn=create_volume_backup,
kwargs_create={
'block_storage_client': block_storage_client,
'module': module
},
list_fn=block_storage_client.list_volume_backups,
kwargs_list={
'compartment_id': compartment_id,
'volume_id': module.params['volume_id']
},
module=module,
model=CreateVolumeBackupDetails(),
exclude_attributes={'display_name': True})
else:
result = update_volume_backup(block_storage_client, module)
module.exit_json(**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']),
creation_type=dict(type='str',
required=False,
default='ExistingDbSystem',
choices=['ExistingDbSystem']),
database_admin_password=dict(type='str',
required=False,
no_log=True),
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)
def main():
my_logger = oci_utils.get_logger(RESOURCE_NAME)
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']),
instance_configuration_id=dict(type='str', required=False),
placement_configurations=dict(type='list', required=False),
instance_pool_id=dict(type='str', required=False, aliases=['id']),
size=dict(type='int', required=False),
state=dict(type='str', required=False, default='present', choices=['absent', 'present', 'running', 'reset',
'softreset', 'stopped']))
)
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=False,
mutually_exclusive=['instance_pool_id', 'compartment_id'],
required_if=[('state', 'absent', ['instance_pool_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)
state = module.params['state']
if state == 'absent':
result = delete_instance_pool(compute_management_client, module)
elif state == 'present':
instance_pool_id = module.params['instance_pool_id']
if instance_pool_id is None:
kwargs_list = {'compartment_id': module.params['compartment_id']}
result = oci_utils.check_and_create_resource(resource_type=RESOURCE_NAME,
create_fn=create_instance_pool,
kwargs_create={
'compute_management_client': compute_management_client,
'module': module},
list_fn=compute_management_client.list_instance_pools,
kwargs_list=kwargs_list,
module=module,
model=CreateInstancePoolDetails(),
exclude_attributes=None,
supports_sort_by_time_created=False
)
else:
result = update_instance_pool(compute_management_client, module)
else:
# one of the power actions
result = power_action_on_instance_pool(compute_management_client, module)
module.exit_json(**result)
def main():
logger = oci_utils.get_logger("oci_autonomous_data_warehouse")
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),
admin_password=dict(type="str", required=False, no_log=True),
autonomous_data_warehouse_id=dict(
type="str", required=False, aliases=["id"]
),
cpu_core_count=dict(type=int, required=False),
data_storage_size_in_tbs=dict(type=int, required=False),
db_name=dict(type="str", required=False),
display_name=dict(type="str", required=False),
license_model=dict(
type="str",
required=False,
choices=["LICENSE_INCLUDED", "BRING_YOUR_OWN_LICENSE"],
),
timestamp=dict(type="str", required=False),
state=dict(
type="str",
required=False,
default="present",
choices=["present", "absent", "restore", "start", "stop"],
),
)
)
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)
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 = create_or_update_autonomous_data_warehouse(db_client, module)
elif state == "absent":
result = delete_autonomous_data_warehouse(db_client, module)
elif state == "restore":
result = restore_autonomous_data_warehouse(db_client, module)
else:
result = start_or_stop_autonomous_data_warehouse(db_client, module)
module.exit_json(**result)
def main():
logger = oci_utils.get_logger("oci_sender")
set_logger(logger)
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),
sender_id=dict(type="str", required=False, aliases=["id"]),
email_address=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")
email_client = oci_utils.create_service_client(module, EmailClient)
state = module.params["state"]
if state == "present":
try:
result = oci_utils.check_and_create_resource(
resource_type="sender",
create_fn=create_sender,
kwargs_create={
"email_client": email_client,
"module": module
},
list_fn=email_client.list_senders,
kwargs_list={
"compartment_id": module.params.get("compartment_id")
},
module=module,
model=CreateSenderDetails(),
)
except ServiceError as ex:
get_logger().error("Unable to create Sender due to: %s",
ex.message)
module.fail_json(msg=ex.message)
except ClientError as ex:
get_logger().error("Unable to create Sender due to: %s", str(ex))
module.fail_json(msg=str(ex))
elif state == "absent":
result = delete_sender(email_client, module)
module.exit_json(**result)
def main():
set_logger(oci_utils.get_logger("oci_api_key"))
module_args = oci_utils.get_common_arg_spec(supports_create=True, supports_wait=True)
module_args.update(dict(
user_id=dict(type='str', required=True),
api_key_id=dict(type='str', required=False, aliases=['id']),
api_signing_key=dict(type='str', required=False, aliases=['key']),
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', ['api_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)
public_key = module.params.get("api_signing_key", None)
api_key_id = module.params.get("api_key_id", None)
if api_key_id is not None:
api_key = _get_api_key_from_id(identity_client, user_id, api_key_id, module)
if state == 'absent':
get_logger().debug("Delete api password %s for user %s requested", api_key_id, user_id)
if api_key is not None:
get_logger().debug("Deleting %s", api_key.key_id)
result = delete_api_key(identity_client, user_id, api_key_id, module)
else:
get_logger().debug("API Signing Key %s already deleted.", api_key_id)
elif state == 'present':
module.fail_json(msg="API signing key cannot be updated.")
else:
result = oci_utils.check_and_create_resource(resource_type=RESOURCE_NAME, create_fn=create_api_key,
kwargs_create={"identity_client": identity_client,
"user_id": user_id, "key": public_key,
"module": module},
list_fn=identity_client.list_api_keys,
kwargs_list={"user_id": user_id},
module=module,
model=CreateApiKeyDetails()
)
module.exit_json(**result)
def main():
logger = oci_utils.get_logger("oci_autonomous_database")
set_logger(logger)
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),
suppression_id=dict(type='str', required=False, aliases=['id']),
email_address=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')
email_client = oci_utils.create_service_client(module, EmailClient)
state = module.params['state']
if state == 'present':
try:
result = oci_utils.check_and_create_resource(
resource_type='suppression',
create_fn=create_suppression,
kwargs_create={
'email_client': email_client,
'module': module
},
list_fn=email_client.list_suppressions,
kwargs_list={
'compartment_id': module.params.get('compartment_id')
},
module=module,
model=CreateSuppressionDetails())
except ServiceError as ex:
get_logger().error("Unable to create suppression due to: %s",
ex.message)
module.fail_json(msg=ex.message)
except ClientError as ex:
get_logger().error("Unable to create suppression due to: %s",
str(ex))
module.fail_json(msg=str(ex))
elif state == 'absent':
result = delete_suppression(email_client, module)
module.exit_json(**result)
