def test_create_portgroup_no_mode(self):
self.config(default_portgroup_mode='802.3ad')
name = uuidutils.generate_uuid()
db_utils.create_test_portgroup(uuid=uuidutils.generate_uuid(),
node_id=self.node.id, name=name,
address='aa:bb:cc:dd:ee:ff')
res = self.dbapi.get_portgroup_by_id(self.portgroup.id)
self.assertEqual('active-backup', res.mode)
res = self.dbapi.get_portgroup_by_name(name)
self.assertEqual('802.3ad', res.mode)
def test_create_portgroup_no_mode(self):
self.config(default_portgroup_mode='802.3ad')
name = uuidutils.generate_uuid()
db_utils.create_test_portgroup(uuid=uuidutils.generate_uuid(),
node_id=self.node.id,
name=name,
address='aa:bb:cc:dd:ee:ff')
res = self.dbapi.get_portgroup_by_id(self.portgroup.id)
self.assertEqual('active-backup', res.mode)
res = self.dbapi.get_portgroup_by_name(name)
self.assertEqual('802.3ad', res.mode)
def test_get_node_vif_ids_two_portgroups(self):
pg1 = db_utils.create_test_portgroup(node_id=self.node.id, extra={"vif_port_id": "test-vif-A"})
pg2 = db_utils.create_test_portgroup(
uuid=uuidutils.generate_uuid(),
address="dd:ee:ff:aa:bb:cc",
node_id=self.node.id,
name="barname",
extra={"vif_port_id": "test-vif-B"},
)
expected = {"portgroups": {pg1.uuid: "test-vif-A", pg2.uuid: "test-vif-B"}, "ports": {}}
with task_manager.acquire(self.context, self.node.uuid) as task:
result = network.get_node_vif_ids(task)
self.assertEqual(expected, result)
def test_remove_vifs_from_node(self):
db_utils.create_test_port(
node_id=self.node.id, address='aa:bb:cc:dd:ee:ff',
internal_info={driver_common.TENANT_VIF_KEY: 'test-vif-A'})
db_utils.create_test_portgroup(
node_id=self.node.id, address='dd:ee:ff:aa:bb:cc',
internal_info={driver_common.TENANT_VIF_KEY: 'test-vif-B'})
with task_manager.acquire(self.context, self.node.uuid) as task:
network.remove_vifs_from_node(task)
with task_manager.acquire(self.context, self.node.uuid) as task:
result = network.get_node_vif_ids(task)
self.assertEqual({}, result['ports'])
self.assertEqual({}, result['portgroups'])
def test_remove_vifs_from_node_failure(self, mock_unbind):
db_utils.create_test_port(
node_id=self.node.id, address='aa:bb:cc:dd:ee:ff',
internal_info={driver_common.TENANT_VIF_KEY: 'test-vif-A'})
db_utils.create_test_portgroup(
node_id=self.node.id, address='dd:ee:ff:aa:bb:cc',
internal_info={driver_common.TENANT_VIF_KEY: 'test-vif-B'})
mock_unbind.side_effect = [exception.NetworkError, None]
with task_manager.acquire(self.context, self.node.uuid) as task:
network.remove_vifs_from_node(task)
with task_manager.acquire(self.context, self.node.uuid) as task:
result = network.get_node_vif_ids(task)
self.assertEqual({}, result['ports'])
self.assertEqual({}, result['portgroups'])
self.assertEqual(2, mock_unbind.call_count)
def test_get_node_vif_ids_one_portgroup(self):
pg1 = db_utils.create_test_portgroup(node_id=self.node.id, extra={"vif_port_id": "test-vif-A"})
expected = {"portgroups": {pg1.uuid: "test-vif-A"}, "ports": {}}
with task_manager.acquire(self.context, self.node.uuid) as task:
result = network.get_node_vif_ids(task)
self.assertEqual(expected, result)
def test_get_node_vif_ids_two_portgroups(self):
pg1 = db_utils.create_test_portgroup(
node_id=self.node.id,
extra={'vif_port_id': 'test-vif-A'})
pg2 = db_utils.create_test_portgroup(
uuid=uuidutils.generate_uuid(),
address='dd:ee:ff:aa:bb:cc',
node_id=self.node.id,
name='barname',
extra={'vif_port_id': 'test-vif-B'})
expected = {'portgroups': {pg1.uuid: 'test-vif-A',
pg2.uuid: 'test-vif-B'},
'ports': {}}
with task_manager.acquire(self.context, self.node.uuid) as task:
result = network.get_node_vif_ids(task)
self.assertEqual(expected, result)
def test_get_node_vif_ids_two_portgroups(self):
pg1 = db_utils.create_test_portgroup(
node_id=self.node.id,
extra={'vif_port_id': 'test-vif-A'})
pg2 = db_utils.create_test_portgroup(
uuid=uuidutils.generate_uuid(),
address='dd:ee:ff:aa:bb:cc',
node_id=self.node.id,
name='barname',
extra={'vif_port_id': 'test-vif-B'})
expected = {'portgroups': {pg1.uuid: 'test-vif-A',
pg2.uuid: 'test-vif-B'},
'ports': {}}
with task_manager.acquire(self.context, self.node.uuid) as task:
result = network.get_node_vif_ids(task)
self.assertEqual(expected, result)
def test_get_node_vif_ids_one_portgroup(self):
pg1 = db_utils.create_test_portgroup(
node_id=self.node.id, extra={'vif_port_id': 'test-vif-A'})
expected = {'portgroups': {pg1.uuid: 'test-vif-A'}, 'ports': {}}
with task_manager.acquire(self.context, self.node.uuid) as task:
result = network.get_node_vif_ids(task)
self.assertEqual(expected, result)
def test_get_node_vif_ids_one_portgroup_int_info(self):
kwargs1 = {'internal_info': {'tenant_vif_port_id': 'test-vif-A'}}
pg1 = db_utils.create_test_portgroup(node_id=self.node.id, **kwargs1)
expected = {'portgroups': {pg1.uuid: 'test-vif-A'}, 'ports': {}}
with task_manager.acquire(self.context, self.node.uuid) as task:
result = network.get_node_vif_ids(task)
self.assertEqual(expected, result)
def setUp(self):
# This method creates a port for every test and
# replaces a test for creating a port.
super(DbPortTestCase, self).setUp()
self.node = db_utils.create_test_node()
self.portgroup = db_utils.create_test_portgroup(node_id=self.node.id)
self.port = db_utils.create_test_port(node_id=self.node.id,
portgroup_id=self.portgroup.id)
def setUp(self):
# This method creates a port for every test and
# replaces a test for creating a port.
super(DbPortTestCase, self).setUp()
self.node = db_utils.create_test_node()
self.portgroup = db_utils.create_test_portgroup(node_id=self.node.id)
self.port = db_utils.create_test_port(node_id=self.node.id,
portgroup_id=self.portgroup.id)
def setUp(self):
# This method creates a port for every test and
# replaces a test for creating a port.
super(DbPortTestCase, self).setUp()
self.node = db_utils.create_test_node(owner='12345', lessee='54321')
self.portgroup = db_utils.create_test_portgroup(node_id=self.node.id)
self.port = db_utils.create_test_port(node_id=self.node.id,
portgroup_id=self.portgroup.id,
name='port-name')
def test_update_portgroup_duplicated_name(self):
name1 = self.portgroup.name
portgroup2 = db_utils.create_test_portgroup(
uuid=uuidutils.generate_uuid(),
node_id=self.node.id,
name='name2', address='aa:bb:cc:11:22:55')
self.assertRaises(exception.PortgroupDuplicateName,
self.dbapi.update_portgroup, portgroup2.id,
{'name': name1})
def test_update_portgroup_duplicated_name(self):
name1 = self.portgroup.name
portgroup2 = db_utils.create_test_portgroup(
uuid=uuidutils.generate_uuid(),
node_id=self.node.id,
name='name2',
address='aa:bb:cc:11:22:55')
self.assertRaises(exception.PortgroupDuplicateName,
self.dbapi.update_portgroup, portgroup2.id,
{'name': name1})
def _test_get_node_vif_ids_two_portgroups(self, key):
if key == "extra":
kwargs1 = {key: {'vif_port_id': 'test-vif-A'}}
kwargs2 = {key: {'vif_port_id': 'test-vif-B'}}
else:
kwargs1 = {key: {'tenant_vif_port_id': 'test-vif-A'}}
kwargs2 = {key: {'tenant_vif_port_id': 'test-vif-B'}}
pg1 = db_utils.create_test_portgroup(
node_id=self.node.id, **kwargs1)
pg2 = db_utils.create_test_portgroup(
uuid=uuidutils.generate_uuid(),
address='dd:ee:ff:aa:bb:cc',
node_id=self.node.id,
name='barname', **kwargs2)
expected = {'portgroups': {pg1.uuid: 'test-vif-A',
pg2.uuid: 'test-vif-B'},
'ports': {}}
with task_manager.acquire(self.context, self.node.uuid) as task:
result = network.get_node_vif_ids(task)
self.assertEqual(expected, result)
def test_update_portgroup_duplicated_address(self):
address1 = self.portgroup.address
address2 = 'aa:bb:cc:11:22:33'
portgroup2 = db_utils.create_test_portgroup(
uuid=uuidutils.generate_uuid(),
node_id=self.node.id,
name=str(uuidutils.generate_uuid()),
address=address2)
self.assertRaises(exception.PortgroupMACAlreadyExists,
self.dbapi.update_portgroup, portgroup2.id,
{'address': address1})
def test_update_portgroup_duplicated_address(self):
address1 = self.portgroup.address
address2 = 'aa:bb:cc:11:22:33'
portgroup2 = db_utils.create_test_portgroup(
uuid=uuidutils.generate_uuid(),
node_id=self.node.id,
name=str(uuidutils.generate_uuid()),
address=address2)
self.assertRaises(exception.PortgroupMACAlreadyExists,
self.dbapi.update_portgroup, portgroup2.id,
{'address': address1})
def _test_get_node_vif_ids_one_portgroup(self, key):
if key == "extra":
kwargs1 = {key: {'vif_port_id': 'test-vif-A'}}
else:
kwargs1 = {key: {'tenant_vif_port_id': 'test-vif-A'}}
pg1 = db_utils.create_test_portgroup(node_id=self.node.id, **kwargs1)
expected = {'portgroups': {pg1.uuid: 'test-vif-A'}, 'ports': {}}
with task_manager.acquire(self.context, self.node.uuid) as task:
result = network.get_node_vif_ids(task)
self.assertEqual(expected, result)
def _test_get_node_vif_ids_multitenancy(self, int_info_key):
port = db_utils.create_test_port(
node_id=self.node.id, address="aa:bb:cc:dd:ee:ff", internal_info={int_info_key: "test-vif-A"}
)
portgroup = db_utils.create_test_portgroup(
node_id=self.node.id, address="dd:ee:ff:aa:bb:cc", internal_info={int_info_key: "test-vif-B"}
)
expected = {"ports": {port.uuid: "test-vif-A"}, "portgroups": {portgroup.uuid: "test-vif-B"}}
with task_manager.acquire(self.context, self.node.uuid) as task:
result = network.get_node_vif_ids(task)
self.assertEqual(expected, result)
def test_get_node_vif_ids_during_cleaning(self):
port = db_utils.create_test_port(
node_id=self.node.id, address='aa:bb:cc:dd:ee:ff',
internal_info={'cleaning_vif_port_id': 'test-vif-A'})
portgroup = db_utils.create_test_portgroup(
node_id=self.node.id, address='dd:ee:ff:aa:bb:cc',
internal_info={'cleaning_vif_port_id': 'test-vif-B'})
expected = {'portgroups': {portgroup.uuid: 'test-vif-B'},
'ports': {port.uuid: 'test-vif-A'}}
with task_manager.acquire(self.context, self.node.uuid) as task:
result = network.get_node_vif_ids(task)
self.assertEqual(expected, result)
def setUp(self):
super(TestMigrateVifPortId, self).setUp()
self.vif_id = 'some_uuid'
self.db_portgroups = []
extra = {'vif_port_id': self.vif_id}
for i in range(3):
portgroup = db_utils.create_test_portgroup(
uuid=uuidutils.generate_uuid(),
name='pg%s' % i,
address='52:54:00:cf:2d:3%s' % i,
extra=extra, version='1.3')
self.db_portgroups.append(portgroup)
def _test_get_node_vif_ids_multitenancy(self, int_info_key):
port = db_utils.create_test_port(
node_id=self.node.id, address='aa:bb:cc:dd:ee:ff',
internal_info={int_info_key: 'test-vif-A'})
portgroup = db_utils.create_test_portgroup(
node_id=self.node.id, address='dd:ee:ff:aa:bb:cc',
internal_info={int_info_key: 'test-vif-B'})
expected = {'ports': {port.uuid: 'test-vif-A'},
'portgroups': {portgroup.uuid: 'test-vif-B'}}
with task_manager.acquire(self.context, self.node.uuid) as task:
result = network.get_node_vif_ids(task)
self.assertEqual(expected, result)
def test_save_after_refresh(self):
# Ensure that it's possible to do object.save() after object.refresh()
address = "b2:54:00:cf:2d:40"
db_node = db_utils.create_test_node()
db_portgroup = db_utils.create_test_portgroup(node_id=db_node.id)
p = objects.Portgroup.get_by_uuid(self.context, db_portgroup.uuid)
p_copy = objects.Portgroup.get_by_uuid(self.context, db_portgroup.uuid)
p.address = address
p.save()
p_copy.refresh()
p_copy.address = 'aa:bb:cc:dd:ee:ff'
# Ensure this passes and an exception is not generated
p_copy.save()
def _test_get_node_vif_ids_one_portgroup(self, key):
if key == "extra":
kwargs1 = {key: {'vif_port_id': 'test-vif-A'}}
else:
kwargs1 = {key: {'tenant_vif_port_id': 'test-vif-A'}}
pg1 = db_utils.create_test_portgroup(
node_id=self.node.id, **kwargs1)
expected = {'portgroups': {pg1.uuid: 'test-vif-A'},
'ports': {}}
with task_manager.acquire(self.context, self.node.uuid) as task:
result = network.get_node_vif_ids(task)
self.assertEqual(expected, result)
def _create_test_portgroup_range(self, count):
"""Create the specified number of test portgroup entries in DB
It uses create_test_portgroup method. And returns List of Portgroup
DB objects.
:param count: Specifies the number of portgroups to be created
:returns: List of Portgroup DB objects
"""
uuids = []
for i in range(1, count):
portgroup = db_utils.create_test_portgroup(
uuid=uuidutils.generate_uuid(),
name='portgroup' + str(i),
address='52:54:00:cf:2d:4%s' % i)
uuids.append(six.text_type(portgroup.uuid))
return uuids
def _create_test_portgroup_range(self, count):
"""Create the specified number of test portgroup entries in DB
It uses create_test_portgroup method. And returns List of Portgroup
DB objects.
:param count: Specifies the number of portgroups to be created
:returns: List of Portgroup DB objects
"""
uuids = []
for i in range(1, count):
portgroup = db_utils.create_test_portgroup(
uuid=uuidutils.generate_uuid(),
name='portgroup' + str(i),
address='52:54:00:cf:2d:4%s' % i)
uuids.append(six.text_type(portgroup.uuid))
return uuids
def _create_test_data(self):
allocated_node_id = 31
fake_db_allocation = db_utils.create_test_allocation(
node_id=allocated_node_id,
resource_class="CUSTOM_TEST")
fake_db_node = db_utils.create_test_node(
chassis_id=None,
driver='fake-driverz',
owner='z')
fake_db_node_alloced = db_utils.create_test_node(
id=allocated_node_id,
chassis_id=None,
allocation_id=fake_db_allocation['id'],
uuid='22e26c0b-03f2-4d2e-ae87-c02d7f33c000',
driver='fake-driverz',
owner='z')
fake_vif_port_id = "ee21d58f-5de2-4956-85ff-33935ea1ca00"
fake_db_port = db_utils.create_test_port(
node_id=fake_db_node['id'],
internal_info={'tenant_vif_port_id': fake_vif_port_id})
fake_db_portgroup = db_utils.create_test_portgroup(
uuid="6eb02b44-18a3-4659-8c0b-8d2802581ae4",
node_id=fake_db_node['id'])
fake_db_chassis = db_utils.create_test_chassis(
drivers=['fake-hardware', 'fake-driverz', 'fake-driver'])
fake_db_deploy_template = db_utils.create_test_deploy_template()
fake_db_conductor = db_utils.create_test_conductor()
fake_db_volume_target = db_utils.create_test_volume_target(
node_id=fake_db_allocation['id'])
fake_db_volume_connector = db_utils.create_test_volume_connector(
node_id=fake_db_allocation['id'])
# Trait name aligns with create_test_node_trait.
fake_trait = 'trait'
fake_setting = 'FAKE_SETTING'
db_utils.create_test_bios_setting(
node_id=fake_db_node['id'],
name=fake_setting,
value=fake_setting)
db_utils.create_test_node_trait(
node_id=fake_db_node['id'])
# dedicated node for portgroup addition test to avoid
# false positives with test runners.
db_utils.create_test_node(
uuid='18a552fb-dcd2-43bf-9302-e4c93287be11')
self.format_data.update({
'node_ident': fake_db_node['uuid'],
'allocated_node_ident': fake_db_node_alloced['uuid'],
'port_ident': fake_db_port['uuid'],
'portgroup_ident': fake_db_portgroup['uuid'],
'chassis_ident': fake_db_chassis['uuid'],
'deploy_template_ident': fake_db_deploy_template['uuid'],
'allocation_ident': fake_db_allocation['uuid'],
'conductor_ident': fake_db_conductor['hostname'],
'vif_ident': fake_vif_port_id,
# Can't use the same fake-driver as other tests can
# pollute a global method cache in the API that is in the
# test runner, resulting in false positives.
'driver_name': 'fake-driverz',
'bios_setting': fake_setting,
'trait': fake_trait,
'volume_target_ident': fake_db_volume_target['uuid'],
'volume_connector_ident': fake_db_volume_connector['uuid'],
})
def _create_test_data(self):
owner_node_ident = '1ab63b9e-66d7-4cd7-8618-dddd0f9f7881'
lessee_node_ident = '38d5abed-c585-4fce-a57e-a2ffc2a2ec6f'
owner_project_id = '70e5e25a-2ca2-4cb1-8ae8-7d8739cee205'
lessee_project_id = 'f11853c7-fa9c-4db3-a477-c9d8e0dbbf13'
unowned_node = db_utils.create_test_node(chassis_id=None)
# owned node - since the tests use the same node for
# owner/lesse checks
owned_node = db_utils.create_test_node(
uuid=owner_node_ident,
owner=owner_project_id,
last_error='meow',
reservation='lolcats')
owned_node_port = db_utils.create_test_port(
uuid='ebe30f19-358d-41e1-8d28-fd7357a0164c',
node_id=owned_node['id'],
address='00:00:00:00:00:01')
db_utils.create_test_port(
uuid='21a3c5a7-1e14-44dc-a9dd-0c84d5477a57',
node_id=owned_node['id'],
address='00:00:00:00:00:02')
owner_pgroup = db_utils.create_test_portgroup(
uuid='b16efcf3-2990-41a1-bc1d-5e2c16f3d5fc',
node_id=owned_node['id'],
name='magicfoo',
address='01:03:09:ff:01:01')
db_utils.create_test_volume_target(
uuid='a265e2f0-e97f-4177-b1c0-8298add53086',
node_id=owned_node['id'])
db_utils.create_test_volume_connector(
uuid='65ea0296-219b-4635-b0c8-a6e055da878d',
node_id=owned_node['id'],
connector_id='iqn.2012-06.org.openstack.magic')
fake_owner_allocation = db_utils.create_test_allocation(
node_id=owned_node['id'],
owner=owner_project_id,
resource_class="CUSTOM_TEST")
# Leased nodes
fake_allocation_id = 61
leased_node = db_utils.create_test_node(
allocation_id=fake_allocation_id,
uuid=lessee_node_ident,
owner=owner_project_id,
lessee=lessee_project_id,
last_error='meow',
reservation='lolcats')
fake_db_volume_target = db_utils.create_test_volume_target(
node_id=leased_node['id'])
fake_db_volume_connector = db_utils.create_test_volume_connector(
node_id=leased_node['id'])
fake_db_port = db_utils.create_test_port(
node_id=leased_node['id'])
fake_db_portgroup = db_utils.create_test_portgroup(
node_id=leased_node['id'])
fake_trait = 'CUSTOM_MEOW'
fake_vif_port_id = "0e21d58f-5de2-4956-85ff-33935ea1ca01"
fake_leased_allocation = db_utils.create_test_allocation(
id=fake_allocation_id,
node_id=leased_node['id'],
owner=lessee_project_id,
resource_class="CUSTOM_LEASED")
# Random objects that shouldn't be project visible
other_port = db_utils.create_test_port(
uuid='abfd8dbb-1732-449a-b760-2224035c6b99',
address='00:00:00:00:00:ff')
other_node = db_utils.create_test_node(
uuid='573208e5-cd41-4e26-8f06-ef44022b3793')
other_pgroup = db_utils.create_test_portgroup(
uuid='5810f41c-6585-41fc-b9c9-a94f50d421b5',
node_id=other_node['id'],
name='corgis_rule_the_world',
address='ff:ff:ff:ff:ff:0f')
self.format_data.update({
'node_ident': unowned_node['uuid'],
'owner_node_ident': owner_node_ident,
'lessee_node_ident': lessee_node_ident,
'allocated_node_ident': lessee_node_ident,
'volume_target_ident': fake_db_volume_target['uuid'],
'volume_connector_ident': fake_db_volume_connector['uuid'],
'lessee_port_ident': fake_db_port['uuid'],
'lessee_portgroup_ident': fake_db_portgroup['uuid'],
'trait': fake_trait,
'vif_ident': fake_vif_port_id,
'ind_component': 'component',
'ind_ident': 'magic_light',
'owner_port_ident': owned_node_port['uuid'],
'other_port_ident': other_port['uuid'],
'owner_portgroup_ident': owner_pgroup['uuid'],
'other_portgroup_ident': other_pgroup['uuid'],
'driver_name': 'fake-driverz',
'owner_allocation': fake_owner_allocation['uuid'],
'lessee_allocation': fake_leased_allocation['uuid']})
