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
