def test_spawn_container_start_fail(self, neutron_failure=None):
def container_get(*args, **kwargs):
raise lxdcore_exceptions.LXDAPIException(MockResponse(404))
def side_effect(*args, **kwargs):
raise lxdcore_exceptions.LXDAPIException(MockResponse(200))
self.client.containers.get.side_effect = container_get
container = mock.Mock()
ctx = context.get_admin_context()
instance = fake_instance.fake_instance_obj(
ctx, name='test', memory_mb=0)
image_meta = mock.Mock()
injected_files = mock.Mock()
admin_password = mock.Mock()
network_info = [_VIF]
block_device_info = mock.Mock()
virtapi = manager.ComputeVirtAPI(mock.MagicMock())
lxd_driver = driver.LXDDriver(virtapi)
lxd_driver.init_host(None)
lxd_driver.cleanup = mock.Mock()
lxd_driver.client.containers.create = mock.Mock(
side_effect=side_effect)
container.start.side_effect = side_effect
self.assertRaises(
lxdcore_exceptions.LXDAPIException,
lxd_driver.spawn,
ctx, instance, image_meta, injected_files, admin_password,
network_info, block_device_info)
lxd_driver.cleanup.assert_called_once_with(
ctx, instance, network_info, block_device_info)
def test_cleanup(self, execute, rmtree, getpwuid, _):
mock_profile = mock.Mock()
self.client.profiles.get.return_value = mock_profile
pwuid = mock.Mock()
pwuid.pw_name = 'user'
getpwuid.return_value = pwuid
ctx = context.get_admin_context()
instance = fake_instance.fake_instance_obj(
ctx, name='test', memory_mb=0)
network_info = [_VIF]
instance_dir = common.InstanceAttributes(instance).instance_dir
block_device_info = mock.Mock()
lxd_driver = driver.LXDDriver(None)
lxd_driver.init_host(None)
lxd_driver.firewall_driver = mock.Mock()
lxd_driver.cleanup(ctx, instance, network_info, block_device_info)
self.vif_driver.unplug.assert_called_once_with(
instance, network_info[0])
lxd_driver.firewall_driver.unfilter_instance.assert_called_once_with(
instance, network_info)
execute.assert_called_once_with(
'chown', '-R', 'user:user', instance_dir, run_as_root=True)
rmtree.assert_called_once_with(instance_dir)
mock_profile.delete.assert_called_once_with()
def test_init_host(self):
"""init_host initializes the pylxd Client."""
lxd_driver = driver.LXDDriver(None)
lxd_driver.init_host(None)
self.Client.assert_called_once_with()
self.assertEqual(self.client, lxd_driver.client)
def test_spawn_profile_fail(self, configdrive, neutron_failure=None):
"""Cleanup is called when profile creation fails."""
def container_get(*args, **kwargs):
raise lxdcore_exceptions.LXDAPIException(MockResponse(404))
def profile_create(*args, **kwargs):
raise lxdcore_exceptions.LXDAPIException(MockResponse(500))
self.client.containers.get.side_effect = container_get
self.client.profiles.create.side_effect = profile_create
configdrive.return_value = False
ctx = context.get_admin_context()
instance = fake_instance.fake_instance_obj(
ctx, name='test', memory_mb=0)
image_meta = mock.Mock()
injected_files = mock.Mock()
admin_password = mock.Mock()
network_info = [_VIF]
block_device_info = mock.Mock()
virtapi = manager.ComputeVirtAPI(mock.MagicMock())
lxd_driver = driver.LXDDriver(virtapi)
lxd_driver.init_host(None)
lxd_driver.cleanup = mock.Mock()
self.assertRaises(
lxdcore_exceptions.LXDAPIException,
lxd_driver.spawn,
ctx, instance, image_meta, injected_files, admin_password,
network_info, block_device_info)
lxd_driver.cleanup.assert_called_once_with(
ctx, instance, network_info, block_device_info)
def test_attach_volume(self, realpath, stat, minor, major, _):
profile = mock.Mock()
self.client.profiles.get.return_value = profile
realpath.return_value = '/dev/sdc'
stat.return_value.st_rdev = 2080
minor.return_value = 32
major.return_value = 8
ctx = context.get_admin_context()
instance = fake_instance.fake_instance_obj(
ctx, name='test', memory_mb=0)
connection_info = fake_connection_info(
{'id': 1, 'name': 'volume-00000001'},
'10.0.2.15:3260', 'iqn.2010-10.org.openstack:volume-00000001',
auth=True)
mountpoint = '/dev/sdd'
lxd_driver = driver.LXDDriver(None)
lxd_driver.init_host(None)
lxd_driver.storage_driver.connect_volume = mock.MagicMock()
lxd_driver.attach_volume(
ctx, connection_info, instance, mountpoint, None, None, None)
lxd_driver.client.profiles.get.assert_called_once_with(instance.name)
lxd_driver.storage_driver.connect_volume.assert_called_once_with(
connection_info['data'])
profile.save.assert_called_once_with()
def test_get_host_uptime(self, execute):
expected = '00:00:00 up 0 days, 0:00 , 0 users, load average: 0'
execute.return_value = (expected, 'stderr')
lxd_driver = driver.LXDDriver(None)
result = lxd_driver.get_host_uptime()
self.assertEqual(expected, result)
def test_filter_defer_apply_off(self):
firewall = mock.Mock()
lxd_driver = driver.LXDDriver(None)
lxd_driver.firewall_driver = firewall
lxd_driver.filter_defer_apply_off()
firewall.filter_defer_apply_off.assert_called_once_with()
def setUp(self):
super(LXDTestLiveMigrate, self).setUp()
self.driver = driver.LXDDriver(None)
self.context = 'fake_context'
self.driver.session = mock.MagicMock()
self.driver.config = mock.MagicMock()
self.driver.operations = mock.MagicMock()
def setUp(self):
super(LXDTestDriver, self).setUp()
self.ml = stubs.lxd_mock()
lxd_patcher = mock.patch('pylxd.api.API',
mock.Mock(return_value=self.ml))
lxd_patcher.start()
self.addCleanup(lxd_patcher.stop)
self.connection = driver.LXDDriver(fake.FakeVirtAPI())
def test_get_available_nodes(self, gethostname):
gethostname.return_value = 'nova-lxd'
expected = ['nova-lxd']
lxd_driver = driver.LXDDriver(None)
result = lxd_driver.get_available_nodes()
self.assertEqual(expected, result)
def test_init_host_fail(self):
def side_effect():
raise lxdcore_exceptions.ClientConnectionFailed()
self.Client.side_effect = side_effect
self.Client.return_value = None
lxd_driver = driver.LXDDriver(None)
self.assertRaises(exception.HostNotFound, lxd_driver.init_host, None)
def test_list_instances(self):
self.client.containers.all.return_value = [
MockContainer('mock-instance-1'),
MockContainer('mock-instance-2'),
]
lxd_driver = driver.LXDDriver(None)
lxd_driver.init_host(None)
instances = lxd_driver.list_instances()
self.assertEqual(['mock-instance-1', 'mock-instance-2'], instances)
def test_reboot(self):
ctx = context.get_admin_context()
instance = fake_instance.fake_instance_obj(
ctx, name='test', memory_mb=0)
lxd_driver = driver.LXDDriver(None)
lxd_driver.init_host(None)
lxd_driver.reboot(ctx, instance, None, None)
self.client.containers.get.assert_called_once_with(instance.name)
def test_refresh_instance_security_rules(self):
ctx = context.get_admin_context()
instance = fake_instance.fake_instance_obj(
ctx, name='test', memory_mb=0)
firewall = mock.Mock()
lxd_driver = driver.LXDDriver(None)
lxd_driver.firewall_driver = firewall
lxd_driver.refresh_instance_security_rules(instance)
firewall.refresh_instance_security_rules.assert_called_once_with(
instance)
def test_detach_volume(self):
profile = mock.Mock()
profile.devices = {
'eth0': {
'name': 'eth0',
'nictype': 'bridged',
'parent': 'lxdbr0',
'type': 'nic'
},
'root': {
'path': '/',
'type': 'disk'
},
1: {
'path': '/dev/sdc',
'type': 'unix-block'
},
}
expected = {
'eth0': {
'name': 'eth0',
'nictype': 'bridged',
'parent': 'lxdbr0',
'type': 'nic'
},
'root': {
'path': '/',
'type': 'disk'
},
}
self.client.profiles.get.return_value = profile
ctx = context.get_admin_context()
instance = fake_instance.fake_instance_obj(
ctx, name='test', memory_mb=0)
connection_info = fake_connection_info(
{'id': 1, 'name': 'volume-00000001'},
'10.0.2.15:3260', 'iqn.2010-10.org.openstack:volume-00000001',
auth=True)
mountpoint = mock.Mock()
lxd_driver = driver.LXDDriver(None)
lxd_driver.init_host(None)
lxd_driver.storage_driver.disconnect_volume = mock.MagicMock()
lxd_driver.detach_volume(connection_info, instance, mountpoint, None)
lxd_driver.client.profiles.get.assert_called_once_with(instance.name)
self.assertEqual(expected, profile.devices)
profile.save.assert_called_once_with()
def test_unfilter_instance(self):
ctx = context.get_admin_context()
instance = fake_instance.fake_instance_obj(
ctx, name='test', memory_mb=0)
firewall = mock.Mock()
network_info = object()
lxd_driver = driver.LXDDriver(None)
lxd_driver.firewall_driver = firewall
lxd_driver.unfilter_instance(instance, network_info)
firewall.unfilter_instance.assert_called_once_with(
instance, network_info)
def test_post_live_migration(self):
ctx = context.get_admin_context()
instance = fake_instance.fake_instance_obj(
ctx, name='test', memory_mb=0)
container = mock.Mock()
self.client.containers.get.return_value = container
lxd_driver = driver.LXDDriver(None)
lxd_driver.init_host(None)
lxd_driver.post_live_migration(context, instance, None)
container.delete.assert_called_once_with(wait=True)
def test_get_available_resource(self, execute, open, statvfs):
expected = {
'cpu_info': {
"features": "fake flag goes here",
"model": "Fake CPU",
"topology": {"sockets": "10", "threads": "4", "cores": "5"},
"arch": "x86_64", "vendor": "FakeVendor"
},
'hypervisor_hostname': 'fake_hostname',
'hypervisor_type': 'lxd',
'hypervisor_version': '011',
'local_gb': 1000,
'local_gb_used': 500,
'memory_mb': 10000,
'memory_mb_used': 8000,
'numa_topology': None,
'supported_instances': [
('i686', 'lxd', 'exe'),
('x86_64', 'lxd', 'exe'),
('i686', 'lxc', 'exe'),
('x86_64', 'lxc', 'exe')],
'vcpus': 200,
'vcpus_used': 0}
execute.return_value = (
'Model name: Fake CPU\n'
'Vendor ID: FakeVendor\n'
'Socket(s): 10\n'
'Core(s) per socket: 5\n'
'Thread(s) per core: 4\n\n',
None)
meminfo = mock.MagicMock()
meminfo.__enter__.return_value = six.moves.cStringIO(
'MemTotal: 10240000 kB\n'
'MemFree: 2000000 kB\n'
'Buffers: 24000 kB\n'
'Cached: 24000 kB\n')
open.side_effect = [
six.moves.cStringIO('flags: fake flag goes here\n'
'processor: 2\n'
'\n'),
meminfo,
]
lxd_driver = driver.LXDDriver(None)
value = lxd_driver.get_available_resource(None)
# This is funky, but json strings make for fragile tests.
value['cpu_info'] = json.loads(value['cpu_info'])
self.assertEqual(expected, value)
def test_resume(self):
container = mock.Mock()
self.client.containers.get.return_value = container
ctx = context.get_admin_context()
instance = fake_instance.fake_instance_obj(
ctx, name='test', memory_mb=0)
lxd_driver = driver.LXDDriver(None)
lxd_driver.init_host(None)
lxd_driver.resume(ctx, instance, None, None)
self.client.containers.get.assert_called_once_with(instance.name)
container.unfreeze.assert_called_once_with(wait=True)
def test_power_on(self):
container = mock.Mock()
container.status = 'Stopped'
self.client.containers.get.return_value = container
ctx = context.get_admin_context()
instance = fake_instance.fake_instance_obj(
ctx, name='test', memory_mb=0)
lxd_driver = driver.LXDDriver(None)
lxd_driver.init_host(None)
lxd_driver.power_on(ctx, instance, None)
self.client.containers.get.assert_called_once_with(instance.name)
container.start.assert_called_once_with(wait=True)
def test_finish_revert_migration(self):
ctx = context.get_admin_context()
instance = fake_instance.fake_instance_obj(
ctx, name='test', memory_mb=0)
network_info = []
container = mock.Mock()
self.client.containers.get.return_value = container
lxd_driver = driver.LXDDriver(None)
lxd_driver.init_host(None)
lxd_driver.finish_revert_migration(ctx, instance, network_info)
container.start.assert_called_once_with(wait=True)
def test_get_volume_connector(self):
expected = {
'host': 'fakehost',
'initiator': 'fake',
'ip': self.CONF.my_block_storage_ip
}
ctx = context.get_admin_context()
instance = fake_instance.fake_instance_obj(
ctx, name='test', memory_mb=0)
lxd_driver = driver.LXDDriver(None)
result = lxd_driver.get_volume_connector(instance)
self.assertEqual(expected, result)
def test_confirm_migration(self):
migration = mock.Mock()
instance = fake_instance.fake_instance_obj(
context.get_admin_context, name='test', memory_mb=0)
network_info = []
profile = mock.Mock()
container = mock.Mock()
self.client.profiles.get.return_value = profile
self.client.containers.get.return_value = container
lxd_driver = driver.LXDDriver(None)
lxd_driver.init_host(None)
lxd_driver.confirm_migration(migration, instance, network_info)
profile.delete.assert_called_once_with()
container.delete.assert_called_once_with(wait=True)
def test_destroy_without_instance(self):
def side_effect(*args, **kwargs):
raise lxdcore_exceptions.LXDAPIException(MockResponse(404))
self.client.containers.get.side_effect = side_effect
ctx = context.get_admin_context()
instance = fake_instance.fake_instance_obj(
ctx, name='test', memory_mb=0)
network_info = [_VIF]
lxd_driver = driver.LXDDriver(None)
lxd_driver.init_host(None)
lxd_driver.cleanup = mock.Mock() # There is a separate cleanup test
lxd_driver.destroy(ctx, instance, network_info)
lxd_driver.cleanup.assert_called_once_with(
ctx, instance, network_info, None)
def test_post_live_migration_at_source(self):
ctx = context.get_admin_context()
instance = fake_instance.fake_instance_obj(
ctx, name='test', memory_mb=0)
network_info = []
profile = mock.Mock()
self.client.profiles.get.return_value = profile
lxd_driver = driver.LXDDriver(None)
lxd_driver.cleanup = mock.Mock()
lxd_driver.init_host(None)
lxd_driver.post_live_migration_at_source(
ctx, instance, network_info)
profile.delete.assert_called_once_with()
lxd_driver.cleanup.assert_called_once_with(ctx, instance, network_info)
def test_check_can_live_migrate_destination(self):
ctx = context.get_admin_context()
instance = fake_instance.fake_instance_obj(
ctx, name='test', memory_mb=0)
src_compute_info = mock.Mock()
dst_compute_info = mock.Mock()
def container_get(*args, **kwargs):
raise lxdcore_exceptions.LXDAPIException(MockResponse(404))
self.client.containers.get.side_effect = container_get
lxd_driver = driver.LXDDriver(None)
lxd_driver.init_host(None)
retval = lxd_driver.check_can_live_migrate_destination(
ctx, instance, src_compute_info, dst_compute_info)
self.assertIsInstance(retval, driver.LXDLiveMigrateData)
def test_spawn_already_exists(self):
"""InstanceExists is raised if the container already exists."""
ctx = context.get_admin_context()
instance = fake_instance.fake_instance_obj(
ctx, name='test', memory_mb=0)
image_meta = mock.Mock()
injected_files = mock.Mock()
admin_password = mock.Mock()
lxd_driver = driver.LXDDriver(None)
lxd_driver.init_host(None)
self.assertRaises(
exception.InstanceExists,
lxd_driver.spawn,
ctx, instance, image_meta, injected_files, admin_password,
None, None)
def test_get_info(self):
container = mock.Mock()
container.state.return_value = MockContainerState(
'Running', {'usage': 4000, 'usage_peak': 4500}, 100)
self.client.containers.get.return_value = container
ctx = context.get_admin_context()
instance = fake_instance.fake_instance_obj(
ctx, name='test', memory_mb=0)
lxd_driver = driver.LXDDriver(None)
lxd_driver.init_host(None)
info = lxd_driver.get_info(instance)
self.assertEqual(power_state.RUNNING, info.state)
self.assertEqual(3, info.mem_kb)
self.assertEqual(4, info.max_mem_kb)
self.assertEqual(1, info.num_cpu)
self.assertEqual(0, info.cpu_time_ns)
def test_attach_interface(self):
expected = {
'hwaddr': '00:11:22:33:44:55',
'parent': 'qbr0123456789a',
'nictype': 'bridged',
'type': 'nic',
}
profile = mock.Mock()
profile.devices = {
'eth0': {
'name': 'eth0',
'nictype': 'bridged',
'parent': 'lxdbr0',
'type': 'nic'
},
'root': {
'path': '/',
'type': 'disk'
},
}
self.client.profiles.get.return_value = profile
ctx = context.get_admin_context()
instance = fake_instance.fake_instance_obj(
ctx, name='test', memory_mb=0)
image_meta = None
vif = {
'id': '0123456789abcdef',
'type': network_model.VIF_TYPE_OVS,
'address': '00:11:22:33:44:55',
'network': {
'bridge': 'fakebr'}}
lxd_driver = driver.LXDDriver(None)
lxd_driver.init_host(None)
lxd_driver.firewall_driver = mock.Mock()
lxd_driver.attach_interface(ctx, instance, image_meta, vif)
self.assertTrue('eth1' in profile.devices)
self.assertEqual(expected, profile.devices['eth1'])
profile.save.assert_called_once_with(wait=True)
def test_migrate_disk_and_power_off_different_host(self):
"""Migrating to a different host only shuts down the container."""
container = mock.Mock()
self.client.containers.get.return_value = container
ctx = context.get_admin_context()
instance = fake_instance.fake_instance_obj(
ctx, name='test', memory_mb=0)
dest = '0.0.0.1'
flavor = mock.Mock()
network_info = []
lxd_driver = driver.LXDDriver(None)
lxd_driver.init_host(None)
lxd_driver.migrate_disk_and_power_off(
ctx, instance, dest, flavor, network_info)
self.assertEqual(0, self.client.profiles.get.call_count)
container.stop.assert_called_once_with(wait=True)
