def test_addProgramToGroup_raises_bad_name_when_process_already_exists(self):
pconfig = DummyPConfig(None, 'process_that_exists', '/bin/foo')
gconfig = DummyPGroupConfig(None, pconfigs=[pconfig])
pgroup = DummyProcessGroup(gconfig)
supervisord = DummySupervisor(process_groups = {'group_name': pgroup})
supervisord.options = supervisor.options.ServerOptions()
interface = self.makeOne(supervisord)
poptions = {'command': '/usr/bin/find /'}
self.assertRPCError(SupervisorFaults.BAD_NAME,
interface.addProgramToGroup,
'group_name', 'process_that_exists', poptions)
def test_addProgramToGroup_raises_incorrect_params_when_poptions_is_not_dict(self):
pconfig = DummyPConfig(None, 'foo', '/bin/foo')
gconfig = DummyPGroupConfig(None, pconfigs=[pconfig])
pgroup = DummyProcessGroup(gconfig)
supervisord = DummySupervisor(process_groups = {'group_name': pgroup})
supervisord.options = supervisor.options.ServerOptions()
interface = self.makeOne(supervisord)
bad_poptions = 42
self.assertRPCError(SupervisorFaults.INCORRECT_PARAMETERS,
interface.addProgramToGroup,
'group_name', 'new_process', bad_poptions)
def test_addProgramToGroup_raises_incorrect_params_when_poptions_is_not_dict(
self):
pconfig = DummyPConfig(None, 'foo', '/bin/foo')
gconfig = DummyPGroupConfig(None, pconfigs=[pconfig])
pgroup = DummyProcessGroup(gconfig)
supervisord = DummySupervisor(process_groups={'group_name': pgroup})
supervisord.options = supervisor.options.ServerOptions()
interface = self.makeOne(supervisord)
bad_poptions = 42
self.assertRPCError(SupervisorFaults.INCORRECT_PARAMETERS,
interface.addProgramToGroup, 'group_name',
'new_process', bad_poptions)
def test_addProgramToGroup_raises_bad_name_when_process_already_exists(
self):
pconfig = DummyPConfig(None, 'process_that_exists', '/bin/foo')
gconfig = DummyPGroupConfig(None, pconfigs=[pconfig])
pgroup = DummyProcessGroup(gconfig)
supervisord = DummySupervisor(process_groups={'group_name': pgroup})
supervisord.options = supervisor.options.ServerOptions()
interface = self.makeOne(supervisord)
poptions = {'command': '/usr/bin/find /'}
self.assertRPCError(SupervisorFaults.BAD_NAME,
interface.addProgramToGroup, 'group_name',
'process_that_exists', poptions)
def test_fetch(self):
supervisord = DummySupervisor()
interface = self.makeOne(supervisord)
interface.cache = {'the-key': 'its-value'}
self.assertEqual('its-value', interface.fetch('the-key'))
self.assertEqual(interface.update_text, 'fetch')
def test_fetch_raises_bad_name_when_key_does_not_exist(self):
supervisord = DummySupervisor()
interface = self.makeOne(supervisord)
interface.cache = {}
self.assertRPCError(Faults.BAD_NAME,
interface.fetch, 'nonexistant-key')
def test_getKeys_returns_list_of_keys_for_items_in_cache(self):
supervisord = DummySupervisor()
interface = self.makeOne(supervisord)
interface.cache = {'foo': None, 'bar': None}
self.assertEqual(interface.getKeys(), ['bar','foo'])
self.assertEqual(interface.update_text, 'getKeys')
def test_store(self):
supervisord = DummySupervisor()
interface = self.makeOne(supervisord)
interface.store('the-key', 'its-value')
self.assertEqual(interface.cache['the-key'], 'its-value')
self.assertEqual(interface.update_text, 'store')
def test_continue_request_nosuchmethod(self):
supervisor = DummySupervisor()
subinterfaces = [('supervisor', DummySupervisorRPCNamespace())]
handler = self._makeOne(supervisor, subinterfaces)
import xmlrpc.client
data = xmlrpc.client.dumps(('a', 'b'), 'supervisor.noSuchMethod')
request = DummyRequest('/what/ever', None, None, None)
handler.continue_request(data, request)
logdata = supervisor.options.logger.data
from supervisor.xmlrpc_lib import loads
if loads:
expected = 2
else:
expected = 3
self.assertEqual(len(logdata), expected)
self.assertEqual(logdata[-2],
'XML-RPC method called: supervisor.noSuchMethod()')
self.assertEqual(
logdata[-1],
('XML-RPC method supervisor.noSuchMethod() returned fault: '
'[1] UNKNOWN_METHOD'))
self.assertEqual(len(request.producers), 1)
xml_response = request.producers[0]
self.assertRaises(xmlrpc.client.Fault, xmlrpc.client.loads,
xml_response)
def test_log_raises_incorrect_parameters_when_level_is_bad(self):
supervisord = DummySupervisor()
interface = self.makeOne(supervisord)
for bad_level in ['bad_level', 9999, None]:
self.assertRPCError(SupervisorFaults.INCORRECT_PARAMETERS,
interface.log, 'hello', bad_level)
def test_removeProcessFromGroup_can_be_disabled(self):
supervisord = DummySupervisor()
interface = self.makeOne(supervisord, whitelist='foo,bar')
self.assertRPCError(TwiddlerFaults.NOT_IN_WHITELIST,
interface.removeProcessFromGroup, 'group',
'process')
def test_continue_request_methodsuccess(self):
supervisor = DummySupervisor()
subinterfaces = [('supervisor', DummySupervisorRPCNamespace())]
handler = self._makeOne(supervisor, subinterfaces)
import xmlrpclib
data = xmlrpclib.dumps((), 'supervisor.getAPIVersion')
request = DummyRequest('/what/ever', None, None, None)
handler.continue_request(data, request)
logdata = supervisor.options.logger.data
from supervisor.xmlrpc import loads
if loads:
expected = 2
else:
expected = 3
self.assertEqual(len(logdata), expected)
self.assertEqual(logdata[-2],
u'XML-RPC method called: supervisor.getAPIVersion()')
self.assertEqual(logdata[-1],
u'XML-RPC method supervisor.getAPIVersion() returned successfully')
self.assertEqual(len(request.producers), 1)
xml_response = request.producers[0]
response = xmlrpclib.loads(xml_response)
self.assertEqual(response[0][0], '3.0')
self.assertEqual(request._done, True)
self.assertEqual(request.headers['Content-Type'], 'text/xml')
self.assertEqual(request.headers['Content-Length'], len(xml_response))
def test_store_raises_incorrect_parameters_when_data_is_not_string(self):
supervisord = DummySupervisor()
interface = self.makeOne(supervisord)
not_a_string = 42
self.assertRPCError(Faults.INCORRECT_PARAMETERS, interface.store,
'key', not_a_string)
def test_ctor(self):
supervisor = DummySupervisor()
subinterfaces = [('supervisor', DummySupervisorRPCNamespace())]
handler = self._makeOne(supervisor, subinterfaces)
self.assertEqual(handler.supervisord, supervisor)
from supervisor.xmlrpc import RootRPCInterface
self.assertEqual(handler.rpcinterface.__class__, RootRPCInterface)
def test_updater_raises_shutdown_error_if_supervisord_in_shutdown_state(
self):
supervisord = DummySupervisor(state=SupervisorStates.SHUTDOWN)
interface = self.makeOne(supervisord)
self.assertRPCError(SupervisorFaults.SHUTDOWN_STATE,
interface.getAPIVersion)
def test_handle_request_stdout_logfile_missing(self):
supervisor = DummySupervisor()
supervisor.options.logfile = '/not/there'
request = DummyRequest('/mainlogtail', None, None, None)
handler = self._makeOne(supervisor)
handler.handle_request(request)
self.assertEqual(request._error, 410)
def test_getGroupNames_returns_empty_array_when_no_groups(self):
supervisord = DummySupervisor()
interface = self.makeOne(supervisord)
names = interface.getGroupNames()
self.assertTrue(isinstance(names, list))
self.assertEqual(0, len(names))
def test_store_raises_bad_name_when_key_is_not_a_string(self):
supervisord = DummySupervisor()
interface = self.makeOne(supervisord)
not_a_string = 42
self.assertRPCError(Faults.BAD_NAME,
interface.store, not_a_string, 'data')
def test_fetch_none(self):
supervisord = DummySupervisor()
interface = self.makeOne(supervisord)
interface.cache = {'the-key': None}
self.assertEqual(None, interface.fetch('the-key'))
self.assertEqual(interface.update_text, 'fetch')
def test_continue_request_no_params_in_request(self):
supervisor = DummySupervisor()
subinterfaces = [('supervisor', DummySupervisorRPCNamespace())]
handler = self._makeOne(supervisor, subinterfaces)
data = '<?xml version="1.0" encoding="UTF-8"?>' \
'<methodCall>' \
'<methodName>supervisor.getAPIVersion</methodName>' \
'</methodCall>'
request = DummyRequest('/what/ever', None, None, None)
handler.continue_request(data, request)
logdata = supervisor.options.logger.data
from supervisor.xmlrpc import loads
if loads:
expected = 2
else:
expected = 3
self.assertEqual(len(logdata), expected)
self.assertEqual(logdata[-2],
u'XML-RPC method called: supervisor.getAPIVersion()')
self.assertEqual(logdata[-1],
u'XML-RPC method supervisor.getAPIVersion() returned successfully')
self.assertEqual(len(request.producers), 1)
xml_response = request.producers[0]
import xmlrpclib
response = xmlrpclib.loads(xml_response)
from supervisor.rpcinterface import API_VERSION
self.assertEqual(response[0][0], API_VERSION)
self.assertEqual(request._done, True)
self.assertEqual(request.headers['Content-Type'], 'text/xml')
self.assertEqual(request.headers['Content-Length'], len(xml_response))
def test_continue_request_500_if_xmlrpc_dumps_raises(self):
supervisor = DummySupervisor()
subinterfaces = [('supervisor', DummySupervisorRPCNamespace())]
handler = self._makeOne(supervisor, subinterfaces)
import xmlrpclib
data = xmlrpclib.dumps((), 'supervisor.getXmlRpcUnmarshallable')
request = DummyRequest('/what/ever', None, None, None)
handler.continue_request(data, request)
logdata = supervisor.options.logger.data
from supervisor.xmlrpc import loads
if loads:
expected = 3
else:
expected = 4
self.assertEqual(len(logdata), expected)
self.assertEqual(logdata[-3],
'XML-RPC method called: supervisor.getXmlRpcUnmarshallable()')
self.assertEqual(logdata[-2],
'XML-RPC method supervisor.getXmlRpcUnmarshallable() '
'returned successfully')
self.assertTrue("unexpected exception" in logdata[-1])
self.assertTrue(repr(data) in logdata[-1])
self.assertTrue("Traceback" in logdata[-1])
self.assertTrue("TypeError: cannot marshal" in logdata[-1])
self.assertEqual(request._error, 500)
def test_addGroup_adds_new_group(self):
supervisord = DummySupervisor()
interface = self.makeOne(supervisord)
self.assertTrue(interface.addGroup("group", 999))
self.assertEqual(1, len(interface.supervisord.process_groups))
self.assertTrue("group" in interface.supervisord.process_groups)
def test_match(self):
class DummyRequest:
def __init__(self, uri):
self.uri = uri
supervisor = DummySupervisor()
handler = self._makeOne(supervisor)
self.assertEqual(handler.match(DummyRequest(handler.path)), True)
def test_make_callback_noaction(self):
context = DummyContext()
context.supervisord = DummySupervisor()
context.template = 'ui/status.html'
context.form = {}
view = self._makeOne(context)
self.assertRaises(ValueError, view.make_callback, 'process', None)
def test_getKeys_returns_empty_list_when_no_items_cache(self):
supervisord = DummySupervisor()
interface = self.makeOne(supervisord)
interface.cache = {}
self.assertEqual(interface.getKeys(), [])
self.assertEqual(interface.update_text, 'getKeys')
def test_delete_removes_data_from_cache_by_key(self):
supervisord = DummySupervisor()
interface = self.makeOne(supervisord)
interface.cache = {'delete-me': 'foo', 'keep-me': 'bar'}
self.assertTrue(interface.delete('delete-me'))
self.assertEqual(None, interface.cache.get('delete-me'))
self.assertEqual({'keep-me': 'bar'}, interface.cache)
def test_store_allows_nonstring_values(self):
supervisord = DummySupervisor()
interface = self.makeOne(supervisord)
not_a_string = [1, 2, 3]
interface.store('the-key', not_a_string)
self.assertEqual(interface.cache['the-key'], not_a_string)
self.assertEqual(interface.update_text, 'store')
def test_clear(self):
supervisord = DummySupervisor()
interface = self.makeOne(supervisord)
interface.cache = {'foo': 'bar'}
interface.clear()
self.assertEqual({}, interface.cache)
self.assertEqual(interface.update_text, 'clear')
def test_addProgramToGroup_adds_new_process_config_to_group(self):
pconfig = DummyPConfig(None, 'foo', '/bin/foo')
gconfig = DummyPGroupConfig(None, pconfigs=[pconfig])
pgroup = DummyProcessGroup(gconfig)
pgroup.processes = {}
supervisord = DummySupervisor(process_groups = {'group_name': pgroup})
supervisord.options = supervisor.options.ServerOptions()
interface = self.makeOne(supervisord)
poptions = {'command': '/usr/bin/find /'}
self.assertTrue(interface.addProgramToGroup('group_name', 'new_process', poptions))
self.assertEqual('addProgramToGroup', interface.update_text)
config = pgroup.config.process_configs[1]
self.assertEqual('new_process', config.name)
self.assertTrue(isinstance(config, supervisor.options.ProcessConfig))
def test_handle_request_stdout_logfile_missing(self):
supervisor = DummySupervisor()
options = DummyOptions()
pconfig = DummyPConfig(options, 'foo', 'foo', 'it/is/missing')
supervisord = PopulatedDummySupervisor(options, 'foo', pconfig)
handler = self._makeOne(supervisord)
request = DummyRequest('/logtail/foo', None, None, None)
handler.handle_request(request)
self.assertEqual(request._error, 410)
def test_addProgramToGroup_adds_all_processes_resulting_from_program_options(self):
gconfig = DummyPGroupConfig(None, pconfigs=[])
pgroup = DummyProcessGroup(gconfig)
pgroup.processes = {}
supervisord = DummySupervisor(process_groups = {'group_name': pgroup})
supervisord.options = supervisor.options.ServerOptions()
interface = self.makeOne(supervisord)
poptions = {'command': '/usr/bin/find /',
'process_name': 'find_%(process_num)d',
'numprocs': 3}
self.assertTrue(interface.addProgramToGroup('group_name', 'new_process', poptions))
self.assertEqual('addProgramToGroup', interface.update_text)
self.assertEqual(3, len(pgroup.config.process_configs))
self.assertEqual(3, len(pgroup.processes))
def test_make_cache_rpcinterface_factory(self):
from supervisor_cache import rpcinterface
supervisord = DummySupervisor()
interface = rpcinterface.make_cache_rpcinterface(supervisord)
self.assertTrue(isinstance(interface,
rpcinterface.CacheNamespaceRPCInterface))
self.assertEqual(supervisord, interface.supervisord)
def test_match(self):
class DummyRequest2:
def __init__(self, uri):
self.uri = uri
supervisor = DummySupervisor()
subinterfaces = [('supervisor', DummySupervisorRPCNamespace())]
handler = self._makeOne(supervisor, subinterfaces)
self.assertEqual(handler.match(DummyRequest2('/RPC2')), True)
self.assertEqual(handler.match(DummyRequest2('/nope')), False)
def test_getAPIVersion_returns_api_version(self):
supervisord = DummySupervisor()
interface = self.makeOne(supervisord)
version = interface.getAPIVersion()
self.assertEqual('getAPIVersion', interface.update_text)
from supervisor_cache.rpcinterface import API_VERSION
self.assertEqual(version, API_VERSION)
def test_addProgramToGroup_uses_process_name_from_options(self):
gconfig = DummyPGroupConfig(None, pconfigs=[])
pgroup = DummyProcessGroup(gconfig)
pgroup.processes = {}
supervisord = DummySupervisor(process_groups = {'group_name': pgroup})
supervisord.options = supervisor.options.ServerOptions()
interface = self.makeOne(supervisord)
poptions = {'process_name': 'renamed', 'command': '/usr/bin/find /'}
self.assertTrue(interface.addProgramToGroup('group_name', 'new_process', poptions))
self.assertEqual('addProgramToGroup', interface.update_text)
config = pgroup.config.process_configs[0]
self.assertEqual('renamed', config.name)
self.assertTrue(pgroup.processes.get('new_process') is None)
self.assertTrue(isinstance(pgroup.processes.get('renamed'),
supervisor.process.Subprocess))
