Python DBSession.add方法代码示例

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import add [as 别名]
def populate_DB():
    """ Peuple la base de données. """
    # On ajoute un groupe d'hôtes et un groupe de services.
    supitemmanagers = functions.add_supitemgroup(u'managersgroup')

    usergroup = UserGroup.by_group_name(u'users_with_access')
    DBSession.add(DataPermission(
        group=supitemmanagers,
        usergroup=usergroup,
        access=u'w',
    ))
    DBSession.flush()

    # On crée un 2 hôtes, et on les ajoute au groupe d'hôtes.
    host1 = functions.add_host(u'host1')
    host2 = functions.add_host(u'host2')
    supitemmanagers.supitems.append(host1)
    supitemmanagers.supitems.append(host2)
    DBSession.flush()

    # On crée 2 services de bas niveau, et on les ajoute au groupe de services.
    service1 = functions.add_lowlevelservice(host1, u'service1')
    service2 = functions.add_lowlevelservice(host2, u'service2')
    supitemmanagers.supitems.append(service1)
    supitemmanagers.supitems.append(service2)
    DBSession.flush()

    return ([host1, host2], [service1, service2])

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import add [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 add [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 add [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 add [as 别名]
    def test_get_root_group_when_not_allowed(self):
        """Récupération des groupes racines de l'arbre sans les droits"""
        # Récupération du groupe utilisé lors de ce test.
        SupItemGroup.by_group_name(u'root')

        # Création d'un nouvel utilisateur et d'un nouveau groupe
        usergroup = UserGroup(group_name=u'new_users')
        vigiboard_perm = Permission.by_permission_name(u'vigiboard-access')
        usergroup.permissions.append(vigiboard_perm)
        user = User(
            user_name=u'new_user',
            fullname=u'',
            email=u'[email protected]',
        )
        user.usergroups.append(usergroup)
        DBSession.add(user)
        DBSession.flush()
        transaction.commit()

        # L'utilisateur est authentifié mais n'a aucun accès. Il
        # cherche à obtenir la liste des groupes racines de l'arbre.
        response = self.app.get('/get_groups',
            extra_environ={'REMOTE_USER': 'new_user'})
        json = response.json

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

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import add [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 add [as 别名]
def populate_DB():
    """ Peuple la base de données. """
    # On ajoute un groupe d'hôtes et un groupe de services.
    supitemmanagers = SupItemGroup(name=u'managersgroup', parent=None)
    DBSession.add(supitemmanagers)
    DBSession.flush()

    usergroup = UserGroup.by_group_name(u'users_with_access')
    DBSession.add(DataPermission(
        group=supitemmanagers,
        usergroup=usergroup,
        access=u'r',
    ))
    DBSession.flush()

    # On crée un hôte de test, et on l'ajoute au groupe d'hôtes.
    managerhost = functions.add_host(u'managerhost')
    supitemmanagers.supitems.append(managerhost)
    DBSession.flush()

    # On crée un services de bas niveau, et on l'ajoute au groupe de services.
    managerservice = functions.add_lowlevelservice(
        managerhost, u'managerservice')
    supitemmanagers.supitems.append(managerservice)
    DBSession.flush()

    return (managerhost, managerservice)

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import add [as 别名]
    def test_get_supitemgroups(self):
        """Récupération des groupes d'éléments supervisés accessibles."""
        user = User(user_name=u'manager', email=u'', fullname=u'')
        DBSession.flush()

        usergroup = UserGroup(group_name=u'managers')
        usergroup.users.append(user)
        DBSession.flush()

        root = SupItemGroup(name=u'root', parent=None)
        DBSession.add(root)
        sub1 = SupItemGroup(name=u'sub1', parent=root)
        DBSession.add(sub1)
        sub2 = SupItemGroup(name=u'sub2', parent=root)
        DBSession.add(sub2)
        sub21 = SupItemGroup(name=u'sub21', parent=sub2)
        DBSession.add(sub21)
        DBSession.flush()

        dataperm = DataPermission(
            usergroup=usergroup,
            group=sub2,
            access=u'r',
        )
        DBSession.add(dataperm)
        DBSession.flush()

        eq_([
                (root.idgroup, False),
                (sub2.idgroup, True),
                (sub21.idgroup, True),
            ], user.supitemgroups())

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import add [as 别名]
    def test_cache(self):
        """Teste le cache des noms d'états."""
        row = DBSession.query(StateName).first()
        oldname = self.klass.value_to_statename(row.idstatename)
        row.statename = row.statename + u'_'
        DBSession.add(row)
        DBSession.flush()

        # On s'assure que le cache est bien utilisé :
        # ie. il renvoie l'ancien nom de l'état.
        currname = self.klass.value_to_statename(row.idstatename)
        assert_equals(oldname, currname)

        # De la même manière, le mapping inverse
        # fonctionne toujours avec l'ancien nom.
        assert_equals(
            row.idstatename,
            self.klass.statename_to_value(oldname)
        )

        # On provoque un rafraîchissement du cache.
        assert_equals(
            row.idstatename,
            self.klass.statename_to_value(row.statename)
        )

        try:
            self.klass.statename_to_value(oldname)
        except KeyError:
            # On s'attend à avoir une KeyError car l'ancien nom
            # n'existe plus (ni dans la base, ni dans le cache).
            pass
        except Exception, e:
            self.fail("Got an unexpected exception: %s (%s)" % (type(e), e))

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import add [as 别名]
def insert_hls_history(info_dictionary):
    """
    Insère le nouvel état du service de haut niveau dans HLSHistory
    afin de conserver une trace.

    @param info_dictionary: Dictionnaire contenant les informations
        extraites du message d'alerte reçu par le rule dispatcher.
    @type info_dictionary: C{dict}
    """

    if not info_dictionary['idsupitem']:
        LOGGER.error(_('Got a reference to a non configured high-level '
                        'service (%(service)r)'), {
                            "service": info_dictionary["service"],
                        })
        return None

    history = HLSHistory()
    history.idhls = info_dictionary['idsupitem']
    # On enregistre l'heure à laquelle le message a
    # été traité plutôt que le timestamp du message.
    history.timestamp = datetime.now()
    history.idstatename = StateName.statename_to_value(
                            info_dictionary['state'])
    DBSession.add(history)

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import add [as 别名]
def add_dependency(group, depended, distance=None):
    """
    Ajoute une dépendance à un groupe de dépendances.

    @param group: Groupe de dépendance (identifiant ou instance).
    @type group: C{int} or L{tables.DependencyGroup}
    @param depended: Élément à ajouter au groupe de dépendance,
        sous la forme d'un tuple (hôte, service) décrivant l'élément
        à ajouter.
    @type depended: C{tuple}
    """
    if isinstance(group, int):
        idgroup = group
    else:
        idgroup = group.idgroup

    if isinstance(depended, tables.SupItem):
        dependency = depended
    else:
        host, service = depended
        if host is None:        # HLS
            dependency = tables.HighLevelService.by_service_name(unicode(service))
        elif service is None:   # Host
            dependency = tables.Host.by_host_name(unicode(host))
        else:                   # LLS
            dependency = tables.LowLevelService.by_host_service_name(
                            unicode(host), unicode(service))

    DBSession.add(tables.Dependency(
        idgroup=idgroup,
        supitem=dependency,
        distance=distance,
    ))
    DBSession.flush()

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import add [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 add [as 别名]
 def db_commit(self):
     version_obj = Version.by_object_name(self.version_key)
     if version_obj is None:
         version_obj = Version(name=self.version_key)
     version_obj.version = self.deploy_revision
     DBSession.add(version_obj)
     DBSession.flush()

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import add [as 别名]
 def _add_permission(self, group, perm):
     print "group = %r, perm = %r" % (unicode(group).encode('utf-8'), perm)
     DBSession.add(tables.DataPermission(
         idgroup=group.idgroup,
         idusergroup=self._usergroup.idgroup,
         access=unicode(perm),
     ))
     DBSession.flush()

# 需要导入模块: from vigilo.models.session import DBSession [as 别名]
# 或者: from vigilo.models.session.DBSession import add [as 别名]
def add_graphgroup(name, parent=None):
    name = unicode(name)
    g = tables.GraphGroup.by_parent_and_name(parent, name)
    if not g:
        g = tables.GraphGroup(name=name, parent=parent)
        DBSession.add(g)
        DBSession.flush()
    return g