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 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 test_rule_creation(self):
""" Ajout d'une règle de mise en silence """
# 1. On essaye d'ajouter une règle de mise en silence sur 'service3'
# avec l'utilisateur 'no_rights' et on s'assure qu'on reçoit bien une
# erreur 403
environ = {"REMOTE_USER": "******"}
url = "/silence/create_or_modify?" + urllib.urlencode(
{"states": "CRITICAL", "host": "host3", "service": "service3", "comment": "commentaire accentué"}
)
self.app.get(url, extra_environ=environ, status=403)
# 2. On essaye d'ajouter une règle de mise en silence sur 'service3'
# avec l'utilisateur 'limited_rights' et on s'assure qu'on est bien
# redirigé sur un message d'erreur
environ = {"REMOTE_USER": "******"}
url = "/silence/create_or_modify?" + urllib.urlencode(
{"states": "CRITICAL", "host": "host3", "service": "service3", "comment": "commentaire accentué"}
)
response = self.app.get(url, extra_environ=environ, status=302)
response = response.follow(status=200, extra_environ=environ)
assert_true(len(response.lxml.xpath('//div[@id="flash"]/div[@class="error"]')))
# 3. On ajoute une règle de mise en silence sur 'service4' avec
# l'utilisateur 'limited_rights'
environ = {"REMOTE_USER": "******"}
url = "/silence/create_or_modify?" + urllib.urlencode(
{"states": "CRITICAL", "host": "host4", "service": "service4", "comment": "commentaire accentué"}
)
self.app.get(url, extra_environ=environ)
# On recherche dans la base toutes les règles concernant 'service4'
supitem_id = SupItem.get_supitem("host4", "service4")
silences = DBSession.query(Silence).filter(Silence.idsupitem == supitem_id).all()
# On s'assure qu'il n'y en a qu'une, et on vérifie ses propriétés
assert_equal(len(silences), 1)
assert_equal([s.statename for s in silences[0].states], ["CRITICAL"])
assert_equal(silences[0].comment, u"commentaire accentué")
assert_equal(silences[0].author, u"limited_rights")
# 4. On ajoute une règle de mise en silence sur 'service3' avec
# l'utilisateur 'manager'
environ = {"REMOTE_USER": "******"}
url = "/silence/create_or_modify?" + urllib.urlencode(
{"states": "CRITICAL", "host": "host3", "service": "service3", "comment": "commentaire accentué"}
)
self.app.get(url, extra_environ=environ)
# On recherche dans la base toutes les règles concernant 'service3'
supitem_id = SupItem.get_supitem("host3", "service3")
silences = DBSession.query(Silence).filter(Silence.idsupitem == supitem_id).all()
# On s'assure qu'il n'y en a qu'une, et on vérifie ses propriétés
assert_equal(len(silences), 1)
assert_equal([s.statename for s in silences[0].states], ["CRITICAL"])
assert_equal(silences[0].comment, u"commentaire accentué")
assert_equal(silences[0].author, u"manager")
def test_insert_hls_event(self):
"""Insertion d'un évènement brut concernant un SHN"""
self.make_dependencies()
# Création d'un message d'événement portant sur un SHN.
info_dictionary = {
"type": "event",
"timestamp": datetime.fromtimestamp(1239104006),
"host": helpers.settings['correlator']['nagios_hls_host'],
"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'événement dans la BDD
idevent = insert_event(info_dictionary)
# Aucun événement ne doit être créé
# pour les services de haut niveau.
assert idevent is None
def test_rule_deletion(self):
""" Suppression d'une règle de mise en silence """
# On recherche dans la base l'id de la règle concernant 'service1'
service1_id = SupItem.get_supitem("host2", "service1")
service1_silence_id = DBSession.query(Silence).filter(Silence.idsupitem == service1_id).one().idsilence
# On recherche dans la base l'id de la règle concernant 'service2'
service2_id = SupItem.get_supitem("host1", "service2")
service2_silence_id = DBSession.query(Silence).filter(Silence.idsupitem == service2_id).one().idsilence
# On essaye de supprimer la règle de mise en silence portant sur
# 'service1' avec l'utilisateur 'no_rights' et on s'assure qu'on reçoit
# bien une erreur 403
environ = {"REMOTE_USER": "******"}
url = "/silence/delete?id=%s" % service1_silence_id
response = self.app.get(url, extra_environ=environ, status=403)
# On essaye de supprimer la règle de mise en silence portant sur
# 'service1' avec l'utilisateur 'limited_rights' et on s'assure qu'on
# est bien redirigé sur un message d'erreur
environ = {"REMOTE_USER": "******"}
url = "/silence/delete?id=%s" % service1_silence_id
response = self.app.get(url, extra_environ=environ, status=302)
response = response.follow(status=200, extra_environ=environ)
assert_true(len(response.lxml.xpath('//div[@id="flash"]/div[@class="error"]')))
# On supprime la règle de mise en silence portant sur 'service2' avec
# l'utilisateur 'limited_rights'
environ = {"REMOTE_USER": "******"}
url = "/silence/delete?id=%s" % service2_silence_id
response = self.app.get(url, extra_environ=environ)
# On s'assure qu'elle n'existe plus en base
silences = DBSession.query(Silence).filter(Silence.idsupitem == service2_silence_id).all()
assert_equal(len(silences), 0)
# On supprime la règle de mise en silence portant sur 'service1' avec
# l'utilisateur 'manager'
environ = {"REMOTE_USER": "******"}
url = "/silence/delete?id=%s" % service1_silence_id
response = self.app.get(url, extra_environ=environ)
# On s'assure qu'elle n'existe plus en base
silences = DBSession.query(Silence).filter(Silence.idsupitem == service1_id).all()
assert_equal(len(silences), 0)
def test_insert_lls_event(self):
"""Insertion d'un évènement brut concernant un SBN"""
self.make_dependencies()
# Création d'un message d'événement portant sur un SBN.
info_dictionary = {
"type": "event",
"timestamp": datetime.fromtimestamp(1239104006),
"host": "server.example.com",
"service": "Load",
"state": u"WARNING",
"message": u"WARNING: Load average is above 4 (4.5)",
}
info_dictionary['idsupitem'] = SupItem.get_supitem(
info_dictionary['host'],
info_dictionary['service']
)
# Insertion de l'événement dans la BDD
idevent = insert_event(info_dictionary)
assert idevent is not None
event = DBSession.query(Event).one()
# Vérification des informations de l'événement dans la BDD.
self.assertEquals(LowLevelService, type(event.supitem))
self.assertEquals(1239104006, time.mktime(event.timestamp.timetuple()))
self.assertEquals(u'server.example.com', event.supitem.host.name)
self.assertEquals(u'Load', event.supitem.servicename)
self.assertEquals(u'WARNING',
StateName.value_to_statename(event.current_state))
self.assertEquals(u'WARNING',
StateName.value_to_statename(event.initial_state))
self.assertEquals(u'WARNING',
StateName.value_to_statename(event.peak_state))
self.assertEquals(u'WARNING: Load average is above 4 (4.5)',
event.message)
# Insertion de l'état dans la BDD
state = DBSession.query(State).get(info_dictionary['idsupitem'])
# le timestamp par défaut est plus récent et insert_state refusera la
# mise à jour
state.timestamp = info_dictionary['timestamp']
insert_state(info_dictionary)
# Vérification des informations de l'état dans la BDD.
self.assertEquals(LowLevelService, type(state.supitem))
self.assertEquals(1239104006, time.mktime(state.timestamp.timetuple()))
self.assertEquals('server.example.com', state.supitem.host.name)
self.assertEquals('Load', state.supitem.servicename)
self.assertEquals('WARNING',
StateName.value_to_statename(state.state))
self.assertEquals('WARNING: Load average is above 4 (4.5)',
state.message)
def create_or_modify(
self,
states,
host,
service=None,
# start=time.time(),
# end=time.time(),
comment=None,
idsilence=None):
"""
Ajoute une règle de mise en silence d'un hôte/service,
ou en modifie une déjà existante.
@param states: (optionnel) Liste des états concernés par la règle.
@type states: C{list} of C{unicode}
@param host: Nom de l'hôte sur lequel porte la règle.
@type host: C{unicode}
@param service: (optionnel) Nom du service sur lequel
porte la règle.
@type service: C{unicode}
# @param start: Début de la mise en silence planifiée.
# @type start: C{str}
# @param end: Fin de la mise en silence planifiée.
# @type end: C{str}
@param comment: (optionnel) Commentaire accompagnant la règle.
@type comment: C{unicode}
@param idsilence: (optionnel) Identifiant de la règle dans le cas d'une
mise à jour.
@type idsilence: C{int}
"""
# TODO: Faire ce traitement dans le schéma de validation
if not states:
msg = _('No state specified for the silence rule.')
self.handle_error_message(msg)
states = list(states)
# On récupère le nom et l'IP de l'utilisateur.
user = get_current_user()
user_name = user.user_name
user_ip = request.remote_addr
# On récupère l'identifiant de l'item (hôte
# ou service) concerné par la mise en silence.
idsupitem = SupItem.get_supitem(host, service)
if idsupitem:
try:
supitem = DBSession.query(SupItem
).filter(SupItem.idsupitem == idsupitem).one()
except InvalidRequestError, e:
msg = _('An exception has been raised while ' \
'querying the database: %s') % str(e)
self.handle_error_message(msg)
def test_insert_host_event(self):
"""Insertion d'un évènement brut concernant un hôte"""
self.make_dependencies()
# Création d'un message d'événement portant sur un hôte.
info_dictionary = {
"type": "event",
"timestamp": datetime.fromtimestamp(1239104006),
"host": "server.example.com",
"state": u"DOWN",
"message": u"DOWN: No ping response",
}
info_dictionary['idsupitem'] = SupItem.get_supitem(
info_dictionary['host'], None,
)
# Insertion de l'événement dans la BDD
idevent = insert_event(info_dictionary)
assert idevent is not None
event = DBSession.query(Event).one()
# Vérification des informations de l'événement dans la BDD.
self.assertEquals(Host, type(event.supitem))
self.assertEquals(1239104006, time.mktime(event.timestamp.timetuple()))
self.assertEquals(u'server.example.com', event.supitem.name)
self.assertEquals(u'DOWN',
StateName.value_to_statename(event.current_state))
self.assertEquals(u'DOWN',
StateName.value_to_statename(event.initial_state))
self.assertEquals(u'DOWN',
StateName.value_to_statename(event.peak_state))
self.assertEquals(u'DOWN: No ping response',
event.message)
# Insertion de l'état dans la BDD
state = DBSession.query(State).get(info_dictionary['idsupitem'])
# le timestamp par défaut est plus récent et insert_state refusera la
# mise à jour
state.timestamp = info_dictionary['timestamp']
insert_state(info_dictionary)
# Vérification des informations de l'état dans la BDD.
self.assertEquals(Host, type(state.supitem))
self.assertEquals(1239104006, time.mktime(state.timestamp.timetuple()))
self.assertEquals('server.example.com', state.supitem.name)
self.assertEquals('DOWN',
StateName.value_to_statename(state.state))
self.assertEquals('DOWN: No ping response', state.message)
def get_supitem(self, elem):
supitem = None
host = None
service = None
if "host" in elem.attrib:
host = self.get_uattrib("host", elem)
if "service" in elem.attrib:
service = self.get_uattrib("service", elem)
# @TODO: il faudrait fusionner le get_supitem() et la requête d'après.
supitem = SupItem.get_supitem(host, service)
if supitem is None:
raise ParsingError(_("Can't find an item matching %s") %
repr(elem.attrib))
return DBSession.query(SupItem).get(supitem)
def test_no_problem_exception(self):
"""Exception à réception d'une alerte n'indiquant aucun problème."""
self.make_dependencies()
info_dictionary = {
"type": "event",
"timestamp": int(time.time()),
"host": "server.example.com",
"service": "Load",
"state": "OK",
"message": "No problem here",
}
info_dictionary['idsupitem'] = SupItem.get_supitem(
info_dictionary['host'],
info_dictionary['service']
)
self.assertRaises(NoProblemException, insert_event, info_dictionary)
def test_reuse_event_with_no_correvent(self):
"""Ne pas créer de nouvel événement brut sans CorrEvent (#908)."""
self.make_dependencies()
host = DBSession.query(Host).first()
ts = int(time.time())
# On crée un événement brut, qu'on ne rattache
# à aucun événement corrélé.
DBSession.add(
Event(
supitem=host,
current_state=StateName.statename_to_value(u"WARNING"),
message="WARNING: ping",
timestamp=datetime.fromtimestamp(ts - 42),
)
)
DBSession.flush()
# Préparation des informations du messages
# et mise à jour de l'événement brut en base.
info_dictionary = {
"timestamp": datetime.fromtimestamp(ts),
"host": host.name,
"service": None,
"state": u"CRITICAL",
"message": u"CRITICAL: even worse",
"idsupitem": SupItem.get_supitem(host.name, None),
}
insert_event(info_dictionary)
# Aucun nouvel événement brut ne doit avoir été créé.
event = DBSession.query(Event).one()
# À la place, l'événement initial doit avoir été mis à jour.
self.assertEquals(datetime.fromtimestamp(ts), event.timestamp)
self.assertEquals(StateName.statename_to_value(u"CRITICAL"), event.current_state)
self.assertEquals(StateName.statename_to_value(u"CRITICAL"), event.peak_state)
self.assertEquals(StateName.statename_to_value(u"WARNING"), event.initial_state)
self.assertEquals(info_dictionary["message"], event.message)
def test_reuse_correvent_if_possible(self):
"""Privilégier la réutilisation des CorrEvents (#908)."""
self.make_dependencies()
host = DBSession.query(Host).first()
ts = int(time.time())
# On crée un événement brut, qu'on ne rattache
# à aucun événement corrélé.
DBSession.add(
Event(
supitem=host,
current_state=StateName.statename_to_value(u"WARNING"),
message="WARNING: ping",
timestamp=datetime.fromtimestamp(ts - 42),
)
)
DBSession.flush()
# On crée un deuxième événement brut correspondant au même
# élément supervisé, cette fois rattaché à un événement corrélé.
event = Event(
supitem=host,
current_state=StateName.statename_to_value(u"WARNING"),
message="WARNING: ping2",
timestamp=datetime.fromtimestamp(ts - 21),
)
correvent = CorrEvent(
cause=event,
priority=1,
trouble_ticket=u"azerty1234",
ack=CorrEvent.ACK_CLOSED,
occurrence=1,
timestamp_active=datetime.fromtimestamp(ts - 21),
)
correvent.events = [event]
DBSession.add(event)
DBSession.add(correvent)
DBSession.flush()
# Préparation des informations du messages
# et mise à jour de l'événement brut en base.
info_dictionary = {
"timestamp": datetime.fromtimestamp(ts),
"host": host.name,
"service": None,
"state": u"CRITICAL",
"message": u"CRITICAL: even worse",
"idsupitem": SupItem.get_supitem(host.name, None),
}
insert_event(info_dictionary)
# On doit toujours avoir 2 événements bruts en base.
self.assertEquals(2, DBSession.query(Event).count())
# On doit avoir un seul événement corrélé.
correvent = DBSession.query(CorrEvent).one()
# La cause de cet événement corrélé
# doit toujours être la même.
DBSession.refresh(event)
self.assertEquals(event, correvent.cause)
# L'événement brut associé à l'événement
# corrélé doit avoir été mis à jour.
self.assertEquals(datetime.fromtimestamp(ts), event.timestamp)
self.assertEquals(StateName.statename_to_value(u"CRITICAL"), event.current_state)
self.assertEquals(StateName.statename_to_value(u"CRITICAL"), event.peak_state)
self.assertEquals(StateName.statename_to_value(u"WARNING"), event.initial_state)
self.assertEquals(info_dictionary["message"], event.message)
# L'autre événement brut ne doit pas avoir changé.
event = DBSession.query(Event).filter(Event.idevent != event.idevent).one()
self.assertEquals(datetime.fromtimestamp(ts - 42), event.timestamp)
self.assertEquals(StateName.statename_to_value(u"WARNING"), event.current_state)
self.assertEquals(StateName.statename_to_value(u"WARNING"), event.peak_state)
self.assertEquals(StateName.statename_to_value(u"WARNING"), event.initial_state)
self.assertEquals("WARNING: ping", event.message)
def test_rule_update(self):
""" Mise à jour d'une règle de mise en silence """
# On recherche dans la base l'id de la règle concernant 'service1'
service1_id = SupItem.get_supitem("host2", "service1")
service1_silence_id = DBSession.query(Silence).filter(Silence.idsupitem == service1_id).one().idsilence
# On recherche dans la base l'id de la règle concernant 'service2'
service2_id = SupItem.get_supitem("host1", "service2")
service2_silence_id = DBSession.query(Silence).filter(Silence.idsupitem == service2_id).one().idsilence
# 1. On essaye de mettre à jour la règle de mise en silence sur
# 'service1' avec l'utilisateur 'no_rights' et on s'assure qu'on reçoit
# bien une erreur 403
environ = {"REMOTE_USER": "******"}
url = (
"/silence/create_or_modify?"
+ urllib.urlencode(
{
"idsilence": service1_silence_id,
"states": "CRITICAL",
"host": "host1",
"service": "service2",
"comment": "commentaire accentué",
}
)
+ "&"
+ urllib.urlencode({"states": "WARNING"})
)
self.app.get(url, extra_environ=environ, status=403)
# 2. On essaye de mettre à jour la règle de mise en silence sur
# 'service1' avec l'utilisateur 'limited_rights' et on s'assure qu'on
# est bien redirigé sur un message d'erreur
environ = {"REMOTE_USER": "******"}
url = (
"/silence/create_or_modify?"
+ urllib.urlencode(
{
"idsilence": service1_silence_id,
"states": "CRITICAL",
"host": "host2",
"service": "service1",
"comment": "commentaire accentué",
}
)
+ "&"
+ urllib.urlencode({"states": "WARNING"})
)
response = self.app.get(url, extra_environ=environ, status=302)
response = response.follow(status=200, extra_environ=environ)
assert_true(len(response.lxml.xpath('//div[@id="flash"]/div[@class="error"]')))
# 3. On met à jour la règle de mise en silence sur 'service2' avec
# l'utilisateur 'limited_rights'
environ = {"REMOTE_USER": "******"}
url = (
"/silence/create_or_modify?"
+ urllib.urlencode(
{
"idsilence": service2_silence_id,
"states": "CRITICAL",
"host": "host1",
"service": "service2",
"comment": "commentaire accentué",
}
)
+ "&"
+ urllib.urlencode({"states": "WARNING"})
)
self.app.get(url, extra_environ=environ)
# On recherche dans la base toutes les règles concernant 'service2'
silences = DBSession.query(Silence).filter(Silence.idsupitem == service2_id).all()
# On s'assure qu'il n'y en a qu'une, et on vérifie ses propriétés
assert_equal(len(silences), 1)
assert_equal(silences[0].idsilence, service2_silence_id)
assert_equal(list(set([s.statename for s in silences[0].states]) - set([u"CRITICAL", u"WARNING"])), [])
assert_equal(silences[0].comment, u"commentaire accentué")
assert_equal(silences[0].author, u"limited_rights")
# 4. On met à jour la règle de mise en silence sur 'service1' avec
# l'utilisateur 'manager'
environ = {"REMOTE_USER": "******"}
url = (
"/silence/create_or_modify?"
+ urllib.urlencode(
{
"idsilence": service1_silence_id,
"states": "CRITICAL",
"host": "host2",
"service": "service1",
"comment": "commentaire accentué",
}
)
+ "&"
+ urllib.urlencode({"states": "WARNING"})
)
self.app.get(url, extra_environ=environ)
# On recherche dans la base toutes les règles concernant 'service1'
silences = DBSession.query(Silence).filter(Silence.idsupitem == service1_id).all()
# On s'assure qu'il n'y en a qu'une, et on vérifie ses propriétés
assert_equal(len(silences), 1)
assert_equal(silences[0].idsilence, service1_silence_id)
assert_equal(list(set([s.statename for s in silences[0].states]) - set([u"CRITICAL", u"WARNING"])), [])
assert_equal(silences[0].comment, u"commentaire accentué")
assert_equal(silences[0].author, u"manager")
def item(self, page, host, service, sort=None, order=None):
"""
Affichage de l'historique de l'ensemble des événements corrélés
jamais ouverts sur l'hôte / service demandé.
Pour accéder à cette page, l'utilisateur doit être authentifié.
@param page: Numéro de la page à afficher.
@type: C{int}
@param host: Nom de l'hôte souhaité.
@type: C{str}
@param service: Nom du service souhaité
@type: C{str}
@param sort: Colonne de tri
@type: C{str} or C{None}
@param order: Ordre du tri (asc ou desc)
@type: C{str} or C{None}
Cette méthode permet de satisfaire l'exigence
VIGILO_EXIG_VIGILO_BAC_0080.
"""
# Auto-supervision
self.get_failures()
idsupitem = SupItem.get_supitem(host, service)
if not idsupitem:
flash(_('No such host/service'), 'error')
redirect('/')
user = get_current_user()
aggregates = VigiboardRequest(user, False, sort=sort, order=order)
aggregates.add_table(
CorrEvent,
aggregates.items.c.hostname,
aggregates.items.c.servicename,
)
aggregates.add_join((Event, CorrEvent.idcause == Event.idevent))
aggregates.add_join((aggregates.items,
Event.idsupitem == aggregates.items.c.idsupitem))
aggregates.add_filter(aggregates.items.c.idsupitem == idsupitem)
# Pagination des résultats
aggregates.generate_request()
items_per_page = int(session.get('items_per_page', config['vigiboard_items_per_page']))
page = paginate.Page(aggregates.req, page=page,
items_per_page=items_per_page)
# Vérification qu'il y a au moins 1 événement qui correspond
if not page.item_count:
flash(_('No access to this host/service or no event yet'), 'error')
redirect('/')
# Ajout des formulaires et préparation
# des données pour ces formulaires.
ids_events = [event[0].idcause for event in page.items]
tmpl_context.last_modification = \
mktime(get_last_modification_timestamp(ids_events).timetuple())
tmpl_context.edit_event_form = EditEventForm("edit_event_form",
submit_text=_('Apply'), action=url('/update'))
plugins_data = {}
for plugin in dict(config['columns_plugins']):
plugins_data[plugin] = {}
return dict(
hostname = host,
servicename = service,
plugins_data = plugins_data,
page = page,
sort = sort,
order = order,
event_edit_status_options = edit_event_status_options,
search_form = create_search_form,
search = {},
fixed_search = {},
)
def simulate_message_reception(self,
new_state, host_name, service_name=None):
"""
Génère un message de changement d'état concernant l'item passé en
paramètre, réalise les mêmes traitements que ceux du rule_dispatcher
et des règles, et déclenche l'exécution de la fonction make_correvent.
"""
# On incrémente l'identifiant du message
self.msgid += 1
# On génère un timestamp à partir de la date courante
timestamp = datetime.now()
infos = {
'type': "event",
'id': self.msgid,
'timestamp': timestamp,
'service': service_name,
'state': new_state,
'message': new_state,
}
if host_name:
infos['host'] = host_name
else:
infos['host'] = helpers.settings['correlator']['nagios_hls_host']
idsupitem = SupItem.get_supitem(host_name, service_name)
# On ajoute les données nécessaires dans le contexte.
ctx = self.context_factory(self.msgid)
yield ctx.set('hostname', host_name)
yield ctx.set('servicename', service_name)
yield ctx.set('statename', new_state)
yield ctx.set('idsupitem', idsupitem)
# On insère les données nécessaires dans la BDD:
info_dictionary = {
"id": self.msgid,
"host": host_name,
"service": service_name,
"state": new_state,
"timestamp": timestamp,
"message": new_state,
"idsupitem": idsupitem,
}
# - D'abord l'évènement ;
LOGGER.info("Inserting event")
raw_id = insert_event(info_dictionary)
yield ctx.set('raw_event_id', raw_id)
# - Et ensuite l'état.
LOGGER.info("Inserting state")
# Si le timestamp est trop récent insert_state ne fera rien
DBSession.query(State).get(idsupitem).timestamp = timestamp
insert_state(info_dictionary)
DBSession.flush()
# On force le traitement du message, par la fonction make_correvent,
# comme s'il avait été traité au préalable par le rule_dispatcher.
corrbuilder = CorrEventBuilder(Mock(), DummyDatabaseWrapper(True))
corrbuilder.context_factory = self.context_factory
LOGGER.info('Creating a new correlated event')
yield corrbuilder.make_correvent(info_dictionary)