Пример #1
0
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()
Пример #2
0
    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)
Пример #3
0
 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])
Пример #4
0
 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())
Пример #5
0
 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())
Пример #6
0
 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
Пример #7
0
 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)
Пример #8
0
 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)
Пример #9
0
    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'])
Пример #10
0
 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)
Пример #11
0
    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(),
        ))
Пример #12
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)
Пример #13
0
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
Пример #14
0
    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
        )
Пример #15
0
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)
Пример #16
0
    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]
        )
Пример #17
0
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
Пример #18
0
    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])
Пример #19
0
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()