def test_init(self):
config = Config()
# dir should not exist
config.logfile = '/asdfasd/cxvasvcsd/cvsadfvsafv/kjhgjhg.log'
# no crash
LoggingHelper.init(config)
def test_set_explicit_module_loglevels_success(self):
config = Config()
logname_1 = 'app.logger_name_1'
loglevel_1 = 'error'
logcomp_1 = LoggingHelper.get_loglevel(loglevel_1)
logname_2 = 'xxx.dfgdg.logger_name_1'
loglevel_2 = 'warn'
logcomp_2 = LoggingHelper.get_loglevel(loglevel_2)
ConfigLoader.add_to_rule_config(
config.rule_config, Constants.LOGGING,
'{}|{}'.format(Constants.LOGLEVEL, logname_1), loglevel_1)
ConfigLoader.add_to_rule_config(
config.rule_config, Constants.LOGGING,
'{}|{}'.format(Constants.LOGLEVEL, logname_2), loglevel_2)
ConfigLoader.add_to_rule_config(
config.rule_config, Constants.LOGGING,
'{}|{}'.format(Constants.LOGLEVEL, logname_1), loglevel_1)
LoggingHelper.set_explicit_module_loglevels(config)
logger = logging.getLogger(logname_1)
loglevel_out = logger.getEffectiveLevel()
self.assertEqual(logcomp_1, loglevel_out)
logger = logging.getLogger(logname_2)
loglevel_out = logger.getEffectiveLevel()
self.assertEqual(logcomp_2, loglevel_out)
def init(self):
try:
self._config = ConfigLoader.parse_cli()
if self._config.exit_code is not None:
return self._print_and_return(self._config.exit_code)
ConfigLoader.update_config_from_file(self._config,
init_app_do_not_raise=True)
if self._config.exit_code is not None:
return self._print_and_return(self._config.exit_code)
self._config.exit_code = LoggingHelper.init(self._config)
if self._config.exit_code is not None:
return self._print_and_return(self._config.exit_code)
LoggingHelper.set_explicit_module_loglevels(self._config)
TypePersister.set_storage_path(self._config.persist_dir)
self._rule_manager = RuleManager(self._config)
self._init_locale(self._config.locale)
return None
except Exception as ex:
print('error: {}'.format(ex))
print(traceback.format_exc())
return 1
def daemonize(self):
"""
Do the UNIX double-fork magic, see Stevens' "Advanced
Programming in the UNIX Environment" for details (ISBN 0201563177)
http://www.erlenstar.demon.co.uk/unix/faq_2.html#SEC16
"""
try:
pid = os.fork()
if pid > 0:
# Exit first parent
self._do_exit(0)
else:
self.is_deamon = True
except OSError as ex:
_logger.error('fork #1 failed: %s (%s)', ex.errno, ex.strerror)
self._do_exit(1)
LoggingHelper.remove_logger_console_output()
# Decouple from parent environment
os.chdir(self.workdir)
os.setsid()
os.umask(self.umask)
# Do second fork
try:
pid = os.fork()
if pid > 0:
# Exit from second parent
self._do_exit(0)
else:
self.is_deamon = True
except OSError as ex:
_logger.error('fork #2 failed: %s (%s)', ex.errno, ex.strerror)
self._do_exit(1)
# noinspection PyUnusedLocal
def sigtermhandler(signum, frame):
self.daemon_alive = False
_logger.info('sigtermhandler(%s)', signum)
self.shutdown()
self._do_exit(signum)
signal.signal(signal.SIGTERM, sigtermhandler)
signal.signal(signal.SIGINT, sigtermhandler)
self.write_pidfile()
def test_get_logname(self):
path = self.__module__
name = self.__class__.__name__
full_path = "{}.{}".format(path, name)
ln = LoggingHelper.get_logname(self, "Xtra")
self.assertEqual(ln, full_path + "(xtra)")
ln = LoggingHelper.get_logname(self, name)
self.assertEqual(ln, full_path)
ln = LoggingHelper.get_logname(self, name.upper())
self.assertEqual(ln, full_path)
ln = LoggingHelper.get_logname(self, full_path)
self.assertEqual(ln, full_path)
ln = LoggingHelper.get_logname(self, full_path.upper())
self.assertEqual(ln, full_path)
def test_get_loglevel(self):
loglevel_default = LoggingHelper.LOGLEVEL_DEFAULT
self.assertEqual(loglevel_default, LoggingHelper.get_loglevel(None))
self.assertEqual(loglevel_default, LoggingHelper.get_loglevel(''))
self.assertEqual(logging.DEBUG, LoggingHelper.get_loglevel('debug'))
self.assertEqual(logging.WARN, LoggingHelper.get_loglevel('WARN'))
self.assertEqual(logging.WARN, LoggingHelper.get_loglevel(' warNing'))
self.assertEqual(logging.ERROR, LoggingHelper.get_loglevel(' error'))
self.assertEqual(logging.ERROR, LoggingHelper.get_loglevel(' ERR '))
self.assertEqual(logging.CRITICAL,
LoggingHelper.get_loglevel(' critial'))
self.assertEqual(logging.CRITICAL,
LoggingHelper.get_loglevel(' crit '))
self.assertEqual(logging.CRITICAL,
LoggingHelper.get_loglevel(' FATAL '))
def run(self):
logger = logging.getLogger(__name__)
LoggingHelper.disable_other_loggers()
try:
if self._exit_code is not None:
return self._exit_code
if not self._config or not self._rule_manager:
return 1
if self._register_rules_from_config:
if self._config.parsed.start or self._config.parsed.toogle or \
self._config.parsed.foreground or self._config.parsed.ensure:
self._register_rules_from_config_delayed()
if self._config.parsed.stop:
logger.debug('run(stop)')
self._rule_manager.stop()
elif self._config.parsed.start:
logger.debug('run(start)')
self._rule_manager.start()
elif self._config.parsed.toogle:
logger.debug('run(toggle)')
self._rule_manager.toogle()
elif self._config.parsed.status:
logger.debug('run(status)')
self._rule_manager.status()
elif self._config.parsed.foreground:
logger.debug('run(foreground)')
self._rule_manager.start_foreground()
elif self._config.parsed.ensure:
logger.debug('run(ensure)')
self._rule_manager.ensure_started()
elif self._config.parsed.print_channels:
logger.debug('run(print channels)')
self._rule_manager.print_channels()
return 0
except Exception as ex:
print('error: {}'.format(ex))
print(traceback.format_exc())
return 1
def test_set_explicit_module_loglevels_nocrash(self):
config = Config()
ConfigLoader.add_to_rule_config(config.rule_config, Constants.LOGGING,
'{}||abc'.format(Constants.LOGLEVEL),
'warn')
ConfigLoader.add_to_rule_config(config.rule_config, Constants.LOGGING,
'{}|abc'.format(Constants.LOGLEVEL),
'warn')
ConfigLoader.add_to_rule_config(config.rule_config, Constants.LOGGING,
'dfasfdsafd', 'warn')
LoggingHelper.set_explicit_module_loglevels(config)
LoggingHelper.set_explicit_module_loglevels(None)
LoggingHelper.set_explicit_module_loglevels({})
def _get_logger(self):
if self._logger is None:
log_name = LoggingHelper.get_logname(self, self._instance_name)
self._logger = logging.getLogger(log_name)
return self._logger
def test_disable_other_loggers(self):
# no crash
LoggingHelper.disable_other_loggers()
LoggingHelper.disable_other_loggers()
def test_remove_logger_console_output(self):
LoggingHelper.remove_logger_console_output()
def _do_exit(self, exit_code):
LoggingHelper.disable_output()
# _logger.debug('_do_exit - {}'.format(exit_code))
sys.exit(exit_code)