Esempio n. 1
0
def nagioscmdh_factory(settings, client, nagiosconf):
    try:
        commands = settings['connector-nagios'].as_list('accepted_commands')
    except KeyError:
        commands = []
    pipe = settings['connector-nagios']['nagios_pipe']
    queue = settings["bus"]["queue"]
    queue_messages_ttl = int(settings['bus'].get('queue_messages_ttl', 0))
    try:
        group_nc = settings['connector-nagios'].as_bool('group_nagios_commands')
    except KeyError:
        group_nc = False
    nch = NagiosCommandHandler(pipe, commands, group_nc, nagiosconf)
    nch.setClient(client)
    try:
        shutil.rmtree(nch.tmpcmddir)
    except OSError:
        pass
    subs = parseSubscriptions(settings)
    nch.subscribe(queue, queue_messages_ttl, subs)
    return nch
Esempio n. 2
0
def ruledispatcher_factory(settings, database, client):
    nagios_hls_host = settings['correlator']['nagios_hls_host']

    timeout = settings['correlator'].as_int('rules_timeout')
    if timeout <= 0:
        timeout = None

    min_runner = settings['correlator'].as_int('min_rule_runners')
    max_runner = settings['correlator'].as_int('max_rule_runners')

    # Identifiant (supposé) unique de l'instance.
    instance = settings['instance']

    try:
        max_idle = settings['correlator'].as_int('rule_runners_max_idle')
    except KeyError:
        max_idle = 20

    msg_handler = RuleDispatcher(database, nagios_hls_host, timeout,
                                 min_runner, max_runner, max_idle, instance)
    msg_handler.check_database_connectivity()
    msg_handler.setClient(client)
    subs = parseSubscriptions(settings)
    queue = settings["bus"]["queue"]
    queue_message_ttl = int(settings['bus'].get('queue_messages_ttl', 0))
    msg_handler.subscribe(queue, queue_message_ttl, subs)

    # Expéditeur de messages
    publications = parsePublications(settings.get('publications', {}).copy())
    publisher = MessagePublisher(nagios_hls_host, publications)
    publisher.setClient(client)
    msg_handler.bus_publisher = publisher

    # Créateur de correvents
    correvent_builder = CorrEventBuilder(publisher, database)
    msg_handler.correvent_builder = correvent_builder

    return msg_handler
Esempio n. 3
0
def makeService(options):
    """ the service that wraps everything the connector needs. """
    from vigilo.connector.options import getSettings, parseSubscriptions

    settings = getSettings(options, __name__)

    from vigilo.common.logging import get_logger

    LOGGER = get_logger(__name__)

    from vigilo.common.gettext import translate

    _ = translate(__name__)

    from vigilo.connector.client import client_factory
    from vigilo.connector.handlers import buspublisher_factory

    from vigilo.connector_metro.rrdtool import RRDToolPoolManager
    from vigilo.connector_metro.rrdtool import RRDToolManager
    from vigilo.connector_metro.confdb import MetroConfDB
    from vigilo.connector_metro.threshold import ThresholdChecker
    from vigilo.connector_metro.bustorrdtool import BusToRRDtool

    root_service = service.MultiService()

    # Client du bus
    client = client_factory(settings)
    client.setServiceParent(root_service)
    providers = []

    # Configuration
    try:
        conffile = settings["connector-metro"]["config"]
    except KeyError:
        LOGGER.error(
            _("Please set the path to the configuration " "database generated by VigiConf in the settings.ini.")
        )
        sys.exit(1)
    confdb = MetroConfDB(conffile)
    confdb.setServiceParent(root_service)

    try:
        must_check_th = settings["connector-metro"].as_bool("check_thresholds")
    except KeyError:
        must_check_th = True

    # Gestion RRDTool
    rrd_base_dir = settings["connector-metro"]["rrd_base_dir"]
    rrd_path_mode = settings["connector-metro"]["rrd_path_mode"]
    rrd_bin = settings["connector-metro"].get("rrd_bin", "/usr/bin/rrdtool")
    rrdcached = settings["connector-metro"].get("rrdcached", None)
    try:
        pool_size = settings["connector-metro"].as_int("rrd_processes")
    except KeyError:
        pool_size = None
    rrdtool_pool = RRDToolPoolManager(
        rrd_base_dir, rrd_path_mode, rrd_bin, check_thresholds=must_check_th, rrdcached=rrdcached, pool_size=pool_size
    )
    rrdtool = RRDToolManager(rrdtool_pool, confdb)

    # Gestion des seuils
    if must_check_th:
        threshold_checker = ThresholdChecker(rrdtool, confdb)
        bus_publisher = buspublisher_factory(settings, client)
        bus_publisher.registerProducer(threshold_checker, streaming=True)
        providers.append(bus_publisher)
    else:
        threshold_checker = None

    # Gestionnaire principal des messages
    bustorrdtool = BusToRRDtool(confdb, rrdtool, threshold_checker)
    bustorrdtool.setClient(client)
    subs = parseSubscriptions(settings)
    queue = settings["bus"]["queue"]
    queue_messages_ttl = int(settings["bus"].get("queue_messages_ttl", 0))
    bustorrdtool.subscribe(queue, queue_messages_ttl, subs)
    providers.append(bustorrdtool)

    # Statistiques
    from vigilo.connector.status import statuspublisher_factory

    status_publisher = statuspublisher_factory(settings, client, providers=providers)

    return root_service