zephir.backend.aaf_rpc

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

# Source Code for Module zephir.backend.aaf_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  # aaf_rpc.py
      9  #
     10  # fonctions xmlrpc pour la gestion des fichiers d'import AAF
     11  #
     12  ###########################################################################
     13  """module de gestion des identifiants ent
     14  """
     15  from zephir.backend.db_utils import db_connect
     16  from zephir.backend.aaf import AAF
     17  from zephir.backend.config import u, AAF_DIR
     18  from zephir.backend.xmlrpceole import XMLRPCEole as XMLRPC
     19  from zephir.backend.uucp_utils import uucp_pool, UUCPError
     20  import os, shutil, traceback
     21
     22 -class AAFRPC(XMLRPC):
     23      """serveur XMLRPC zephir pour la gestion des fichiers d'import AAF
     24      """
     25
     26 -    def __init__(self, parent):
     27          self.dbpool = db_connect()
     28          self.dbpool.noisy = 0
     29          self.parent = parent
     30          self.aaf = AAF()
     31          XMLRPC.__init__(self)
     32
     33 -    def xmlrpc_add_file(self, cred_user, serveur, filename):
     34          """associe un fichier AAF à un serveur
     35          """
     36          try:
     37              id_serveur = int(serveur)
     38              self.parent.s_pool.get(cred_user, id_serveur)
     39          except (KeyError, ValueError):
     40              return 0, """serveur %s non retrouvé""" % str(serveur)
     41          try:
     42              self.aaf.add_file(filename, id_serveur)
     43          except:
     44              traceback.print_exc()
     45              return 0, u("Erreur lors de l'attribution du fichier \
     46  au serveur %s" % str(id_serveur))
     47          return 1, "OK"
     48
     49 -    def xmlrpc_del_file(self, cred_user, filename):
     50          """supprime l'association d'un fichier AAF à un serveur
     51          """
     52          # vérification des droits sur le serveur
     53          try:
     54              id_serveur = self.aaf.get_serveur(filename)
     55              self.parent.s_pool.get(cred_user, id_serveur)
     56          except (KeyError, ValueError):
     57              return 0, """serveur associé à %s non retrouvé""" % str(filename)
     58          try:
     59              self.aaf.del_file(filename)
     60          except:
     61              traceback.print_exc()
     62              return 0, "Impossible de supprimer l'entrée"
     63          return 1, "OK"
     64
     65 -    def xmlrpc_get_list(self, cred_user, serveur):
     66          """renvoie la liste des fichiers associés à un serveur"""
     67          try:
     68              id_serveur = int(serveur)
     69              self.parent.s_pool.get(cred_user, id_serveur)
     70          except (KeyError, ValueError):
     71              return 0, """serveur %s non retrouvé""" % str(serveur)
     72          try:
     73              files = self.aaf.list_files(id_serveur)
     74          except:
     75              traceback.print_exc()
     76              return 0, "Erreur de recherche des fichiers associés au serveur"
     77          return 1, u(files)
     78
     79 -    def xmlrpc_notify_upload(self, cred_user, filename):
     80          """préviens Zéphir qu'un fichier a été mis à jour
     81          Envoie le fichier au serveur associé si besoin
     82          """
     83          if not os.path.isfile(os.path.join(AAF_DIR, filename)):
     84              return 0, u("Fichier non retrouvé sur Zéphir : %s" % filename)
     85          # recherche du serveur associé
     86          try:
     87              id_serveur = self.aaf.get_serveur(filename)
     88              serv = self.parent.s_pool[int(id_serveur)]
     89          except (KeyError, ValueError):
     90              return 0, """serveur associé à %s non retrouvé""" % str(filename)
     91          # si serveur trouvé, on regarde si le contenu du fichier a changé
     92          def_hash = self.aaf.check_hash(filename)
     93          return def_hash.addBoth(self.check_aff_callb, filename, serv)
     94
     95 -    def check_aff_callb(self, result, filename, serv):
     96          if result == True:
     97              # envoi nécessaire
     98              archive = 'import_%s' % filename
     99              serveur_dir = serv.get_confdir()
    100              # copie dans le répertoire du serveur
    101              if os.path.isfile(os.path.join(serveur_dir, archive)):
    102                  os.unlink(os.path.join(serveur_dir, archive))
    103              shutil.copy(os.path.join(AAF_DIR, filename),
    104                          os.path.join(serveur_dir, archive))
    105              # calcul et stockage d'un hash de l'archive
    106              cmd_checksum = """cd %s;/usr/bin/sha256sum -b %s > %s.sha""" \
    107  % (serveur_dir, archive, archive)
    108              os.system(cmd_checksum)
    109              # ajout de l'archive à la file d'attente uucp
    110              try:
    111                  id_uucp = "%s-%s" % (str(serv.get_rne()), str(serv.id_s))
    112                  uucp_pool.add_file(id_uucp, os.path.join(serveur_dir, archive))
    113                  # on met en attente la commande de traitement du fichier sur le
    114                  # serveur client (si plusieurs appels, elle remplace l'ancienne)
    115                  uucp_pool.add_cmd(id_uucp, "zephir_client import_aaf")
    116              except UUCPError, err:
    117                  return 0, u("Erreur d'envoi du fichier par uucp: %s" % str(err))
    118          return 1, "OK"
    119
    120 -    def xmlrpc_confirm_transfer(self, cred_user, id_serveur, dict_hash):
    121          """vérifie que les fichiers transférés sont bien pris en compte
    122          et met à jour leur hash dans la base de données
    123          """
    124          try:
    125              serv = self.parent.s_pool[int(id_serveur)]
    126          except:
    127              return 0, u("Serveur invalide : %s" % str(id_serveur))
    128          errors = []
    129          for fic_aaf, hash_res in dict_hash.items():
    130              # comparaison au fichier hash stocké
    131              fic_hash = os.path.join(serv.get_confdir(), "%s.sha" % fic_aaf)
    132              if not os.path.isfile(fic_hash):
    133                  errors.append(fic_aaf)
    134              else:
    135                  hash_data = file(fic_hash).read().split('\n')
    136                  # vérification de la correspondance
    137                  if not hash_res.strip() in hash_data:
    138                      errors.append(fic_aaf)
    139                      # demander une relance de la copie au prochain appel ?
    140                  else:
    141                      # vérification ok, on met à jour le checksum dans
    142                      # la base de données. Le fichier ne sera plus envoyé
    143                      fic_ori = fic_aaf.lstrip('import_')
    144                      self.aaf.update_hash(fic_ori, hash_res.split()[0])
    145                      # suppression des fichiers inutiles
    146                      os.unlink(os.path.join(serv.get_confdir(), "%s.sha" % fic_aaf))
    147                      os.unlink(os.path.join(serv.get_confdir(), fic_aaf))
    148          if errors != []:
    149              return 0, u(errors)
    150          return 1, "OK"
    151