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)