# web_path

rrd_web_path = /rrdgraph

nagios_web_path = /nagios/cgi-bin

    "getImage": "/rpc/getImage",

    "getStartTime": "/rpc/getStartTime",

    "exportCSV": "/rpc/exportCSV"

        url= urls.getImage+"?host="+encodeURIComponent(host)+"&start="+start+"&duration="+duration+"&graph="+encodeURIComponent(graph);

        var i=new qx.io.remote.Request(url,"GET","text/plain");

        i.addEventListener("completed", function(e) { 

          img = e.getContent();

          if (img)

          {

            o.add(new qx.ui.basic.Image(e.getContent()));

          }

        });

        i.send();

        var url= urls.getStartTime+"?host="+encodeURIComponent(host);

          var url= urls.exportCSV+"?host="+encodeURIComponent(host)+"&graph="+graph+"&indicator="+indicator+"&start="+start+"&end="+end;

"POT-Creation-Date: 2010-04-16 16:43+0200\n"

#: source/class/vigigraph/Application.js:1047

#: source/class/vigigraph/Application.js:1076

#: source/class/vigigraph/Application.js:1105

"POT-Creation-Date: 2010-04-16 16:43+0200\n"

#: source/class/vigigraph/Application.js:1047

#: source/class/vigigraph/Application.js:1076

#: source/class/vigigraph/Application.js:1105

"POT-Creation-Date: 2010-04-16 16:43+0200\n"

#: source/class/vigigraph/Application.js:1047

#: source/class/vigigraph/Application.js:1076

#: source/class/vigigraph/Application.js:1105

