/ - Diff - Vigigraph - UNITY 360

Revision 454df3f9

ID	454df3f915f79d80908352ce4711b3cc2181aad6
Parent	16a7bac7
Child	e4b8d982

Added by Francois POIROTTE over 14 years ago

Correction de VigiGraph suite aux changements dans le modèle (r2606)
et aux corrections dans RRDGraph (r2622).
Suppression de fichiers obsolètes.

git-svn-id: https://vigilo-dev.si.c-s.fr/svn@2630 b22e2e97-25c9-44ff-b637-2e5ceca36478

     [app:main]
     use = egg:vigigraph
     ;db_basename=vigilo_
     db_basename=
     ;password_hashing_function=md5
     db_basename=vigilo_
     ;db_basename=
     password_hashing_function=md5
     lang=fr
     use_kerberos=False
     app.vigicore = /
-...
     # Vigigraph - refresh for graphs (en millisecondes)
     delay_refresh = 30000
     # separateurs pour export CSV
     # - entre valeurs consecutives
     export_csv_sep_values = ;
     # - dans une valeur
     export_csv_sep_value = ,
     full_stack = true
     cache_dir = %(here)s/data
     beaker.session.key = vigigraph

           var gl = new qx.ui.layout.GridLayout;
           gl.setDimension("auto", "auto");
           gl.setColumnCount(4);
           gl.setRowCount(6);			//Number of rows in the main window
           gl.setRowCount(5);			//Number of rows in the main window
           gl.setVerticalSpacing(4);
           gl.setHorizontalSpacing(2);
-...
           gl.setRowHeight(2, 20);
           gl.setRowHeight(3, 20);
           gl.setRowHeight(4, 20);
           gl.setRowHeight(5, 20);
           gl.add(new qx.ui.basic.Label(this.tr("Main Group")), 0, 0);
           gl.add(new qx.ui.basic.Label(this.tr("Host Group")), 0, 1);
-...
           b5.setToolTip(new qx.ui.popup.ToolTip(this.tr("Show graph")));
           b5.setEnabled(false);
           var bp=new qx.ui.form.Button("","icon/16/actions/document-print.png");
           bp.setToolTip(new qx.ui.popup.ToolTip(this.tr("Print Graph(s)")));
           bp.setEnabled(true);
           gl.add(r1,2,0);
           gl.add(r2,2,1);
           gl.add(r3,2,2);
-...
           gl.add(b3,3,2);
           gl.add(b5,3,4);
           gl.add(bp,3,5);
           _updateServerGroupList();
           var w2 = undefined;
