Exemple #1
0
    def test_should_log_message(self, mock_logging_error, mock_traceback):
        message = "test message"
        exception = HPOneViewException(message)
        traceback_ex = None
        handle_exceptions(exception.__class__, exception, traceback_ex,
                          mock_logging_error)

        log_message = "Uncaught Exception: HPOneViewException with message: test message"
        mock_logging_error.error.assert_called_once_with(log_message)
 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 = HPOneViewException("Failed")
     self.assertRaises(HPOneViewException, self.connection.login, {
         "userName": "******",
         "password": "",
         "sessionID": "123"
     })
Exemple #3
0
    def test_should_print_exception(self, mock_logging_error, mock_traceback):
        message = "test message"
        exception = HPOneViewException(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)
Exemple #4
0
    def test_should_call_fail_json_when_oneview_exception(self):
        self.mock_ansible_module.params = self._ansible_params
        self._method_to_fire.side_effect = HPOneViewException(
            self.error_message)

        self._testing_class().run()

        self.mock_ansible_module.fail_json.assert_called_once_with(
            msg=self.error_message)
Exemple #5
0
    def test_should_log_oneview_reponse(self, mock_logging_error,
                                        mock_traceback):
        message = {"msg": "test message"}
        exception = HPOneViewException(message)
        traceback_ex = None
        handle_exceptions(exception.__class__, exception, traceback_ex,
                          mock_logging_error)

        log_message = "Uncaught Exception: HPOneViewException with message: \n{'msg': 'test message'}"
        mock_logging_error.error.assert_called_once_with(log_message)
Exemple #6
0
    def test_get_processor_collection_server_hardware_not_found(self):
        self.oneview_client.server_hardware.get_by_id.side_effect = \
            HPOneViewException({"errorCode": "RESOURCE_NOT_FOUND"})

        response = self.client.get(
            "/redfish/v1/CompositionService/ResourceBlocks"
            "/30303437-3034-4D32-3230-313133364752/Systems/1/Processors/")

        self.assertEqual(status.HTTP_404_NOT_FOUND, response.status_code)
        self.assertEqual("application/json", response.mimetype)
