zephir.backend.dicos_rpc

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
     92 -    def xmlrpc_get_dict_links(self, cred_user, eole_version, dict_type, dict_name):
     93          """renvoie l'ensemble des liens pointant sur un dictionnaire ou paquet
     94          """
     95          try:
     96              liste_dicts = self.parent.dictpool.get_dict_links(eole_version, dict_type, dict_name)
     97          except Exception, e:
     98              return 0, u(str(e))
     99          return 1, u(liste_dicts)
    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