def main(): # => Load the default arguments including those specific to the Cohesity Protection Jobs. argument_spec = cohesity_common_argument_spec() argument_spec.update( dict(task_name=dict(type=str), source_db=dict(type=str, required=True), source_server=dict(type=str, required=True), target_db=dict(type=str, required=True), target_server=dict(type=str, required=True), oracle_home=dict(type=str, required=True), oracle_base=dict(type=str, required=True), oracle_data=dict(type=str, required=True), channels=dict(type=str, required=False), control_file=dict(type=str, default=''), redo_log_path=dict(type=str, default=''), audit_path=dict(type=str, default=''), diag_path=dict(type=str, default=''), fra_path=dict(type=str, default=''), fra_size_mb=dict(type=int, default=2048), bct_file=dict(type=str, default=''), log_time=dict(type=str, default=''), clone_app_view=dict(type=bool, default=False), overwrite=dict(type=bool, default=False), no_recovery=dict(type=bool, default=False))) # => Create a new module object module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) global cohesity_client cohesity_client = get_cohesity_client(module) token = get__cohesity_auth__token(module) database_info = search_for_database(token, module) resp = create_recover_job(module, token, database_info) # Check for restore task status. task_id = resp['restoreTask']['performRestoreTaskState']['base']['taskId'] status = check_for_status(module, task_id) if status == False: msg = 'Error occured during task recovery.' module.fail_json(msg=msg) results = dict(changed=True, msg='Successfully created restore task "%s"' % module.params.get('task_name')) module.exit_json(**results)
def main(): # => Load the default arguments including those specific to the Cohesity protection policy. argument_spec = cohesity_common_argument_spec() argument_spec.update( dict( name=dict(type=str, required=True), description=dict(type='str', default=''), state=dict(choices=['present', 'absent'], default='present'), storage_domain=dict(type='str', required=True), qos_policy=dict(type='str', default='Backup Target Low'), protocol=dict(type='str', default='All'), case_insensitive=dict(type='bool', required=True), object_key_pattern=dict(type='str', required=False), inline_dedupe_compression=dict(type='bool', default=False), security=dict(type='dict', required=False), quota=dict(type='dict', required=False), nfs_options=dict(type='dict', required=False), smb_options=dict(type='dict', required=False) ) ) # => Create a new module object module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) results = dict( changed=False, msg="Attempting to manage Cohesity view", state=module.params.get('state') ) global cohesity_client base_controller = BaseController() base_controller.global_headers['user-agent'] = 'cohesity-ansible/v2.3.4' cohesity_client = get_cohesity_client(module) view_exists, view_details = get_view_details(module) if module.check_mode: check_mode_results = dict( changed=False, msg="Check Mode: Cohesity view doesn't exist", name="" ) if module.params.get('state') == "present": if view_exists: check_mode_results['msg'] =\ "Check Mode: Cohesity view is updated." check_mode_results['name'] = view_details.name check_mode_results['changed'] = True else: check_mode_results['msg'] =\ "Check Mode: Cohesity view doesn't exist." \ " This action would create a new Cohesity view" check_mode_results['changed'] = True else: if view_exists: check_mode_results['msg'] =\ "Check Mode: Cohesity view is present." \ "This action would delete the view." check_mode_results['name'] = view_details.name check_mode_results['changed'] = True else: check_mode_results['msg'] =\ "Check Mode: Cohesity view doesn't exist. No changes." module.exit_json(**check_mode_results) elif module.params.get('state') == "present": if view_exists: update_view(module) else: create_view(module) elif module.params.get('state') == "absent": if view_exists: delete_view(module) results = dict( changed=True, msg="Cohesity view is deleted successfully", view_name=module.params.get('name') ) else: results = dict( changed=False, msg="Cohesity view doesn't exist", view_name=module.params.get('name') ) else: module.fail_json(msg="Invalid State selected: {}".format( module.params.get('state')), changed=False) module.exit_json(**results)
def main(): # => Load the default arguments including those specific to the Cohesity Protection Jobs. argument_spec = cohesity_common_argument_spec() argument_spec.update( dict( name=dict(type='str', required=True), state=dict(choices=['present', 'absent', 'started', 'stopped'], default='present'), endpoint=dict(type='str', required=True), restore_to_source=dict(type='str', default=''), job_name=dict(type='str', default=''), backup_id=dict(type='int'), backup_timestamp=dict(type='str'), # => Currently, the only supported environments types are list in the choices # => For future enhancements, the below list should be consulted. # => 'SQL', 'View', 'Puppeteer', 'Pure', 'Netapp', 'HyperV', 'Acropolis', 'Azure' environment=dict(choices=['VMware'], default='VMware'), vm_names=dict(type='list'), wait_for_job=dict(type='bool', default=True), wait_minutes=dict(type='str', default=20), datastore_id=dict(type='int'), datastore_name=dict(type='str', default=''), datastore_folder_id=dict(type='int'), interface_group_name=dict(type='str'), network_connected=dict(type='bool', default=True), network_id=dict(type='int'), network_name=dict(type='str'), power_state=dict(type='bool', default=True), prefix=dict(type='str'), resource_pool_id=dict(type='int'), resource_pool_name=dict(type='str', default=''), recovery_process_type=dict(type='str', default='InstantRecovery'), suffix=dict(type='str'), vm_folder_id=dict(type='int'), vm_folder_name=dict(type='str'))) # => Create a new module object module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) results = dict(changed=False, msg="Attempting to manage Protection Source", state=module.params.get('state')) job_details = dict( token=get__cohesity_auth__token(module), endpoint=module.params.get('endpoint'), job_name=module.params.get('job_name'), environment=module.params.get('environment'), ) if module.params.get('job_name'): job_details['name'] = module.params.get( 'job_name') + ": " + module.params.get('name') else: job_details['name'] = module.params.get('name') if module.params.get('backup_id'): job_details['jobRunId'] = module.params.get('backup_id') if module.params.get('backup_timestamp'): job_details['backup_timestamp'] = module.params.get('backup_timestamp') job_exists = check__protection_restore__exists(module, job_details) if module.check_mode: check_mode_results = dict( changed=False, msg= "Check Mode: Cohesity Protection Restore Job is not currently registered", id="") if module.params.get('state') == "present": if job_exists: check_mode_results[ 'msg'] = "Check Mode: Cohesity Protection Restore Job is currently registered. No changes" else: check_mode_results[ 'msg'] = "Check Mode: Cohesity Protection Restore Job is not currently registered. This action would register the Cohesity Protection Job." check_mode_results['id'] = job_exists else: if job_exists: check_mode_results[ 'msg'] = "Check Mode: Cohesity Protection Restore Job is currently registered. This action would unregister the Cohesity Protection Job." check_mode_results['id'] = job_exists else: check_mode_results[ 'msg'] = "Check Mode: Cohesity Protection Restore Job is not currently registered. No changes." module.exit_json(**check_mode_results) elif module.params.get('state') == "present": if job_exists: results = dict(changed=False, msg="The Restore Job for is already registered", id=job_exists, name=job_details['name']) else: # check__mandatory__params(module) environment = module.params.get('environment') response = [] if environment == "VMware": job_details['vm_names'] = module.params.get('vm_names') source_object_info = get_snapshot_information_for_vmname( module, job_details) restore_data = dict( name=job_details['name'], vm_names=module.params.get('vm_names'), objects=source_object_info, token=job_details['token'], type="kRecoverVMs", vmwareParameters=dict( poweredOn=module.params.get('power_state'), disableNetwork=module.params.get('network_connected'), recoveryProcessType='k' + module.params.get('recovery_process_type'))) if module.params.get('prefix'): restore_data['vmwareParameters'][ 'prefix'] = module.params.get('prefix') if module.params.get('suffix'): restore_data['vmwareParameters'][ 'suffix'] = module.params.get('suffix') if module.params.get('interface_group_name'): iface_group = module.params.get('interface_group_name') # Check the group exist in the cluster. cohesity_client = get_cohesity_client(module) vlans = cohesity_client.vlan.get_vlans() for vlan in vlans: if vlan.iface_group_name == iface_group: restore_data['vlanParameters'] = dict( interfaceName=iface_group, disableVlan=True) break if restore_data.get('vlanParameters', None) == None: module.fail_json( msg="Failed to find Inferface Group with name %s" % iface_group, changed=False) if module.params.get('restore_to_source'): datastore_id = module.params.get('datastore_id') resource_pool_id = module.params.get('resource_pool_id') restore_to_source_details = get_source_details( module, True) restore_to_source_objects = get_vmware_source_objects( module, restore_to_source_details['id']) if (module.params.get('resource_pool_id') or module.params.get('resource_pool_name')) and\ (module.params.get('datastore_id') or module.params.get('datastore_name')): if module.params.get('resource_pool_name'): resource_pool_id =\ get_vmware_object_id(restore_to_source_objects, module.params.get('resource_pool_name'), 'kResourcePool') if module.params.get('datastore_name'): datastore_id = get_vmware_object_id( restore_to_source_objects, module.params.get('datastore_name'), 'kDatastore') if not datastore_id or not resource_pool_id: module.fail_json( msg="Failed to find the resource pool" " or datastore on the target source") restore_data[ 'newParentId'] = restore_to_source_details['id'] restore_data['vmwareParameters'][ 'resourcePoolId'] = resource_pool_id restore_data['vmwareParameters'][ 'datastoreId'] = datastore_id # => Optional VMware Parameters if module.params.get('datastore_folder_id'): restore_data['vmwareParameters'][ 'datastoreFolderId'] = module.params.get( 'datastore_folder_id') if module.params.get('network_id'): restore_data['vmwareParameters'][ 'networkId'] = module.params.get('network_id') if module.params.get('network_name'): network_name = module.params.get('network_name') network_id = get_vmware_object_id( restore_to_source_objects, network_name, 'kNetwork') if not network_id: module.fail_json( msg="Failed to find network with name %s" % network_name, changed=False) restore_data['vmwareParameters'][ 'networkId'] = network_id if module.params.get('vm_folder_id'): restore_data['vmwareParameters'][ 'vmFolderId'] = module.params.get( 'vm_folder_id') if module.params.get('vm_folder_name'): vm_folder_name = module.params.get( 'vm_folder_name') vm_folder_id = get_vmware_object_id( restore_to_source_objects, vm_folder_name, 'kFolder') if not vm_folder_id: module.fail_json( msg="Failed to find folder with name %s" % vm_folder_name, changed=False) restore_data['vmwareParameters'][ 'vmFolderId'] = vm_folder_id else: module.fail_json( msg="The resource pool and datastore details are" " required for restoring to a new location") # => Start the Virtual Machine Restore operation job_start = start_restore__vms(module, restore_data) job_start['vm_names'] = job_details['vm_names'] response.append(job_start) else: # => This error should never happen based on the set assigned to the parameter. # => However, in case, we should raise an appropriate error. module.fail_json( msg="Invalid Environment Type selected: {0}".format( module.params.get('environment')), changed=False) task = dict(changed=False) for jobCheck in response: restore_data['id'] = jobCheck['id'] restore_data['environment'] = environment if module.params.get('wait_for_job'): task = wait_restore_complete(module, restore_data) jobCheck['status'] = task['status'] results = dict(changed=True, msg="Registration of Cohesity Restore Job Complete", name=module.params.get('job_name') + ": " + module.params.get('name'), restore_jobs=response) if not task['changed'] and module.params.get('wait_for_job'): # => If the task failed to complete, then the key 'changed' will be False and # => we need to fail the module. results['changed'] = False results.pop('msg') errorCode = "" # => Set the errorCode to match the task['error'] if the key exists if 'error' in task: errorCode = task['error'] module.fail_json(msg="Cohesity Restore Job Failed to complete", error=errorCode, **results) elif module.params.get('state') == "absent": results = dict( changed=False, msg= "Cohesity Restore: This feature (absent) has not be implemented yet.", name=module.params.get('job_name') + ": " + module.params.get('name')) else: # => This error should never happen based on the set assigned to the parameter. # => However, in case, we should raise an appropriate error. module.fail_json(msg="Invalid State selected: {}".format( module.params.get('state')), changed=False) module.exit_json(**results)
def main(): # => Load the default arguments including those specific to the Cohesity clone task. argument_spec = cohesity_common_argument_spec() argument_spec.update( dict(name=dict(type='str', required=True), state=dict(choices=['present', 'absent'], default='present'), job_name=dict(type='str', required=True), view_name=dict(type='str', required=True), backup_timestamp=dict(type='str', default=''), environment=dict(choices=['VMware'], default='VMware'), vm_names=dict(type='list', required=True), wait_for_job=dict(type='bool', default=True), prefix=dict(type='str', default=""), suffix=dict(type='str', default=""), power_on=dict(type='bool', default=True), network_connected=dict(type='bool', default=True), wait_minutes=dict(type=int, default=30), resource_pool=dict(type='str', required=True))) # => Create a new module object module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) results = dict(changed=False, msg="Attempting to manage Cohesity Clone", state=module.params.get('state')) global cohesity_client base_controller = BaseController() base_controller.global_headers['user-agent'] = 'cohesity-ansible/v2.3.4' cohesity_client = get_cohesity_client(module) clone_exists, clone_details = get_clone_task(module, False) if module.check_mode: check_mode_results = dict( changed=False, msg="Check Mode: Cohesity clone task doesn't exist", id="") if module.params.get('state') == "present": if clone_exists: check_mode_results['msg'] =\ "Check Mode: Cohesity clone task is already present. No changes" check_mode_results['id'] = clone_details.id else: check_mode_results['msg'] =\ "Check Mode: Cohesity clone task doesn't exist. This action would clone VMs" check_mode_results['changed'] = True else: if clone_exists: check_mode_results['msg'] =\ "Check Mode: Cohesity clone task is present." \ "This action would tear down the Cohesity Clone." check_mode_results['id'] = clone_details.id check_mode_results['changed'] = True else: check_mode_results['msg'] =\ "Check Mode: Cohesity Clone task doesn't exist. No changes." module.exit_json(**check_mode_results) elif module.params.get('state') == "present": if clone_exists: results = dict( changed=False, msg="The clone task with specified name is already present", id=clone_details.id, name=module.params.get('name')) else: clone_vm(module) elif module.params.get('state') == "absent": if clone_exists: destroy_clone(module, clone_details.id) results = dict(changed=True, msg="Cohesity clone is destroyed", id=clone_details.id, task_name=module.params.get('name')) else: results = dict(changed=False, msg="Cohesity clone task doesn't exist", task_name=module.params.get('name')) else: module.fail_json(msg="Invalid State selected: {}".format( module.params.get('state')), changed=False) module.exit_json(**results)
def main(): # => Load the default arguments including those specific to the Cohesity Agent. argument_spec = cohesity_common_argument_spec() argument_spec.update( dict(state=dict(choices=['present', 'absent'], default='present'), endpoint=dict(type='str', required=True), force_register=dict(default=False, type='bool'), db_username=dict(default='', type='str'), db_password=dict(default='', type='str'))) # => Create a new module object module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) global cohesity_client cohesity_client = get_cohesity_client(module) results = dict(changed=False, msg='Attempting to manage Protection Source', state=module.params.get('state')) # Check the endpoint is already registred as a Physical source. prot_sources = dict(token=get__cohesity_auth__token(module), endpoint=module.params.get('endpoint'), environment='kPhysical') current_status = get__protection_source_registration__status( module, prot_sources) if module.check_mode: prot_sources['environment'] = 'kOracle' current_status = get__protection_source_registration__status( module, prot_sources) check_mode_results = dict( changed=False, msg= 'Check Mode: Cohesity Protection Source is not currently registered', id='') if module.params.get('state') == 'present': if current_status: check_mode_results[ 'msg'] = 'Check Mode: Cohesity Protection Source is currently registered. No changes' else: check_mode_results[ 'msg'] = 'Check Mode: Cohesity Protection Source is not currently registered. This action would register the Protection Source.' check_mode_results['id'] = current_status else: if current_status: check_mode_results[ 'msg'] = 'Check Mode: Cohesity Protection Source is currently registered. This action would unregister the Protection Source.' check_mode_results['id'] = current_status else: check_mode_results[ 'msg'] = 'Check Mode: Cohesity Protection Source is not currently registered. No changes.' module.exit_json(**check_mode_results) elif module.params.get('state') == 'present': if current_status: prot_sources = dict(token=get__cohesity_auth__token(module), endpoint=module.params.get('endpoint'), environment='kOracle') oracle_status = get__protection_source_registration__status( module, prot_sources) if not oracle_status: resp = register_oracle_source(module, prot_sources, current_status) if resp == True: results = dict( changed=True, msg= 'Registration of Cohesity Protection Source Complete') else: results = dict( changed=False, msg='Error while registering Cohesity Protection Source' ) else: results = dict( changed=False, msg= 'The Protection Source for this host is already registered', id=current_status, endpoint=module.params.get('endpoint')) else: sleep_count = 0 # Register the endpoint as Physical source first. response = register_source(module, prot_sources) # Wait until Physical source is successfully registered. while sleep_count < 5: sleep_count += 1 status = get__protection_source_registration__status( module, dict(environment='kPhysical', token=prot_sources['token'], endpoint=prot_sources['endpoint'])) time.sleep(10) if status == False: module.fail_json( changed=False, msg= 'Error while registering Cohesity Physical Protection Source' ) response = register_oracle_source(module, prot_sources, response.id) if response == True: results = dict( changed=True, msg='Registration of Cohesity Protection Source Complete') else: results = dict( changed=False, msg='Error while registering Cohesity Protection Source') elif module.params.get('state') == 'absent': if current_status: response = unregister_source(module, current_status) results = dict( changed=True, msg='Unregistration of Cohesity Protection Source Complete', id=current_status, endpoint=module.params.get('endpoint')) else: results = dict( changed=False, msg= 'The Protection Source for this host is currently not registered' ) else: # => This error should never happen based on the set assigned to the parameter. # => However, in case, we should raise an appropriate error. module.fail_json(msg='Invalid State selected: {0}'.format( module.params.get('state')), changed=False) module.exit_json(**results)
def main(): # => Load the default arguments including those specific to the Cohesity Protection Jobs. argument_spec = cohesity_common_argument_spec() argument_spec.update( dict( state=dict(choices=['present', 'absent'], default='present'), name=dict(type='str', required=True), # => Currently, the only supported environments types are list in the choices # => For future enhancements, the below list should be consulted. # => 'SQL', 'View', 'Puppeteer', 'Pure', 'Netapp', 'HyperV', 'Acropolis', 'Azure' environment=dict(type='str', default='VMware'), job_name=dict(type='str', required=True), endpoint=dict(type='str', required=True), backup_timestamp=dict(type='str', default=''), file_names=dict(type='list', required=True), wait_for_job=dict(type='bool', default=True), overwrite=dict(type='bool', default=True), preserve_attributes=dict(type='bool', default=True), restore_location=dict(type='str', default=''), vm_name=dict(type='str', default=''), vm_username=dict(type='str', default=''), vm_password=dict(type='str', default='', no_log=True), wait_minutes=dict(type='str', default=10))) # => Create a new module object module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) results = dict(changed=False, msg="Attempting to manage Protection Source", state=module.params.get('state')) job_details = dict(token=get__cohesity_auth__token(module), endpoint=module.params.get('endpoint'), job_name=module.params.get('job_name'), environment=module.params.get('environment'), name=module.params.get('job_name') + ": " + module.params.get('name')) global cohesity_client base_controller = BaseController() base_controller.global_headers['user-agent'] = 'Ansible-v2.3.4' cohesity_client = get_cohesity_client(module) if module.params.get('backup_id'): job_details['jobRunId'] = module.params.get('backup_id') if module.params.get('backup_timestamp'): job_details['backup_timestamp'] = module.params.get('backup_timestamp') job_exists = check__protection_restore__exists(module, job_details) if module.check_mode: check_mode_results = dict( changed=False, msg= "Check Mode: Cohesity Protection Restore Job is not currently registered", id="") if module.params.get('state') == "present": if job_exists: check_mode_results[ 'msg'] = "Check Mode: Cohesity Protection Restore Job is currently registered. No changes" else: check_mode_results[ 'msg'] = "Check Mode: Cohesity Protection Restore Job is not currently registered. This action would register the Cohesity Protection Job." check_mode_results['id'] = job_exists else: if job_exists: check_mode_results[ 'msg'] = "Check Mode: Cohesity Protection Restore Job is currently registered. This action would unregister the Cohesity Protection Job." check_mode_results['id'] = job_exists else: check_mode_results[ 'msg'] = "Check Mode: Cohesity Protection Restore Job is not currently registered. No changes." module.exit_json(**check_mode_results) elif module.params.get('state') == "present": if job_exists: results = dict(changed=False, msg="The Restore Job for is already registered", id=job_exists, name=module.params.get('job_name') + ": " + module.params.get('name')) else: response = [] environment = module.params.get('environment') endpoint = module.params.get('endpoint') # => Gather the Source Details source_id = None vcenter_list = cohesity_client.protection_sources.list_protection_sources_root_nodes( environment='k' + environment) for vcenter in vcenter_list: if vcenter.protection_source.vmware_protection_source.name == endpoint: source_id = vcenter.protection_source.id if not source_id: module.fail_json( msg="Vcenter '%s' is not registered to the cluster" % endpoint) vm_id = None vm_name = module.params.get("vm_name") restore_file_list = module.params.get('file_names') job_details['endpoint'] = source_id job_details['file_names'] = restore_file_list # Fetch the virtual machine source id, using which files can be searched. objects = cohesity_client.protection_sources.list_virtual_machines( v_center_id=source_id, names=vm_name) for each_object in objects: if each_object.name == vm_name: vm_id = each_object.id break for file_name in job_details['file_names']: resp = cohesity_client.restore_tasks.search_restored_files( environments='kVMware', search=file_name, source_ids=vm_id) # Fail if the file is not available. if not (resp and resp.files): module.fail_json( msg="File '%s' is not available to restore" % file_name) for file_obj in resp.files: if file_obj.filename != file_name and file_obj.protection_source.name != vm_name: module.fail_json( msg= "File '%s' is not available in virtual machine '%s' to restore" % (file_name, vm_name)) source_object_info = dict( jobId=file_obj.job_id, protectionSourceId=file_obj.source_id, environment="kVMware") get__job_information__for_file(module, source_object_info) # For VMware file restore, VM credentials are mandatory. if not (module.params.get('username') or module.params.get('password')): module.fail_json( msg= "Please provide VM credentials to to proceed with restore." ) restore_data = dict(name=module.params.get('job_name') + ": " + module.params.get('name'), filenames=restore_file_list, targetSourceId=vm_id, targetParentSourceId=source_id, sourceObjectInfo=source_object_info, token=job_details['token'], overwrite=module.params.get('overwrite'), username=module.params.get('vm_username'), password=module.params.get('vm_password'), preserveAttributes=module.params.get( 'preserve_attributes')) if module.params.get('restore_location'): restore_data['newBaseDirectory'] = module.params.get( 'restore_location') response.append(start_restore__files(module, restore_data)) task = dict(changed=False) for jobCheck in response: restore_data['id'] = jobCheck['id'] restore_data['environment'] = environment if module.params.get('wait_for_job'): task = wait_restore_complete(module, restore_data) jobCheck['status'] = task['status'] results = dict(changed=True, msg="Registration of Cohesity Restore Job Complete", name=module.params.get('job_name') + ": " + module.params.get('name'), restore_jobs=response) if 'file_names' in job_details: results['filenames'] = job_details['file_names'] if not task['changed'] and module.params.get('wait_for_job'): # => If the task failed to complete, then the key 'changed' will be False and # => we need to fail the module. results['changed'] = False results.pop('msg') errorCode = "" # => Set the errorCode to match the task['error'] if the key exists if 'error' in task: errorCode = task['error'] module.fail_json(msg="Cohesity Restore Job Failed to complete", error=errorCode, **results) elif module.params.get('state') == "absent": results = dict( changed=False, msg= "Cohesity Restore: This feature (absent) has not be implemented yet.", name=module.params.get('job_name') + ": " + module.params.get('name')) else: # => This error should never happen based on the set assigned to the parameter. # => However, in case, we should raise an appropriate error. module.fail_json(msg="Invalid State selected: {}".format( module.params.get('state')), changed=False) module.exit_json(**results)
def main(): # => Load the default arguments including those specific to the Cohesity protection policy. argument_spec = cohesity_common_argument_spec() argument_spec.update( dict(name=dict(type='str', required=True), description=dict(type='str', default=''), state=dict(choices=['present', 'absent'], default='present'), days_to_retain=dict(type=int, default=90), incremental_backup_schedule=dict(type=dict, required=True), full_backup_schedule=dict(type=dict), blackout_window=dict(type=list), retries=dict(type=int, default=3), retry_interval=dict(type=int, default=30), bmr_backup_schedule=dict(type=dict), log_backup_schedule=dict(type=dict), extended_retention=dict(type=list), archival_copy=dict(type=list))) # => Create a new module object module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) results = dict(changed=False, msg="Attempting to manage Cohesity protection policy", state=module.params.get('state')) global cohesity_client base_controller = BaseController() base_controller.global_headers['user-agent'] = 'cohesity-ansible/v2.3.4' cohesity_client = get_cohesity_client(module) policy_exists, policy_details = get_policy_details(module) if module.check_mode: check_mode_results = dict( changed=False, msg="Check Mode: Cohesity protection policy doesn't exist", id="") if module.params.get('state') == "present": if policy_exists: check_mode_results['msg'] =\ "Check Mode: Cohesity protection policy is already present. No changes" check_mode_results['id'] = policy_details.id else: check_mode_results['msg'] =\ "Check Mode: Cohesity protection policy doesn't exist." \ " This action would create a protection policy" check_mode_results['changed'] = True else: if policy_exists: check_mode_results['msg'] =\ "Check Mode: Cohesity protection policy is present." \ "This action would delete the policy." check_mode_results['id'] = policy_details.id check_mode_results['changed'] = True else: check_mode_results['msg'] =\ "Check Mode: Cohesity protection policy doesn't exist. No changes." module.exit_json(**check_mode_results) elif module.params.get('state') == "present": if policy_exists: results = dict( changed=False, msg= "The Cohesity protection policy with specified name is already present", id=policy_details.id, policy_name=module.params.get('name')) else: create_policy(module) elif module.params.get('state') == "absent": if policy_exists: delete_policy(module, policy_details.id) results = dict(changed=True, msg="Cohesity protection policy is deleted", id=policy_details.id, policy_name=module.params.get('name')) else: results = dict(changed=False, msg="Cohesity protection policy doesn't exist", policy_name=module.params.get('name')) else: module.fail_json(msg="Invalid State selected: {}".format( module.params.get('state')), changed=False) module.exit_json(**results)
def main(): # => Load the default arguments including those specific to the Cohesity Protection Jobs. argument_spec = cohesity_common_argument_spec() argument_spec.update( dict( state=dict(choices=['present', 'absent', 'started', 'stopped'], default='present'), name=dict(type='str', required=True, aliases=['job_name']), description=dict(type='str', default=''), environment=dict(default='kOracle'), protection_policy=dict(type='str', aliases=['policy'], default='Bronze'), storage_domain=dict(type='str', default='DefaultStorageDomain'), time_zone=dict(type='str', default=''), start_time=dict(type='str', default=''), delete_backups=dict(type='bool', default=False), ondemand_run_type=dict( choices=['Regular', 'Full', 'Log', 'System'], default='Regular'), cancel_active=dict(type='bool', default=False), validate_certs=dict(type='bool', default=False), endpoint=dict(type=str, default=''), databases=dict(type=list, default=[]), )) # => Create a new module object module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True) if not module.params.get("time_zone"): module.params["time_zone"] = get_timezone() global cohesity_client cohesity_client = get_cohesity_client(module) results = dict(changed=False, msg='Attempting to manage Protection Source', state=module.params.get('state')) job_exists, job_meta_data = check__protection_job__exists(module) if module.check_mode: check_mode_results = dict( changed=False, msg= 'Check Mode: Cohesity Protection Job is not currently registered', id='') if module.params.get('state') == 'present': if job_exists: check_mode_results[ 'msg'] = 'Check Mode: Cohesity Protection Job is currently registered. No changes' else: check_mode_results[ 'msg'] = 'Check Mode: Cohesity Protection Job is not currently registered. This action would register the Cohesity Protection Job.' check_mode_results['id'] = job_exists else: if job_exists: check_mode_results[ 'msg'] = 'Check Mode: Cohesity Protection Job is currently registered. This action would unregister the Cohesity Protection Job.' check_mode_results['id'] = job_exists else: check_mode_results[ 'msg'] = 'Check Mode: Cohesity Protection Job is not currently registered. No changes.' module.exit_json(**check_mode_results) elif module.params.get('state') == 'present': parent_id, source_id = get_source_id_by_endpoint(module) if not (parent_id and source_id): module.fail_json( msg= "Source '%s' is not registered to cluster, Please register the source and try again." % module.params.get('endpoint')) check__mandatory__params(module) body = ProtectionJobRequestBody() body.name = module.params.get('name') body.parent_source_id = source_id body.source_ids = [source_id] body.view_box_id = get__storage_domain_id__by_name(module) body.environment = module.params.get('environment') body.policy_id = get__prot_policy_id__by_name(module) body.timezone = module.params.get('time_zone').strip() body.description = module.params.get('description') databases = module.params.get('databases') if databases: entity_ids = list() application_nodes = [] body.source_special_parameters = list() resp = cohesity_client.protection_sources.list_protection_sources( environment='kOracle', id=parent_id) if not resp: module.fail_json( msg="Oracle source is not available to protect") for node in resp[0].nodes: application_nodes.extend(node.get("applicationNodes", [])) # Make copy of database list and remove once entity id fetched. This check # is to ensure availability of databases in server. copy_database = copy.deepcopy(databases) for database in databases: for node in application_nodes: if node["protectionSource"]["name"] == database.strip(): entity_ids.append(node["protectionSource"]["id"]) copy_database.remove(database) if len(databases) == len(entity_ids): break if copy_database: module.fail_json( "Following list of databases are not available in the " "Oracle Server: %s" % ", ".join(copy_database)) spl_params = SourceSpecialParameter() spl_params.source_id = source_id spl_params.oracle_special_parameters = OracleSpecialParameters() spl_params.oracle_special_parameters.application_entity_ids = entity_ids body.source_special_parameters.append(spl_params) if module.params.get('start_time'): start_time = list(module.params.get('start_time').replace(':', '')) if not len(start_time) == 4: # => There are only so many options here but if we get more characters # => than four then we need to escape quickly. module.fail_json( msg='Invalid start_time selected (' + module.params.get('start_time') + '). Please review and submit the correct Protection Job Starting time.' ) body.start_time = dict(hour=int(start_time[0] + start_time[1]), minute=int(start_time[2] + start_time[3])) try: if job_exists: response = cohesity_client.protection_jobs.update_protection_job( body, job_exists) msg = 'Updation of Cohesity Protection Job Complete' else: response = cohesity_client.protection_jobs.create_protection_job( body) msg = 'Creation of Cohesity Protection Job Complete' response = dict(id=response.id, name=response.name, environment=response.environment) results = dict(changed=True, msg=msg, **response) except APIException as err: module.fail_json(msg=err.message) elif module.params.get('state') == 'absent': if job_exists: job_id = job_meta_data.uid.id status, _, _ = get_protection_run__status__by_id(module, job_id) if status: stop_job(module, job_id) while True: status, _, _ = get_protection_run__status__by_id( module, job_id) if not status: time.sleep(10) break response = unregister_job(module, job_exists) results = dict( changed=True, msg='Unregistration of Cohesity Protection Job Complete', id=job_exists, name=module.params.get('name')) else: results = dict( changed=False, msg= 'The Protection Job for this host is currently not registered', name=module.params.get('name')) elif module.params.get('state') == 'started': if job_exists: response = start_job(module) results = dict( changed=True, msg='The Protection Job for this host has been started', id=job_exists, name=module.params.get('name')) else: results = dict( changed=False, msg= 'The Protection Job for this host is currently not registered', name=module.params.get('name')) elif module.params.get('state') == 'stopped': if job_exists: job_id = job_meta_data.uid.id response = stop_job(module, job_id) results = dict( changed=True, msg='The Protection Job for this host has been stopped', id=job_id, name=module.params.get('name')) else: results = dict( changed=False, msg= 'The Protection Job for this host is currently not registered', name=module.params.get('name')) else: # => This error should never happen based on the set assigned to the parameter. # => However, in case, we should raise an appropriate error. module.fail_json(msg='Invalid State selected: {0}'.format( module.params.get('state')), changed=False) module.exit_json(**results)