openstack/nova
Code Issues Proposed changes

Remove _legacy_dict methods

Browse Source 
These are left over from the objectification of live migration. We can
safely get rid of them. This isn't required for the NUMA live
migration series, but the presence of _legacy_dict methods caused unit
test failures in subsequent paches because of their failure to handle
the changes to LiveMigrateData. Rather than working around that, bite
the bullet and remove _legacy_dict altogether.

Change-Id: I01c108ceb539bb99491ed542c683e36fbf0c2bbe
This commit is contained in:
Artom Lifshitz 2019-02-11 14:15:12 -05:00
parent f58cdcd58d
commit 3c13865a56
5 changed files with 121 additions and 508 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

137
nova/objects/migrate_data.py
View File

@ -120,36 +120,6 @@ class LiveMigrateData(obj_base.NovaObject):
'vifs': fields.ListOfObjectsField('VIFMigrateData'),
}
def to_legacy_dict(self, pre_migration_result=False):
legacy = {}
if self.obj_attr_is_set('is_volume_backed'):
legacy['is_volume_backed'] = self.is_volume_backed
if self.obj_attr_is_set('migration'):
legacy['migration'] = self.migration
if pre_migration_result:
legacy['pre_live_migration_result'] = {}
return legacy
def from_legacy_dict(self, legacy):
if 'is_volume_backed' in legacy:
self.is_volume_backed = legacy['is_volume_backed']
if 'migration' in legacy:
self.migration = legacy['migration']
@classmethod
def detect_implementation(cls, legacy_dict):
if 'instance_relative_path' in legacy_dict:
obj = LibvirtLiveMigrateData()
elif 'image_type' in legacy_dict:
obj = LibvirtLiveMigrateData()
elif 'migrate_data' in legacy_dict:
obj = XenapiLiveMigrateData()
else:
obj = LiveMigrateData()
obj.from_legacy_dict(legacy_dict)
return obj
@obj_base.NovaObjectRegistry.register
class LibvirtLiveMigrateBDMInfo(obj_base.NovaObject):
@ -296,52 +266,6 @@ class LibvirtLiveMigrateData(LiveMigrateData):
bdmi.boot_index = int(vol['disk_info']['boot_index'])
self.bdms.append(bdmi)
def to_legacy_dict(self, pre_migration_result=False):
LOG.debug('Converting to legacy: %s', self)
legacy = super(LibvirtLiveMigrateData, self).to_legacy_dict()
keys = (set(self.fields.keys()) -
set(LiveMigrateData.fields.keys()) - {'bdms'})
legacy.update({k: getattr(self, k) for k in keys
if self.obj_attr_is_set(k)})
graphics_vnc = legacy.pop('graphics_listen_addr_vnc', None)
graphics_spice = legacy.pop('graphics_listen_addr_spice', None)
transport_target = legacy.pop('target_connect_addr', None)
live_result = {
'graphics_listen_addrs': {
'vnc': graphics_vnc and str(graphics_vnc),
'spice': graphics_spice and str(graphics_spice),
},
'serial_listen_addr': legacy.pop('serial_listen_addr', None),
'target_connect_addr': transport_target,
}
if pre_migration_result:
legacy['pre_live_migration_result'] = live_result
self._bdms_to_legacy(live_result)
LOG.debug('Legacy result: %s', legacy)
return legacy
def from_legacy_dict(self, legacy):
LOG.debug('Converting legacy dict to obj: %s', legacy)
super(LibvirtLiveMigrateData, self).from_legacy_dict(legacy)
keys = set(self.fields.keys()) - set(LiveMigrateData.fields.keys())
for k in keys - {'bdms'}:
if k in legacy:
setattr(self, k, legacy[k])
if 'pre_live_migration_result' in legacy:
pre_result = legacy['pre_live_migration_result']
self.graphics_listen_addr_vnc = \
pre_result['graphics_listen_addrs'].get('vnc')
self.graphics_listen_addr_spice = \
pre_result['graphics_listen_addrs'].get('spice')
self.target_connect_addr = pre_result.get('target_connect_addr')
if 'serial_listen_addr' in pre_result:
self.serial_listen_addr = pre_result['serial_listen_addr']
self._bdms_from_legacy(pre_result)
LOG.debug('Converted object: %s', self)
def is_on_shared_storage(self):
return self.is_shared_block_storage or self.is_shared_instance_path
@ -365,42 +289,6 @@ class XenapiLiveMigrateData(LiveMigrateData):
'vif_uuid_map': fields.DictOfStringsField(),
}
def to_legacy_dict(self, pre_migration_result=False):
legacy = super(XenapiLiveMigrateData, self).to_legacy_dict()
if self.obj_attr_is_set('block_migration'):
legacy['block_migration'] = self.block_migration
if self.obj_attr_is_set('migrate_send_data'):
legacy['migrate_data'] = {
'migrate_send_data': self.migrate_send_data,
'destination_sr_ref': self.destination_sr_ref,
}
live_result = {
'sr_uuid_map': ('sr_uuid_map' in self and self.sr_uuid_map
or {}),
'vif_uuid_map': ('vif_uuid_map' in self and self.vif_uuid_map
or {}),
}
if pre_migration_result:
legacy['pre_live_migration_result'] = live_result
return legacy
def from_legacy_dict(self, legacy):
super(XenapiLiveMigrateData, self).from_legacy_dict(legacy)
if 'block_migration' in legacy:
self.block_migration = legacy['block_migration']
else:
self.block_migration = False
if 'migrate_data' in legacy:
self.migrate_send_data = \
legacy['migrate_data']['migrate_send_data']
self.destination_sr_ref = \
legacy['migrate_data']['destination_sr_ref']
if 'pre_live_migration_result' in legacy:
self.sr_uuid_map = \
legacy['pre_live_migration_result']['sr_uuid_map']
self.vif_uuid_map = \
legacy['pre_live_migration_result'].get('vif_uuid_map', {})
def obj_make_compatible(self, primitive, target_version):
super(XenapiLiveMigrateData, self).obj_make_compatible(
primitive, target_version)
@ -443,18 +331,6 @@ class HyperVLiveMigrateData(LiveMigrateData):
if 'is_shared_instance_path' in primitive:
del primitive['is_shared_instance_path']
def to_legacy_dict(self, pre_migration_result=False):
legacy = super(HyperVLiveMigrateData, self).to_legacy_dict()
if self.obj_attr_is_set('is_shared_instance_path'):
legacy['is_shared_instance_path'] = self.is_shared_instance_path
return legacy
def from_legacy_dict(self, legacy):
super(HyperVLiveMigrateData, self).from_legacy_dict(legacy)
if 'is_shared_instance_path' in legacy:
self.is_shared_instance_path = legacy['is_shared_instance_path']
@obj_base.NovaObjectRegistry.register
class PowerVMLiveMigrateData(LiveMigrateData):
@ -491,19 +367,6 @@ class PowerVMLiveMigrateData(LiveMigrateData):
if 'vea_vlan_mappings' in primitive:
del primitive['vea_vlan_mappings']
def to_legacy_dict(self, pre_migration_result=False):
legacy = super(PowerVMLiveMigrateData, self).to_legacy_dict()
for field in self.fields:
if self.obj_attr_is_set(field):
legacy[field] = getattr(self, field)
return legacy
def from_legacy_dict(self, legacy):
super(PowerVMLiveMigrateData, self).from_legacy_dict(legacy)
for field in self.fields:
if field in legacy:
setattr(self, field, legacy[field])
@obj_base.NovaObjectRegistry.register
class VMwareLiveMigrateData(LiveMigrateData):

