def test_take_over_success(self):
for i in range(2):
db_utils.create_test_conductor(id=i, hostname='host-%d' % i)
allocation = db_utils.create_test_allocation(conductor_affinity=0)
self.assertTrue(self.dbapi.take_over_allocation(
allocation.id, old_conductor_id=0, new_conductor_id=1))
allocation = self.dbapi.get_allocation_by_id(allocation.id)
self.assertEqual(1, allocation.conductor_affinity)
def test_take_over_conflict(self):
for i in range(3):
db_utils.create_test_conductor(id=i, hostname='host-%d' % i)
allocation = db_utils.create_test_allocation(conductor_affinity=2)
self.assertFalse(self.dbapi.take_over_allocation(
allocation.id, old_conductor_id=0, new_conductor_id=1))
allocation = self.dbapi.get_allocation_by_id(allocation.id)
# The affinity was not changed
self.assertEqual(2, allocation.conductor_affinity)
def test_get_allocation_list_filter_by_conductor_affinity(self):
db_utils.create_test_conductor(id=1, hostname='host1')
db_utils.create_test_conductor(id=2, hostname='host2')
in_host1 = self._create_test_allocation_range(2, conductor_affinity=1)
in_host2 = self._create_test_allocation_range(2, conductor_affinity=2,
start_idx=2)
res = self.dbapi.get_allocation_list(
filters={'conductor_affinity': 1})
self.assertEqual(set(in_host1), {r.uuid for r in res})
res = self.dbapi.get_allocation_list(
filters={'conductor_affinity': 'host2'})
self.assertEqual(set(in_host2), {r.uuid for r in res})
def test_check_versions_conductor(self):
for v in self.object_versions['Conductor']:
conductor = utils.create_test_conductor(
uuid=uuidutils.generate_uuid(), version=v)
conductor = self.dbapi.get_conductor(conductor.hostname)
self.assertEqual(v, conductor.version)
self.assertTrue(self.dbapi.check_versions())
def test_check_versions_conductor(self):
for v in self.object_versions['Conductor']:
# NOTE(jroll) conductor model doesn't have a uuid :(
conductor = utils.create_test_conductor(
hostname=uuidutils.generate_uuid(), version=v,
id=random.randint(1, 1000000))
conductor = self.dbapi.get_conductor(conductor.hostname)
self.assertEqual(v, conductor.version)
self.assertTrue(self.dbapi.check_versions())
def test_check_versions_conductor(self):
for v in self.object_versions['Conductor']:
# NOTE(jroll) conductor model doesn't have a uuid :(
conductor = utils.create_test_conductor(
hostname=uuidutils.generate_uuid(), version=v,
id=random.randint(1, 1000000))
conductor = self.dbapi.get_conductor(conductor.hostname)
self.assertEqual(v, conductor.version)
self.assertTrue(self.dbapi.check_versions())
def _create_conductors(self, num, version=None):
conductors = []
for i in range(0, num):
conductor = utils.create_test_conductor(
version=version,
hostname='test_name_%d' % i,
uuid=uuidutils.generate_uuid())
conductors.append(conductor.hostname)
for hostname in conductors:
conductor = self.dbapi.get_conductor(hostname)
self.assertEqual(version, conductor.version)
return conductors
def test_check_versions_conductor_old(self):
conductor = utils.create_test_conductor(version='1.0')
conductor = self.dbapi.get_conductor(conductor.hostname)
self.assertEqual('1.0', conductor.version)
self.assertFalse(self.dbapi.check_versions())
def test_version_exists(self):
utils.create_test_conductor()
self.assertEqual((0, 0),
self.dbapi.backfill_version_column(self.context, 10))
def test_check_versions_conductor_no_version(self):
# works in Queens only
conductor = utils.create_test_conductor(version=None)
conductor = self.dbapi.get_conductor(conductor.hostname)
self.assertIsNone(conductor.version)
self.assertTrue(self.dbapi.check_versions())
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 test_check_versions_conductor_old(self):
conductor = utils.create_test_conductor(version='1.0')
conductor = self.dbapi.get_conductor(conductor.hostname)
self.assertEqual('1.0', conductor.version)
self.assertFalse(self.dbapi.check_versions())
