Python DBSession.delete方法代码示例

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import delete [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 delete [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 delete [as 别名]
 def before_delete(self, mapper, connection, instance):
     """
     On utilise before_delete() plutôt qu' after_delete() parce qu'avec
     after_delete() le ON DELETE CASCADE s'est déjà produit et on a plus de
     MapNodeService correspondant en base.
     """
     from vigilo.models.tables.mapnode import MapNodeHls
     mapnodes = DBSession.query(MapNodeHls).filter(
             MapNodeHls.idservice == instance.idservice
         ).all()
     for mapnode in mapnodes:
         DBSession.delete(mapnode)
     return EXT_CONTINUE

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import delete [as 别名]
 def test_change_dependencies_add(self):
     grouploader = GroupLoader()
     grouploader.load_dir(self.datadir)
     print DBSession.query(SupItemGroup).all()
     first_group = DBSession.query(SupItemGroup).first()
     assert first_group is not None
     DBSession.delete(first_group)
     DBSession.flush()
     before = DBSession.query(SupItemGroup).count()
     # On doit créer un 2ème loader pour forcer le rechargement
     # des instances depuis la base de données.
     grouploader = GroupLoader()
     grouploader.load_dir(self.datadir)
     after = DBSession.query(SupItemGroup).count()
     self.assertEquals(after, before + 1)

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import delete [as 别名]
 def test_host_mapnode(self):
     """Suppression des mapnodes d'un host supprimé (#57)"""
     # Mettre localhost sur une carte
     h = fct.add_host(u"localhost")
     testmap = fct.add_map(u"Test map")
     fct.add_node_host(h, "localhost", testmap)
     DBSession.flush()
     DBSession.delete(h)
     DBSession.flush()
     # On vérifie que la suppression de l'hôte a bien supprimé ses
     # représentations cartographiques
     mn_count = DBSession.query(tables.MapNode).count()
     self.assertEquals(mn_count, 0)
     mnh_count = DBSession.query(tables.MapNodeHost).count()
     self.assertEquals(mnh_count, 0)

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import delete [as 别名]
    def test_remove_permission_single(self):
        """Retrait de permission sur un seul groupe."""
        # Permettra de tester une tentative de suppression
        # sur le group3, en ignorant l'accès actuel.
        permissions = commands._permissions.copy()
        permissions[None] = None
        for incode in commands._permissions:
            print "Test permission %s" % incode
            self._set_permissions()
            if incode == "ro":
                group = self._group1
            else:
                group = self._group3

            options = NamespaceStub(
                permission=incode,
                object_type=self._type,
                usergroup=self._usergroup.group_name.encode('utf-8'),
                object_group=group.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_remove(options)
            self.assertEquals(res, 0)

            # On doit avoir 7 permissions en base :
            # les 8 de départ - 1 permission supprimée.
            dataperms = DBSession.query(tables.DataPermission).all()
            self.assertEquals(7, len(dataperms))

            # On vérifie que la permission qu'on voulait supprimer
            # a effectivement été supprimée.
            dataperm = DBSession.query(tables.DataPermission
                ).filter(tables.DataPermission.idgroup == group.idgroup
                ).filter(tables.DataPermission.idusergroup ==
                    self._usergroup.idgroup
                ).first()
            self.assertEquals(None, dataperm)

            # Suppression des permissions pour le test
            # du type de permission suivant.
            for dataperm in DBSession.query(tables.DataPermission).all():
                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 delete [as 别名]
 def test_hls_mapnode(self):
     """Suppression des mapnodes d'un hls supprimé (#57)"""
     # Mettre localhost sur une carte
     fct.add_host(u"localhost")
     s = fct.add_highlevelservice("testservice")
     testmap = fct.add_map(u"Test map")
     fct.add_node_hls(s, "testservice", testmap)
     DBSession.flush()
     DBSession.delete(s)
     DBSession.flush()
     # On vérifie que la suppression du hls a bien supprimé ses
     # représentations cartographiques
     mn_count = DBSession.query(tables.MapNode).count()
     self.assertEquals(mn_count, 0)
     mns_count = DBSession.query(tables.MapNodeService).count()
     self.assertEquals(mns_count, 0)
     mnlls_count = DBSession.query(tables.MapNodeHls).count()
     self.assertEquals(mnlls_count, 0)

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import delete [as 别名]
    def test_conffile(self):
        """Suppression des mapnodes d'un hôte d'un conffile"""
        # Mettre localhost sur une carte
        conffile = tables.ConfFile.get_or_create("/tmp/test_file")
        h = fct.add_host(u"localhost", conffile=conffile)
        testmap = fct.add_map(u"Test map")
        fct.add_node_host(h, "localhost", testmap)
        DBSession.flush()

        DBSession.delete(conffile)
        DBSession.flush()

        # On vérifie que la suppression du fichier de configuration
        # de l'hôte a bien supprimé les représentations cartographiques.
        mn_count = DBSession.query(tables.MapNode).count()
        self.assertEquals(mn_count, 0)
        mnh_count = DBSession.query(tables.MapNodeHost).count()
        self.assertEquals(mnh_count, 0)

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import delete [as 别名]
    def test_remove_multiple_batch(self):
        """Retrait de permissions sur plusieurs groupes en mode batch."""
        # Permettra de tester une tentative de suppression
        # de toutes les permissions, quelle que soit le type.
        permissions = commands._permissions.copy()
        permissions[None] = None
        for incode in permissions:
            print "Test permission %s" % incode
            self._set_permissions()
            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_remove(options)
            self.assertEquals(res, 0)

            dataperms = DBSession.query(tables.DataPermission).all()

            if incode is None:
                # Les 4 permissions de l'utilisateur
                # doivent avoir été supprimées.
                # Il reste donc 8-4 permissions en base.
                self.assertEquals(4, len(dataperms))
            else:
                # 2 permissions de l'utilisateur doivent avoir été supprimées.
                # Il en reste donc 8-2 en base.
                self.assertEquals(6, len(dataperms))

            # 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 delete [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 delete [as 别名]
    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])

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import delete [as 别名]
    def cleanup(self):
        # Presque rien à faire ici : la fin du load_conf se charge déjà
        # de supprimer les instances de ConfFile retirées du SVN,
        # ce qui a pour effet de supprimer les hôtes associés.
        # Elle supprime aussi les hôtes qui n'ont pas de fichier
        # attaché (résidus laissés lors de la migration vers ConfFile).
        # Il reste uniquement à vérifier qu'on a pas encore en base des
        # fichiers qui auraient disparu du disque (modif SVN manuelle par
        # exemple)
        LOGGER.debug("Checking for leftover ConfFiles")
        for conffilename in self.conffiles:
            # self.conffiles indexe les objets par leur ID, mais aussi
            # pas leur nom de fichier, on ne s'intéresse qu'à ces derniers.
            if not isinstance(conffilename, basestring):
                continue

            filename = os.path.join(settings["vigiconf"].get("confdir"),
                                    conffilename)
            if not os.path.exists(filename):
                LOGGER.warning(_("Deleting leftover config file from "
                                 "database: %s"), conffilename)
                DBSession.delete(self.conffiles[conffilename])
        DBSession.flush()

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import delete [as 别名]
    def test_remove_multiple_error(self):
        """Pas de retrait de permissions sur plusieurs groupes par défaut."""
        # Permettra de tester une tentative de suppression
        # de toutes les permissions, quelle que soit le type.
        permissions = commands._permissions.copy()
        permissions[None] = None
        for incode in permissions:
            print "Test permission %r" % (incode, )
            self._set_permissions()

            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=False,
                update=False,
                commit=False,   # la base de test est en mémoire,
                                # en la committant, on perdrait tout.
            )

            # La commande a été rejetée.
            res = commands.cmd_remove(options)
            self.assertNotEquals(res, 0)

            # Aucune permission n'a été retirée.
            dataperms = DBSession.query(tables.DataPermission).all()
            self.assertEquals(8, len(dataperms))

            # Suppression des permissions pour le test
            # du type de permission suivant.
            for dataperm in DBSession.query(tables.DataPermission).all():
                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 delete [as 别名]

