def setUp(self):
super(TestLPM, self).setUp()
self.flags(disk_driver='localdisk', group='powervm')
self.drv_fix = self.useFixture(fx.PowerVMComputeDriver())
self.drv = self.drv_fix.drv
self.apt = self.drv.adapter
self.inst = objects.Instance(**powervm.TEST_INSTANCE)
self.network_infos = fake_network.fake_get_instance_nw_info(self, 1)
self.inst.info_cache = objects.InstanceInfoCache(
network_info=self.network_infos)
self.mig_data = mig_obj.PowerVMLiveMigrateData()
self.mig_data.host_mig_data = {}
self.mig_data.dest_ip = '1'
self.mig_data.dest_user_id = 'neo'
self.mig_data.dest_sys_name = 'a'
self.mig_data.public_key = 'PublicKey'
self.mig_data.dest_proc_compat = 'a,b,c'
self.mig_data.vol_data = {}
self.mig_data.vea_vlan_mappings = {}
self.lpmsrc = lpm.LiveMigrationSrc(self.drv, self.inst, self.mig_data)
self.lpmdst = lpm.LiveMigrationDest(self.drv, self.inst)
self.add_key = self.useFixture(fixtures.MockPatch(
'pypowervm.tasks.management_console.add_authorized_key')).mock
self.get_key = self.useFixture(fixtures.MockPatch(
'pypowervm.tasks.management_console.get_public_key')).mock
self.get_key.return_value = 'PublicKey'
# Short path to the host's migration_data
self.host_mig_data = self.drv.host_wrapper.migration_data
def _spawn_instance(self,
cow,
block_device_info=None,
ephemeral_storage=False):
self.flags(use_cow_images=cow)
self._instance_data = self._get_instance_data()
instance = db.instance_create(self._context, self._instance_data)
instance['system_metadata'] = {}
instance.flavor = mock.MagicMock()
instance.flavor.extra_specs.get.return_value = None
if ephemeral_storage:
instance['ephemeral_gb'] = 1
image = db_fakes.get_fake_image_data(self._project_id, self._user_id)
network_info = fake_network.fake_get_instance_nw_info(self.stubs)
self._conn.spawn(self._context,
instance,
image,
injected_files=[],
admin_password=None,
network_info=network_info,
block_device_info=block_device_info)
def setUp(self):
super(NotificationsTestCase, self).setUp()
self.fixture = self.useFixture(o_fixture.ClearRequestContext())
self.net_info = fake_network.fake_get_instance_nw_info(self, 1,
1)
def fake_get_nw_info(cls, ctxt, instance):
self.assertTrue(ctxt.is_admin)
return self.net_info
self.stub_out('nova.network.api.API.get_instance_nw_info',
fake_get_nw_info)
fake_notifier.stub_notifier(self)
self.addCleanup(fake_notifier.reset)
self.flags(host='testhost')
self.flags(notify_on_state_change="vm_and_task_state",
group='notifications')
self.flags(api_servers=['http://localhost:9292'], group='glance')
self.user_id = 'fake'
self.project_id = 'fake'
self.context = context.RequestContext(self.user_id, self.project_id)
self.fake_time = datetime.datetime(2017, 2, 2, 16, 45, 0)
timeutils.set_time_override(self.fake_time)
self.instance = self._wrapped_create()
self.decorated_function_called = False
def setUp(self):
super(NotificationsTestCase, self).setUp()
self.fixture = self.useFixture(o_fixture.ClearRequestContext())
self.net_info = fake_network.fake_get_instance_nw_info(self, 1, 1)
def fake_get_nw_info(cls, ctxt, instance):
self.assertTrue(ctxt.is_admin)
return self.net_info
self.stub_out('nova.network.api.API.get_instance_nw_info',
fake_get_nw_info)
fake_network.set_stub_network_methods(self)
fake_notifier.stub_notifier(self.stubs)
self.addCleanup(fake_notifier.reset)
self.flags(network_manager='nova.network.manager.FlatManager',
notify_on_state_change="vm_and_task_state",
host='testhost')
self.flags(api_servers=['http://localhost:9292'], group='glance')
self.user_id = 'fake'
self.project_id = 'fake'
self.context = context.RequestContext(self.user_id, self.project_id)
self.instance = self._wrapped_create()
self.decorated_function_called = False
def setUp(self):
super(NotificationsTestCase, self).setUp()
self.fixture = self.useFixture(o_fixture.ClearRequestContext())
self.net_info = fake_network.fake_get_instance_nw_info(self.stubs, 1,
1)
def fake_get_nw_info(cls, ctxt, instance):
self.assertTrue(ctxt.is_admin)
return self.net_info
self.stubs.Set(network_api.API, 'get_instance_nw_info',
fake_get_nw_info)
fake_network.set_stub_network_methods(self.stubs)
fake_notifier.stub_notifier(self.stubs)
self.addCleanup(fake_notifier.reset)
self.flags(compute_driver='nova.virt.fake.FakeDriver',
network_manager='nova.network.manager.FlatManager',
notify_on_state_change="vm_and_task_state",
host='testhost')
self.user_id = 'fake'
self.project_id = 'fake'
self.context = context.RequestContext(self.user_id, self.project_id)
self.instance = self._wrapped_create()
self.decorated_function_called = False
def test_confirm_migration(self):
self._instance = self._get_instance()
network_info = fake_network.fake_get_instance_nw_info(self.stubs)
pathutils.PathUtils.get_instance_migr_revert_dir(self._instance.name, remove_dir=True)
self._mox.ReplayAll()
self._conn.confirm_migration(None, self._instance, network_info)
self._mox.VerifyAll()
def test_local_ipv4_from_nw_info(self):
nw_info = fake_network.fake_get_instance_nw_info(self.stubs,
num_networks=2)
expected_local = "192.168.1.100"
md = fake_InstanceMetadata(self.stubs, self.instance,
network_info=nw_info)
data = md.get_ec2_metadata(version='2009-04-04')
self.assertEqual(data['meta-data']['local-ipv4'], expected_local)
def test_local_ipv4_from_nw_info(self):
nw_info = fake_network.fake_get_instance_nw_info(self.stubs,
num_networks=2)
expected_local = "192.168.1.100"
md = fake_InstanceMetadata(self.stubs, self.instance,
network_info=nw_info)
data = md.get_ec2_metadata(version='2009-04-04')
self.assertEqual(data['meta-data']['local-ipv4'], expected_local)
def test_vm_update_with_states(self):
fake_net_info = fake_network.fake_get_instance_nw_info(self)
self.instance.info_cache.network_info = fake_net_info
notifications.send_update_with_states(self.context, self.instance,
vm_states.BUILDING, vm_states.ACTIVE, task_states.SPAWNING,
task_states.SPAWNING, verify_states=True)
self._verify_notification()
def test_confirm_migration(self):
self._instance = self._get_instance()
network_info = fake_network.fake_get_instance_nw_info(self.stubs)
pathutils.PathUtils.get_instance_migr_revert_dir(self._instance.name,
remove_dir=True)
self._mox.ReplayAll()
self._conn.confirm_migration(None, self._instance, network_info)
self._mox.VerifyAll()
def _test_finish_revert_migration(self, power_on, ephemeral_storage=False,
config_drive=False,
config_drive_format='iso'):
self._instance = self._get_instance()
self._instance.memory_mb = 100
self._instance.vcpus = 2
self._instance['system_metadata'] = {}
network_info = fake_network.fake_get_instance_nw_info(self.stubs)
fake_revert_path = ('C:\\FakeInstancesPath\\%s\\_revert' %
self._instance.name)
m = fake.PathUtils.get_instance_dir(mox.IsA(str),
create_dir=False,
remove_dir=True)
m.AndReturn(self._test_instance_dir)
m = pathutils.PathUtils.get_instance_migr_revert_dir(
self._instance.name)
m.AndReturn(fake_revert_path)
fake.PathUtils.rename(fake_revert_path, mox.IsA(str))
m = fake.PathUtils.get_instance_dir(mox.IsA(str))
m.AndReturn(self._test_instance_dir)
m = fake.PathUtils.get_instance_dir(mox.IsA(str))
if ephemeral_storage:
m.AndReturn(self._test_instance_dir)
else:
m.AndReturn(None)
m = imagecache.ImageCache.get_image_details(mox.IsA(object),
mox.IsA(object))
m.AndReturn({'properties': {constants.IMAGE_PROP_VM_GEN:
constants.IMAGE_PROP_VM_GEN_1}})
self._set_vm_name(self._instance.name)
self._setup_create_instance_mocks(None, False,
ephemeral_storage=ephemeral_storage)
if power_on:
vmutils.VMUtils.set_vm_state(mox.Func(self._check_instance_name),
constants.HYPERV_VM_STATE_ENABLED)
self._setup_log_vm_output_mocks()
if config_drive:
self._mock_attach_config_drive(self._instance, config_drive_format)
self._mox.ReplayAll()
self._conn.finish_revert_migration(self._context, self._instance,
network_info, None,
power_on)
self._mox.VerifyAll()
if config_drive:
self._verify_attach_config_drive(config_drive_format)
def _test_finish_migration(self, power_on, ephemeral_storage=False, config_drive=False, config_drive_format="iso"):
self._instance = self._get_instance()
self._instance.memory_mb = 100
self._instance.vcpus = 2
self._instance["system_metadata"] = {}
self._instance["old_flavor"] = objects.Flavor(root_gb=5)
network_info = fake_network.fake_get_instance_nw_info(self.stubs)
m = fake.PathUtils.get_instance_dir(mox.IsA(str))
m.AndReturn(self._test_instance_dir)
self._mox.StubOutWithMock(fake.PathUtils, "exists")
m = fake.PathUtils.exists(mox.IsA(six.text_type))
m.AndReturn(True)
fake_parent_vhd_path = os.path.join("FakeParentPath", "%s.vhd" % self._instance["image_ref"])
m = vhdutils.VHDUtils.get_vhd_info(mox.IsA(str))
m.AndReturn({"ParentPath": fake_parent_vhd_path, "MaxInternalSize": 1})
m = vhdutils.VHDUtils.get_internal_vhd_size_by_file_size(mox.IsA(six.text_type), mox.IsA(object))
m.AndReturn(1025)
vhdutils.VHDUtils.reconnect_parent_vhd(mox.IsA(str), mox.IsA(six.text_type))
m = vhdutils.VHDUtils.get_vhd_info(mox.IsA(six.text_type))
m.AndReturn({"MaxInternalSize": 1024})
m = fake.PathUtils.exists(mox.IsA(six.text_type))
m.AndReturn(True)
m = fake.PathUtils.get_instance_dir(mox.IsA(str))
if ephemeral_storage:
return m.AndReturn(self._test_instance_dir)
else:
m.AndReturn(None)
self._set_vm_name(self._instance.name)
self._setup_create_instance_mocks(None, False, ephemeral_storage=ephemeral_storage)
if power_on:
vmutils.VMUtils.set_vm_state(mox.Func(self._check_instance_name), constants.HYPERV_VM_STATE_ENABLED)
self._setup_log_vm_output_mocks()
if config_drive:
self._mock_attach_config_drive(self._instance, config_drive_format)
self._mox.ReplayAll()
image_meta = {"properties": {constants.IMAGE_PROP_VM_GEN: constants.IMAGE_PROP_VM_GEN_1}}
self._conn.finish_migration(
self._context, None, self._instance, "", network_info, image_meta, False, None, power_on
)
self._mox.VerifyAll()
if config_drive:
self._verify_attach_config_drive(config_drive_format)
def test_vm_update_with_states(self, mock_bandwidth_list):
mock_bandwidth_list.return_value = [self.get_fake_bandwidth()]
fake_net_info = fake_network.fake_get_instance_nw_info(self, 1, 1)
self.instance.info_cache.network_info = fake_net_info
notifications.send_update_with_states(self.context, self.instance,
vm_states.BUILDING, vm_states.ACTIVE, task_states.SPAWNING,
task_states.SPAWNING, verify_states=True)
self._verify_notification()
def test_vm_update_with_states(self, mock_bandwidth_list):
mock_bandwidth_list.return_value = [self.get_fake_bandwidth()]
fake_net_info = fake_network.fake_get_instance_nw_info(self, 1, 1)
self.instance.info_cache.network_info = fake_net_info
notifications.send_update_with_states(self.context, self.instance,
vm_states.BUILDING, vm_states.ACTIVE, task_states.SPAWNING,
task_states.SPAWNING, verify_states=True)
self._verify_notification()
def test_create_network(self):
instance = stubs._fake_instance()
instance_name = 'fake_instance'
network_info = fake_network.fake_get_instance_nw_info(self)
config = self.config.create_network(instance_name, instance,
network_info)
self.assertEqual({'fake_br1': {'hwaddr': 'DE:AD:BE:EF:00:01',
'nictype': 'bridged',
'parent': 'fake_br1',
'type': 'nic'}}, config)
def test_get_cached_vifs_with_vlan(self):
network_info = fake_network.fake_get_instance_nw_info(self, 2)
network_info[0]['vnic_type'] = network_model.VNIC_TYPE_DIRECT_PHYSICAL
network_info[0]['address'] = "51:5a:2c:a4:5e:1b"
network_info[1]['vnic_type'] = network_model.VNIC_TYPE_DIRECT_PHYSICAL
network_info[1]['address'] = "fa:16:3e:d1:28:e4"
network_info[1]['details'] = dict(vlan='2145')
expected = {'fa:16:3e:d1:28:e4': '2145'}
self.assertEqual(expected,
netutils.get_cached_vifs_with_vlan(network_info))
def test_get_cached_vifs_with_vlan(self):
network_info = fake_network.fake_get_instance_nw_info(self, 2)
network_info[0]['vnic_type'] = network_model.VNIC_TYPE_DIRECT_PHYSICAL
network_info[0]['address'] = "51:5a:2c:a4:5e:1b"
network_info[1]['vnic_type'] = network_model.VNIC_TYPE_DIRECT_PHYSICAL
network_info[1]['address'] = "fa:16:3e:d1:28:e4"
network_info[1]['details'] = dict(vlan=2145)
expected = {'fa:16:3e:d1:28:e4': 2145}
self.assertEqual(expected,
netutils.get_cached_vifs_with_vlan(network_info))
def test_task_update_with_states(self, mock_bandwidth_list):
self.flags(notify_on_state_change="vm_and_task_state")
mock_bandwidth_list.return_value = [self.get_fake_bandwidth()]
fake_net_info = fake_network.fake_get_instance_nw_info(self, 1, 1)
self.instance.info_cache.network_info = fake_net_info
notifications.send_update_with_states(self.context, self.instance,
vm_states.BUILDING, vm_states.BUILDING, task_states.SPAWNING,
None, verify_states=True)
self._verify_notification(expected_state=vm_states.BUILDING,
expected_new_task_state=None)
def test_task_update_with_states(self):
self.flags(notify_on_state_change="vm_and_task_state",
group='notifications')
fake_net_info = fake_network.fake_get_instance_nw_info(self)
self.instance.info_cache.network_info = fake_net_info
notifications.send_update_with_states(self.context, self.instance,
vm_states.BUILDING, vm_states.BUILDING, task_states.SPAWNING,
None, verify_states=True)
self._verify_notification(expected_state=vm_states.BUILDING,
expected_new_task_state=None)
def test_task_update_with_states(self, mock_bandwidth_list):
self.flags(notify_on_state_change="vm_and_task_state",
group='notifications')
mock_bandwidth_list.return_value = [self.get_fake_bandwidth()]
fake_net_info = fake_network.fake_get_instance_nw_info(self, 1, 1)
self.instance.info_cache.network_info = fake_net_info
notifications.send_update_with_states(self.context, self.instance,
vm_states.BUILDING, vm_states.BUILDING, task_states.SPAWNING,
None, verify_states=True)
self._verify_notification(expected_state=vm_states.BUILDING,
expected_new_task_state=None)
def test_network_in_out_average(self):
instance = stubs._fake_instance()
instance.flavor.extra_specs = {
'quota:vif_inbound_average': 20 * units.M,
'quota:vif_outbound_average': 8 * units.M
}
instance_name = 'fake_instance'
network_info = fake_network.fake_get_instance_nw_info(self)
config = self.config.create_network(instance_name, instance,
network_info)
self.assertEqual({'fake_br1': {'hwaddr': 'DE:AD:BE:EF:00:01',
'nictype': 'bridged',
'parent': 'fake_br1',
'type': 'nic',
'limits.ingress': '20Mbit',
'limits.egress': '8Mbit'}}, config)
def test_network_in_out_average(self):
instance = stubs._fake_instance()
# We get KB/s from flavor spec, but expect Mbit/s
# in LXD confix
instance.flavor.extra_specs = {
'quota:vif_inbound_average': 20000,
'quota:vif_outbound_average': 8000
}
instance_name = 'fake_instance'
network_info = fake_network.fake_get_instance_nw_info(self)
config = self.config.create_network(instance_name, instance,
network_info)
self.assertEqual({'fake_br1': {'hwaddr': 'DE:AD:BE:EF:00:01',
'nictype': 'bridged',
'parent': 'fake_br1',
'type': 'nic',
'limits.ingress': '160Mbit',
'limits.egress': '64Mbit'}}, config)
def _spawn_instance(self, cow, block_device_info=None,
ephemeral_storage=False):
self.flags(use_cow_images=cow)
self._instance_data = self._get_instance_data()
instance = db.instance_create(self._context, self._instance_data)
instance['system_metadata'] = {}
if ephemeral_storage:
instance['ephemeral_gb'] = 1
image = db_fakes.get_fake_image_data(self._project_id, self._user_id)
network_info = fake_network.fake_get_instance_nw_info(self.stubs)
self._conn.spawn(self._context, instance, image,
injected_files=[], admin_password=None,
network_info=network_info,
block_device_info=block_device_info)
def test_network_in_out_average_and_peak(self):
# Max of the two values should take precedence
instance = stubs._fake_instance()
instance.flavor.extra_specs = {
'quota:vif_inbound_average': 2 * units.M,
'quota:vif_outbound_average': 10 * units.M,
'quota:vif_inbound_peak': 10 * units.M,
'quota:vif_outbound_peak': 2 * units.M,
}
instance_name = 'fake_instance'
network_info = fake_network.fake_get_instance_nw_info(self)
config = self.config.create_network(instance_name, instance,
network_info)
self.assertEqual({'fake_br1': {'hwaddr': 'DE:AD:BE:EF:00:01',
'nictype': 'bridged',
'parent': 'fake_br1',
'type': 'nic',
'limits.ingress': '10Mbit',
'limits.egress': '10Mbit'}}, config)
def test_network_in_out_average(self):
instance = stubs._fake_instance()
# We get KB/s from flavor spec, but expect Mbit/s
# in LXD confix
instance.flavor.extra_specs = {
'quota:vif_inbound_average': 20000,
'quota:vif_outbound_average': 8000
}
instance_name = 'fake_instance'
network_info = fake_network.fake_get_instance_nw_info(self)
config = self.config.create_network(instance_name, instance,
network_info)
self.assertEqual(
{
'fake_br1': {
'hwaddr': 'DE:AD:BE:EF:00:01',
'nictype': 'bridged',
'parent': 'fake_br1',
'type': 'nic',
'limits.ingress': '160Mbit',
'limits.egress': '64Mbit'
}
}, config)
def setUp(self):
super(NotificationsTestCase, self).setUp()
self.fixture = self.useFixture(o_fixture.ClearRequestContext())
self.net_info = fake_network.fake_get_instance_nw_info(self)
self.notifier = self.useFixture(fixtures.NotificationFixture(self))
self.flags(host='testhost')
self.flags(notify_on_state_change="vm_and_task_state",
group='notifications')
self.flags(api_servers=['http://localhost:9292'], group='glance')
self.user_id = 'fake'
self.project_id = 'fake'
self.context = context.RequestContext(self.user_id, self.project_id)
self.fake_time = datetime.datetime(2017, 2, 2, 16, 45, 0)
timeutils.set_time_override(self.fake_time)
self.instance = self._wrapped_create()
self.decorated_function_called = False
def test_get_cached_vifs_with_vlan_with_no_vlan_details(self):
network_info = fake_network.fake_get_instance_nw_info(self, 1)
network_info[0]['vnic_type'] = network_model.VNIC_TYPE_DIRECT_PHYSICAL
network_info[0]['address'] = "51:5a:2c:a4:5e:1b"
self.assertEqual({}, netutils.get_cached_vifs_with_vlan(network_info))
def _test_finish_migration(self,
power_on,
ephemeral_storage=False,
config_drive=False,
config_drive_format='iso'):
self._instance = self._get_instance()
self._instance.memory_mb = 100
self._instance.vcpus = 2
self._instance['system_metadata'] = {}
self._instance['old_flavor'] = objects.Flavor(root_gb=5)
network_info = fake_network.fake_get_instance_nw_info(self.stubs)
m = fake.PathUtils.get_instance_dir(mox.IsA(str))
m.AndReturn(self._test_instance_dir)
self._mox.StubOutWithMock(fake.PathUtils, 'exists')
m = fake.PathUtils.exists(mox.IsA(six.text_type))
m.AndReturn(True)
fake_parent_vhd_path = (os.path.join(
'FakeParentPath', '%s.vhd' % self._instance["image_ref"]))
m = vhdutils.VHDUtils.get_vhd_info(mox.IsA(str))
m.AndReturn({'ParentPath': fake_parent_vhd_path, 'MaxInternalSize': 1})
m = vhdutils.VHDUtils.get_internal_vhd_size_by_file_size(
mox.IsA(six.text_type), mox.IsA(object))
m.AndReturn(1025)
vhdutils.VHDUtils.reconnect_parent_vhd(mox.IsA(str),
mox.IsA(six.text_type))
m = vhdutils.VHDUtils.get_vhd_info(mox.IsA(six.text_type))
m.AndReturn({'MaxInternalSize': 1024})
m = fake.PathUtils.exists(mox.IsA(six.text_type))
m.AndReturn(True)
m = fake.PathUtils.get_instance_dir(mox.IsA(str))
if ephemeral_storage:
return m.AndReturn(self._test_instance_dir)
else:
m.AndReturn(None)
self._set_vm_name(self._instance.name)
self._setup_create_instance_mocks(None,
False,
ephemeral_storage=ephemeral_storage)
if power_on:
vmutils.VMUtils.set_vm_state(mox.Func(self._check_instance_name),
constants.HYPERV_VM_STATE_ENABLED)
self._setup_log_vm_output_mocks()
if config_drive:
self._mock_attach_config_drive(self._instance, config_drive_format)
self._mox.ReplayAll()
image_meta = {
'properties': {
constants.IMAGE_PROP_VM_GEN: constants.IMAGE_PROP_VM_GEN_1
}
}
self._conn.finish_migration(self._context, None, self._instance, "",
network_info, image_meta, False, None,
power_on)
self._mox.VerifyAll()
if config_drive:
self._verify_attach_config_drive(config_drive_format)
def test_local_ipv4(self):
nw_info = fake_network.fake_get_instance_nw_info(self.stubs, num_networks=2)
expected_local = "192.168.1.100"
md = fake_InstanceMetadata(self.stubs, self.instance, network_info=nw_info, address="fake")
data = md.get_ec2_metadata(version="2009-04-04")
self.assertEqual(expected_local, data["meta-data"]["local-ipv4"])
def fake_get_nw_info(cls, ctxt, instance):
self.assertTrue(ctxt.is_admin)
return fake_network.fake_get_instance_nw_info(self.stubs, 1, 1)
def fake_get_nw_info(cls, ctxt, instance):
self.assertTrue(ctxt.is_admin)
return fake_network.fake_get_instance_nw_info(self.stubs, 1, 1)
def fake_get_nw_info_for_instance(instance):
return fake_network.fake_get_instance_nw_info(self)
def fake_get_nw_info_for_instance(instance):
return fake_network.fake_get_instance_nw_info(self)
def _setup_test_migrate_disk_and_power_off_mocks(self, same_host=False,
copy_exception=False,
size_exception=False):
self._instance = self._get_instance()
network_info = fake_network.fake_get_instance_nw_info(self.stubs)
self._instance['root_gb'] = 10
fake_local_ip = '10.0.0.1'
if same_host:
fake_dest_ip = fake_local_ip
else:
fake_dest_ip = '10.0.0.2'
if size_exception:
flavor = 'm1.tiny'
else:
flavor = 'm1.small'
flavor = db.flavor_get_by_name(self._context, flavor)
flavor = fake_flavor.fake_flavor_obj(self._context, **flavor)
if not size_exception:
fake_root_vhd_path = 'C:\\FakePath\\root.vhd'
fake_revert_path = os.path.join(self._test_instance_dir, '_revert')
func = mox.Func(self._check_instance_name)
vmutils.VMUtils.set_vm_state(func,
constants.HYPERV_VM_STATE_DISABLED)
self._setup_delete_vm_log_mocks()
m = vmutils.VMUtils.get_vm_storage_paths(func)
m.AndReturn(([fake_root_vhd_path], []))
m = hostutils.HostUtils.get_local_ips()
m.AndReturn([fake_local_ip])
m = fake.PathUtils.get_instance_dir(mox.IsA(str))
m.AndReturn(self._test_instance_dir)
m = pathutils.PathUtils.get_instance_migr_revert_dir(
self._instance.name, remove_dir=True, create_dir=True)
m.AndReturn(fake_revert_path)
if same_host:
fake.PathUtils.makedirs(mox.IsA(str))
m = fake.PathUtils.copy(fake_root_vhd_path, mox.IsA(str))
if copy_exception:
m.AndRaise(shutil.Error('Simulated copy error'))
m = fake.PathUtils.get_instance_dir(mox.IsA(str),
mox.IsA(str),
remove_dir=True)
m.AndReturn(self._test_instance_dir)
else:
fake.PathUtils.move_folder_files(mox.IsA(str),
mox.IsA(str))
destroy_disks = True
if same_host:
fake.PathUtils.move_folder_files(mox.IsA(str),
mox.IsA(str))
destroy_disks = False
self._setup_destroy_mocks(False)
if destroy_disks:
m = fake.PathUtils.get_instance_dir(mox.IsA(str),
mox.IsA(str),
remove_dir=True)
m.AndReturn(self._test_instance_dir)
return (self._instance, fake_dest_ip, network_info, flavor)
def get_nw_info_for_instance(instance):
return fake_network.fake_get_instance_nw_info(test)
def _setup_test_migrate_disk_and_power_off_mocks(self,
same_host=False,
copy_exception=False,
size_exception=False):
self._instance = self._get_instance()
network_info = fake_network.fake_get_instance_nw_info(self.stubs)
self._instance['root_gb'] = 10
fake_local_ip = '10.0.0.1'
if same_host:
fake_dest_ip = fake_local_ip
else:
fake_dest_ip = '10.0.0.2'
if size_exception:
flavor = 'm1.tiny'
else:
flavor = 'm1.small'
flavor = db.flavor_get_by_name(self._context, flavor)
if not size_exception:
fake_root_vhd_path = 'C:\\FakePath\\root.vhd'
fake_revert_path = os.path.join(self._test_instance_dir, '_revert')
func = mox.Func(self._check_instance_name)
vmutils.VMUtils.set_vm_state(func,
constants.HYPERV_VM_STATE_DISABLED)
self._setup_delete_vm_log_mocks()
m = vmutils.VMUtils.get_vm_storage_paths(func)
m.AndReturn(([fake_root_vhd_path], []))
m = hostutils.HostUtils.get_local_ips()
m.AndReturn([fake_local_ip])
m = fake.PathUtils.get_instance_dir(mox.IsA(str))
m.AndReturn(self._test_instance_dir)
m = pathutils.PathUtils.get_instance_migr_revert_dir(
self._instance.name, remove_dir=True, create_dir=True)
m.AndReturn(fake_revert_path)
if same_host:
fake.PathUtils.makedirs(mox.IsA(str))
m = fake.PathUtils.copy(fake_root_vhd_path, mox.IsA(str))
if copy_exception:
m.AndRaise(shutil.Error('Simulated copy error'))
m = fake.PathUtils.get_instance_dir(mox.IsA(str),
mox.IsA(str),
remove_dir=True)
m.AndReturn(self._test_instance_dir)
else:
fake.PathUtils.move_folder_files(mox.IsA(str), mox.IsA(str))
destroy_disks = True
if same_host:
fake.PathUtils.move_folder_files(mox.IsA(str),
mox.IsA(str))
destroy_disks = False
self._setup_destroy_mocks(False)
if destroy_disks:
m = fake.PathUtils.get_instance_dir(mox.IsA(str),
mox.IsA(str),
remove_dir=True)
m.AndReturn(self._test_instance_dir)
return (self._instance, fake_dest_ip, network_info, flavor)
def test_get_cached_vifs_with_vlan_with_no_vlan_details(self):
network_info = fake_network.fake_get_instance_nw_info(self, 1)
network_info[0]['vnic_type'] = network_model.VNIC_TYPE_DIRECT_PHYSICAL
network_info[0]['address'] = "51:5a:2c:a4:5e:1b"
self.assertEqual({}, netutils.get_cached_vifs_with_vlan(network_info))
def get_nw_info_for_instance(instance):
return fake_network.fake_get_instance_nw_info(test)
