def get_volume(rest_api, vserver, name):
api = 'storage/volumes/'
query = dict(name=name)
query['svm.name'] = vserver
response, error = rest_api.get(api, query)
volume, error = rrh.check_for_0_or_1_records(api, response, error, query)
return volume, error
def get_igroup_rest(self, name):
api = "protocols/san/igroups"
fields = 'name,uuid,svm,initiators,os_type,protocol'
if self.rest_api.meets_rest_minimum_version(self.use_rest, 9, 9):
fields += ',igroups'
query = dict(name=name, fields=fields)
query['svm.name'] = self.parameters['vserver']
response, error = self.rest_api.get(api, query)
igroup, error = rrh.check_for_0_or_1_records(api, response, error)
self.fail_on_error(error)
if igroup:
try:
igroup_details = dict(
name=igroup['name'],
uuid=igroup['uuid'],
vserver=igroup['svm']['name'],
os_type=igroup['os_type'],
initiator_group_type=igroup['protocol'],
name_to_uuid=dict()
)
except KeyError as exc:
self.module.fail_json(msg='Error: unexpected igroup body: %s, KeyError on %s' % (str(igroup), str(exc)))
igroup_details['name_to_key'] = dict()
for attr in ('igroups', 'initiators'):
if attr in igroup:
igroup_details[attr] = [item['name'] for item in igroup[attr]]
# for initiators, there is no uuid, so we're using name as the key
igroup_details['name_to_uuid'][attr] = dict((item['name'], item.get('uuid', item['name'])) for item in igroup[attr])
else:
igroup_details[attr] = []
igroup_details['name_to_uuid'][attr] = dict()
return igroup_details
return None
def _set_application_uuid(self):
"""Use REST application/applications to get application uuid"""
api = '/application/applications'
query = {'return_timeout': 30, 'return_records': 'true', 'svm.name': self.svm_name, 'name': self.app_name}
response, error = self.rest_api.get(api, query)
record, error = rrh.check_for_0_or_1_records(api, response, error, query)
if error is None and record is not None:
self.app_uuid = record['uuid']
return None, error
def get_flexcache(rest_api, vserver, name, fields=None):
api = 'storage/flexcache/flexcaches'
query = dict(name=name)
query['svm.name'] = vserver
if fields is not None:
query['fields'] = fields
response, error = rest_api.get(api, query)
flexcache, error = rrh.check_for_0_or_1_records(api, response, error,
query)
return flexcache, error
def get_application_component_uuid(self):
"""Use REST application/applications to get component uuid
Assume a single component per application
"""
self.fail_if_no_uuid()
response, error = self.get_application_components()
record, error = rrh.check_for_0_or_1_records(None, response, error,
None)
if error is None and record is not None:
return record['uuid'], None
return None, error
def get_storage_failover(self):
"""
get the storage failover for a given node
:return: dict of is-enabled: true if enabled is true None if not
"""
if self.use_rest:
return_value = None
api = "cluster/nodes"
query = {
'fields': 'uuid,ha.enabled',
'name': self.parameters['node_name']
}
message, error = self.rest_api.get(api, query)
records, error = rrh.check_for_0_or_1_records(api, message, error)
if error is None and records is not None:
return_value = {
'uuid': message['records'][0]['uuid'],
'is_enabled': message['records'][0]['ha']['enabled']
}
if error:
self.module.fail_json(msg=error)
if not records:
error = "REST API did not return failover details for node %s" % (self.parameters['node_name'])
self.module.fail_json(msg=error)
return return_value
else:
storage_failover_get_iter = netapp_utils.zapi.NaElement('cf-status')
storage_failover_get_iter.add_new_child('node', self.parameters['node_name'])
try:
result = self.server.invoke_successfully(storage_failover_get_iter, True)
return_value = {'is_enabled': self.na_helper.get_value_for_bool(True, result.get_child_content('is-enabled'))}
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(msg='Error getting storage failover info for node %s: %s' % (
self.parameters['node_name'], to_native(error)), exception=traceback.format_exc())
return return_value
def get_igroup_rest(self, name):
api = "protocols/san/igroups"
query = dict(name=name, fields='name,uuid,svm,initiators,os_type,protocol')
query['svm.name'] = self.parameters['vserver']
response, error = self.rest_api.get(api, query)
igroup, error = rrh.check_for_0_or_1_records(api, response, error)
self.fail_on_error(error)
if igroup:
try:
igroup_details = dict(
name=igroup['name'],
uuid=igroup['uuid'],
vserver=igroup['svm']['name'],
os_type=igroup['os_type'],
initiator_group_type=igroup['protocol'],
)
except KeyError as exc:
self.module.fail_json(msg='Error: unexpected igroup body: %s, KeyError on %s' % (str(igroup), str(exc)))
if 'initiators' in igroup:
igroup_details['initiators'] = [item['name'] for item in igroup['initiators']]
else:
igroup_details['initiators'] = []
return igroup_details
return None
def get_storage_auto_giveback(self):
"""
get the storage failover giveback options for a given node
:return: dict for options
"""
return_value = None
if self.use_rest:
api = "private/cli/storage/failover"
query = {
'fields': 'node,auto_giveback,auto_giveback_after_panic',
'node': self.parameters['name'],
}
message, error = self.rest_api.get(api, query)
records, error = rrh.check_for_0_or_1_records(api, message, error)
if error is None and records is not None:
return_value = {
'name':
message['records'][0]['node'],
'auto_giveback_enabled':
message['records'][0]['auto_giveback'],
'auto_giveback_after_panic_enabled':
message['records'][0]['auto_giveback_after_panic']
}
if error:
self.module.fail_json(msg=error)
if not records:
error = "REST API did not return failover options for node %s" % (
self.parameters['name'])
self.module.fail_json(msg=error)
else:
storage_auto_giveback_get_iter = netapp_utils.zapi.NaElement(
'cf-get-iter')
try:
result = self.server.invoke_successfully(
storage_auto_giveback_get_iter, True)
except netapp_utils.zapi.NaApiError as error:
self.module.fail_json(
msg='Error getting auto giveback info for node %s: %s' %
(self.parameters['name'], to_native(error)),
exception=traceback.format_exc())
if result.get_child_by_name('attributes-list'):
attributes_list = result.get_child_by_name('attributes-list')
for storage_failover_info_attributes in attributes_list.get_children(
):
sfo_node_info = storage_failover_info_attributes.get_child_by_name(
'sfo-node-info')
node_related_info = sfo_node_info.get_child_by_name(
'node-related-info')
if node_related_info.get_child_content(
'node') == self.parameters['name']:
sfo_options_info = storage_failover_info_attributes.get_child_by_name(
'sfo-options-info')
options_related_info = sfo_options_info.get_child_by_name(
'options-related-info')
sfo_giveback_options_info = options_related_info.get_child_by_name(
'sfo-giveback-options-info')
giveback_options = sfo_giveback_options_info.get_child_by_name(
'giveback-options')
return_value = {
'name':
node_related_info.get_child_content('node'),
'auto_giveback_enabled':
self.na_helper.get_value_for_bool(
True,
options_related_info.get_child_content(
'auto-giveback-enabled')),
'auto_giveback_after_panic_enabled':
self.na_helper.get_value_for_bool(
True,
giveback_options.get_child_content(
'auto-giveback-after-panic-enabled')),
}
break
return return_value
