def test_handlers_args(self):
        """Lecture des arguments d'un 'handler'."""
        # Note : on ne peut pas changer la configuration du logger_root
        # car nose effectue déjà des modifications de celui-ci (qui sont
        # prioritaires sur notre configuration).
        self.load_conf_from_string("""
[loggers]
keys=test

[handlers]
keys=test

[logger_test]
level=DEBUG
handlers=test
qualname=%s

[handler_test]
class=StreamHandler
level=INFO
; En remplace le flux par défaut (stderr) par stdout.
args=(sys.stdout, )
""" % __name__)
        fileConfig()
        logger = get_logger(__name__)

        # Le logger doit avoir le bon niveau, le bon nombre d'handlers
        # et surtout le handler doit avoir la bonne configuration de flux.
        self.assertEquals(logger.level, logging.DEBUG)
        self.assertEquals(len(logger.handlers), 1)
        handler = logger.handlers[0]
        self.assertTrue(isinstance(handler, logging.StreamHandler),
                        handler.__class__.__name__)
        self.assertEquals(handler.level, logging.INFO)
        self.assertEquals(handler.stream, sys.stdout)

    def setUp(self):
        # On prépare la base de données et le serveur MemcacheD.
        helpers.setup_db()
        self.context_factory = helpers.ContextStubFactory()

        # On récupère le logger 'vigilo.correlator.syslog'
        # défini dans les settings.
        self.logger = get_logger('vigilo.correlator.syslog')

        # On crée une instance de la classe test_log_handler()
        # pour intercepter les logs du corrélateur, et on
        # construit un StreamHandler à partir de cette instance.
        self.stream = LogHandlerStub()
        self.handler = logging.StreamHandler(self.stream)

        # On associe ce handler au logger.
        self.logger.addHandler(self.handler)

        # On crée un formatter (qui comme son nom l'indique permet de
        # spécifier le format des messages) qu'on associe lui-même au handler.
        formatter = logging.Formatter("%(message)s")
        self.handler.setFormatter(formatter)

        # Initialisation de l'identifiant des messages XML.
        self.msgid = 0
        return defer.succeed(None)

def makeService(options):
    """ the service that wraps everything the connector needs. """
    from vigilo.connector.options import getSettings
    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.handlers import backupprovider_factory
    from vigilo.connector.socket import socketlistener_factory
    from vigilo.connector_nagios.nagioscommand import nagioscmdh_factory
    from vigilo.connector_nagios.nagiosconf import nagiosconffile_factory

    try:
        socket_filename = settings['connector-nagios']['listen_unix']
        # Statement seems to have no effect # pylint: disable-msg=W0104
        settings['connector-nagios']['nagios_pipe']
        settings["bus"]["queue"]
    except KeyError, e:
        LOGGER.error(_("Missing configuration option: %s"), str(e))
        sys.exit(1)

    def _db_thread(self):
        """
        Cette méthode est exécutée dans un thread séparé.
        C'est elle qui traite les demandes d'opérations sur la base de données
        et retourne les résultats sous la forme d'un objet C{Deferred}.

        @note: Cette méthode ne retourne pas tant que la méthode
            L{DatabaseWrapper.shutdown} n'a pas été appelée.
        """
        from vigilo.common.logging import get_logger
        from vigilo.common.gettext import translate

        logger = get_logger(__name__)
        _ = translate(__name__)

        while True:
            op = self.queue.get()
            if op is None:
                return
            else:
                func, args, kwargs, d, txn = op

            if txn:
                transaction.begin()
            try:
                result = d.callback, func(*args, **kwargs)
                if txn:
                    transaction.commit()
            except Exception:
                if txn:
                    transaction.abort()
                result = d.errback, Failure()
            self.queue.task_done()
            reactor.callFromThread(*result)

    def _log_correvent(self, info_dictionary):
        """
        Enregistre un résumé du traitement de l'événement
        dans les journaux système.

        @param info_dictionary: Dictionnaire contenant les informations
            sur l'événement courant.
        @type info_dictionary: C{dict}
        """
        try:
            log_level = settings['correlator'].as_int('syslog_data_level')
        except KeyError:
            log_level = logging.INFO

        data_logger = get_logger('vigilo.correlator.syslog')
        if not data_logger.isEnabledFor(log_level):
            return

        LOGGER.debug(_('Sending the correlated event to syslog'))
        data_logger.log(log_level,
                        '%s|%s|%s|%s|%s|%s|%s',
                        info_dictionary['idcorrevent'],
                        info_dictionary['update'] and
                            'CHANGE' or 'NEW',
                        info_dictionary['host'],
                        info_dictionary['service'] or '',
                        info_dictionary['state'],
                        info_dictionary['priority'],
                        info_dictionary.get('message', ''),
                    )

