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 __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})