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 populate_DB():
""" Peuple la base de données. """
# On ajoute un groupe d'hôtes et un groupe de services.
supitemmanagers = functions.add_supitemgroup(u'managersgroup')
usergroup = UserGroup.by_group_name(u'users_with_access')
DBSession.add(DataPermission(
group=supitemmanagers,
usergroup=usergroup,
access=u'w',
))
DBSession.flush()
# On crée un 2 hôtes, et on les ajoute au groupe d'hôtes.
host1 = functions.add_host(u'host1')
host2 = functions.add_host(u'host2')
supitemmanagers.supitems.append(host1)
supitemmanagers.supitems.append(host2)
DBSession.flush()
# On crée 2 services de bas niveau, et on les ajoute au groupe de services.
service1 = functions.add_lowlevelservice(host1, u'service1')
service2 = functions.add_lowlevelservice(host2, u'service2')
supitemmanagers.supitems.append(service1)
supitemmanagers.supitems.append(service2)
DBSession.flush()
return ([host1, host2], [service1, service2])
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 populate_DB():
""" Peuple la base de données en vue des tests. """
# On crée quatre hôtes de test.
host1 = functions.add_host(u"host1")
host2 = functions.add_host(u"host2")
host3 = functions.add_host(u"host3")
host4 = functions.add_host(u"host4")
DBSession.flush()
# On ajoute un service sur chaque hôte.
service1 = functions.add_lowlevelservice(host2, u"service1")
service2 = functions.add_lowlevelservice(host1, u"service2")
service3 = functions.add_lowlevelservice(host3, u"service3")
functions.add_lowlevelservice(host4, u"service4")
DBSession.flush()
# On crée un groupe de supitems et on y ajoute 'host1' et 'host4' en vue des
# tests portant sur les permissions
group1 = functions.add_supitemgroup(u"group1")
DBSession.add(group1)
functions.add_host2group(u"host1", u"group1")
functions.add_host2group(u"host4", u"group1")
DBSession.flush()
# On ajoute 2 utilisateurs.
functions.add_user(u"no_rights", u"*****@*****.**", u"no_rights", u"no_rights", u"no_rights")
functions.add_user(u"limited_rights", u"*****@*****.**", u"limited_rights", u"limited_rights", u"limited_rights")
functions.add_usergroup_permission(u"limited_rights", u"vigiboard-silence")
functions.add_supitemgrouppermission(u"group1", u"limited_rights")
DBSession.flush()
# On ajoute 4 règles de mise en silence.
functions.add_silence(
states=[u"UNKNOWN"], host=host1, service=None, user=u"manager", comment=u"foo", date=u"2000-01-01 00:00:00"
)
functions.add_silence(
states=[u"DOWN"],
host=host1,
service=service2,
user=u"unrestricted",
comment=u"bar",
date=u"2000-01-02 00:00:00",
)
functions.add_silence(
states=[u"WARNING", "CRITICAL"],
host=host2,
service=service1,
user=u"unrestricted",
comment=u"baz",
date=u"2000-01-03 00:00:00",
)
functions.add_silence(
states=[u"DOWN"], host=host3, service=None, user=u"manager", comment=u"qux", date=u"2000-01-04 00:00:00"
)
DBSession.flush()
transaction.commit()
def setUp(self):
"""Initialisation avant chaque test."""
super(TestDetailsPluginMapsHostLimited, self).setUp()
# On fait manuellement ce que l'initialisation de VigiMap ferait
# (car on est dans les tests de VigiBoard, pas ceux de VigiMap).
root = functions.add_mapgroup(u'Root')
DBSession.add(Permission(permission_name=u'vigimap-access'))
print "Creation hote, service et cartes"
host = functions.add_host(u'localhost éçà')
functions.add_lowlevelservice(host, u'lls éçà')
sig = functions.add_supitemgroup(u'supitemgroup éçà')
functions.add_host2group(host, sig)
mg = functions.add_mapgroup(u'éçà', root)
m1 = functions.add_map(u'M1', root)
# La seconde carte appartient à "/Root/éçà"
# et permet de tester les accès indirects.
m2 = functions.add_map(u'M2', mg)
m3 = functions.add_map(u'M3', root)
# On ajoute l'hôte 2 fois sur M1 pour vérifier
# l'absense de doublons dans les liens.
print "Preparation cartes"
functions.add_node_host(host, 'h1', m1)
functions.add_node_host(host, 'h2', m1)
functions.add_node_host(host, 'h', m2)
functions.add_node_host(host, 'h', m3)
# Création de quelques utilisateurs.
print "Creation des comptes utilisateurs et reglages permissions"
functions.add_user(u'restricted', u'*****@*****.**',
u'restricted', u'restricted',
u'restricted')
functions.add_user(u'unrestricted', u'*****@*****.**',
u'unrestricted', u'unrestricted',
u'unrestricted')
functions.add_user(u'no_rights', u'*****@*****.**',
u'no_rights', u'no_rights',
u'no_rights')
# Les 3 utilisateurs ont accès à VigiBoard.
functions.add_usergroup_permission(u'no_rights', u'vigiboard-access')
functions.add_usergroup_permission(u'restricted', u'vigiboard-access')
functions.add_usergroup_permission(u'unrestricted', u'vigiboard-access')
# Mais seuls "restricted" et "unrestricted" ont accès à VigiMap.
functions.add_usergroup_permission(u'restricted', u'vigimap-access')
functions.add_usergroup_permission(u'unrestricted', u'vigimap-access')
# Ils voient tous les trois les événements dans VigiBoard...
functions.add_supitemgrouppermission(sig, 'no_rights')
functions.add_supitemgrouppermission(sig, 'restricted')
functions.add_supitemgrouppermission(sig, 'unrestricted')
# ... mais "restricted" ne peut voir que "M2" ...
functions.add_MapGroupPermission(mg, 'restricted')
# ... tandis que "unrestricted" voit les 3 cartes (par héritage).
functions.add_MapGroupPermission(root, 'unrestricted')
DBSession.flush()
transaction.commit()
def add_services(self):
"""Création de 5 couples host/service"""
self.host1 = functions.add_host(u'messagerie')
self.host2 = functions.add_host(u'firewall')
self.service1 = functions.add_lowlevelservice(self.host1, u'Processes')
self.service2 = functions.add_lowlevelservice(self.host1, u'CPU')
self.service3 = functions.add_lowlevelservice(self.host1, u'RAM')
self.service4 = functions.add_lowlevelservice(self.host1, u'Interface eth0')
self.service5 = functions.add_lowlevelservice(self.host2, u'Interface eth1')
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 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 runTest(self):
"""
Test de la récupération dans la BDD de l'identifiant d'un
item (hôte, service de haut niveau, ou service de bas niveau).
"""
setup_db()
DBSession.flush()
host1 = functions.add_host(u'messagerie')
lls1 = functions.add_lowlevelservice(host1, u'Processes')
hls1 = functions.add_highlevelservice(u'Connexion')
# On vérifie que la fonction get_supitem renvoie bien l'identifiant
# du host1 lorsqu'on lui passe son nom en paramètre.
self.assertEqual(host1.idhost, SupItem.get_supitem(host1.name, None))
# On vérifie que la fonction get_supitem renvoie bien l'identifiant
# du hls1 lorsqu'on lui passe son nom en paramètre.
self.assertEqual(hls1.idservice,
SupItem.get_supitem(None, hls1.servicename))
# On vérifie que la fonction get_supitem renvoie bien l'identifiant
# du lls1 lorsqu'on lui passe son nom en paramètre.
self.assertEqual(lls1.idservice,
SupItem.get_supitem(host1.name, lls1.servicename))
#Nettoyage de la BDD à la fin du test
del host1
del lls1
del hls1
DBSession.rollback()
DBSession.expunge_all()
teardown_db()
def populate_DB():
""" Peuple la base de données. """
# On ajoute un groupe d'hôtes et un groupe de services.
supitemmanagers = SupItemGroup(name=u'managersgroup', parent=None)
DBSession.add(supitemmanagers)
DBSession.flush()
usergroup = UserGroup.by_group_name(u'users_with_access')
DBSession.add(DataPermission(
group=supitemmanagers,
usergroup=usergroup,
access=u'r',
))
DBSession.flush()
# On crée un hôte de test, et on l'ajoute au groupe d'hôtes.
managerhost = functions.add_host(u'managerhost')
supitemmanagers.supitems.append(managerhost)
DBSession.flush()
# On crée un services de bas niveau, et on l'ajoute au groupe de services.
managerservice = functions.add_lowlevelservice(
managerhost, u'managerservice')
supitemmanagers.supitems.append(managerservice)
DBSession.flush()
return (managerhost, managerservice)
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 do_get_dependencies(self):
"""Génère les dépendances de cette instance."""
# Insère les noms d'états dans la base de données.
ModelTest.do_get_dependencies(self)
host = functions.add_host(u'myhost')
service = functions.add_lowlevelservice(host, u'myservice')
return dict(idsupitem=service.idservice)
def test_host_up_many_services(self):
"""Demander les états de tous les services d'un hôte qui passe UP"""
yield self.setup_context("DOWN", "UP")
servicenames = [ u'testservice-%d' % i for i in range(10) ]
for servicename in servicenames:
functions.add_lowlevelservice(self.host, servicename)
rule_dispatcher = Mock()
yield self.rule.process(rule_dispatcher, self.message_id)
servicenames.insert(0, "testservice") # crée en setUp
print "Count:", rule_dispatcher.sendItem.call_count
self.assertEqual(rule_dispatcher.sendItem.call_count, len(servicenames))
for i, servicename in enumerate(servicenames):
call = rule_dispatcher.method_calls[i]
print servicename, call
self.assertEqual(call[0], "sendItem")
self.assertEqual(call[1][0]["value"].count(servicename), 1)
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 create_deps(self):
# Les caractères "_" & "%" sont spéciaux en SQL.
# Leur usage permet de détecter les échappements abusifs (#943).
self.host = functions.add_host(u'a.b.c_d%e')
self.service = functions.add_lowlevelservice(self.host, u'foobarbaz')
# L'hôte appartient au groupe "Child".
parent = functions.add_supitemgroup(u'Parent')
child = functions.add_supitemgroup(u'Child', parent)
functions.add_host2group(self.host, child)
# Positionnement des permissions.
functions.add_supitemgrouppermission(parent, u'indirect')
functions.add_supitemgrouppermission(child, u'direct')
def test_collector_relation(self):
"""Bon fonctionnement de l'association service -> collector."""
service = DBSession.query(self.klass).one()
collector = functions.add_lowlevelservice(
service.host.name,
u'Collector'
)
service.idcollector = collector.idservice
DBSession.flush()
assert_equals(service.idcollector, collector.idservice)
assert_equals(service.collector, collector)
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')
depgroup = functions.add_dependency_group(
host, service, u'topology', u'+')
return dict(
idgroup=depgroup,
supitem=service,
)
def do_get_dependencies(self):
"""Generate some data for the test"""
ModelTest.do_get_dependencies(self)
# Création du groupe de cartes racine.
functions.add_mapgroup(u'Root')
# Création des objets nécessaires aux relations.
new_map = functions.add_map(u'Carte 1')
host = functions.add_host(u'host1.example.com')
service = functions.add_lowlevelservice(host, u'myservice')
return dict(map=new_map, service=service)
def add_data(self):
"""
Ajoute un hôte et un service de bas niveau dans la BDD, ainsi
que d'autres données nécessaires à l'exécution des tests.
"""
helpers.populate_statename()
# Ajout de la date de dernière
# modification de la topologie dans la BDD.
DBSession.add(Change(
element = u"Topology",
last_modified = datetime.now(),))
DBSession.flush()
self.host = functions.add_host(u'Host')
self.lls = functions.add_lowlevelservice(self.host, u'LLS')
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 do_get_dependencies(self):
"""Generate some data for the test"""
ModelTest.do_get_dependencies(self)
# Création du groupe de cartes racine.
functions.add_mapgroup(u'Root')
# Création des objets nécessaires aux relations.
new_map = functions.add_map(u'Carte 1')
host1 = functions.add_host(u'host1.example.com')
host2 = functions.add_host(u'host2.example.com')
reference = functions.add_lowlevelservice(host1, u'myservice')
from_node = functions.add_node_host(host1, u'Host 1', new_map)
to_node = functions.add_node_host(host2, u'Host 2', new_map)
return dict(from_node=from_node,
to_node=to_node,
map=new_map,
reference=reference)
def test_lls_mapnode(self):
"""Suppression des mapnodes d'un lls supprimé (#57)"""
# Mettre localhost sur une carte
h = fct.add_host(u"localhost")
s = fct.add_lowlevelservice(h, "testservice")
testmap = fct.add_map(u"Test map")
fct.add_node_lls(s, "testservice", testmap)
DBSession.flush()
DBSession.delete(s)
DBSession.flush()
# On vérifie que la suppression du lls a bien supprimé ses
# représentations cartographiques
mn_count = DBSession.query(tables.MapNode).count()
self.assertEquals(mn_count, 0)
mns_count = DBSession.query(tables.MapNodeService).count()
self.assertEquals(mns_count, 0)
mnlls_count = DBSession.query(tables.MapNodeLls).count()
self.assertEquals(mnlls_count, 0)
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 setUp(self):
"""Initialisation d'une réplique du RuleDispatcher."""
self.mp = MessagePublisher(
helpers.settings['correlator']['nagios_hls_host'], {})
self.mp.sendMessage = Mock()
# Initialisation de la BDD
helpers.setup_db()
# Ajout des noms d'états dans la BDD
helpers.populate_statename()
# Ajout d'un hôte dans la BDD
self.host1 = functions.add_host(u'host1.example.com')
# Ajout d'un service de haut niveau dans la BDD
self.hls1 = functions.add_highlevelservice(u'Connexion')
# Ajout d'un service de bas niveau dans la BDD
self.lls1 = functions.add_lowlevelservice(self.host1, u'Processes')
# Création d'un timestamp à partir de l'heure actuelle
self.timestamp = datetime.now()
self.int_timestamp = int(mktime(self.timestamp.timetuple()))
def make_dependencies(self):
"""Création de quelques dépendances dans la BDD."""
host = functions.add_host(u'server.example.com')
functions.add_lowlevelservice(host, u'Load')
functions.add_highlevelservice(u'Load')
def do_get_dependencies(self):
"""Insertion de données dans la base préalable aux tests."""
ModelTest.do_get_dependencies(self)
host = functions.add_host(u'myhost')
service = functions.add_lowlevelservice(host, u'myservice')
return dict(supitem=service)
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()
def populate_db(self):
helpers.populate_statename()
self.host = functions.add_host(u'testhost')
self.lls = functions.add_lowlevelservice(self.host, u'testservice')
def _insert_test_data(self):
"""Création de quelques dépendances dans la BDD."""
host = functions.add_host(u'server.example.com')
functions.add_lowlevelservice(host, u'Load')
functions.add_highlevelservice(u'Load')