Exemple #7
0
    def test_exception_constructor_with_invalid_type(self):
        exception = HPOneViewException(
            ['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 generate_backup(self, blocking=True, verbose=False):
     resp, body = self._con.do_http('POST', uri['backups'], None)
     if resp.status >= 400:
         raise HPOneViewException(body)
     taskuri = resp.getheader('Location')
     task = self._con.get(taskuri)
     if blocking is True:
         task = self._activity.wait4task(task, tout=600, verbose=verbose)
     backupResource = self._activity.get_task_associated_resource(task)
     backup = self._con.get(backupResource['resourceUri'])
     return backup
Exemple #9
0
 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 HPOneViewException(body)
     elif resp.status == 202:
         task = self.get(resp.getheader('Location'))
         return task, body
     return None, body
Exemple #10
0
    def execute_module(self):
        """
        Abstract function, must be implemented by the inheritor.

        This method is called from the run method. It should contains the module logic

        Returns:
            dict:
                 It must return a dictionary with the attributes for the module result,
                 such as ansible_facts, msg and changed.
        """
        raise HPOneViewException("execute_module not implemented")
Exemple #11
0
    def test_pickle_HPOneViewException_message(self):
        message = "test message"
        exception = HPOneViewException(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('HPOneViewException', exception.__class__.__name__)
    def test_should_create_new_user(self):
        self.resource.get_by.side_effect = HPOneViewException('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 upload_spp(self, sppPath, sppName, verbose=False, blocking=True):
     response, body = self._con.post_multipart(uri['fwUpload'], '', sppPath,
                                               sppName, verbose)
     if response.status >= 400:
         raise HPOneViewException(body)
     if response.status == 202 and verbose is True:
         print('Upload complete. Waiting for processing.')
     task, spp = self._activity.make_task_entity_tuple(body)
     if blocking is True:
         task = self._activity.wait4task(task, tout=600, verbose=verbose)
     if verbose is True:
         print('Processing complete.')
     return spp['resourceId']
Exemple #14
0
    def test_remove_computer_system_sp_not_found(self, g):
        """Tests remove ComputerSystem with ServerProfile not found"""

        e = HPOneViewException({
            'errorCode': 'RESOURCE_NOT_FOUND',
            'message': 'server-profile not found',
        })
        g.oneview_client.server_profiles.delete.side_effect = e

        response = self.client.delete("/redfish/v1/Systems/"
                                      "e7f93fa2-0cb4-11e8-9060-e839359bc36b")

        self.assertEqual(status.HTTP_404_NOT_FOUND, response.status_code)
        self.assertEqual("application/json", response.mimetype)
Exemple #15
0
    def test_get_computer_system_sh_not_found(self, g):
        """Tests ComputerSystem with ServerHardware Not Found"""

        e = HPOneViewException({
            'errorCode': 'RESOURCE_NOT_FOUND',
            'message': 'server-hardware not found',
        })
        g.oneview_client.server_hardware.get.side_effect = e

        response = self.client.get(
            "/redfish/v1/Systems/0303437-3034-4D32-3230-313133364752")

        self.assertEqual(status.HTTP_404_NOT_FOUND, response.status_code)
        self.assertEqual("application/json", response.mimetype)
    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 HPOneViewException('Failure during login attempt.\n %s' %
                                         traceback.format_exc())

        return successful_connected
Exemple #17
0
    def test_remove_computer_system_exception(self):
        """Tests remove ComputerSystem with ServerProfile exception"""

        e = HPOneViewException({
            'errorCode': 'ANOTHER_ERROR',
            'message': 'server-profile error',
        })
        ServerProfiles.delete.side_effect = e

        response = self.client.delete("/redfish/v1/Systems/"
                                      "e7f93fa2-0cb4-11e8-9060-e839359bc36b")

        self.assertEqual(status.HTTP_500_INTERNAL_SERVER_ERROR,
                         response.status_code)
        self.assertEqual("application/json", response.mimetype)
Exemple #18
0
    def test_get_computer_system_sh_exception(self, g):
        """Tests ComputerSystem with ServerHardware exception"""

        e = HPOneViewException({
            'errorCode': 'ANOTHER_ERROR',
            'message': 'server-hardware error',
        })
        g.oneview_client.server_hardware.get.side_effect = e

        response = self.client.get(
            "/redfish/v1/Systems/0303437-3034-4D32-3230-313133364752")

        self.assertEqual(status.HTTP_500_INTERNAL_SERVER_ERROR,
                         response.status_code)
        self.assertEqual("application/json", response.mimetype)
Exemple #19
0
    def test_get_storage_collection_sh_not_found(self, g):
        """Tests StorageCollection"""

        e = HPOneViewException({
            'errorCode': 'RESOURCE_NOT_FOUND',
            'message': 'server-hardware not found',
        })
        g.oneview_client.server_hardware.get.side_effect = e

        # Get StorageCollection
        response = self.app.get(
            "/redfish/v1/Systems/30303437-3034-4D32-3230-313133364752/Storage")

        self.assertEqual(status.HTTP_404_NOT_FOUND, response.status_code)
        self.assertEqual("application/json", response.mimetype)
    def setUpClass(self):
        super(TestResourceBlock, self).setUpClass()

        self.app.register_blueprint(resource_block.resource_block)

        with open('oneview_redfish_toolkit/mockups/oneview/ServerHardware.json'
                  ) as f:
            self.server_hardware = json.load(f)

        with open('oneview_redfish_toolkit/mockups/oneview'
                  '/ServerProfileTemplate.json') as f:
            self.server_profile_template = json.load(f)

        with open('oneview_redfish_toolkit/mockups/oneview/Drive.json') as f:
            self.drive = json.load(f)

        with open(
                'oneview_redfish_toolkit/mockups/oneview/DriveIndexTrees.json'
        ) as f:
            self.drive_index_tree = json.load(f)

        with open('oneview_redfish_toolkit/mockups/oneview/'
                  'DriveComposedIndexTrees.json') as f:
            self.drive_composed_index_tree = json.load(f)

        with open('oneview_redfish_toolkit/mockups/oneview'
                  '/ServerProfileTemplates.json') as f:
            self.server_profile_templates = json.load(f)

        with open(
                'oneview_redfish_toolkit/mockups/oneview/LogicalEnclosures.json'
        ) as f:
            self.log_encl_list = json.load(f)

        with open('oneview_redfish_toolkit/mockups/redfish'
                  '/ServerHardwareResourceBlock.json') as f:
            self.expected_sh_resource_block = json.load(f)

        with open('oneview_redfish_toolkit/mockups/oneview'
                  '/DriveEnclosureList.json') as f:
            self.drive_enclosure_list = json.load(f)

        self.resource_not_found = HPOneViewException({
            "errorCode":
            "RESOURCE_NOT_FOUND",
            "message":
            "Any resource not found message"
        })
Exemple #21
0
    def test_get_storage_collection_sh_exception(self, g):
        """Tests StorageCollection"""

        e = HPOneViewException({
            'errorCode': 'ANOTHER_ERROR',
            'message': 'server-hardware-types error',
        })
        g.oneview_client.server_hardware.get.side_effect = e

        # Get StorageCollection
        response = self.app.get(
            "/redfish/v1/Systems/30303437-3034-4D32-3230-313133364752/Storage")

        self.assertEqual(status.HTTP_500_INTERNAL_SERVER_ERROR,
                         response.status_code)
        self.assertEqual("application/json", response.mimetype)
    def test_get_ethernet_interface_when_profile_not_found(self):
        """Tests request EthernetInterface when server profile not found"""

        e = HPOneViewException({'errorCode': 'RESOURCE_NOT_FOUND'})

        self.oneview_client.server_profiles.get.side_effect = e

        response = self.client.get(
            "/redfish/v1/Systems/b425802b-a6a5-4941-8885-aab68dfa2ee2/"
            "EthernetInterfaces/1")

        self.assertEqual(status.HTTP_404_NOT_FOUND, response.status_code)
        self.assertEqual("application/json", response.mimetype)
        self.oneview_client.server_profiles.get.assert_called_with(
            self.server_profile["uuid"])
        self.oneview_client.index_resources.get.assert_not_called()
    def test_get_storage_collection_when_profile_not_found(self):
        """Tests StorageCollection"""

        e = HPOneViewException({
            'errorCode': 'RESOURCE_NOT_FOUND',
            'message': 'server-hardware not found',
        })
        self.oneview_client.server_profiles.get_by_id.side_effect = e

        response = self.client.get(
            "/redfish/v1/Systems/b425802b-a6a5-4941-8885-aab68dfa2ee2/Storage")

        self.assertEqual(status.HTTP_404_NOT_FOUND, response.status_code)
        self.assertEqual("application/json", response.mimetype)
        self.oneview_client.server_profiles.get_by_id.assert_called_with(
            self.server_profile["uuid"])
    def test_service_root_oneview_exception(self, connection):
        """Tests ServiceROOT with an exception"""

        e = HPOneViewException({
            'errorCode': 'ANOTHER_ERROR',
            'message': 'appliance error',
        })

        connection.request_oneview.side_effect = e

        response = self.client.get("/redfish/v1/")

        self.assertEqual(status.HTTP_500_INTERNAL_SERVER_ERROR,
                         response.status_code)

        self.assertEqual("application/json", response.mimetype)
Exemple #25
0
 def get(self, uri):
     resp, body = self.do_http('GET', uri, '')
     if resp.status >= 400:
         raise HPOneViewException(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
Exemple #26
0
 def create_enet_networks(self, prefix, vid_start, vid_count, bw={}):
     enet_list = []
     try:
         for vid in range(vid_start, vid_start + vid_count):
             enet_name = '%s%s' % (prefix, vid)
             enet_list.append(
                 self.create_enet_network(enet_name, vid, bw=bw))
     except http.client.HTTPException:
         # All or nothing
         for enet in enet_list:
             try:
                 self._con.delete(enet['uri'])
             except http.client.HTTPException:
                 pass
         raise HPOneViewException('Could not create one or more networks')
     return enet_list
Exemple #27
0
    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 HPOneViewException(body)
Exemple #28
0
    def test_get_network_device_function_sh_not_found(self):
        """Tests NetworkDeviceFunction server hardware not found"""

        e = HPOneViewException({
            'errorCode': 'RESOURCE_NOT_FOUND',
            'message': 'server-hardware not found',
        })
        self.oneview_client.server_hardware.get.side_effect = e

        # Get NetworkDeviceFunction
        response = self.client.get(
            "/redfish/v1/Chassis/30303437-3034-4D32-3230-313133364752/"
            "NetworkAdapters/3/NetworkDeviceFunctions/1_1_a")

        self.assertEqual(status.HTTP_404_NOT_FOUND, response.status_code)
        self.assertEqual("application/json", response.mimetype)
    def test_get_network_interface_sh_exception(self, g):
        """Tests NetworkInterface unknown exception"""

        e = HPOneViewException({
            'errorCode': 'ANOTHER_ERROR',
            'message': 'server-hardware error',
        })
        g.oneview_client.server_hardware.get.side_effect = e

        # Get NetworkInterfaceCollection
        response = self.client.get(
            "/redfish/v1/Systems/30303437-3034-4D32-3230-313133364752/"
            "NetworkInterfaces/3")

        self.assertEqual(status.HTTP_500_INTERNAL_SERVER_ERROR,
                         response.status_code)
        self.assertEqual("application/json", response.mimetype)
Exemple #30
0
    def test_get_network_device_function_sh_exception(self):
        """Tests NetworkDeviceFunction unknown exception"""

        e = HPOneViewException({
            'errorCode': 'ANOTHER_ERROR',
            'message': 'server-hardware error',
        })
        self.oneview_client.server_hardware.get.side_effect = e

        # Get NetworkDeviceFunction
        response = self.client.get(
            "/redfish/v1/Chassis/30303437-3034-4D32-3230-313133364752/"
            "NetworkAdapters/3/NetworkDeviceFunctions/1_1_a")

        self.assertEqual(status.HTTP_500_INTERNAL_SERVER_ERROR,
                         response.status_code)
        self.assertEqual("application/json", response.mimetype)