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)

    def test_purge_zero_days(self):
        """Purge des événements sans limite d'âge."""
        # On veut fermer les événements corrélés qui sont dans l'état OK,
        # quelque soit la date à laquelle ils ont été créés.
        options = Options(days=0, size=None)
        clean_vigiboard(LOGGER, options, None)

        # Les 2 entrées d'historique pour un HLS
        # doivent avoir été supprimées.
        self.assertEquals(0, DBSession.query(tables.HLSHistory).count())

        # On s'assure que le CorrEvent et l'événement sur localhost2
        # âgés de 2j ont bien été supprimés.
        supitem = tables.Host.by_host_name(u'localhost2')
        event = DBSession.query(tables.Event).filter(
            tables.Event.idsupitem == supitem.idsupitem).first()
        self.assertEquals(None, event) # sans Event, pas de CorrEvent possible.

        # Les autres doivent toujours être dans l'état "fermé".
        others = DBSession.query(tables.CorrEvent).all()

        self.assertNotEquals(0, len(others))
        for other in others:
            # Contourne le problème du support incomplet des contraintes
            # référentielles de type ON DELETE CASCADE dans SQLite.
            if other.cause is None:
                continue

            self.assertEquals(
                other.ack,
                tables.CorrEvent.ACK_NONE,
                "L'événement corrélé sur %s devrait être 'nouveau'" %
                    other.cause.supitem
            )

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

 def test_insert_old_state(self):
     """Abandon de l'insertion d'un état ancien"""
     self.make_dependencies()
     ts_old = 1239104006
     ts_recent = 1239104042
     ts_recent_dt = datetime.fromtimestamp(ts_recent)
     idsupitem = SupItem.get_supitem("server.example.com", "Load")
     # Insertion de l'état récent
     state = DBSession.query(State).get(idsupitem)
     state.timestamp = ts_recent_dt
     # Création d'un message d'événement portant sur un SBN.
     info_dictionary = {
             "type": "event",
             "timestamp": datetime.fromtimestamp(ts_old),
             "host": "server.example.com",
             "service": "Load",
             "state": "WARNING",
             "message": "WARNING: Load average is above 4 (4.5)",
             }
     info_dictionary['idsupitem'] = SupItem.get_supitem(
         info_dictionary['host'],
         info_dictionary['service']
     )
     # Insertion de l'ancien événement dans la BDD
     result = insert_state(info_dictionary)
     self.assertTrue(isinstance(result, OldStateReceived))
     supitem = DBSession.query(SupItem).get(idsupitem)
     self.assertEqual(supitem.state.timestamp, ts_recent_dt)

    def test_pagination(self):
        """ Pagination du tri """

        # On crée autant d'événements qu'on peut en afficher par page + 1,
        # afin d'avoir 2 pages dans le bac à événements.
        host3 = functions.add_host(u'host3')
        service3 = functions.add_lowlevelservice(
                            host3, u'service3')
        DBSession.flush()
        items_per_page = int(config['vigiboard_items_per_page'])
        for i in xrange(items_per_page - 1):
            event = functions.add_event(service3, u'WARNING', u'foo')
            functions.add_correvent([event])
            DBSession.flush()
        transaction.commit()

        # On affiche la seconde page de VigiBoard avec
        # un tri par ordre décroissant sur le nom d'hôte
        environ = {'REMOTE_USER': 'manager'}
        response = self.app.get(
            '/?page=2&sort=hostname&order=desc', extra_environ=environ)

        # Il ne doit y avoir qu'une seule ligne de
        # résultats concernant "service2" sur "host1"
        hostnames = response.lxml.xpath(
            '//table[@class="vigitable"]/tbody/tr/' \
            'td[@class="plugin_hostname"]/text()')
        assert_equal(hostnames, ['host1'])
        servicenames = response.lxml.xpath(
            '//table[@class="vigitable"]/tbody/tr/' \
            'td[@class="plugin_servicename"]/text()')
        assert_equal(servicenames, ['service2'])

    def test_get_graph_groups_when_not_allowed(self):
        """
        Récupération des groupes de graphes sans les bons droits
        """

        # Récupération de l'hôte 'host1' dans la base de données
        host1 = DBSession.query(Host).filter(
            Host.name == u'host1 éà').first()

        # Récupération de l'hôte 'host3' dans la base de données
        host3 = DBSession.query(Host).filter(
            Host.name == u'host3 éà').first()

        # Récupération des groupes de graphes de l'hôte
        # host1 accessibles à l'utilisateur 'user'
        response = self.app.post(
        '/rpc/graphtree?host_id=%s' % (host1.idhost, ), {
            }, extra_environ={'REMOTE_USER': 'user'})
        json = response.json

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

        # Récupération des groupes de graphes de l'hôte
        # host3 accessibles à l'utilisateur 'user'
        response = self.app.post(
        '/rpc/graphtree?host_id=%s' % (host3.idhost, ), {
            }, extra_environ={'REMOTE_USER': 'user'})
        json = response.json

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

        # Récupération des groupes de graphes de l'hôte
        # host1 accessibles à l'utilisateur 'visitor'
        response = self.app.post(
        '/rpc/graphtree?host_id=%s' % (host1.idhost, ), {
            }, extra_environ={'REMOTE_USER': 'visitor'})
        json = response.json

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