282
nova/tests/unit/objects/test_migrate_data.py
View File

@ -25,58 +25,6 @@ from nova.tests.unit.objects import test_objects
class _TestLiveMigrateData(object):
def test_to_legacy_dict(self):
obj = migrate_data.LiveMigrateData(is_volume_backed=False)
self.assertEqual({'is_volume_backed': False},
obj.to_legacy_dict())
def test_from_legacy_dict(self):
obj = migrate_data.LiveMigrateData()
obj.from_legacy_dict({'is_volume_backed': False, 'ignore': 'foo'})
self.assertFalse(obj.is_volume_backed)
def test_from_legacy_dict_migration(self):
migration = objects.Migration()
obj = migrate_data.LiveMigrateData()
obj.from_legacy_dict({'is_volume_backed': False, 'ignore': 'foo',
'migration': migration})
self.assertFalse(obj.is_volume_backed)
self.assertIsInstance(obj.migration, objects.Migration)
def test_legacy_with_pre_live_migration_result(self):
obj = migrate_data.LiveMigrateData(is_volume_backed=False)
self.assertEqual({'pre_live_migration_result': {},
'is_volume_backed': False},
obj.to_legacy_dict(pre_migration_result=True))
def test_detect_implementation_none(self):
legacy = migrate_data.LiveMigrateData().to_legacy_dict()
self.assertIsInstance(
migrate_data.LiveMigrateData.detect_implementation(legacy),
migrate_data.LiveMigrateData)
def test_detect_implementation_libvirt(self):
legacy = migrate_data.LibvirtLiveMigrateData(
instance_relative_path='foo').to_legacy_dict()
self.assertIsInstance(
migrate_data.LiveMigrateData.detect_implementation(legacy),
migrate_data.LibvirtLiveMigrateData)
def test_detect_implementation_libvirt_early(self):
legacy = migrate_data.LibvirtLiveMigrateData(
image_type='foo').to_legacy_dict()
self.assertIsInstance(
migrate_data.LiveMigrateData.detect_implementation(legacy),
migrate_data.LibvirtLiveMigrateData)
def test_detect_implementation_xenapi(self):
legacy = migrate_data.XenapiLiveMigrateData(
migrate_send_data={},
destination_sr_ref='foo').to_legacy_dict()
self.assertIsInstance(
migrate_data.LiveMigrateData.detect_implementation(legacy),
migrate_data.XenapiLiveMigrateData)
def test_obj_make_compatible(self):
props = {
'serial_listen_addr': '127.0.0.1',
@ -120,121 +68,6 @@ class _TestLibvirtLiveMigrateData(object):
expected_info['boot_index'] = '1'
self.assertEqual(expected_info, obj.as_disk_info())
def test_to_legacy_dict(self):
obj = migrate_data.LibvirtLiveMigrateData(
is_volume_backed=False,
filename='foo',
image_type='rbd',
block_migration=False,
disk_over_commit=False,
disk_available_mb=123,
is_shared_instance_path=False,
is_shared_block_storage=False,
instance_relative_path='foo/bar')
expected = {
'is_volume_backed': False,
'filename': 'foo',
'image_type': 'rbd',
'block_migration': False,
'disk_over_commit': False,
'disk_available_mb': 123,
'is_shared_instance_path': False,
'is_shared_block_storage': False,
'instance_relative_path': 'foo/bar',
}
self.assertEqual(expected, obj.to_legacy_dict())
def test_from_legacy_dict(self):
obj = migrate_data.LibvirtLiveMigrateData(
is_volume_backed=False,
filename='foo',
image_type='rbd',
block_migration=False,
disk_over_commit=False,
disk_available_mb=123,
is_shared_instance_path=False,
is_shared_block_storage=False,
instance_relative_path='foo/bar')
legacy = obj.to_legacy_dict()
legacy['ignore_this_thing'] = True
obj2 = migrate_data.LibvirtLiveMigrateData()
obj2.from_legacy_dict(legacy)
self.assertEqual(obj.filename, obj2.filename)
def test_to_legacy_dict_with_pre_result(self):
test_bdmi = migrate_data.LibvirtLiveMigrateBDMInfo(
serial='123',
bus='scsi',
dev='/dev/sda',
type='disk',
format='qcow2',
boot_index=1,
connection_info='myinfo')
obj = migrate_data.LibvirtLiveMigrateData(
is_volume_backed=False,
filename='foo',
image_type='rbd',
block_migration=False,
disk_over_commit=False,
disk_available_mb=123,
is_shared_instance_path=False,
is_shared_block_storage=False,
instance_relative_path='foo/bar',
graphics_listen_addr_vnc='127.0.0.1',
serial_listen_addr='127.0.0.1',
bdms=[test_bdmi])
legacy = obj.to_legacy_dict(pre_migration_result=True)
self.assertIn('pre_live_migration_result', legacy)
expected = {
'graphics_listen_addrs': {'vnc': '127.0.0.1',
'spice': None},
'target_connect_addr': None,
'serial_listen_addr': '127.0.0.1',
'volume': {
'123': {
'connection_info': 'myinfo',
'disk_info': {
'bus': 'scsi',
'dev': '/dev/sda',
'type': 'disk',
'format': 'qcow2',
'boot_index': '1',
}
}
}
}
self.assertEqual(expected, legacy['pre_live_migration_result'])
def test_from_legacy_with_pre_result(self):
test_bdmi = migrate_data.LibvirtLiveMigrateBDMInfo(
serial='123',
bus='scsi',
dev='/dev/sda',
type='disk',
format='qcow2',
boot_index=1,
connection_info='myinfo')
obj = migrate_data.LibvirtLiveMigrateData(
is_volume_backed=False,
filename='foo',
image_type='rbd',
block_migration=False,
disk_over_commit=False,
disk_available_mb=123,
is_shared_instance_path=False,
is_shared_block_storage=False,
instance_relative_path='foo/bar',
graphics_listen_addrs={'vnc': '127.0.0.1'},
serial_listen_addr='127.0.0.1',
bdms=[test_bdmi],
dst_wants_file_backed_memory=True,
file_backed_memory_discard=True)
obj2 = migrate_data.LibvirtLiveMigrateData()
obj2.from_legacy_dict(obj.to_legacy_dict(pre_migration_result=True))
self.assertEqual(obj.to_legacy_dict(),
obj2.to_legacy_dict())
self.assertEqual(obj.bdms[0].serial, obj2.bdms[0].serial)
def test_obj_make_compatible(self):
obj = migrate_data.LibvirtLiveMigrateData(
src_supports_native_luks=True,
@ -325,93 +158,6 @@ class TestRemoteLibvirtLiveMigrateData(test_objects._RemoteTest,
class _TestXenapiLiveMigrateData(object):
def test_to_legacy_dict(self):
obj = migrate_data.XenapiLiveMigrateData(
is_volume_backed=False,
block_migration=False,
destination_sr_ref='foo',
migrate_send_data={'key': 'val'},
sr_uuid_map={'apple': 'banana'},
vif_uuid_map={'orange': 'lemon'})
expected = {
'is_volume_backed': False,
'block_migration': False,
'migrate_data': {
'destination_sr_ref': 'foo',
'migrate_send_data': {'key': 'val'},
}
}
self.assertEqual(expected, obj.to_legacy_dict())
def test_from_legacy_dict(self):
obj = migrate_data.XenapiLiveMigrateData(
is_volume_backed=False,
block_migration=False,
destination_sr_ref='foo',
migrate_send_data={'key': 'val'},
sr_uuid_map={'apple': 'banana'},
vif_uuid_map={'orange': 'lemon'})
legacy = obj.to_legacy_dict()
legacy['ignore_this_thing'] = True
obj2 = migrate_data.XenapiLiveMigrateData()
obj2.from_legacy_dict(legacy)
self.assertEqual(obj.destination_sr_ref, obj2.destination_sr_ref)
def test_to_legacy_dict_missing_attrs(self):
obj = migrate_data.XenapiLiveMigrateData(
is_volume_backed=False,
destination_sr_ref='foo',
sr_uuid_map={'apple': 'banana'},
vif_uuid_map={'orange': 'lemon'})
expected = {
'is_volume_backed': False,
}
self.assertEqual(expected, obj.to_legacy_dict())
obj = migrate_data.XenapiLiveMigrateData(
is_volume_backed=False,
destination_sr_ref='foo')
expected = {
'is_volume_backed': False,
'pre_live_migration_result': {
'sr_uuid_map': {},
'vif_uuid_map': {},
},
}
self.assertEqual(expected, obj.to_legacy_dict(True))
def test_from_legacy_dict_missing_attrs(self):
obj = migrate_data.XenapiLiveMigrateData(
is_volume_backed=False,
destination_sr_ref='foo',
sr_uuid_map={'apple': 'banana'},
vif_uuid_map={'orange': 'lemon'})
legacy = obj.to_legacy_dict()
obj2 = migrate_data.XenapiLiveMigrateData()
obj2.from_legacy_dict(legacy)
self.assertFalse(obj2.block_migration)
self.assertNotIn('migrate_send_data', obj2)
self.assertNotIn('sr_uuid_map', obj2)
self.assertNotIn('vif_uuid_map', obj2)
def test_to_legacy_with_pre_result(self):
obj = migrate_data.XenapiLiveMigrateData(
sr_uuid_map={'a': 'b'},
vif_uuid_map={'c': 'd'})
self.assertNotIn('sr_uuid_map', obj.to_legacy_dict())
self.assertNotIn('vi_uuid_map', obj.to_legacy_dict())
legacy = obj.to_legacy_dict(True)
self.assertEqual(
{'a': 'b'},
legacy['pre_live_migration_result']['sr_uuid_map'])
self.assertEqual(
{'c': 'd'},
legacy['pre_live_migration_result']['vif_uuid_map']
)
obj2 = migrate_data.XenapiLiveMigrateData()
obj2.from_legacy_dict(legacy)
self.assertEqual({'a': 'b'}, obj2.sr_uuid_map)
self.assertEqual({'c': 'd'}, obj2.vif_uuid_map)
def test_obj_make_compatible(self):
obj = migrate_data.XenapiLiveMigrateData(
is_volume_backed=False,
@ -459,23 +205,6 @@ class _TestHyperVLiveMigrateData(object):
primitive = data(obj.obj_to_primitive(target_version='1.2'))
self.assertNotIn('wait_for_vif_plugged', primitive)
def test_to_legacy_dict(self):
obj = migrate_data.HyperVLiveMigrateData(
is_shared_instance_path=False)
expected = {
'is_shared_instance_path': False,
}
self.assertEqual(expected, obj.to_legacy_dict())
def test_from_legacy_dict(self):
obj = migrate_data.HyperVLiveMigrateData(
is_shared_instance_path=False)
legacy = obj.to_legacy_dict()
obj2 = migrate_data.HyperVLiveMigrateData()
obj2.from_legacy_dict(legacy)
self.assertEqual(obj.is_shared_instance_path,
obj2.is_shared_instance_path)
class TestHyperVLiveMigrateData(test_objects._LocalTest,
_TestHyperVLiveMigrateData):
@ -537,17 +266,6 @@ class _TestPowerVMLiveMigrateData(object):
primitive = data(obj.obj_to_primitive(target_version='1.2'))
self.assertNotIn('wait_for_vif_plugged', primitive)
def test_to_legacy_dict(self):
self.assertEqual(self._mk_leg(), self._mk_obj().to_legacy_dict())
def test_from_legacy_dict(self):
obj = self._mk_obj()
leg = self._mk_leg()
obj2 = migrate_data.PowerVMLiveMigrateData()
obj2.from_legacy_dict(leg)
for field in leg:
self.assertEqual(getattr(obj, field), getattr(obj2, field))
class TestPowerVMLiveMigrateData(test_objects._LocalTest,
_TestPowerVMLiveMigrateData):

190
nova/tests/unit/virt/libvirt/test_driver.py
View File

@ -8759,15 +8759,18 @@ class LibvirtConnTestCase(test.NoDBTestCase,
return_value = drvr.check_can_live_migrate_destination(self.context,
instance_ref, None, compute_info, True)
return_value.is_volume_backed = False
self.assertThat({"filename": "file",
'image_type': 'default',
'disk_available_mb': 409600,
"disk_over_commit": False,
"block_migration": True,
"is_volume_backed": False,
"dst_wants_file_backed_memory": False,
"file_backed_memory_discard": False},
matchers.DictMatches(return_value.to_legacy_dict()))
self.assertEqual({'filename': 'file',
'image_type': 'default',
'disk_available_mb': 409600,
'disk_over_commit': False,
'block_migration': True,
'is_volume_backed': False,
'dst_wants_file_backed_memory': False,
'file_backed_memory_discard': False,
'graphics_listen_addr_spice': '127.0.0.1',
'graphics_listen_addr_vnc': '127.0.0.1',
'serial_listen_addr': None},
return_value.obj_to_primitive()['nova_object.data'])
@mock.patch.object(objects.Service, 'get_by_compute_host')
@mock.patch.object(libvirt_driver.LibvirtDriver,
@ -8794,15 +8797,18 @@ class LibvirtConnTestCase(test.NoDBTestCase,
return_value = drvr.check_can_live_migrate_destination(self.context,
instance_ref, None, compute_info, True, True)
return_value.is_volume_backed = False
self.assertThat({"filename": "file",
'image_type': 'default',
'disk_available_mb': 51200,
"disk_over_commit": True,
"block_migration": True,
"is_volume_backed": False,
"dst_wants_file_backed_memory": False,
"file_backed_memory_discard": False},
matchers.DictMatches(return_value.to_legacy_dict()))
self.assertEqual({'filename': 'file',
'image_type': 'default',
'disk_available_mb': 51200,
'disk_over_commit': True,
'block_migration': True,
'is_volume_backed': False,
'dst_wants_file_backed_memory': False,
'file_backed_memory_discard': False,
'graphics_listen_addr_spice': '127.0.0.1',
'graphics_listen_addr_vnc': '127.0.0.1',
'serial_listen_addr': None},
return_value.obj_to_primitive()['nova_object.data'])
@mock.patch.object(objects.Service, 'get_by_compute_host')
@mock.patch.object(libvirt_driver.LibvirtDriver,
@ -8826,15 +8832,18 @@ class LibvirtConnTestCase(test.NoDBTestCase,
return_value = drvr.check_can_live_migrate_destination(self.context,
instance_ref, None, compute_info, False)
return_value.is_volume_backed = False
self.assertThat({"filename": "file",
"image_type": 'default',
"block_migration": False,
"disk_over_commit": False,
"disk_available_mb": 409600,
"is_volume_backed": False,
"dst_wants_file_backed_memory": False,
"file_backed_memory_discard": False},
matchers.DictMatches(return_value.to_legacy_dict()))
self.assertEqual({'filename': 'file',
'image_type': 'default',
'block_migration': False,
'disk_over_commit': False,
'disk_available_mb': 409600,
'is_volume_backed': False,
'dst_wants_file_backed_memory': False,
'file_backed_memory_discard': False,
'graphics_listen_addr_spice': '127.0.0.1',
'graphics_listen_addr_vnc': '127.0.0.1',
'serial_listen_addr': None},
return_value.obj_to_primitive()['nova_object.data'])
@mock.patch.object(objects.Service, 'get_by_compute_host')
@mock.patch.object(libvirt_driver.LibvirtDriver,
@ -8900,15 +8909,18 @@ class LibvirtConnTestCase(test.NoDBTestCase,
self.context, instance_ref, compute_info, compute_info)
result.is_volume_backed = False
mock_cpu.assert_called_once_with(None, 'asdf', instance_ref)
expected_result = {"filename": 'fake',
"image_type": CONF.libvirt.images_type,
"block_migration": False,
"disk_over_commit": False,
"disk_available_mb": 1024,
"is_volume_backed": False,
"dst_wants_file_backed_memory": False,
"file_backed_memory_discard": False}
self.assertEqual(expected_result, result.to_legacy_dict())
self.assertEqual({'filename': 'fake',
'image_type': CONF.libvirt.images_type,
'block_migration': False,
'disk_over_commit': False,
'disk_available_mb': 1024,
'is_volume_backed': False,
'dst_wants_file_backed_memory': False,
'file_backed_memory_discard': False,
'graphics_listen_addr_spice': '127.0.0.1',
'graphics_listen_addr_vnc': '127.0.0.1',
'serial_listen_addr': None},
result.obj_to_primitive()['nova_object.data'])
@mock.patch.object(objects.Service, 'get_by_compute_host')
@mock.patch.object(libvirt_driver.LibvirtDriver,
@ -8936,15 +8948,18 @@ class LibvirtConnTestCase(test.NoDBTestCase,
instance_ref, compute_info, compute_info, False)
# NOTE(danms): Compute manager would have set this, so set it here
return_value.is_volume_backed = False
self.assertThat({"filename": "file",
"image_type": 'default',
"block_migration": False,
"disk_over_commit": False,
"disk_available_mb": 1024,
"is_volume_backed": False,
"dst_wants_file_backed_memory": False,
"file_backed_memory_discard": False},
matchers.DictMatches(return_value.to_legacy_dict()))
self.assertEqual({'filename': 'file',
'image_type': 'default',
'block_migration': False,
'disk_over_commit': False,
'disk_available_mb': 1024,
'is_volume_backed': False,
'dst_wants_file_backed_memory': False,
'file_backed_memory_discard': False,
'graphics_listen_addr_spice': '127.0.0.1',
'graphics_listen_addr_vnc': '127.0.0.1',
'serial_listen_addr': None},
return_value.obj_to_primitive()['nova_object.data'])
@mock.patch.object(objects.Service, 'get_by_compute_host')
@mock.patch.object(libvirt_driver.LibvirtDriver,
@ -11653,25 +11668,42 @@ class LibvirtConnTestCase(test.NoDBTestCase,
'/fake/instance/dir', None)
self.assertFalse(mock_fetch.called)
def _migrate_data_to_dict(self, migrate_data):
primitive = migrate_data.obj_to_primitive()['nova_object.data']
primitive['bdms'] = [bdm['nova_object.data'] for bdm in
primitive['bdms']]
return primitive
def _generate_target_ret(self, target_connect_addr=None):
target_ret = {
'graphics_listen_addrs': {'spice': '127.0.0.1', 'vnc': '127.0.0.1'},
'target_connect_addr': target_connect_addr,
'serial_listen_addr': '127.0.0.1',
'volume': {
'12345': {'connection_info': {u'data': {'device_path':
u'/dev/disk/by-path/ip-1.2.3.4:3260-iqn.abc.12345.opst-lun-X'},
'serial': '12345'},
'disk_info': {'bus': 'scsi',
'dev': 'sda',
'type': 'disk'}},
'67890': {'connection_info': {u'data': {'device_path':
u'/dev/disk/by-path/ip-1.2.3.4:3260-iqn.cde.67890.opst-lun-Z'},
'serial': '67890'},
'disk_info': {'bus': 'scsi',
'dev': 'sdb',
'type': 'disk'}}}}
return target_ret
return self._migrate_data_to_dict(objects.LibvirtLiveMigrateData(
block_migration=False,
instance_relative_path='foo',
is_shared_block_storage=False,
is_shared_instance_path=False,
serial_listen_ports=[],
src_supports_native_luks=True,
supported_perf_events=[],
graphics_listen_addr_spice='127.0.0.1',
graphics_listen_addr_vnc='127.0.0.1',
serial_listen_addr='127.0.0.1',
target_connect_addr=target_connect_addr,
bdms=[
objects.LibvirtLiveMigrateBDMInfo(
serial='12345', bus='scsi', dev='sda', type='disk',
boot_index=None, format=None,
connection_info_json=jsonutils.dumps({
'serial': '12345',
'data': {
'device_path': '/dev/disk/by-path/ip-1.2.3.4:3260'
'-iqn.abc.12345.opst-lun-X'}})),
objects.LibvirtLiveMigrateBDMInfo(
serial='67890', bus='scsi', dev='sdb', type='disk',
boot_index=None, format=None,
connection_info_json=jsonutils.dumps({
'serial': '67890',
'data': {
'device_path': '/dev/disk/by-path/ip-1.2.3.4:3260'
'-iqn.cde.67890.opst-lun-Z'}}))]))
def test_pre_live_migration_works_correctly_mocked(self):
self._test_pre_live_migration_works_correctly_mocked()
@ -11772,18 +11804,23 @@ class LibvirtConnTestCase(test.NoDBTestCase,
serial_listen_addr='127.0.0.1',
)
if not target_ret:
target_ret = self._generate_target_ret()
if src_supports_native_luks:
migrate_data.src_supports_native_luks = True
else:
target_ret.pop('src_supports_native_luks')
result = drvr.pre_live_migration(
c, instance, block_device_info, nw_info, None,
migrate_data=migrate_data)
if not target_ret:
target_ret = self._generate_target_ret()
self.assertEqual(
target_ret,
result.to_legacy_dict(
pre_migration_result=True)['pre_live_migration_result'])
result_dict = self._migrate_data_to_dict(result)
# connection_info_json is a string, needs special handling
for bdms in zip(target_ret.pop('bdms'), result_dict.pop('bdms')):
conninfo0 = jsonutils.loads(bdms[0].pop('connection_info_json'))
conninfo1 = jsonutils.loads(bdms[1].pop('connection_info_json'))
self.assertEqual(conninfo0, conninfo1)
self.assertThat(bdms[0], matchers.DictMatches(bdms[1]))
self.assertThat(target_ret, matchers.DictMatches(result_dict))
mock_connect.assert_has_calls(expected_connect_calls)
self.assertEqual(len(expected_connect_calls), mock_connect.call_count)
mock_plug.assert_called_once_with(test.MatchType(objects.Instance),
@ -11854,18 +11891,21 @@ class LibvirtConnTestCase(test.NoDBTestCase,
)
res_data = drvr.pre_live_migration(
self.context, instance, vol, [], None, migrate_data)
res_data = res_data.to_legacy_dict(pre_migration_result=True)
block_device_info_get_mapping.assert_called_once_with(
{'block_device_mapping': [
{'connection_info': 'dummy', 'mount_device': '/dev/sda'},
{'connection_info': 'dummy', 'mount_device': '/dev/sdb'}
]}
)
self.assertEqual({'graphics_listen_addrs': {'spice': None,
'vnc': None},
self.assertEqual({'block_migration': False,
'instance_relative_path': 'foo',
'is_shared_block_storage': False,
'is_shared_instance_path': False,
'serial_listen_ports': [],
'supported_perf_events': [],
'target_connect_addr': None,
'serial_listen_addr': None,
'volume': {}}, res_data['pre_live_migration_result'])
'bdms': []},
res_data.obj_to_primitive()['nova_object.data'])
def _test_pre_live_migration_volume_backed(self, encrypted_volumes=False):
inst_ref = objects.Instance(root_device_name='/dev/vda',

14
nova/tests/unit/virt/xenapi/test_xenapi.py
View File

@ -3587,18 +3587,17 @@ class XenAPILiveMigrateTestCase(stubs.XenAPITestBaseNoDB):
fake_get_network_ref.return_value = 'fake_network_ref'
expected = {'block_migration': True,
'is_volume_backed': False,
'migrate_data': {
'migrate_send_data': {'value':
'fake_migrate_data'},
'destination_sr_ref': 'asdf'}
}
'migrate_send_data': {'value': 'fake_migrate_data'},
'destination_sr_ref': 'asdf',
'vif_uuid_map': {'': 'fake_network_ref'}}
result = self.conn.check_can_live_migrate_destination(
self.context,
fake_instance,
{}, {},
True, False)
result.is_volume_backed = False
self.assertEqual(expected, result.to_legacy_dict())
self.assertEqual(expected,
result.obj_to_primitive()['nova_object.data'])
def test_check_live_migrate_destination_verifies_ip(self):
stubs.stubout_session(self, stubs.FakeSessionForVMTests)
@ -3690,8 +3689,7 @@ class XenAPILiveMigrateTestCase(stubs.XenAPITestBaseNoDB):
result = self.conn.check_can_live_migrate_source(self.context,
{'host': 'host'},
dest_check_data)
self.assertEqual(dest_check_data.to_legacy_dict(),
result.to_legacy_dict())
self.assertEqual(dest_check_data, result)
@mock.patch.object(session.XenAPISession, 'is_xsm_sr_check_relaxed',
return_value=False)

6
nova/virt/libvirt/driver.py
View File

@ -88,7 +88,6 @@ from nova.network import model as network_model
from nova import objects
from nova.objects import diagnostics as diagnostics_obj
from nova.objects import fields
from nova.objects import migrate_data as migrate_data_obj
from nova.pci import manager as pci_manager
from nova.pci import utils as pci_utils
import nova.privsep.libvirt
@ -6760,11 +6759,6 @@ class LibvirtDriver(driver.ComputeDriver):
:param block_device_info: result of _get_instance_block_device_info
:returns: a LibvirtLiveMigrateData object
"""
if not isinstance(dest_check_data, migrate_data_obj.LiveMigrateData):
md_obj = objects.LibvirtLiveMigrateData()
md_obj.from_legacy_dict(dest_check_data)
dest_check_data = md_obj
# Checking shared storage connectivity
# if block migration, instances_path should not be on shared storage.
source = CONF.host