def validateVersion(self):
version = self.get(uri['version'])
if 'minimumVersion' in version:
if self._apiVersion < version['minimumVersion']:
raise HPEOneViewException('Unsupported API Version')
if 'currentVersion' in version:
if self._apiVersion > version['currentVersion']:
raise HPEOneViewException('Unsupported API Version')
self._validateVersion = True
def login(self, cred, verbose=False):
try:
if self._validateVersion is False:
self.validateVersion()
except Exception:
raise(HPEOneViewException('Failure during login attempt.\n %s' % traceback.format_exc()))
cred['loginMsgAck'] = True # This will handle the login acknowledgement message
self._cred = cred
try:
if self._cred.get("sessionID"):
self.set_session_id(self._cred["sessionID"])
task, body = self.put(uri['loginSessions'], None)
else:
self._cred.pop("sessionID", None)
task, body = self.post(uri['loginSessions'], self._cred)
except HPEOneViewException:
logger.exception('Login failed')
raise
auth = body['sessionID']
# Add the auth ID to the headers dictionary
self._headers['auth'] = auth
self._session = True
if verbose is True:
print(('Session Key: ' + auth))
logger.info('Logged in successfully')
def patch(self, uri, timeout=-1):
"""
Sets the state of task to cancelling only if IsCancellable is set to true for the task and its children or
children are in terminal state.
Args:
uri: URI of task resource.
timeout: Timeout in seconds. Wait for task completion by default. The timeout does not abort the operation
in OneView; it just stops waiting for its completion.
Returns:
dict: Updated resource.
"""
resp, body = self._connection.do_http('PATCH', path=uri, body=None)
if resp.status >= 400:
raise HPEOneViewException(body)
elif resp.status == 304:
if body and not isinstance(body, dict):
try:
body = json.loads(body)
except Exception:
pass
elif resp.status == 202:
task = self._connection.__get_task_from_response(resp, body)
return self._task_monitor.wait_for_task(task, timeout)
return body
def test_exception_constructor_with_unicode(self):
exception = HPEOneViewException(u"A message string")
self.assertEqual(exception.msg, "A message string")
self.assertEqual(exception.oneview_response, None)
self.assertEqual(exception.args[0], "A message string")
self.assertEqual(len(exception.args), 1)
def test_exception_constructor_with_invalid_dict(self):
exception = HPEOneViewException({'msg': "A message string"})
self.assertEqual(exception.msg, None)
self.assertEqual(exception.oneview_response,
{'msg': "A message string"})
self.assertEqual(exception.args[0], None)
self.assertEqual(exception.args[1], {'msg': "A message string"})
def test_should_log_message(self, mock_logging_error, mock_traceback):
message = "test message"
exception = HPEOneViewException(message)
traceback_ex = None
handle_exceptions(exception.__class__, exception, traceback_ex,
mock_logging_error)
log_message = "Uncaught Exception: HPEOneViewException with message: test message"
mock_logging_error.error.assert_called_once_with(log_message)
def test_should_print_exception(self, mock_logging_error, mock_traceback):
message = "test message"
exception = HPEOneViewException(message)
traceback_ex = None
handle_exceptions(exception.__class__, exception, traceback_ex,
mock_logging_error)
mock_traceback.assert_called_once_with(exception.__class__, exception,
traceback_ex)
def test_exception_constructor_with_invalid_type(self):
exception = HPEOneViewException(
['List, item 1', "List, item 2: A message string"])
self.assertEqual(exception.msg, None)
self.assertEqual(exception.oneview_response,
['List, item 1', "List, item 2: A message string"])
self.assertEqual(exception.args[0], None)
self.assertEqual(exception.args[1],
['List, item 1', "List, item 2: A message string"])
def test_should_log_oneview_reponse(self, mock_logging_error,
mock_traceback):
message = {"msg": "test message"}
exception = HPEOneViewException(message)
traceback_ex = None
handle_exceptions(exception.__class__, exception, traceback_ex,
mock_logging_error)
log_message = "Uncaught Exception: HPEOneViewException with message: \n{'msg': 'test message'}"
mock_logging_error.error.assert_called_once_with(log_message)
def test_pickle_HPEOneViewException_message(self):
message = "test message"
exception = HPEOneViewException(message)
tempf = tempfile.NamedTemporaryFile(delete=False)
with tempf as f:
pickle.dump(exception, f)
with open(tempf.name, 'rb') as f:
exception = pickle.load(f)
os.remove(tempf.name)
self.assertEqual('HPEOneViewException', exception.__class__.__name__)
def test_should_create_new_user(self):
self.resource.get_by.side_effect = HPEOneViewException('FAKE_MSG_ERROR')
self.resource.create.return_value = DEFAULT_PARAMS
self.mock_ansible_module.params = PARAMS_FOR_PRESENT
UserModule().run()
self.mock_ansible_module.exit_json.assert_called_once_with(
changed=True,
msg=UserModule.MSG_CREATED,
ansible_facts=dict(user=DEFAULT_PARAMS)
)
def download_to_stream(self,
stream_writer,
url,
body='',
method='GET',
custom_headers=None):
http_headers = self._headers.copy()
if custom_headers:
http_headers.update(custom_headers)
chunk_size = 4096
conn = None
successful_connected = False
while not successful_connected:
try:
conn = self.get_connection()
conn.request(method, url, body, http_headers)
resp = conn.getresponse()
if resp.status >= 400:
self.__handle_download_error(resp, conn)
if resp.status == 302:
return self.download_to_stream(
stream_writer=stream_writer,
url=resp.getheader('Location'),
body=body,
method=method,
custom_headers=http_headers)
tempbytes = True
while tempbytes:
tempbytes = resp.read(chunk_size)
if tempbytes: # filter out keep-alive new chunks
stream_writer.write(tempbytes)
conn.close()
successful_connected = True
except http.client.BadStatusLine:
logger.warning('Bad Status Line. Trying again...')
if conn:
conn.close()
time.sleep(1)
continue
except http.client.HTTPException:
raise HPEOneViewException(
'Failure during login attempt.\n %s' %
traceback.format_exc())
return successful_connected
def get(self, uri, custom_headers=None):
resp, body = self.do_http('GET', uri, '', custom_headers=custom_headers)
if resp.status >= 400:
raise HPEOneViewException(body)
if resp.status == 302:
body = self.get(resp.getheader('Location'))
if type(body) is dict:
if 'nextPageUri' in body:
self._nextPage = body['nextPageUri']
if 'prevPageUri' in body:
self._prevPage = body['prevPageUri']
if 'total' in body:
self._numTotalRecords = body['total']
if 'count' in body:
self._numDisplayedRecords = body['count']
return body
def __handle_download_error(self, resp, conn):
try:
tempbytes = resp.read()
tempbody = tempbytes.decode('utf-8')
try:
body = json.loads(tempbody)
except ValueError:
body = tempbody
except UnicodeDecodeError: # Might be binary data
body = tempbytes
conn.close()
if not body:
body = "Error " + str(resp.status)
conn.close()
raise HPEOneViewException(body)
def post_multipart(self, uri, fields, files, baseName, verbose=False):
content_type = self.encode_multipart_formdata(fields, files, baseName,
verbose)
inputfile = self._open(files + '.b64', 'rb')
mappedfile = mmap.mmap(inputfile.fileno(), 0, access=mmap.ACCESS_READ)
if verbose is True:
print(('Uploading ' + files + '...'))
conn = self.get_connection()
# conn.set_debuglevel(1)
conn.connect()
conn.putrequest('POST', uri)
conn.putheader('uploadfilename', baseName)
conn.putheader('auth', self._headers['auth'])
conn.putheader('Content-Type', content_type)
totalSize = os.path.getsize(files + '.b64')
conn.putheader('Content-Length', totalSize)
conn.putheader('X-API-Version', self._apiVersion)
conn.endheaders()
while mappedfile.tell() < mappedfile.size():
# Send 1MB at a time
# NOTE: Be careful raising this value as the read chunk
# is stored in RAM
readSize = 1048576
conn.send(mappedfile.read(readSize))
if verbose is True:
print('%d bytes sent... \r' % mappedfile.tell())
mappedfile.close()
inputfile.close()
os.remove(files + '.b64')
response = conn.getresponse()
body = response.read().decode('utf-8')
if body:
try:
body = json.loads(body)
except ValueError:
body = response.read().decode('utf-8')
conn.close()
if response.status >= 400:
raise HPEOneViewException(body)
return response, body
def do_http(self, method, path, body, custom_headers=None):
http_headers = self._headers.copy()
if custom_headers:
http_headers.update(custom_headers)
bConnected = False
conn = None
while bConnected is False:
try:
conn = self.get_connection()
conn.request(method, path, body, http_headers)
resp = conn.getresponse()
tempbytes = ''
try:
tempbytes = resp.read()
tempbody = tempbytes.decode('utf-8')
except UnicodeDecodeError: # Might be binary data
tempbody = tempbytes
conn.close()
bConnected = True
return resp, tempbody
if tempbody:
try:
body = json.loads(tempbody)
except ValueError:
body = tempbody
conn.close()
bConnected = True
except http.client.BadStatusLine:
logger.warning('Bad Status Line. Trying again...')
if conn:
conn.close()
time.sleep(1)
continue
except http.client.HTTPException:
raise HPEOneViewException(
'Failure during login attempt.\n %s' %
traceback.format_exc())
return resp, body
def __do_rest_call(self, http_method, uri, body, custom_headers):
resp, body = self.do_http(method=http_method,
path=uri,
body=json.dumps(body),
custom_headers=custom_headers)
if resp.status >= 400:
raise HPEOneViewException(body)
if resp.status == 304:
if body and not isinstance(body, dict):
try:
body = json.loads(body)
except Exception:
pass
elif resp.status == 202:
task = self.__get_task_from_response(resp, body)
return task, body
if self.__body_content_is_task(body):
return body, body
return None, body
def get_by(self, field, value):
"""
Gets all Users that match the filter.
The search is case-insensitive.
Args:
field: Field name to filter. Accepted values: 'name', 'userName', 'role'
value: Value to filter.
Returns:
list: A list of Users.
"""
if field == 'userName' or field == 'name':
return self._client.get(self.URI + '/' + value)
elif field == 'role':
value = value.replace(" ", "%20")
return self._client.get(self.URI + '/roles/users/' +
value)['members']
else:
raise HPEOneViewException(
'Only userName, name and role can be queried for this resource.'
)
if all_firmwares:
firmware_driver = firmware_drivers.get_by_name(all_firmwares[0]['name'])
if firmware_driver:
print("Found a firmware by name: '{}'.\n uri = '{}'".format(
firmware_driver.data['name'], firmware_driver.data['uri']))
else:
# Getting a SPP and a hotfix from within the Appliance to use in the custom SPP creation.
try:
spp = firmware_drivers.get_by('bundleType', "SPP")[0]
options['baselineUri'] = spp['uri']
print(
"\nSPP named '{}' found within appliance. Saving for custom SPP.".
format(spp['name']))
except IndexError:
raise HPEOneViewException(
'No available SPPs found within appliance. Stopping run.')
try:
hotfix = firmware_drivers.get_by('bundleType', "Hotfix")[0]
options['hotfixUris'] = [hotfix['uri']]
print(
"\nHotfix named '{}' found within appliance. Saving for custom SPP."
.format(hotfix['name']))
except IndexError:
raise HPEOneViewException(
'No available hotfixes found within appliance. Stopping run.')
# Create the custom SPP
print("\nCreate the custom SPP '{}'".format(options['customBaselineName']))
firmware_driver = firmware_drivers.create(options)
print(" Custom SPP '%s' created successfully" %
def test_get_by_aliasName_when_not_found(self, mock_get_by):
mock_get_by.side_effect = HPEOneViewException("not found")
self.assertEqual(self._certificate_server.get_by_alias_name("test1"),
None)
def test_login_with_exception_in_put_username_password_sessionID(self, mock_put, mock_get):
mock_get.side_effect = [{'minimumVersion': 800, 'currentVersion': 400}]
mock_put.side_effect = HPEOneViewException("Failed")
self.assertRaises(HPEOneViewException, self.connection.login, {"userName": "******",
"password": "", "sessionID": "123"})
def test_login_with_exception_in_put(self, mock_put, mock_get):
mock_get.side_effect = [{'minimumVersion': 800, 'currentVersion': 400}]
mock_put.side_effect = HPEOneViewException("Failed")
self.assertRaises(HPEOneViewException, self.connection.login, {"sessionID": "123"})
def test_get_by_called_with_userName_with_exception(self, mock_get):
mock_get.side_effect = HPEOneViewException("username is not found")
result = self._users.get_by_userName('testUser')
self.assertIsNone(result)
