Package zephir :: Package backend :: Module dicos_rpc
[frames] | no frames]

Source Code for Module zephir.backend.dicos_rpc

  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  # ent_rpc.py 
  9  # 
 10  # fonctions xmlrpc pour la gestion des dictionnaires creole 
 11  # 
 12  ########################################################################### 
 13  """module de gestion des dictionnaires Creole 
 14  """ 
 15  from zephir.backend.db_utils import * 
 16  from zephir.backend import config 
 17  from zephir.backend.config import u, log 
 18  from zephir.backend.xmlrpceole import XMLRPCEole as XMLRPC 
 19  import traceback 
 20   
21 -class RPCDicos(XMLRPC):
22 """serveur XMLRPC zephir pour la gestion des dictionnaires Creole 23 """ 24
25 - def __init__(self, parent):
26 self.parent = parent 27 XMLRPC.__init__(self)
28 29 ########################################### 30 # gestion du pool de dictionnaires/paquets 31
32 - def _check_resource_perms(self, cred_user, eole_version, dict_name):
33 """vérifie qu'on a l'autorisation de modifier les ressources utilisant un dictionnaire local 34 """ 35 dict_resources = self.parent.dictpool.get_dict_resources(eole_version, 'local', dict_name) 36 # en cas de dictionnaire déjà utilisé par un module/variante, 37 # on vérifie les restrictions d'accès 38 if dict_resources['module']: 39 for id_mod in dict_resources['module']: 40 self.parent.s_pool.check_mod_credential(cred_user, id_mod) 41 elif dict_resources['variante']: 42 for id_var in dict_resources['variante']: 43 self.parent.s_pool.check_var_credential(cred_user, id_var) 44 # serveurs: vérification des droits d'accès 45 elif dict_resources['serveur']: 46 allowed_s = set([int(serv) for serv in self.parent.s_pool.get_allowed_servers(cred_user)]) 47 # on vérifie qu'on a bien accès à tous les serveurs affectés 48 assert set(dict_resources['serveur']).issubset(allowed_s), "Ce dictionnaire affecte un serveur auquel vous n'avez pas accès"
49
50 - def xmlrpc_get_dict(self, cred_user, eole_version, type_dict, dict_name, paq_name=""):
51 """renvoie le contenu d'un dictionnaire du pool 52 paq_name: nom du paquet pour les dictionnaires non isolés 53 """ 54 try: 55 result = self.parent.dictpool.get_dict(eole_version, type_dict, dict_name, paq_name) 56 except Exception, e: 57 return 0, u(str(e)) 58 return 1, u(result)
59
60 - def xmlrpc_add_dict(self, cred_user, eole_version, dict_name, content, paq_name=""):
61 """ajoute ou met à jour un dictionnaire dans le dépot. 62 paq_name: met le dictionnaire dans un répertoire de paquet 63 """ 64 try: 65 self._check_resource_perms(cred_user, eole_version, paq_name or dict_name) 66 # vérification passées, on ajoute/met à jour le dictionnaire 67 result = self.parent.dictpool.add_dict(eole_version, dict_name, content, paq_name) 68 except Exception, e: 69 return 0, u(str(e)) 70 return 1, u(result)
71
72 - def xmlrpc_remove_dict(self, cred_user, eole_version, dict_name, paq_name=""):
73 """supprime un dictionnaire/paquet du dépot (et les liens associés) 74 """ 75 try: 76 self._check_resource_perms(cred_user, eole_version, paq_name or dict_name) 77 # vérification passées, on supprime le dictionnaire 78 result = self.parent.dictpool.remove_dict(eole_version, dict_name, paq_name) 79 except Exception, e: 80 return 0, u(str(e)) 81 return 1, u(result)
82
83 - def xmlrpc_get_dict_resources(self, cred_user, eole_version, dict_type, dict_name):
84 """renvoie l'ensemble des ressources utilisant un dictionnaire ou paquet 85 """ 86 try: 87 resources = self.parent.dictpool.get_dict_resources(eole_version, dict_type, dict_name) 88 except Exception, e: 89 return 0, u(str(e)) 90 return 1, u(resources)
91 100
101 - def xmlrpc_get_paq_dict(self, cred_user, eole_version, liste_paqs):
102 """renvoie la liste des dictionnaires d'un paquet 103 """ 104 try: 105 liste_dicts = self.parent.dictpool.get_paq_dict(eole_version, liste_paqs) 106 except Exception, e: 107 return 0, u(str(e)) 108 return 1, u(liste_dicts)
109
110 - def xmlrpc_list_available(self, cred_user, eole_version, type_paq=None):
111 """renvoie la liste des dictionnaires disponibles dans le pool pour une distribution eole 112 type_paq : permet de limiter le résultat aux paquets eole ou locaux 113 """ 114 # types de données renvoyés par défaut 115 types_paq = ('eole', 'local') 116 if type_paq and type_paq in types_paq: 117 types_paq = [type_paq] 118 dict_res = {} 119 for type_paq in types_paq: 120 dict_res[type_paq] = {} 121 dict_res[type_paq]['dicos'] = self.parent.dictpool.dicos.get(eole_version,{}).get(type_paq, {}) 122 dict_res[type_paq]['paqs'] = self.parent.dictpool.paqs.get(eole_version,{}).get(type_paq, {}) 123 return 1, u(dict_res)
124
125 - def xmlrpc_update_dicts(self, cred_user, module_version, dict_type="local"):
126 """force une vérification des dictionnaires disponibles pour une distribution 127 module_version : version de la distribution à vérifier 128 dict_type: dictionnaires 'eole' ou 'locaux' 129 """ 130 try: 131 assert int(module_version) in self.parent.dictpool.eole_versions 132 except: 133 return 0, u("version de distribution non gérée") 134 if dict_type not in ('eole', 'local'): 135 return 0, u("le type de dictionnaire doit être 'eole' ou 'local'") 136 try: 137 self.parent.dictpool.update_dicts(int(module_version), dict_type) 138 except Exception, e: 139 traceback.print_exc() 140 return 0, False 141 return 1, True
142 143 ############################################### 144 # gestion des associations au niveau module 145
146 - def xmlrpc_managed_modules(self, cred_user):
147 """renvoie la liste des version de distribution comportant 148 des modules gérés avec le pool (et les ids des modules en question) 149 """ 150 res = {} 151 for id_mod, data in self.parent.dictpool.modules.items(): 152 libelle, version = data 153 if version not in res: 154 res[str(version)] = [] 155 res[str(version)].append(id_mod) 156 return 1, res
157
158 - def xmlrpc_check_module(self, cred_user, id_module):
159 """renvoie True si un module est géré par le pool de dictionnaire, False sinon 160 """ 161 try: 162 mod_ok = self.parent.dictpool.check_module(int(id_module)) 163 except Exception, e: 164 return 0, u(str(e)) 165 return 1, mod_ok
166
167 - def xmlrpc_list_module(self, cred_user, id_module, full_path=True):
168 """liste les dictionnaires associés à un module 169 """ 170 try: 171 self.parent.s_pool.check_mod_credential(cred_user, int(id_module)) 172 list_dicts = self.parent.dictpool.list_module(id_module, full_path) 173 except Exception, e: 174 return 0, u(str(e)) 175 return 1, u(list_dicts)
176
177 - def xmlrpc_add_module(self, cred_user, id_module, dict_type, dict_path):
178 """associe un dictionnaire/paquet à un module 179 """ 180 try: 181 self.parent.s_pool.check_mod_credential(cred_user, int(id_module)) 182 self.parent.dictpool.add_module_dict(id_module, dict_type, dict_path) 183 except Exception, e: 184 return 0, u(str(e)) 185 return 1, "OK"
186
187 - def xmlrpc_del_module(self, cred_user, id_module, dict_type, dict_path):
188 """supprime l'association entre un module et un dictionnaire/paquet 189 """ 190 try: 191 self.parent.s_pool.check_mod_credential(cred_user, int(id_module)) 192 self.parent.dictpool.del_module_dict(id_module, dict_type, dict_path) 193 except Exception, e: 194 return 0, u(str(e)) 195 return 1, "OK"
196
197 - def xmlrpc_get_module_defaults(self, cred_user, id_module, full_path=True):
198 """renvoie la liste des paquets par défaut d'un module 199 (basé sur le fichier de description du module) 200 """ 201 try: 202 self.parent.s_pool.check_mod_credential(cred_user, int(id_module)) 203 liste_dicts = self.parent.dictpool.get_module_defaults(id_module, full_path) 204 except Exception, e: 205 return 0, u(str(e)) 206 return 1, u(liste_dicts)
207 208 ############################################### 209 # gestion des associations au niveau variante 210
211 - def xmlrpc_list_variante(self, cred_user, id_variante):
212 """liste les dictionnaires associés à une variante 213 """ 214 try: 215 self.parent.s_pool.check_var_credential(cred_user, int(id_variante)) 216 list_dicts = self.parent.dictpool.list_variante(id_variante) 217 except Exception, e: 218 return 0, u(str(e)) 219 return 1, u(list_dicts)
220 221
222 - def xmlrpc_add_variante(self, cred_user, id_variante, dict_type, dict_path, pass_var=""):
223 """associe un paquet/dictionnaire à une variante 224 """ 225 try: 226 assert self.parent.dictpool.check_passvar(id_variante, cred_user, pass_var) == True 227 self.parent.s_pool.check_var_credential(cred_user, int(id_variante)) 228 self.parent.dictpool.add_variante_dict(id_variante, dict_type, dict_path) 229 except Exception, e: 230 return 0, u(str(e)) 231 return 1, "OK"
232
233 - def xmlrpc_del_variante(self, cred_user, id_variante, dict_type, dict_path, pass_var=""):
234 """supprime l'association entre un module et un dictionnaire/paquet 235 """ 236 try: 237 assert self.parent.dictpool.check_passvar(id_variante, cred_user, pass_var) == True 238 self.parent.s_pool.check_var_credential(cred_user, int(id_variante)) 239 self.parent.dictpool.del_variante_dict(id_variante, dict_type, dict_path) 240 except Exception, e: 241 traceback.print_exc() 242 return 0, u(str(e)) 243 return 1, "OK"
244 245 ############################################### 246 # gestion des associations au niveau serveur 247
248 - def xmlrpc_list_serveur(self, cred_user, id_serveur):
249 """liste les dictionnaires associés à un serveur 250 """ 251 try: 252 self.parent.s_pool.check_serv_credential(cred_user, int(id_serveur)) 253 list_dicts = self.parent.dictpool.list_serveur(id_serveur) 254 except Exception, e: 255 return 0, u(str(e)) 256 return 1, u(list_dicts)
257
258 - def xmlrpc_add_serveur(self, cred_user, id_serveur, dict_type, dict_path):
259 """associe un dictionnaire/paquet à un serveur 260 """ 261 try: 262 self.parent.s_pool.check_serv_credential(cred_user, int(id_serveur)) 263 self.parent.dictpool.add_serveur_dict(id_serveur, dict_type, dict_path) 264 except Exception, e: 265 return 0, u(str(e)) 266 return 1, "OK"
267
268 - def xmlrpc_del_serveur(self, cred_user, id_serveur, dict_type, dict_path):
269 """supprime l'association entre un serveur et un dictionnaire/paquet 270 """ 271 try: 272 self.parent.s_pool.check_serv_credential(cred_user, int(id_serveur)) 273 self.parent.dictpool.del_serveur_dict(id_serveur, dict_type, dict_path) 274 except Exception, e: 275 return 0, u(str(e)) 276 return 1, "OK"
277
278 - def xmlrpc_list_local_serveur(self, cred_user, id_serveur):
279 """renvoie la liste des dictionnaires et paquets devant être 280 mis en place sur un serveur 281 """ 282 try: 283 self.parent.s_pool.check_serv_credential(cred_user, int(id_serveur)) 284 liste_dicts = self.parent.dictpool.list_local_serveur(id_serveur) 285 except Exception, e: 286 return 0, u(str(e)) 287 return 1, u(liste_dicts)
288 289 # # fonctions internes ????? 290 # update_module(id_module) 291 # update_variante(id_variante, id_mod = None) 292 # get_var_mod(id_variante) 293 # update_serveur(id_serveur) 294 # get_serveur(id_serveur) 295 # reset_modules(self) 296 # update_data(self) 297 # check_dict(eole_version, dict_type, dict_name) 298 # check_type_res(res_type) 299 # get_link_path(eole_version, id_res, type_res, dict_type, dict_name) 300