zephir.manage_pool

Package zephir :: Module manage_pool |
[frames] | no frames]

# Source Code for Module zephir.manage_pool

      1  #!/usr/bin/env python
      2  # -*- coding: utf-8 -*-
      3  ###########################################################################
      4  # Eole NG - 2007
      5  # Copyright Pole de Competence Eole  (Ministere Education - Academie Dijon)
      6  # Licence CeCill  cf /root/LicenceEole.txt
      7  # eole@ac-dijon.fr
      8  #
      9  # manage_pool.py
     10  #
     11  ###########################################################################
     12
     13  """
     14  librairie de fonctions pour la gestion des identifiants ENT
     15  """
     16
     17  import sys, os, base64, xmlrpclib, time, subprocess
     18  # imports creole
     19  from creole.utils import print_red, print_green, print_orange
     20  from creole.parsedico import parse_dico
     21  # imports zephir
     22  from entpool import ClientIdPool
     23  try:
     24      from zephir_conf.zephir_conf import id_serveur
     25      from lib_zephir import zephir_proxy, convert
     26      registered = True
     27  except:
     28      registered = False
     29
     30  ERR_FILE = '/etc/eole/.ent_ids_err'
     31  OK_FILE = '/etc/eole/.ent_ids_ok'
     32  # réserve d'identifiants à conserver dans la mesure du possible
     33  MIN_STOCK = 50
     34
     35 -def get_pool(code_ent=None):
     36      """initialisation d'un pool d'identifiant
     37      """
     38      # Récupération du code ent
     39      config = parse_dico()
     40      try:
     41          if not code_ent:
     42              code_ent = config['code_ent']
     43          assert len(code_ent) == 2
     44      except:
     45          return None
     46      # Chargement du pool d'identifiants
     47      return ClientIdPool(code_ent)
     48
     49 -def get_new_ids(num_ids):
     50      # lecture de la cle ssh publique
     51      cle_pub = file('/var/spool/uucp/.ssh/id_rsa.pub').read().strip()
     52      try:
     53          code, res = convert(zephir_proxy.entid.get_id_range(id_serveur, base64.encodestring(cle_pub), num_ids))
     54      except xmlrpclib.ProtocolError:
     55          print_red("""Erreur d'authentification ou zephir non disponible""")
     56          return False
     57      if code == 0:
     58          print_red("Erreur lors de la réservation d'une plage d'identifiants sur Zephir: %s" % str(res))
     59          return False
     60      # confirmation de la réservation auprès de Zephir:
     61      # - synchronisation du serveur
     62      # (lancement de la lecture du fichier de plages envoyé et confirmation)
     63      # - attente de la fin de l'action programmée par zephir
     64      # - vérification des identifiants disponibles
     65      print_orange("Réservation d'une plage d'identifiants auprès de Zephir")
     66      print_orange("Veuillez patienter ...")
     67      orig_stdout = sys.stdout
     68      nullout = open('/dev/null','w')
     69      sys.stdout = nullout
     70      zephir_call = subprocess.Popen('/usr/share/zephir/scripts/zephir_client.py call >/dev/null 2>&1', shell=True)
     71      if zephir_call.wait() != 0:
     72          print_red("Erreur lors de la synchronisation avec Zéphir")
     73          return False
     74      sys.stdout = orig_stdout
     75      nullout.close()
     76      # boucle d'attente (320 secondes maxi)
     77      # la validation est lancée par zephir à travers uucp
     78      wait = 0
     79      while wait < 640:
     80          time.sleep(0.5)
     81          wait += 1
     82          if os.path.exists(OK_FILE):
     83              os.unlink(OK_FILE)
     84              return True
     85          if os.path.exists(ERR_FILE):
     86              os.unlink(ERR_FILE)
     87              break
     88      print_red("""La plage Réservée n'a pas pu être validée""")
     89      return False
     90
     91 -def get_ids(num_ids, code_ent = None):
     92      pool = get_pool(code_ent)
     93      if pool is None:
     94          return pool
     95      # essai de récupération de num_ids identifiants (on essaye de conserver un stock supplémentaires)
     96      required = num_ids + MIN_STOCK
     97      if pool.free_space < required:
     98          if not registered:
     99              if pool.free_space < num_ids:
    100                  print_red("""Pas assez d'identifiants disponibles.
    101  Serveur non enregistré sur Zephir.
    102  La récupération automatique d'identifiants n'est pas gérée""")
    103                  return None
    104              else:
    105                  print_orange("""Il restera moins de %s identifiants en fin de procédure""" % MIN_STOCK)
    106                  return pool
    107          if pool.free_space < num_ids:
    108              print_orange("""Pas assez d'identifiants disponibles""")
    109          # calcul du nombre d'identifiants à demander (identifiants manquants + stock minimum)
    110          if get_new_ids(required - pool.free_space):
    111              print_green("Nouveaux identifiants réservés")
    112          # chargement du pool et vérification des identifiants disponibles après demande
    113          pool.load_state()
    114          # on vérifie qu'on a au moins le nombre d'identifiants nécessaire
    115          if pool.free_space >= num_ids:
    116              print_green("Identifiants disponibles: %s" % str(pool.free_space))
    117          else:
    118              print_red("""Impossible de réserver un nombre d'identifiants suffisants auprès de Zephir !""")
    119              print_red("""Identifiants disponibles: %s (%s demandés)""" % (str(pool.free_space),str(num_ids)))
    120              return None
    121      return pool
    122
    123 -def get_single_id(code_ent = None):
    124      pool = get_pool(code_ent)
    125      if pool is None:
    126          return pool
    127      # essai de récupération d'un identifiant
    128      if pool.free_space < 1:
    129          if not registered:
    130              print_red("""Pas assez d'identifiants disponibles.
    131  Serveur non enregistré sur Zephir.
    132  La récupération automatique d'identifiants n'est pas gérée""")
    133              return None
    134          else:
    135              print_orange("""Pas assez d'identifiants disponibles""")
    136              # calcul du nombre d'identifiants à demander (identifiants manquants + stock minimum)
    137              if get_new_ids(MIN_STOCK):
    138                  print_green("Nouveaux identifiants réservés")
    139          # chargement du pool et vérification des identifiants disponibles après demande
    140          pool.load_state()
    141          # on vérifie qu'on a au moins le nombre d'identifiants nécessaire
    142          if pool.free_space >= 1:
    143              print_green("Identifiants disponibles: %s" % str(pool.free_space))
    144          else:
    145              print_red("""Impossible de réserver de nouveaux identifiants auprès de Zephir !""")
    146              return None
    147      return pool
    148
    149  if __name__ == "__main__":
    150      print("test de génération de 50 identifiants :\n")
    151      pool = get_ids(50)
    152      if pool:
    153          for ent_id in range(50):
    154              print ent_id, ' -> ', pool.get_next_id()
    155      else:
    156          print_red("Récupération des identifiants nécessaires impossible")
    157