def test_add_default_job(self):
""" Test the addition of a new job using the strategy configured. """
from supvisors.strategy import RunningFailureHandler
handler = RunningFailureHandler(self.supvisors)
# create a dummy process
process = Mock()
process.rules = Mock(running_failure_strategy=2)
# add a series of jobs
with patch.object(handler, 'add_job') as mocked_add:
handler.add_default_job(process)
self.assertEqual([call(2, process)], mocked_add.call_args_list)
def test_add_default_job(self):
""" Test the addition of a new job using the strategy configured. """
from supvisors.strategy import RunningFailureHandler
handler = RunningFailureHandler(self.supvisors)
# create a dummy process
process = Mock()
process.rules = Mock(running_failure_strategy=2)
# add a series of jobs
with patch.object(handler, 'add_job') as mocked_add:
handler.add_default_job(process)
self.assertEqual([call(2, process)], mocked_add.call_args_list)
def test_trigger_jobs(self):
""" Test the processing of jobs. """
from supvisors.strategy import RunningFailureHandler
handler = RunningFailureHandler(self.supvisors)
# create mocked applications
def mocked_application(appli_name, stopped):
application = Mock(aplication_name=appli_name,
**{'stopped.side_effect': [stopped, True]})
self.supvisors.context.applications[appli_name] = application
return application
stop_appli_A = mocked_application('stop_application_A', False)
stop_appli_B = mocked_application('stop_application_B', False)
restart_appli_A = mocked_application('restart_application_A', False)
restart_appli_B = mocked_application('restart_application_B', False)
start_appli_A = mocked_application('start_application_A', True)
start_appli_B = mocked_application('start_application_B', True)
# create mocked processes
def mocked_process(namespec, stopped):
return Mock(**{'namespec.return_value': namespec,
'stopped.side_effect': [stopped, True]})
restart_process_1 = mocked_process('restart_process_1', False)
restart_process_2 = mocked_process('restart_process_2', False)
start_process_1 = mocked_process('start_process_1', True)
start_process_2 = mocked_process('start_process_2', True)
continue_process = mocked_process('continue_process', False)
# pre-fill sets
handler.stop_application_jobs = {'stop_application_A', 'stop_application_B'}
handler.restart_application_jobs = {'restart_application_A', 'restart_application_B'}
handler.restart_process_jobs = {restart_process_1, restart_process_2}
handler.continue_process_jobs = {continue_process}
handler.start_application_jobs = {start_appli_A, start_appli_B}
handler.start_process_jobs = {start_process_1, start_process_2}
# get patches to starter and stopper
mocked_stop_app = self.supvisors.stopper.stop_application
mocked_start_app = self.supvisors.starter.default_start_application
mocked_stop_proc = self.supvisors.stopper.stop_process
mocked_start_proc = self.supvisors.starter.default_start_process
# test jobs trigger
handler.trigger_jobs()
# check called patches
self.assertItemsEqual([call(stop_appli_A), call(stop_appli_B),
call(restart_appli_A), call(restart_appli_B)],
mocked_stop_app.call_args_list)
self.assertItemsEqual([call(start_appli_A), call(start_appli_B)],
mocked_start_app.call_args_list)
self.assertItemsEqual([call(restart_process_1), call(restart_process_2)],
mocked_stop_proc.call_args_list)
self.assertItemsEqual([call(start_process_1), call(start_process_2)],
mocked_start_proc.call_args_list)
# check impact on sets
self.assertEqual(set(), handler.stop_application_jobs)
self.assertEqual(set(), handler.restart_application_jobs)
self.assertEqual(set(), handler.restart_process_jobs)
self.assertEqual(set(), handler.continue_process_jobs)
self.assertEqual({restart_appli_A, restart_appli_B},
handler.start_application_jobs)
self.assertEqual({restart_process_1, restart_process_2},
handler.start_process_jobs)
def test_clear_jobs(self):
""" Test the clearance of internal structures. """
from supvisors.strategy import RunningFailureHandler
handler = RunningFailureHandler(self.supvisors)
# add data to sets
self.stop_application_jobs = {1, 2}
self.restart_application_jobs = {'a', 'b'}
self.restart_process_jobs = {1, 0, 'bcd'}
self.continue_process_jobs = {'aka', 2}
self.start_application_jobs = {1, None}
self.start_process_jobs = {0}
# clear all
handler.clear_jobs()
# test empty structures
self.assertEqual(set(), handler.stop_application_jobs)
self.assertEqual(set(), handler.restart_application_jobs)
self.assertEqual(set(), handler.restart_process_jobs)
self.assertEqual(set(), handler.continue_process_jobs)
self.assertEqual(set(), handler.start_application_jobs)
self.assertEqual(set(), handler.start_process_jobs)
def test_create(self):
""" Test the values set at construction. """
from supvisors.strategy import RunningFailureHandler
handler = RunningFailureHandler(self.supvisors)
# test empty structures
self.assertEqual(set(), handler.stop_application_jobs)
self.assertEqual(set(), handler.restart_application_jobs)
self.assertEqual(set(), handler.restart_process_jobs)
self.assertEqual(set(), handler.continue_process_jobs)
self.assertEqual(set(), handler.start_application_jobs)
self.assertEqual(set(), handler.start_process_jobs)
def test_clear_jobs(self):
""" Test the clearance of internal structures. """
from supvisors.strategy import RunningFailureHandler
handler = RunningFailureHandler(self.supvisors)
# add data to sets
self.stop_application_jobs = {1, 2}
self.restart_application_jobs = {'a', 'b'}
self.restart_process_jobs = {1, 0, 'bcd'}
self.continue_process_jobs = {'aka', 2}
self.start_application_jobs = {1, None}
self.start_process_jobs = {0}
# clear all
handler.clear_jobs()
# test empty structures
self.assertEqual(set(), handler.stop_application_jobs)
self.assertEqual(set(), handler.restart_application_jobs)
self.assertEqual(set(), handler.restart_process_jobs)
self.assertEqual(set(), handler.continue_process_jobs)
self.assertEqual(set(), handler.start_application_jobs)
self.assertEqual(set(), handler.start_process_jobs)
def __init__(self, supervisord):
""" Initialization of the attributes. """
# store this instance in supervisord to ensure persistence
supervisord.supvisors = self
# get options from config file
server_options = SupvisorsServerOptions()
server_options.realize()
self.options = server_options.supvisors_options
# create logger
stdout = supervisord.options.nodaemon
self.logger = getLogger(self.options.logfile, self.options.loglevel,
Supvisors.LOGGER_FORMAT, True,
self.options.logfile_maxbytes,
self.options.logfile_backups, stdout)
# configure supervisor info source
self.info_source = SupervisordSource(supervisord)
# set addresses and check local address
self.address_mapper = AddressMapper(self.logger)
self.address_mapper.addresses = self.options.address_list
if not self.address_mapper.local_address:
raise RPCError(
Faults.SUPVISORS_CONF_ERROR,
'local host unexpected in address list: {}'.format(
self.options.address_list))
# create context data
self.context = Context(self)
# create application starter and stopper
self.starter = Starter(self)
self.stopper = Stopper(self)
# create statistics handler
self.statistician = StatisticsCompiler(self)
# create the failure handler of crashing processes
self.failure_handler = RunningFailureHandler(self)
# create state machine
self.fsm = FiniteStateMachine(self)
# check parsing
try:
self.parser = Parser(self)
except:
self.logger.warn('cannot parse rules file: {}'.format(
self.options.rules_file))
self.parser = None
# create event subscriber
self.listener = SupervisorListener(self)
def test_trigger_jobs(self):
""" Test the processing of jobs. """
from supvisors.strategy import RunningFailureHandler
handler = RunningFailureHandler(self.supvisors)
# create mocked applications
def mocked_application(appli_name, stopped):
application = Mock(aplication_name=appli_name,
**{'stopped.side_effect': [stopped, True]})
self.supvisors.context.applications[appli_name] = application
return application
stop_appli_A = mocked_application('stop_application_A', False)
stop_appli_B = mocked_application('stop_application_B', False)
restart_appli_A = mocked_application('restart_application_A', False)
restart_appli_B = mocked_application('restart_application_B', False)
start_appli_A = mocked_application('start_application_A', True)
start_appli_B = mocked_application('start_application_B', True)
# create mocked processes
def mocked_process(namespec, stopped):
return Mock(
**{
'namespec.return_value': namespec,
'stopped.side_effect': [stopped, True]
})
restart_process_1 = mocked_process('restart_process_1', False)
restart_process_2 = mocked_process('restart_process_2', False)
start_process_1 = mocked_process('start_process_1', True)
start_process_2 = mocked_process('start_process_2', True)
continue_process = mocked_process('continue_process', False)
# pre-fill sets
handler.stop_application_jobs = {
'stop_application_A', 'stop_application_B'
}
handler.restart_application_jobs = {
'restart_application_A', 'restart_application_B'
}
handler.restart_process_jobs = {restart_process_1, restart_process_2}
handler.continue_process_jobs = {continue_process}
handler.start_application_jobs = {start_appli_A, start_appli_B}
handler.start_process_jobs = {start_process_1, start_process_2}
# get patches to starter and stopper
mocked_stop_app = self.supvisors.stopper.stop_application
mocked_start_app = self.supvisors.starter.default_start_application
mocked_stop_proc = self.supvisors.stopper.stop_process
mocked_start_proc = self.supvisors.starter.default_start_process
# test jobs trigger
handler.trigger_jobs()
# check called patches
self.assertItemsEqual([
call(stop_appli_A),
call(stop_appli_B),
call(restart_appli_A),
call(restart_appli_B)
], mocked_stop_app.call_args_list)
self.assertItemsEqual(
[call(start_appli_A), call(start_appli_B)],
mocked_start_app.call_args_list)
self.assertItemsEqual(
[call(restart_process_1),
call(restart_process_2)], mocked_stop_proc.call_args_list)
self.assertItemsEqual([call(start_process_1),
call(start_process_2)],
mocked_start_proc.call_args_list)
# check impact on sets
self.assertEqual(set(), handler.stop_application_jobs)
self.assertEqual(set(), handler.restart_application_jobs)
self.assertEqual(set(), handler.restart_process_jobs)
self.assertEqual(set(), handler.continue_process_jobs)
self.assertEqual({restart_appli_A, restart_appli_B},
handler.start_application_jobs)
self.assertEqual({restart_process_1, restart_process_2},
handler.start_process_jobs)
def test_add_job(self):
""" Test the addition of a new job using a strategy. """
from supvisors.strategy import RunningFailureHandler
from supvisors.ttypes import RunningFailureStrategies
handler = RunningFailureHandler(self.supvisors)
# create a dummy process
process_1 = Mock(application_name='dummy_application_A')
process_2 = Mock(application_name='dummy_application_A')
process_3 = Mock(application_name='dummy_application_B')
# define compare function
def compare_sets(stop_app=set(),
restart_app=set(),
restart_proc=set(),
continue_proc=set(),
start_app=set(),
start_proc=set()):
self.assertSetEqual(stop_app, handler.stop_application_jobs)
self.assertSetEqual(restart_app, handler.restart_application_jobs)
self.assertSetEqual(restart_proc, handler.restart_process_jobs)
self.assertSetEqual(continue_proc, handler.continue_process_jobs)
self.assertSetEqual(start_app, handler.start_application_jobs)
self.assertSetEqual(start_proc, handler.start_process_jobs)
# add a series of jobs
handler.add_job(RunningFailureStrategies.CONTINUE, process_1)
compare_sets(continue_proc={process_1})
handler.add_job(RunningFailureStrategies.RESTART_PROCESS, process_2)
compare_sets(restart_proc={process_2}, continue_proc={process_1})
handler.add_job(RunningFailureStrategies.RESTART_PROCESS, process_1)
compare_sets(restart_proc={process_2, process_1})
handler.add_job(RunningFailureStrategies.RESTART_PROCESS, process_3)
compare_sets(restart_proc={process_2, process_1, process_3})
handler.add_job(RunningFailureStrategies.RESTART_PROCESS, process_3)
compare_sets(restart_proc={process_2, process_1, process_3})
handler.add_job(RunningFailureStrategies.RESTART_APPLICATION,
process_1)
compare_sets(restart_app={'dummy_application_A'},
restart_proc={process_3})
handler.add_job(RunningFailureStrategies.STOP_APPLICATION, process_2)
compare_sets(stop_app={'dummy_application_A'},
restart_proc={process_3})
handler.add_job(RunningFailureStrategies.RESTART_APPLICATION,
process_2)
compare_sets(stop_app={'dummy_application_A'},
restart_proc={process_3})
handler.add_job(RunningFailureStrategies.STOP_APPLICATION, process_1)
compare_sets(stop_app={'dummy_application_A'},
restart_proc={process_3})
def test_add_job(self):
""" Test the addition of a new job using a strategy. """
from supvisors.strategy import RunningFailureHandler
from supvisors.ttypes import RunningFailureStrategies
handler = RunningFailureHandler(self.supvisors)
# create a dummy process
process_1 = Mock(application_name='dummy_application_A')
process_2 = Mock(application_name='dummy_application_A')
process_3 = Mock(application_name='dummy_application_B')
# define compare function
def compare_sets(stop_app=set(), restart_app=set(), restart_proc=set(),
continue_proc=set(), start_app=set(), start_proc=set()):
self.assertSetEqual(stop_app, handler.stop_application_jobs)
self.assertSetEqual(restart_app, handler.restart_application_jobs)
self.assertSetEqual(restart_proc, handler.restart_process_jobs)
self.assertSetEqual(continue_proc, handler.continue_process_jobs)
self.assertSetEqual(start_app, handler.start_application_jobs)
self.assertSetEqual(start_proc, handler.start_process_jobs)
# add a series of jobs
handler.add_job(RunningFailureStrategies.CONTINUE, process_1)
compare_sets(continue_proc={process_1})
handler.add_job(RunningFailureStrategies.RESTART_PROCESS, process_2)
compare_sets(restart_proc={process_2}, continue_proc={process_1})
handler.add_job(RunningFailureStrategies.RESTART_PROCESS, process_1)
compare_sets(restart_proc={process_2, process_1})
handler.add_job(RunningFailureStrategies.RESTART_PROCESS, process_3)
compare_sets(restart_proc={process_2, process_1, process_3})
handler.add_job(RunningFailureStrategies.RESTART_PROCESS, process_3)
compare_sets(restart_proc={process_2, process_1, process_3})
handler.add_job(RunningFailureStrategies.RESTART_APPLICATION, process_1)
compare_sets(restart_app={'dummy_application_A'}, restart_proc={process_3})
handler.add_job(RunningFailureStrategies.STOP_APPLICATION, process_2)
compare_sets(stop_app={'dummy_application_A'}, restart_proc={process_3})
handler.add_job(RunningFailureStrategies.RESTART_APPLICATION, process_2)
compare_sets(stop_app={'dummy_application_A'}, restart_proc={process_3})
handler.add_job(RunningFailureStrategies.STOP_APPLICATION, process_1)
compare_sets(stop_app={'dummy_application_A'}, restart_proc={process_3})