def load_alerters(m, config):
"""Load the alerters listed in the config object."""
if config.has_option("reporting", "alerters"):
alerters = config.get("reporting", "alerters").split(",")
else:
alerters = []
main_logger.info('=== Loading alerters')
for alerter in alerters:
alerter_type = config.get(alerter, "type")
config_options = get_config_dict(config, alerter)
try:
alerter_cls = Alerters.alerter.get_class(alerter_type)
except KeyError:
main_logger.error(
"Unknown alerter type %s; valid types are: %s",
alerter_type, ', '.join(Alerters.alerter.all_types()))
continue
new_alerter = alerter_cls(config_options)
main_logger.info("Adding %s alerter %s", alerter_type, alerter)
new_alerter.name = alerter
m.add_alerter(alerter, new_alerter)
del new_alerter
main_logger.info('--- Loaded %d alerters', len(m.alerters))
return m
def load_loggers(m, config):
"""Load the loggers listed in the config object."""
if config.has_option("reporting", "loggers"):
loggers = config.get("reporting", "loggers").split(",")
else:
loggers = []
main_logger.info('=== Loading loggers')
for config_logger in loggers:
logger_type = config.get(config_logger, "type")
config_options = get_config_dict(config, config_logger)
config_options['_name'] = config_logger
try:
logger_cls = Loggers.logger.get_class(logger_type)
except KeyError:
main_logger.error(
"Unknown logger type %s; valid types are: %s",
logger_type, ', '.join(Loggers.logger.all_types()))
continue
new_logger = logger_cls(config_options)
main_logger.info("Adding %s logger %s: %s", logger_type, config_logger, new_logger)
m.add_logger(config_logger, new_logger)
del new_logger
main_logger.info('--- Loaded %d loggers', len(m.loggers))
return m
def load_monitors(m, filename):
"""Load all the monitors from the config file and return a populated SimpleMonitor."""
config = EnvironmentAwareConfigParser()
config.read(filename)
monitors = config.sections()
if "defaults" in monitors:
default_config = get_config_dict(config, "defaults")
monitors.remove("defaults")
else:
default_config = {}
myhostname = gethostname().lower()
main_logger.info('=== Loading monitors')
for monitor in monitors:
if config.has_option(monitor, "runon"):
if myhostname != config.get(monitor, "runon").lower():
main_logger.warning(
"Ignoring monitor %s because it's only for host %s",
monitor, config.get(monitor, "runon"))
continue
monitor_type = config.get(monitor, "type")
new_monitor = None
config_options = default_config.copy()
config_options.update(get_config_dict(config, monitor))
try:
cls = Monitors.monitor.get_class(monitor_type)
except KeyError:
main_logger.error("Unknown monitor type %s; valid types are: %s",
monitor_type,
', '.join(Monitors.monitor.all_types()))
continue
new_monitor = cls(monitor, config_options)
new_monitor.set_mon_refs(m)
main_logger.info("Adding %s monitor %s: %s", monitor_type, monitor,
new_monitor)
m.add_monitor(monitor, new_monitor)
for i in list(m.monitors.keys()):
m.monitors[i].post_config_setup()
main_logger.info('--- Loaded %d monitors', m.count_monitors())
return m