def test_unplug(self, tag, vif_data, exists):
instance = stubs.MockInstance()
vif = copy.deepcopy(self.vif_data)
self.mgr.net.device_exists.side_effect = exists
self.assertEqual(None, self.vif_driver.unplug(instance, vif))
calls = [mock.call.net.device_exists('qbr0123456789a')]
if exists[0]:
calls[1:1] = [
mock.call.ex('brctl',
'delif',
'qbr0123456789a',
'qvb0123456789a',
run_as_root=True),
mock.call.ex('ip',
'link',
'set',
'qbr0123456789a',
'down',
run_as_root=True),
mock.call.ex('brctl',
'delbr',
'qbr0123456789a',
run_as_root=True),
mock.call.net.delete_ovs_vif_port('fakebr', 'qvo0123456789a')
]
self.assertEqual(calls, self.mgr.method_calls)
def test_start_instance(self, mu, tag='', rescue=False, running=False,
is_neutron=True, timeout=10, network_info=[],
vifs=(), plug_side_effect=None):
instance = stubs.MockInstance()
container_config = mock.Mock()
need_vif_plugged = True
self.ml.container_running.return_value = running
self.ml.container_start.return_value = (
200, {'operation': '/1.0/operations/0123456789'})
container_ops.CONF.vif_plugging_timeout = timeout
mu.is_neutron.return_value = is_neutron
self.mv.plug.side_effect = plug_side_effect
with mock.patch.object(self.container_ops.virtapi,
'wait_for_instance_event') as mw:
self.assertEqual(
None,
self.container_ops.start_container(container_config,
instance,
network_info,
need_vif_plugged))
mw.assert_called_once_with(
instance,
[('network-vif-plugged', vif) for vif in vifs],
deadline=timeout,
error_callback=self.container_ops._neutron_failed_callback)
self.assertEqual(
[mock.call(instance, viface) for viface in network_info],
self.mv.plug.call_args_list)
calls = [
mock.call.container_start('fake-uuid', 5),
mock.call.wait_container_operation('0123456789', 200, -1)
]
self.assertEqual(calls, self.ml.method_calls[-2:])
def test_rescue_defined(self):
instance = stubs.MockInstance()
self.ml.container_defined.return_value = True
self.assertRaises(
exception.InstanceExists,
self.container_ops.spawn,
{}, instance, {}, [], 'secret', rescue=True)
self.ml.container_defined.called_once_with('fake-instance')
def test_detach_interface(self, tag, side_effect):
instance = stubs.MockInstance()
vif = mock.Mock()
with mock.patch.object(self.connection.container_ops,
'vif_driver') as mv:
mv.unplug.side_effect = [side_effect]
self.assertEqual(None,
self.connection.detach_interface(instance, vif))
mv.unplug.assert_called_once_with(instance, vif)
def test_detach_interface_fail(self):
instance = stubs.MockInstance()
vif = mock.Mock()
with mock.patch.object(self.connection.container_ops,
'vif_driver') as mv:
mv.unplug.side_effect = [TypeError]
self.assertRaises(TypeError, self.connection.detach_interface,
instance, vif)
def test_configure_container_configdrive_wrong_format(self):
instance = stubs.MockInstance()
with mock.patch.object(container_config.CONF,
'config_drive_format',
new='fake-format'):
self.assertRaises(
exception.InstancePowerOnFailure,
self.container_config.configure_container_configdrive, {},
instance, {})
def test_plug(self, tag, vif_data, exists):
instance = stubs.MockInstance()
vif_data = copy.deepcopy(self.vif_data)
vif_data.update(vif_data)
self.mgr.net.device_exists.side_effect = exists
self.assertEqual(None, self.vif_driver.plug(instance, vif_data))
calls = [
mock.call.net.device_exists('qbr0123456789a'),
mock.call.net.device_exists('qvo0123456789a')
]
if not exists[0]:
calls[1:1] = [
mock.call.ex('brctl',
'addbr',
'qbr0123456789a',
run_as_root=True),
mock.call.ex('brctl',
'setfd',
'qbr0123456789a',
0,
run_as_root=True),
mock.call.ex('brctl',
'stp',
'qbr0123456789a',
'off',
run_as_root=True),
mock.call.ex('tee', '/sys/class/net/qbr0123456789a/'
'bridge/multicast_snooping',
process_input='0',
run_as_root=True,
check_exit_code=[0, 1]),
]
if not exists[1]:
calls.extend([
mock.call.net._create_veth_pair('qvb0123456789a',
'qvo0123456789a'),
mock.call.ex('ip',
'link',
'set',
'qbr0123456789a',
'up',
run_as_root=True),
mock.call.ex('brctl',
'addif',
'qbr0123456789a',
'qvb0123456789a',
run_as_root=True)
])
calls.append(
mock.call.net.create_ovs_vif_port('fakebr', 'qvo0123456789a',
'0123456789abcdef',
'00:11:22:33:44:55',
'fake-uuid'))
self.assertEqual(calls, self.mgr.method_calls)
def test_attach_interface(self,
mo,
tag,
net='',
config={},
info={'init': 1},
firewall_setup=None,
update=None,
expected_if='',
success=True):
instance = stubs.MockInstance()
vif = {
'type': 'ovs',
'id': '0123456789abcdef',
'address': '00:11:22:33:44:55',
}
self.ml.get_container_config.side_effect = [config]
self.ml.container_info.side_effect = [info]
self.ml.container_update.side_effect = [update]
mo.return_value = six.moves.cStringIO(net)
with mock.patch.object(self.connection.container_ops,
'vif_driver') as mv, (
mock.patch.object((self.connection.container_ops
.firewall_driver), 'firewall_driver')) \
as mf:
manager = mock.Mock()
manager.attach_mock(mv, 'vif_driver')
manager.attach_mock(mf, 'firewall')
mf.setup_basic_filtering.side_effect = [firewall_setup]
self.assertEqual(
None, self.connection.attach_interface(instance, {}, vif))
calls = [
mock.call.vif_driver.plug(instance, vif),
mock.call.firewall.setup_basic_filtering(instance, vif)
]
if not success:
calls.append(mock.call.vif_driver.unplug(instance, vif))
self.assertEqual(calls, manager.method_calls)
if success or update is not None:
self.ml.container_update.assert_called_once_with(
'fake-uuid', {
'profiles': ['nclxd-profile'],
'devices': {
'qbr0123456789a': {
'nictype': 'bridged',
'hwaddr': '00:11:22:33:44:55',
'name': 'eth1',
'parent': 'qbr0123456789a',
'type': 'nic'
}
},
'name': 'fake-uuid',
'config': {}
})
def test_configure_container_config(self, tag, flavor, expected):
instance = stubs.MockInstance(**flavor)
config = {
'raw.lxc':
'lxc.console.logfile=/fake/lxd/root/containers/'
'fake-uuid/console.log\n'
}
config.update(expected)
self.assertEqual({'config': config},
self.container_config.configure_container_config(
{}, instance))
def test_container_unrescue(self):
instance = stubs.MockInstance()
network_info = mock.Mock()
with contextlib.nested(
mock.patch.object(container_utils.LXDContainerUtils,
'container_move'),
mock.patch.object(container_utils.LXDContainerUtils,
'container_destroy')) as (container_move,
container_destroy):
self.connection.unrescue(instance, network_info)
self.assertTrue(container_move)
self.assertTrue(container_destroy)
def test_configure_container_rescuedisk(self):
instance = stubs.MockInstance()
self.assertEqual(
{
'devices': {
'rescue': {
'path': 'mnt',
'source': '/fake/lxd/root/containers/'
'fake-uuid-backup/rootfs',
'type': 'disk'
}
}
},
self.container_config.configure_container_rescuedisk({}, instance))
def test_configure_container_configdrive_fail_dir(self, md, mi):
instance = stubs.MockInstance()
injected_files = mock.Mock()
self.assertRaises(
AttributeError,
self.container_config.configure_container_configdrive, None,
instance, injected_files)
md.assert_called_once_with(instance_md=mi.return_value)
(md.return_value.__enter__.return_value.make_drive.
assert_called_once_with('/fake/instances/path/fake-uuid/config-drive')
)
mi.assert_called_once_with(instance,
content=injected_files,
extra_md={})
def test_spawn_new(self, tag, side_effect, mc):
context = mock.Mock()
instance = stubs.MockInstance()
image_meta = mock.Mock()
injected_files = mock.Mock()
network_info = mock.Mock()
block_device_info = mock.Mock()
self.ml.container_defined.side_effect = [side_effect]
with contextlib.nested(
mock.patch.object(self.connection.container_ops,
'create_container'), ) as (create_container):
self.connection.spawn(context, instance, image_meta,
injected_files, None, network_info,
block_device_info)
self.assertTrue(create_container)
def test_get_console_output(self, me, mo):
instance = stubs.MockInstance()
mo.return_value.__enter__.return_value = six.BytesIO(b'fake contents')
self.assertEqual(b'fake contents',
self.connection.get_console_output({}, instance))
calls = [
mock.call('chown',
'1234:1234',
'/fake/lxd/root/containers/fake-uuid/console.log',
run_as_root=True),
mock.call('chmod',
'755',
'/fake/lxd/root/containers/fake-uuid',
run_as_root=True)
]
self.assertEqual(calls, me.call_args_list)
def test_configure_container_configdrive(self, md, mi):
instance = stubs.MockInstance()
injected_files = mock.Mock()
self.assertEqual(
{
'devices': {
'configdrive': {
'path': 'mnt',
'type': 'disk',
'source': '/fake/instances/path/'
'fake-uuid/config-drive'
}
}
},
self.container_config.configure_container_configdrive(
{}, instance, injected_files))
md.assert_called_once_with(instance_md=mi.return_value)
(md.return_value.__enter__.return_value.make_drive.
assert_called_once_with('/fake/instances/path/fake-uuid/config-drive')
)
mi.assert_called_once_with(instance,
content=injected_files,
extra_md={})
def test_rescue(self):
context = mock.Mock()
instance = stubs.MockInstance()
image_meta = mock.Mock()
network_info = mock.Mock()
self.ml.container_defined.return_value = True
with contextlib.nested(
mock.patch.object(container_utils.LXDContainerUtils,
'container_stop'),
mock.patch.object(self.connection.container_ops,
'_container_local_copy'),
mock.patch.object(container_utils.LXDContainerUtils,
'container_destroy'),
mock.patch.object(self.connection.container_ops,
'spawn')) as (container_stop,
container_local_copy,
container_destroy, spawn):
self.connection.rescue(context, instance, network_info, image_meta,
'secret')
self.assertTrue(container_stop)
self.assertTrue(container_local_copy)
self.assertTrue(container_destroy)
self.assertTrue(spawn)
def test_snapshot_fail(self, tag, export_effect, update_effect, mi):
instance = stubs.MockInstance()
mi.get.return_value = {'name': 'mock_snapshot'}
self.ml.container_snapshot_create.return_value = (200, {
'operation':
'/1.0/operations/0123456789'
})
self.ml.container_stop.return_value = (200, {
'operation':
'/1.0/operations/1234567890'
})
self.ml.container_start.return_value = (200, {
'operation':
'/1.0/operations/2345678901'
})
self.ml.container_publish.return_value = (200, {
'metadata': {
'fingerprint': 'abcdef0123456789'
}
})
self.ml.image_export.side_effect = export_effect
mi.update.side_effect = update_effect
self.assertRaises(exception.NovaException, self.connection.snapshot,
{}, instance, '', mock.Mock())
def test_instance_exists(self, expected, name):
self.assertEqual(
expected,
self.connection.instance_exists(stubs.MockInstance(name=name)))
def test_cleanup(self, mr):
instance = stubs.MockInstance()
self.assertEqual(
None,
self.connection.cleanup({}, instance, [], [], None, None, None))
mr.assert_called_once_with('/fake/instances/path/fake-uuid')
def test_snapshot(self, mi):
context = mock.Mock()
instance = stubs.MockInstance()
image_id = 'mock_image'
mi.get.return_value = {'name': 'mock_snapshot'}
self.ml.container_snapshot_create.return_value = (200, {
'operation':
'/1.0/operations/0123456789'
})
self.ml.container_stop.return_value = (200, {
'operation':
'/1.0/operations/1234567890'
})
self.ml.container_start.return_value = (200, {
'operation':
'/1.0/operations/2345678901'
})
self.ml.container_publish.return_value = (200, {
'metadata': {
'fingerprint': 'abcdef0123456789'
}
})
manager = mock.Mock()
manager.attach_mock(mi, 'image')
manager.attach_mock(self.ml, 'lxd')
self.assertEqual(
None,
self.connection.snapshot(context, instance, image_id,
manager.update))
calls = [
mock.call.update(task_state='image_pending_upload'),
mock.call.image.get(context, 'mock_image'),
mock.call.lxd.container_snapshot_create('fake-uuid', {
'name': 'mock_snapshot',
'stateful': False
}),
mock.call.lxd.wait_container_operation('0123456789', 200, -1),
mock.call.lxd.container_stop('fake-uuid', 5),
mock.call.lxd.wait_container_operation('1234567890', 200, -1),
mock.call.lxd.container_publish({
'source': {
'name': 'fake-uuid/'
'mock_'
'snapshot',
'type': 'snapshot'
}
}),
mock.call.lxd.alias_create({
'name': 'mock_snapshot',
'target': 'abcdef0123456789'
}),
mock.call.lxd.image_export('abcdef0123456789'),
mock.call.image.update(
context, 'mock_image', {
'name': 'mock_snapshot',
'container_format': 'bare',
'disk_format': 'raw'
}, self.ml.image_export.return_value),
mock.call.update(expected_state='image_pending_upload',
task_state='image_uploading'),
mock.call.lxd.container_start('fake-uuid', 5)
]
self.assertEqual(calls, manager.method_calls)
def test_nonetype(self):
instance = stubs.MockInstance()
vif_data = {'type': None}
self.assertRaises(exception.NovaException, self.vif_driver.plug,
instance, vif_data)
def test_unplug_fail(self):
instance = stubs.MockInstance()
vif_data = copy.deepcopy(self.vif_data)
self.mgr.net.device_exists.side_effect = (
processutils.ProcessExecutionError)
self.assertEqual(None, self.vif_driver.unplug(instance, vif_data))
def test_spawn_defined(self, tag, side_effect, expected):
instance = stubs.MockInstance()
self.ml.container_defined.side_effect = side_effect
self.assertRaises(expected, self.connection.spawn, {}, instance, {},
[], 'secret')
self.ml.container_defined.called_once_with('mock_instance')