zephir.rapports.connecteur

Package zephir :: Package rapports :: Module connecteur |
[frames] | no frames]

# Source Code for Module zephir.rapports.connecteur

      1  # -*- coding: UTF-8 -*-
      2  ###########################################################################
      3  # Eole NG - 2007
      4  # Copyright Pole de Competence Eole  (Ministere Education - Academie Dijon)
      5  # Licence CeCill  cf /root/LicenceEole.txt
      6  # eole@ac-dijon.fr
      7  #
      8  # connecteur.py
      9  #
     10  # fonctions de connexion au backend Zephir pour création de rapports
     11  # les fonctions convert et backend sont les mêmes que pour le frontend
     12  #
     13  ###########################################################################
     14  import xmlrpclib
     15  from zephir.config import charset
     16
     17  # encodage et conversions en encodage local
     18  BACKEND_EXCEPTIONS = ['libpq.OperationalError','libpq.IntegrityError']
     19
     20 -class BackendError(Exception):
     21      """Gère les erreurs provenant du backend xml-rpc
     22      """
     23 -    def __init__(self, msg=None):
     24          """Définition du message d'erreur
     25          """
     26          txt = """<p>Erreur provenant du backend XML-RPC<br/>
     27          <a href="javascript:history.back()">retour</a><br/></p>"""
     28          if msg :
     29              txt2 = """<p><b>Détail</b> : %s </p>""" % msg
     30              self.msg = txt + txt2
     31          else :
     32              self.msg = txt
     33
     34 -    def __str__(self):
     35          return self.msg
     36
     37 -class DatabaseError(Exception):
     38      """Différencie une erreur backend simple
     39      d'un pb d'intégrité référentielle
     40      """
     41 -    def __init__(self, msg=None):
     42          txt = """Interdiction due à un problème d'intégrité référentielle dans la base de données
     43          """
     44          if msg:
     45              txt2 = """, dans la table : <b>""" + msg + "</b>"
     46              self.msg = txt + txt2
     47          else :
     48              self.msg = "<p>" + txt + "</p>"
     49
     50 -    def __str__(self):
     51          return self.msg
     52
     53 -def convert(objet):
     54      """Transforme les objets unicode contenus dans un objet en chaines
     55      """
     56      if type(objet) == list:
     57          l = []
     58          for item in objet:
     59              l.append(convert(item))
     60          return l
     61      if type(objet) == dict:
     62          dico={}
     63          for cle in objet.keys():
     64              dico[cle] = convert(objet[cle])
     65          return dico
     66      if type(objet) == unicode:
     67          string =  objet.encode(charset)
     68          return string
     69      return objet
     70
     71 -def backend(liste_backend):
     72      """Récupère les codes et les messages d'erreur système
     73      """
     74      # premier terme de la liste
     75      return_code = liste_backend[0]
     76      # le contenu à récupérer... si tout va bien
     77      # sinon, c'est une exception ou un message d'erreur
     78      retour = liste_backend[1]
     79      try:
     80          assert liste_backend[2]
     81          database_msg = liste_backend[2]
     82      except:
     83          database_msg = ""
     84
     85      if not return_code :
     86          # quelque chose close
     87          if retour in BACKEND_EXCEPTIONS :
     88              # extrait la table concernée du message d'erreur
     89              database_msg = database_msg.split("from")[1]
     90              raise DatabaseError(database_msg)
     91          else:
     92              # tout va mal
     93              raise BackendError()
     94      else :
     95          # tout va bien
     96          retour = convert(retour)
     97          return retour
     98
     99 -def tri_etab(x,y):
    100      if x[1].upper() > y[1].upper():
    101          return 1
    102      elif x[1].upper() == y[1].upper():
    103          return 0
    104      else:
    105          return -1
    106
    107 -class Nomenclature:
    108      """utilitaires de récupérations de dictionnaires clef-libellé (nomenclatures)
    109      """
    110
    111 -    def __init__(self, server, rne_rapport=None):
    112          self.server = server
    113          try:
    114              # récupération des données
    115              self.variante = backend(self.server.modules.get_variante())
    116              self.module_list = backend(self.server.modules.get_module())
    117              if rne_rapport != None:
    118                  self.etab_list = backend(self.server.etabs.get_etab(rne_rapport))
    119              else:
    120                  self.etab_list = backend(self.server.etabs.get_etab())
    121              self.types = backend(self.server.etabs.get_types())[0]
    122          except BackendError:
    123              raise BackendError, "erreur lors de la récupération des données"
    124
    125 -    def get_variante(self):
    126          """Dictionnaire clefs,libelle pour les variantes
    127          """
    128          libelle = {}
    129          for v in self.variante :
    130              libelle[v['id']] = xmlrpclib.escape(v['libelle'])
    131          return libelle
    132
    133 -    def get_variante_module(self,id_module):
    134          """Dictionnaire clefs, libelle pour les variantes d'un module considéré
    135          """
    136          libelle = {}
    137          for v in self.variante :
    138              if int(v['module']) == int(id_module) :
    139                  libelle[v['id']] = xmlrpclib.escape(v['libelle'])
    140          return libelle
    141
    142 -    def get_module(self):
    143          """Dictionnaire clef,libelle pour les modules
    144          """
    145          # construction du dico des libellés
    146          dico_libelle = {}
    147          for module in self.module_list :
    148              dico_libelle[module['id']] = xmlrpclib.escape(module['libelle'])
    149          return dico_libelle
    150
    151 -    def get_etab(self):
    152          """Dictionnaire clef,libelle pour les établissements
    153          """
    154          # construction du dico des libellés
    155          dico_libelle = {}
    156          for etab in self.etab_list :
    157              dico_libelle[etab['rne']] = xmlrpclib.escape(etab['libelle'])
    158          return dico_libelle
    159
    160 -    def get_types(self):
    161          """Types d'établissement
    162          """
    163          return self.types
    164
    165 -class Connecteur:
    166      """Gère les appels au backend
    167      """
    168 -    def __init__(self,server,rne_rapport=None):
    169          self.server = server #xmlrpclib.Server(ZEPHIR)
    170          self.nomenc=Nomenclature(self.server, rne_rapport)
    171          self.rne_rapport = rne_rapport
    172          try:
    173              if rne_rapport is not None:
    174                  self.liste_serveurs = backend(self.server.serveurs.groupe_serveur({'rne':rne_rapport}))
    175              else:
    176                  self.liste_serveurs = backend(self.server.serveurs.get_serveur())
    177              self.serv_etabs = {}
    178              self.etat_serv = {}
    179              for serveur in self.liste_serveurs:
    180                  # stockage de l'id du serveur dans l'etablissement correspondant
    181                  if self.serv_etabs.has_key(serveur["rne"]):
    182                      self.serv_etabs[serveur["rne"]].append(serveur['id'])
    183                  else:
    184                      self.serv_etabs[serveur["rne"]] = [serveur['id']]
    185                  # on récupère l'état du serveur
    186                  liste_etat = []
    187                  try:
    188                      try:
    189                          # le dictionnaire d'état est stocké sous forme de chaîne dans le champs params
    190                          etat2 = eval(serveur['params'])
    191                      except:
    192                          etat2 = backend(self.server.serveurs.get_status(serveur['id']))
    193                      if etat2['cle_ok'] == 1:
    194                          # serveur enregistré, on vérifie son état
    195                          for cle in etat2.keys():
    196                              etat = etat2[cle]
    197                              if type(etat) == list:
    198                                  if len(etat) == 3:
    199                                      if etat[0] == 0:
    200                                          liste_etat.append("erreur rapportée par zephir (cf. page d'état)")
    201                          try:
    202                              etat1 = int(serveur["status"])
    203                              if etat1 == 2:
    204                                  liste_etat.append("contact perdu avec le serveur")
    205                              if etat1 in [3,4]:
    206                                  liste_etat.append("file d'attente bloquée (problème uucp ou ssh)")
    207                              if etat1 in [0,4]:
    208                                  liste_etat.append("erreur reportée par le serveur (cf. page de surveillance)")
    209                          except:
    210                              liste_etat.append("pas de statistiques reçues")
    211                      else:
    212                          liste_etat.append("pas de serveur enregistré")
    213                  except:
    214                      pass
    215
    216                  self.etat_serv[serveur['id']] = liste_etat
    217
    218          except BackendError:
    219              raise BackendError, "erreur lors de la récupération des données"
    220
    221 -    def module(self, id_module=None):
    222          """Module ou liste de modules
    223          """
    224          if id_module:
    225              for module in self.nomenc.modules_list:
    226                  if int(module['id']) == int(id_module):
    227                      return module
    228          return self.nomenc.module_list
    229
    230 -    def dict_module(self):
    231          """Dictionnaire clef-libelle pour les modules
    232          """
    233          return self.nomenc.get_module()
    234
    235 -    def nom_module(self, id_module):
    236          """Libellé d'un module
    237          """
    238          dico_module = self.dict_module()
    239          return xmlrpclib.escape(dico_module[id_module])
    240          # return self.module(id_module)['libelle']
    241
    242 -    def get_variante(self,id_variante=None):
    243          """Variante d'un module
    244          """
    245          if id_variante:
    246              for variante in self.nomenc.variante:
    247                  if int(variante['id']) == int(id_variante):
    248                      return [variante]
    249          return self.nomenc.variante
    250
    251 -    def _dict_variante(self, id_module):
    252          """dictionnaire des variantes d'un module
    253          """
    254          return self.nomenc.get_variante_module(id_module)
    255
    256 -    def id_variante(self, id_module):
    257          """Liste des id des variantes d'un module
    258          """
    259          return self._dict_variante().keys()
    260
    261 -    def nom_variante(self, id_variante):
    262          """Libellé d'une variante
    263          """
    264          variante = self.nomenc.get_variante()
    265          return variante[id_variante]
    266
    267 -    def get_serveur(self, id_serveur=None):
    268          """Description d'un serveur
    269          """
    270          res={}
    271          if id_serveur:
    272              for serveur in self.liste_serveurs:
    273                  if int(serveur['id']) == int(id_serveur):
    274                      for cle in serveur.keys():
    275                          if cle != "libelle":
    276                              res[cle]=xmlrpclib.escape(serveur[cle])
    277                      return serveur
    278
    279 -    def nom_serveur(self, id_serveur):
    280          """Libellé d'un serveur
    281          """
    282          for serveur in self.liste_serveurs:
    283              if int(serveur['id']) == int(id_serveur):
    284                  return xmlrpclib.escape(serveur['libelle'])
    285
    286 -    def libelle_serveur_etab(self, rne):
    287          """Liste des libellés des serveurs d'un établissement
    288          """
    289          list = []
    290          for id in self.id_serveur_etab(rne):
    291              string = self.nom_serveur(id) + " (%s)" % id
    292              if self.etat_serv[id] != []:
    293                  string += xmlrpclib.escape(" : %s" % ", ".join(self.etat_serv[id]))
    294              list.append(string)
    295          else:
    296              etat = ""
    297
    298          return list
    299
    300 -    def id_serveur_etab(self, rne):
    301          """Liste des id des serveurs d'un établissement
    302          """
    303          if self.serv_etabs.has_key(rne):
    304              return self.serv_etabs[rne]
    305          else:
    306              return []
    307
    308 -    def get_etab(self,rne):
    309          """Détail d'un établissement
    310          """
    311          for etab in self.nomenc.etab_list:
    312              if etab['rne'].upper() == rne.upper():
    313                  # remplace le type d'etab par son libellé
    314                  etab['type'] = xmlrpclib.escape(self.nom_type(str(etab['type'])))
    315                  return etab
    316          return {}
    317
    318 -    def _dict_etab(self):
    319          """Nomenclature etab
    320          """
    321          return self.nomenc.get_etab()
    322
    323 -    def id_etab(self):
    324          """Liste des rne des etablissements
    325          """
    326          dico=self._dict_etab().items()
    327          dico.sort(tri_etab)
    328          liste=[]
    329          for rne in dico:
    330              liste.append(rne[0])
    331          return liste
    332
    333 -    def noms_etab(self):
    334          """liste des noms des etablissements
    335          """
    336          dico=self._dict_etab().items()
    337          dico.sort(tri_etab)
    338          liste=[]
    339          for rne in dico:
    340              liste.append(xmlrpclib.escape("%s (%s)" % (rne[1],rne[0])))
    341          return liste
    342          #return self._dict_etab().values()
    343
    344 -    def nom_etab(self, rne):
    345          """libellé d'un établissement
    346          """
    347          return xmlrpclib.escape(self._dict_etab()[rne])
    348
    349 -    def _dict_type(self):
    350          """Nomenclature des types d'etab
    351          """
    352          return self.nomenc.get_types()
    353
    354 -    def nom_type(self, type):
    355          """libelle d'un type d'etab
    356          """
    357          return xmlrpclib.escape(self._dict_type()[type])
    358
    359  # FIXME ce qu'il faut récupérer concernant les services :
    360  # la liste des services pour chaque module
    361
    362 -    def get_service(self, id_module):
    363          """Liste des services d'un module
    364          """
    365          return backend(self.server.services.get_service_module(id))
    366
    367  if __name__ == "__main__" :
    368      # print Connecteur().get_serveur(178)
    369      print Connecteur().module()
    370      # print Connecteur().services(39)
    371      # print Connecteur().service_module(13)
    372      # print Connecteur().get_variante_module(13)
    373      # print Connecteur().get_etab("qsd")
    374      # print Connecteur().nom_etab()
    375      # print Connecteur().nom_types()
    376      # print Connecteur().dict_module()
    377      # print Connecteur().nom_module(3)
    378      pass
    379