Python session.DBSession类代码示例

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

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

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

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

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

    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))

    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)

 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()

 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)))

    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()

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)

    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

    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
            )

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()

    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)