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_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 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_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 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 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)