def test_on_delete_request_busy(self):
"""Test processing of a localdisk delete request.
"""
# Access to a protected member
# pylint: disable=W0212
svc = localdisk_service.LocalDiskResourceService(
block_dev='/dev/block',
vg_name='treadmill',
read_bps='100M',
write_bps='100M',
read_iops=1000,
write_iops=1000)
request_id = 'myproid.test-0-ID1234'
# trying to lvremote fails
treadmill.lvm.lvremove.side_effect = [
subproc.CalledProcessError(returncode=5, cmd='lvm'),
subproc.CalledProcessError(returncode=5, cmd='lvm'),
subproc.CalledProcessError(returncode=5, cmd='lvm'), 0
]
# XXX: Remove once AFSClient workaround is removed.
# XXX: self.assertRaises(
# XXX: subproc.CalledProcessError,
# XXX: svc.on_delete_request,
# XXX: request_id
# XXX: )
svc.on_delete_request(request_id)
treadmill.lvm.lvdisplay.assert_called_with('tm-ID1234',
group='treadmill')
treadmill.lvm.lvremove.assert_called_with('tm-ID1234',
group='treadmill')
def test_add_raw_rule_safe(self):
"""Test adding iptable rule (safe)."""
treadmill.subproc.check_call.return_value = 0
iptables.add_raw_rule('nat', 'OUTPUT', '-j FOO', safe=True)
treadmill.subproc.check_call.assert_called_once_with(
['iptables', '-t', 'nat', '-C', 'OUTPUT', '-j', 'FOO'])
# Rule does not exist.
treadmill.subproc.check_call.reset_mock()
treadmill.subproc.check_call.side_effect = [
subproc.CalledProcessError(1, ''),
0,
]
iptables.add_raw_rule('nat', 'OUTPUT', '-j FOO', safe=True)
treadmill.subproc.check_call.assert_has_calls([
mock.call(['iptables', '-t', 'nat', '-C', 'OUTPUT', '-j', 'FOO']),
mock.call(['iptables', '-t', 'nat', '-A', 'OUTPUT', '-j', 'FOO'])
])
# Unexpected iptables error while checking if the rule already exists.
treadmill.subproc.check_call.reset_mock()
treadmill.subproc.check_call.side_effect = \
subproc.CalledProcessError(3, '')
with self.assertRaises(subproc.CalledProcessError):
iptables.add_raw_rule('nat', 'OUTPUT', '-j FOO', safe=True)
def test_control_service_wait(self):
"""Tests controlling a service and wait"""
# Disable W0212(protected-access)
# pylint: disable=W0212
# shutdown supervised service
res = supervisor.control_service(
self.root, supervisor.ServiceControlAction.down,
wait=supervisor.ServiceWaitAction.down,
timeout=100,
)
treadmill.subproc.check_call.assert_called_with(
[supervisor._get_cmd('svc'), '-d', self.root]
)
treadmill.supervisor.wait_service.assert_called_with(
self.root,
treadmill.supervisor.ServiceWaitAction.down,
timeout=100
)
self.assertTrue(res)
# shutdown service timeouts
treadmill.subproc.check_call.reset_mock()
supervisor.wait_service.side_effect = \
subproc.CalledProcessError(99, supervisor._get_cmd('svwait'))
res = supervisor.control_service(
self.root, supervisor.ServiceControlAction.down,
wait=supervisor.ServiceWaitAction.down,
timeout=100,
)
treadmill.subproc.check_call.assert_called_with(
[supervisor._get_cmd('svc'), '-d', self.root]
)
treadmill.supervisor.wait_service.assert_called_with(
self.root,
treadmill.supervisor.ServiceWaitAction.down,
timeout=100
)
self.assertFalse(res)
# shutdown unsupervised service
treadmill.subproc.check_call.reset_mock()
treadmill.subproc.check_call.side_effect = \
subproc.CalledProcessError(100, supervisor._get_cmd('svc'))
with self.assertRaises(subproc.CalledProcessError):
supervisor.control_service(
self.root, supervisor.ServiceControlAction.down,
wait=supervisor.ServiceWaitAction.down,
timeout=100,
)
def test_flush_pt_conntrack_table(self):
"""Test flushing Passthrough conntrack rules.
"""
treadmill.subproc.check_call.return_value = 0
treadmill.iptables.flush_pt_conntrack_table('5.5.5.5')
treadmill.subproc.check_call.assert_has_calls([
mock.call([
'conntrack', '-D', '--protonum', 'udp', '--orig-src', '5.5.5.5'
]),
mock.call([
'conntrack', '-D', '--protonum', 'udp', '--orig-dst', '5.5.5.5'
]),
],
any_order=True)
treadmill.subproc.check_call.reset_mock()
treadmill.subproc.check_call.return_value = 1
treadmill.subproc.check_call.side_effect = \
subproc.CalledProcessError(returncode=1, cmd='failed conntrack')
treadmill.iptables.flush_pt_conntrack_table('4.4.4.4')
treadmill.subproc.check_call.assert_has_calls([
mock.call([
'conntrack', '-D', '--protonum', 'udp', '--orig-src', '4.4.4.4'
]),
mock.call([
'conntrack', '-D', '--protonum', 'udp', '--orig-dst', '4.4.4.4'
]),
],
any_order=True)
def test__bring_up(self, mock_policy, mock_down_action):
"""Test interface with supervisor bringing up services.
"""
# pylint: disable=protected-access
mon = monitor.Monitor(scan_dirs='/some/dir',
service_dirs=None,
policy_impl=mock_policy,
down_action=mock_down_action())
mock_pol_inst = mock_policy.return_value
treadmill.supervisor.wait_service.side_effect = [
subproc.CalledProcessError(supervisor.ERR_TIMEOUT, 's6-svwait'),
None,
]
mon._bring_up(mock_pol_inst.service)
supervisor.wait_service.assert_has_calls([
mock.call(mock_pol_inst.service.directory,
supervisor.ServiceWaitAction.up,
timeout=100),
mock.call(mock_pol_inst.service.directory,
supervisor.ServiceWaitAction.really_down,
timeout=60 * 1000),
])
treadmill.supervisor.control_service.assert_called_with(
mock_pol_inst.service.directory,
treadmill.supervisor.ServiceControlAction.up)
def test_wait_service(self):
"""Tests waiting on a service.
"""
# Disable W0212(protected-access)
# pylint: disable=W0212
supervisor.wait_service(self.root, supervisor.ServiceWaitAction.down)
treadmill.subproc.check_call.assert_called_with(
[supervisor._get_cmd('svwait'), '-d', self.root])
treadmill.subproc.check_call.reset_mock()
supervisor.wait_service(
(os.path.join(self.root, 'a'), os.path.join(self.root, 'b')),
supervisor.ServiceWaitAction.up,
all_services=False,
timeout=100,
)
treadmill.subproc.check_call.assert_called_with([
supervisor._get_cmd('svwait'), '-t100', '-o', '-u',
os.path.join(self.root, 'a'),
os.path.join(self.root, 'b')
])
treadmill.subproc.check_call.reset_mock()
treadmill.subproc.check_call.side_effect = \
subproc.CalledProcessError(99, supervisor._get_cmd('svwait'))
with self.assertRaises(subproc.CalledProcessError):
supervisor.wait_service(self.root,
supervisor.ServiceWaitAction.really_down)
treadmill.subproc.check_call.assert_called_with(
[supervisor._get_cmd('svwait'), '-D', self.root])
def test_initialize_img(self):
"""Test service initialization (image).
"""
# pylint: disable=W0212
img_location = '/image_dir'
img_size = 42
treadmill.lvm.vgactivate.side_effect = \
subproc.CalledProcessError(returncode=5, cmd='lvm')
mock_init_blkdev = treadmill.localdiskutils.init_block_dev
mock_init_blkdev.return_value = '/dev/test'
treadmill.lvm.lvsdisplay.return_value = []
localdiskutils.setup_image_lvm(
localdiskutils.TREADMILL_IMG,
img_location,
img_size
)
treadmill.lvm.vgactivate.assert_called_with(group='treadmill')
mock_init_blkdev.assert_called_with('treadmill.img', '/image_dir', 42)
treadmill.localdiskutils.init_vg.assert_called_with(
'treadmill',
'/dev/test',
)
def test_ensure_not_supervised_failed(self): # pylint: disable=C0103
"""Tests when a service fails to be brought down.
"""
treadmill.supervisor.is_supervised.return_value = True
treadmill.supervisor.control_service.side_effect = \
subproc.CalledProcessError(1, '')
with self.assertRaises(Exception):
supervisor.ensure_not_supervised(self.root)
def test_initialize(self, mock_vipmgr):
"""Test service initialization.
"""
# Access to a protected member _device_info of a client class
# pylint: disable=W0212
treadmill.services.network_service._device_info.side_effect = \
lambda dev: {'alias': 'reqid_%s' % dev}
treadmill.netdev.link_set_up.side_effect = [
subproc.CalledProcessError('any', 'how'),
None,
]
mock_vipmgr_inst = mock_vipmgr.return_value
mock_vipmgr_inst.list.return_value = []
svc = network_service.NetworkResourceService(
ext_device='eth42',
ext_speed=10000,
ext_mtu=9000,
)
svc.initialize(self.root)
mock_vipmgr.assert_called_with(
'192.168.0.0/16',
mock.ANY,
svc._service_rsrc_dir
)
mock_vipmgr_inst.garbage_collect.assert_not_called()
treadmill.iptables.create_set.assert_has_calls(
[
mock.call(treadmill.iptables.SET_PROD_CONTAINERS,
family='inet', set_type='hash:ip',
hashsize=1024, maxelem=65536),
mock.call(treadmill.iptables.SET_NONPROD_CONTAINERS,
family='inet', set_type='hash:ip',
hashsize=1024, maxelem=65536),
],
any_order=True
)
treadmill.netdev.link_set_up.assert_called_with('tm0')
svc._bridge_initialize.assert_called()
mock_vipmgr_inst.initialize.assert_not_called()
treadmill.netdev.bridge_setfd.assert_called_with('br0', 0)
treadmill.netdev.dev_mtu.assert_called_with('br0')
treadmill.netdev.dev_conf_route_localnet_set('tm0', True)
treadmill.netdev.bridge_brif('br0')
treadmill.services.network_service._device_info.assert_not_called()
mock_vipmgr_inst.free.assert_not_called()
self.assertEqual(
svc._devices,
{}
)
def test_is_supervised(self):
"""Tests that checking if a service directory is supervised.
"""
# Disable W0212(protected-access)
# pylint: disable=W0212
self.assertTrue(supervisor.is_supervised(self.root))
treadmill.subproc.check_call.assert_called_with(
[supervisor._get_cmd('svok'), self.root])
treadmill.subproc.check_call.side_effect = \
subproc.CalledProcessError(1, supervisor._get_cmd('svok'))
self.assertFalse(supervisor.is_supervised(self.root))
treadmill.subproc.check_call.assert_called_with(
[supervisor._get_cmd('svok'), self.root])
def test__init_block_dev(self):
"""Create a backing block device for LVM's Treadmill volume group.
"""
# pylint: disable=W0212
localdiskutils.loop_dev_for.side_effect = [
subproc.CalledProcessError(returncode=1, cmd='losetup'),
'/dev/test'
]
res = localdiskutils.init_block_dev('treadmill.img', '/bar', '2G')
self.assertTrue(localdiskutils.init_loopback_devices.called)
localdiskutils.create_image.assert_called_with(
localdiskutils.TREADMILL_IMG, '/bar', '2G')
self.assertEqual(res, '/dev/test')
def test__init_vg(self):
"""Test LVM volume group initialization.
"""
# pylint: disable=W0212
treadmill.lvm.vgactivate.side_effect = [
subproc.CalledProcessError(returncode=5, cmd='lvm'),
0,
]
localdiskutils.init_vg('test-group', '/dev/test')
treadmill.lvm.pvcreate.assert_called_with(device='/dev/test')
treadmill.lvm.vgcreate.assert_called_with('test-group',
device='/dev/test')
treadmill.lvm.vgactivate.assert_called_with('test-group')
def test_delete_dnat_rule_nonexist(self):
"""Test dnat rule deleting when the rule does not exist."""
treadmill.subproc.check_call.side_effect = \
subproc.CalledProcessError(returncode=1, output='', cmd='')
iptables.delete_dnat_rule(
firewall.DNATRule(proto='tcp',
dst_ip='1.1.1.1', dst_port=123,
new_ip='2.2.2.2', new_port=345),
'SOME_RULE',
)
treadmill.subproc.check_call.assert_called_with([
'iptables', '-t', 'nat', '-D', 'SOME_RULE',
'-s', '0.0.0.0/0', '-d', '1.1.1.1', '-p', 'tcp', '-m', 'tcp',
'--dport', '123',
'-j', 'DNAT', '--to-destination', '2.2.2.2:345'])
def test_control_service(self):
"""Tests controlling a service.
"""
# Disable W0212(protected-access)
# pylint: disable=W0212
self.assertTrue(supervisor.control_service(
self.root, supervisor.ServiceControlAction.down
))
treadmill.subproc.check_call.assert_called_with(
[supervisor._get_cmd('svc'), '-d', self.root]
)
self.assertTrue(supervisor.control_service(
self.root, (
supervisor.ServiceControlAction.up,
supervisor.ServiceControlAction.once_at_most,
),
timeout=100, # Should not be used
))
treadmill.subproc.check_call.assert_called_with(
[supervisor._get_cmd('svc'), '-uO', self.root]
)
self.assertTrue(supervisor.control_service(
self.root, supervisor.ServiceControlAction.up,
wait=supervisor.ServiceWaitAction.up,
timeout=100,
))
treadmill.subproc.check_call.assert_called_with(
[supervisor._get_cmd('svwait'), '-t100', '-u', self.root]
)
treadmill.subproc.check_call.side_effect = \
subproc.CalledProcessError(1, supervisor._get_cmd('svc'))
self.assertRaises(
subproc.CalledProcessError,
supervisor.control_service,
self.root,
supervisor.ServiceControlAction.down
)
treadmill.subproc.check_call.assert_called_with(
[supervisor._get_cmd('svc'), '-d', self.root]
)
def test_flush_pt_conntrack_table(self):
"""Test flushing Passthrough conntrack rules.
"""
treadmill.subproc.check_call.return_value = 0
treadmill.iptables.flush_pt_conntrack_table('5.5.5.5')
treadmill.subproc.check_call.assert_called_with(
['conntrack', '-D', '-s', '5.5.5.5'])
treadmill.subproc.check_call.reset_mock()
treadmill.subproc.check_call.return_value = 1
treadmill.subproc.check_call.side_effect = \
subproc.CalledProcessError(returncode=1, cmd='failed conntrack')
treadmill.iptables.flush_pt_conntrack_table('4.4.4.4')
treadmill.subproc.check_call.assert_called_with(
['conntrack', '-D', '-s', '4.4.4.4'])
def test_initialize_blk(self):
"""Test service initialization (block device).
"""
# pylint: disable=W0212
block_dev = '/dev/test'
treadmill.lvm.vgactivate.side_effect = \
subproc.CalledProcessError(returncode=5, cmd='lvm')
treadmill.lvm.lvsdisplay.return_value = []
localdiskutils.setup_device_lvm(block_dev)
treadmill.lvm.vgactivate.assert_called_with(group='treadmill')
# If provided, we should try to create the block device
self.assertFalse(treadmill.localdiskutils.init_block_dev.called)
treadmill.localdiskutils.init_vg.assert_called_with(
'treadmill',
'/dev/test',
)
def test_initialize(self):
"""Test iptables initialization"""
# Disable protected-access: Test access protected members .
# pylint: disable=protected-access
treadmill.iptables._iptables_restore.side_effect = [
None,
subproc.CalledProcessError(2, 'failed'),
None,
]
# NOTE(boysson): keep this IP in sync with the tests' states
iptables.initialize('1.2.3.4')
treadmill.iptables.ipset_restore.assert_called_with(self.ipset_state)
treadmill.iptables._iptables_restore.assert_has_calls([
mock.call(self.iptables_state),
mock.call(self.iptables_filter_state, noflush=True),
mock.call(self.iptables_filter_drop_state, noflush=True),
])
def test__bring_up_no_sup(self, mock_policy, mock_down_action):
"""Test interface with supervisor bringing up services.
Service not supervised.
"""
# pylint: disable=protected-access
mon = monitor.Monitor(scan_dirs='/some/dir',
service_dirs=None,
policy_impl=mock_policy,
down_action=mock_down_action())
mock_pol_inst = mock_policy.return_value
treadmill.supervisor.wait_service.side_effect = (
subproc.CalledProcessError(supervisor.ERR_NO_SUP, 's6-svwait'))
mon._bring_up(mock_pol_inst.service)
supervisor.wait_service.assert_called_with(
mock_pol_inst.service.directory,
supervisor.ServiceWaitAction.up,
timeout=100)
treadmill.supervisor.control_service.assert_not_called()
def test_on_delete_request_notexist(self):
"""Test processing of a localdisk delete request.
"""
# Access to a protected member
# pylint: disable=W0212
svc = localdisk_service.LocalDiskResourceService(
block_dev='/dev/block',
vg_name='treadmill',
read_bps='100M',
write_bps='100M',
read_iops=1000,
write_iops=1000)
request_id = 'myproid.test-0-ID1234'
# trying to find the LV fails
treadmill.lvm.lvdisplay.side_effect = (subproc.CalledProcessError(
returncode=5, cmd='lvm'), )
svc.on_delete_request(request_id)
treadmill.lvm.lvdisplay.assert_called_with('tm-ID1234',
group='treadmill')
treadmill.lvm.lvremove.assert_not_called()
treadmill.localdiskutils.refresh_vg_status.assert_not_called()
