def __init__(self, settings):
"""
Crée un thread dédié à la gestion de la base de données.
Cette méthode configure également la session d'accès à
la base de données pour qu'elle soit partagée entre les
threads.
@param settings: Options de configuration du corrélateur,
contenant en particulier les options relatives à la
base de données (préfixées par "sqlalchemy_").
@type settings: C{dict}
"""
from vigilo.models.configure import configure_db
self.engine = configure_db(settings, 'sqlalchemy_')
from sqlalchemy.orm import sessionmaker
from zope.sqlalchemy import ZopeTransactionExtension
from vigilo.models import session
# On remplace l'objet DBSession par une session partagée
# entre les threads. L'idée est que tous les threads peuvent
# s'en servir pour générer des Query, mais seul le thread
# géré par cette classe peut s'en servir pour exécuter le SQL.
session.DBSession = sessionmaker(
autoflush=True,
autocommit=False,
extension=ZopeTransactionExtension()
)()
self.queue = Queue.Queue()
self.defer = threads.deferToThread(self._db_thread)
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()
def populate_db():
"""
Configure la base de données et l'initialise.
L'initialisation de la base de données crée les tables et insère
les données nécessaires pour commencer à utiliser Vigilo.
"""
from vigilo.models.configure import configure_db
engine = configure_db(config, 'sqlalchemy.')
# Cette méthode se contente d'appeler le websetup du modèle
# en réutilisant la configuration de l'application stockée
# dans la configuration de pylons.
from vigilo.models import websetup
return websetup.populate_db(engine)
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
# 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")
# -*- 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()
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: "******"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)