def setUp(self): self.logger = FakeLogger() self.pipe_path = 'path/to/pipe' self.container_id = 'contid' self.dfactory = DaemonFactory(self.pipe_path, self.logger, self.container_id)
class TestDaemonFactory(unittest.TestCase): base_path = 'storlets.agent.daemon_factory.manager' kill_path = base_path + '.os.kill' waitpid_path = base_path + '.os.waitpid' sbus_path = base_path + '.SBus' def setUp(self): self.logger = FakeLogger() self.pipe_path = 'path/to/pipe' self.container_id = 'contid' self.dfactory = DaemonFactory(self.pipe_path, self.logger, self.container_id) def test_get_jvm_args(self): dummy_env = {'CLASSPATH': '/default/classpath', 'LD_LIBRARY_PATH': '/default/ld/library/path'} with mock.patch('storlets.agent.daemon_factory.manager.os.environ', dummy_env): pargs, env = self.dfactory.get_jvm_args( 'java', 'path/to/storlet/a', 'Storlet-1.0.jar', 1, 'path/to/uds/a', 'DEBUG') self.assertEqual( ['/usr/bin/java', 'org.openstack.storlet.daemon.SDaemon', 'Storlet-1.0.jar', 'path/to/uds/a', 'DEBUG', '1', self.container_id], pargs) self.assertEqual( {'CLASSPATH': '/default/classpath:' '/opt/storlets/logback-classic-1.1.2.jar:' '/opt/storlets/logback-core-1.1.2.jar:' '/opt/storlets/slf4j-api-1.7.7.jar:' '/opt/storlets/json_simple-1.1.jar:' '/opt/storlets/SBusJavaFacade.jar:' '/opt/storlets/SCommon.jar:' '/opt/storlets/SDaemon.jar:' '/opt/storlets/:' 'path/to/storlet/a', 'LD_LIBRARY_PATH': '/default/ld/library/path:' '/opt/storlets/'}, env) def test_get_python_args(self): dummy_env = {'PYTHONPATH': '/default/pythonpath'} with mock.patch('storlets.agent.daemon_factory.manager.os.environ', dummy_env): pargs, env = self.dfactory.get_python_args( 'python', 'path/to/storlet', 'test_storlet.TestStorlet', 1, 'path/to/uds', 'DEBUG') self.assertEqual( ['/usr/local/bin/storlets-daemon', 'test_storlet.TestStorlet', 'path/to/uds', 'DEBUG', '1', self.container_id], pargs) self.assertEqual( {'PYTHONPATH': '/default/pythonpath:' '/home/swift/test_storlet.TestStorlet'}, env) def test_spawn_subprocess(self): self.dfactory.storlet_name_to_pipe_name = \ {'storleta': 'path/to/uds/a'} class FakePopenObject(object): def __init__(self, pid): self.pid = pid self.stderr = mock.MagicMock() with mock.patch(self.base_path + '.subprocess.Popen') as popen, \ mock.patch(self.base_path + '.time.sleep'), \ mock.patch(self.waitpid_path) as waitpid, \ mock.patch(self.sbus_path + '.send') as send, \ mock.patch(self.base_path + '.os.read') as read: popen.side_effect = [FakePopenObject(1000), FakePopenObject(1001)] waitpid.return_value = 0, 0 send.return_value = 0 read.return_value = 'True: OK' self.dfactory.spawn_subprocess( ['arg0', 'argv1', 'argv2'], {'envk0': 'envv0'}, 'storleta') self.assertEqual((1000, 1), waitpid.call_args[0]) self.assertEqual({'storleta': 1000}, self.dfactory.storlet_name_to_pid) with mock.patch(self.base_path + '.subprocess.Popen') as popen, \ mock.patch(self.base_path + '.time.sleep'), \ mock.patch(self.waitpid_path) as waitpid, \ mock.patch(self.sbus_path + '.send') as send, \ mock.patch(self.base_path + '.os.read') as read: popen.side_effect = [FakePopenObject(1000), FakePopenObject(1001)] waitpid.return_value = 0, 0 send.return_value = 0 read.return_value = 'False: NG' with self.assertRaises(SDaemonError): self.dfactory.spawn_subprocess( ['arg0', 'argv1', 'argv2'], {'envk0': 'envv0'}, 'storleta') self.assertEqual((1000, 1), waitpid.call_args[0]) self.assertEqual({'storleta': 1000}, self.dfactory.storlet_name_to_pid) with mock.patch(self.base_path + '.subprocess.Popen') as popen, \ mock.patch(self.base_path + '.time.sleep'), \ mock.patch(self.waitpid_path) as waitpid: popen.side_effect = [FakePopenObject(1000), FakePopenObject(1001)] waitpid.return_value = 1000, -1 with self.assertRaises(SDaemonError): self.dfactory.spawn_subprocess( ['arg0', 'argv1', 'argv2'], {'envk0': 'envv0'}, 'storleta') self.assertEqual((1000, 1), waitpid.call_args[0]) with mock.patch(self.base_path + '.subprocess.Popen') as popen: popen.side_effect = OSError() with self.assertRaises(SDaemonError): self.dfactory.spawn_subprocess( ['arg0', 'argv1', 'argv2'], {'envk0': 'envv0'}, 'storleta') def test_wait_for_daemon_to_initialize(self): self.dfactory.storlet_name_to_pipe_name = \ {'storleta': 'path/to/uds/a'} with mock.patch(self.sbus_path + '.send') as send, \ mock.patch(self.base_path + '.time.sleep'), \ mock.patch(self.base_path + '.os.read') as read: send.side_effect = [-1, 0] read.return_value = 'True: OK' self.assertTrue( self.dfactory.wait_for_daemon_to_initialize('storleta')) self.assertEqual(2, send.call_count) self.assertEqual(1, read.call_count) with mock.patch(self.sbus_path + '.send') as send, \ mock.patch(self.base_path + '.time.sleep'), \ mock.patch(self.base_path + '.os.read') as read: send.return_value = 0 read.return_value = 'False: NG' self.assertFalse( self.dfactory.wait_for_daemon_to_initialize('storleta')) self.assertEqual( self.dfactory.NUM_OF_TRIES_PINGING_STARTING_DAEMON, send.call_count) self.assertEqual( self.dfactory.NUM_OF_TRIES_PINGING_STARTING_DAEMON, read.call_count) self.dfactory.storlet_name_to_pipe_name = \ {'storleta': 'path/to/uds/a', 'storletb': 'path/to/uds/b'} with mock.patch(self.sbus_path + '.send') as send, \ mock.patch(self.base_path + '.time.sleep'): send.return_value = -1 self.assertFalse( self.dfactory.wait_for_daemon_to_initialize('storleta')) self.assertEqual( self.dfactory.NUM_OF_TRIES_PINGING_STARTING_DAEMON, send.call_count) def test_process_start_daemon(self): # Not running self.dfactory.storlet_name_to_pid = {} self.dfactory.storlet_name_to_pipe_name = {} class FakePopenObject(object): def __init__(self, pid): self.pid = pid self.stderr = mock.MagicMock() with mock.patch(self.base_path + '.subprocess.Popen') as popen, \ mock.patch(self.base_path + '.time.sleep'), \ mock.patch(self.waitpid_path) as waitpid, \ mock.patch(self.sbus_path + '.send') as send, \ mock.patch(self.base_path + '.os.read') as read: popen.side_effect = [FakePopenObject(1000), FakePopenObject(1001)] waitpid.return_value = 0, 0 send.return_value = 0 read.return_value = 'True: OK' self.assertTrue(self.dfactory.process_start_daemon( 'java', 'path/to/storlet/a', 'storleta', 1, 'path/to/uds/a', 'TRACE')) self.assertEqual({'storleta': 'path/to/uds/a'}, self.dfactory.storlet_name_to_pipe_name) # Already running self.dfactory.storlet_name_to_pid = {'storleta': 1000} self.dfactory.storlet_name_to_pipe_name = {'storleta': 'path/to/uds/a'} with mock.patch(self.waitpid_path) as waitpid: waitpid.return_value = 0, 0 self.assertFalse(self.dfactory.process_start_daemon( 'java', 'path/to/storlet/a', 'storleta', 1, 'path/to/uds/a', 'TRACE')) # Unsupported language with self.assertRaises(SDaemonError): self.dfactory.process_start_daemon( 'foo', 'path/to/storlet/a', 'storleta', 1, 'path/to/uds/a', 'TRACE') def test_get_process_status_by_name(self): self.dfactory.storlet_name_to_pid = \ {'storleta': 1000, 'storletb': 1001} with mock.patch(self.waitpid_path) as waitpid: waitpid.return_value = 0, 0 self.assertTrue( self.dfactory.get_process_status_by_name('storleta')) self.assertEqual(1, waitpid.call_count) self.assertEqual((1000, 1), waitpid.call_args[0]) self.assertFalse( self.dfactory.get_process_status_by_name('storletc')) def test_get_process_status_by_pid(self): with mock.patch(self.waitpid_path) as waitpid: waitpid.return_value = 0, 0 self.assertTrue( self.dfactory.get_process_status_by_pid(1000, 'storleta')) self.assertEqual(1, waitpid.call_count) self.assertEqual((1000, 1), waitpid.call_args[0]) with mock.patch(self.waitpid_path) as waitpid: waitpid.return_value = 1000, 0 self.assertFalse( self.dfactory.get_process_status_by_pid(1000, 'storleta')) self.assertEqual(1, waitpid.call_count) self.assertEqual((1000, 1), waitpid.call_args[0]) with mock.patch(self.waitpid_path) as waitpid: waitpid.side_effect = OSError(errno.ESRCH, '') self.assertFalse( self.dfactory.get_process_status_by_pid(1000, 'storleta')) self.assertEqual(1, waitpid.call_count) self.assertEqual((1000, 1), waitpid.call_args[0]) with mock.patch(self.waitpid_path) as waitpid: waitpid.side_effect = OSError(errno.EPERM, '') exc_pattern = '^No permission to access the storlet daemon' + \ ' for storleta$' with self.assertRaisesRegexp(SDaemonError, exc_pattern): self.dfactory.get_process_status_by_pid(1000, 'storleta') self.assertEqual(1, waitpid.call_count) self.assertEqual((1000, 1), waitpid.call_args[0]) with mock.patch(self.waitpid_path) as waitpid: waitpid.side_effect = OSError() exc_pattern = '^Unknown error$' with self.assertRaisesRegexp(SDaemonError, exc_pattern): self.dfactory.get_process_status_by_pid(1000, 'storleta') self.assertEqual(1, waitpid.call_count) self.assertEqual((1000, 1), waitpid.call_args[0]) def test_process_kill(self): # Success self.dfactory.storlet_name_to_pid = \ {'storleta': 1000, 'storletb': 1001} with mock.patch(self.kill_path) as kill, \ mock.patch(self.waitpid_path) as waitpid: waitpid.return_value = 1000, 0 self.assertEqual((1000, 0), self.dfactory.process_kill('storleta')) self.assertEqual(1, kill.call_count) self.assertEqual(1, waitpid.call_count) self.assertEqual({'storletb': 1001}, self.dfactory.storlet_name_to_pid) # When failed to send kill to the storlet daemon self.dfactory.storlet_name_to_pid = \ {'storleta': 1000, 'storletb': 1001} with mock.patch(self.kill_path) as kill, \ mock.patch(self.waitpid_path) as waitpid: kill.side_effect = OSError() with self.assertRaises(SDaemonError): self.dfactory.process_kill('storleta') self.assertEqual(1, kill.call_count) self.assertEqual(0, waitpid.call_count) self.assertEqual({'storleta': 1000, 'storletb': 1001}, self.dfactory.storlet_name_to_pid) # When failed to wait self.dfactory.storlet_name_to_pid = \ {'storleta': 1000, 'storletb': 1001} with mock.patch(self.kill_path) as kill, \ mock.patch(self.waitpid_path) as waitpid: waitpid.side_effect = OSError() with self.assertRaises(SDaemonError): self.dfactory.process_kill('storleta') self.assertEqual(1, kill.call_count) self.assertEqual(1, waitpid.call_count) self.assertEqual({'storleta': 1000, 'storletb': 1001}, self.dfactory.storlet_name_to_pid) # if the storlet daemon is not recognised self.dfactory.storlet_name_to_pid = \ {'storleta': 1000, 'storletb': 1001} with mock.patch(self.kill_path) as kill, \ mock.patch(self.waitpid_path) as waitpid: with self.assertRaises(SDaemonError): self.dfactory.process_kill('storletc') self.assertEqual(0, kill.call_count) self.assertEqual(0, waitpid.call_count) self.assertEqual({'storleta': 1000, 'storletb': 1001}, self.dfactory.storlet_name_to_pid) def test_process_kill_all(self): # Success self.dfactory.storlet_name_to_pid = \ {'storleta': 1000, 'storletb': 1001} with mock.patch(self.kill_path) as kill, \ mock.patch(self.waitpid_path) as waitpid: waitpid.side_effect = [(1000, 0), (1001, 0)] self.dfactory.process_kill_all() self.assertEqual(2, kill.call_count) self.assertEqual(2, waitpid.call_count) self.assertEqual({}, self.dfactory.storlet_name_to_pid) # Success (no processes) self.dfactory.storlet_name_to_pid = {} with mock.patch(self.kill_path) as kill, \ mock.patch(self.waitpid_path) as waitpid: self.dfactory.process_kill_all() self.assertEqual(0, kill.call_count) self.assertEqual(0, waitpid.call_count) self.assertEqual({}, self.dfactory.storlet_name_to_pid) # Failure (try_all = True) self.dfactory.storlet_name_to_pid = \ {'storleta': 1000, 'storletb': 1001} with mock.patch(self.kill_path) as kill, \ mock.patch(self.waitpid_path) as waitpid: kill.side_effect = OSError() exc_pattern = '^Failed to stop some storlet daemons: .*' with self.assertRaisesRegexp(SDaemonError, exc_pattern) as e: self.dfactory.process_kill_all() self.assertIn('storleta', str(e.exception)) self.assertIn('storletb', str(e.exception)) self.assertEqual(2, kill.call_count) self.assertEqual(0, waitpid.call_count) self.assertEqual({'storleta': 1000, 'storletb': 1001}, self.dfactory.storlet_name_to_pid) # Failure (try_all = False) self.dfactory.storlet_name_to_pid = \ {'storleta': 1000, 'storletb': 1001} with mock.patch(self.kill_path) as kill, \ mock.patch(self.waitpid_path) as waitpid: kill.side_effect = OSError() exc_pattern = '^Failed to send kill signal to storlet[a-b]$' with self.assertRaisesRegexp(SDaemonError, exc_pattern): self.dfactory.process_kill_all(False) self.assertEqual(1, kill.call_count) self.assertEqual(0, waitpid.call_count) self.assertEqual({'storleta': 1000, 'storletb': 1001}, self.dfactory.storlet_name_to_pid) def test_shutdown_all_processes(self): # Success self.dfactory.storlet_name_to_pid = \ {'storleta': 1000, 'storletb': 1001} self.dfactory.storlet_name_to_pipe_name = \ {'storleta': 'path/to/uds/a', 'storletb': 'path/to/uds/b'} with mock.patch(self.sbus_path + '.send') as send, \ mock.patch(self.base_path + '.os.read') as read, \ mock.patch(self.waitpid_path): send.return_value = 0 read.return_value = 'True: OK' terminated = self.dfactory.shutdown_all_processes() self.assertEqual(2, len(terminated)) self.assertIn('storleta', terminated) self.assertIn('storletb', terminated) self.assertEqual({}, self.dfactory.storlet_name_to_pid) # Failure (try_all = True) self.dfactory.storlet_name_to_pid = \ {'storleta': 1000, 'storletb': 1001} self.dfactory.storlet_name_to_pipe_name = \ {'storleta': 'patha', 'storletb': 'pathb'} with mock.patch(self.sbus_path + '.send') as send, \ mock.patch(self.base_path + '.os.read') as read, \ mock.patch(self.waitpid_path) as waitpid: send.return_value = -1 read.return_value = 'True: OK' exc_pattern = '^Failed to shutdown some storlet daemons: .*' with self.assertRaisesRegexp(SDaemonError, exc_pattern) as e: self.dfactory.shutdown_all_processes() self.assertIn('storleta', str(e.exception)) self.assertIn('storletb', str(e.exception)) self.assertEqual(2, send.call_count) self.assertEqual(0, waitpid.call_count) self.assertEqual({'storleta': 1000, 'storletb': 1001}, self.dfactory.storlet_name_to_pid) # Failure (try_all = False) self.dfactory.storlet_name_to_pid = \ {'storleta': 1000, 'storletb': 1001} self.dfactory.storlet_name_to_pipe_name = \ {'storleta': 'patha', 'storletb': 'pathb'} with mock.patch(self.sbus_path + '.send') as send, \ mock.patch(self.base_path + '.os.read') as read, \ mock.patch(self.waitpid_path) as waitpid: send.return_value = -1 read.return_value = 'True: OK' exc_pattern = '^Failed to send halt to storlet[a-b]$' with self.assertRaisesRegexp(SDaemonError, exc_pattern): self.dfactory.shutdown_all_processes(False) self.assertEqual(1, send.call_count) self.assertEqual(0, waitpid.call_count) self.assertEqual({'storleta': 1000, 'storletb': 1001}, self.dfactory.storlet_name_to_pid) def test_shutdown_process(self): # Success self.dfactory.storlet_name_to_pid = \ {'storleta': 1000, 'storletb': 1001} self.dfactory.storlet_name_to_pipe_name = \ {'storleta': 'path/to/uds/a', 'storletb': 'path/to/uds/b'} with mock.patch(self.sbus_path + '.send') as send, \ mock.patch(self.base_path + '.os.read') as read, \ mock.patch(self.waitpid_path): send.return_value = 0 read.return_value = 'True: OK' self.dfactory.shutdown_process('storleta') self.assertEqual({'storletb': 1001}, self.dfactory.storlet_name_to_pid) # Failed to send a command to the storlet daemon self.dfactory.storlet_name_to_pid = \ {'storleta': 1000, 'storletb': 1001} self.dfactory.storlet_name_to_pipe_name = \ {'storleta': 'path/to/uds/a', 'storletb': 'path/to/uds/b'} with mock.patch(self.sbus_path + '.send') as send, \ mock.patch(self.base_path + '.os.read') as read, \ mock.patch(self.waitpid_path) as waitpid: send.return_value = -1 read.return_value = 'True: OK' with self.assertRaises(SDaemonError): self.dfactory.shutdown_process('storleta') self.assertEqual(0, waitpid.call_count) self.assertEqual({'storleta': 1000, 'storletb': 1001}, self.dfactory.storlet_name_to_pid) # Failed to wait self.dfactory.storlet_name_to_pid = \ {'storleta': 1000, 'storletb': 1001} self.dfactory.storlet_name_to_pipe_name = \ {'storleta': 'path/to/uds/a', 'storletb': 'path/to/uds/b'} with mock.patch(self.sbus_path + '.send') as send, \ mock.patch(self.base_path + '.os.read') as read, \ mock.patch(self.waitpid_path) as waitpid: send.return_value = 0 read.return_value = 'True: OK' waitpid.side_effect = OSError() with self.assertRaises(SDaemonError): self.dfactory.shutdown_process('storleta') self.assertEqual({'storleta': 1000, 'storletb': 1001}, self.dfactory.storlet_name_to_pid) # If the storlet is not found in pid mapping self.dfactory.storlet_name_to_pid = \ {'storleta': 1000, 'storletb': 1001} self.dfactory.storlet_name_to_pipe_name = \ {'storleta': 'path/to/uds/a', 'storletb': 'path/to/uds/b'} with self.assertRaises(SDaemonError): self.dfactory.shutdown_process('storletc') def test_start_daemon(self): prms = {'daemon_language': 'java', 'storlet_path': 'path/to/storlet/a', 'storlet_name': 'storleta', 'pool_size': 1, 'uds_path': 'path/to/uds/a', 'log_level': 'TRACE'} # Not running self.dfactory.storlet_name_to_pid = {} self.dfactory.storlet_name_to_pipe_name = {} class FakePopenObject(object): def __init__(self, pid): self.pid = pid self.stderr = mock.MagicMock() with mock.patch(self.base_path + '.subprocess.Popen') as popen, \ mock.patch(self.base_path + '.time.sleep'), \ mock.patch(self.waitpid_path) as waitpid, \ mock.patch(self.sbus_path + '.send') as send, \ mock.patch(self.base_path + '.os.read') as read: popen.side_effect = [FakePopenObject(1000), FakePopenObject(1001)] waitpid.return_value = 0, 0 send.return_value = 0 read.return_value = 'True: OK' ret = self.dfactory.start_daemon(prms) self.assertTrue(ret.status) self.assertEqual('OK', ret.message) self.assertTrue(ret.iterable) # Already running self.dfactory.storlet_name_to_pid = {'storleta': 1000} self.dfactory.storlet_name_to_pipe_name = {'storleta': 'path/to/uds/a'} with mock.patch(self.waitpid_path) as waitpid: waitpid.return_value = 0, 0 ret = self.dfactory.start_daemon(prms) self.assertTrue(ret.status) self.assertEqual('storleta is already running', ret.message) self.assertTrue(ret.iterable) # Unsupported language prms['daemon_language'] = 'foo' ret = self.dfactory.start_daemon(prms) self.assertFalse(ret.status) self.assertEqual('Got unsupported daemon language: foo', ret.message) self.assertTrue(ret.iterable) def test_stop_daemon(self): # Success self.dfactory.storlet_name_to_pid = \ {'storleta': 1000} with mock.patch(self.kill_path), \ mock.patch(self.waitpid_path) as waitpid: waitpid.return_value = 1000, 0 resp = self.dfactory.stop_daemon({'storlet_name': 'storleta'}) self.assertTrue(resp.status) self.assertEqual('Storlet storleta, PID = 1000, ErrCode = 0', resp.message) self.assertTrue(resp.iterable) # Failure self.dfactory.storlet_name_to_pid = \ {'storleta': 1000} with mock.patch(self.kill_path) as kill, \ mock.patch(self.waitpid_path): kill.side_effect = OSError('ERROR') resp = self.dfactory.stop_daemon({'storlet_name': 'storleta'}) self.assertFalse(resp.status) self.assertEqual('Failed to kill the storlet daemon storleta', resp.message) self.assertTrue(resp.iterable) def test_daemon_status(self): self.dfactory.storlet_name_to_pid = \ {'storleta': 1000, 'storletb': 1001} with mock.patch(self.waitpid_path) as waitpid: waitpid.return_value = 0, 0 resp = self.dfactory.daemon_status({'storlet_name': 'storleta'}) self.assertTrue(resp.status) self.assertEqual('Storlet storleta seems to be OK', resp.message) self.assertTrue(resp.iterable) with mock.patch(self.waitpid_path) as waitpid: waitpid.return_value = 1000, 0 resp = self.dfactory.daemon_status({'storlet_name': 'storleta'}) self.assertFalse(resp.status) self.assertEqual('No running storlet daemon for storleta', resp.message) self.assertTrue(resp.iterable) with mock.patch(self.waitpid_path) as waitpid: waitpid.side_effect = OSError() resp = self.dfactory.daemon_status({'storlet_name': 'storleta'}) self.assertFalse(resp.status) self.assertEqual('Unknown error', resp.message) self.assertTrue(resp.iterable) def test_halt(self): self.dfactory.storlet_name_to_pid = \ {'storleta': 1000, 'storletb': 1001} self.dfactory.storlet_name_to_pipe_name = \ {'storleta': 'path/to/uds/a', 'storletb': 'path/to/uds/b'} with mock.patch(self.sbus_path + '.send') as send, \ mock.patch(self.base_path + '.os.read') as read, \ mock.patch(self.waitpid_path): send.return_value = 0 read.return_value = 'True: OK' resp = self.dfactory.halt({}) self.assertTrue(resp.status) self.assertIn('storleta: terminated', resp.message) self.assertIn('storletb: terminated', resp.message) self.assertFalse(resp.iterable) def test_stop_daemons(self): # Success self.dfactory.storlet_name_to_pid = \ {'storleta': 1000, 'storletb': 1001} with mock.patch(self.kill_path), \ mock.patch(self.waitpid_path) as waitpid: waitpid.side_effect = [(1000, 0), (1001, 0)] resp = self.dfactory.stop_daemons({}) self.assertTrue(resp.status) self.assertEqual('OK', resp.message) self.assertFalse(resp.iterable) def test_get_handler(self): # start daemon self.assertEqual( self.dfactory.start_daemon, self.dfactory.get_handler( sbus_cmd.SBUS_CMD_START_DAEMON)) # stop daemon self.assertEqual( self.dfactory.stop_daemon, self.dfactory.get_handler( sbus_cmd.SBUS_CMD_STOP_DAEMON)) # daemon status self.assertEqual( self.dfactory.daemon_status, self.dfactory.get_handler( sbus_cmd.SBUS_CMD_DAEMON_STATUS)) # stop daemons self.assertEqual( self.dfactory.stop_daemons, self.dfactory.get_handler( sbus_cmd.SBUS_CMD_STOP_DAEMONS)) # halt self.assertEqual( self.dfactory.halt, self.dfactory.get_handler( sbus_cmd.SBUS_CMD_HALT)) # ping self.assertEqual( self.dfactory.ping, self.dfactory.get_handler( sbus_cmd.SBUS_CMD_PING)) # invalid with self.assertRaises(ValueError): self.dfactory.get_handler('FOO') # unknown with self.assertRaises(ValueError): self.dfactory.get_handler('SBUS_CMD_UNKNOWN') # not command handler with self.assertRaises(ValueError): self.dfactory.get_handler('SBUS_CMD_GET_JVM_ARGS')