diff --git a/ironic/drivers/modules/oneview/common.py b/ironic/drivers/modules/oneview/common.py index 56376714e1..cb0b871a6e 100644 --- a/ironic/drivers/modules/oneview/common.py +++ b/ironic/drivers/modules/oneview/common.py @@ -12,7 +12,9 @@ # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. + from oslo_log import log as logging +from oslo_serialization import jsonutils from oslo_utils import importutils from six.moves.urllib import parse @@ -226,43 +228,25 @@ def get_oneview_info(node): def validate_oneview_resources_compatibility(oneview_client, task): """Validate if the node configuration is consistent with OneView. - This method calls python-oneviewclient functions to validate if the node + This method calls hpOneView functions to validate if the node configuration is consistent with the OneView resources it represents, - including server_hardware_uri, server_hardware_type_uri, - server_profile_template_uri, enclosure_group_uri and node ports. Also - verifies if a Server Profile is applied to the Server Hardware the node - represents when in pre-allocation model. If any validation fails, - python-oneviewclient will raise an appropriate OneViewException. + including serverHardwareUri, serverHardwareTypeUri, serverGroupUri + serverProfileTemplateUri, enclosureGroupUri and node ports. If any + validation fails, the driver will raise an appropriate OneViewError. :param oneview_client: an instance of the OneView client :param: task: a TaskManager instance containing the node to act on. + :raises: OneViewError if any validation fails. """ - node_ports = task.ports - + ports = task.ports oneview_info = get_oneview_info(task.node) - try: - spt_uuid = oneview_utils.get_uuid_from_uri( - oneview_info.get("server_profile_template_uri") - ) - - oneview_client.validate_node_server_profile_template(oneview_info) - oneview_client.validate_node_server_hardware_type(oneview_info) - oneview_client.validate_node_enclosure_group(oneview_info) - oneview_client.validate_node_server_hardware( - oneview_info, - task.node.properties.get('memory_mb'), - task.node.properties.get('cpus') - ) - oneview_client.is_node_port_mac_compatible_with_server_hardware( - oneview_info, node_ports - ) - oneview_client.validate_server_profile_template_mac_type(spt_uuid) - - except oneview_exceptions.OneViewException as oneview_exc: - msg = (_("Error validating node resources with OneView: %s") % - oneview_exc) - raise exception.OneViewError(error=msg) + _validate_node_server_profile_template(oneview_client, oneview_info) + _validate_node_server_hardware_type(oneview_client, oneview_info) + _validate_node_enclosure_group(oneview_client, oneview_info) + _validate_server_profile_template_mac_type(oneview_client, oneview_info) + _validate_node_port_mac_server_hardware( + oneview_client, oneview_info, ports) def _verify_node_info(node_namespace, node_info_dict, info_required): @@ -292,8 +276,8 @@ def _verify_node_info(node_namespace, node_info_dict, info_required): def node_has_server_profile(func): """Checks if the node's Server Hardware has a Server Profile associated. - Decorator to execute before the function execution if the Server Profile - is applied to the Server Hardware. + Decorator to execute before the function execution to check if the Server + Profile is applied to the Server Hardware. :param func: a given decorated function. """ @@ -322,3 +306,257 @@ def has_server_profile(task, client): {"node": task.node.uuid, "message": exc} ) raise exception.OneViewError(error=exc) + + +def _get_server_hardware_mac_from_ilo(oneview_client, server_hardware): + """Get the MAC of Server Hardware's iLO controller. + + :param: oneview_client: an instance of the HPE OneView client + :param: server_hardware: a server hardware uuid or uri + :return: MAC of Server Hardware's iLO controller. + :raises: InvalidParameterValue if required iLO credentials are missing. + :raises: OneViewError if can't get mac from a server hardware via iLO or + if fails to get JSON object with the default path. + """ + try: + client = get_ilorest_client(oneview_client, server_hardware) + ilo_path = "/rest/v1/systems/1" + hardware = jsonutils.loads(client.get(ilo_path).text) + hardware_mac = hardware['HostCorrelation']['HostMACAddress'][0] + except redfish.JsonDecodingError as exc: + LOG.error("Failed in JSON object getting path: %s", ilo_path) + raise exception.OneViewError(error=exc) + except (ValueError, TypeError, IndexError) as exc: + LOG.error( + "Failed to get mac from server hardware %(server_hardware)s " + "via iLO. Error: %(message)s", { + "server_hardware": server_hardware.get("uri"), + "message": exc + } + ) + raise exception.OneViewError(error=exc) + + return hardware_mac + + +def _get_server_hardware_mac(server_hardware): + """Get the MAC address of the first PXE bootable port of an Ethernet port. + + :param: server_hardware: OneView Server Hardware object + :return: MAC of the first Ethernet and function 'a' port of the + Server Hardware object + :raises: OneViewError if there is no Ethernet port on the Server Hardware + or if there is no portMap on the Server Hardware requested + """ + sh_physical_port = None + + if server_hardware.get('portMap'): + for device in server_hardware.get( + 'portMap', {}).get('deviceSlots', ()): + for physical_port in device.get('physicalPorts', ()): + if physical_port.get('type') == 'Ethernet': + sh_physical_port = physical_port + break + if sh_physical_port: + for virtual_port in sh_physical_port.get('virtualPorts', ()): + # NOTE(nicodemos): Ironic oneview drivers needs to use a + # port that type is Ethernet and function identifier 'a' for + # this FlexNIC to be able to make a deploy using PXE. + if virtual_port.get('portFunction') == 'a': + return virtual_port.get('mac', ()).lower() + raise exception.OneViewError( + _("There is no Ethernet port on the Server Hardware: %s") % + server_hardware.get('uri')) + else: + raise exception.OneViewError( + _("The Server Hardware: %s doesn't have a list of adapters/slots, " + "their ports and attributes. This information is available only " + "for blade servers. Is this a rack server?") % + server_hardware.get('uri')) + + +def _validate_node_server_profile_template(oneview_client, oneview_info): + """Validate if the Server Profile Template is consistent. + + :param: oneview_client: an instance of the HPE OneView client + :param: oneview_info: the OneView related info in an Ironic node + :raises: OneViewError if the node's Server Profile Template is not + consistent + """ + server_profile_template = oneview_client.server_profile_templates.get( + oneview_info['server_profile_template_uri']) + server_hardware = oneview_client.server_hardware.get( + oneview_info['server_hardware_uri']) + + _validate_server_profile_template_server_hardware_type( + server_profile_template, server_hardware) + _validate_spt_enclosure_group(server_profile_template, server_hardware) + _validate_server_profile_template_manage_boot(server_profile_template) + + +def _validate_server_profile_template_server_hardware_type( + server_profile_template, server_hardware): + """Validate if the Server Hardware Types are the same. + + Validate if the Server Profile Template and the Server Hardware have the + same Server Hardware Type + + :param: server_profile_template: OneView Server Profile Template object + :param: server_hardware: OneView Server Hardware object + :raises: OneViewError if the Server Profile Template and the Server + Hardware does not have the same Server Hardware Type + """ + spt_server_hardware_type_uri = ( + server_profile_template.get('serverHardwareTypeUri') + ) + sh_server_hardware_type_uri = server_hardware.get('serverHardwareTypeUri') + + if spt_server_hardware_type_uri != sh_server_hardware_type_uri: + message = _( + "Server profile template %(spt_uri)s serverHardwareTypeUri is " + "inconsistent with server hardware %(server_hardware_uri)s " + "serverHardwareTypeUri.") % { + 'spt_uri': server_profile_template.get('uri'), + 'server_hardware_uri': server_hardware.get('uri')} + raise exception.OneViewError(message) + + +def _validate_spt_enclosure_group(server_profile_template, server_hardware): + """Validate Server Profile Template's Enclosure Group and Server Hardware's. + + :param: server_profile_template: OneView Server Profile Template object + :param: server_hardware: OneView Server Hardware object + :raises: OneViewError if the Server Profile Template's Enclosure Group does + not match the Server Hardware's + """ + spt_enclosure_group_uri = server_profile_template.get('enclosureGroupUri') + sh_enclosure_group_uri = server_hardware.get('serverGroupUri') + + if spt_enclosure_group_uri != sh_enclosure_group_uri: + message = _("Server profile template %(spt_uri)s enclosureGroupUri is " + "inconsistent with server hardware %(sh_uri)s " + "serverGroupUri.") % { + 'spt_uri': server_profile_template.get('uri'), + 'sh_uri': server_hardware.get('uri')} + raise exception.OneViewError(message) + + +def _validate_server_profile_template_manage_boot(server_profile_template): + """Validate if the Server Profile Template allows to manage the boot order. + + :param: server_profile_template: OneView Server Profile Template object + :raises: OneViewError if the Server Profile Template does not allows to + manage the boot order. + """ + manage_boot = server_profile_template.get('boot', {}).get('manageBoot') + + if not manage_boot: + message = _("Server Profile Template: %s, does not allow to manage " + "boot order.") % server_profile_template.get('uri') + raise exception.OneViewError(message) + + +def _validate_node_server_hardware_type(oneview_client, oneview_info): + """Validate if the node's Server Hardware Type matches Server Hardware's. + + :param: oneview_client: the HPE OneView Client + :param: oneview_info: the OneView related info in an Ironic node + :raises: OneViewError if the node's Server Hardware Type group doesn't + match the Server Hardware's + """ + node_server_hardware_type_uri = oneview_info['server_hardware_type_uri'] + server_hardware = oneview_client.server_hardware.get( + oneview_info['server_hardware_uri']) + server_hardware_sht_uri = server_hardware.get('serverHardwareTypeUri') + + if server_hardware_sht_uri != node_server_hardware_type_uri: + message = _("Node server_hardware_type_uri is inconsistent " + "with OneView's server hardware %(server_hardware_uri)s " + "serverHardwareTypeUri.") % { + 'server_hardware_uri': server_hardware.get('uri')} + raise exception.OneViewError(message) + + +def _validate_node_enclosure_group(oneview_client, oneview_info): + """Validate if the node's Enclosure Group matches the Server Hardware's. + + :param: oneview_client: an instance of the HPE OneView client + :param: oneview_info: the OneView related info in an Ironic node + :raises: OneViewError if the node's enclosure group doesn't match the + Server Hardware's + """ + server_hardware = oneview_client.server_hardware.get( + oneview_info['server_hardware_uri']) + sh_enclosure_group_uri = server_hardware.get('serverGroupUri') + node_enclosure_group_uri = oneview_info['enclosure_group_uri'] + + if node_enclosure_group_uri and ( + sh_enclosure_group_uri != node_enclosure_group_uri): + message = _( + "Node enclosure_group_uri '%(node_enclosure_group_uri)s' " + "is inconsistent with OneView's server hardware " + "serverGroupUri '%(sh_enclosure_group_uri)s' of " + "ServerHardware %(server_hardware)s") % { + 'node_enclosure_group_uri': node_enclosure_group_uri, + 'sh_enclosure_group_uri': sh_enclosure_group_uri, + 'server_hardware': server_hardware.get('uri')} + raise exception.OneViewError(message) + + +def _validate_node_port_mac_server_hardware(oneview_client, + oneview_info, ports): + """Validate if a port matches the node's Server Hardware's MAC. + + :param: oneview_client: an instance of the HPE OneView client + :param: oneview_info: the OneView related info in an Ironic node + :param: ports: a list of Ironic node's ports + :raises: OneViewError if there is no port with MAC address matching one + in OneView + + """ + server_hardware = oneview_client.server_hardware.get( + oneview_info['server_hardware_uri']) + + if not ports: + return + + # NOTE(nicodemos) If hponeview client's unable to get the MAC of the Server + # Hardware and raises an exception, the driver will try to get it from + # the iLOrest client. + try: + mac = _get_server_hardware_mac(server_hardware) + except exception.OneViewError: + mac = _get_server_hardware_mac_from_ilo( + oneview_client, server_hardware) + + incompatible_macs = [] + for port in ports: + if port.address.lower() == mac.lower(): + return + incompatible_macs.append(port.address) + + message = _("The ports of the node are not compatible with its " + "server hardware %(server_hardware_uri)s. There are no Ironic " + "port MAC's: %(port_macs)s, that matches with the " + "server hardware's MAC: %(server_hardware_mac)s") % { + 'server_hardware_uri': server_hardware.get('uri'), + 'port_macs': ', '.join(incompatible_macs), + 'server_hardware_mac': mac} + raise exception.OneViewError(message) + + +def _validate_server_profile_template_mac_type(oneview_client, oneview_info): + """Validate if the node's Server Profile Template's MAC type is physical. + + :param: oneview_client: an instance of the HPE OneView client + :param: oneview_info: the OneView related info in an Ironic node + :raises: OneViewError if the node's Server Profile Template's MAC type is + not physical + """ + server_profile_template = oneview_client.server_profile_templates.get( + oneview_info['server_profile_template_uri'] + ) + if server_profile_template.get('macType') != 'Physical': + message = _("The server profile template %s is not set to use " + "physical MAC.") % server_profile_template.get('uri') + raise exception.OneViewError(message) diff --git a/ironic/drivers/modules/oneview/deploy.py b/ironic/drivers/modules/oneview/deploy.py index e8fa9e92da..d4553a32f0 100644 --- a/ironic/drivers/modules/oneview/deploy.py +++ b/ironic/drivers/modules/oneview/deploy.py @@ -230,8 +230,7 @@ class OneViewIscsiDeploy(iscsi_deploy.ISCSIDeploy, OneViewPeriodicTasks): def validate(self, task): common.verify_node_info(task.node) try: - common.validate_oneview_resources_compatibility( - self.oneview_client, task) + common.validate_oneview_resources_compatibility(self.client, task) except exception.OneViewError as oneview_exc: raise exception.InvalidParameterValue(oneview_exc) super(OneViewIscsiDeploy, self).validate(task) @@ -275,8 +274,7 @@ class OneViewAgentDeploy(agent.AgentDeploy, OneViewPeriodicTasks): def validate(self, task): common.verify_node_info(task.node) try: - common.validate_oneview_resources_compatibility( - self.oneview_client, task) + common.validate_oneview_resources_compatibility(self.client, task) except exception.OneViewError as oneview_exc: raise exception.InvalidParameterValue(oneview_exc) super(OneViewAgentDeploy, self).validate(task) diff --git a/ironic/drivers/modules/oneview/inspect.py b/ironic/drivers/modules/oneview/inspect.py index 5aa87e9bb5..fc3838d508 100644 --- a/ironic/drivers/modules/oneview/inspect.py +++ b/ironic/drivers/modules/oneview/inspect.py @@ -59,8 +59,7 @@ class OneViewInspect(inspector.Inspector): common.verify_node_info(task.node) try: - common.validate_oneview_resources_compatibility( - self.oneview_client, task) + common.validate_oneview_resources_compatibility(self.client, task) except exception.OneViewError as oneview_exc: raise exception.InvalidParameterValue(oneview_exc) diff --git a/ironic/drivers/modules/oneview/management.py b/ironic/drivers/modules/oneview/management.py index 5984b906a3..f94c1bca3a 100644 --- a/ironic/drivers/modules/oneview/management.py +++ b/ironic/drivers/modules/oneview/management.py @@ -191,8 +191,7 @@ class OneViewManagement(base.ManagementInterface): common.verify_node_info(task.node) try: - common.validate_oneview_resources_compatibility( - self.oneview_client, task) + common.validate_oneview_resources_compatibility(self.client, task) if not deploy_utils.is_node_in_use_by_ironic( self.client, task.node diff --git a/ironic/drivers/modules/oneview/power.py b/ironic/drivers/modules/oneview/power.py index fadc0956d0..fe4115bf58 100644 --- a/ironic/drivers/modules/oneview/power.py +++ b/ironic/drivers/modules/oneview/power.py @@ -90,15 +90,12 @@ class OneViewPower(base.PowerInterface): common.verify_node_info(task.node) try: - if deploy_utils.is_node_in_use_by_oneview( - self.client, task.node - ): + common.validate_oneview_resources_compatibility(self.client, task) + + if deploy_utils.is_node_in_use_by_oneview(self.client, task.node): raise exception.InvalidParameterValue( _("Node %s is in use by OneView.") % task.node.uuid) - common.validate_oneview_resources_compatibility( - self.oneview_client, task - ) except exception.OneViewError as oneview_exc: raise exception.InvalidParameterValue(oneview_exc) diff --git a/ironic/tests/unit/drivers/modules/oneview/test_common.py b/ironic/tests/unit/drivers/modules/oneview/test_common.py index 751e5a0d32..7f26221ed6 100644 --- a/ironic/tests/unit/drivers/modules/oneview/test_common.py +++ b/ironic/tests/unit/drivers/modules/oneview/test_common.py @@ -14,6 +14,7 @@ # under the License. import mock + from oslo_utils import importutils from ironic.common import exception @@ -239,35 +240,139 @@ class OneViewCommonTestCase(db_base.DbTestCase): {"a": '', "b": None, "c": "something"}, ["a", "b", "c"]) - @mock.patch.object(common, 'get_oneview_client', spec_set=True, - autospec=True) + @mock.patch.object(common, 'get_hponeview_client', autospec=True) + @mock.patch.object(common, '_validate_node_server_profile_template') + @mock.patch.object(common, '_validate_node_server_hardware_type') + @mock.patch.object(common, '_validate_node_enclosure_group') + @mock.patch.object(common, '_validate_node_port_mac_server_hardware') + @mock.patch.object(common, '_validate_server_profile_template_mac_type') def test_validate_oneview_resources_compatibility( - self, mock_get_ov_client): + self, mock_spt_mac_type, mock_port_mac_sh, mock_enclosure, + mock_sh_type, mock_sp_template, mock_hponeview): """Validate compatibility of resources. - 1) Check validate_node_server_profile_template method is called - 2) Check validate_node_server_hardware_type method is called - 3) Check validate_node_enclosure_group method is called - 4) Check validate_node_server_hardware method is called - 5) Check is_node_port_mac_compatible_with_server_hardware method - is called - 6) Check validate_server_profile_template_mac_type method is called + 1) Check _validate_node_server_profile_template method is called + 2) Check _validate_node_server_hardware_type method is called + 3) Check _validate_node_enclosure_group method is called + 4) Check _validate_node_port_mac_server_hardware method is called + 5) Check _validate_server_profile_template_mac_type method is called """ - oneview_client = mock_get_ov_client() + oneview_client = mock_hponeview() + fake_port = db_utils.create_test_port() + fake_port.address = 'AA:BB:CC:DD:EE' + fake_device = {'physicalPorts': [ + {'type': 'Ethernet', + 'virtualPorts': [ + {'portFunction': 'a', + 'mac': 'AA:BB:CC:DD:EE'} + ]} + ]} + fake_spt = { + 'serverHardwareTypeUri': 'fake_sht_uri', + 'enclosureGroupUri': 'fake_eg_uri', + 'macType': 'Physical', + 'boot': {'manageBoot': True} + } + fake_sh = { + 'serverHardwareTypeUri': 'fake_sht_uri', + 'serverGroupUri': 'fake_eg_uri', + 'processorCoreCount': 4, + 'processorCount': 2, + 'memoryMb': 4096, + 'portMap': {'deviceSlots': [fake_device]} + } + oneview_client.server_profile_templates.get.return_value = fake_spt + oneview_client.server_hardware.get.return_value = fake_sh + with task_manager.acquire(self.context, self.node.uuid) as task: + task.ports = [fake_port] common.validate_oneview_resources_compatibility(oneview_client, task) - self.assertTrue( - oneview_client.validate_node_server_profile_template.called) - self.assertTrue( - oneview_client.validate_node_server_hardware_type.called) - self.assertTrue( - oneview_client.validate_node_enclosure_group.called) - self.assertTrue( - oneview_client.validate_node_server_hardware.called) - self.assertTrue( - oneview_client. - is_node_port_mac_compatible_with_server_hardware.called) - self.assertTrue( - oneview_client. - validate_server_profile_template_mac_type.called) + self.assertTrue(mock_sp_template.called) + self.assertTrue(mock_sh_type.called) + self.assertTrue(mock_enclosure.called) + self.assertTrue(mock_port_mac_sh.called) + self.assertTrue(mock_spt_mac_type.called) + + @mock.patch.object(common, 'get_hponeview_client', autospec=True) + def test__validate_server_profile_template_mac_type_virtual( + self, mock_hponeview): + oneview_client = mock_hponeview() + fake_spt = {'macType': 'Virtual'} + oneview_client.server_hardware.get.return_value = fake_spt + oneview_info = {'server_profile_template_uri': 'fake_uri'} + + self.assertRaises(exception.OneViewError, + common._validate_server_profile_template_mac_type, + oneview_client, oneview_info) + + @mock.patch.object(common, 'get_hponeview_client', autospec=True) + def test__validate_node_port_mac_server_hardware_invalid( + self, mock_hponeview): + oneview_client = mock_hponeview() + fake_device = { + 'physicalPorts': [ + {'type': 'notEthernet', + 'mac': '00:11:22:33:44', + 'virtualPorts': [{ + 'portFunction': 'a', + 'mac': 'AA:BB:CC:DD:EE'}]}, + {'type': 'Ethernet', + 'mac': '11:22:33:44:55', + 'virtualPorts': [{ + 'portFunction': 'a', + 'mac': 'BB:CC:DD:EE:FF'}]}]} + fake_sh = {'portMap': {'deviceSlots': [fake_device]}} + fake_port = db_utils.create_test_port(address='AA:BB:CC:DD:EE') + oneview_client.server_hardware.get.return_value = fake_sh + oneview_info = db_utils.get_test_oneview_driver_info() + + self.assertRaises(exception.OneViewError, + common._validate_node_port_mac_server_hardware, + oneview_client, oneview_info, [fake_port]) + + @mock.patch.object(common, 'get_hponeview_client', autospec=True) + def test__validate_node_enclosure_group_invalid(self, mock_hponeview): + oneview_client = mock_hponeview() + fake_sh = {'serverGroupUri': 'invalid_fake_eg_uri'} + oneview_client.server_hardware.get.return_value = fake_sh + oneview_info = {'server_hardware_uri': 'fake_sh_uri', + 'enclosure_group_uri': 'fake_eg_uri'} + + self.assertRaises(exception.OneViewError, + common._validate_node_enclosure_group, + oneview_client, oneview_info) + + @mock.patch.object(common, 'get_hponeview_client', autospec=True) + def test__validate_node_server_hardware_type(self, mock_hponeview): + oneview_client = mock_hponeview() + fake_sh = {'serverHardwareTypeUri': 'invalid_fake_sh_uri'} + oneview_client.server_hardware.get.return_value = fake_sh + oneview_info = {'server_hardware_uri': 'fake_sh_uri', + 'server_hardware_type_uri': 'fake_sht_uri'} + + self.assertRaises(exception.OneViewError, + common._validate_node_server_hardware_type, + oneview_client, oneview_info) + + def test__validate_server_profile_template_manage_boot_false(self): + fake_spt = {'boot': {'manageBoot': False}} + self.assertRaises(exception.OneViewError, + common._validate_server_profile_template_manage_boot, + fake_spt) + + def test__validate_spt_enclosure_group_invalid(self): + fake_spt = {'enclosureGroupUri': 'fake_eg_uri'} + fake_sh = {'serverGroupUri': 'invalid_fake_eg_uri'} + self.assertRaises(exception.OneViewError, + common._validate_spt_enclosure_group, + fake_spt, fake_sh) + + def test__validate_server_profile_template_server_hardware_type(self): + fake_spt = {'serverHardwareTypeUri': 'fake_sht_uri'} + fake_sh = {'serverHardwareTypeUri': 'invalid_fake_sht_uri'} + self.assertRaises( + exception.OneViewError, + common._validate_server_profile_template_server_hardware_type, + fake_spt, fake_sh + ) diff --git a/ironic/tests/unit/drivers/modules/oneview/test_deploy.py b/ironic/tests/unit/drivers/modules/oneview/test_deploy.py index 233ea487ff..0dd8e003f8 100644 --- a/ironic/tests/unit/drivers/modules/oneview/test_deploy.py +++ b/ironic/tests/unit/drivers/modules/oneview/test_deploy.py @@ -278,10 +278,16 @@ class OneViewIscsiDeployTestCase(db_base.DbTestCase): expected = common.COMMON_PROPERTIES self.assertEqual(expected, self.driver.deploy.get_properties()) - @mock.patch.object(iscsi_deploy.ISCSIDeploy, 'validate', autospec=True) - def test_validate(self, iscsi_deploy_validate_mock, mock_get_ov_client): - with task_manager.acquire(self.context, self.node.uuid) as task: + @mock.patch.object(common, 'validate_oneview_resources_compatibility', + spect_set=True, autospec=True) + @mock.patch.object(iscsi_deploy.ISCSIDeploy, 'validate', + spec_set=True, autospec=True) + def test_validate(self, iscsi_deploy_validate_mock, + mock_validate_resources, mock_ov_client): + with task_manager.acquire(self.context, self.node.uuid, + shared=False) as task: task.driver.deploy.validate(task) + self.assertTrue(mock_validate_resources.called) iscsi_deploy_validate_mock.assert_called_once_with(mock.ANY, task) @mock.patch.object(iscsi_deploy.ISCSIDeploy, 'prepare', autospec=True) @@ -397,10 +403,16 @@ class OneViewAgentDeployTestCase(db_base.DbTestCase): expected = common.COMMON_PROPERTIES self.assertEqual(expected, self.driver.deploy.get_properties()) - @mock.patch.object(agent.AgentDeploy, 'validate', autospec=True) - def test_validate(self, agent_deploy_validate_mock, mock_get_ov_client): - with task_manager.acquire(self.context, self.node.uuid) as task: + @mock.patch.object(common, 'validate_oneview_resources_compatibility', + spect_set=True, autospec=True) + @mock.patch.object(agent.AgentDeploy, 'validate', + spec_set=True, autospec=True) + def test_validate(self, agent_deploy_validate_mock, + mock_validate_resources, mock_ov_client): + with task_manager.acquire(self.context, self.node.uuid, + shared=False) as task: task.driver.deploy.validate(task) + self.assertTrue(mock_validate_resources.called) agent_deploy_validate_mock.assert_called_once_with(mock.ANY, task) @mock.patch.object(agent.AgentDeploy, 'prepare', autospec=True) diff --git a/ironic/tests/unit/drivers/modules/oneview/test_inspect.py b/ironic/tests/unit/drivers/modules/oneview/test_inspect.py index f42f978708..53f0a3ca1e 100644 --- a/ironic/tests/unit/drivers/modules/oneview/test_inspect.py +++ b/ironic/tests/unit/drivers/modules/oneview/test_inspect.py @@ -16,7 +16,7 @@ import mock from ironic.conductor import task_manager -from ironic.drivers.modules.oneview import common as oneview_common +from ironic.drivers.modules.oneview import common from ironic.drivers.modules.oneview import deploy_utils from ironic.tests.unit.conductor import mgr_utils from ironic.tests.unit.db import base as db_base @@ -43,13 +43,13 @@ class AgentPXEOneViewInspectTestCase(db_base.DbTestCase): shared=True) as task: self.assertEqual(expected, task.driver.inspect.get_properties()) - @mock.patch.object(oneview_common, 'verify_node_info') - def test_validate(self, mock_verify_node_info): + @mock.patch.object(common, 'validate_oneview_resources_compatibility') + def test_validate(self, mock_validate): self.config(enabled=False, group='inspector') with task_manager.acquire(self.context, self.node.uuid, shared=False) as task: task.driver.inspect.validate(task) - mock_verify_node_info.assert_called_once_with(task.node) + self.assertTrue(mock_validate.called) @mock.patch.object(deploy_utils, 'allocate_server_hardware_to_ironic') def test_inspect_hardware(self, mock_allocate_server_hardware_to_ironic): @@ -78,13 +78,13 @@ class ISCSIPXEOneViewInspectTestCase(db_base.DbTestCase): shared=True) as task: self.assertEqual(expected, task.driver.inspect.get_properties()) - @mock.patch.object(oneview_common, 'verify_node_info') - def test_validate(self, mock_verify_node_info): + @mock.patch.object(common, 'validate_oneview_resources_compatibility') + def test_validate(self, mock_validate): self.config(enabled=False, group='inspector') with task_manager.acquire(self.context, self.node.uuid, shared=False) as task: task.driver.inspect.validate(task) - mock_verify_node_info.assert_called_once_with(task.node) + self.assertTrue(mock_validate.called) @mock.patch.object(deploy_utils, 'allocate_server_hardware_to_ironic') def test_inspect_hardware(self, mock_allocate_server_hardware_to_ironic): diff --git a/ironic/tests/unit/drivers/modules/oneview/test_management.py b/ironic/tests/unit/drivers/modules/oneview/test_management.py index 9b0054faea..c6bbf1f699 100644 --- a/ironic/tests/unit/drivers/modules/oneview/test_management.py +++ b/ironic/tests/unit/drivers/modules/oneview/test_management.py @@ -236,18 +236,22 @@ class OneViewManagementDriverTestCase(db_base.DbTestCase): ) self.info = common.get_oneview_info(self.node) - @mock.patch.object(deploy_utils, 'is_node_in_use_by_ironic') - @mock.patch.object(common, 'validate_oneview_resources_compatibility') - def test_validate(self, mock_validate, mock_ironic_node, mock_ovclient): + @mock.patch.object(deploy_utils, 'is_node_in_use_by_ironic', + spect_set=True, autospec=True) + @mock.patch.object(common, 'validate_oneview_resources_compatibility', + spect_set=True, autospec=True) + def test_validate(self, mock_validate, mock_ironic_node, mock_ov_client): mock_ironic_node.return_value = True - with task_manager.acquire(self.context, self.node.uuid) as task: + with task_manager.acquire(self.context, self.node.uuid, + shared=False) as task: task.driver.management.validate(task) self.assertTrue(mock_validate.called) - @mock.patch.object(deploy_utils, 'is_node_in_use_by_ironic') - @mock.patch.object(common, 'validate_oneview_resources_compatibility') + @mock.patch.object(deploy_utils, 'is_node_in_use_by_ironic', + spect_set=True, autospec=True) def test_validate_for_node_not_in_use_by_ironic( - self, mock_validate, mock_ironic_node, mock_ovclient): + self, mock_ironic_node, mock_get_ov_client + ): mock_ironic_node.return_value = False with task_manager.acquire(self.context, self.node.uuid) as task: self.assertRaises(exception.InvalidParameterValue, diff --git a/releasenotes/notes/oneview-validations-f6d702d1fab77f91.yaml b/releasenotes/notes/oneview-validations-f6d702d1fab77f91.yaml new file mode 100644 index 0000000000..58b7128508 --- /dev/null +++ b/releasenotes/notes/oneview-validations-f6d702d1fab77f91.yaml @@ -0,0 +1,7 @@ +--- +other: + - | + Adds the implementation of the validations for the OneView hardware type, + migrating from python-oneviewclient library to OneView driver. This process + is part of migrating from ``python-oneviewclient`` to ``python-hpOneView`` + and ``python-ilorest-library``.