zephir.backend.prelude_rpc

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

# Source Code for Module zephir.backend.prelude_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  # prelude_rpc.py
      9  #
     10  # fonctions xmlrpc pour la gestion de prélude dans Zephir
     11  #
     12  ###########################################################################
     13  """module de gestion de prelude
     14  """
     15  from twisted.internet.utils import getProcessOutput
     16  from zephir.backend.db_utils import *
     17  from zephir.backend import config
     18  from zephir.backend.config import u
     19  from zephir.backend.xmlrpceole import XMLRPCEole as XMLRPC
     20  from zephir.backend.lib_backend import ResourceAuthError
     21  from zephir.eolerpclib import xmlrpclib, EoleProxy
     22  import sys,os,shutil,time,base64
     23  from zephir.backend.uucp_utils import uucp_pool
     24  from creole import cert
     25  from creole.config import rsyslog_ca_file, rsyslog_ca_template
     26  from creole.parsedico import parse_dico
     27
     28 -class RPCPrelude(XMLRPC):
     29      """serveur XMLRPC zephir pour la gestion de prélude
     30      """
     31
     32 -    def __init__(self, parent):
     33          self.dbpool = db_connect()
     34          self.dbpool.noisy = 0
     35          XMLRPC.__init__(self)
     36          self.parent = parent
     37
     38 -    def xmlrpc_register_server(self, cred_user, id_manager):
     39          """négocie l'enregistrement d'une sonde prelude dans prelude manager
     40          id_serveur : identifiant zephir du serveur sonde
     41
     42          -génère un mot de passe aléatoire
     43          -demande le lancement de prelude-adduser sur le manager
     44          -renvoie le mot de passe pour permettre l'enregistrement côté sonde
     45          """
     46          # génération du mot de passe avec pwgen
     47          cmd_pass = getProcessOutput("/usr/bin/pwgen",
     48                                      args = ["-B","-s","-1"],
     49                                      env = {'LC_ALL': 'C'})
     50          return cmd_pass.addCallback(self._register_server, cred_user, id_manager)
     51
     52 -    def _register_server(self, output, cred_user, id_manager):
     53          """
     54          Callback de la fonction xmlrpc_register_server.
     55          """
     56          passwd = output.strip()
     57          # lancement de prelude-adduser sur le manager
     58          try:
     59              # lecture de la clé du manager
     60              serv = self.parent.s_pool.get(cred_user, int(id_manager))
     61              key = file(os.path.join(serv.get_confdir(), 'cle_publique')).read()
     62              try:
     63                  ip_manager = serv.parsedico()['adresse_ip_eth0']
     64              except:
     65                  return 0, u("""Adresse ip du manager %s non disponible""" % id_manager)
     66              manager_rpc = EoleProxy('https://%s:%s' % (ip_manager, config.PRELUDE_PORT))
     67              res = manager_rpc.register_server(xmlrpclib.base64.encodestring(key),passwd)
     68          except:
     69              import traceback
     70              traceback.print_exc()
     71              res = 0
     72          if res == 1:
     73              return 1, u(passwd)
     74          elif res == -1:
     75              return -1, u("""Un enregistrement est déjà en cours""")
     76          else:
     77              return 0, u("""Impossible de lancer prelude-adduser sur le manager""")
     78
     79 -    def xmlrpc_get_managers(self, cred_user, module='preludemanager'):
     80          """renvoie l'adresse du manager défini sur zephir si il existe"""
     81          # on récupère la liste des managers disponibles
     82          if module == '':
     83              # nouvelle méthode, on reherche tous les serveurs ayant activé la réception des logs
     84              managers = {}
     85              for id_serv in self.parent.s_pool.keys():
     86                  try:
     87                      serv = self.parent.s_pool.get(cred_user, id_serv)
     88                  except:
     89                      # serveur non autorisé
     90                      continue
     91                  conf = serv.parsedico()
     92                  if conf.get('activer_reception_logs','non') == 'oui':
     93                      if conf.get('activer_reception_logs_tcp','non') == 'oui':
     94                          if conf.get('rsyslog_reception_tls','non') == 'oui':
     95                              managers[str(id_serv)] = [conf.get('adresse_ip_eth0',''), serv.libelle]
     96              return 1, u(managers)
     97          else:
     98              query = """select distinct(serveurs.id), serveurs.libelle from serveurs, modules where\
     99              serveurs.module_actuel=modules.id and modules.libelle like %s"""
    100              return self.dbpool.runQuery(query, ('%s-%%' % module, )).addCallbacks(self._get_managers, db_client_failed, callbackArgs=[cred_user])
    101
    102 -    def _get_managers(self, data, cred_user):
    103          """
    104          Callback de la fonction xmlrpc_get_managers.
    105          """
    106          if data == []:
    107              # pas de serveurs preludemanager enregistrés
    108              return 1, {}
    109          else:
    110              managers = {}
    111              for manager in data:
    112                  id_man = int(manager[0])
    113                  libelle = manager[1]
    114                  # récupération de l'adresse ip
    115                  serv = self.parent.s_pool.get(cred_user, id_man)
    116                  try:
    117                      ip = serv.parsedico()['adresse_ip_eth0']
    118                  except:
    119                      # configuration inconnue pour ce manager
    120                      ip = ''
    121                  if ip != '':
    122                      managers[str(id_man)]=[ip, libelle]
    123
    124          return 1, u(managers)
    125
    126 -    def xmlrpc_gen_certif(self, cred_user, request_data, id_serveur, id_zephirlog=None):
    127          """
    128          Récupère les données d'une requête et enregistre la configuration
    129          rsyslog dans le répertoire adéquat.
    130          @request_data : dictionnaire contenant le contenu de la requête
    131                          (entrée request), le modèle pour générer le
    132                          certificat (entrée template) et la configuration
    133                          pour rsyslog.
    134          @id_serveur : identifiant zephir du serveur demandant la génération
    135                          du certificat
    136          @id_zephirlog (optionnel) : identifiant zephir du zephirlog concerné
    137                          par l'appairage.
    138          """
    139          rsyslog_privkey = '/etc/ssl/private/rsyslog_privkey.pem'
    140          serveur_rsyslog_conf = 'rsyslog/zephirlog'
    141          client_rsyslog_conf = 'rsyslog/client'
    142
    143          if id_zephirlog:
    144              zephirlog_dest = self.parent.s_pool.get(cred_user, int(id_zephirlog))
    145              write_path_rsyslog_conf = os.path.join(zephirlog_dest.get_confdir(), client_rsyslog_conf)
    146              read_path_rsyslog_conf = os.path.join(zephirlog_dest.get_confdir(), serveur_rsyslog_conf)
    147          else:
    148              zephirlog_dest = self.parent.s_pool.get(cred_user, int(id_serveur))
    149              write_path_rsyslog_conf = os.path.join(zephirlog_dest.get_confdir(), serveur_rsyslog_conf)
    150              read_path_rsyslog_conf = os.path.join(zephirlog_dest.get_confdir(), client_rsyslog_conf)
    151
    152          if not os.path.exists(write_path_rsyslog_conf):
    153              os.makedirs(write_path_rsyslog_conf, 0755)
    154          if not os.path.exists(read_path_rsyslog_conf):
    155              os.makedirs(read_path_rsyslog_conf, 0755)
    156
    157          rsyslog_conf_file = os.path.join(write_path_rsyslog_conf, str(id_serveur) + '.peer')
    158          rsyslog_file = open(rsyslog_conf_file, 'w')
    159          rsyslog_file.write(xmlrpclib.base64.decodestring(request_data['rsyslog']))
    160          rsyslog_file.close()
    161
    162          if id_zephirlog and os.path.exists(rsyslog_conf_file):
    163              id_uucp = str(zephirlog_dest.get_rne()) + '-' + str(zephirlog_dest.id_s)
    164              res = uucp_pool.add_cmd(id_uucp, "zephir_client get_rsyslog_conf")
    165
    166          serv = self.parent.s_pool.get(cred_user, int(id_serveur))
    167          path_request = os.path.join(serv.get_confdir(), "request.pem")
    168          file_request = open(path_request, "w")
    169          file_request.write(xmlrpclib.base64.decodestring(request_data['request']))
    170          file_request.close()
    171          path_request_template = os.path.join(serv.get_confdir(), "request-template.tmpl")
    172          file_request_template = open(path_request_template, "w")
    173          file_request_template.write(xmlrpclib.base64.decodestring(request_data['template']))
    174          file_request_template.close()
    175          path_cert = os.path.join(serv.get_confdir(), "rsyslog_cert.pem")
    176
    177          if not os.path.exists(rsyslog_privkey):
    178              cert.gen_privkey(rsyslog_privkey)
    179          if not os.path.exists(rsyslog_ca_file):
    180              cert.gen_selfsigned_cert(rsyslog_ca_template, rsyslog_privkey, path_cert=rsyslog_ca_file)
    181
    182          cmd_pass = getProcessOutput("/usr/bin/certtool",
    183                                      args = ["--generate-certificate",
    184                                          "--load-request", path_request,
    185                                          "--outfile", path_cert,
    186                                          "--load-ca-certificate", rsyslog_ca_file,
    187                                          "--load-ca-privkey", rsyslog_privkey,
    188                                          "--template", path_request_template],
    189                                      env = {'LC_ALL': 'C'},
    190                                      errortoo=True)
    191          return cmd_pass.addCallback(self._gen_certif, cred_user, path_cert, read_path_rsyslog_conf)
    192
    193 -    def _gen_certif(self, output, cred_user, path_cert, path_rsyslog_conf):
    194          """
    195          Retourne le certificat et la configuration de rsyslog si elle est
    196          disponible.
    197          @path_cert : le chemin du certificat à retransmettre
    198          @path_rsyslog_conf : répertoire contenant les bouts de conf
    199              pour rsyslog. Les contenus de tous les fichiers présents sont
    200              concaténés pour être envoyés.
    201          """
    202
    203          result = {}
    204          ca_file = open(rsyslog_ca_file, 'r')
    205          result['ca_data'] = xmlrpclib.base64.encodestring(ca_file.read())
    206          ca_file.close()
    207          cert_file = open(path_cert, 'r')
    208          result['cert_data'] = xmlrpclib.base64.encodestring(cert_file.read())
    209          cert_file.close()
    210
    211          if os.path.exists(path_rsyslog_conf):
    212              rsyslog_data = []
    213              for rsyslog_conf in [i for i in os.listdir(path_rsyslog_conf) if i[-5:] == '.peer']:
    214                  rsyslog_conf = open(os.path.join(path_rsyslog_conf, rsyslog_conf), 'r')
    215                  rsyslog_data.append(rsyslog_conf.read())
    216                  rsyslog_conf.close()
    217
    218          result['rsyslog_data'] = xmlrpclib.base64.encodestring('\n'.join(rsyslog_data))
    219
    220          return 1, result
    221
    222 -    def xmlrpc_get_rsyslog_conf(self, cred_user,  id_serveur, id_zephirlog=None):
    223          """
    224          Récupère les données d'une requête et enregistre la configuration
    225          rsyslog dans le répertoire adéquat.
    226          @request_data : dictionnaire contenant le contenu de la requête
    227                          (entrée request), le modèle pour générer le
    228                          certificat (entrée template) et la configuration
    229                          pour rsyslog.
    230          @id_serveur : identifiant zephir du serveur demandant la génération
    231                          du certificat
    232          @id_zephirlog (optionnel) : identifiant zephir du zephirlog concerné
    233                          par l'appairage.
    234          """
    235
    236          serveur_rsyslog_conf = 'rsyslog/zephirlog'
    237          client_rsyslog_conf = 'rsyslog/client'
    238
    239          if id_zephirlog:
    240              zephirlog_dest = self.parent.s_pool.get(cred_user, int(id_zephirlog))
    241              read_path_rsyslog_conf = os.path.join(zephirlog_dest.get_confdir(), serveur_rsyslog_conf)
    242          else:
    243              zephirlog_dest = self.parent.s_pool.get(cred_user, int(id_serveur))
    244              read_path_rsyslog_conf = os.path.join(zephirlog_dest.get_confdir(), client_rsyslog_conf)
    245
    246          return self._get_rsyslog_conf(1, cred_user, read_path_rsyslog_conf)
    247
    248 -    def _get_rsyslog_conf(self, output, cred_user, path_rsyslog_conf):
    249          """
    250          Retourne la configuration de rsyslog.
    251          @path_rsyslog_conf : répertoire contenant les bouts de configuration.
    252          """
    253          rsyslog_data = []
    254          for rsyslog_conf in [i for i in os.listdir(path_rsyslog_conf) if i[-5:] == '.peer']:
    255              rsyslog_conf = open(os.path.join(path_rsyslog_conf, rsyslog_conf), 'r')
    256              rsyslog_data.append(rsyslog_conf.read())
    257              rsyslog_conf.close()
    258
    259          return 1, xmlrpclib.base64.encodestring('\n'.join(rsyslog_data))
    260
    261
    262 -    def xmlrpc_register_logger(self, cred_user, id_serveur):
    263          """permet de vérifier si des serveurs ont été modifiés
    264          """
    265          return 1, u("""Fonction non implémentée""")
    266