def populate_DB():
""" Peuple la base de données en vue des tests. """
# On crée deux hôtes de test.
host1 = functions.add_host(u'host1')
host2 = functions.add_host(u'host2')
DBSession.flush()
# On ajoute un service sur chaque hôte.
service1 = functions.add_lowlevelservice(
host2, u'service1')
service2 = functions.add_lowlevelservice(
host1, u'service2')
DBSession.flush()
# On ajoute un événement brut sur chaque service.
event1 = functions.add_event(service1, u'WARNING', u'foo')
event2 = functions.add_event(service2, u'CRITICAL', u'foo')
DBSession.flush()
# On ajoute un événement corrélé pour chaque événement brut.
functions.add_correvent([event1])
functions.add_correvent([event2])
DBSession.flush()
transaction.commit()
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 add_events_and_aggregates(self):
"""
Ajout de quelques événements associés à des services de
bas niveau dans la BDD, ainsi que de quelques agrégats.
"""
self.event1 = functions.add_event(self.service3, u'WARNING', 'WARNING: RAM is overloaded')
self.event2 = functions.add_event(self.service4, u'WARNING', 'WARNING: eth0 is down')
self.events_aggregate1 = functions.add_correvent([self.event1])
self.events_aggregate2 = functions.add_correvent([self.event2])
def test_nonexisting_predecessor(self):
"""Agrégation topologique : agrégat inexistant."""
ctx = self.context_factory(42)
event1 = functions.add_event(self.hosts[1], 'DOWN', u'foo')
event2 = functions.add_event(self.hosts[2], 'UNREACHABLE', u'foo')
ctx.set('predecessors_aggregates', [1])
res = yield self.corrbuilder._aggregate_topologically(
ctx, None, event2.idevent, self.hosts[2].idhost)
self.assertEquals(False, res)
self.assertEquals(0, DBSession.query(tables.CorrEvent).count())
self.assertEquals(2, DBSession.query(tables.Event).count())
def test_predecessor_and_no_aggregate(self):
"""Agrégation topologique : prédécesseur et pas d'agrégat."""
ctx = self.context_factory(42)
event1 = functions.add_event(self.hosts[1], 'DOWN', u'foo')
event2 = functions.add_event(self.hosts[2], 'UNREACHABLE', u'foo')
aggr1 = functions.add_correvent([event1])
ctx.set('predecessors_aggregates', [aggr1.idcorrevent])
ctx.set('successors_aggregates', [])
res = yield self.corrbuilder._aggregate_topologically(
ctx, None, event2.idevent, self.hosts[2].idhost)
self.assertEquals(True, res)
self.assertEquals(1, DBSession.query(tables.CorrEvent).count())
self.assertEquals(2, DBSession.query(tables.Event).count())
def _insert_dep(self):
"""Insertion de l'événement corrélé de test."""
print "Insertion evenement correle"
timestamp = datetime.now()
supitem = DBSession.query(self.supitem_class).one()
if isinstance(supitem, Host):
event = functions.add_event(supitem, u'DOWN', u'', timestamp)
else: # Sinon, il s'agit d'un LowLevelService.
event = functions.add_event(supitem, u'CRITICAL', u'', timestamp)
functions.add_correvent([event], timestamp=timestamp)
DBSession.flush()
transaction.commit()
correvent = DBSession.query(CorrEvent.idcorrevent).one()
return correvent.idcorrevent
def do_get_dependencies(self):
"""Generate some data for the test"""
ModelTest.do_get_dependencies(self)
host = functions.add_host(u"myhost")
service = functions.add_lowlevelservice(host, u"myservice")
event = functions.add_event(service, u"OK", u"Foo")
return dict(idcause=event.idevent)
def do_get_dependencies(self):
"""Generate some data for the test"""
ModelTest.do_get_dependencies(self)
host = functions.add_host(u'myhost')
service = functions.add_lowlevelservice(host, u'myservice')
event = functions.add_event(service, u'OK', u'Foo')
return dict(idevent=event.idevent)
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_no_predecessors(self):
"""Agrégation topologique : pas de prédécesseurs."""
ctx = self.context_factory(42)
event1 = functions.add_event(self.hosts[1], 'DOWN', u'foo')
ctx.set('predecessors_aggregates', [])
res = yield self.corrbuilder._aggregate_topologically(
ctx, None, event1.idevent, self.hosts[1].idhost)
self.assertEquals(False, res)
def setUp(self):
setup_db()
two_days_ago = datetime.fromtimestamp(time.time() - 2 * 86400)
localhost = fn.add_host('localhost')
localhost2 = fn.add_host('localhost2')
localhost3 = fn.add_host('localhost3')
localhost4 = fn.add_host('localhost4')
hls = fn.add_highlevelservice('hls')
fn.add_correvent(
[fn.add_event(localhost, 'UP', 'foo')],
status=tables.CorrEvent.ACK_CLOSED,
)
fn.add_correvent(
[fn.add_event(localhost2, 'UP', 'foo')],
status=tables.CorrEvent.ACK_CLOSED,
timestamp=two_days_ago,
)
fn.add_correvent(
[fn.add_event(localhost3, 'UP', 'foo')],
status=tables.CorrEvent.ACK_NONE,
)
fn.add_correvent(
[fn.add_event(localhost4, 'UP', 'foo')],
status=tables.CorrEvent.ACK_NONE,
timestamp=two_days_ago,
)
DBSession.add(tables.HLSHistory(
hls=hls,
idstatename=tables.StateName.statename_to_value(u'OK'),
timestamp=two_days_ago,
))
DBSession.add(tables.HLSHistory(
hls=hls,
idstatename=tables.StateName.statename_to_value(u'OK'),
timestamp=datetime.now(),
))
def insert_deps(return_service):
"""
Insère les dépendances nécessaires aux tests.
@param return_service: Indique si les événements générés
concernent un hôte (False) ou un service de bas niveau (True).
@type return_service: C{bool}
@return: Renvoie un tuple avec le groupe d'hôte créé,
l'identifiant du L{CorrEvent} généré et enfin,
l'identifiant de l'L{Event} généré.
@rtype: C{tuple}
"""
timestamp = datetime.now()
hostgroup = functions.add_supitemgroup(u'foo')
host = functions.add_host(u'bar')
hostgroup.supitems.append(host)
DBSession.flush()
servicegroup = functions.add_supitemgroup(u'bar')
service = functions.add_lowlevelservice(host, u'baz')
servicegroup.supitems.append(service)
DBSession.flush()
if return_service:
event = functions.add_event(service, u'WARNING', u'', timestamp)
else:
event = functions.add_event(host, u'WARNING', u'', timestamp)
correvent = functions.add_correvent([event], timestamp=timestamp)
usergroup = UserGroup.by_group_name(u'users_with_access')
DBSession.add(DataPermission(
usergroup=usergroup,
group=hostgroup,
access=u'r',
))
DBSession.flush()
transaction.commit()
correvent = DBSession.query(CorrEvent).first()
event = DBSession.query(Event).first()
return (correvent.idcorrevent, event.idevent)
def add_correvent_caused_by(supitem, timestamp,
correvent_status=CorrEvent.ACK_NONE, event_status=u"WARNING"):
"""
Ajoute dans la base de données un évènement corrélé causé
par un incident survenu sur l'item passé en paramètre.
Génère un historique pour les tests.
"""
# Ajout d'un événement brut et d'un événement corrélé.
event = functions.add_event(supitem, event_status, u'foo')
aggregate = functions.add_correvent([event], status=correvent_status)
return aggregate.idcorrevent
def setUp(self):
setup_db()
two_days_ago = datetime.fromtimestamp(time.time() - 2 * 86400)
localhost = fn.add_host('localhost')
uptime = fn.add_lowlevelservice(localhost, 'UpTime')
ping = fn.add_lowlevelservice(localhost, 'Ping')
users = fn.add_lowlevelservice(localhost, 'Users')
localhost2 = fn.add_host('localhost2')
uptime2 = fn.add_lowlevelservice(localhost2, 'UpTime2')
localhost3 = fn.add_host('localhost3')
localhost4 = fn.add_host('localhost4')
# localhost UP : l'événement pourra être fermé (option -u).
fn.add_correvent([fn.add_event(localhost, 'UP', 'foo')])
# UpTime OK : l'événement pourra être fermé (option -k).
fn.add_correvent([fn.add_event(uptime, 'OK', 'foo')])
# Le Ping et les Users sont CRITICAL depuis une durée variable :
# les événements ne pourront pas être fermés.
fn.add_correvent([fn.add_event(ping, 'CRITICAL', 'foo')])
fn.add_correvent(
[fn.add_event(users, 'CRITICAL', 'foo')],
timestamp=two_days_ago
)
# localhost2 UP et événement ouvert depuis 2j.
fn.add_correvent(
[fn.add_event(localhost2, 'UP', 'foo')],
timestamp=two_days_ago
)
# UpTime2 OK et événement ouvert depuis 2j.
fn.add_correvent(
[fn.add_event(uptime2, 'OK', 'foo')],
timestamp=two_days_ago
)
# localhost3 et 4 sont DOWN depuis une durée variable
# et ne doivent pas être fermés.
fn.add_correvent([fn.add_event(localhost3, 'DOWN', 'foo')])
fn.add_correvent(
[fn.add_event(localhost4, 'DOWN', 'foo')],
timestamp=two_days_ago
)
def insert_deps():
"""Insère les dépendances nécessaires aux tests."""
timestamp = datetime.now()
hostgroup = functions.add_supitemgroup(u'foo')
host = functions.add_host(u'bar')
hostgroup.supitems.append(host)
DBSession.flush()
servicegroup = functions.add_supitemgroup(u'bar')
service = functions.add_lowlevelservice(host, u'baz')
servicegroup.supitems.append(service)
DBSession.flush()
event = functions.add_event(service, u'WARNING', u'Hello world', timestamp)
functions.add_correvent([event], timestamp=timestamp)
return (hostgroup, servicegroup)
def test_desaggregate2(self):
"""Désagrégation d'une vraie alerte d'un agrégat OK/UP (#1027)."""
# Ajout des dépendances topologiques :
# - Host 3 dépend de Host 1.
dep_group = functions.add_dependency_group(
self.hosts[3], None, u'topology', u'|')
functions.add_dependency(dep_group, self.hosts[1], 1)
# Host 1 est dans l'état UP (pour cela, on génère déjà une alerte
# DOWN qu'on fait ensuite repasser UP).
res, idcorrevent1 = yield self.handle_alert(self.hosts[1], 'DOWN')
self.assertNotEquals(res, None)
res, idcorrevent1 = yield self.handle_alert(self.hosts[1], 'UP')
self.assertNotEquals(res, None)
# Host 3 est DOWN.
event = functions.add_event(self.hosts[3], 'DOWN', 'DOWN')
functions.add_host_state(self.hosts[3], 'DOWN')
# Par erreur, l'alerte sur Host 3 s'est retrouvée masquée
# par celle sur Host 1 (#1027).
correvent = DBSession.query(tables.CorrEvent).filter(
tables.CorrEvent.idcorrevent == idcorrevent1).one()
correvent.events.append(event)
DBSession.flush()
# On reçoit une notification sur Host 3 qui confirme le problème.
# L'événement doit être retiré de l'agrégat d'Host 1 et placé
# dans un nouvel agrégat.
res, idcorrevent2 = yield self.handle_alert(self.hosts[3], 'DOWN')
self.assertNotEquals(res, None)
self.assertNotEquals(idcorrevent2, idcorrevent1)
# On vérifie que les événements sont bien dans les bons agrégats.
correvent = DBSession.query(tables.CorrEvent).filter(
tables.CorrEvent.idcorrevent == idcorrevent1).one()
self.assertEquals(len(correvent.events), 1)
correvent2 = DBSession.query(tables.CorrEvent).filter(
tables.CorrEvent.idcorrevent == idcorrevent2).one()
self.assertEquals(
[event.idevent],
[e.idevent for e in correvent2.events]
)
def add_correvent_caused_by(supitem):
"""
Ajoute dans la base de données un évènement corrélé causé
par un incident survenu sur l'item passé en paramètre.
Génère un historique pour les tests.
"""
# Ajout d'un événement et de ses entrées dans l'historique.
event = functions.add_event(supitem, u'WARNING', u'foo')
DBSession.add(EventHistory(
type_action=u'Nagios update state',
idevent=event.idevent,
timestamp=datetime.now()))
DBSession.add(EventHistory(
type_action=u'Acknowlegement change state',
idevent=event.idevent,
timestamp=datetime.now()))
DBSession.flush()
functions.add_correvent([event])
return event.idevent
def test_first_successors_aggregates(self):
"""Récupération des premiers agrégats dépendant d'une alerte brute"""
# On ajoute quelques événements et agrégats
self.add_events_and_aggregates()
# On supprime un agrégat
DBSession.delete(self.events_aggregate2)
DBSession.flush()
# On ajoute un événement et un nouvel
# agrégat dont cet événement est la cause.
self.event3 = functions.add_event(self.service1, u'WARNING', 'WARNING: Processes are not responding')
self.events_aggregate3 = functions.add_correvent([self.event3])
# On récupère les aggrégats causés par le service 5
ctx = self.context_factory(142, defer=True)
ctx._connection._must_defer = False
print "First step"
aggregates = yield self.topology.get_first_successors_aggregates(
ctx,
self.database,
self.service5.idservice
)
aggregates.sort()
# On vérifie que le service 5 n'a causé aucun agrégat directement.
self.assertEqual(aggregates, [])
# On récupère les aggrégats causés par le service 4
print "Second step"
aggregates = yield self.topology.get_first_successors_aggregates(
ctx,
self.database,
self.service4.idservice
)
aggregates.sort()
# On vérifie que le service 4 a bien causé l'agrégat 1
# (Et uniquement l'agrégat 1).
self.assertEqual(aggregates, [self.events_aggregate1.idcorrevent])
def populate_DB():
""" Peuple la base de données. """
# Création des 4 groupes de supitems :
# - 1 groupe racine 'root' ;
root = functions.add_supitemgroup(u'root')
# - 1 groupe principal 'maingroup' ;
maingroup = functions.add_supitemgroup(u'maingroup', root)
# - 2 sous-groupes 'group1' et 'group2', faisant tous
# les deux parties du groupe principal 'maingroup'.
group1 = functions.add_supitemgroup(u'group1', maingroup)
group2 = functions.add_supitemgroup(u'group2', maingroup)
# Création de 2 groupes d'utilisateurs (contenant chacun un utilisateur) :
vigiboard_perm = Permission.by_permission_name(u'vigiboard-access')
# - le premier avec des droits étendus
# (il a indirectement accès à tous les groupes de supitems) ;
usergroup = UserGroup(group_name=u'users_with_access')
usergroup.permissions.append(vigiboard_perm)
DBSession.add(DataPermission(
group = root,
usergroup = usergroup,
access = u'r',
))
user = User(
user_name=u'access',
fullname=u'',
email=u'user.has@access',
)
user.usergroups.append(usergroup)
DBSession.add(user)
# - le second avec des droits plus restreints
# (il n'a accès qu'au groupe de supitems 'group1').
usergroup = UserGroup(group_name=u'users_with_limited_access')
usergroup.permissions.append(vigiboard_perm)
DBSession.add(DataPermission(
group = group1,
usergroup = usergroup,
access = u'r',
))
user = User(
user_name=u'limited_access',
fullname=u'',
email=u'user.has.limited@access',
)
user.usergroups.append(usergroup)
DBSession.add(user)
DBSession.flush()
# Création de 3 hôtes (1 par groupe de supitems).
maingroup_host = functions.add_host(u'maingroup_host')
group1_host = functions.add_host(u'group1_host')
group2_host = functions.add_host(u'group2_host')
# Affectation des hôtes aux groupes.
maingroup.supitems.append(maingroup_host)
group1.supitems.append(group1_host)
group2.supitems.append(group2_host)
DBSession.flush()
# Création de 3 services de bas niveau (1 par hôte).
group1_service = functions.add_lowlevelservice(
group1_host, u'group1_service')
group2_service = functions.add_lowlevelservice(
group2_host, u'group2_service')
maingroup_service = functions.add_lowlevelservice(
maingroup_host, u'maingroup_service')
# Ajout de 6 événements (1 par supitem)
event1 = functions.add_event(maingroup_host, u'WARNING', u'foo')
event2 = functions.add_event(maingroup_service, u'WARNING', u'foo')
event3 = functions.add_event(group1_host, u'WARNING', u'foo')
event4 = functions.add_event(group1_service, u'WARNING', u'foo')
event5 = functions.add_event(group2_host, u'WARNING', u'foo')
event6 = functions.add_event(group2_service, u'WARNING', u'foo')
# Ajout de 5 événements corrélés (1 pour chaque évènement,
# sauf celui touchant le 'maingroup_service' qui sera rattaché
# à l'évènement corrélé causé par le 'maingroup_host').
functions.add_correvent([event1, event2])
functions.add_correvent([event3])
functions.add_correvent([event4])
functions.add_correvent([event5])
functions.add_correvent([event6])
transaction.commit()