from vigilo.turbogears.controllers.nagiosproxy \

    import make_nagios_proxy_controller

    All the other controllers and WSGI applications should be mounted on this

    controller. For example::

        panel = ControlPanelController()

        another_app = AnotherWSGIApplication()

    Keep in mind that WSGI applications shouldn't be mounted directly: They

    must be wrapped around with :class:`tg.controllers.WSGIAppController`.

    nagios = make_nagios_proxy_controller(BaseController, '/nagios/')

    @expose(content_type='text/plain')

    def getImage(self, host, start=None, duration=86400, graph=None, \

    details=1, nocache=0):

        """

        Determination de l url d un graphe

        (via proxy RRD)

        @param host : hôte

        @type host : C{str}

        @param start : date-heure de debut des donnees

        @type start : C{str}

        @param duration : plage de temps des données

        @type duration : C{str}

                         (parametre optionnel, initialise a 86400 = plage de 1 jour)

        @param details : indicateur affichage details dans graphe (legende)

        @type details : int

        @param graph : graphe

        @type graph : C{str}

        @return: url du graphe

        @rtype: C{str}

        """

        result = None

        if start is None:

            start = int(time.time()) - 24*3600

        # valeurs particulieres

        direct = 1

        rrdserver = self.getRRDServer(host)

        if rrdserver is not None:

            # url

            url_web_path = config.get('rrd_web_path')

            url_l = '%s%s' % (rrdserver, url_web_path)

            # proxy

            rrdproxy = RRDProxy(url_l)

            try:

                result = rrdproxy.get_img_name_with_params(host, graph, \

                direct, duration, start, int(details))

            except urllib2.URLError:

                txt = _("Can't get RRD graph \"%(graph)s\" on "

                        "host \"%(host)s\"") % {

                    'graph': graph,

                    'host': host,

                }

                LOGGER.error(txt)

                exceptions.HTTPNotFound(comment=txt)

        return result

    # VIGILO_EXIG_VIGILO_PERF_0020:Visualisation unitaire des graphes

    @expose(content_type='image/png')

    def getImage_png(self, host, start=None, duration=86400, graph=None, \

    details=1):

        """

        Affichage de l image d un graphe

        (via proxy RRD)

        @param host : hôte

        @type host : C{str}

        @param start : date-heure de debut des donnees

        @type start : C{str}

        @param duration : plage de temps des données

        @type duration : C{str}

                      (parametre optionnel, initialise a 86400 = plage de 1 jour)

        @param graph : graphe

        @type graph : C{str}

        @param details : indicateur affichage details dans graphe (legende)

        @type details : int

        @return: image du graphe

        @rtype: image png

        """

        result = None

        if start is None:

            start = int(time.time()) - 24*3600

        # valeurs particulieres

        direct = 1

        rrdserver = self.getRRDServer(host)

        if rrdserver is not None:

            # url

            url_web_path = config.get('rrd_web_path')

            url_l = '%s%s' % (rrdserver, url_web_path)

            # proxy

            rrdproxy = RRDProxy(url_l)

            try:

                result = rrdproxy.get_img_with_params(host, graph, direct, \

                duration, start, int(details))

            except urllib2.URLError:

                txt = _("Can't get RRD graph \"%(graph)s\" on "

                        "host \"%(host)s\"") % {

                    'graph': graph,

                    'host': host,

                }

                LOGGER.error(txt)

                exceptions.HTTPNotFound(comment=txt)

        return result

    @expose()

    def imagePage(self, server, graphtemplate):

        """

        Affichage de l image d un graphe

        @param server : hôte

        @type server : C{str}

        @param graphtemplate : graphe

        @type graphtemplate : C{str}

        @return: page avec l image du graphe (redirection sur getImage_png)

        @rtype: page

        """

        redirect('getImage_png?host=%s&graph=%s' % (server, graphtemplate))

    @expose()

    def getStartTime(self, host, nocache=None):

        """

        Determination de la date-heure de debut des donnees RRD d un hote

        (via proxy RRD)

        @param host : hôte

        @type host : C{str}

        @return: date-heure de debut des donnees RRD

        @rtype: C{str}

        """

        result = None

        getstarttime = 1

        rrdserver = self.getRRDServer(host)

        if rrdserver is not None:

            # url

            url_web_path = config.get('rrd_web_path')

            url_l = '%s%s' % (rrdserver, url_web_path)

            # proxy

            rrdproxy = RRDProxy(url_l)

            try:

                result = rrdproxy.get_starttime(host, getstarttime)

            except urllib2.URLError:

                txt = _("Can't get RRD data on host \"%s\"") % host

                LOGGER.error(txt)

                exceptions.HTTPNotFound(comment=txt)

        return result

    @expose()

    def metroPage(self, host):

        """

        Affichage page metrologie pour un hote

        (via proxy RRD)

        @param host : hôte

        @type host : C{str}

        @return: page de metrologie

        @rtype: page

        """

        result = None

        rrdserver = self.getRRDServer(host)

        if rrdserver is not None:

            # url

            url_web_path = config.get('rrd_web_path')

            url_l = '%s%s' % (rrdserver, url_web_path)

            # proxy

            rrdproxy = RRDProxy(url_l)

            try:

                result = rrdproxy.get_hostC(host)

            except urllib2.URLError:

                txt = _("Can't get RRD data on host \"%s\"") % host

                LOGGER.error(txt)

                error_url = '../error/rrd_error?host=%s' % host

                redirect(error_url)

        return result

    def getListIndicators(self, graph=None):

        """

        Liste d indicateurs associes a un graphe

        @param graph : graphe

        @type graph  : C{str}

        @return: liste d indicateurs

        @rtype  : list

        """

        indicators = []

        if graph is not None:

            indicators = DBSession.query \

              (PerfDataSource.name, PerfDataSource.idperfdatasource) \

              .join((GRAPH_PERFDATASOURCE_TABLE, \

              GRAPH_PERFDATASOURCE_TABLE.c.idperfdatasource == \

              PerfDataSource.idperfdatasource)) \

              .join((Graph, \

              Graph.idgraph == GRAPH_PERFDATASOURCE_TABLE.c.idgraph)) \

              .filter(Graph.name == graph) \

              .all()

        return indicators

    # VIGILO_EXIG_VIGILO_PERF_0040:Export des donnees d'un graphe au format CSV

    @expose(content_type='text/csv')

    def exportCSV(self, nocache=None, host=None, graph=None, indicator=None, \

    start=None, end=None):

        """

        Export CSV sous forme de fichier

        pour un hote et un graphe et pour l'indicateur suivant

        * soit un des indicateurs associes au graphe

        * soit l ensemble des indicateurs -> valeur argument = All

        @param host : hôte

        @type host : C{str}

        @param graph : graphe

        @type graph : C{str}

        @param indicator : indicateur graphe

        @type indicator : C{str}

        @param start : date-heure de debut des donnees

        @type start : C{str}

        @return: fichier genere avec les donnees RRD repondant aux criteres

        @rtype  : fichier CSV

        """

        result = None

        filename = None

        # indicateurs

        if indicator is None:

            raise ValueError

        rrdserver = self.getRRDServer(host)

        if not rrdserver:

            raise ValueError, host

        indicators = [ind[0] for ind in self.getListIndicators(graph)]

        if indicator != "All":

            if indicator not in indicators:

                raise ValueError, indicator

            indicators = [indicator]

            filename = graphs.getExportFileName(host, indicator, start, end)

        else:

            filename = graphs.getExportFileName(host, graph, start, end)

        indicators.insert(0, "Timestamp")

        url_web_path = config.get('rrd_web_path', '')

        url = '%s%s' % (rrdserver, url_web_path)

        rrdproxy = RRDProxy(url)

        try:

            result = rrdproxy.exportCSV(server=host, graph=graph, \

                indicator=indicator, start=start, end=end)

        except urllib2.URLError:

            txt = _("Can't get RRD data on host \"%(host)s\", "

                    "graph \"%(graph)s\" and indicator \"%(indicator)s\"") % {

                        'host': host,

                        'graph': graph,

                        'indicator': indicator,

                    }

            LOGGER.error(txt)

            error_url = '../error'

            error_url += '/rrd_exportCSV_error'

            error_url += '?host=%s&graph=%s&indicator=%s' % \

                (host, graph, indicator)

            redirect(error_url)

        else:

            response.headerlist.append(('Content-Disposition',

                'attachment;filename=%s' % filename))

            return result

    def getRRDServer(self, host=None):

        Determination Serveur RRD pour l hote courant

        (Serveur RRD -> nom de l application associee = rrdgraph)

        @param host : hôte

        @type host : C{str}

        @return: serveur RRD

        @rtype: C{str}

        result = DBSession.query(

                    VigiloServer.name

                ).filter(VigiloServer.idvigiloserver == \

                    Ventilation.idvigiloserver

                ).filter(Ventilation.idhost == Host.idhost

                ).filter(Ventilation.idapp == Application.idapp

                ).filter(Host.name == host

                ).filter(Application.name == 'rrdgraph'

                ).scalar()

        return result

