def add_event(supitem, statename, message, timestamp=None):
"""
Ajoute un événement
@param supitem: ID ou instance du supitem
@type supitem: C{int} ou sous-classe de L{tables.SupItem}
@param statename: Nouvel état
@type statename: C{basestr}
@param message: Message associé au nouvel état.
@type message: C{basestr}
@param timestamp: timestamp de l'événement (par défaut: maintenant)
@type timestamp: C{datetime.datetime.DateTime}
"""
if isinstance(supitem, int):
idsupitem = supitem
elif isinstance(supitem, tables.Host):
idsupitem = supitem.idhost
elif isinstance(supitem, tables.service.Service):
idsupitem = supitem.idservice
elif isinstance(supitem, tables.SupItem):
idsupitem = supitem.idsupitem
if timestamp is None:
timestamp = datetime.now()
e = tables.Event(
idsupitem=idsupitem,
current_state=tables.StateName.statename_to_value(statename),
timestamp=timestamp,
message=unicode(message),
)
e = DBSession.merge(e)
DBSession.flush()
return e
def add_host_state(host, statename, message=None, timestamp=None):
"""
Met à jour l'état d'un hôte
@param host: Nom, ID, ou instance de l'hôte.
@type host: C{str} ou C{int} ou L{tables.Host}
@param statename: Nouvel état de l'hôte.
@type statename: C{basestr}
@param message: Message associé au nouvel état.
@type message: C{basestr}
"""
if isinstance(host, int):
idhost = host
elif isinstance(host, basestring):
idhost = tables.Host.by_name(host).idhost
else:
idhost = host.idhost
if timestamp is None:
timestamp = datetime.now()
s = tables.State(idsupitem=idhost,
state=tables.StateName.statename_to_value(statename),
message=unicode(message),
timestamp=timestamp,
)
s = DBSession.merge(s)
DBSession.flush()
return s
def add_svc_state(service, statename, message=None, timestamp=None):
"""
Met à jour l'état d'un service (bas niveau ou haut niveau).
@param service: Si c'est un tuple (hôte, service), on cherche un service de
bas niveau. Si c'est une chaîne on cherche un service de haut niveau.
Si c'est une instance on l'utilise telle quelle.
@type service: C{tuple} ou C{str} ou L{tables.LowLevelService} ou
L{tables.HighLevelService}
@param statename: Nouvel état du service.
@type statename: C{basestr}
@param message: Message associé au nouvel état.
@type message: C{basestr}
"""
if isinstance(service, tuple):
service = [ unicode(s) for s in service ]
service = tables.LowLevelService.by_host_service_name(*service)
elif isinstance(service, basestring):
service = tables.HighLevelService.by_service_name(service)
if timestamp is None:
timestamp = datetime.now()
s = tables.State(idsupitem=service.idservice,
state=tables.StateName.statename_to_value(statename),
message=unicode(message),
timestamp=timestamp,
)
s = DBSession.merge(s)
DBSession.flush()
return s
def add_ventilation(host, server, application):
"""
Ventile un hôte sur un serveur de supervision
pour une application donnée.
@param host: Hôte supervisé à ventiler.
@type host: C{basestr} ou L{tables.Host}
@param server: Serveur de supervision sur lequel ventiler.
@type server: C{basestr} ou L{tables.VigiloServer}
@param application: Application sur laquelle porte la ventilation.
@type application: C{basestr} ou L{tables.Application}
@return: Instance de ventilation créée.
Cette fonction lèvera une exception si l'hôte est déjà ventilé
sur un serveur de supervision pour l'application donnée.
@rtype: L{tables.Ventilation}
"""
if isinstance(host, basestring):
host = tables.Host.by_host_name(unicode(host))
if isinstance(server, basestring):
server = tables.VigiloServer.by_vigiloserver_name(unicode(server))
if isinstance(application, basestring):
application = tables.Application.by_app_name(unicode(application))
v = tables.Ventilation(
idhost=host.idhost,
idvigiloserver=server.idvigiloserver,
idapp=application.idapp
)
DBSession.merge(v)
DBSession.flush()
return v
def add_mapsegment(from_node, to_node, map):
"""
Ajoute un segment entre deux éléments d'une carte.
@param from_node: Nœud de départ du segment.
@type from_node: L{tables.MapNode} ou C{basestring}
@param to_node: Nœud d'arrivée du segment.
@type to_node: L{tables.MapNode} ou C{basestring}
@param map: Carte sur laquelle le segment doit être ajouté.
@type map: L{tables.Map}
@return: Le segment nouvellement créé.
@rtype: L{tables.MapSegment}
"""
if isinstance(from_node, basestring):
from_node = tables.MapNode.by_map_label(map, unicode(from_node))
if isinstance(to_node, basestring):
to_node = tables.MapNode.by_map_label(map, unicode(to_node))
ms = tables.MapSegment(idfrom_node=from_node.idmapnode,
idto_node=to_node.idmapnode,
idmap=map.idmap,
color=u'#000000',
thickness=2)
DBSession.merge(ms)
DBSession.flush()
return ms
def test_cache(self):
"""Teste le cache des noms d'états."""
row = DBSession.query(StateName).first()
oldname = self.klass.value_to_statename(row.idstatename)
row.statename = row.statename + u'_'
DBSession.add(row)
DBSession.flush()
# On s'assure que le cache est bien utilisé :
# ie. il renvoie l'ancien nom de l'état.
currname = self.klass.value_to_statename(row.idstatename)
assert_equals(oldname, currname)
# De la même manière, le mapping inverse
# fonctionne toujours avec l'ancien nom.
assert_equals(
row.idstatename,
self.klass.statename_to_value(oldname)
)
# On provoque un rafraîchissement du cache.
assert_equals(
row.idstatename,
self.klass.statename_to_value(row.statename)
)
try:
self.klass.statename_to_value(oldname)
except KeyError:
# On s'attend à avoir une KeyError car l'ancien nom
# n'existe plus (ni dans la base, ni dans le cache).
pass
except Exception, e:
self.fail("Got an unexpected exception: %s (%s)" % (type(e), e))
def test_search_service_when_allowed_by_service(self):
"""
Teste la recherche par service avec des droits explicites
(droits accordés car l'utilisateur a explicitement les droits
sur ce service).
"""
# On crée un service avec une alerte.
# Le service est rattaché à un groupe de services
# pour lesquel l'utilisateur a les permissions.
servicegroup = insert_deps()[1]
usergroup = UserGroup.by_group_name(u'users')
DBSession.add(DataPermission(
group=servicegroup,
usergroup=usergroup,
access=u'r',
))
DBSession.flush()
transaction.commit()
# On envoie une requête avec recherche sur le service créé,
# on s'attend à recevoir 1 résultat.
response = self.app.get('/?service=baz',
extra_environ={'REMOTE_USER': '******'})
# Il doit y avoir 1 seule ligne de résultats.
rows = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr')
print "There are %d rows in the result set" % len(rows)
assert_equal(len(rows), 1)
# Il doit y avoir plusieurs colonnes dans la ligne de résultats.
cols = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr/td')
print "There are %d columns in the result set" % len(cols)
assert_true(len(cols) > 1)
def db_commit(self):
version_obj = Version.by_object_name(self.version_key)
if version_obj is None:
version_obj = Version(name=self.version_key)
version_obj.version = self.deploy_revision
DBSession.add(version_obj)
DBSession.flush()
def test_get_maps_limit(self):
"""La fonction get_maps doit récupérer les cartes du groupe"""
titles = [ u"test_map_%d" % i for i in range(10) ]
for title in titles:
add_map(title, self.obj)
DBSession.flush()
assert_equal(5, len(self.obj.get_maps(limit=5)))
def by_host_and_source_name(cls, host, sourcename):
"""
Renvoie une source de données concernant un service donné
en fonction de son nom.
@param cls: Classe à utiliser pour la récupération de la source.
@type cls: C{type}
@param host: Instance de L{Host} ou identifiant
de l'hôte sur lequel porte la source de données.
@type host: C{int} ou L{Host}
@param sourcename: Nom de la source de données à récupérer.
@type sourcename: C{unicode}
@return: La source de données de performances dont le nom est
C{sourcename} et qui porte sur le service C{service}.
@rtype: L{PerfDataSource}
"""
if isinstance(host, (int, long)):
return DBSession.query(cls
).filter(cls.idhost == host
).filter(cls.name == sourcename
).first()
return DBSession.query(cls
).filter(cls.idhost == host.idhost
).filter(cls.name == sourcename
).first()
def insert_hls_history(info_dictionary):
"""
Insère le nouvel état du service de haut niveau dans HLSHistory
afin de conserver une trace.
@param info_dictionary: Dictionnaire contenant les informations
extraites du message d'alerte reçu par le rule dispatcher.
@type info_dictionary: C{dict}
"""
if not info_dictionary['idsupitem']:
LOGGER.error(_('Got a reference to a non configured high-level '
'service (%(service)r)'), {
"service": info_dictionary["service"],
})
return None
history = HLSHistory()
history.idhls = info_dictionary['idsupitem']
# On enregistre l'heure à laquelle le message a
# été traité plutôt que le timestamp du message.
history.timestamp = datetime.now()
history.idstatename = StateName.statename_to_value(
info_dictionary['state'])
DBSession.add(history)
def impacted_hls(self, *args):
"""
Renvoie une requête portant sur les services de haut niveau impactés.
@param args: Liste d'éléments à récupérer dans la requête.
@type args: Une C{DeclarativeBase} ou une liste de C{Column}s.
@return: Une C{Query} portant sur les éléments demandés.
@rtype: C{sqlalchemy.orm.query.Query}
"""
from vigilo.models.tables import HighLevelService, \
ImpactedHLS, ImpactedPath
if not args:
args = [HighLevelService]
imp_hls1 = aliased(ImpactedHLS)
imp_hls2 = aliased(ImpactedHLS)
subquery = DBSession.query(
functions.max(imp_hls1.distance).label('distance'),
imp_hls1.idpath
).join(
(ImpactedPath, ImpactedPath.idpath == imp_hls1.idpath)
).filter(ImpactedPath.idsupitem == self.idsupitem
).group_by(imp_hls1.idpath).subquery()
services_query = DBSession.query(*args).distinct(
).join(
(imp_hls2, HighLevelService.idservice == imp_hls2.idhls),
(subquery, subquery.c.idpath == imp_hls2.idpath),
).filter(imp_hls2.distance == subquery.c.distance)
return services_query
def test_close_limited_up(self):
"""Fermeture événements état UP avec limite de durée."""
# On veut fermer les événements corrélés qui sont dans l'état UP,
# ayant au moins 1j d'âge.
options = Options(state_up=True, state_ok=False, days=1)
res = close_green(LOGGER, options)
self.assertTrue(res) # pas d'erreur.
# On s'assure que le CorrEvent associé à l'état UP
# âgé de 2j a bien été clos.
supitem = tables.Host.by_host_name(u'localhost2')
event = DBSession.query(tables.Event).filter(
tables.Event.idsupitem == supitem.idsupitem).one()
correvent = DBSession.query(tables.CorrEvent).filter(
tables.CorrEvent.idcause == event.idevent).one()
self.assertEquals(correvent.ack, tables.CorrEvent.ACK_CLOSED)
# Les autres doivent toujours être dans l'état "nouveau".
others = DBSession.query(tables.CorrEvent).filter(
tables.CorrEvent.idcorrevent != correvent.idcorrevent).all()
self.assertNotEquals(0, len(others))
for other in others:
self.assertEquals(other.ack, tables.CorrEvent.ACK_NONE,
"L'événement corrélé sur %s devrait être 'nouveau'" %
other.cause.supitem
)
def add_dependency(group, depended, distance=None):
"""
Ajoute une dépendance à un groupe de dépendances.
@param group: Groupe de dépendance (identifiant ou instance).
@type group: C{int} or L{tables.DependencyGroup}
@param depended: Élément à ajouter au groupe de dépendance,
sous la forme d'un tuple (hôte, service) décrivant l'élément
à ajouter.
@type depended: C{tuple}
"""
if isinstance(group, int):
idgroup = group
else:
idgroup = group.idgroup
if isinstance(depended, tables.SupItem):
dependency = depended
else:
host, service = depended
if host is None: # HLS
dependency = tables.HighLevelService.by_service_name(unicode(service))
elif service is None: # Host
dependency = tables.Host.by_host_name(unicode(host))
else: # LLS
dependency = tables.LowLevelService.by_host_service_name(
unicode(host), unicode(service))
DBSession.add(tables.Dependency(
idgroup=idgroup,
supitem=dependency,
distance=distance,
))
DBSession.flush()
def test_add_to_agregate(self):
"""Ajout d'un événement brut à un évènement corrélé déjà existant"""
# On crée 2 couples host/service.
host1 = functions.add_host(u'messagerie')
service1 = functions.add_lowlevelservice(host1, u'Processes')
service2 = functions.add_lowlevelservice(host1, u'CPU')
# On ajoute 1 couple événement/agrégat à la BDD.
event2 = functions.add_event(service2, u'WARNING', 'WARNING: CPU is overloaded')
events_aggregate1 = functions.add_correvent([event2])
# On ajoute un nouvel événement à la BDD.
event1 = functions.add_event(service1, u'WARNING', 'WARNING: Processes are not responding')
# On ajoute ce nouvel événement à l'agrégat existant.
ctx = helpers.ContextStub(42)
yield add_to_aggregate(
event1.idevent,
events_aggregate1.idcorrevent,
DummyDatabaseWrapper(True),
ctx,
123,
False
)
DBSession.flush()
# On vérifie que l'événement a bien été ajouté à l'agrégat.
DBSession.refresh(events_aggregate1)
expected = sorted([event1.idevent, event2.idevent])
actual = sorted([event.idevent for event in events_aggregate1.events])
print "actual = %r, expected = %r" % (actual, expected)
self.assertEquals(actual, expected)
def test_purge_zero_days(self):
"""Purge des événements sans limite d'âge."""
# On veut fermer les événements corrélés qui sont dans l'état OK,
# quelque soit la date à laquelle ils ont été créés.
options = Options(days=0, size=None)
clean_vigiboard(LOGGER, options, None)
# Les 2 entrées d'historique pour un HLS
# doivent avoir été supprimées.
self.assertEquals(0, DBSession.query(tables.HLSHistory).count())
# On s'assure que le CorrEvent et l'événement sur localhost2
# âgés de 2j ont bien été supprimés.
supitem = tables.Host.by_host_name(u'localhost2')
event = DBSession.query(tables.Event).filter(
tables.Event.idsupitem == supitem.idsupitem).first()
self.assertEquals(None, event) # sans Event, pas de CorrEvent possible.
# Les autres doivent toujours être dans l'état "fermé".
others = DBSession.query(tables.CorrEvent).all()
self.assertNotEquals(0, len(others))
for other in others:
# Contourne le problème du support incomplet des contraintes
# référentielles de type ON DELETE CASCADE dans SQLite.
if other.cause is None:
continue
self.assertEquals(
other.ack,
tables.CorrEvent.ACK_NONE,
"L'événement corrélé sur %s devrait être 'nouveau'" %
other.cause.supitem
)
def populate_db(bind):
from vigilo.models.session import DBSession
from vigilo.models import tables
permissions = {
'vigiboard-access':
'Gives access to VigiBoard',
'vigiboard-update':
'Allows users to update events',
'vigiboard-admin':
'Allows users to forcefully close open events',
'vigiboard-silence':
'Allows users to view and edit silence rules',
}
for (permission_name, description) in permissions.iteritems():
if not tables.Permission.by_permission_name(unicode(permission_name)):
DBSession.add(tables.Permission(
permission_name=unicode(permission_name),
description=unicode(description),
))
DBSession.flush()
def test_insert_old_state(self):
"""Abandon de l'insertion d'un état ancien"""
self.make_dependencies()
ts_old = 1239104006
ts_recent = 1239104042
ts_recent_dt = datetime.fromtimestamp(ts_recent)
idsupitem = SupItem.get_supitem("server.example.com", "Load")
# Insertion de l'état récent
state = DBSession.query(State).get(idsupitem)
state.timestamp = ts_recent_dt
# Création d'un message d'événement portant sur un SBN.
info_dictionary = {
"type": "event",
"timestamp": datetime.fromtimestamp(ts_old),
"host": "server.example.com",
"service": "Load",
"state": "WARNING",
"message": "WARNING: Load average is above 4 (4.5)",
}
info_dictionary['idsupitem'] = SupItem.get_supitem(
info_dictionary['host'],
info_dictionary['service']
)
# Insertion de l'ancien événement dans la BDD
result = insert_state(info_dictionary)
self.assertTrue(isinstance(result, OldStateReceived))
supitem = DBSession.query(SupItem).get(idsupitem)
self.assertEqual(supitem.state.timestamp, ts_recent_dt)
def test_pagination(self):
""" Pagination du tri """
# On crée autant d'événements qu'on peut en afficher par page + 1,
# afin d'avoir 2 pages dans le bac à événements.
host3 = functions.add_host(u'host3')
service3 = functions.add_lowlevelservice(
host3, u'service3')
DBSession.flush()
items_per_page = int(config['vigiboard_items_per_page'])
for i in xrange(items_per_page - 1):
event = functions.add_event(service3, u'WARNING', u'foo')
functions.add_correvent([event])
DBSession.flush()
transaction.commit()
# On affiche la seconde page de VigiBoard avec
# un tri par ordre décroissant sur le nom d'hôte
environ = {'REMOTE_USER': '******'}
response = self.app.get(
'/?page=2&sort=hostname&order=desc', extra_environ=environ)
# Il ne doit y avoir qu'une seule ligne de
# résultats concernant "service2" sur "host1"
hostnames = response.lxml.xpath(
'//table[@class="vigitable"]/tbody/tr/' \
'td[@class="plugin_hostname"]/text()')
assert_equal(hostnames, ['host1'])
servicenames = response.lxml.xpath(
'//table[@class="vigitable"]/tbody/tr/' \
'td[@class="plugin_servicename"]/text()')
assert_equal(servicenames, ['service2'])
def test_get_graph_groups_when_not_allowed(self):
"""
Récupération des groupes de graphes sans les bons droits
"""
# Récupération de l'hôte 'host1' dans la base de données
host1 = DBSession.query(Host).filter(
Host.name == u'host1 éà').first()
# Récupération de l'hôte 'host3' dans la base de données
host3 = DBSession.query(Host).filter(
Host.name == u'host3 éà').first()
# Récupération des groupes de graphes de l'hôte
# host1 accessibles à l'utilisateur 'user'
response = self.app.post(
'/rpc/graphtree?host_id=%s' % (host1.idhost, ), {
}, extra_environ={'REMOTE_USER': '******'})
json = response.json
# On s'assure que la liste de groupes
# de graphes retournée est vide
self.assertEqual(
json, {
'graphs': [],
'groups': []
}
)
# Récupération des groupes de graphes de l'hôte
# host3 accessibles à l'utilisateur 'user'
response = self.app.post(
'/rpc/graphtree?host_id=%s' % (host3.idhost, ), {
}, extra_environ={'REMOTE_USER': '******'})
json = response.json
# On s'assure que la liste de groupes
# de graphes retournée est vide
self.assertEqual(
json, {
'graphs': [],
'groups': []
}
)
# Récupération des groupes de graphes de l'hôte
# host1 accessibles à l'utilisateur 'visitor'
response = self.app.post(
'/rpc/graphtree?host_id=%s' % (host1.idhost, ), {
}, extra_environ={'REMOTE_USER': '******'})
json = response.json
# On s'assure que la liste de groupes
# de graphes retournée est vide
self.assertEqual(
json, {
'graphs': [],
'groups': []
}
)
def test_status_no_change(self):
"""RevMan: statut sans changement"""
DBSession.add(tables.Version(name=RevisionManager.version_key, version=1))
DBSession.flush()
status = self.rev_mgr.status()
expected = {"added": [], "removed": [], "modified": []}
self.assertEqual(status, expected)
def test_select_graph_without_a_host(self):
"""
Résultats de la recherche sur un graphe sans préciser d'hôte
"""
# Récupération de l'hôte 'host1' dans la base de données
host1 = DBSession.query(Host).filter(
Host.name == u'host1 éà').first()
# Récupération du graphe 'graph1' dans la base de données
graph1 = DBSession.query(Graph).filter(
Graph.name == u'graph1 éà').first()
# Récupération des résultats obtenus après une recherche sur
# un graphe sans préciser d'hôte par l'utilisateur 'manager'.
response = self.app.post(
'/rpc/searchHostAndGraph?search_form_graph=%s' %
urllib2.quote(graph1.name.encode('utf-8'), ''),
{},
extra_environ={'REMOTE_USER': '******'}
)
json = response.json
# On s'assure que la liste retournée est conforme à celle attendue
self.assertEqual(
json, {
'labels': [[host1.name, graph1.name]],
'ids': [[host1.idhost, graph1.idgraph]],
'more': False,
}
)
def test_get_root_group_when_not_allowed(self):
"""Récupération des groupes racines de l'arbre sans les droits"""
# Récupération du groupe utilisé lors de ce test.
SupItemGroup.by_group_name(u'root')
# Création d'un nouvel utilisateur et d'un nouveau groupe
usergroup = UserGroup(group_name=u'new_users')
vigiboard_perm = Permission.by_permission_name(u'vigiboard-access')
usergroup.permissions.append(vigiboard_perm)
user = User(
user_name=u'new_user',
fullname=u'',
email=u'user.has.no@access',
)
user.usergroups.append(usergroup)
DBSession.add(user)
DBSession.flush()
transaction.commit()
# L'utilisateur est authentifié mais n'a aucun accès. Il
# cherche à obtenir la liste des groupes racines de l'arbre.
response = self.app.get('/get_groups',
extra_environ={'REMOTE_USER': '******'})
json = response.json
# On s'assure que la liste retournée est bien vide.
self.assertEqual(
json, {
'items': [],
'groups': []
}
)
def cb(_result):
self.assertEqual(DBSession.query(tables.Event).count(), 0,
"L'événement ne doit pas avoir été inséré")
self.assertEqual(DBSession.query(tables.EventHistory).count(), 0,
"L'événement ne doit pas avoir d'historique")
self.assertEqual(self.rd._do_correl.call_count, 0,
"La correlation ne doit pas avoir été lancée")
def add_graphgroup(name, parent=None):
name = unicode(name)
g = tables.GraphGroup.by_parent_and_name(parent, name)
if not g:
g = tables.GraphGroup(name=name, parent=parent)
DBSession.add(g)
DBSession.flush()
return g
def tearDown(self):
""" Nettoyage entre les tests """
print "Dropping the database..."
DBSession.expunge_all()
metadata.drop_all()
self.plugin = None
def _add_permission(self, group, perm):
print "group = %r, perm = %r" % (unicode(group).encode('utf-8'), perm)
DBSession.add(tables.DataPermission(
idgroup=group.idgroup,
idusergroup=self._usergroup.idgroup,
access=unicode(perm),
))
DBSession.flush()
def setUp(self):
helpers.teardown_db()
helpers.setup_db()
helpers.populate_statename()
self._insert_test_data()
DBSession.flush()
self.rd = helpers.RuleDispatcherStub()
return defer.succeed(None)
def add_perfdatasource2graph(ds, graph):
if isinstance(graph, int):
graph = DBSession.query(tables.Graph).get(graph)
if isinstance(ds, tuple):
ds = tables.PerfDataSource.by_host_and_source_name(*ds)
if ds not in graph.perfdatasources:
graph.perfdatasources.append(ds)
DBSession.flush()
def add_graph2group(graph, group):
if isinstance(group, basestring):
group = tables.GraphGroup.by_group_name(unicode(group))
if isinstance(graph, int):
graph = DBSession.query(tables.Graph).get(graph)
if graph not in group.graphs:
group.graphs.append(graph)
DBSession.flush()