Python DBSession.flush方法代码示例

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import flush [as 别名]
def add_event(supitem, statename, message, timestamp=None):
    """
    Ajoute un événement

    @param supitem: ID ou instance du supitem
    @type  supitem: C{int} ou sous-classe de L{tables.SupItem}
    @param statename: Nouvel état
    @type  statename: C{basestr}
    @param message: Message associé au nouvel état.
    @type  message: C{basestr}
    @param timestamp: timestamp de l'événement (par défaut: maintenant)
    @type  timestamp: C{datetime.datetime.DateTime}
    """
    if isinstance(supitem, int):
        idsupitem = supitem
    elif isinstance(supitem, tables.Host):
        idsupitem = supitem.idhost
    elif isinstance(supitem, tables.service.Service):
        idsupitem = supitem.idservice
    elif isinstance(supitem, tables.SupItem):
        idsupitem = supitem.idsupitem
    if timestamp is None:
        timestamp = datetime.now()
    e = tables.Event(
                idsupitem=idsupitem,
                current_state=tables.StateName.statename_to_value(statename),
                timestamp=timestamp,
                message=unicode(message),
                )
    e = DBSession.merge(e)
    DBSession.flush()
    return e

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import flush [as 别名]
def add_host_state(host, statename, message=None, timestamp=None):
    """
    Met à jour l'état d'un hôte

    @param host: Nom, ID, ou instance de l'hôte.
    @type  host: C{str} ou C{int} ou L{tables.Host}
    @param statename: Nouvel état de l'hôte.
    @type  statename: C{basestr}
    @param message: Message associé au nouvel état.
    @type  message: C{basestr}
    """
    if isinstance(host, int):
        idhost = host
    elif isinstance(host, basestring):
        idhost = tables.Host.by_name(host).idhost
    else:
        idhost = host.idhost
    if timestamp is None:
        timestamp = datetime.now()
    s = tables.State(idsupitem=idhost,
                    state=tables.StateName.statename_to_value(statename),
                    message=unicode(message),
                    timestamp=timestamp,
                    )
    s = DBSession.merge(s)
    DBSession.flush()
    return s

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import flush [as 别名]
def add_svc_state(service, statename, message=None, timestamp=None):
    """
    Met à jour l'état d'un service (bas niveau ou haut niveau).

    @param service: Si c'est un tuple (hôte, service), on cherche un service de
        bas niveau. Si c'est une chaîne on cherche un service de haut niveau.
        Si c'est une instance on l'utilise telle quelle.
    @type  service: C{tuple} ou C{str} ou L{tables.LowLevelService} ou
        L{tables.HighLevelService}
    @param statename: Nouvel état du service.
    @type  statename: C{basestr}
    @param message: Message associé au nouvel état.
    @type  message: C{basestr}
    """
    if isinstance(service, tuple):
        service = [ unicode(s) for s in service ]
        service = tables.LowLevelService.by_host_service_name(*service)
    elif isinstance(service, basestring):
        service = tables.HighLevelService.by_service_name(service)
    if timestamp is None:
        timestamp = datetime.now()
    s = tables.State(idsupitem=service.idservice,
                    state=tables.StateName.statename_to_value(statename),
                    message=unicode(message),
                    timestamp=timestamp,
                    )
    s = DBSession.merge(s)
    DBSession.flush()
    return s

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import flush [as 别名]
def add_ventilation(host, server, application):
    """
    Ventile un hôte sur un serveur de supervision
    pour une application donnée.

    @param host: Hôte supervisé à ventiler.
    @type host: C{basestr} ou L{tables.Host}
    @param server: Serveur de supervision sur lequel ventiler.
    @type server: C{basestr} ou L{tables.VigiloServer}
    @param application: Application sur laquelle porte la ventilation.
    @type application: C{basestr} ou L{tables.Application}
    @return: Instance de ventilation créée.
        Cette fonction lèvera une exception si l'hôte est déjà ventilé
        sur un serveur de supervision pour l'application donnée.
    @rtype: L{tables.Ventilation}
    """
    if isinstance(host, basestring):
        host = tables.Host.by_host_name(unicode(host))
    if isinstance(server, basestring):
        server = tables.VigiloServer.by_vigiloserver_name(unicode(server))
    if isinstance(application, basestring):
        application = tables.Application.by_app_name(unicode(application))
    v = tables.Ventilation(
            idhost=host.idhost,
            idvigiloserver=server.idvigiloserver,
            idapp=application.idapp
        )
    DBSession.merge(v)
    DBSession.flush()
    return v

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import flush [as 别名]
def add_mapsegment(from_node, to_node, map):
    """
    Ajoute un segment entre deux éléments d'une carte.

    @param from_node: Nœud de départ du segment.
    @type from_node: L{tables.MapNode} ou C{basestring}
    @param to_node: Nœud d'arrivée du segment.
    @type to_node: L{tables.MapNode} ou C{basestring}
    @param map: Carte sur laquelle le segment doit être ajouté.
    @type map: L{tables.Map}
    @return: Le segment nouvellement créé.
    @rtype: L{tables.MapSegment}
    """
    if isinstance(from_node, basestring):
        from_node = tables.MapNode.by_map_label(map, unicode(from_node))
    if isinstance(to_node, basestring):
        to_node = tables.MapNode.by_map_label(map, unicode(to_node))
    ms = tables.MapSegment(idfrom_node=from_node.idmapnode,
                           idto_node=to_node.idmapnode,
                           idmap=map.idmap,
                           color=u'#000000',
                           thickness=2)
    DBSession.merge(ms)
    DBSession.flush()
    return ms

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import flush [as 别名]
 def test_status_no_change(self):
     """RevMan: statut sans changement"""
     DBSession.add(tables.Version(name=RevisionManager.version_key, version=1))
     DBSession.flush()
     status = self.rev_mgr.status()
     expected = {"added": [], "removed": [], "modified": []}
     self.assertEqual(status, expected)

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import flush [as 别名]
def setup_db():
    """Crée toutes les tables du modèle dans la BDD."""
    #tmpdir = tempfile.mkdtemp(prefix="tests-vigiconf-")
    #settings["database"]["sqlalchemy_url"] = "sqlite:///%s/vigilo.db" % tmpdir
    transaction.abort()

    # La vue GroupPath dépend de Group et GroupHierarchy.
    # SQLAlchemy ne peut pas détecter correctement la dépendance.
    # On crée le schéma en 2 fois pour contourner ce problème.
    # Idem pour la vue UserSupItem (6 dépendances).
    from vigilo.models.tables.grouppath import GroupPath
    from vigilo.models.tables.usersupitem import UserSupItem
    mapped_tables = metadata.tables.copy()
    del mapped_tables[GroupPath.__tablename__]
    del mapped_tables[UserSupItem.__tablename__]
    metadata.create_all(tables=mapped_tables.itervalues())
    metadata.create_all(tables=[GroupPath.__table__, UserSupItem.__table__])

    DBSession.add(StateName(statename=u'OK', order=1))
    DBSession.add(StateName(statename=u'UNKNOWN', order=2))
    DBSession.add(StateName(statename=u'WARNING', order=3))
    DBSession.add(StateName(statename=u'CRITICAL', order=4))
    DBSession.add(StateName(statename=u'UP', order=1))
    DBSession.add(StateName(statename=u'UNREACHABLE', order=2))
    DBSession.add(StateName(statename=u'DOWN', order=4))
    MapGroup(name=u'Root')
    DBSession.flush()

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import flush [as 别名]
def populate_db(bind):
    from vigilo.models.session import DBSession
    from vigilo.models import tables

    permissions = {
        'vigiboard-access':
            'Gives access to VigiBoard',

        'vigiboard-update':
            'Allows users to update events',

        'vigiboard-admin':
            'Allows users to forcefully close open events',

        'vigiboard-silence':
            'Allows users to view and edit silence rules',
    }

    for (permission_name, description) in permissions.iteritems():
        if not tables.Permission.by_permission_name(unicode(permission_name)):
            DBSession.add(tables.Permission(
                permission_name=unicode(permission_name),
                description=unicode(description),
            ))
    DBSession.flush()

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import flush [as 别名]
 def test_get_maps_limit(self):
     """La fonction get_maps doit récupérer les cartes du groupe"""
     titles = [ u"test_map_%d" % i for i in range(10) ]
     for title in titles:
         add_map(title, self.obj)
     DBSession.flush()
     assert_equal(5, len(self.obj.get_maps(limit=5)))

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

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import flush [as 别名]
    def test_search_service_when_allowed_by_service(self):
        """
        Teste la recherche par service avec des droits explicites
        (droits accordés car l'utilisateur a explicitement les droits
        sur ce service).
        """
        # On crée un service avec une alerte.
        # Le service est rattaché à un groupe de services
        # pour lesquel l'utilisateur a les permissions.
        servicegroup = insert_deps()[1]
        usergroup = UserGroup.by_group_name(u'users')
        DBSession.add(DataPermission(
            group=servicegroup,
            usergroup=usergroup,
            access=u'r',
        ))
        DBSession.flush()
        transaction.commit()

        # On envoie une requête avec recherche sur le service créé,
        # on s'attend à recevoir 1 résultat.
        response = self.app.get('/?service=baz',
            extra_environ={'REMOTE_USER': 'user'})

        # Il doit y avoir 1 seule ligne de résultats.
        rows = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr')
        print "There are %d rows in the result set" % len(rows)
        assert_equal(len(rows), 1)

        # Il doit y avoir plusieurs colonnes dans la ligne de résultats.
        cols = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr/td')
        print "There are %d columns in the result set" % len(cols)
        assert_true(len(cols) > 1)

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import flush [as 别名]
    def setUp(self):
        super(TestDetailsPlugin, self).setUp()
        perm = Permission.by_permission_name(u'vigiboard-access')

        user = User(
            user_name=u'access',
            fullname=u'',
            email=u'[email protected]',
        )
        usergroup = UserGroup(group_name=u'users_with_access')
        usergroup.permissions.append(perm)
        user.usergroups.append(usergroup)
        DBSession.add(user)
        DBSession.add(usergroup)
        DBSession.flush()

        user = User(
            user_name=u'no_access',
            fullname=u'',
            email=u'[email protected]',
        )
        usergroup = UserGroup(group_name=u'users_without_access')
        usergroup.permissions.append(perm)
        user.usergroups.append(usergroup)
        DBSession.add(user)
        DBSession.add(usergroup)
        DBSession.flush()

        transaction.commit()

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