def main():
module_args = oci_utils.get_taggable_arg_spec(supports_create=True,
supports_wait=True)
module_args.update(
compartment_id=dict(type="str", required=False),
display_name=dict(type="str", required=False, aliases=["name"]),
vcn_id=dict(type="str", required=False),
rt_id=dict(type="str", required=False, aliases=["id"]),
state=dict(type="str",
required=False,
default="present",
choices=["present", "absent"]),
route_rules=dict(type=list, required=False),
purge_route_rules=dict(type="bool", required=False, default=True),
delete_route_rules=dict(type="bool", required=False, default=False),
)
module = AnsibleModule(
argument_spec=module_args,
mutually_exclusive=[["purge_route_rules", "delete_route_rules"]],
)
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)
state = module.params["state"]
if state == "present":
result = create_or_update_route_table(virtual_network_client, module)
elif state == "absent":
result = delete_route_table(virtual_network_client, module)
module.exit_json(**result)
def main():
module_args = oci_utils.get_taggable_arg_spec(supports_create=True,
supports_wait=True)
module_args.update(
dict(compartment_id=dict(type='str', required=False),
display_name=dict(type='str', required=False, aliases=['name']),
vcn_id=dict(type='str', required=False),
dhcp_id=dict(type='str', required=False, aliases=['id']),
state=dict(type='str',
required=False,
default='present',
choices=['present', 'absent']),
options=dict(type=list, required=False),
purge_dhcp_options=dict(type='bool', required=False,
default=True)))
module = AnsibleModule(argument_spec=module_args)
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)
virtual_network_client = VirtualNetworkClient(oci_config)
state = module.params['state']
if state == 'present':
result = create_or_update_dhcp_options(virtual_network_client, module)
elif state == 'absent':
result = delete_dhcp_options(virtual_network_client, module)
module.exit_json(**result)
def main():
module_args = oci_utils.get_taggable_arg_spec(supports_create=True,
supports_wait=True)
module_args.update(
dict(compartment_id=dict(type='str', required=False),
display_name=dict(type='str', required=False, aliases=['name']),
vcn_id=dict(type='str', required=False),
ig_id=dict(type='str', required=False, aliases=['id']),
state=dict(type='str',
required=False,
default='present',
choices=['present', 'absent']),
is_enabled=dict(type='bool', required=False,
aliases=['enabled'])))
module = AnsibleModule(argument_spec=module_args)
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)
state = module.params['state']
if state == 'present':
result = create_or_update_internet_gateway(virtual_network_client,
module)
elif state == 'absent':
result = delete_internet_gateway(virtual_network_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_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():
module_args = oci_utils.get_taggable_arg_spec(supports_wait=True)
module_args.update(
dict(name=dict(type='str', required=False),
user_id=dict(type='str', required=False, aliases=['id']),
description=dict(type='str', required=False, default=''),
user_groups=dict(type='list', required=False),
blocked=dict(type='str', required=False, choices=['yes', 'no']),
create_or_reset_ui_password=dict(type='bool',
required=False,
default=False),
state=dict(type='str',
required=False,
default='present',
choices=['present', 'absent']),
purge_group_memberships=dict(type='bool',
required=False,
default=False),
force=dict(type='bool', required=False, default=False)))
module = AnsibleModule(argument_spec=module_args)
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)
identity_client = IdentityClient(oci_config)
compartment_id = oci_config['tenancy']
module.params.update(dict({'compartment_id': compartment_id}))
state = module.params['state']
if state == 'present':
result = create_or_update_user(identity_client, module)
elif state == 'absent':
result = delete_user(identity_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_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_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():
module_args = oci_utils.get_taggable_arg_spec(supports_create=True,
supports_wait=True)
module_args.update(
dict(instance_id=dict(type='str', required=False),
public_key=dict(type='str', required=False),
instance_console_connection_id=dict(type='str',
required=False,
aliases=['id']),
state=dict(type='str',
required=False,
default='present',
choices=['absent', 'present'])))
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=False,
mutually_exclusive=['instance_console_connection_id', 'instance_id'],
required_if=[('state', 'absent', ['instance_console_connection_id']),
('state', 'present', ['instance_id', 'public_key'])])
if not HAS_OCI_PY_SDK:
module.fail_json(msg='oci python sdk required for this module.')
compute_client = oci_utils.create_service_client(module, ComputeClient)
state = module.params['state']
if state == 'absent':
result = delete_instance_console_connection(compute_client, module)
else:
# Replace value of `public_key` key by content of file pointed to by the `public_key` param
module.params["public_key"] = get_file_content(
module.params['public_key'])
instance_id = module.params['instance_id']
kwargs_list = {
'instance_id':
instance_id,
'compartment_id':
_get_compartment_of_instance(compute_client, instance_id)
}
result = oci_utils.check_and_create_resource(
resource_type='instance_console_connection',
create_fn=create_instance_console_connection,
kwargs_create={
'compute_client': compute_client,
'module': module
},
list_fn=compute_client.list_instance_console_connections,
kwargs_list=kwargs_list,
module=module,
model=CreateInstanceConsoleConnectionDetails(),
exclude_attributes=None)
module.exit_json(**result)
def main():
module_args = oci_utils.get_taggable_arg_spec(supports_create=True,
supports_wait=True)
module_args.update(
dict(instance_id=dict(type='str', required=False),
name=dict(type='str', required=False, aliases=['display_name']),
instance_console_history_id=dict(type='str',
required=False,
aliases=['id']),
state=dict(type='str',
required=False,
default='present',
choices=['absent', 'present'])))
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=False,
mutually_exclusive=['console_history_id', 'instance_id'],
required_if=[('state', 'absent', ['instance_console_history_id'])])
if not HAS_OCI_PY_SDK:
module.fail_json(msg='oci python sdk required for this module.')
compute_client = oci_utils.create_service_client(module, ComputeClient)
state = module.params['state']
if state == 'absent':
result = delete_console_history(compute_client, module)
else:
console_history_id = module.params['instance_console_history_id']
if console_history_id is not None:
# Update service gateway details.
result = update_console_history(compute_client, module)
else:
instance_id = module.params['instance_id']
kwargs_list = {
'instance_id':
instance_id,
'compartment_id':
_get_compartment_of_instance(compute_client, instance_id)
}
result = oci_utils.check_and_create_resource(
resource_type='console_history',
create_fn=capture_console_history,
kwargs_create={
'compute_client': compute_client,
'module': module
},
list_fn=compute_client.list_console_histories,
kwargs_list=kwargs_list,
module=module,
model=CaptureConsoleHistoryDetails())
module.exit_json(**result)
def main():
module_args = oci_utils.get_taggable_arg_spec(supports_wait=True)
module_args.update(
dict(
compartment_id=dict(type="str", required=False),
description=dict(type="str", required=False),
name=dict(type="str", required=False),
policy_document=dict(type="str", required=False),
policy_id=dict(type="str", required=False, aliases=["id"]),
state=dict(
type="str",
required=False,
default="present",
choices=["absent", "present"],
),
statements=dict(type="list", required=False),
version_date=dict(type="datetime", required=False),
))
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=False,
mutually_exclusive=[["policy_document", "statements"]],
required_if=[["state", "absent", ["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)
state = module.params["state"]
policy_id = module.params["policy_id"]
exclude_attributes = {"version_date": True}
if state == "absent":
result = delete_policy(identity_client, module)
else:
if policy_id is not None:
result = update_policy(identity_client, module)
else:
result = oci_utils.check_and_create_resource(
resource_type="policy",
create_fn=create_policy,
kwargs_create={
"identity_client": identity_client,
"module": module
},
list_fn=identity_client.list_policies,
kwargs_list={
"compartment_id": module.params["compartment_id"]
},
module=module,
model=CreatePolicyDetails(),
exclude_attributes=exclude_attributes,
)
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():
module_args = oci_utils.get_taggable_arg_spec(supports_create=True,
supports_wait=True)
module_args.update(
dict(
block_traffic=dict(type="bool", required=False, default=False),
vcn_id=dict(type="str", required=False),
compartment_id=dict(type="str", required=False),
display_name=dict(type="str", required=False, aliases=["name"]),
state=dict(
type="str",
required=False,
default="present",
choices=["absent", "present"],
),
nat_gateway_id=dict(type="str", required=False, aliases=["id"]),
))
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=False,
required_if=[("state", "absent", ["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)
exclude_attributes = {"display_name": True}
state = module.params["state"]
if state == "absent":
result = delete_nat_gateway(virtual_network_client, module)
else:
if module.params["nat_gateway_id"] is not None:
result = update_nat_gateway(virtual_network_client, module)
else:
result = oci_utils.check_and_create_resource(
resource_type="nat_gateway",
create_fn=create_nat_gateway,
kwargs_create={
"virtual_network_client": virtual_network_client,
"module": module,
},
list_fn=virtual_network_client.list_nat_gateways,
kwargs_list={
"compartment_id": module.params["compartment_id"],
"vcn_id": module.params["vcn_id"],
},
module=module,
model=CreateNatGatewayDetails(),
exclude_attributes=exclude_attributes,
)
module.exit_json(**result)
def main():
module_args = oci_utils.get_taggable_arg_spec()
module_args.update(
dict(hostname_label=dict(type='str', required=False),
ip_address=dict(type='str', required=False),
display_name=dict(type='str', required=False, aliases=['name']),
vnic_id=dict(type='str', required=False),
state=dict(type='str',
required=False,
default='present',
choices=['absent', 'present']),
private_ip_id=dict(type='str', required=False, aliases=['id'])))
module = AnsibleModule(argument_spec=module_args,
supports_check_mode=False,
required_if=[('state', 'absent', ['private_ip_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)
state = module.params['state']
private_ip_id = module.params['private_ip_id']
if state == 'absent':
result = delete_private_ip(virtual_network_client, module)
else:
if private_ip_id is not None:
result = update_private_ip(virtual_network_client, module)
else:
# Exclude ip_address & display_name when matching private_ips if they are not explicitly specified by user.
exclude_attributes = {'display_name': True, 'ip_address': True}
subnet_id = oci_utils.call_with_backoff(
virtual_network_client.get_vnic,
vnic_id=module.params['vnic_id']).data.subnet_id
result = oci_utils.check_and_create_resource(
resource_type='private_ip',
create_fn=create_private_ip,
kwargs_create={
'virtual_network_client': virtual_network_client,
'module': module
},
list_fn=virtual_network_client.list_private_ips,
kwargs_list={
"vnic_id": module.params['vnic_id'],
"subnet_id": subnet_id
},
module=module,
model=CreatePrivateIpDetails(),
exclude_attributes=exclude_attributes)
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():
module_args = oci_utils.get_taggable_arg_spec(supports_create=True,
supports_wait=True)
module_args.update(
dict(compartment_id=dict(type='str', required=False),
display_name=dict(type='str', required=False, aliases=['name']),
state=dict(type='str',
required=False,
default='present',
choices=['absent', 'present']),
ipsc_id=dict(type='str', required=False, aliases=['id']),
cpe_id=dict(type='str', required=False),
drg_id=dict(type='str', required=False),
static_routes=dict(type='list', required=False)))
module = AnsibleModule(argument_spec=module_args,
supports_check_mode=False,
required_if=[('state', 'absent', ['ipsc_id'])])
if not HAS_OCI_PY_SDK:
module.fail_json(msg='oci python sdk required for this module.')
virtual_network_client = oci_utils.create_service_client(
module, VirtualNetworkClient)
exclude_attributes = {'display_name': True}
state = module.params['state']
if state == 'absent':
result = delete_ip_sec_connection(virtual_network_client, module)
else:
ip_sec_connection_id = module.params['ipsc_id']
if ip_sec_connection_id is not None:
result = update_ip_sec_connection(virtual_network_client, module)
else:
result = oci_utils.check_and_create_resource(
resource_type='ip_sec_connection',
create_fn=create_ip_sec_connection,
kwargs_create={
'virtual_network_client': virtual_network_client,
'module': module
},
list_fn=virtual_network_client.list_ip_sec_connections,
kwargs_list={
'compartment_id': module.params['compartment_id'],
'drg_id': module.params['drg_id'],
'cpe_id': module.params['cpe_id']
},
module=module,
model=CreateIPSecConnectionDetails(),
exclude_attributes=exclude_attributes)
module.exit_json(**result)
def main():
module_args = oci_utils.get_taggable_arg_spec(supports_create=True,
supports_wait=True)
module_args.update(
dict(cidr_block=dict(type='str', required=False),
compartment_id=dict(type='str', required=False),
display_name=dict(type='str', required=False, aliases=['name']),
dns_label=dict(type='str', required=False),
state=dict(type='str',
required=False,
default='present',
choices=['absent', 'present']),
vcn_id=dict(type='str', required=False, aliases=['id'])))
module = AnsibleModule(argument_spec=module_args,
supports_check_mode=False,
mutually_exclusive=[['compartment_id', 'vcn_id']])
if not HAS_OCI_PY_SDK:
module.fail_json(msg='oci python sdk required for this module.')
config = oci_utils.get_oci_config(module)
virtual_network_client = VirtualNetworkClient(config)
exclude_attributes = {'display_name': True, 'dns_label': True}
state = module.params['state']
vcn_id = module.params['vcn_id']
if state == 'absent':
if vcn_id is not None:
result = delete_vcn(virtual_network_client, module)
else:
module.fail_json(
msg="Specify vcn_id with state as 'absent' to delete a VCN.")
else:
if vcn_id is not None:
result = update_vcn(virtual_network_client, module)
else:
result = oci_utils.check_and_create_resource(
resource_type='vcn',
create_fn=create_vcn,
kwargs_create={
'virtual_network_client': virtual_network_client,
'module': module
},
list_fn=virtual_network_client.list_vcns,
kwargs_list={
'compartment_id': module.params['compartment_id']
},
module=module,
model=CreateVcnDetails(),
exclude_attributes=exclude_attributes)
module.exit_json(**result)
def main():
module_args = oci_utils.get_taggable_arg_spec(supports_create=True,
supports_wait=True)
module_args.update(
dict(availability_domain=dict(type='str', required=False),
compartment_id=dict(type='str', required=False),
volume_group_id=dict(type='str', required=False, aliases=['id']),
display_name=dict(type='str', required=False, aliases=['name']),
state=dict(type='str',
required=False,
default='present',
choices=['absent', 'present']),
volume_ids=dict(type='list', required=False),
source_details=dict(type='dict', required=False)))
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=False,
required_if=[['state', 'absent', ['volume_group_id']]],
mutually_exclusive=[['volume_ids', 'source_details']])
if not HAS_OCI_PY_SDK:
module.fail_json(msg='oci python sdk required for this module.')
block_storage_client = oci_utils.create_service_client(
module, BlockstorageClient)
state = module.params['state']
volume_group_id = module.params['volume_group_id']
if state == 'absent':
result = handle_delete_volume_group(block_storage_client, module)
else:
if volume_group_id is None:
result = oci_utils.check_and_create_resource(
resource_type='volume_group',
create_fn=handle_create_volume_group,
kwargs_create={
'block_storage_client': block_storage_client,
'module': module
},
list_fn=block_storage_client.list_volume_groups,
kwargs_list={
'compartment_id': module.params['compartment_id'],
'availability_domain': module.params['availability_domain']
},
module=module,
model=CreateVolumeGroupDetails())
else:
result = handle_update_volume_group(block_storage_client, module)
module.exit_json(**result)
def main():
module_args = oci_utils.get_taggable_arg_spec(supports_wait=True)
module_args.update(
dict(compartment_id=dict(type='str', required=False),
description=dict(type='str', required=False),
name=dict(type='str', required=False),
policy_document=dict(type='str', required=False),
policy_id=dict(type='str', required=False, aliases=['id']),
state=dict(type='str',
required=False,
default='present',
choices=['absent', 'present']),
statements=dict(type='list', required=False),
version_date=dict(type='datetime', required=False)))
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=False,
mutually_exclusive=[['policy_document', 'statements']],
required_if=[['state', 'absent', ['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)
state = module.params['state']
policy_id = module.params['policy_id']
exclude_attributes = {'version_date': True}
if state == 'absent':
result = delete_policy(identity_client, module)
else:
if policy_id is not None:
result = update_policy(identity_client, module)
else:
result = oci_utils.check_and_create_resource(
resource_type='policy',
create_fn=create_policy,
kwargs_create={
'identity_client': identity_client,
'module': module
},
list_fn=identity_client.list_policies,
kwargs_list={
"compartment_id": module.params['compartment_id']
},
module=module,
model=CreatePolicyDetails(),
exclude_attributes=exclude_attributes)
module.exit_json(**result)
def main():
logger = oci_utils.get_logger("oci_bucket")
set_logger(logger)
module_args = oci_utils.get_taggable_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", "ObjectReadWithoutList"
],
),
metadata=dict(type="dict", default={}),
state=dict(
type="str",
required=False,
default="present",
choices=["present", "absent"],
),
storage_tier=dict(
type="str",
required=False,
default="Standard",
choices=["Standard", "Archive"],
),
kms_key_id=dict(type="str", required=False),
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_taggable_arg_spec(supports_wait=True)
module_args.update(
dict(compartment_id=dict(type='str', required=False),
description=dict(type='str', required=False),
matching_rule=dict(type='str', required=False),
name=dict(type='str', required=False),
state=dict(type='str',
required=False,
default='present',
choices=['absent', 'present']),
dynamic_group_id=dict(type='str', required=False,
aliases=['id'])))
module = AnsibleModule(argument_spec=module_args,
supports_check_mode=False,
required_if=[('state', 'absent',
['dynamic_group_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']
dynamic_group_id = module.params['dynamic_group_id']
if state == 'absent':
result = delete_dynamic_group(identity_client, module)
else:
if dynamic_group_id is not None:
result = update_dynamic_group(identity_client, module)
else:
result = oci_utils.check_and_create_resource(
resource_type='dynamic_group',
create_fn=create_dynamic_group,
kwargs_create={
'identity_client': identity_client,
'module': module
},
list_fn=identity_client.list_dynamic_groups,
kwargs_list={
"compartment_id": module.params['compartment_id']
},
module=module,
model=CreateDynamicGroupDetails(),
)
module.exit_json(**result)
def main():
logger = oci_utils.get_logger("oci_autonomous_database")
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_database_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_database(db_client, module)
elif state == 'absent':
result = delete_autonomous_database(db_client, module)
elif state == 'restore':
result = restore_autonomous_database(db_client, module)
else:
result = start_or_stop_autonomous_database(db_client, module)
module.exit_json(**result)
def main():
module_args = oci_utils.get_taggable_arg_spec(supports_wait=True)
module_args.update(
dict(
name=dict(type="str", required=False),
user_id=dict(type="str", required=False, aliases=["id"]),
description=dict(type="str", required=False, default=""),
user_groups=dict(type="list", required=False),
blocked=dict(type="str", required=False, choices=["yes", "no"]),
create_or_reset_ui_password=dict(type="bool",
required=False,
default=False),
state=dict(
type="str",
required=False,
default="present",
choices=["present", "absent"],
),
purge_group_memberships=dict(type="bool",
required=False,
default=False),
delete_group_memberships=dict(type="bool",
required=False,
default=False),
force=dict(type="bool", required=False, default=False),
))
module = AnsibleModule(
argument_spec=module_args,
mutually_exclusive=[[
"purge_group_memberships", "delete_group_memberships"
]],
)
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)
identity_client = oci_utils.create_service_client(module, IdentityClient)
compartment_id = oci_config["tenancy"]
module.params.update(dict({"compartment_id": compartment_id}))
state = module.params["state"]
if state == "present":
result = create_or_update_user(identity_client, module)
elif state == "absent":
result = delete_user(identity_client, module)
module.exit_json(**result)
def main():
module_args = oci_utils.get_taggable_arg_spec(supports_wait=True)
module_args.update(
dict(compartment_id=dict(type='str', required=True),
name=dict(type='str', required=False),
description=dict(type='str', required=False),
state=dict(type='str',
required=False,
default='present',
choices=['present'])))
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.')
config = oci_utils.get_oci_config(module)
identity_client = IdentityClient(config)
compartment_id = module.params['compartment_id']
tenancy = None
try:
tenancy = oci_utils.call_with_backoff(identity_client.get_tenancy,
tenancy_id=compartment_id).data
except ServiceError:
pass
# Check if the provided compartment_id is OCID of a tenancy(root compartment). If tenancy OCID is provided, it's
# supposed to be a call to create compartment in the tenancy else it's a call to update compartment.
if tenancy is not None:
result = oci_utils.check_and_create_resource(
resource_type='compartment',
create_fn=create_compartment,
kwargs_create={
'identity_client': identity_client,
'module': module
},
list_fn=identity_client.list_compartments,
kwargs_list={"compartment_id": module.params['compartment_id']},
module=module,
model=CreateCompartmentDetails())
else:
result = update_compartment(identity_client, module)
module.exit_json(**result)
def main():
module_args = oci_utils.get_taggable_arg_spec(supports_create=True,
supports_wait=True)
module_args.update(
dict(
cidr_block=dict(type="str", required=False),
compartment_id=dict(type="str", required=False),
display_name=dict(type="str", required=False, aliases=["name"]),
dns_label=dict(type="str", required=False),
state=dict(
type="str",
required=False,
default="present",
choices=["absent", "present"],
),
vcn_id=dict(type="str", required=False, aliases=["id"]),
))
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=True,
mutually_exclusive=[["compartment_id", "vcn_id"]],
)
if not HAS_OCI_PY_SDK:
module.fail_json(msg="oci python sdk required for this module.")
resource_helper = ResourceHelper(module=module,
resource_type="vcn",
service_client_class=VirtualNetworkClient)
result = dict(changed=False)
if resource_helper.is_delete():
result = resource_helper.delete()
elif resource_helper.is_update():
result = resource_helper.update()
elif resource_helper.is_create():
result = resource_helper.create()
elif resource_helper.is_action():
result = resource_helper.perform_action(module.params.get("state"))
module.exit_json(**result)
def main():
logger = oci_utils.get_logger("oci_load_balancer")
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),
display_name=dict(type="str", required=False, aliases=["name"]),
load_balancer_id=dict(type="str", required=False, aliases=["id"]),
backend_sets=dict(type=dict, required=False),
certificates=dict(type=dict, required=False),
listeners=dict(type=dict, required=False),
hostnames=dict(type=dict, required=False),
shape_name=dict(type="str", required=False),
subnet_ids=dict(type=list, required=False),
path_route_sets=dict(type=dict, required=False),
state=dict(
type="str",
required=False,
default="present",
choices=["present", "absent"],
),
is_private=dict(type="bool", required=False, default=False),
))
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)
state = module.params["state"]
if state == "present":
result = create_or_update_lb(lb_client, module)
elif state == "absent":
result = delete_load_balancer(lb_client, module)
module.exit_json(**result)
def main():
module_args = oci_utils.get_taggable_arg_spec(supports_create=True,
supports_wait=True)
module_args.update(
dict(availability_domain=dict(type='str', required=False),
cidr_block=dict(type='str', required=False),
compartment_id=dict(type='str', required=False),
dhcp_options_id=dict(type='str', required=False),
display_name=dict(type='str', required=False, aliases=['name']),
dns_label=dict(type='str', required=False),
prohibit_public_ip_on_vnic=dict(type='bool',
required=False,
default=False),
route_table_id=dict(type='str', required=False),
security_list_ids=dict(type='list', required=False),
subnet_id=dict(type='str', required=False, aliases=['id']),
state=dict(type='str',
required=False,
default='present',
choices=['absent', 'present']),
vcn_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)
exclude_attributes = {
'display_name': True,
'dns_label': True,
'dhcp_options_id': True
}
state = module.params['state']
subnet_id = module.params['subnet_id']
if state == 'absent':
if subnet_id is not None:
result = delete_subnet(virtual_network_client, module)
else:
module.fail_json(
msg=
"Specify subnet_id with state as 'absent' to delete a subnet.")
else:
if subnet_id is not None:
result = update_subnet(virtual_network_client, module)
else:
vcn = oci_utils.call_with_backoff(
virtual_network_client.get_vcn,
vcn_id=module.params["vcn_id"]).data
default_attribute_values = {
"dhcp_options_id": vcn.default_dhcp_options_id,
"prohibit_public_ip_on_vnic": False,
"route_table_id": vcn.default_route_table_id,
"security_list_ids": [vcn.default_security_list_id]
}
result = oci_utils.check_and_create_resource(
resource_type='subnet',
create_fn=create_subnet,
kwargs_create={
'virtual_network_client': virtual_network_client,
'module': module
},
list_fn=virtual_network_client.list_subnets,
kwargs_list={
'compartment_id': module.params['compartment_id'],
'vcn_id': module.params['vcn_id']
},
module=module,
model=CreateSubnetDetails(),
exclude_attributes=exclude_attributes,
default_attribute_values=default_attribute_values)
module.exit_json(**result)
def main():
module_args = oci_utils.get_taggable_arg_spec(supports_create=True,
supports_wait=True)
module_args.update(
dict(
cidr_block=dict(type="str", required=False),
compartment_id=dict(type="str", required=False),
display_name=dict(type="str", required=False, aliases=["name"]),
dns_label=dict(type="str", required=False),
state=dict(
type="str",
required=False,
default="present",
choices=["absent", "present"],
),
vcn_id=dict(type="str", required=False, aliases=["id"]),
))
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=False,
mutually_exclusive=[["compartment_id", "vcn_id"]],
)
if not HAS_OCI_PY_SDK:
module.fail_json(msg="oci python sdk required for this module.")
virtual_network_client = oci_utils.create_service_client(
module, VirtualNetworkClient)
exclude_attributes = {"display_name": True, "dns_label": True}
state = module.params["state"]
vcn_id = module.params["vcn_id"]
if state == "absent":
if vcn_id is not None:
result = delete_vcn(virtual_network_client, module)
else:
module.fail_json(
msg="Specify vcn_id with state as 'absent' to delete a VCN.")
else:
if vcn_id is not None:
result = update_vcn(virtual_network_client, module)
else:
result = oci_utils.check_and_create_resource(
resource_type="vcn",
create_fn=create_vcn,
kwargs_create={
"virtual_network_client": virtual_network_client,
"module": module,
},
list_fn=virtual_network_client.list_vcns,
kwargs_list={
"compartment_id": module.params["compartment_id"]
},
module=module,
model=CreateVcnDetails(),
exclude_attributes=exclude_attributes,
)
module.exit_json(**result)
def main():
my_logger = oci_utils.get_logger("oci_instance")
set_logger(my_logger)
module_args = oci_utils.get_taggable_arg_spec(
supports_create=True, supports_wait=True
)
module_args.update(
dict(
compartment_id=dict(type="str", required=False),
name=dict(type="str", required=False, aliases=["display_name"]),
image_id=dict(type="str", required=False, aliases=["id"]),
instance_id=dict(type="str", required=False),
image_source_details=dict(type="dict", required=False),
state=dict(
type="str",
required=False,
default="present",
choices=["present", "absent"],
),
launch_mode=dict(
type="str",
required=False,
choices=["NATIVE", "EMULATED", "PARAVIRTUALIZED", "CUSTOM"],
),
)
)
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=False,
mutually_exclusive=[("instance_id", "image_source_details")],
required_if=[("state", "absent", ["image_id"])],
)
if not HAS_OCI_PY_SDK:
module.fail_json(msg="oci python sdk required for this module.")
compute_client = oci_utils.create_service_client(module, ComputeClient)
state = module.params["state"]
result = dict(changed=False)
id = module.params.get("image_id", None)
exclude_attributes = {"display_name": True}
debug("Id is " + str(id))
if id is not None:
image_resp = _get_image_from_id(compute_client, id, module)
if state == "absent":
debug("Delete " + id + " requested")
if image_resp.data is not None:
debug("Deleting " + image_resp.data.id)
result = delete_image(compute_client, id, module)
else:
debug("Image " + id + " already deleted.")
elif state == "present":
display_name = module.params["name"]
current_image = image_resp.data
attrs_equal = oci_utils.are_attrs_equal(
current_image, module, ["display_name", "freeform_tags", "defined_tags"]
)
if not attrs_equal:
result = update_image(compute_client, id, display_name, module)
else:
result = oci_utils.check_and_create_resource(
resource_type="image",
create_fn=create_image,
kwargs_create={"compute_client": compute_client, "module": module},
list_fn=compute_client.list_images,
kwargs_list={"compartment_id": module.params["compartment_id"]},
module=module,
model=CreateImageDetails(),
exclude_attributes=exclude_attributes,
)
module.exit_json(**result)
