def main(): """ Main entry point for Ansible module execution. """ results = {} argument_spec = rubrik_argument_spec # Start Parameters argument_spec.update( dict( server_ip=dict(required=True, type='list'), timeout=dict(required=False, type='int', default=15), ) ) # End Parameters module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=False) if sdk_present is False: module.fail_json(msg="The Rubrik Python SDK is required for this module (pip install rubrik_cdm).") load_provider_variables(module) ansible = module.params try: rubrik = rubrik_cdm.Connect() except SystemExit as error: if "has not been provided" in str(error): try: ansible["node_ip"] ansible["username"] ansible["password"] except KeyError: module.fail_json( msg="Error: The Rubrik login credentials are missing. Verify the correct env vars are present or provide them through the provider param.") else: module.fail_json(msg=str(error)) try: rubrik = rubrik_cdm.Connect(ansible['node_ip'], ansible['username'], ansible['password']) except SystemExit as error: module.fail_json(msg=str(error)) try: api_request = rubrik.configure_dns_servers(ansible["server_ip"], ansible["timeout"]) except SystemExit as error: module.fail_json(msg=str(error)) if "No change required" in api_request: results["changed"] = False else: results["changed"] = True results["response"] = api_request module.exit_json(**results)
def main(): """ Main entry point for Ansible module execution. """ results = {} argument_spec = rubrik_argument_spece # Start Parameters argument_spec.update( dict( timeout=dict(required=False, type='int', default=15), ) ) # End Parameters module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=False) ansible = module.params load_provider_variables(module) if not HAS_RUBRIK_SDK: module.fail_json(msg='The Rubrik Python SDK is required for this module (pip install rubrik_cdm).') node_ip, username, password, api_token = credentials(module) try: rubrik = rubrik_cdm.Connect(node_ip, username, password, api_token) except Exception as error: module.fail_json(msg=str(error)) try: rubrik = rubrik_cdm.Connect(node_ip, username, password) except SystemExit as error: module.fail_json(msg=str(error)) ################################## ######### Code Block ############# ################################## ################################## try: api_request = rubrik. except SystemExit as error: module.fail_json(msg=str(error)) if "No change required" in api_request: results["changed"] = False else: results["changed"] = True results["response"] = api_request module.exit_json(**results)
def rotate_access_key(secret, iam_client, iam_username, access_keys): #connect to the rubrik cluster for this secret rubrik_cred = ast.literal_eval(secrets_client.get_secret_value(SecretId=secret['ARN'])['SecretString']) rubrik = rubrik_cdm.Connect(rubrik_cred['rubrik_ip'], rubrik_cred['rubrik_user'], rubrik_cred['rubrik_password']) #find the archive that matches our secret archive = get_archive_in_scope(rubrik, rubrik_cred, access_keys['current_access_key']) #tidy up the depricated access key if we have an archive match and an existing depricated key if access_keys['depricated_access_key'] is not None and archive is not None: log_cloudwatch('rotate_access_key - found matching archive and depricated access key, deleting depricated access key') delete_depricated_access_key(iam_client, access_keys['depricated_access_key']) access_keys['depricated_access_key'] = None elif access_keys['depricated_access_key'] is not None and archive is None: log_cloudwatch('rotate_access_key - found depricated access key but no matching archive on cluster \'{}\', skipping deletion of depricated access key'.format(rubrik_cred['rubrik_ip'])) #check to see if we already have a new access key from this run, if not, create one global new_access_key if new_access_key is None and archive is not None: log_cloudwatch('rotate_access_key - found matching archive and no new access key, creating new access key') new_access_key = create_new_access_key(iam_client, iam_username) log_cloudwatch('rotate_access_key - sleeping for 15 seconds to allow for access key propegation') time.sleep(15) elif new_access_key is not None and archive is not None: log_cloudwatch('rotate_access_key - found matching archive and existing new access key, skipping access key creation') #update the iam credentials used for the matching achive if new_access_key is not None and archive is not None: log_cloudwatch('rotate_access_key - updating archive \'{}\' on \'{}\''.format(archive['definition']['name'], rubrik_cred['rubrik_ip'])) update_response = rubrik.update_aws_s3_cloudout(archive['definition']['name'], aws_access_key=new_access_key['AccessKeyId'], aws_secret_key=new_access_key['SecretAccessKey']) if update_response['definition']['accessKey'] == new_access_key['AccessKeyId']: log_cloudwatch ('rotate_access_key - access key update success for \'{}\' on \'{}\''.format(archive['definition']['name'], rubrik_cred['rubrik_ip'])) elif update_response['definition']['accessKey'] != new_access_key['AccessKeyId']: log_cloudwatch('rotate_access_key - access key update failed for \'{}\' on \'{}\''.format(archive['definition']['name'], rubrik_cred['rubrik_ip'])) return update_response else: return None
def main(): """ Main entry point for Ansible module execution. """ results = {} argument_spec = dict( managed_volume_name=dict(required=True, aliases=['name']), sla_name=dict(required=False, type='str', default="current"), action=dict(required=True, choices=['begin', 'end']), timeout=dict(required=False, type='int', default=15), ) argument_spec.update(rubrik_argument_spec) required_if = [('action', 'end', ['sla_name'])] module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=False) ansible = module.params load_provider_variables(module) if not HAS_RUBRIK_SDK: module.fail_json( msg= 'The Rubrik Python SDK is required for this module (pip install rubrik_cdm).' ) node_ip, username, password, api_token = credentials(module) try: rubrik = rubrik_cdm.Connect(node_ip, username, password, api_token) except Exception as error: module.fail_json(msg=str(error)) if ansible["action"] == "begin": try: api_request = rubrik.begin_managed_volume_snapshot( ansible["managed_volume_name"], ansible["timeout"]) except Exception as error: module.fail_json(msg=str(error)) else: try: api_request = rubrik.end_managed_volume_snapshot( ansible["managed_volume_name"], ansible["sla_name"], ansible["timeout"]) except Exception as error: module.fail_json(msg=str(error)) if "No change required" in api_request: results["changed"] = False else: results["changed"] = True results["response"] = api_request module.exit_json(**results)
def test_logging_output(mocker, caplog): def mock_get_v1_cluster_me_version(): return {'version': '5.0.1-1280'} mock_get = mocker.patch('rubrik_cdm.Connect.get', autospec=True, spec_set=True) mock_get.return_value = mock_get_v1_cluster_me_version() # Manually import rubrik_cdm instead of using the fixture to get proper log # message count and to more easily set logging level rubrik = rubrik_cdm.Connect("10.0.1.1", "user", "password", enable_logging=True) rubrik.cluster_version() assert len(caplog.records) == 4 log_entries = { 0: "Node IP: 10.0.1.1", 1: "Username: user", 2: "Password: ******", 3: "cluster_version: Getting the software version of the Rubrik cluster." } for index, log_message in log_entries.items(): assert caplog.records[index].message == log_message
async def vsphereondemandsnapshot(self, message): """ A skills function to take an on-demand snapshot using the current sla. The parser looks for the message argument. Arguments: message {str} -- take a snapshot of {vmware} {vm} {vm_name} -- take a snapshot of {mssql_db} {db_name} on {sql_instance} on host {sql_host} """ object_type = message.regex.group('object_type') rubrik = rubrik_cdm.Connect() if object_type == 'vmware' or object_type == 'ahv': vm_name = message.regex.group('object_name') snapshot = rubrik.on_demand_snapshot(vm_name, object_type) await message.respond( 'All done! A snapshot of {} has been taken. Response: {}'. format(vm_name, snapshot)) else: db_name = message.regex.group('object_name') sql_db = message.regex.group('object_name') sql_instance = message.regex.group('sql_instance') sql_hostname = message.regex.group('sql_host') sql_host = _hostname_to_text(sql_hostname) snapshot = rubrik.on_demand_snapshot(db_name, object_type, sql_host=sql_host, sql_instance=sql_instance, sql_db=sql_db) await message.respond( 'All done! A snapshot of {} has been taken. Response: {}'. format(db_name, snapshot))
def test_logging_level(mocker, caplog, logging_level): def mock_get_v1_cluster_me_version(): return {'version': '5.0.1-1280'} mock_get = mocker.patch('rubrik_cdm.Connect.get', autospec=True, spec_set=True) mock_get.return_value = mock_get_v1_cluster_me_version() # Manually import rubrik_cdm instead of using the fixture to get proper log # message count and to more easily set logging level rubrik = rubrik_cdm.Connect("10.0.1.1", "user", "password", enable_logging=True, logging_level=logging_level) rubrik.cluster_version() # Validate the logging level set_logging = { "debug": logging.DEBUG, "critical": logging.CRITICAL, "error": logging.ERROR, "warning": logging.WARNING, "info": logging.INFO, } assert caplog.records[0].levelno == set_logging[logging_level]
def ondemandsnapshot(self, msg, vm, sla_domain): response = ':thumbsup: Gotchya - Take an on-demand snap of `' + vm + '`' if sla_domain is None: response = response + '. You didn' 't pass a value for `--sla-domain` so I' 'll just use the one currently assigned' else: response = response + ' using the `' + sla_domain + '` SLA Domain! Let me execute that!' yield response rubrik = rubrik_cdm.Connect(node_ip=self.config['NODE_IP'], api_token=self.config['API_TOKEN']) try: if sla_domain is None: ondemandsnap = rubrik.on_demand_snapshot(object_name=vm, object_type='vmware') else: ondemandsnap = rubrik.on_demand_snapshot(object_name=vm, object_type='vmware', sla_name=sla_domain) yield ':boom: The on-demand snapshot has been submitted! You can monitor querying the API URI `' + ondemandsnap[ 1] + '` if you want. Either way, I' 'll let you know when it has completed' snapshot_status = rubrik.job_status(url=ondemandsnap[1], wait_for_completion=True) yield ':thumbsup: Looks like the on-demand snapshot for `' + vm + '` has completed with a status of ' + snapshot_status[ 'status'] except Exception as e: yield ':x: :eyes: ' + str(e) + ' :eyes:' sys.exit(1)
def softwareversion(self, msg, args): rubrik = rubrik_cdm.Connect(node_ip=self.config['NODE_IP'], api_token=self.config['API_TOKEN'], enable_logging=False) cluster_version = rubrik.cluster_version() returnmessage = ':computer: Your Rubrik cluster is running software version %s' % cluster_version return returnmessage # This string format is markdown.
def main(): """ Main entry point for Ansible module execution. """ results = {} argument_spec = dict( ) argument_spec.update(rubrik_argument_spec) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=False) ansible = module.params load_provider_variables(module) if not HAS_RUBRIK_SDK: module.fail_json(msg='The Rubrik Python SDK is required for this module (pip install rubrik_cdm).') node_ip, username, password = credentials(module) try: rubrik = rubrik_cdm.Connect(node_ip, username, password) except SystemExit as error: module.fail_json(msg=str(error)) try: api_request = rubrik.get_all_vcenters() except SystemExit as error: module.fail_json(msg=str(error)) #fixed module.exit_json(**api_request)
def main(): """ Main entry point for Ansible module execution. """ results = {} argument_spec = dict( vcenter_ip=dict(required=True, type='str'), vcenter_username=dict(required=True, type='str'), vcenter_password=dict(required=True, type='str'), vm_linking=dict(required=False, default=True, type='bool'), ca_certificate=dict(required=False, type='str'), timeout=dict(required=False, type='int', default=30), ) argument_spec.update(rubrik_argument_spec) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=False) ansible = module.params vcenter_ip = ansible["vcenter_ip"] vcenter_username = ansible["vcenter_username"] vcenter_password = ansible["vcenter_password"] vm_linking = ansible["vm_linking"] ca_certificate = ansible["ca_certificate"] timeout = ansible["timeout"] load_provider_variables(module) if not HAS_RUBRIK_SDK: module.fail_json( msg= 'The Rubrik Python SDK is required for this module (pip install rubrik_cdm).' ) node_ip, username, password, api_token = credentials(module) try: rubrik = rubrik_cdm.Connect(node_ip, username, password, api_token) except Exception as error: module.fail_json(msg=str(error)) try: api_request = rubrik.add_vcenter(vcenter_ip, vcenter_username, vcenter_password, vm_linking, ca_certificate, timeout) except Exception as error: module.fail_json(msg=str(error)) if "No change required" in api_request: results["changed"] = False else: results["changed"] = True results["response"] = api_request module.exit_json(**results)
def get_node_status(self): """Gets node statuses from Rubrik CDM""" urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning) rk = rubrik_cdm.Connect(node_ip=self.rubrik_ip, username=self.rubrik_user, password=self.rubrik_pass) rknodes = rk.get('internal', '/node') return (rknodes)
def get_runway(self): """Gets runway remaining metric from Rubrik CDM""" urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning) rk = rubrik_cdm.Connect(node_ip=self.rubrik_ip, username=self.rubrik_user, password=self.rubrik_pass) rkrunway = rk.get('internal', '/stats/runway_remaining')['days'] return (rkrunway)
def get_cluster_storage(self): """Gets cluster storage from Rubrik CDM""" urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning) rk = rubrik_cdm.Connect(node_ip=self.rubrik_ip, username=self.rubrik_user, password=self.rubrik_pass) rkstorage = rk.get('internal', '/stats/system_storage') return (rkstorage)
def main(): """ Main entry point for Ansible module execution. """ results = {} argument_spec = dict( object_name=dict(required=True, type='str'), end_user=dict(required=True, type='str'), object_type=dict(required=False, type='str', default="vmware", choices=['vmware']), timeout=dict(required=False, type='int', default=15), ) argument_spec.update(rubrik_argument_spec) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=False) ansible = module.params load_provider_variables(module) if not HAS_RUBRIK_SDK: module.fail_json( msg= 'The Rubrik Python SDK is required for this module (pip install rubrik_cdm).' ) node_ip, username, password, api_token = credentials(module) try: rubrik = rubrik_cdm.Connect(node_ip, username, password, api_token) except Exception as error: module.fail_json(msg=str(error)) object_name = ansible["object_name"] end_user = ansible["end_user"] object_type = ansible["object_type"] timeout = ansible["timeout"] try: api_request = rubrik.end_user_authorization(object_name, end_user, object_type, timeout) except Exception as error: module.fail_json(msg=str(error)) if "No change required" in api_request: results["changed"] = False else: results["changed"] = True results["response"] = api_request module.exit_json(**results)
def main(): """ Main entry point for Ansible module execution. """ results = {} argument_spec = rubrik_argument_spec # Start Parameters argument_spec.update( dict( hostID=dict(required=True, type='string'), shareType=dict(required=True, type='string'), exportPoint=dict(required=True, type='String'), fileshareusername=dict(required=False, type='string', default="blank"), filesharepassword=dict(required=False, type='string', default="blank"), domain=dict(required=False, type='string', default="blank"), ) ) # End Parameters module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=False) ansible = module.params load_provider_variables(module) if not HAS_RUBRIK_SDK: module.fail_json(msg='The Rubrik Python SDK is required for this module (pip install rubrik_cdm).') try: node_ip, username, password = credentials(module) except ValueError: module.fail_json(msg="The Rubrik login credentials are missing. Verify the correct env vars are present or provide them through the `provider` param.") try: rubrik = rubrik_cdm.Connect(node_ip, username, password) except SystemExit as error: module.fail_json(msg=str(error)) try: api_request = rubrik.new_NasShare(ansible["hostID"], ansible["shareType"], ansible["exportPoint"], ansible["fileshareusername"], ansible["filesharepassword"], ansible["domain"]) except SystemExit as error: module.fail_json(msg=str(error)) if "No change required" in api_request: results["changed"] = False else: results["changed"] = True results["response"] = api_request module.exit_json(**results)
def main(): """ Main entry point for Ansible module execution. """ results = {} argument_spec = dict( hostname=dict(required=True, aliases=['ip_address']), action=dict(required=True, choices=['add', 'delete']), timeout=dict(required=False, type='int', default=120), ) argument_spec.update(rubrik_argument_spec) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=False) ansible = module.params load_provider_variables(module) if not HAS_RUBRIK_SDK: module.fail_json( msg= 'The Rubrik Python SDK is required for this module (pip install rubrik_cdm).' ) node_ip, username, password = credentials(module) try: rubrik = rubrik_cdm.Connect(node_ip, username, password) except SystemExit as error: module.fail_json(msg=str(error)) if ansible["action"] == "add": try: api_request = rubrik.add_physical_host(ansible["hostname"], ansible["timeout"]) except SystemExit as error: module.fail_json(msg=str(error)) else: try: api_request = rubrik.delete_physical_host(ansible["hostname"], ansible["timeout"]) except SystemExit as error: module.fail_json(msg=str(error)) if "No change required" in api_request: results["changed"] = False else: results["changed"] = True results["response"] = api_request module.exit_json(**results)
def get_rubrik_stats(): rubrik = rubrik_cdm.Connect(node_ip=os.environ['RUBRIK_IP'], username=os.environ['RUBRIK_USER'], password=os.environ['RUBRIK_PASS']) stats = rubrik.get('internal', '/stats/system_storage') RUBRIK_TOTAL_STORAGE.set(stats['total']) RUBRIK_USED_STORAGE.set(stats['used']) RUBRIK_AVAILABLE_STORAGE.set(stats['available']) RUBRIK_SNAPSHOT_STORAGE.set(stats['snapshot']) RUBRIK_LIVEMOUNT_STORAGE.set(stats['liveMount']) RUBRIK_MISC_STORAGE.set(stats['miscellaneous'])
def test_secret(secret_service_client, arn, token): """Test the secret This method should validate that the AWSPENDING secret works in the service that the secret belongs to. For example, if the secret is a database credential, this method should validate that the user can login with the password in AWSPENDING and that the user has all of the expected permissions against the database. Args: secret_service_client (client): The secrets manager service client arn (string): The secret ARN or other identifier token (string): The ClientRequestToken associated with the secret version """ # retrieve pending secret pending_secret = ast.literal_eval( secret_service_client.get_secret_value( SecretId=arn, VersionStage="AWSPENDING")['SecretString']) # connect to rubrik api rubrik_credentials = ast.literal_eval( secret_service_client.get_secret_value( SecretId='/rubrik/rubrik_cdm_credentials', VersionStage="AWSCURRENT")['SecretString']) rubrik = rubrik_cdm.Connect(rubrik_credentials['rubrikhost'], rubrik_credentials['rubrikuser'], rubrik_credentials['rubrikpassword']) # find relevant cloud source cloud_sources = rubrik.get('internal', '/aws/account', timeout=60, authentication=True)['data'] for source in cloud_sources: source_detail = rubrik.get('internal', '/aws/account/' + source['id'], timeout=60, authentication=True) if source_detail['accessKey'] == pending_secret['iamaccesskey']: source_id = source_detail['id'] # check if the cloud source can iterate subnets in us-east-1 try: rubrik.get('internal', '/aws/account/%s/subnet?region=us-east-1' % (source_id), timeout=60, authentication=True) except: logger.error( "Error iterating subnets in us-east-1 for Cloud Source %s" % source_id) raise ValueError( "Error iterating subnets in us-east-1 for Cloud Source %s" % source_id) logger.info("testSecret: Successfully tested %s with new access keys" % source_id)
async def getclusterversion(self, message): """ A skills function to get the rubrik cluster version. The parser looks for the message argument. Arguments: message {str} -- get rubrik cluster version """ rubrik = rubrik_cdm.Connect() version = rubrik.cluster_version() await message.respond( 'All done! The current Rubrik cluster version is: {}'.format( version))
async def getclusternodeids(self, message): """ A skills function to get the rubrik cluster node id's. The parser looks for the message argument. Arguments: message {str} -- get rubrik cluster node names """ rubrik = rubrik_cdm.Connect() node_id = rubrik.cluster_node_id() await message.respond( 'All done! The current Rubrik cluster node id\'s are: {}'.format( node_id))
def main(): """ Main entry point for Ansible module execution. """ results = {} argument_spec = dict( organization_name=dict(required=True, type='str'), mssql_host=dict(required=True, type='str'), timeout=dict(required=False, type='int', default=15), ) argument_spec.update(rubrik_argument_spec) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=False) ansible = module.params organization_name = ansible["organization_name"] mssql_host = ansible["mssql_host"] timeout = ansible["timeout"] load_provider_variables(module) if not HAS_RUBRIK_SDK: module.fail_json( msg= 'The Rubrik Python SDK is required for this module (pip install rubrik_cdm).' ) node_ip, username, password, api_token = credentials(module) try: rubrik = rubrik_cdm.Connect(node_ip, username, password, api_token) except Exception as error: module.fail_json(msg=str(error)) try: api_request = rubrik.add_organization_protectable_object_mssql_server_host( organization_name, mssql_host, timeout) except Exception as error: module.fail_json(msg=str(error)) if "No change required" in api_request: results["changed"] = False else: results["changed"] = True results["response"] = api_request module.exit_json(**results)
async def getvspherevmsnapshots(self, message): """ A skills function to get snapshots of a VMware VM. The parser looks for the message argument. Arguments: message {str} -- get vmware vm {vm_name} snapshots """ rubrik = rubrik_cdm.Connect() vm_name = message.regex.group('vm_name') get_vm = rubrik.get_vsphere_vm_snapshot(id=vm_name) await message.respond( 'All done! : Snapshots of VMware VM {}. Response: {}'.format( vm_name, get_vm))
def connect_rubrik(): """ Creates a connection to the Rubrik CDM. Returns: rubrik_connection_object: A connection to the Rubrik CDM """ __location__ = os.path.realpath(os.path.join(os.getcwd(), os.path.dirname(__file__))) with open(os.path.join(__location__, 'config.json')) as config_file: config = json.load(config_file) if not config['rubrik_cdm_node_ip']: config['rubrik_cdm_node_ip'] = None return rubrik_cdm.Connect(config['rubrik_cdm_node_ip'], config['rubrik_cdm_username'], config['rubrik_cdm_password'], config['rubrik_cdm_token'])
async def vsphereinstantrecoverylatest(self, message): """ A skills function to perform vmware instant recovery. The parser looks for the message argument. Arguments: message {str} -- perform instant recovery of vmware VM {vm_name} """ rubrik = rubrik_cdm.Connect() vm_name = message.regex.group('vm_name') instant_recovery = rubrik.vsphere_instant_recovery(vm_name) await message.respond( 'All done! {} has been recovered from the latest snapshot. Response: {}' .format(vm_name, instant_recovery))
async def getvspherelivemountnames(self, message): """ A skills function to list the current live mounts of a VMware VM. The parser looks for the message argument. Arguments: message {str} -- get live mount names of vmware vm {vm_name} """ rubrik = rubrik_cdm.Connect() vm_name = message.regex.group('vm_name') live_mount = rubrik.get_vsphere_live_mount_names(vm_name) await message.respond( 'All done! {} has the following live mounts: {}.'.format( vm_name, live_mount))
async def vsphereliveunmount(self, message): """ A skills function to unmount a vSphere virtual machine. The parser looks for the message argument. Arguments: message {str} -- unmount vm {vm_name} """ mounted_vm_name = message.regex.group('mounted_vm_name') rubrik = rubrik_cdm.Connect() live_unmount = rubrik.vsphere_live_unmount(mounted_vm_name) await message.respond( 'All done! {} has been unmounted. Response: {}'.format( mounted_vm_name, live_unmount))
async def beginmvsnapshot(self, message): """ A skills function to start a managed volume snapshot. The parser looks for the message argument. Arguments: message {str} -- begin managed volume {mv_name} snapshot """ rubrik = rubrik_cdm.Connect() mv_name = message.regex.group('mv_name') start_mv = rubrik.begin_managed_volume_snapshot(name=mv_name) await message.respond( 'All done! : Starting managed volume snapshot "{}". Response: {}'. format(mv_name, start_mv))
def main(): """ Main entry point for Ansible module execution. """ results = {} argument_spec = dict( db_name=dict(required=True, type='str'), date=dict(required=True, type='str'), time=dict(required=True, type='str'), sql_instance=dict(required=True, type='str'), sql_host=dict(required=True, type='str'), mount_name=dict(required=True, type='str'), timeout=dict(required=False, type='int', default=30), ) argument_spec.update(rubrik_argument_spec) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=False) ansible = module.params load_provider_variables(module) if not HAS_RUBRIK_SDK: module.fail_json( msg= 'The Rubrik Python SDK is required for this module (pip install rubrik_cdm).' ) node_ip, username, password, api_token = credentials(module) try: rubrik = rubrik_cdm.Connect(node_ip, username, password, api_token) except Exception as error: module.fail_json(msg=str(error)) try: api_request = rubrik.sql_live_mount(ansible["db_name"], ansible["date"], ansible["time"], ansible["sql_instance"], ansible["sql_host"], ansible["mount_name"], ansible["timeout"]) except Exception as error: module.fail_json(msg=str(error)) results["response"] = api_request module.exit_json(**results)
def _connect(self, creds): try: print() cli_ui.info('Connecting to Rubrik Cluster', cli_ui.turquoise, creds['address']) rbk = rubrik_cdm.Connect(node_ip=creds['address'], api_token=creds['api_token']) cluster_version = rbk.cluster_version() cli_ui.info('Cluster Version =', cli_ui.turquoise, cluster_version) except rubrik_cdm.exceptions.APICallException as e: cli_ui.error(e) sys.exit(1) # FIXME: Replace with exception self.rubrik = rbk