def test_add_ports_to_vlan_network(self, create_mock): # Ports will be created only if pxe_enabled is True object_utils.create_test_port( self.context, node_id=self.node.id, uuid=uuidutils.generate_uuid(), address='52:54:00:cf:2d:22', pxe_enabled=False ) port = self.ports[0] expected_body = { 'port': { 'network_id': self.network_uuid, 'admin_state_up': True, 'binding:vnic_type': 'baremetal', 'device_owner': 'baremetal:none', 'binding:host_id': self.node.uuid, 'device_id': self.node.uuid, 'mac_address': port.address, 'binding:profile': { 'local_link_information': [port.local_link_connection] } } } # Ensure we can create ports create_mock.return_value = {'port': self.neutron_port} expected = {port.uuid: self.neutron_port['id']} with task_manager.acquire(self.context, self.node.uuid) as task: ports = neutron.add_ports_to_network(task, self.network_uuid) self.assertEqual(expected, ports) create_mock.assert_called_once_with(expected_body)
def test_get_all_by_node_uuid_and_name(self, mock_get_rpc_node): # GET /v1/ports specifying node and uuid - should only use node_uuid mock_get_rpc_node.return_value = self.node obj_utils.create_test_port(self.context, node_id=self.node.id) self.get_json('/ports/detail?node_uuid=%s&node=%s' % (self.node.uuid, 'node-name')) mock_get_rpc_node.assert_called_once_with(self.node.uuid)
def test__write_infiniband_mac_pxe_configs( self, unlink_mock, create_link_mock): client_id1 = ( '20:00:55:04:01:fe:80:00:00:00:00:00:00:00:02:c9:02:00:23:13:92') port_1 = object_utils.create_test_port( self.context, node_id=self.node.id, address='11:22:33:44:55:66', uuid=uuidutils.generate_uuid(), extra={'client-id': client_id1}) client_id2 = ( '20:00:55:04:01:fe:80:00:00:00:00:00:00:00:02:c9:02:00:23:45:12') port_2 = object_utils.create_test_port( self.context, node_id=self.node.id, address='11:22:33:44:55:67', uuid=uuidutils.generate_uuid(), extra={'client-id': client_id2}) create_link_calls = [ mock.call(u'../1be26c0b-03f2-4d2e-ae87-c02d7f33c123/config', '/tftpboot/pxelinux.cfg/20-11-22-33-44-55-66'), mock.call(u'../1be26c0b-03f2-4d2e-ae87-c02d7f33c123/config', '/tftpboot/pxelinux.cfg/20-11-22-33-44-55-67') ] unlink_calls = [ mock.call('/tftpboot/pxelinux.cfg/20-11-22-33-44-55-66'), mock.call('/tftpboot/pxelinux.cfg/20-11-22-33-44-55-67'), ] with task_manager.acquire(self.context, self.node.uuid) as task: task.ports = [port_1, port_2] pxe_utils._link_mac_pxe_configs(task) unlink_mock.assert_has_calls(unlink_calls) create_link_mock.assert_has_calls(create_link_calls)
def test_port_by_address_invalid_address_format(self): obj_utils.create_test_port(self.context, node_id=self.node.id) invalid_address = 'invalid-mac-format' response = self.get_json('/ports?address=%s' % invalid_address, expect_errors=True) self.assertEqual(http_client.BAD_REQUEST, response.status_int) self.assertEqual('application/json', response.content_type) self.assertIn(invalid_address, response.json['error_message'])
def test__unbind_flat_ports(self, unbind_neutron_port_mock): extra = {'vif_port_id': 'foo'} utils.create_test_port(self.context, node_id=self.node.id, address='52:54:00:cf:2d:33', extra=extra, uuid=uuidutils.generate_uuid()) with task_manager.acquire(self.context, self.node.id) as task: self.interface._unbind_flat_ports(task) unbind_neutron_port_mock.assert_called_once_with('foo', context=self.context)
def test_detail_by_node_name_not_supported(self, mock_get_rpc_node): # GET /v1/ports/detail specifying node_name - name not supported mock_get_rpc_node.side_effect = ( exception.InvalidUuidOrName(name=self.node.uuid)) obj_utils.create_test_port(self.context, node_id=self.node.id) data = self.get_json('/ports/detail?node=%s' % 'test-node', expect_errors=True) self.assertEqual(0, mock_get_rpc_node.call_count) self.assertEqual(http_client.NOT_ACCEPTABLE, data.status_int)
def test__bind_flat_ports_set_binding_host_id_raise(self, client_mock): client_mock.return_value.update_port.side_effect = \ (neutron_exceptions.ConnectionFailed()) extra = {'vif_port_id': 'foo'} utils.create_test_port(self.context, node_id=self.node.id, address='52:54:00:cf:2d:33', extra=extra, uuid=uuidutils.generate_uuid()) with task_manager.acquire(self.context, self.node.id) as task: self.assertRaises(exception.NetworkError, self.interface._bind_flat_ports, task)
def test_old_api_version(self): obj_utils.create_test_port(self.context, node_id=self.node.id, address=self.addresses[1]) response = self.get_json( '/lookup?addresses=%s' % ','.join(self.addresses), headers={api_base.Version.string: str(api_v1.MIN_VER)}, expect_errors=True) self.assertEqual(http_client.NOT_FOUND, response.status_int)
def test_two_ports(self): object_utils.create_test_port(self.context, node_id=self.node.id, portgroup_id=self.portgroup.id, physical_network='physnet1') object_utils.create_test_port(self.context, node_id=self.node.id, uuid=uuidutils.generate_uuid(), address='00:11:22:33:44:55', portgroup_id=self.portgroup.id, physical_network='physnet1') self._test({'physnet1'})
def test_configure_tenant_networks_with_portgroups( self, glgi_mock, client_mock, wait_agent_mock): pg = utils.create_test_portgroup( self.context, node_id=self.node.id, address='ff:54:00:cf:2d:32', extra={'vif_port_id': uuidutils.generate_uuid()}) port1 = utils.create_test_port( self.context, node_id=self.node.id, address='ff:54:00:cf:2d:33', uuid=uuidutils.generate_uuid(), portgroup_id=pg.id, local_link_connection={'switch_id': '0a:1b:2c:3d:4e:ff', 'port_id': 'Ethernet1/1', 'switch_info': 'switch2'} ) port2 = utils.create_test_port( self.context, node_id=self.node.id, address='ff:54:00:cf:2d:34', uuid=uuidutils.generate_uuid(), portgroup_id=pg.id, local_link_connection={'switch_id': '0a:1b:2c:3d:4e:ff', 'port_id': 'Ethernet1/2', 'switch_info': 'switch2'} ) upd_mock = mock.Mock() client_mock.return_value.update_port = upd_mock local_group_info = {'a': 'b'} glgi_mock.return_value = local_group_info expected_body = { 'port': { 'binding:vnic_type': 'baremetal', 'binding:host_id': self.node.uuid, } } call1_body = copy.deepcopy(expected_body) call1_body['port']['binding:profile'] = { 'local_link_information': [self.port.local_link_connection], } call1_body['port']['mac_address'] = '52:54:00:cf:2d:32' call2_body = copy.deepcopy(expected_body) call2_body['port']['binding:profile'] = { 'local_link_information': [port1.local_link_connection, port2.local_link_connection], 'local_group_information': local_group_info } call2_body['port']['mac_address'] = 'ff:54:00:cf:2d:32' with task_manager.acquire(self.context, self.node.id) as task: # Override task.portgroups here, to have ability to check # that mocked get_local_group_information was called with # this portgroup object. task.portgroups = [pg] self.interface.configure_tenant_networks(task) client_mock.assert_called_once_with(context=task.context) glgi_mock.assert_called_once_with(task, pg) upd_mock.assert_has_calls( [mock.call(self.port.extra['vif_port_id'], call1_body), mock.call(pg.extra['vif_port_id'], call2_body)] )
def test_configure_tenant_networks_with_portgroups(self, client_mock): pg = utils.create_test_portgroup( self.context, node_id=self.node.id, address="ff:54:00:cf:2d:32", extra={"vif_port_id": uuidutils.generate_uuid()}, ) port1 = utils.create_test_port( self.context, node_id=self.node.id, address="ff:54:00:cf:2d:33", uuid=uuidutils.generate_uuid(), portgroup_id=pg.id, local_link_connection={ "switch_id": "0a:1b:2c:3d:4e:ff", "port_id": "Ethernet1/1", "switch_info": "switch2", }, ) port2 = utils.create_test_port( self.context, node_id=self.node.id, address="ff:54:00:cf:2d:34", uuid=uuidutils.generate_uuid(), portgroup_id=pg.id, local_link_connection={ "switch_id": "0a:1b:2c:3d:4e:ff", "port_id": "Ethernet1/2", "switch_info": "switch2", }, ) upd_mock = mock.Mock() client_mock.return_value.update_port = upd_mock expected_body = { "port": { "device_owner": "baremetal:none", "device_id": self.node.uuid, "admin_state_up": True, "binding:vnic_type": "baremetal", "binding:host_id": self.node.uuid, } } call1_body = copy.deepcopy(expected_body) call1_body["port"]["binding:profile"] = {"local_link_information": [self.port.local_link_connection]} call2_body = copy.deepcopy(expected_body) call2_body["port"]["binding:profile"] = { "local_link_information": [port1.local_link_connection, port2.local_link_connection] } with task_manager.acquire(self.context, self.node.id) as task: self.interface.configure_tenant_networks(task) client_mock.assert_called_once_with(task.context.auth_token) upd_mock.assert_has_calls( [mock.call(self.port.extra["vif_port_id"], call1_body), mock.call(pg.extra["vif_port_id"], call2_body)] )
def setUp(self): super(LibvirtManagementTestCase, self).setUp() mgr_utils.mock_the_extension_manager(driver="fake_libvirt_fake") driver_factory.get_driver("fake_libvirt_fake") self.node = obj_utils.create_test_node( self.context, driver='fake_libvirt_fake', driver_info=_get_test_libvirt_driver_info('sasl')) obj_utils.create_test_port(self.context, node_id=self.node.id, address='52:54:00:5c:b7:df')
def test_get_physnets_for_node_multiple_ports(self): node = object_utils.create_test_node(self.context) object_utils.create_test_port(self.context, node_id=node.id, physical_network='physnet1') object_utils.create_test_port(self.context, node_id=node.id, uuid=uuidutils.generate_uuid(), address='00:11:22:33:44:55', physical_network='physnet2') with task_manager.acquire(self.context, node.uuid) as task: res = network.get_physnets_for_node(task) self.assertEqual({'physnet1', 'physnet2'}, res)
def test_found_by_addresses(self): obj_utils.create_test_port(self.context, node_id=self.node.id, address=self.addresses[1]) data = self.get_json( '/lookup?addresses=%s' % ','.join(self.addresses), headers={api_base.Version.string: str(api_v1.MAX_VER)}) self.assertEqual(self.node.uuid, data['node']['uuid']) self.assertEqual(set(ramdisk._LOOKUP_RETURN_FIELDS) | {'links'}, set(data['node'])) self._check_config(data)
def test_clean_up_pxe_config(self, unlink_mock, rmtree_mock): address = "aa:aa:aa:aa:aa:aa" object_utils.create_test_port(self.context, node_id=self.node.id, address=address) with task_manager.acquire(self.context, self.node.uuid) as task: pxe_utils.clean_up_pxe_config(task) unlink_mock.assert_called_once_with("/tftpboot/pxelinux.cfg/01-%s" % address.replace(':', '-')) rmtree_mock.assert_called_once_with( os.path.join(CONF.pxe.tftp_root, self.node.uuid))
def test_exclude_port_no_id(self): # During port creation there may be no 'id' field. object_utils.create_test_port(self.context, node_id=self.node.id, portgroup_id=self.portgroup.id, physical_network='physnet1') port2 = object_utils.get_test_port(self.context, node_id=self.node.id, uuid=uuidutils.generate_uuid(), address='00:11:22:33:44:55', portgroup_id=self.portgroup.id, physical_network='physnet2') self._test({'physnet1'}, port2)
def test_ports_by_portgroup_id(self): node = object_utils.create_test_node(self.context) portgroup = object_utils.create_test_portgroup(self.context, node_id=node.id) port = object_utils.create_test_port(self.context, node_id=node.id, portgroup_id=portgroup.id) object_utils.create_test_port(self.context, node_id=node.id, uuid=uuidutils.generate_uuid(), address='00:11:22:33:44:55') with task_manager.acquire(self.context, node.uuid) as task: res = network.get_ports_by_portgroup_id(task, portgroup.id) self.assertEqual([port.id], [p.id for p in res])
def test_port_by_address(self): address_template = "aa:bb:cc:dd:ee:f%d" for id_ in range(3): obj_utils.create_test_port(self.context, node_id=self.node.id, uuid=uuidutils.generate_uuid(), address=address_template % id_) target_address = address_template % 1 data = self.get_json('/ports?address=%s' % target_address) self.assertThat(data['ports'], HasLength(1)) self.assertEqual(target_address, data['ports'][0]['address'])
def test_two_ports_inconsistent(self): object_utils.create_test_port(self.context, node_id=self.node.id, portgroup_id=self.portgroup.id, physical_network='physnet1') object_utils.create_test_port(self.context, node_id=self.node.id, uuid=uuidutils.generate_uuid(), address='00:11:22:33:44:55', portgroup_id=self.portgroup.id, physical_network='physnet2') with task_manager.acquire(self.context, self.node.uuid) as task: self.assertRaises(exception.PortgroupPhysnetInconsistent, network.get_physnets_by_portgroup_id, task, self.portgroup.id)
def test_get_all_by_node_name_not_supported(self, mock_get_rpc_node): # GET /v1/ports specifying node_name - name not supported mock_get_rpc_node.side_effect = ( exception.InvalidUuidOrName(name=self.node.uuid)) for i in range(3): obj_utils.create_test_port(self.context, node_id=self.node.id, uuid=uuidutils.generate_uuid(), address='52:54:00:cf:2d:3%s' % i) data = self.get_json("/ports?node=%s" % 'test-node', expect_errors=True) self.assertEqual(0, mock_get_rpc_node.call_count) self.assertEqual(http_client.NOT_ACCEPTABLE, data.status_int)
def test__bind_flat_ports_set_binding_host_id(self, client_mock): upd_mock = mock.Mock() client_mock.return_value.update_port = upd_mock extra = {'vif_port_id': 'foo'} utils.create_test_port(self.context, node_id=self.node.id, address='52:54:00:cf:2d:33', extra=extra, uuid=uuidutils.generate_uuid()) exp_body = {'port': {'binding:host_id': self.node.uuid, 'binding:vnic_type': neutron.VNIC_BAREMETAL, 'mac_address': '52:54:00:cf:2d:33'}} with task_manager.acquire(self.context, self.node.id) as task: self.interface._bind_flat_ports(task) upd_mock.assert_called_once_with('foo', exp_body)
def test_remove_ports_from_network_not_all_pxe_enabled(self, remove_mock): object_utils.create_test_port( self.context, node_id=self.node.id, uuid=uuidutils.generate_uuid(), address='52:54:55:cf:2d:32', pxe_enabled=False ) with task_manager.acquire(self.context, self.node.uuid) as task: neutron.remove_ports_from_network(task, self.network_uuid) remove_mock.assert_called_once_with( task, {'network_id': self.network_uuid, 'mac_address': [self.ports[0].address]} )
def test__unbind_flat_ports_portgroup(self, unbind_neutron_port_mock): internal_info = {'tenant_vif_port_id': 'foo'} utils.create_test_portgroup(self.context, node_id=self.node.id, internal_info=internal_info, uuid=uuidutils.generate_uuid()) extra = {'vif_port_id': 'bar'} utils.create_test_port(self.context, node_id=self.node.id, address='52:54:00:cf:2d:33', extra=extra, uuid=uuidutils.generate_uuid()) with task_manager.acquire(self.context, self.node.id) as task: self.interface._unbind_flat_ports(task) unbind_neutron_port_mock.has_calls( [mock.call('foo', context=self.context), mock.call('bar', context=self.context)])
def test_get_all_by_node_name_ok(self, mock_get_rpc_node): # GET /v1/ports specifying node_name - success mock_get_rpc_node.return_value = self.node for i in range(5): if i < 3: node_id = self.node.id else: node_id = 100000 + i obj_utils.create_test_port(self.context, node_id=node_id, uuid=uuidutils.generate_uuid(), address='52:54:00:cf:2d:3%s' % i) data = self.get_json("/ports?node=%s" % 'test-node', headers={api_base.Version.string: '1.5'}) self.assertEqual(3, len(data['ports']))
def test_clean_up_ipxe_config_uefi(self, unlink_mock, rmtree_mock): self.config(ipxe_enabled=True, group='pxe') address = "aa:aa:aa:aa:aa:aa" properties = {'capabilities': 'boot_mode:uefi'} object_utils.create_test_port(self.context, node_id=self.node.id, address=address) with task_manager.acquire(self.context, self.node.uuid) as task: task.node.properties = properties pxe_utils.clean_up_pxe_config(task) unlink_mock.assert_called_once_with( '/httpboot/pxelinux.cfg/aa-aa-aa-aa-aa-aa') rmtree_mock.assert_called_once_with( os.path.join(CONF.deploy.http_root, self.node.uuid))
def test_add_provisioning_network_no_binding_host_id( self, client_mock): upd_mock = mock.Mock() client_mock.return_value.update_port = upd_mock instance_info = self.node.instance_info instance_info.pop('nova_host_id', None) self.node.instance_info = instance_info self.node.save() extra = {'vif_port_id': 'foo'} utils.create_test_port(self.context, node_id=self.node.id, address='52:54:00:cf:2d:33', extra=extra, uuid=uuidutils.generate_uuid()) with task_manager.acquire(self.context, self.node.id) as task: self.interface.add_provisioning_network(task) self.assertFalse(upd_mock.called)
def test_add_network_create_some_ports_fail(self, log_mock): object_utils.create_test_port( self.context, node_id=self.node.id, uuid=uuidutils.generate_uuid(), address='52:54:55:cf:2d:32', extra={'vif_port_id': uuidutils.generate_uuid()} ) self.client_mock.create_port.side_effect = [ {'port': self.neutron_port}, neutron_client_exc.ConnectionFailed] with task_manager.acquire(self.context, self.node.uuid) as task: neutron.add_ports_to_network(task, self.network_uuid) self.assertIn("Could not create neutron port for node's", log_mock.warning.call_args_list[0][0][0]) self.assertIn("Some errors were encountered when updating", log_mock.warning.call_args_list[1][0][0])
def test_ignore_malformed_address(self, mock_log): obj_utils.create_test_port(self.context, node_id=self.node.id, address=self.addresses[1]) addresses = ('not-a-valid-address,80:00:02:48:fe:80:00:00:00:00:00:00' ':f4:52:14:03:00:54:06:c2,' + ','.join(self.addresses)) data = self.get_json( '/lookup?addresses=%s' % addresses, headers={api_base.Version.string: str(api_v1.MAX_VER)}) self.assertEqual(self.node.uuid, data['node']['uuid']) self.assertEqual(set(ramdisk._LOOKUP_RETURN_FIELDS) | {'links'}, set(data['node'])) self._check_config(data) self.assertTrue(mock_log.called)
def setUp(self): super(TestNeutronNetworkActions, self).setUp() mgr_utils.mock_the_extension_manager(driver='fake') self.config(enabled_drivers=['fake']) self.node = object_utils.create_test_node(self.context) self.ports = [ object_utils.create_test_port( self.context, node_id=self.node.id, uuid='1be26c0b-03f2-4d2e-ae87-c02d7f33c782', address='52:54:00:cf:2d:32', extra={'vif_port_id': uuidutils.generate_uuid()}) ] # Very simple neutron port representation self.neutron_port = { 'id': '132f871f-eaec-4fed-9475-0d54465e0f00', 'mac_address': '52:54:00:cf:2d:32' } self.network_uuid = uuidutils.generate_uuid() self.client_mock = mock.Mock() patcher = mock.patch('ironic.common.neutron.get_client', return_value=self.client_mock, autospec=True) patcher.start() self.addCleanup(patcher.stop)
def setUp(self): super(WakeOnLanPrivateMethodTestCase, self).setUp() mgr_utils.mock_the_extension_manager(driver='fake_wol') self.driver = driver_factory.get_driver('fake_wol') self.node = obj_utils.create_test_node(self.context, driver='fake_wol') self.port = obj_utils.create_test_port(self.context, node_id=self.node.id)
def test_get_collection_custom_fields(self): fields = 'uuid,extra' for i in range(3): obj_utils.create_test_port(self.context, node_id=self.node.id, uuid=uuidutils.generate_uuid(), address='52:54:00:cf:2d:3%s' % i) data = self.get_json( '/ports?fields=%s' % fields, headers={api_base.Version.string: str(api_v1.MAX_VER)}) self.assertEqual(3, len(data['ports'])) for port in data['ports']: # We always append "links" self.assertItemsEqual(['uuid', 'extra', 'links'], port)
def setUp(self): super(NeutronInterfaceTestCase, self).setUp() self.config(enabled_hardware_types=['fake-hardware']) for iface in drivers_base.ALL_INTERFACES: name = 'fake' if iface == 'network': name = 'neutron' config_kwarg = { 'enabled_%s_interfaces' % iface: [name], 'default_%s_interface' % iface: name } self.config(**config_kwarg) self.interface = neutron.NeutronNetwork() self.node = utils.create_test_node(self.context, driver='fake-hardware', network_interface='neutron') self.port = utils.create_test_port( self.context, node_id=self.node.id, address='52:54:00:cf:2d:32', extra={'vif_port_id': uuidutils.generate_uuid()}) self.neutron_port = { 'id': '132f871f-eaec-4fed-9475-0d54465e0f00', 'mac_address': '52:54:00:cf:2d:32' }
def setUp(self): super(TestNeutron, self).setUp() mgr_utils.mock_the_extension_manager(driver='fake') self.config( cleaning_network_uuid='00000000-0000-0000-0000-000000000000', group='neutron') self.config(enabled_drivers=['fake']) self.config(dhcp_provider='neutron', group='dhcp') self.config(url='test-url', url_timeout=30, retries=2, group='neutron') self.config(insecure=False, certfile='test-file', admin_user='******', admin_tenant_name='test-admin-tenant', admin_password='******', auth_uri='test-auth-uri', group='keystone_authtoken') self.node = object_utils.create_test_node(self.context) self.ports = [ object_utils.create_test_port( self.context, node_id=self.node.id, id=2, uuid='1be26c0b-03f2-4d2e-ae87-c02d7f33c782', address='52:54:00:cf:2d:32') ] # Very simple neutron port representation self.neutron_port = { 'id': '132f871f-eaec-4fed-9475-0d54465e0f00', 'mac_address': '52:54:00:cf:2d:32' } dhcp_factory.DHCPFactory._dhcp_provider = None
def test_add_rescuing_network(self, add_ports_mock, rollback_mock, validate_mock): other_port = utils.create_test_port( self.context, node_id=self.node.id, address='52:54:00:cf:2d:33', uuid=uuidutils.generate_uuid(), extra={'vif_port_id': uuidutils.generate_uuid()}) neutron_other_port = { 'id': uuidutils.generate_uuid(), 'mac_address': '52:54:00:cf:2d:33' } add_ports_mock.return_value = { other_port.uuid: neutron_other_port['id'] } with task_manager.acquire(self.context, self.node.id) as task: res = self.interface.add_rescuing_network(task) add_ports_mock.assert_called_once_with( task, CONF.neutron.rescuing_network, security_groups=[]) rollback_mock.assert_called_once_with( task, CONF.neutron.rescuing_network) self.assertEqual(add_ports_mock.return_value, res) validate_mock.assert_called_once_with( CONF.neutron.rescuing_network, 'rescuing network', context=task.context) other_port.refresh() self.assertEqual(neutron_other_port['id'], other_port.internal_info['rescuing_vif_port_id']) self.assertNotIn('rescuing_vif_port_id', self.port.internal_info)
def test_add_rescuing_network_from_node(self, add_ports_mock, rollback_mock, validate_mock): other_port = utils.create_test_port( self.context, node_id=self.node.id, address='52:54:00:cf:2d:33', uuid=uuidutils.generate_uuid(), internal_info={'tenant_vif_port_id': uuidutils.generate_uuid()}) neutron_other_port = {'id': uuidutils.generate_uuid(), 'mac_address': '52:54:00:cf:2d:33'} add_ports_mock.return_value = { other_port.uuid: neutron_other_port['id']} rescuing_network_uuid = '3aea0de6-4b92-44da-9aa0-52d134c83fdf' driver_info = self.node.driver_info driver_info['rescuing_network'] = rescuing_network_uuid self.node.driver_info = driver_info self.node.save() with task_manager.acquire(self.context, self.node.id) as task: res = self.interface.add_rescuing_network(task) add_ports_mock.assert_called_once_with( task, rescuing_network_uuid, security_groups=[]) rollback_mock.assert_called_once_with( task, rescuing_network_uuid) self.assertEqual(add_ports_mock.return_value, res) validate_mock.assert_called_once_with( rescuing_network_uuid, 'rescuing network', context=task.context) other_port.refresh() self.assertEqual(neutron_other_port['id'], other_port.internal_info['rescuing_vif_port_id']) self.assertNotIn('rescuing_vif_port_id', self.port.internal_info)
def test_vif_detach_in_internal_info_portgroup(self): vif_id = uuidutils.generate_uuid() pg = obj_utils.create_test_portgroup( self.context, node_id=self.node.id, internal_info={common.TENANT_VIF_KEY: vif_id}) obj_utils.create_test_port(self.context, node_id=self.node.id, address='52:54:00:cf:2d:01', portgroup_id=pg.id, uuid=uuidutils.generate_uuid()) with task_manager.acquire(self.context, self.node.id) as task: self.interface.vif_detach(task, vif_id) pg.refresh() self.assertFalse('vif_port_id' in pg.extra) self.assertFalse(common.TENANT_VIF_KEY in pg.internal_info)
def _test_configure_tenant_networks(self, client_mock, update_mock, wait_agent_mock, is_client_id=False, vif_int_info=False): if vif_int_info: kwargs = {'internal_info': { 'tenant_vif_port_id': uuidutils.generate_uuid()}} self.port.internal_info = { 'tenant_vif_port_id': self.port.extra['vif_port_id']} self.port.extra = {} else: kwargs = {'extra': {'vif_port_id': uuidutils.generate_uuid()}} second_port = utils.create_test_port( self.context, node_id=self.node.id, address='52:54:00:cf:2d:33', uuid=uuidutils.generate_uuid(), local_link_connection={'switch_id': '0a:1b:2c:3d:4e:ff', 'port_id': 'Ethernet1/1', 'switch_info': 'switch2'}, **kwargs ) if is_client_id: client_ids = (CLIENT_ID1, CLIENT_ID2) ports = (self.port, second_port) for port, client_id in zip(ports, client_ids): extra = port.extra extra['client-id'] = client_id port.extra = extra port.save() expected_attrs = {'binding:vnic_type': 'baremetal', 'binding:host_id': self.node.uuid} port1_attrs = copy.deepcopy(expected_attrs) port1_attrs['binding:profile'] = { 'local_link_information': [self.port.local_link_connection] } port1_attrs['mac_address'] = '52:54:00:cf:2d:32' port2_attrs = copy.deepcopy(expected_attrs) port2_attrs['binding:profile'] = { 'local_link_information': [second_port.local_link_connection] } port2_attrs['mac_address'] = '52:54:00:cf:2d:33' if is_client_id: port1_attrs['extra_dhcp_opts'] = [{'opt_name': '61', 'opt_value': client_ids[0]}] port2_attrs['extra_dhcp_opts'] = [{'opt_name': '61', 'opt_value': client_ids[1]}] with task_manager.acquire(self.context, self.node.id) as task: self.interface.configure_tenant_networks(task) client_mock.assert_called_once_with(context=task.context) if vif_int_info: portid1 = self.port.internal_info['tenant_vif_port_id'] portid2 = second_port.internal_info['tenant_vif_port_id'] else: portid1 = self.port.extra['vif_port_id'] portid2 = second_port.extra['vif_port_id'] update_mock.assert_has_calls( [mock.call(self.context, portid1, port1_attrs), mock.call(self.context, portid2, port2_attrs)], any_order=True )
def test_add_network_create_some_ports_fail(self, log_mock): object_utils.create_test_port( self.context, node_id=self.node.id, uuid=uuidutils.generate_uuid(), address='52:54:55:cf:2d:32', extra={'vif_port_id': uuidutils.generate_uuid()}) self.client_mock.create_port.side_effect = [{ 'port': self.neutron_port }, neutron_client_exc.ConnectionFailed] with task_manager.acquire(self.context, self.node.uuid) as task: neutron.add_ports_to_network(task, self.network_uuid) self.assertIn("Could not create neutron port for node's", log_mock.warning.call_args_list[0][0][0]) self.assertIn("Some errors were encountered when updating", log_mock.warning.call_args_list[1][0][0])
def test_ignore_malformed_address(self, mock_log): self._set_secret_mock(self.node, '123456') obj_utils.create_test_port(self.context, node_id=self.node.id, address=self.addresses[1]) addresses = ('not-a-valid-address,80:00:02:48:fe:80:00:00:00:00:00:00' ':f4:52:14:03:00:54:06:c2,' + ','.join(self.addresses)) data = self.get_json( '/lookup?addresses=%s' % addresses, headers={api_base.Version.string: str(api_v1.max_version())}) self.assertEqual(self.node.uuid, data['node']['uuid']) self.assertEqual( set(ramdisk._LOOKUP_RETURN_FIELDS) | {'links'}, set(data['node'])) self._check_config(data) self.assertTrue(mock_log.called)
def test_get_free_port_like_object_vif_attached_to_portgroup_extra( self, vpi_mock): pg = obj_utils.create_test_portgroup( self.context, node_id=self.node.id, extra={'vif_port_id': self.vif_id}) obj_utils.create_test_port(self.context, node_id=self.node.id, address='52:54:00:cf:2d:01', uuid=uuidutils.generate_uuid(), portgroup_id=pg.id) with task_manager.acquire(self.context, self.node.id) as task: self.assertRaisesRegex(exception.VifAlreadyAttached, r"already attached to Ironic Portgroup", common.get_free_port_like_object, task, self.vif_id)
def test_add_provisioning_network_no_binding_host_id(self, client_mock): upd_mock = mock.Mock() client_mock.return_value.update_port = upd_mock instance_info = self.node.instance_info instance_info.pop('nova_host_id', None) self.node.instance_info = instance_info self.node.save() extra = {'vif_port_id': 'foo'} utils.create_test_port(self.context, node_id=self.node.id, address='52:54:00:cf:2d:33', extra=extra, uuid=uuidutils.generate_uuid()) with task_manager.acquire(self.context, self.node.id) as task: self.interface.add_provisioning_network(task) self.assertFalse(upd_mock.called)
def test_add_provisioning_network_binding_host_id_raise(self, client_mock): client_mock.return_value.update_port.side_effect = \ (neutron_exceptions.ConnectionFailed()) instance_info = self.node.instance_info instance_info['nova_host_id'] = 'nova_host_id' self.node.instance_info = instance_info self.node.save() extra = {'vif_port_id': 'foo'} utils.create_test_port(self.context, node_id=self.node.id, address='52:54:00:cf:2d:33', extra=extra, uuid=uuidutils.generate_uuid()) with task_manager.acquire(self.context, self.node.id) as task: self.assertRaises(exception.NetworkError, self.interface.add_provisioning_network, task)
def setUp(self): super(TestNeutron, self).setUp() mgr_utils.mock_the_extension_manager(driver='fake') self.config( cleaning_network='00000000-0000-0000-0000-000000000000', group='neutron') self.config(enabled_drivers=['fake']) self.config(dhcp_provider='neutron', group='dhcp') self.config(url='test-url', url_timeout=30, retries=2, group='neutron') self.config(insecure=False, certfile='test-file', admin_user='******', admin_tenant_name='test-admin-tenant', admin_password='******', auth_uri='test-auth-uri', group='keystone_authtoken') self.node = object_utils.create_test_node(self.context) self.ports = [ object_utils.create_test_port( self.context, node_id=self.node.id, id=2, uuid='1be26c0b-03f2-4d2e-ae87-c02d7f33c782', address='52:54:00:cf:2d:32')] # Very simple neutron port representation self.neutron_port = {'id': '132f871f-eaec-4fed-9475-0d54465e0f00', 'mac_address': '52:54:00:cf:2d:32'} dhcp_factory.DHCPFactory._dhcp_provider = None
def _test_add_ports_to_network(self, is_client_id, security_groups=None): # Ports will be created only if pxe_enabled is True self.node.network_interface = 'neutron' self.node.save() object_utils.create_test_port(self.context, node_id=self.node.id, uuid=uuidutils.generate_uuid(), address='52:54:00:cf:2d:22', pxe_enabled=False) port = self.ports[0] if is_client_id: extra = port.extra extra['client-id'] = self._CLIENT_ID port.extra = extra port.save() expected_body = { 'port': { 'network_id': self.network_uuid, 'admin_state_up': True, 'binding:vnic_type': 'baremetal', 'device_owner': 'baremetal:none', 'binding:host_id': self.node.uuid, 'device_id': self.node.uuid, 'mac_address': port.address, 'binding:profile': { 'local_link_information': [port.local_link_connection] } } } if security_groups: expected_body['port']['security_groups'] = security_groups if is_client_id: expected_body['port']['extra_dhcp_opts'] = ([{ 'opt_name': 'client-id', 'opt_value': self._CLIENT_ID }]) # Ensure we can create ports self.client_mock.create_port.return_value = {'port': self.neutron_port} expected = {port.uuid: self.neutron_port['id']} with task_manager.acquire(self.context, self.node.uuid) as task: ports = neutron.add_ports_to_network( task, self.network_uuid, security_groups=security_groups) self.assertEqual(expected, ports) self.client_mock.create_port.assert_called_once_with(expected_body)
def setUp(self): super(WakeOnLanPrivateMethodTestCase, self).setUp() self.config(enabled_hardware_types=['staging-wol'], enabled_power_interfaces=['fake', 'staging-wol']) self.node = obj_utils.create_test_node(self.context, driver='staging-wol') self.port = obj_utils.create_test_port(self.context, node_id=self.node.id)
def test__link_ip_address_pxe_configs(self, provider_mock, unlink_mock, create_link_mock): ip_address = '10.10.0.1' address = "aa:aa:aa:aa:aa:aa" object_utils.create_test_port(self.context, node_id=self.node.id, address=address) provider_mock.get_ip_addresses.return_value = [ip_address] create_link_calls = [ mock.call(u'1be26c0b-03f2-4d2e-ae87-c02d7f33c123/config', u'/tftpboot/10.10.0.1.conf'), ] with task_manager.acquire(self.context, self.node.uuid) as task: pxe_utils._link_ip_address_pxe_configs(task, False) unlink_mock.assert_called_once_with('/tftpboot/10.10.0.1.conf') create_link_mock.assert_has_calls(create_link_calls)
def setUp(self): super(NoopInterfaceTestCase, self).setUp() self.interface = noop.NoopNetwork() self.node = utils.create_test_node(self.context, network_interface='noop') self.port = utils.create_test_port(self.context, node_id=self.node.id, address='52:54:00:cf:2d:32')
def test_get_node_mac_addresses(self): ports = [] ports.append( obj_utils.create_test_port( self.context, address='aa:bb:cc:dd:ee:ff', uuid='bb43dc0b-03f2-4d2e-ae87-c02d7f33cc53', node_id=self.node.id)) ports.append( obj_utils.create_test_port( self.context, address='dd:ee:ff:aa:bb:cc', uuid='4fc26c0b-03f2-4d2e-ae87-c02d7f33c234', node_id=self.node.id)) with task_manager.acquire(self.context, self.node.uuid) as task: node_macs = driver_utils.get_node_mac_addresses(task) self.assertEqual(sorted([p.address for p in ports]), sorted(node_macs))
def test__bind_flat_ports_set_binding_host_id(self, update_mock): extra = {'vif_port_id': 'foo'} utils.create_test_port(self.context, node_id=self.node.id, address='52:54:00:cf:2d:33', extra=extra, uuid=uuidutils.generate_uuid()) exp_body = { 'port': { 'binding:host_id': self.node.uuid, 'binding:vnic_type': neutron.VNIC_BAREMETAL, 'mac_address': '52:54:00:cf:2d:33' } } with task_manager.acquire(self.context, self.node.id) as task: self.interface._bind_flat_ports(task) update_mock.assert_called_once_with(self.context, 'foo', exp_body)
def test_get_custom_fields_invalid_api_version(self): port = obj_utils.create_test_port(self.context, node_id=self.node.id) fields = 'uuid,extra' response = self.get_json( '/ports/%s?fields=%s' % (port.uuid, fields), headers={api_base.Version.string: str(api_v1.MIN_VER)}, expect_errors=True) self.assertEqual(http_client.NOT_ACCEPTABLE, response.status_int)
def test_detail(self): port = obj_utils.create_test_port(self.context, node_id=self.node.id) data = self.get_json('/ports/detail') self.assertEqual(port.uuid, data['ports'][0]["uuid"]) self.assertIn('extra', data['ports'][0]) self.assertIn('node_uuid', data['ports'][0]) # never expose the node_id self.assertNotIn('node_id', data['ports'][0])
def test_detail_by_node_name_ok(self, mock_get_rpc_node): # GET /v1/ports/detail specifying node_name - success mock_get_rpc_node.return_value = self.node port = obj_utils.create_test_port(self.context, node_id=self.node.id) data = self.get_json('/ports/detail?node=%s' % 'test-node', headers={api_base.Version.string: '1.5'}) self.assertEqual(port.uuid, data['ports'][0]['uuid']) self.assertEqual(self.node.uuid, data['ports'][0]['node_uuid'])
def test_get_one(self): port = obj_utils.create_test_port(self.context, node_id=self.node.id) data = self.get_json('/ports/%s' % port.uuid) self.assertEqual(port.uuid, data['uuid']) self.assertIn('extra', data) self.assertIn('node_uuid', data) # never expose the node_id self.assertNotIn('node_id', data)
def setUp(self): super(TestFlatInterface, self).setUp() self.interface = flat_interface.FlatNetwork() self.node = utils.create_test_node(self.context) self.port = utils.create_test_port( self.context, node_id=self.node.id, internal_info={'cleaning_vif_port_id': uuidutils.generate_uuid()})
def test_add_provisioning_network_set_binding_host_id(self, client_mock): upd_mock = mock.Mock() client_mock.return_value.update_port = upd_mock instance_info = self.node.instance_info instance_info['nova_host_id'] = 'nova_host_id' self.node.instance_info = instance_info self.node.save() extra = {'vif_port_id': 'foo'} utils.create_test_port(self.context, node_id=self.node.id, address='52:54:00:cf:2d:33', extra=extra, uuid=uuidutils.generate_uuid()) exp_body = {'port': {'binding:host_id': 'nova_host_id'}} with task_manager.acquire(self.context, self.node.id) as task: self.interface.add_provisioning_network(task) upd_mock.assert_called_once_with('foo', exp_body)
def test_get_one_custom_fields(self): port = obj_utils.create_test_port(self.context, node_id=self.node.id) fields = 'address,extra' data = self.get_json( '/ports/%s?fields=%s' % (port.uuid, fields), headers={api_base.Version.string: str(api_v1.MAX_VER)}) # We always append "links" self.assertItemsEqual(['address', 'extra', 'links'], data)
def test__unbind_flat_ports_portgroup(self, unbind_neutron_port_mock): internal_info = {'tenant_vif_port_id': 'foo'} utils.create_test_portgroup(self.context, node_id=self.node.id, internal_info=internal_info, uuid=uuidutils.generate_uuid()) extra = {'vif_port_id': 'bar'} utils.create_test_port(self.context, node_id=self.node.id, address='52:54:00:cf:2d:33', extra=extra, uuid=uuidutils.generate_uuid()) with task_manager.acquire(self.context, self.node.id) as task: self.interface._unbind_flat_ports(task) unbind_neutron_port_mock.has_calls([ mock.call('foo', context=self.context), mock.call('bar', context=self.context) ])
def setUp(self): super(OneViewAgentDeployTestCase, self).setUp() self.config(manager_url='https://1.2.3.4', group='oneview') self.config(username='******', group='oneview') self.config(password='******', group='oneview') self.port = obj_utils.create_test_port(self.context, node_id=self.node.id) self.info = common.get_oneview_info(self.node)