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