Exemplo n.º 1
0
def run_demo():
    """
    Insère des données d'exemple dans la base de données
    à partir d'un scénario de démonstration.
    Plusieurs scénarios différents peuvent être cumulés
    en passant leurs différents noms à ce programme.
    """
    import optparse
    from vigilo.common.gettext import translate_narrow
    _ = translate_narrow(__name__)

    parser = optparse.OptionParser("Usage: %prog sample1 [sample2...]")
    args = parser.parse_args()[1]
    if not args:
        parser.error(_("No sample selected. Available samples: %s")
                % ", ".join(samples.keys()))
        return

    from vigilo.common.conf import settings
    settings.load_module('vigilo.models')

    from vigilo.models.configure import configure_db
    configure_db(settings['database'], 'sqlalchemy_')

    import atexit
    def commit_on_exit():
        """
        Effectue un COMMIT sur la transaction à la fin de l'exécution
        du script d'insertion des données de test.
        """
        import transaction, sqlalchemy
        try:
            transaction.commit()
        except sqlalchemy.exc.InvalidRequestError:
            transaction.abort()
    atexit.register(commit_on_exit)

    for sample in args:
        if sample not in samples:
            parser.error(_("Sample '%s' cannot be found.") % sample)
            return
        module = __import__(samples[sample], globals(), locals(), ["main"], -1)
        module.main()
Exemplo n.º 2
0
def main():
    # Chargement des traductions d'optparse.
    prepare_argparse()

    parser = optparse.OptionParser(_("%prog [options] command [arguments]"))
    parser.add_option("-n", "--dry-run", action="store_true", dest="dryrun",
                      help=_("Only print the command that would be run"))
    opts, args = parser.parse_args()
    if not args:
        parser.error(N_("No command selected. Available commands: %s") %
                        ", ".join(COMMANDS.keys()))

    cmd_name = args[0]
    if cmd_name not in COMMANDS:
        parser.error(N_("Unknown command. Available commands: %s") %
                        ", ".join(COMMANDS.keys()))

    settings.load_module("vigilo.vigiconf", "settings-local.ini")

    cmd_args = inspect.getargspec(COMMANDS[cmd_name].__init__)
    cmd_min_args = len(cmd_args[0]) - 1
    if cmd_args[3]:
        cmd_min_args -= len(cmd_args[3])

    if len(args) < cmd_min_args or len(args) > len(cmd_args[0]):
        args_list = []
        for index, arg in enumerate(cmd_args[0][1:]):
            if index + 1 > cmd_min_args:
                arg = "[%s]" % arg
            args_list.append(arg)
        parser.error(N_("Wrong number of arguments. Expected: %s") %
                        " ".join(args_list))

    cmd = COMMANDS[cmd_name](*args[1:])

    if opts.dryrun:
        cmd.debug = True

    try:
        cmd.run()
    except CommandPrereqError, e:
        print >> sys.stderr, N_("Setup error: %s") % e
        sys.exit(11)
Exemplo n.º 3
0
def _prepare_db(options):
    """
    Configure l'accès à la base de données Vigilo.

    @param options: Options et arguments passés au script
        sur la ligne de commandes.
    @type options: C{argparse.Namespace}
    @return: Un booléen qui indique si la configuration
        de la base de données s'est bien déroulée ou non.
    @rtype: C{bool}
    """
    from vigilo.common.conf import settings
    if options.config:
        settings.load_file(options.config)
    else:
        settings.load_module(__name__)

    from vigilo.models.configure import configure_db
    try:
        configure_db(settings['database'], 'sqlalchemy_')
    except KeyError:
        print _('No database configuration found')
        return False
    return True
Exemplo n.º 4
0
# vim: set fileencoding=utf-8 sw=4 ts=4 et :
# Copyright (C) 2006-2014 CS-SI
# License: GNU GPL v2 <http://www.gnu.org/licenses/gpl-2.0.html>

import os
import sys
import shutil
import tempfile
import stat

from vigilo.common.conf import settings
settings.load_module(__name__)

from vigilo.models.configure import configure_db
configure_db(settings['database'], 'sqlalchemy_')

from vigilo.models.session import metadata, DBSession
from vigilo.models.tables import StateName, MapGroup

import vigilo.vigiconf.conf as conf

# test postgres: appeler abort() avant teardown
import transaction

TESTDATADIR = os.path.join(os.path.dirname(__file__), "testdata")

def setUpModule(self):
    """Call once, before loading all the test cases."""
    setup_path()
    self.testdatadir = os.path.join(os.path.dirname(__file__), "testdata")
Exemplo n.º 5
0
# -*- coding: utf-8 -*-
# Copyright (C) 2006-2014 CS-SI
# License: GNU GPL v2 <http://www.gnu.org/licenses/gpl-2.0.html>

import transaction
import sqlalchemy

from vigilo.common.conf import settings

settings.load_module("vigilo.models")

from vigilo.models.configure import configure_db

configure_db(settings["database"], "sqlalchemy_")

from vigilo.models.session import DBSession, metadata
from vigilo.models.websetup import populate_db
from vigilo.models import tables


def drop():
    print "DROPping all tables"
    metadata.drop_all()
    transaction.commit()


def truncate():
    for table in metadata.tables.items():
        print "Truncating table '%s'" % table[0]
        try:
            table[1].delete().execute()
Exemplo n.º 6
0
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)
Exemplo n.º 7
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)
Exemplo n.º 8
0
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: "******"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: "******"Confirm new password: "******"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é.
    msg = _("Successfully updated password for user '%s'.")
    logger.info(msg, username)
    print msg % username
    sys.exit(0)