from pylons.i18n import ugettext as _

        format = "%d-%m-%Y %H:%M"

            title = "Inconnu"

            graph['sts'] = _(strftime(format, gmtime(v)))

            graph['ets'] = _(strftime(format, gmtime(v)))

def getExportFileName(host, indicator_f, start, end):

    """

    Determination nom fichier pour export

    -> <hote>_<indicator_f>_<date_heure_debut>_<date_heure_fin>

    avec format <date_heure_...> = AAMMJJ-hhmmss

    @param host : hôte

    @type host : C{str}

    @param indicator_f : indicateur graphe ( nom du graphe ou d un des indicateurs)

    @type indicator_f : C{str}

    @param start : date-heure de debut des donnees

    @type start : C{str}

    @param end : duree des donnees

    @type end : C{str}

    @return: nom du fichier

    @rtype: C{str}

    """

    # plage temps sous forme texte

    format = '%Y%m%d-%H%M%S'

    dt = datetime.utcfromtimestamp(int(start))

    str_start = dt.strftime(format)

    dt = datetime.utcfromtimestamp(int(end))

    str_end = dt.strftime(format)

    # nom fichier

    filename = '%s_%s_%s_%s' % (host, indicator_f, str_start, str_end)

    # remplacement caracteres particuliers

    lc = [' ', '|', '/', '\\', ':', '?', '*', '<', '>', '"']

    for c in lc:

        filename = filename.replace(c, "_")

    # extension

    filename += ".csv"

    return filename

def setExportFile(writer, dict_values, dict_indicators, sep_value):

    """

    Ecriture des donnees sous forme texte dans le fichier d export

    (les donnees se rapportent aux indicateurs passes en parametre)

    @param writer : gestion csv pour lecture/ecriture

    @type writer : csv.DictWriter (voir Python)

    @param dict_values : valeurs

    @type dict_values : dict

    @param dict_indicators : indicateurs

    @type dict_indicators : dict

    @param sep_value : separateur partie entiere - partie decimale

    @type sep_value : C{str}

    @return: resultat generation (pas de valeurs -> false, sinon true)

    @rtype: booleen

    """

    # format pour valeur temps

    format = '%Y/%m/%d %H:%M:%S'

    result = (writer is not None)

    result &= (dict_values is not None or dict_values != "{}")

    if result:

        # parcours valeurs

        for key_tv in dict_values:

            tv = dict_values[key_tv]

            # generation ligne

            dict_data = {}

            for key_i in dict_indicators:

                iv = dict_indicators[key_i]

                v = str(tv[key_i])

                # temps sous forme texte

                if iv == 'TimeStamp':

                    dt = datetime.utcfromtimestamp(int(v))

                    v = dt.strftime(format)

                # separateur dans valeur -> remplacement . par ,

                v = v.replace(".", sep_value)

                dict_data[iv] = v

            writer.writerow(dict_data)

    return result