def log_initialized(silent_load=False):
    """
    Cette fonction est appelée une fois la configuration chargée
    afin d'indiquer le nom du fichier qui a été chargé.
    """
    if silent_load:
        return
    from vigilo.common.logging import get_logger
    LOGGER = get_logger(__name__)
    LOGGER.debug('Loaded settings from paths: %s',
                 ", ".join(settings.filenames))

def setup_plugins_path(plugins_path):
    """Très fortement inspiré de Trac"""
    from vigilo.common.logging import get_logger
    LOGGER = get_logger(__name__)
    LOGGER.debug("Loading plugins from %s" % plugins_path)

    distributions, errors = pkg_resources.working_set.find_plugins(
        pkg_resources.Environment([plugins_path])
    )
    for dist in distributions:
        if dist in pkg_resources.working_set:
            continue
        LOGGER.debug('Adding plugin %(plugin)s from %(location)s', {
            'plugin': dist,
            'location': dist.location,
        })
        pkg_resources.working_set.add(dist)

    def _log_error(item, e):
        if isinstance(e, pkg_resources.DistributionNotFound):
            LOGGER.debug('Skipping "%(item)s": ("%(module)s" not found)', {
                'item': item,
                'module': e,
            })
        elif isinstance(e, pkg_resources.VersionConflict):
            LOGGER.error(_('Skipping "%(item)s": (version conflict '
                           '"%(error)s")'),
                         {'item': item, 'error': e})
        elif isinstance(e, pkg_resources.UnknownExtra):
            LOGGER.error(_('Skipping "%(item)s": (unknown extra "%(error)s")'),
                         {'item': item, 'error': e })
        elif isinstance(e, ImportError):
            LOGGER.error(_('Skipping "%(item)s": (can\'t import "%(error)s")'),
                         {'item': item, 'error': e })
        else:
            LOGGER.error(_('Skipping "%(item)s": (error "%(error)s")'), {
                'item': item,
                'error': e,
            })

    for dist, e in errors.iteritems():
        _log_error(dist, e)

    def run(self, msgid):
        logger = get_logger(__name__)
        logger.debug(u'Rule runner: process begins for rule "%s" (msgid=%r)',
                     self._name, msgid)

        def commit(res):
            transaction.commit()
            return res

        def abort(fail):
            error_message = fail.getErrorMessage()

            if not isinstance(error_message, unicode):
                error_message = unicode(error_message, 'utf-8', 'replace')

            logger.error(_('Got an exception while running rule ''"%(rule)s". '
                            'Running the correlator in the foreground '
                            '(service vigilo-correlator debug) may help '
                            'troubleshooting (%(error)s)'), {
                                'rule': self._name,
                                'error': error_message,
                            })
            transaction.abort()
            return fail

        def log_end(res):
            logger.debug(u'Rule runner: process ends for rule "%s"', self._name)
            return res

        transaction.begin()
        d = defer.maybeDeferred(
            self._rule.process,
            self._dispatcher,
            msgid)
        d.addCallback(commit)
        d.addErrback(abort)
        d.addBoth(log_end)
        return d

    def run(self, func, *args, **kwargs):
        """
        Exécute une fonction interagissant avec la base de données.


        @param func: La fonction à exécuter qui utilise la base de données.
        @type func: C{callable}
        @note: Les arguments supplémentaires passés à cette méthode
            sont transmis à la fonction indiquée par C{func} lorsque
            celle-ci est appelée.
        @note: Cette méthode accepte également un paramètre nommé
            C{transaction} qui indique si le traitement doit avoir
            lieu dans une transaction ou non. Si le paramètre C{disable_txn}
            a été positionné à True à l'initialisation de l'objet,
            le traitement NE SERA PAS encapsulé dans une transaction,
            quelle que soit la valeur de ce paramètre.
        @return: Un Deferred qui sera appelé avec le résultat de
            l'exécution de la fonction.
        @rtype: L{defer.Deferred}
        """
        from vigilo.common.logging import get_logger
        logger = get_logger(__name__)

        txn = kwargs.pop('transaction', True) and not self.disable_txn
        if txn:
            transaction.begin()
        try:
            res = func(*args, **kwargs)
            if txn:
                transaction.commit()
        except KeyboardInterrupt:
            raise
        except:
            res = Failure()
            if txn:
                transaction.abort()
            self.logger.error(res)
        return self._return(res)