#.........这里部分代码省略.........
            # services
            LOGGER.debug("Loading services for host %s", hostname)
            service_loader = ServiceLoader(host)
            service_loader.load()

            # directives Nagios de l'hôte
            LOGGER.debug("Loading nagios conf for host %s", hostname)
            nagiosconf_loader = NagiosConfLoader(host,
                                    hostdata['nagiosDirectives'])
            nagiosconf_loader.load()

            # données de performance
            LOGGER.debug("Loading perfdatasources for host %s", hostname)
            pds_loader = PDSLoader(host)
            pds_loader.load()

            # graphes
            LOGGER.debug("Loading graphs for host %s", hostname)
            graph_loader = GraphLoader(host, graphgroups)
            graph_loader.load()

        # Suppression des fichiers de configuration retirés du SVN
        # ainsi que de leurs hôtes (par CASCADE).
        LOGGER.debug("Cleaning up old hosts")
        removed = self.rev_mgr.get_removed()
        for filename in removed:
            relfilename = filename[len(settings["vigiconf"].get("confdir"))+1:]
            # Si un dossier est supprimé avec rm -rf, SVN ne signale que le
            # dossier, pas tous ses fichiers/sous-dossiers -> on doit utiliser
            # un LIKE pour les attrapper
            DBSession.query(ConfFile).filter(or_(
                    ConfFile.name == unicode(relfilename),
                    ConfFile.name.like(unicode(relfilename) + u"/%")
                )).delete(synchronize_session='fetch')
        LOGGER.debug("Done cleaning up old hosts")

        # Ghostbusters
        # 1- Hosts qui n'ont plus de fichier de configuration.
        nb_ghosts = DBSession.query(
                SupItem.__table__
            ).filter(
                SupItem.__table__.c.idsupitem.in_(
                    DBSession.query(
                        Host.__table__.c.idhost
                    ).filter(Host.__table__.c.idconffile == None)
                )
            ).delete(synchronize_session=False)
        LOGGER.debug("Deleted %d ghosts [Host]", nb_ghosts)


        # 2a- SupItems censés être des hôtes, mais qui n'ont pas d'entrée
        #     dans la table Host.
        nb_ghosts = DBSession.query(
                SupItem.__table__
            ).filter(
                SupItem.__table__.c.idsupitem.in_(
                    DBSession.query(
                        SupItem.idsupitem
                    ).outerjoin(
                        (Host.__table__,
                            Host.__table__.c.idhost ==
                            SupItem.__table__.c.idsupitem)
                    ).filter(
                        SupItem.__table__.c.itemtype ==
                            Host.__mapper_args__['polymorphic_identity']
                    ).filter(Host.__table__.c.idhost == None)

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import delete [as 别名]
 def delete(self, instance): # pylint: disable-msg=R0201
     LOGGER.debug("Deleting: %s", instance)
     DBSession.delete(instance)