def test_inspect_hardware_with_existing_ports(self, mock_port_create,
mock_get_drac_client):
expected_node_properties = {
'memory_mb': 32768,
'local_gb': 1116,
'cpus': 18,
'cpu_arch': 'x86_64'
}
mock_client = mock.Mock()
mock_get_drac_client.return_value = mock_client
mock_client.list_memory.return_value = self.memory
mock_client.list_cpus.return_value = self.cpus
mock_client.list_virtual_disks.return_value = self.virtual_disks
mock_client.list_nics.return_value = self.nics
mock_client.list_bios_settings.return_value = self.uefi_boot_settings
mock_port_create.side_effect = exception.MACAlreadyExists("boom")
with task_manager.acquire(self.context, self.node.uuid,
shared=True) as task:
return_value = task.driver.inspect.inspect_hardware(task)
self.node.refresh()
self.assertEqual(expected_node_properties, self.node.properties)
self.assertEqual(states.MANAGEABLE, return_value)
self.assertEqual(2, mock_port_create.call_count)
def test_inspect_hardware_mac_already_exist(self, power_state_mock,
_inspect_hardware_mock,
port_mock, warn_mock):
inspected_props = {
'memory_mb': '1024',
'local_gb': 10,
'cpus': 2,
'cpu_arch': 'x86_64'
}
inspected_macs = ['aa:aa:aa:aa:aa:aa', 'bb:bb:bb:bb:bb:bb']
_inspect_hardware_mock.return_value = (inspected_props, inspected_macs)
power_state_mock.return_value = states.POWER_ON
side_effect = exception.MACAlreadyExists("fake exception")
new_port_mock = port_mock.return_value
new_port_mock.create.side_effect = side_effect
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
result = task.driver.inspect.inspect_hardware(task)
_inspect_hardware_mock.assert_called_once_with(task.node)
self.assertTrue(port_mock.call_count, 2)
task.node.refresh()
self.assertEqual(inspected_props, task.node.properties)
self.assertEqual(states.MANAGEABLE, result)
def test__create_ports_if_not_exist_mac_exception(self, create_mock,
log_mock):
create_mock.side_effect = exception.MACAlreadyExists('f')
macs = {'Port 1': 'aa:aa:aa:aa:aa:aa', 'Port 2': 'bb:bb:bb:bb:bb:bb'}
with task_manager.acquire(self.context, self.node.uuid,
shared=False) as task:
ilo_inspect._create_ports_if_not_exist(task, macs)
self.assertEqual(2, log_mock.call_count)
def test__create_ports_if_not_exist_mac_exception(self, instance_mock,
log_mock):
dbapi_mock = instance_mock.return_value
dbapi_mock.create_port.side_effect = exception.MACAlreadyExists('f')
macs = {'Port 1': 'aa:aa:aa:aa:aa:aa', 'Port 2': 'bb:bb:bb:bb:bb:bb'}
ilo_inspect._create_ports_if_not_exist(self.node, macs)
instance_mock.assert_called_once_with()
self.assertTrue(log_mock.called)
def create_port(self, values):
if not values.get('uuid'):
values['uuid'] = utils.generate_uuid()
port = models.Port()
port.update(values)
try:
port.save()
except db_exc.DBDuplicateEntry:
raise exception.MACAlreadyExists(mac=values['address'])
return port
def update_port(self, port_id, values):
session = get_session()
try:
with session.begin():
query = model_query(models.Port, session=session)
query = add_port_filter(query, port_id)
ref = query.one()
ref.update(values)
except NoResultFound:
raise exception.PortNotFound(port=port_id)
except db_exc.DBDuplicateEntry:
raise exception.MACAlreadyExists(mac=values['address'])
return ref
def create_port(self, values):
if not values.get('uuid'):
values['uuid'] = uuidutils.generate_uuid()
port = models.Port()
port.update(values)
with _session_for_write() as session:
try:
session.add(port)
session.flush()
except db_exc.DBDuplicateEntry as exc:
if 'address' in exc.columns:
raise exception.MACAlreadyExists(mac=values['address'])
raise exception.PortAlreadyExists(uuid=values['uuid'])
return port
def test_replace_address_already_exist(self, mock_upd):
address = 'aa:aa:aa:aa:aa:aa'
mock_upd.side_effect = exception.MACAlreadyExists(mac=address)
response = self.patch_json('/ports/%s' % self.port.uuid,
[{'path': '/address',
'value': address,
'op': 'replace'}],
expect_errors=True)
self.assertEqual('application/json', response.content_type)
self.assertEqual(409, response.status_code)
self.assertTrue(response.json['error_message'])
self.assertTrue(mock_upd.called)
kargs = mock_upd.call_args[0][1]
self.assertEqual(address, kargs.address)
def update_port(self, port_id, values):
# NOTE(dtantsur): this can lead to very strange errors
if 'uuid' in values:
msg = _("Cannot overwrite UUID for an existing Port.")
raise exception.InvalidParameterValue(err=msg)
session = get_session()
try:
with session.begin():
query = model_query(models.Port, session=session)
query = add_port_filter(query, port_id)
ref = query.one()
ref.update(values)
except NoResultFound:
raise exception.PortNotFound(port=port_id)
except db_exc.DBDuplicateEntry:
raise exception.MACAlreadyExists(mac=values['address'])
return ref
