def test_RunningFailureStrategies(self):
""" Test the RunningFailureStrategies enumeration. """
from supvisors.ttypes import RunningFailureStrategies
self.assertEqual('CONTINUE', RunningFailureStrategies._to_string(RunningFailureStrategies.CONTINUE))
self.assertEqual('RESTART_PROCESS', RunningFailureStrategies._to_string(RunningFailureStrategies.RESTART_PROCESS))
self.assertEqual('STOP_APPLICATION', RunningFailureStrategies._to_string(RunningFailureStrategies.STOP_APPLICATION))
self.assertEqual('RESTART_APPLICATION', RunningFailureStrategies._to_string(RunningFailureStrategies.RESTART_APPLICATION))
def load_application_rules(self, application):
# find application element
self.logger.trace('searching application element for {}'.format(application.application_name))
application_elt = self.root.find("./application[@name='{}']".format(application.application_name))
if application_elt is not None:
# get start_sequence rule
value = application_elt.findtext('start_sequence')
application.rules.start_sequence = int(value) if value and int(value)>0 else 0
# get stop_sequence rule
value = application_elt.findtext('stop_sequence')
application.rules.stop_sequence = int(value) if value and int(value)>0 else 0
# get starting_failure_strategy rule
value = application_elt.findtext('starting_failure_strategy')
if value:
strategy = StartingFailureStrategies._from_string(value)
if strategy:
application.rules.starting_failure_strategy = strategy
# get running_failure_strategy rule
value = application_elt.findtext('running_failure_strategy')
if value:
strategy = RunningFailureStrategies._from_string(value)
if strategy:
application.rules.running_failure_strategy = strategy
# final print
self.logger.debug('application {} - rules {}'.format(application.application_name, application.rules))
def __str__(self):
""" Contents as string. """
return 'start_sequence={} stop_sequence={} starting_failure_strategy={}'\
' running_failure_strategy={}'.format(
self.start_sequence, self.stop_sequence,
StartingFailureStrategies._to_string(self.starting_failure_strategy),
RunningFailureStrategies._to_string(self.running_failure_strategy))
def check_dependencies(self, namespec):
""" Update rules after they have been read from the rules file.
A required process that is not in the starting sequence is forced to
optional.
If addresses are not defined, all addresses are applicable.
Supervisor autorestart is not compatible with RunningFailureStrategy
STOP / RESTART.
"""
# required MUST have start_sequence, so force to optional if
# start_sequence is not set
if self.required and self.start_sequence == 0:
self.logger.warn('{} - required forced to False because'
' no start_sequence defined'.format(namespec))
self.required = False
# if no addresses, consider all addresses
if not self.addresses:
self.addresses = ['*']
self.logger.warn('{} - no address defined so all Supvisors'
' addresses are applicable'.format(namespec))
# disable autorestart when RunningFailureStrategies is not CONTINUE
if self.running_failure_strategy != RunningFailureStrategies.CONTINUE:
if self.info_source.autorestart(namespec):
self.info_source.disable_autorestart(namespec)
self.logger.warn('{} - autorestart disabled due to running failure'
' strategy {}'.format(namespec,
RunningFailureStrategies._to_string(self.running_failure_strategy)))
def __str__(self):
""" Contents as string. """
return 'start_sequence={} stop_sequence={} starting_failure_strategy={}'\
' running_failure_strategy={}'.format(
self.start_sequence, self.stop_sequence,
StartingFailureStrategies._to_string(self.starting_failure_strategy),
RunningFailureStrategies._to_string(self.running_failure_strategy))
def __str__(self):
""" Contents as string. """
return 'addresses={} start_sequence={} stop_sequence={} required={}' \
' wait_exit={} expected_loading={} running_failure_strategy={}'.\
format(self.addresses,
self.start_sequence, self.stop_sequence, self.required,
self.wait_exit, self.expected_loading,
RunningFailureStrategies._to_string(self.running_failure_strategy))
def serial(self):
""" Return a serializable form of the ApplicationRules. """
return {'start_sequence': self.start_sequence,
'stop_sequence': self.stop_sequence,
'starting_failure_strategy':
StartingFailureStrategies._to_string(self.starting_failure_strategy),
'running_failure_strategy':
RunningFailureStrategies._to_string(self.running_failure_strategy)}
def __str__(self):
""" Contents as string. """
return 'addresses={} start_sequence={} stop_sequence={} required={}' \
' wait_exit={} expected_loading={} running_failure_strategy={}'.\
format(self.addresses,
self.start_sequence, self.stop_sequence, self.required,
self.wait_exit, self.expected_loading,
RunningFailureStrategies._to_string(
self.running_failure_strategy))
def serial(self):
""" Return a serializable form of the ProcessRules. """
return {'addresses': self.addresses,
'start_sequence': self.start_sequence,
'stop_sequence': self.stop_sequence,
'required': self.required,
'wait_exit': self.wait_exit,
'expected_loading': self.expected_loading,
'running_failure_strategy':
RunningFailureStrategies._to_string(
self.running_failure_strategy)}
def load_process_rules(self, process):
self.logger.trace('searching program element for {}'.format(
process.namespec()))
program_elt = self.get_program_element(process)
rules = process.rules
if program_elt is not None:
# get addresses rule
self.get_program_addresses(program_elt, rules)
# get start_sequence rule
value = program_elt.findtext('start_sequence')
try:
rules.start_sequence = int(value)
if rules.start_sequence < 0:
raise
except:
rules.start_sequence = 0
# get stop_sequence rule
value = program_elt.findtext('stop_sequence')
try:
rules.stop_sequence = int(value)
if rules.stop_sequence < 0:
raise
except:
rules.stop_sequence = 0
# get required rule
value = program_elt.findtext('required')
try:
rules.required = boolean(value)
except:
rules.required = False
# get wait_exit rule
value = program_elt.findtext('wait_exit')
try:
rules.wait_exit = boolean(value)
except:
rules.wait_exit = False
# get expected_loading rule
value = program_elt.findtext('expected_loading')
try:
rules.expected_loading = int(value)
if not 0 <= rules.expected_loading <= 100:
raise
except:
rules.expected_loading = 1
# get running_failure_strategy rule
value = program_elt.findtext('running_failure_strategy')
if value:
strategy = RunningFailureStrategies._from_string(value)
if strategy:
rules.running_failure_strategy = strategy
# check that rules are compliant with dependencies
rules.check_dependencies(process.namespec())
self.logger.debug('process {} - rules {}'.format(
process.namespec(), rules))
def load_process_rules(self, process):
self.logger.trace('searching program element for {}'.format(process.namespec()))
program_elt = self.get_program_element(process)
rules = process.rules
if program_elt is not None:
# get addresses rule
self.get_program_addresses(program_elt, rules)
# get start_sequence rule
value = program_elt.findtext('start_sequence')
try:
rules.start_sequence = int(value)
if rules.start_sequence < 0:
raise
except:
rules.start_sequence = 0
# get stop_sequence rule
value = program_elt.findtext('stop_sequence')
try:
rules.stop_sequence = int(value)
if rules.stop_sequence < 0:
raise
except:
rules.stop_sequence = 0
# get required rule
value = program_elt.findtext('required')
try:
rules.required = boolean(value)
except:
rules.required = False
# get wait_exit rule
value = program_elt.findtext('wait_exit')
try:
rules.wait_exit = boolean(value)
except:
rules.wait_exit = False
# get expected_loading rule
value = program_elt.findtext('expected_loading')
try:
rules.expected_loading = int(value)
if not 0 <= rules.expected_loading <= 100:
raise
except:
rules.expected_loading = 1
# get running_failure_strategy rule
value = program_elt.findtext('running_failure_strategy')
if value:
strategy = RunningFailureStrategies._from_string(value)
if strategy:
rules.running_failure_strategy = strategy
# check that rules are compliant with dependencies
rules.check_dependencies(process.namespec())
self.logger.debug('process {} - rules {}'.format(process.namespec(), rules))
def serial(self):
""" Return a serializable form of the ApplicationRules. """
return {
'start_sequence':
self.start_sequence,
'stop_sequence':
self.stop_sequence,
'starting_failure_strategy':
StartingFailureStrategies._to_string(
self.starting_failure_strategy),
'running_failure_strategy':
RunningFailureStrategies._to_string(self.running_failure_strategy)
}
def test_dependency_rules_running_failure(self):
""" Test the dependency related to running failure strategy in process rules.
Done in a separate test as it impacts the supervisor internal model. """
from supvisors.process import ProcessRules
from supvisors.ttypes import RunningFailureStrategies
rules = ProcessRules(self.supvisors)
# test that only the CONTINUE strategy keeps the autorestart
mocked_disable = self.supvisors.info_source.disable_autorestart
for strategy in RunningFailureStrategies._values():
rules.running_failure_strategy = strategy
rules.check_dependencies('dummy_process_1')
if strategy == RunningFailureStrategies.CONTINUE:
self.assertEqual(0, mocked_disable.call_count)
else:
self.assertEqual([call('dummy_process_1')], mocked_disable.call_args_list)
mocked_disable.reset_mock()
def test_dependency_rules_running_failure(self):
""" Test the dependency related to running failure strategy in process rules.
Done in a separate test as it impacts the supervisor internal model. """
from supvisors.process import ProcessRules
from supvisors.ttypes import RunningFailureStrategies
rules = ProcessRules(self.supvisors)
# test that only the CONTINUE strategy keeps the autorestart
mocked_disable = self.supvisors.info_source.disable_autorestart
for strategy in RunningFailureStrategies._values():
rules.running_failure_strategy = strategy
rules.check_dependencies('dummy_process_1')
if strategy == RunningFailureStrategies.CONTINUE:
self.assertEqual(0, mocked_disable.call_count)
else:
self.assertEqual([call('dummy_process_1')],
mocked_disable.call_args_list)
mocked_disable.reset_mock()