Python DBSession.expunge_all方法代码示例

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

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import expunge_all [as 别名]
    def tearDown(self):
        """ Nettoyage entre les tests """

        print "Dropping the database..."
        DBSession.expunge_all()
        metadata.drop_all()

        self.plugin = None

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import expunge_all [as 别名]
    def test_update(self):
        """Mise à jour des permissions."""
        for (incode, outcode) in commands._permissions.iteritems():
            print "Test permission %s" % incode
            # On simule l'existence d'une permission avant le début du test.
            # Si le test porte sur la permission "lecture seule", alors la
            # permission existante est en lecture/écriture et vice-versa.
            existing_perm = (incode == "ro") and "w" or "r"
            self._add_permission(self._group1, existing_perm)

            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=True,
                commit=False,   # la base de test est en mémoire,
                                # en la committant, on perdrait tout.
            )
            # La demande doit être rejetée car elle rentre
            # en conflit avec les permissions existantes.
            res = commands.cmd_add(options)
            self.assertEquals(res, 0)

            # Une seule permission doit exister en base de données.
            dataperm = DBSession.query(tables.DataPermission).one()
            # Le contenu de la permission doit avoir changé.
            self.assertEquals(self._usergroup.idgroup, dataperm.idusergroup)
            self.assertEquals(self._group1.idgroup, dataperm.idgroup)
            self.assertEquals(outcode, dataperm.access)

            # Suppression de la permission pour le test
            # du type de permission suivant.
            DBSession.delete(dataperm)
            DBSession.flush()
            DBSession.expunge_all() # Nécessaire pour éviter que l'ancienne
                                    # DataPerm ne soit "vue" à l'itération
                                    # suivante.
            dataperm = DBSession.query(tables.DataPermission).first()
            self.assertEquals(dataperm, None)

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import expunge_all [as 别名]
 def tearDown(self):
     DBSession.expunge_all()
     teardown_db()
     shutil.rmtree(self.tmpdir)
     settings["vigiconf"]["confdir"] = self.old_conf_path
     conf.hostsConf = {}

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import expunge_all [as 别名]
 def tearDown(self):
     print "Dropping all tables"
     transaction.abort()
     DBSession.expunge_all()
     teardown_db()

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import expunge_all [as 别名]
 def tearDown(self):
     """Nettoyage à l'issue des tests."""
     DBSession.rollback()
     DBSession.expunge_all()
     teardown_db()
     super(TestSupItemAbstraction, self).tearDown()

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import expunge_all [as 别名]
 def tearDown(self):
     """Finalisation du test."""
     DBSession.expunge_all()
     transaction.abort()
     teardown_db()

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import expunge_all [as 别名]
 def tearDown(self):
     super(TestSvcHostDownRule, self).tearDown()
     DBSession.flush()
     DBSession.expunge_all()
     helpers.teardown_db()
     return defer.succeed(None)

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import expunge_all [as 别名]
 def tearDown(self):
     DBSession.rollback()
     DBSession.expunge_all()
     teardown_db()
     transaction.begin()

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import expunge_all [as 别名]
def teardown_db():
    """Supprime toutes les tables du modèle de la BDD."""
    DBSession.expunge_all()
    DBSession.rollback()
    DBSession.flush()
    metadata.drop_all()

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import expunge_all [as 别名]
 def tearDown(self):
     DBSession.expunge_all()
     transaction.abort()
     teardown_db()

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import expunge_all [as 别名]
 def tearDown(self):
     """Nettoyage après chaque test."""
     transaction.abort()
     DBSession.expunge_all()
     super(TestDetailsPluginMapsHostLimited, self).tearDown()

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import expunge_all [as 别名]
    def handle_alert(self, host, new_state, preds=None, succs=None):
        """
        Simule l'arrivée d'une alerte concernant un hôte
        avec l'état donné en argument.
        """
        new_state = unicode(new_state)

        if preds is None:
            preds = []
        if succs is None:
            succs = []

        self.ts += 1
        info_dictionary = {
            'id': self.ts,
            #'timestamp': self.ts,
            'host': host.name,
            'service': u'',
            'state': new_state,
            'message': new_state,
        }
        info_dictionary['timestamp'] = datetime.fromtimestamp(self.ts)

        ctx = self.context_factory(self.ts)


        # Création Event.
        event = DBSession.query(tables.Event).filter(
            tables.Event.idsupitem == host.idhost).first()
        if event is None:
            event = tables.Event(idsupitem=host.idhost)

        event.current_state = tables.StateName.statename_to_value(
                                info_dictionary['state'])
        event.message = unicode(info_dictionary['message'])
        event.timestamp = info_dictionary['timestamp']
        DBSession.add(event)
        DBSession.flush()

        open_aggr = DBSession.query(
                tables.CorrEvent.idcorrevent
            ).filter(tables.CorrEvent.idcause == event.idevent
            ).scalar()
        # open_aggr vaut None si aucun événement corrélé
        # n'existe pour le moment pour l'élément.
        # Le contexte doit contenir 0 à la place pour ce cas.
        open_aggr = open_aggr or 0

        # On passe par une DeferredList pour garantir l'exécution
        # de tous les Deferred comme étant un seul bloc logique.
        yield defer.DeferredList([
            ctx.set('hostname', host.name),
            ctx.set('servicename', ''),
            ctx.set('statename', new_state),
            ctx.set('raw_event_id', event.idevent),
            ctx.set('idsupitem', host.idhost),
            ctx.set('payload', None),
            ctx.set('timestamp', info_dictionary['timestamp']),
            ctx.set('predecessors_aggregates', preds),
            ctx.set('successors_aggregates', succs),
            ctx.setShared('open_aggr:%s' % host.idhost, open_aggr),
        ])

        res = yield self.corrbuilder.make_correvent(info_dictionary)

        idcorrevent = DBSession.query(
                tables.CorrEvent.idcorrevent
            ).filter(tables.CorrEvent.idcause == event.idevent
            ).scalar()
        # Le expunge_all() évite que SQLAlchemy ne garde en cache
        # la valeur du .events des CorrEvents.
        DBSession.expunge_all()
        defer.returnValue( (res, idcorrevent) )

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import expunge_all [as 别名]
 def tearDown(self):
     """Tear down the fixture used to test the model."""
     del self.obj
     DBSession.rollback()
     DBSession.expunge_all()
     teardown_db()

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import expunge_all [as 别名]
 def tearDown(self):
     """Call after every test case."""
     DBSession.rollback()
     DBSession.expunge_all()
     teardown_db()