-...
+          }
           // Buttons
           bp.addEventListener("execute",function(e) {
           bp = document.getElementById('print');
           /// @XXX le addEventListener est ici celui du DOM (pas celui de qooxdoo)
           /// Il faudrait migrer vers mootools et reprendre ce code pour assurer
           /// la compatibilité avec les navigateurs n'ayant pas addEventListener
           /// (ie: Internet Explorer).
           bp.addEventListener("click",function(e) {
             var nb = document.images.length;
             // liste src
-...
                 tempoFire(wDelay);
+              }
+            }
           });
             e.stopPropagation();
             e.preventDefault();
           }, true);
           b3.addEventListener("execute",function(e) {
             var win = new qx.client.NativeWindow(urls.supPage+"?host="+combo3.getSelected().getLabel());
-...
               var g=new qx.io.remote.Request(url,"GET","application/json");
               g.addEventListener("completed", function(e) {
                 r=e.getContent().items;
                 var host_main_group = r[0];
                 var host_sec_group = r[1];
                 /// @XXX pour le moment, on suppose qu'il y a 2 SupItemGroup
                 /// dans la réponse. A terme, on devrait pouvoir en avoir plus.
                 /// De même, on suppose qu'il n'y a qu'un seul GraphGroup à
                 /// sélectionner. Une évolution consisterait à en avoir plus.
                 var host_main_group = r[0][0];
                 var host_sec_group = r[0][1];
                 if (r.length < 3) {
                 if (!r[1].length) {
                   _chooseInCombos(host, host_main_group, host_sec_group, null, null);
+                }
                 else {
                   var srv_group = r[2];
                   _chooseInCombos(host, host_main_group, host_sec_group, graph, srv_group);
                   var graph_group = r[1][0];
                   _chooseInCombos(host, host_main_group, host_sec_group, graph, graph_group);
                   mainObj.openGraph(host, graph, null, null, true);
+                }
                 //qx.log.Logger.ROOT_LOGGER.debug(rowData);

     # vim: set fileencoding=utf-8 sw=4 ts=4 et :
     VIGILO_MODELS_BDD_BASENAME = ''
     VIGILO_SQLALCHEMY = {
         'url': 'sqlite:///:memory:',
+    }
     USE_KERBEROS = False
     VIGILO_ALL_DEFAULT_LANGUAGE = 'fr'

     # -*- coding: utf-8 -*-
     """Sample controller module"""
     # turbogears imports
     from tg import expose
     #from tg import redirect, validate, flash
     # third party imports
     #from pylons.i18n import ugettext as _
     #from repoze.what import predicates
     # project specific imports
     from vigigraph.lib.base import BaseController
     #from vigigraph.model import DBSession, metadata
     class SampleController(BaseController):
         #Uncomment this line if your controller requires an authenticated user
         #allow_only = authorize.not_anonymous()
         @expose('vigigraph.templates.index')
         def index(self):
             return dict(page='index')

     from vigigraph.lib.base import BaseController
     from vigilo.models.session import DBSession
     from vigilo.models.tables import Host, HostGroup
     from vigilo.models.tables import Service, ServiceGroup, LowLevelService
     from vigilo.models.tables import Service, LowLevelService, Host
     from vigilo.models.tables import SupItemGroup, GroupHierarchy
     from vigilo.models.tables import PerfDataSource
     from vigilo.models.tables import Graph, GraphGroup
     from vigilo.models.tables import Ventilation, VigiloServer, Application
     from vigilo.models.tables.secondary_tables import SERVICE_GROUP_TABLE
     from vigilo.models.tables.secondary_tables import HOST_GROUP_TABLE
     from vigilo.models.tables.secondary_tables import SUPITEM_GROUP_TABLE
     from vigilo.models.tables.secondary_tables import GRAPH_GROUP_TABLE
     from vigilo.models.tables.secondary_tables import GRAPH_PERFDATASOURCE_TABLE
     from vigilo.models.functions import sql_escape_like
-...
             @return: groupes principaux
             @rtype: document json (sous forme de dict)
             """
             topgroups = DBSession.query(HostGroup.name, HostGroup.idgroup) \
                     .filter(HostGroup.parent == None) \
                     .order_by(HostGroup.name) \
                     .all()
             topgroups = [(tpg.name, str(tpg.idgroup)) for tpg in topgroups]
             topgroups = [(tpg.name, str(tpg.idgroup)) \
                         for tpg in SupItemGroup.get_top_groups()]
             return dict(items=topgroups)
         @expose('json')
-...
             @return: groupes
             @rtype: document json (sous forme de dict)
             """
             hostgroups = DBSession.query(HostGroup.name, HostGroup.idgroup)\
                          .filter(HostGroup.idparent == maingroupid) \
                          .all()
             hostgroups = DBSession.query(
                     SupItemGroup.name,
                     SupItemGroup.idgroup,
                 ).join(
                     (GroupHierarchy, GroupHierarchy.idchild == \
                         SupItemGroup.idgroup),
                 ).filter(GroupHierarchy.idparent == maingroupid
                 ).filter(GroupHierarchy.hops == 1
                 ).order_by(
                     SupItemGroup.name.asc(),
                 ).all()
             hostgroups = [(hg.name, str(hg.idgroup)) for hg in hostgroups]
             return dict(items=hostgroups)
-...
             @return: hotes
             @rtype: document json (sous forme de dict)
             """
             hostgroup = DBSession.query(HostGroup) \
                     .filter(HostGroup.idgroup == othergroupid) \
                     .first()
             if hostgroup is not None:
                 hosts = [(h.name, str(h.idhost)) for h in hostgroup.hosts]
                 return dict(items=hosts)
             return dict(items=[])
             hosts = DBSession.query(
                     Host.name,
                     Host.idhost,
                 ).join(
                     (SUPITEM_GROUP_TABLE, SUPITEM_GROUP_TABLE.c.idsupitem == Host.idhost),
                     (SupItemGroup, SupItemGroup.idgroup == SUPITEM_GROUP_TABLE.c.idgroup),
                 ).filter(SupItemGroup.idgroup == othergroupid
                 ).order_by(
                     Host.name.asc(),
                 ).all()
             hosts = [(h.name, str(h.idhost)) for h in hosts]
             return dict(items=hosts)
         @expose('json')
         def graphgroups(self, idhost, nocache=None):
-...
                         PerfDataSource.idservice),
                 ).filter(
                     LowLevelService.idhost == idhost
                 ).all()
                 ).order_by(
                     GraphGroup.name.asc()
+                )
             print "@@@\n%s\n@@@" % graphgroups
             graphgroups = graphgroups.all()
             graphgroups = [(gg.name, str(gg.idgroup)) for gg in graphgroups]
             return dict(items=graphgroups)
-...
             graphs_l = DBSession.query(
                     Graph.name,
                     Graph.idgraph,
                 ).join(
                 ).distinct().join(
                     (GRAPH_GROUP_TABLE, GRAPH_GROUP_TABLE.c.idgraph == \
                         Graph.idgraph),
                     (GraphGroup, GraphGroup.idgroup == \
-...
                         PerfDataSource.idservice),
                 ).filter(GraphGroup.idgroup == idgraphgroup
                 ).filter(LowLevelService.idhost == idhost
                 ).all()
                 ).order_by(
                     Graph.name.asc()
+                )
             print "@@@\n%s\n@@@" % graphs_l
             graphs_l = graphs_l.all()
             graphs_l = [(pds.name, str(pds.idgraph)) for pds in graphs_l]
             return dict(items=graphs_l)
-...
                 items = DBSession.query(
                         Host.name.label('hostname'),
                         Graph.name.label('graphname'),
                     ).join(
                     ).distinct().join(
                         (LowLevelService, LowLevelService.idhost == Host.idhost),
                         (PerfDataSource, PerfDataSource.idservice == \
                             LowLevelService.idservice),
-...
             return dict(items=items)
         @expose('json')
         def selectHostAndService(self, **kwargs):
         def selectHostAndGraph(self, host=None, graph=None, nocache=None):
             """
             Determination (groupe principal-groupe-service) associe au couple (hote-service)
             Renvoie les valeurs à sélectionner dans les comboboxes
             de VigiGraph pour afficher les données de l'hôte ou du
             couple hôte/graphe sélectionné.
             @param kwargs : arguments nommes
             @type kwargs : dict
                              ( arguments nommes -> host et service )
             La clé "items" du dictionnaire renvoyé contient une liste avec
 éléments, chacun de ces éléments étant lui-même une liste.
             La 1ère liste contient les noms des groupes d'hôtes à sélectionner.
             La 2ème liste contient la liste des groupes de graphes à sélectionner.
             @return: (groupe principal-groupe-service)
             @rtype: document json (sous forme de dict)
             Pour le moment, la 2ème liste contiendra au plus 1 élément car
             les groupes de graphes ne sont pas récursifs. L'utilisation d'une
             liste permet d'assurer facilement une évolution vers des groupes
             de graphes récursifs.
             """
             host = kwargs.get('host')
             #service = kwargs.get('service')
             service = None
             groups = []
             services = None
             if host is not None:
                 hg1 = aliased(HostGroup)
                 hg2 = aliased(HostGroup)
                 sg =  aliased(ServiceGroup)
                 if service is not None:
                     for hg1_r, hg2_r, sg_r in \
                     DBSession.query(hg1, hg2, sg) \
                     .filter(hg1.parent == None) \
                     .filter(hg2.parent != None) \
                     .filter(HOST_GROUP_TABLE.c.idhost == Host.idhost) \
                     .filter(HOST_GROUP_TABLE.c.idgroup == hg2.idgroup) \
                     .filter(SERVICE_GROUP_TABLE.c.idservice == Service.idservice) \
                     .filter(SERVICE_GROUP_TABLE.c.idgroup == sg.idgroup) \
                     .filter(Host.idhost == LowLevelService.idhost) \
                     .filter(Service.idservice == LowLevelService.idservice) \
                     .filter(Host.name == host ) \
                     .filter(Service.servicename == service):
                         if hg1_r.idgroup == hg2_r.parent.idgroup:
                             groups.append(hg1_r.name)
                             groups.append(hg2_r.name)
                             groups.append(sg_r.name)
                             # 1 seul ensemble
                             break
                 else:
                     for hg1_r, hg2_r in \
                     DBSession.query(hg1, hg2) \
                     .filter(hg1.parent == None) \
                     .filter(hg2.parent != None) \
                     .filter(HOST_GROUP_TABLE.c.idhost == Host.idhost) \
                     .filter(HOST_GROUP_TABLE.c.idgroup == hg2.idgroup) \
                     .filter(Host.name == host ):
                         if hg1_r.idgroup == hg2_r.parent.idgroup:
                             groups.append(hg1_r.name)
                             groups.append(hg2_r.name)
                             # 1 seul ensemble
                             break
             if groups is not None and groups != []:
                 return dict(items=groups)
             else:
                 return dict(items=[])
             # Ce cas ne devrait pas se produire, mais on tente
             # d'avoir un comportement gracieux malgré tout.
             if (not host) and (not graph):
                 return dict(items=[[], []])
             # Groupe principal de l'hôte.
             mhg = aliased(SupItemGroup)
             # Groupe secondaire de l'hôte.
             shg = aliased(SupItemGroup)
             selected_hostgroups = []
             selected_graphgroups = []
             # @TODO: ajouter la gestion des permissions au code qui suit.
             # Pour le moment, la récupération de idsupitemgroup & idgraphgroup
             # ne prend pas en compte les permissions réelles de l'utilisateur.
             if host:
                 # Sélectionne l'identifiant du premier SupItemGroup auquel
                 # l'utilisateur a accès et auquel l'hôte donné appartient.
                 idsupitemgroup = DBSession.query(
                         SupItemGroup.idgroup,
                     ).join(
                         (SUPITEM_GROUP_TABLE, SUPITEM_GROUP_TABLE.c.idgroup == \
                             SupItemGroup.idgroup),
                         (Host, Host.idhost == SUPITEM_GROUP_TABLE.c.idsupitem),
                     ).filter(Host.name == host
                     ).scalar()
                 # Si on a trouvé un tel groupe, on renvoie les noms des
                 # groupes de la hiérarchie à sélectionner pour arriver
                 # à celui-ci.
                 if idsupitemgroup is not None:
                     selected_hostgroups = DBSession.query(
                             SupItemGroup.name,
                         ).join(
                             (GroupHierarchy, GroupHierarchy.idparent == \
                                 GraphGroup.idgroup),
                         ).filter(GroupHierarchy.idchild == idsupitemgroup
                         ).order_by(
                             GroupHierarchy.hops.desc()
                         ).all()
             if graph:
                 # Le principe est le même que pour l'hôte, en considérant
                 # cette fois les GraphGroup à la place des SupItemGroup.
                 idgraphgroup = DBSession.query(
                         GraphGroup.idgroup,
                     ).join(
                         (GRAPH_GROUP_TABLE, GRAPH_GROUP_TABLE.c.idgroup == \
                             GraphGroup.idgroup),
                         (Graph, Graph.idgraph == GRAPH_GROUP_TABLE.c.idgraph),
                     ).filter(Graph.name == graph
                     ).scalar()
                 # Même principe que pour l'hôte.
                 if idgraphgroup is not None:
                     selected_graphgroups = DBSession.query(
                             GraphGroup.name,
                         ).join(
                             (GroupHierarchy, GroupHierarchy.idparent == \
                                 GraphGroup.idgroup),
                         ).filter(GroupHierarchy.idchild == idgraphgroup
                         ).order_by(
                             GroupHierarchy.hops.desc()
                         ).all()
             hostgroups = [hg.name for hg in selected_hostgroups]
             graphgroups = [gg.name for gg in selected_graphgroups]
             return dict(items=[hostgroups, graphgroups])
         @expose(content_type='text/plain')
         def getImage(self, host, start=None, duration=86400, graph=None, \
-...
             """
             result = None
             b_export = False
             filename = None
             # separateurs
             sep_values = ";"
             sep_value = ","
             # indicateurs
             if indicator is None:
                 raise ValueError
             sep = config.get("export_csv_sep_values")
             if sep is not None:
                 sep_values = sep
             sep = config.get("export_csv_sep_value")
             if sep is not None:
                 sep_value = sep
             rrdserver = self.getRRDServer(host)
             if not rrdserver:
                 raise ValueError, host
             filename = None
             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:
                 # @TODO utiliser des dicos pour faciliter la traduction.
                 txt = _("Can't get RRD data on host \"%s\" "
                         "graph \"%s\" indicator \"%s\" ") % (host, graph, indicator)
                 LOGGER.error(txt)
                 error_url = '../error'
                 error_url += '/rrd_exportCSV_error'
                 error_url += '?host=%s&graph=%s&indicator=%s'
                 redirect(error_url % (host, graph, indicator))
             else:
                 response.headerlist.append(('Content-Disposition',
                     'attachment;filename=%s' % filename))
                 return result
             # indicateurs
             if indicator is not None:
                 dict_indicators = {}
                 indicators = self.getListIndicators(graph)
                 indicators_l = []
                 indicator_f = ''
                 if indicator == "All":
                     b_export = True
                     for i in range(len(indicators)):
                         indicators_l.append(indicators[i][0])
                     indicator_f = graph
                 else:
                     for i in range(len(indicators)):
                         if indicator == indicators[i][0]:
                             b_export = True
                             indicators_l.append(indicator)
                             indicator_f = indicator
                             break
                 if b_export:
                     # nom fichier
                     filename = graphs.getExportFileName(host, indicator_f, \
                     start, end)
                     idx = 0
                     dict_indicators[idx] = 'TimeStamp'
                     for i in range(len(indicators_l)):
                         idx += 1
                         dict_indicators[idx] = indicators_l[i]
                     rrdserver = self.getRRDServer(host)
                     if rrdserver is not None:
                         # url selon configuration
                         url_web_path = config.get('rrd_web_path')
                         url_l = '%s%s' % (rrdserver, url_web_path)
                         # donnees via proxy
                         rrdproxy = RRDProxy(url_l)
                         try:
                             result = rrdproxy.exportCSV(server=host, graph=graph, \
                                 indicator=indicator, start=start, end=end)
                         except urllib2.URLError:
                             b_export = False
                             txt = _("Can't get RRD data on host \"%s\" \
                                     graph \"%s\" indicator \"%s\" ") \
                             % (host, graph, indicator)
                             LOGGER.error(txt)
                             error_url = '../error'
                             error_url += '/rrd_exportCSV_error'
                             error_url += '?host=%s&graph=%s&indicator=%s'
                             redirect(error_url % (host, graph, indicator))
                         finally:
                             if b_export:
                                 # conversion sous forme de dictionnaire
                                 dict_values = {}
                                 if result is not None:
                                     if result != "{}":
                                         if result.startswith("{") and \
                                         result.endswith("}"):
                                             dict_values = eval(result)
                                 fieldnames = tuple([dict_indicators[k] \
                                 for k in dict_indicators])
                                 # fichier
                                 f = open(filename, 'wt')
                                 fn = 'attachment;filename=' + filename
                                 response.headerlist.append \
                                 (('Content-Disposition', fn))
                                 try:
                                     writer = csv.DictWriter(f, \
                                     fieldnames=fieldnames, delimiter=sep_values, \
                                     quoting=csv.QUOTE_ALL)
                                     # entête
                                     headers = dict( (n, n) for n in fieldnames )
                                     writer.writerow(headers)
                                     # generation fichier
                                     graphs.setExportFile(writer, dict_values, \
                                     dict_indicators, sep_value)
                                 finally:
                                     f.close()
                                 return open(filename, 'rt').read()
             if b_export == False:
                 return 'KO'
         # VIGILO_EXIG_VIGILO_PERF_0010:Visualisation globale des graphes
         @expose('fullhostpage.html')

Also available in: Unified diff

Project

General

Profile

Revision 454df3f9