Python DBSession.query方法代码示例

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import query [as 别名]
 def cb(_result):
     self.assertEqual(DBSession.query(tables.Event).count(), 0,
         "L'événement ne doit pas avoir été inséré")
     self.assertEqual(DBSession.query(tables.EventHistory).count(), 0,
         "L'événement ne doit pas avoir d'historique")
     self.assertEqual(self.rd._do_correl.call_count, 0,
         "La correlation ne doit pas avoir été lancée")

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import query [as 别名]
    def by_host_and_source_name(cls, host, sourcename):
        """
        Renvoie une source de données concernant un service donné
        en fonction de son nom.

        @param cls: Classe à utiliser pour la récupération de la source.
        @type cls: C{type}
        @param host: Instance de L{Host} ou identifiant
            de l'hôte sur lequel porte la source de données.
        @type host: C{int} ou L{Host}
        @param sourcename: Nom de la source de données à récupérer.
        @type sourcename: C{unicode}
        @return: La source de données de performances dont le nom est
            C{sourcename} et qui porte sur le service C{service}.
        @rtype: L{PerfDataSource}
        """
        if isinstance(host, (int, long)):
            return DBSession.query(cls
                ).filter(cls.idhost == host
                ).filter(cls.name == sourcename
                ).first()

        return DBSession.query(cls
            ).filter(cls.idhost == host.idhost
            ).filter(cls.name == sourcename
            ).first()

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import query [as 别名]
    def test_purge_zero_days(self):
        """Purge des événements sans limite d'âge."""
        # On veut fermer les événements corrélés qui sont dans l'état OK,
        # quelque soit la date à laquelle ils ont été créés.
        options = Options(days=0, size=None)
        clean_vigiboard(LOGGER, options, None)

        # Les 2 entrées d'historique pour un HLS
        # doivent avoir été supprimées.
        self.assertEquals(0, DBSession.query(tables.HLSHistory).count())

        # On s'assure que le CorrEvent et l'événement sur localhost2
        # âgés de 2j ont bien été supprimés.
        supitem = tables.Host.by_host_name(u'localhost2')
        event = DBSession.query(tables.Event).filter(
            tables.Event.idsupitem == supitem.idsupitem).first()
        self.assertEquals(None, event) # sans Event, pas de CorrEvent possible.

        # Les autres doivent toujours être dans l'état "fermé".
        others = DBSession.query(tables.CorrEvent).all()

        self.assertNotEquals(0, len(others))
        for other in others:
            # Contourne le problème du support incomplet des contraintes
            # référentielles de type ON DELETE CASCADE dans SQLite.
            if other.cause is None:
                continue

            self.assertEquals(
                other.ack,
                tables.CorrEvent.ACK_NONE,
                "L'événement corrélé sur %s devrait être 'nouveau'" %
                    other.cause.supitem
            )

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import query [as 别名]
    def impacted_hls(self, *args):
        """
        Renvoie une requête portant sur les services de haut niveau impactés.

        @param args: Liste d'éléments à récupérer dans la requête.
        @type args: Une C{DeclarativeBase} ou une liste de C{Column}s.
        @return: Une C{Query} portant sur les éléments demandés.
        @rtype: C{sqlalchemy.orm.query.Query}
        """
        from vigilo.models.tables import HighLevelService, \
                                            ImpactedHLS, ImpactedPath

        if not args:
            args = [HighLevelService]

        imp_hls1 = aliased(ImpactedHLS)
        imp_hls2 = aliased(ImpactedHLS)

        subquery = DBSession.query(
            functions.max(imp_hls1.distance).label('distance'),
            imp_hls1.idpath
        ).join(
            (ImpactedPath, ImpactedPath.idpath == imp_hls1.idpath)
        ).filter(ImpactedPath.idsupitem == self.idsupitem
        ).group_by(imp_hls1.idpath).subquery()

        services_query = DBSession.query(*args).distinct(
        ).join(
            (imp_hls2, HighLevelService.idservice == imp_hls2.idhls),
            (subquery, subquery.c.idpath == imp_hls2.idpath),
        ).filter(imp_hls2.distance == subquery.c.distance)

        return services_query

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import query [as 别名]
    def test_migration(self):
        """Teste la migration (partielle/totale) du modèle."""

        # Recherche des scripts de migration dans le dossier des tests.
        module = u'vigilo.models.test.testdata'
        scripts = get_migration_scripts(module)

        expected_scripts = {
            1: '001_Initial_version',
            2: '002_Dummy',
            3: '003_Dummy',
        }
        self.assertEquals(scripts, expected_scripts)

        # On simule l'installation d'un nouveau modèle.
        DBSession.add(tables.Version(
            name=module,
            version=1,
        ))
        DBSession.flush()

        # On vérifie qu'une migration jusqu'à un point fixe fonctionne.
        migrate_model(DBSession.bind, module, scripts, 2)
        version = DBSession.query(tables.Version).filter(
            tables.Version.name == module).one()
        self.assertEquals(version.version, 2)

        # On annule la migration et on teste cette fois une migration
        # jusqu'à la dernière version disponible.
        version.version = 1
        DBSession.flush()
        migrate_model(DBSession.bind, module, scripts)
        version = DBSession.query(tables.Version).filter(
            tables.Version.name == module).one()
        self.assertEquals(version.version, 3)

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import query [as 别名]
    def test_select_graph_without_a_host(self):
        """
        Résultats de la recherche sur un graphe sans préciser d'hôte
        """

        # Récupération de l'hôte 'host1' dans la base de données
        host1 = DBSession.query(Host).filter(
            Host.name == u'host1 éà').first()

        # Récupération du graphe 'graph1' dans la base de données
        graph1 = DBSession.query(Graph).filter(
            Graph.name == u'graph1 éà').first()

        # Récupération des résultats obtenus après une recherche sur
        # un graphe sans préciser d'hôte par l'utilisateur 'manager'.
        response = self.app.post(
            '/rpc/searchHostAndGraph?search_form_graph=%s' %
                urllib2.quote(graph1.name.encode('utf-8'), ''),
            {},
            extra_environ={'REMOTE_USER': 'manager'}
        )
        json = response.json

        # On s'assure que la liste retournée est conforme à celle attendue
        self.assertEqual(
            json, {
                'labels': [[host1.name, graph1.name]],
                'ids': [[host1.idhost, graph1.idgraph]],
                'more': False,
            }
        )

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import query [as 别名]
    def test_close_limited_up(self):
        """Fermeture événements état UP avec limite de durée."""
        # On veut fermer les événements corrélés qui sont dans l'état UP,
        # ayant au moins 1j d'âge.
        options = Options(state_up=True, state_ok=False, days=1)
        res = close_green(LOGGER, options)
        self.assertTrue(res) # pas d'erreur.

        # On s'assure que le CorrEvent associé à l'état UP
        # âgé de 2j a bien été clos.
        supitem = tables.Host.by_host_name(u'localhost2')
        event = DBSession.query(tables.Event).filter(
            tables.Event.idsupitem == supitem.idsupitem).one()
        correvent = DBSession.query(tables.CorrEvent).filter(
            tables.CorrEvent.idcause == event.idevent).one()
        self.assertEquals(correvent.ack, tables.CorrEvent.ACK_CLOSED)

        # Les autres doivent toujours être dans l'état "nouveau".
        others = DBSession.query(tables.CorrEvent).filter(
            tables.CorrEvent.idcorrevent != correvent.idcorrevent).all()
        self.assertNotEquals(0, len(others))
        for other in others:
            self.assertEquals(other.ack, tables.CorrEvent.ACK_NONE,
                "L'événement corrélé sur %s devrait être 'nouveau'" %
                other.cause.supitem
            )

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import query [as 别名]
    def test_add_multiple_batch(self):
        """Ajout permission sur plusieurs groupes en mode batch."""
        for (incode, outcode) in commands._permissions.iteritems():
            print "Test permission %s" % incode
            options = NamespaceStub(
                permission=incode,
                object_type=self._type,
                usergroup=self._usergroup.group_name.encode('utf-8'),
                object_group=self._group1.name.encode('utf-8'),
                batch=True,
                update=False,
                commit=False,   # la base de test est en mémoire,
                                # en la committant, on perdrait tout.
            )
            res = commands.cmd_add(options)
            self.assertEquals(res, 0)

            # 2 permissions doivent avoir été ajoutées.
            dataperms = DBSession.query(tables.DataPermission).all()
            self.assertEquals(2, len(dataperms))

            idgroups = [self._group1.idgroup, self._group2.idgroup]
            for dataperm in dataperms:
                self.assertTrue(dataperm.idgroup in idgroups)
                idgroups.remove(dataperm.idgroup)
                self.assertEquals(dataperm.idusergroup, self._usergroup.idgroup)
                self.assertEquals(dataperm.access, outcode)

            # Suppression des permissions pour le test
            # du type de permission suivant.
            for dataperm in dataperms:
                DBSession.delete(dataperm)
                DBSession.flush()
            dataperm = DBSession.query(tables.DataPermission).first()
            self.assertEquals(dataperm, None)

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import query [as 别名]
    def test_get_graph_groups_when_not_allowed(self):
        """
        Récupération des groupes de graphes sans les bons droits
        """

        # Récupération de l'hôte 'host1' dans la base de données
        host1 = DBSession.query(Host).filter(
            Host.name == u'host1 éà').first()

        # Récupération de l'hôte 'host3' dans la base de données
        host3 = DBSession.query(Host).filter(
            Host.name == u'host3 éà').first()

        # Récupération des groupes de graphes de l'hôte
        # host1 accessibles à l'utilisateur 'user'
        response = self.app.post(
        '/rpc/graphtree?host_id=%s' % (host1.idhost, ), {
            }, extra_environ={'REMOTE_USER': 'user'})
        json = response.json

        # On s'assure que la liste de groupes
        # de graphes retournée est vide
        self.assertEqual(
            json, {
                'graphs': [],
                'groups': []
            }
        )

        # Récupération des groupes de graphes de l'hôte
        # host3 accessibles à l'utilisateur 'user'
        response = self.app.post(
        '/rpc/graphtree?host_id=%s' % (host3.idhost, ), {
            }, extra_environ={'REMOTE_USER': 'user'})
        json = response.json

        # On s'assure que la liste de groupes
        # de graphes retournée est vide
        self.assertEqual(
            json, {
                'graphs': [],
                'groups': []
            }
        )

        # Récupération des groupes de graphes de l'hôte
        # host1 accessibles à l'utilisateur 'visitor'
        response = self.app.post(
        '/rpc/graphtree?host_id=%s' % (host1.idhost, ), {
            }, extra_environ={'REMOTE_USER': 'visitor'})
        json = response.json

        # On s'assure que la liste de groupes
        # de graphes retournée est vide
        self.assertEqual(
            json, {
                'graphs': [],
                'groups': []
            }
        )

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import query [as 别名]
    def test_add_single(self):
        """Ajout de permission sur un seul groupe."""
        for (incode, outcode) in commands._permissions.iteritems():
            print "Test permission %s" % incode
            options = NamespaceStub(
                permission=incode,
                object_type=self._type,
                usergroup=self._usergroup.group_name.encode('utf-8'),
                object_group=self._group1.path.encode('utf-8'),
                batch=False,
                update=False,
                commit=False,   # la base de test est en mémoire,
                                # en la committant, on perdrait tout.
            )
            res = commands.cmd_add(options)
            self.assertEquals(res, 0)

            # Une seule permission doit exister en base de données.
            # Elle doit porter sur le groupe 1 définis par le test
            # et avoir le bon type d'accès.
            dataperm = DBSession.query(tables.DataPermission).one()
            self.assertEquals(dataperm.idgroup, self._group1.idgroup)
            self.assertEquals(dataperm.idusergroup, self._usergroup.idgroup)
            self.assertEquals(dataperm.access, outcode)

            # Suppression de la permission pour le test
            # du type de permission suivant.
            DBSession.delete(dataperm)
            DBSession.flush()
            dataperm = DBSession.query(tables.DataPermission).first()
            self.assertEquals(dataperm, None)

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import query [as 别名]
 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)

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import query [as 别名]
    def test_parent(self):
        """Affectation d'un parent à un groupe."""
        # Au début, nous n'avons pas de parent.
        assert_equal(self.obj.has_parent(), False)

        # On obtient un parent.
        parent = self.klass(name=u"aparent", parent=None)
        DBSession.add(parent)
        self.obj.parent = parent
        DBSession.query(GroupHierarchy
                        ).filter(GroupHierarchy.parent == parent
                        ).filter(GroupHierarchy.child == self.obj
                        ).filter(GroupHierarchy.hops == 1
                        ).one()
        assert_equal(self.obj.parent, parent)
        assert_equal(self.obj.has_parent(), True)

        # Notre parent est modifié.
        anotherparent = self.klass(name=u"anotherparent", parent=None)
        DBSession.add(anotherparent)
        self.obj.parent = anotherparent
        DBSession.query(GroupHierarchy
                        ).filter(GroupHierarchy.parent == anotherparent
                        ).filter(GroupHierarchy.child == self.obj
                        ).filter(GroupHierarchy.hops == 1
                        ).one()
        assert_equal(self.obj.parent, anotherparent)
        assert_equal(self.obj.has_parent(), True)

        # Suppression du parent.
        self.obj.parent = None
        assert_equal(self.obj.parent, None)
        assert_equal(self.obj.has_parent(), False)

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import query [as 别名]
    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": "no_rights"}
        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": "limited_rights"}
        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": "limited_rights"}
        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": "manager"}
        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")

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import query [as 别名]
    def supitemgroups(self, access=None):
        """
        Renvoie la liste des identifiants des groupes d'éléments supervisés
        auxquels l'utilisateur a accès.

        @param access: La liste des types d'accès qui autoriseront
            l'utilisateur à voir les groupes. Si elle vaut C{None},
            aucune vérification n'est faite sur le type d'accès.
        @param access: C{basestring} or C{list} of C{basestring}

        @return: Liste des identifiants des groupes d'éléments supervisés
            auxquels l'utilisateur a accès.
        @rtype: C{list} of Ctuple{} of C{int}, C{bool}
        """
        result = {}
        if hasattr(access, '__iter__'):
            access = set([ unicode(a) for a in access ])
        elif access is not None:
            access = set([unicode(access)])

        # L'accès en écriture donne implicitement un accès en lecture.
        if access is not None and u'r' in access:
            access.add(u'w')

        # Groupes d'éléments supervisés auxquels
        # l'utilisateur a directement accès.
        direct = DBSession.query(SupItemGroup.idgroup).distinct(
            ).join(
                (GroupHierarchy, GroupHierarchy.idchild ==
                    SupItemGroup.idgroup),
                (DataPermission, DataPermission.idgroup ==
                    GroupHierarchy.idparent),
                (UserGroup, UserGroup.idgroup == DataPermission.idusergroup),
                (USER_GROUP_TABLE, USER_GROUP_TABLE.c.idgroup ==
                    UserGroup.idgroup),
            ).filter(USER_GROUP_TABLE.c.username == self.user_name)
        if access is not None:
            direct = direct.filter(DataPermission.access.in_(access))
        direct = direct.all()
        direct_ids = [sig.idgroup for sig in direct]

        # Groupes d'éléments supervisés auxquels l'utilisateur a accès
        # indirectement (droit de passage, mais pas de droit de lecture).
        indirect = DBSession.query(SupItemGroup.idgroup).distinct(
            ).join(
                (GroupHierarchy, GroupHierarchy.idparent == \
                    SupItemGroup.idgroup),
            ).filter(GroupHierarchy.idchild.in_(direct_ids)
            ).filter(GroupHierarchy.hops > 0
            ).all()

        for sig in indirect:
            result[sig.idgroup] = (sig.idgroup, False)
        for sig in direct:
            result[sig.idgroup] = (sig.idgroup, True)

        return result.values()

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import query [as 别名]
 def test_creation_loop(self):
     """
     Ajout des boucles dans la hiérarchie lors de la création d'un groupe.
     """
     DBSession.query(GroupHierarchy
                     ).filter(GroupHierarchy.idparent == self.obj.idgroup
                     ).filter(GroupHierarchy.idchild == self.obj.idgroup
                     ).filter(GroupHierarchy.hops == 0
                     ).one()