def __get_snapshot_by_name(self, resource, data):
if 'name' not in data['snapshotParameters']:
raise HPOneViewValueError(VOLUME_NO_OPTIONS_PROVIDED)
result = self.oneview_client.volumes.get_snapshot_by(resource['uri'], 'name',
data['snapshotParameters']['name'])
return result[0] if result else None
def __present(self, data):
resource = self.__get_resource(data)
changed = False
msg = ''
if not resource:
if 'credentials' not in data:
raise HPOneViewValueError(STORAGE_SYSTEM_CREDENTIALS_MANDATORY)
resource = self.oneview_client.storage_systems.add(
data['credentials'])
changed = True
msg = STORAGE_SYSTEM_ADDED
merged_data = resource.copy()
merged_data.update(data)
if 'credentials' in merged_data and 'password' in merged_data[
'credentials']:
# remove password, it cannot be used in comparison
del merged_data['credentials']['password']
if not resource_compare(resource, merged_data):
# update the resource
resource = self.oneview_client.storage_systems.update(merged_data)
if not changed:
changed = True
msg = STORAGE_SYSTEM_UPDATED
else:
msg = STORAGE_SYSTEM_ALREADY_UPDATED
return changed, msg, dict(storage_system=resource)
def run(self):
try:
state = self.module.params['state']
data = self.module.params['data']
changed, msg, ansible_facts = False, '', {}
if not self.module.params.get('validate_etag'):
self.oneview_client.connection.disable_etag_validation()
if not data.get('name'):
raise HPOneViewValueError(STORAGE_VOLUME_TEMPLATE_MANDATORY_FIELD_MISSING)
resource = (self.oneview_client.storage_volume_templates.get_by("name", data['name']) or [None])[0]
if state == 'present':
changed, msg, ansible_facts = self.__present(data, resource)
elif state == 'absent':
changed, msg, ansible_facts = self.__absent(resource)
self.module.exit_json(changed=changed,
msg=msg,
ansible_facts=ansible_facts)
except HPOneViewException as exception:
self.module.fail_json(msg=exception.args[0])
def test_oneview_value_error_inheritance(self):
exception = HPOneViewValueError("The given data is empty!")
self.assertIsInstance(exception, HPOneViewException)
self.assertEqual(exception.msg, "The given data is empty!")
self.assertEqual(exception.oneview_response, None)
self.assertEqual(exception.args[0], "The given data is empty!")
def __get_specific_attachment(self, params):
attachment_uri = params.get('storageVolumeAttachmentUri')
if attachment_uri:
return [
self.oneview_client.storage_volume_attachments.get(
attachment_uri)
]
else:
volume_uri = params.get('storageVolumeUri')
profile_name = params.get('serverProfileName')
if not profile_name or not (volume_uri
or params.get('storageVolumeName')):
raise HPOneViewValueError(ATTACHMENT_KEY_REQUIRED)
if not volume_uri and params.get('storageVolumeName'):
volumes = self.oneview_client.volumes.get_by(
'name', params.get('storageVolumeName'))
if volumes:
volume_uri = volumes[0]['uri']
uri = self.__search_attachment_uri.format(volume_uri, profile_name)
attachments = self.oneview_client.storage_volume_attachments.get(
uri) or {}
return attachments.get('members')
def __retrieve_differences(self, data, resource):
if 'content' not in data:
raise HPOneViewValueError(PLAN_SCRIPT_CONTENT_ATTRIBUTE_MANDATORY)
differences = self.i3s_client.plan_scripts.retrieve_differences(
resource['uri'], data['content'])
return False, PLAN_SCRIPT_DIFFERENCES_RETRIEVED, dict(
plan_script_differences=differences)
def __get_resource(self, data):
if not data.get('name'):
raise HPOneViewValueError(POWER_DEVICE_MANDATORY_FIELD_MISSING)
resource = (self.oneview_client.power_devices.get_by(
"name", data['name']) or [None])[0]
return resource
def __present(self, data, resource):
server_template_name = data.pop('server_template', '')
server_hardware_name = data.pop('server_hardware', '')
server_template = None
changed = False
created = False
ServerProfileReplaceNamesByUris().replace(self.oneview_client, data)
if server_hardware_name:
selected_server_hardware = self.__get_server_hardware_by_name(
server_hardware_name)
if not selected_server_hardware:
raise HPOneViewValueError(
HARDWARE_NOT_FOUND.format(server_hardware_name))
data['serverHardwareUri'] = selected_server_hardware['uri']
if server_template_name:
server_template = self.oneview_client.server_profile_templates.get_by_name(
server_template_name)
if not server_template:
raise HPOneViewValueError(
TEMPLATE_NOT_FOUND.format(server_template_name))
data['serverProfileTemplateUri'] = server_template['uri']
elif data.get('serverProfileTemplateUri'):
server_template = self.oneview_client.server_profile_templates.get(
data['serverProfileTemplateUri'])
if not resource:
resource = self.__create_profile(data, server_template)
changed = True
created = True
msg = SERVER_PROFILE_CREATED
else:
merged_data = ServerProfileMerger().merge_data(resource, data)
if not resource_compare(resource, merged_data):
resource = self.__update_server_profile(merged_data)
changed = True
msg = SERVER_PROFILE_UPDATED
else:
msg = SERVER_ALREADY_UPDATED
return created, changed, msg, resource
def __get_drive_enclosure(self, data):
name = data.get('name')
if not name:
raise HPOneViewValueError(DRIVE_ENCLOSURE_NAME_REQUIRED)
else:
result = self.oneview_client.drive_enclosures.get_by('name', name)
if not result:
raise HPOneViewResourceNotFound(DRIVE_ENCLOSURE_NOT_FOUND)
return result[0]
def __get_provider_uri_by_display_name(self, data):
display_name = data.get('providerDisplayName')
provider_uri = self.oneview_client.san_managers.get_provider_uri(
display_name)
if not provider_uri:
raise HPOneViewValueError(
SAN_MANAGER_PROVIDER_DISPLAY_NAME_NOT_FOUND.format(
display_name))
return provider_uri
def __compliance(self, data):
uris = data.get('logicalInterconnectUris')
if not uris:
if 'logicalInterconnectNames' not in data:
raise HPOneViewValueError(SAS_LOGICAL_INTERCONNECT_NO_OPTIONS_PROVIDED)
uris = self.__resolve_log_interconnect_names(data['logicalInterconnectNames'])
self.oneview_client.sas_logical_interconnects.update_compliance_all(uris)
return True, SAS_LOGICAL_INTERCONNECT_CONSISTENT, {}
def __update(self, data, resource):
if 'newName' in data:
if self.__get_by_name(data['newName']):
raise HPOneViewValueError(VOLUME_NEW_NAME_INVALID)
data['name'] = data.pop('newName')
merged_data = resource.copy()
merged_data.update(data)
updated_volume = self.oneview_client.volumes.update(merged_data)
self.module.exit_json(changed=True,
msg=VOLUME_UPDATED,
ansible_facts=dict(storage_volume=updated_volume))
def run(self):
try:
state = self.module.params['state']
data = self.module.params['data']
if not self.module.params.get('validate_etag'):
self.oneview_client.connection.disable_etag_validation()
if state == 'present':
changed, msg, ansible_facts = self.__present(data)
else:
if not data.get('name'):
raise HPOneViewValueError(
SERVER_HARDWARE_MANDATORY_FIELD_MISSING.format(
"data.name"))
resource = self.__get_server_hardware(data['name'])
if state == 'absent':
changed, msg, ansible_facts = self.__absent(resource)
else:
if not resource:
raise HPOneViewResourceNotFound(
SERVER_HARDWARE_NOT_FOUND)
if state == 'power_state_set':
changed, msg, ansible_facts = self.__set_power_state(
data, resource)
elif state == 'refresh_state_set':
changed, msg, ansible_facts = self.__set_refresh_state(
data, resource)
elif state == 'ilo_firmware_version_updated':
changed, msg, ansible_facts = self.__update_mp_firmware_version(
resource)
elif state == 'environmental_configuration_set':
changed, msg, ansible_facts = self.__set_environmental_configuration(
data, resource)
else:
changed, msg, ansible_facts = self.__patch(
state, resource)
self.module.exit_json(changed=changed,
msg=msg,
ansible_facts=ansible_facts)
except HPOneViewException as exception:
self.module.fail_json(msg=exception.args[0])
def __get_resource(self, data):
if 'credentials' in data and data['credentials'].get('ip_hostname'):
resource = self.oneview_client.storage_systems.get_by_ip_hostname(
data['credentials']['ip_hostname'])
if data['credentials'].get('newIp_hostname'):
data['credentials']['ip_hostname'] = data['credentials'].pop(
'newIp_hostname')
return resource
elif data.get('name'):
return self.oneview_client.storage_systems.get_by_name(
data['name'])
else:
raise HPOneViewValueError(STORAGE_SYSTEM_MANDATORY_FIELDS_MISSING)
def __get_interconnect(self):
interconnect_ip = self.module.params['ip']
interconnect_name = self.module.params['name']
if interconnect_ip:
interconnects = self.oneview_client.interconnects.get_by('interconnectIP', interconnect_ip) or []
elif interconnect_name:
interconnects = self.oneview_client.interconnects.get_by('name', interconnect_name) or []
else:
raise HPOneViewValueError(MISSING_KEY_MSG)
if not interconnects:
raise HPOneViewResourceNotFound(INTERCONNECT_WAS_NOT_FOUND)
return interconnects[0]
def build_subresource_uri(self, resource_id_or_uri=None, subresource_id_or_uri=None, subresource_path=''):
if subresource_id_or_uri and "/" in subresource_id_or_uri:
return subresource_id_or_uri
else:
if not resource_id_or_uri:
raise HPOneViewValueError(RESOURCE_ID_OR_URI_REQUIRED)
resource_uri = self.build_uri(resource_id_or_uri)
uri = "{}/{}/{}".format(resource_uri, subresource_path, str(subresource_id_or_uri or ''))
uri = uri.replace("//", "/")
if uri.endswith("/"):
uri = uri[:-1]
return uri
def __present(self, data):
if not data.get('hostname'):
raise HPOneViewValueError(
SERVER_HARDWARE_MANDATORY_FIELD_MISSING.format(
"data.hostname"))
resource = self.__get_server_hardware(data['hostname'])
changed = False
if not resource:
resource = self.oneview_client.server_hardware.add(data)
changed = True
msg = SERVER_HARDWARE_ADDED
else:
msg = SERVER_HARDWARE_ALREADY_ADDED
return changed, msg, dict(server_hardware=resource)
def __update(self, data, resource):
if 'newName' in data:
if self.__get_by_name(data['newName']):
raise HPOneViewValueError(NETWORK_SET_NEW_NAME_INVALID)
data['name'] = data.pop('newName')
merged_data = resource.copy()
merged_data.update(data)
if resource_compare(resource, merged_data):
self.module.exit_json(changed=False,
msg=NETWORK_SET_ALREADY_EXIST,
ansible_facts=dict(network_set=resource))
else:
updated_network_set = self.oneview_client.network_sets.update(
merged_data)
self.module.exit_json(
changed=True,
msg=NETWORK_SET_UPDATED,
ansible_facts=dict(network_set=updated_network_set))
def run(self):
try:
state = self.module.params['state']
data = self.module.params['data']
changed, msg, ansible_facts = False, '', {}
if not data.get('poolName'):
raise HPOneViewValueError(STORAGE_POOL_MANDATORY_FIELD_MISSING)
resource = (self.oneview_client.storage_pools.get_by(
"name", data['poolName']) or [None])[0]
if state == 'present':
changed, msg, ansible_facts = self.__present(data, resource)
elif state == 'absent':
changed, msg, ansible_facts = self.__absent(resource)
self.module.exit_json(changed=changed,
msg=msg,
ansible_facts=ansible_facts)
except HPOneViewException as exception:
self.module.fail_json(msg=exception.args[0])
def run(self):
try:
state = self.module.params['state']
data = self.module.params['data']
changed, msg, ansible_facts = False, '', {}
if not data.get('name'):
raise HPOneViewValueError(
CONNECTION_TEMPLATE_MANDATORY_FIELD_MISSING)
resource = (self.oneview_client.connection_templates.get_by(
"name", data['name']) or [None])[0]
if state == 'present':
changed, msg, ansible_facts = self.__present(data, resource)
self.module.exit_json(changed=changed,
msg=msg,
ansible_facts=ansible_facts)
except HPOneViewException as exception:
self.module.fail_json(msg='; '.join(
str(e) for e in exception.args))
def __present(self, data, resource):
changed = False
msg = ''
if "newName" in data:
data["name"] = data.pop("newName")
self.__replace_name_by_uris(data)
self.__check_present_consistency(data)
file_path = data.pop('localImageFilePath', None)
if not resource:
if data.get('osVolumeURI'):
resource = self.i3s_client.golden_images.create(data)
msg = GOLDEN_IMAGE_CREATED
changed = True
elif file_path:
resource = self.i3s_client.golden_images.upload(file_path, data)
msg = GOLDEN_IMAGE_UPLOADED
changed = True
else:
raise HPOneViewValueError(I3S_MISSING_MANDATORY_ATTRIBUTES)
else:
merged_data = resource.copy()
merged_data.update(data)
if not resource_compare(resource, merged_data):
# update resource
resource = self.i3s_client.golden_images.update(merged_data)
changed = True
msg = GOLDEN_IMAGE_UPDATED
else:
msg = GOLDEN_IMAGE_ALREADY_UPDATED
return changed, msg, dict(golden_image=resource)
def __validate_key(self, data):
if 'name' not in data:
raise HPOneViewValueError(UPLINK_SET_KEY_REQUIRED)
if 'logicalInterconnectUri' not in data and 'logicalInterconnectName' not in data:
raise HPOneViewValueError(UPLINK_SET_KEY_REQUIRED)
def __check_present_consistency(self, data):
if data.get('osVolumeURI') and data.get('localImageFilePath'):
raise HPOneViewValueError(I3S_CANT_CREATE_AND_UPLOAD)
def __validate_settings(self, data):
if 'ethernetSettings' not in data and 'fcoeSettings' not in data:
raise HPOneViewValueError(LOGICAL_INTERCONNECT_NO_OPTIONS_PROVIDED)
def __validate_options(self, subresource_type, data):
if subresource_type not in data:
raise HPOneViewValueError(LOGICAL_INTERCONNECT_NO_OPTIONS_PROVIDED)