################################################################################
"""
Ce module contient la classe de base pour un serveur Vigilo: L{Server}.
"""

from __future__ import absolute_import

import os
import shutil
import glob
import re

from vigilo.common.conf import settings

from vigilo.common.logging import get_logger
LOGGER = get_logger(__name__)

from vigilo.common.gettext import translate
_ = translate(__name__)

from vigilo.vigiconf import conf
from vigilo.vigiconf.lib import VigiConfError
from vigilo.vigiconf.lib.systemcommand import SystemCommand, SystemCommandError


class ServerError(VigiConfError):
    """Exception concernant un objet L{Server}"""

    def __init__(self, value, iServerName = ''):
        super(ServerError, self).__init__(value)
        self.value = value

@todo: gérer un I{pool} de process RRDTool
@note: U{http://twistedmatrix.com/documents/current/core/howto/process.html}
"""

import os
import stat
import urllib
from signal import SIGINT, SIGTERM

from twisted.internet import reactor, protocol, defer
from twisted.internet.error import ProcessDone, ProcessTerminated

from vigilo.common import get_rrd_path

from vigilo.common.logging import get_logger
LOGGER = get_logger(__name__, silent_load=True)

from vigilo.common.gettext import translate
_ = translate(__name__)


from vigilo.connector_metro.exceptions import CreationError
from vigilo.connector_metro.exceptions import NotInConfiguration
from vigilo.connector_metro.exceptions import MissingConfigurationData


class NoAvailableProcess(Exception):
    """
    Il n'y a plus de process rrdtool disponible, et pourtant le sémaphore a
    autorisé l'accès
    """

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

def main(*args):
    """
    Point d'entrée du script qui ferme les événements en vert
    dans le bac à événements (VigiBoard).

    @note: Cette fonction ne rend pas la main, mais quitte
        l'exécution de Python à la fin de sa propre exécution.
        Les codes de retour possibles pour le script sont :
        * 0 : pas d'erreur
        * 1 : exception levée durant l'exécution
        * 2 : paramètres / options incorrects pour le script
    """
    parser = OptionParser()
    parser.add_option("-d", "--days", action="store", dest="days",
        type="int", default=None, help=_("Close events which are "
        "at least DAYS old. DAYS must be a positive non-zero integer."))
    parser.add_option("-u", "--up", action="store_true", dest="state_up",
        default=False, help=_("Close events for hosts in the 'UP' state."))
    parser.add_option("-k", "--ok", action="store_true", dest="state_ok",
        default=False, help=_("Close events for services in the 'OK' state."))
    parser.add_option("-c", "--config", action="store", dest="config",
        type="string", default=None, help=_("Load configuration from "
        "this file."))

    (options, args) = parser.parse_args()

    from vigilo.common.conf import settings
    if options.config:
        settings.load_file(options.config)
    else:
        settings.load_module(__name__)

    from vigilo.common.logging import get_logger
    logger = get_logger(__name__)

    if args:
        logger.error(_('Too many arguments'))
        sys.exit(2)

    from vigilo.models.configure import configure_db
    try:
        configure_db(settings['database'], 'sqlalchemy_')
    except KeyError:
        logger.error(_('No database configuration found'))
        sys.exit(2)

    # Le script doit être appelé avec au moins une
    # des deux options parmi -k et -u pour être utile.
    if not options.state_up and not options.state_ok:
        parser.error(N_(
            "Either -k or -u must be used. "
            "See %s --help for more information.") % sys.argv[0])
        sys.exit(2)

    try:
        res = close_green(logger, options)
        transaction.commit()
    except Exception: # pylint: disable-msg=W0703
        # W0703: Catch "Exception"
        logger.exception(_('Some error occurred:'))
        transaction.abort()
        sys.exit(1)

    logger.info(
        _("Successfully closed %d events matching the given criteria."),
        res
    )
    sys.exit(0)

def main(*args):
    """
    Point d'entrée du script qui supprime les événements
    obsolètes du bac à événements (VigiBoard).

    @note: Cette fonction ne rend pas la main, mais quitte
        l'exécution de Python à la fin de sa propre exécution.
        Les codes de retour possibles pour le script sont :
        * 0 : pas d'erreur
        * 1 : exception levée durant l'exécution
        * 2 : paramètres / options incorrects pour le script
    """
    parser = OptionParser()
    parser.add_option("-d", "--days", action="store", dest="days",
        type="int", default=None, help=_("Remove closed events which are "
        "at least DAYS old. DAYS must be a positive non-zero integer."))
    parser.add_option("-s", "--size", action="store", dest="size",
        type="int", default=None, help=_("Remove closed events, starting "
        "with the oldest ones, when the Vigilo database starts occupying "
        "more then SIZE bytes. SIZE must be a positive non-zero integer."))
    parser.add_option("-c", "--config", action="store", dest="config",
        type="string", default=None, help=_("Load configuration from "
        "this file."))

    (options, args) = parser.parse_args()

    from vigilo.common.conf import settings
    if options.config:
        settings.load_file(options.config)
    else:
        settings.load_module(__name__)

    from vigilo.common.logging import get_logger
    logger = get_logger(__name__)

    if args:
        logger.error(_('Too many arguments'))
        sys.exit(2)

    from vigilo.models.configure import configure_db
    try:
        configure_db(settings['database'], 'sqlalchemy_')
    except KeyError:
        logger.error(_('No database configuration found'))
        sys.exit(2)

    url = make_url(settings['database']['sqlalchemy_url'])

    if options.days is None and options.size is None:
        parser.error(N_(
            "Either -d or -s must be used. "
            "See %s --help for more information.") % sys.argv[0])
        sys.exit(2)

    try:
        clean_vigiboard(logger, options, url)
        transaction.commit()
        sys.exit(0)
    except Exception: # pylint: disable-msg=W0703
        # W0703: Catch "Exception"
        logger.exception(_('Some error occurred:'))
        transaction.abort()
        sys.exit(1)

def change_password(*args):
    """
    Change le mot de passe d'un utilisateur
    dans la base de données de Vigilo.
    """

    from vigilo.common.gettext import translate
    _ = translate(__name__)

    usage=_("%prog [options] [username]"),
    parser = OptionParser(
        description=_("Changes Vigilo's password for user 'username' "
            "or the currently logged in user if this argument is omitted."),
    )
    parser.add_option("-c", "--config", action="store", dest="config",
        type="string", default=None, help=_("Load configuration from "
        "this file."))
    parser.add_option("-f", action="store", dest="passfile", metavar="FILE",
        type="string", default=None, help=_("Read the new password from "
        "this file."))

    (options, args) = parser.parse_args()

    from vigilo.common.conf import settings
    if options.config:
        settings.load_file(options.config)
    else:
        settings.load_module(__name__)

    from vigilo.common.logging import get_logger
    logger = get_logger(__name__)

    if len(args) > 1:
        print _('Too many arguments')
        sys.exit(1)

    from vigilo.models.configure import configure_db
    try:
        configure_db(settings['database'], 'sqlalchemy_')
    except KeyError:
        print _('No database configuration found')
        sys.exit(1)

    from vigilo.models.session import DBSession
    from vigilo.models import tables

    current_password = None
    current_user = pwd.getpwuid(os.getuid())
    username = current_user.pw_name

    if len(args) > 0:
        username = args[0]

    msg = _("Changing Vigilo password for user '%s'.")
    logger.info(msg, username)
    print msg % username

    # Si l'utilisateur n'est pas "root" (UID 0),
    # alors on demande le mot de passe actuel.
    if current_user.pw_uid != 0:
        current_password = getpass.getpass(_("Enter current password: "))

    user = tables.User.by_user_name(unicode(username))
    if user is None or (current_user.pw_uid != 0 and \
        not user.validate_password(current_password, True)):
        print _("Bad login or password.")
        sys.exit(1)

    if options.passfile:
        passfile = open(options.passfile, "r")
        new_password = new_password2 = passfile.readline().strip()
        passfile.close()
    else:
        new_password = getpass.getpass(_("Enter new password: "))
        new_password2 = getpass.getpass(_("Confirm new password: "))

    # Le nouveau mot de passe et sa
    # confirmation doivent coïncider.
    if new_password != new_password2:
        print _("Sorry, passwords do not match.")
        sys.exit(1)

    # Si le nouveau mot de passe est le même
    # que l'ancien, il n'y a rien à faire.
    if current_password == new_password:
        print _("Password unchanged.")
        sys.exit(0)

    user.password = new_password
    try:
        DBSession.flush()
        transaction.commit()
    except Exception: # pylint: disable-msg=W0703
        # W0703: Catch "Exception"
        msg = _("An exception occurred while updating password for user '%s'.")
        logger.exception(msg, username)
        print msg % username
        sys.exit(1)

    # Si on arrive ici, c'est que tout s'est bien passé.
#.........这里部分代码省略.........