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

Source Code for Module zephir.lib_zephir

  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  # lib_zephir.py 
  9  # 
 10  # librairie de fonctions pour le client Zephir 
 11  # 
 12  ########################################################################### 
 13   
 14  registered = 1 
 15  try: 
 16      import zephir.zephir_conf.zephir_conf as config 
 17  except: 
 18      registered = 0 
 19  import os, sys, time, socket 
 20  from creole.cfgparser import EoleDict 
 21  from creole.config import eoledirs 
 22  try: 
 23      from creole.cert import cert_dir 
 24  except: 
 25      cert_dir = "/etc/ssl/certs" 
 26  from creole.fonctionseole import get_module_name 
 27  from creole.utils import print_orange, print_red, print_green 
 28  from glob import glob 
 29  import traceback 
 30  # imports locaux 
 31  from zephir.eolerpclib import xmlrpclib 
 32  from zephir.prelude_options import get_options 
 33   
 34  # définition de l'encodage du texte 
 35  charset = 'UTF-8' 
 36  # répertoire publique d'uucp 
 37  public_dir = '/var/spool/uucppublic' 
 38  # définition du proxy XMLRPC 
 39  eole_dir = '/usr/share/eole' 
 40  zephir_dir = '/usr/share/zephir' 
 41  new_addr_file = os.path.join(zephir_dir,'zephir_conf','new_pubkey') 
 42  # mode de sauvegarde des données locales 
 43  save_modes = {0:"Tout", 
 44                1:"configuration", 
 45                2:"configuration + patchs/dicos/templates", 
 46                3:"fichiers divers locaux", 
 47               } 
 48   
 49  # recherche du répertoire du module zephir 
 50  import zephir as zephir_lib 
 51  zephir_path = os.path.dirname(zephir_lib.__file__) 
 52   
 53  # redéfinition de la classe pour supporter les timeouts 
54 -class TransportEole(xmlrpclib.SafeTransport):
55 56 # def __init__(self, use_datetime = 0): 57 # self.proxy = None 58 # super(xmlrpclib.SafeTransport,self).__init__(use_datetime) 59 # 60 # def set_proxy(self, proxy): 61 # self.proxy = proxy 62 # 63 # def make_connection(self, host): 64 # if self.proxy is not None: 65 # self.realhost = host 66 # https = httplib.HTTPS(self.proxy) 67 # return https 68 # else: 69 # return super(xmlrpclib.SafeTransport,self).make_connection() 70 # 71 # def send_request(self, connection, handler, request_body): 72 # connection.putrequest("POST", 'https://%s%s' % (self.realhost, handler)) 73 # 74 # def send_host(self, connection, host): 75 # connection.putheader('Host', self.realhost) 76
77 - def _parse_response(self, file, sock):
78 """lit et parse la réponse du serveur 79 modifié pour ne pas bloquer sur la lecture (file.read) 80 dans le cas de l'utilisation de ssl 81 """ 82 # read response from input file/socket, and parse it 83 84 p, u = self.getparser() 85 86 while 1: 87 if sock: 88 response = sock.recv(1024) 89 else: 90 response = file.read(1024) 91 if not response: 92 break 93 if self.verbose: 94 print "body:", repr(response) 95 p.feed(response) 96 if len(response) < 1024: 97 break 98 99 file.close() 100 p.close() 101 102 return u.close()
103 104 try: 105 if get_module_name() == 'zephir': 106 # on permet un temps d'attente plus long lors des requêtes sur Zephir 107 socket.setdefaulttimeout(180) 108 else: 109 # timeout réduit sur les serveurs clients pour éviter de bloquer le système 110 socket.setdefaulttimeout(15) 111 except: 112 # non implémenté sur python 2.2 113 pass 114 115 if registered: 116 zephir_proxy = xmlrpclib.ServerProxy("https://zephir:zephir@"+config.adresse_zephir+":7080", transport=TransportEole()) 117 # pour compatibilité avec des programmes externes 118 zephir = zephir_proxy 119
120 -def convert(objet):
121 """Transforme les objets unicode contenus dans un objet en chaines 122 """ 123 if type(objet) == list: 124 l = [] 125 for item in objet: 126 l.append(convert(item)) 127 return l 128 if type(objet) == dict: 129 dico={} 130 for cle in objet.keys(): 131 dico[cle] = convert(objet[cle]) 132 return dico 133 if type(objet) == unicode: 134 string = objet.encode(charset) 135 return string 136 return objet
137
138 -def u(objet):
139 if type(objet) == list: 140 l = [] 141 for item in objet: 142 l.append(u(item)) 143 return l 144 if type(objet) == dict: 145 dico={} 146 for cle in objet.keys(): 147 dico[cle] = u(objet[cle]) 148 return dico 149 if type(objet) == str: 150 string = unicode(objet,charset) 151 return string 152 return objet
153
154 -def log(action,etat,msg,date=''):
155 """fonction de log local et distant (si disponible) des actions zephir effectuées sur le serveur 156 """ 157 # on insère le log actuel à la liste des logs à envoyer 158 failed_logs = [] 159 ignored_logs = [] 160 if date == '': 161 date = str(time.ctime()) 162 liste_logs = [[str(date),action,str(etat),msg]] 163 # on regarde si il y a des logs différés (erreur de contact avec zephir lors d'un log précédent) 164 try: 165 fic_logs=open('%s/deffered_logs' % zephir_dir, 'r') 166 # rqe : on limite à 20 le nombre d'anciens logs à remonter (pour éviter de bloquer trop longtemps) 167 deffered_logs = fic_logs.read().strip().split('\n') 168 if len(deffered_logs) > 20: 169 old_logs = deffered_logs[:20] 170 ignored_logs = deffered_logs[20:] 171 else: 172 old_logs = deffered_logs 173 for log in old_logs: 174 # on stocke ces logs dans la liste 175 if log.count(';') > 0: 176 liste_logs.append(log.split(';')) 177 fic_logs.close() 178 except: 179 # le fichier n'existe pas 180 # (tous les logs sont passés) 181 pass 182 183 erreur_zephir = 0 184 # on essaie d'envoyer tous les logs via xmlrpc 185 for log in liste_logs: 186 if erreur_zephir == 0: 187 # on n'essaie pas de réinsérer les logs suivants si il y a eu une erreur 188 # (évite de répeter les timeouts de la connexion) 189 try: 190 date, action, etat, msg = log 191 try: 192 msg = u(msg) 193 except: 194 pass 195 if log[0] != '': 196 res=zephir_proxy.uucp.log_serveur(config.id_serveur,u(date),u(action),int(etat),msg) 197 else: 198 res=zephir_proxy.uucp.log_serveur(config.id_serveur,u(str(time.ctime())),u(action),int(etat),msg) 199 if res[0] == 0: 200 # erreur d'insertion du log, mais zephir répond, on continue en stockant ce log 201 failed_logs.append(';'.join(log)) 202 except: 203 # echec de la connexion à zephir 204 # on stocke les informations de log dans le fichier deffered_logs 205 # Ces logs seront parsés au prochain appel de cette fonction 206 erreur_zephir = 1 207 failed_logs.append(';'.join(log)) 208 else: 209 failed_logs.append(';'.join(log)) 210 211 if ignored_logs != []: 212 failed_logs.extend(ignored_logs) 213 # on sauvegarde tous les logs non envoyés 214 try: 215 fic_logs=open('%s/deffered_logs' % zephir_dir, 'w') 216 for log in failed_logs: 217 fic_logs.write(log+'\n') 218 fic_logs.close() 219 except: 220 # pas les droits pour écrire dans le fichier ? 221 pass 222 223 # Le log local est géré par les fonctions Zephir et Zecho 224 return "ok"
225 226 # fonctions de verrouillage 227 228 lock_dir = '/var/lock' 229
230 -def lock(tags):
231 """fonction qui crée un ou plusieurs verrous""" 232 retour = 1 233 if os.path.isdir(lock_dir): 234 if not type(tags) == list: 235 tags=[tags] 236 for tag in tags: 237 try: 238 fic_temp=open(lock_dir+os.sep+tag,"w").close() 239 except: 240 retour = 0 241 else: 242 retour = 0 243 return retour
244
245 -def unlock(tags):
246 """fonction qui supprime un verrou""" 247 try: 248 if not type(tags) == list: 249 tags=[tags] 250 for tag in tags: 251 if os.path.isfile(lock_dir+os.sep+tag): 252 os.unlink(lock_dir+os.sep+tag) 253 except: 254 return 0 255 return 1
256
257 -def is_locked(tags):
258 """fonction qui permet de savoir si un verrou particulier est posé""" 259 if not type(tags) == list: 260 tags=[tags] 261 for tag in tags: 262 if os.path.isfile(lock_dir+os.sep+tag): 263 return 1 264 else: 265 return 0
266
267 -def update_conf(id_serveur, adresse_zephir):
268 """met à jour le fichier conf_zephir""" 269 template_conf = """#!/usr/bin/env python 270 id_serveur=%s 271 adresse_zephir="%s" 272 273 if __name__ == "__main__": 274 print adresse_zephir 275 """ 276 try: 277 conf=open(os.path.join(zephir_path,'zephir_conf/zephir_conf.py'), 'w') 278 conf.write(template_conf % (str(id_serveur), str(adresse_zephir))) 279 conf.close() 280 res = os.system('/bin/chmod 644 %s' % os.path.join(zephir_path,'zephir_conf/zephir_conf.py')) 281 assert res == 0 282 except: 283 return False 284 if os.path.isfile(new_addr_file): 285 os.unlink(new_addr_file) 286 log('CONFIGURE',0,"""Nouvelle adresse de zephir prise en compte : %s""" % str(adresse_zephir)) 287 return True
288 289
290 -def maj_client_zephir(zephir_proxy, adresse_zephir):
291 """met à jour le client""" 292 293 # on regarde si une mise à jour est nécessaire 294 # récupération de la version locale 295 out=os.popen('/usr/bin/dpkg -p zephir-client | grep Version') 296 version_client = out.read().split(':')[1] 297 out.close() 298 version_client = "zephir-client_" + version_client.strip() 299 res_maj = 2 300 # vérification de la version présente sur zephir 301 try: 302 res=convert(zephir_proxy.maj_client(version_client)) 303 except Exception,e: 304 # fonction de mise à jour non disponible sur cette version de zephir 305 pass 306 else: 307 if res[0] == 0: 308 print("pas de mise à jour disponible sur zephir") 309 else: 310 if res[1] != "OK": 311 # une mise à jour est nécessaire 312 rpm_client = res[1].encode(charset).strip() 313 res_maj=os.system('%s/scripts/maj_client.sh %s %s' % (zephir_dir,adresse_zephir,rpm_client)) / 256 314 return res_maj
315
316 -def update_zephir_ip():
317 """vérifie si zephir répond sur sa nouvelle adresse (envoyée auparavant via change_ip) 318 """ 319 # lecture des données stockées (ancienne/nouvelle clé + nouvelle adresse) 320 ssh_dir = "/var/spool/uucp/.ssh/" 321 tmp_dir = os.path.join(ssh_dir,'tmpkeys') 322 data_new_key = file(new_addr_file).read().strip() 323 old_key, new_key, new_addr = data_new_key.split('%%') 324 try: 325 proxy = xmlrpclib.ServerProxy("https://zephir:zephir@%s:7080" % (new_addr),transport=TransportEole()) 326 # demande de récupération de la nouvelle clé privée sur zephir. On doit envoyer les clés publiques (actuelle et nouvelle) 327 code, res = convert(proxy.serveurs.get_key(config.id_serveur,old_key, new_key)) 328 if code == 0: 329 log('CONFIGURE',1,"""Prise en compte de la nouvelle adresse (%s): clé non reconnue par zephir""" % (new_addr)) 330 return False 331 except: 332 return False 333 fic_priv = os.path.join(tmp_dir, 'new_key') 334 try: 335 if os.path.exists(fic_priv): 336 os.unlink(fic_priv) 337 os.system('/bin/touch %s;/bin/chmod 600 %s' % (fic_priv, fic_priv)) 338 fichier = file(fic_priv,'a') 339 fichier.write(xmlrpclib.base64.decodestring(res)) 340 fichier.close() 341 except: 342 print "erreur d'ouverture du fichier %s" %fic_priv 343 return False 344 # activation de la clé sur zephir 345 data = convert(proxy.serveurs.update_key(config.id_serveur)) 346 if data[0] == 0: 347 print "erreur de mise en place de la nouvelle clé sur zephir : %s" % str(res) 348 return False 349 # sauvegarde de la clé actuelle 350 os.system("/bin/mv %s/id_rsa.pub %s/old_key.pub" % (ssh_dir, tmp_dir)) 351 os.system("/bin/mv %s/id_rsa %s/old_key" % (ssh_dir, tmp_dir)) 352 # mise en place de la nouvelle clé locale 353 os.system("/bin/mv %s/new_key.pub %s/id_rsa.pub" % (tmp_dir, ssh_dir)) 354 os.system("/bin/mv %s/new_key %s/id_rsa" % (tmp_dir, ssh_dir)) 355 os.system("/bin/chown uucp.uucp %s/id_rsa*" % ssh_dir) 356 # unlock(['configure','uucp','maj','reconfigure']) 357 # mise à jour de la configuration uucp 358 old_addr = config.adresse_zephir 359 for path_uucp in ['/etc/uucp/port', '/etc/uucp/sys']: 360 conf_uucp = open(path_uucp).read() 361 conf_uucp = conf_uucp.replace(old_addr, new_addr) 362 fic_uucp = open(path_uucp, 'w') 363 fic_uucp.write(conf_uucp) 364 fic_uucp.close() 365 # mise à jour de zephir_conf.py avec la nouvelle adresse 366 return update_conf(config.id_serveur, new_addr)
367
368 -def update_sudoers():
369 """met à jour la liste des scripts exécutables par sudo en tant que root""" 370 uucp_pattern = """uucp ALL=NOPASSWD""" 371 if os.path.isfile('/etc/sudoers'): 372 scripts = glob('%s/scripts/*.zephir' % zephir_dir) 373 scripts.sort() 374 # liste des scripts disponibles 375 uucp_conf = ["#ZEPHIR : liste des scripts exécutables par zephir_client, ne pas modifier\n"] 376 for script in scripts: 377 uucp_conf.append('uucp ALL=NOPASSWD : %s\n' % script) 378 uucp_conf.append('#ZEPHIR FIN\n') 379 # fichier actuel 380 orig_data = file('/etc/sudoers').readlines() 381 # supression des lignes concernant uucp 382 final_data = [] 383 for line in orig_data: 384 if not (line.startswith(uucp_pattern) or line.startswith('#ZEPHIR')): 385 final_data.append(line) 386 final_data.extend(uucp_conf) 387 # ré-écriture du fichier 388 try: 389 sudo_file = file('/etc/sudoers','w') 390 sudo_file.writelines(final_data) 391 os.system('chmod 0440 /etc/sudoers') 392 return True 393 except: 394 print "\n! Client Zephir: Le fichier /etc/sudoers n'a pas pu être mis à jour !\n" 395 return False
396
397 -def verif_transfer(zephir_proxy, archive):
398 """vérifie la validité d'une archive recue et confirme sa réception à zephir""" 399 verif_archive = convert(zephir_proxy.uucp.get_checksum(config.id_serveur,u(archive))) 400 if verif_archive[0] == 0: 401 log('ZEPHIR',1,'erreur de récupération du checksum pour '+archive+'.tar') 402 return verif_archive 403 else: 404 md5string=xmlrpclib.base64.decodestring(verif_archive[1]) 405 f_md5 = open(public_dir+os.sep+archive+'.md5','w') 406 f_md5.write(md5string) 407 f_md5.close() 408 res = os.system('cd ' + public_dir + ' ; /usr/bin/md5sum -c ' + f_md5.name) 409 os.unlink(f_md5.name) 410 if res == 0: 411 # on informe zephir que le transfert s'est bien passé (rapport ?) 412 res = convert(zephir_proxy.uucp.confirm_transfer(config.id_serveur,u(archive))) 413 if res[0] == 1: 414 return 1, 'ok' 415 else: 416 #erreur de supression de l'archive sur zephir ? 417 return 1, res[1] 418 else: 419 # log('WARNING','checksum invalide pour '+archive+'.tar') 420 return 0, 'checksum invalide pour '+archive+'.tar'
421
422 -def mod_var_path(filepath):
423 """change un chemin de fichier pour insérer 'variante' """ 424 filepath = list(os.path.split(filepath)) 425 filepath.insert(1,'variante') 426 return os.sep.join(filepath)
427
428 -def get_file_perms(base_dir, data_path, variante=False, filepath=""):
429 """renvoie les informations de permissions associées à un fichier 430 """ 431 data_dir = base_dir+os.sep+data_path 432 # lecture des informations sur le fichier si disponibles 433 if variante == True: 434 permsfile = base_dir + os.sep + 'droits_variante' 435 else: 436 permsfile = base_dir+os.sep+'droits_zephir' 437 if os.path.isfile(permsfile): 438 f_rights = file(permsfile) 439 data = f_rights.read().strip().split('\n') 440 f_rights.close() 441 else: 442 data = [] 443 mode = user = group = "" 444 recursive = False 445 if filepath != "": 446 if variante == True: 447 result = {mod_var_path(filepath):[mode, user, group, recursive]} 448 else: 449 result = {filepath:[mode, user, group, recursive]} 450 else: 451 result = {} 452 for line in data: 453 if line.startswith(filepath) or filepath == "": 454 if line.startswith(data_path): 455 try: 456 filename, mode, user, group, recursive = line.split('#') 457 if recursive != '': 458 recursive = eval(recursive) 459 if variante == True: 460 result[mod_var_path(filename)] = [mode, user, group, recursive] 461 else: 462 result[filename] = [mode, user, group, recursive] 463 if filepath != "": 464 break 465 except: 466 # fichier vide ? 467 pass 468 return result
469
470 -def sudo_script(cmd, log_prefix='ZEPHIR'):
471 res = os.system("sudo %s/scripts/%s 2>&1 >> /var/log/zephir/last_action.log" % (zephir_dir, cmd)) 472 if res != 0: 473 # log de l'erreur sur zephir (par défaut dans la rubrique divers) 474 log(log_prefix,1,"Erreur lors de l'exécution du script %s" % cmd) 475 sys.exit(1)
476
477 -def register_log(zephir_proxy, ip_zlog):
478 """mise en place d'un certificat pour envoi des logs centralisés si disponible""" 479 id_zlog = None 480 # recherche du serveur zephirlog correspondant sur zephir 481 res, managers = zephir_proxy.prelude.get_managers('zephirlogs') 482 if res != 1: 483 print_red("Erreur lors de la récupération des serveurs ZephirLogs") 484 return False 485 if managers != {}: 486 id_man, ip_manager = select_manager(ip_zlog, managers, 'zephirlogs') 487 if id_man == "": 488 print_orange("\nMise en place du certificat ZephirLogs ignoré\n\n") 489 return True 490 else: 491 if ip_zlog != ip_manager: 492 if not update_logs_conf(ip_manager): 493 print_red("""\nL'adresse ip du serveur zephirlog n'a pas pu être sauvegardée\n\n""") 494 return False 495 print_green("""\nNouvelle adresse ZephirLogs enregistrée dans la configuration : %s\n\n""" % ip_manager) 496 # mise en place de la CA du serveur ZephirLog sélectionné 497 res, ca_data = zephir_proxy.serveurs.get_file_content(id_man, 'fichiers_zephir/ca_local.crt') 498 if res != 1: 499 print_red("""\nErreur de récupération du certificat rsyslog sur Zephir : %s\n\n""" % ca_data) 500 return False 501 cert_path = os.path.join(cert_dir, 'ca-eole-rsyslog.crt') 502 f_rsyslog_cert = open(cert_path, 'w') 503 f_rsyslog_cert.write(xmlrpclib.base64.decodestring(ca_data)) 504 f_rsyslog_cert.close() 505 print_green("\nCertificat rsyslog enregistré sous %s\n\n" % cert_path) 506 return True
507 508
509 -def wait_for_port(addr, port, timeout = 20):
510 """attend qu'une connexion soit disponible sur une adresse/port 511 timeout : temps d'attente maximum avant d'abandonner (en secondes) 512 """ 513 sock_timeout = 3 514 run_time = 0 515 while run_time < timeout: 516 sock_test = socket.socket() 517 sock_test.settimeout(sock_timeout) 518 try: 519 sock_test.connect((addr, port)) 520 return True 521 except socket.timeout: 522 pass 523 except socket.error: 524 time.sleep(sock_timeout) 525 run_time += sock_timeout 526 return False
527
528 -def check_prelude_conf():
529 """récupère les options prelude définies dans la configuration creole 530 """ 531 ip_conf = '' 532 sondes = [] 533 try: 534 # si une adresse_ip est définie, on la propose par défaut 535 conf = EoleDict() 536 conf.read_dir(eoledirs) 537 conf.load_values('/etc/eole/config.eol') 538 try: 539 ip_conf = conf.get_value('adresse_ip_prelude_manager')[0] 540 except IndexError: 541 ip_conf = "" 542 if get_module_name() == 'zephirlogs': 543 print "** enregistrement prelude-lml" 544 sondes = ['prelude-lml'] 545 else: 546 for varname, var in conf.variables.items(): 547 if varname.startswith('sonde_') and var.get_final_value() == 'oui': 548 sondes.append(varname.replace('sonde_','').replace('__','-')) 549 print "** enregistrement ", varname.replace('sonde_','').replace('__','-') 550 except: 551 traceback.print_exc() 552 pass 553 return ip_conf, sondes
554
555 -def select_manager(ip_conf, managers, mgr_type = 'preludemanager'):
556 """propose le choix du manager sur lequel l'enregistrement doit s'effectuer 557 """ 558 # choix du manager 559 saisie_default = "" 560 choix = [""] 561 id_man = "" 562 ip_manager = "" 563 if ip_conf is not None: 564 ip_manager = ip_conf 565 # ip du manager donnée en paramètre, on recherche l'id correspondant 566 for id_manager, data_man in managers.items(): 567 ip_man = data_man[0] 568 libelle = data_man[1] 569 if ip_man == ip_conf: 570 id_man = id_manager 571 if id_man == "": 572 if ip_conf: 573 print_orange("\nLe serveur %s correspondant à l'ip %s n'a pas été trouvé." % (mgr_type, ip_conf)) 574 print "\nserveurs %s disponibles :\n" % mgr_type 575 id_default = "" 576 # si pas de manager spécifié, on propose un choix 577 for id_man in managers.keys(): 578 ip_man = managers[id_man][0] 579 libelle = managers[id_man][1] 580 choix.append(id_man) 581 print id_man, " -> ", ip_man, "(", libelle, ")" 582 id_man = "undef" 583 while id_man not in choix: 584 id_man = raw_input("\nIdentifiant du serveur %s à utiliser (rien pour ignorer) ? " % (mgr_type)) 585 if id_man != "": 586 ip_manager = managers[id_man][0] 587 return id_man, ip_manager
588
589 -def update_prelude_conf(ip_manager):
590 """met à jour la configuration creole du serveur et instancie les templates 591 nécessaires à l'enregistrement des sondes prelude 592 """ 593 # mise en place de la configuration 594 conf = EoleDict() 595 conf.read(os.path.join('/etc/eole/dicos/', '1_prelude.xml')) 596 prelude_files = conf.files 597 prelude_filelists = conf.filelists 598 # instanciation des fichier de configuration prelude 599 conf = EoleDict() 600 # on récupère les autres variables 601 conf.read_dir(eoledirs) 602 # on lit la configuration dans config.eol (ou zephir.eol si non instancié) 603 if os.path.isfile('/etc/eole/config.eol'): 604 conf.load_values('/etc/eole/config.eol') 605 else: 606 conf.load_values('/root/zephir.eol') 607 conf.set_value('adresse_ip_prelude_manager' , ip_manager) 608 saved = True 609 for conf_file in ['/etc/eole/config.eol', '/root/zephir.eol']: 610 if os.path.isfile(conf_file): 611 if not conf.save_values(conf_file): 612 saved = False 613 if saved: 614 # et on ne garde que les fichiers prelude 615 conf.files = prelude_files 616 conf.filelists = prelude_filelists 617 # instanciation des fichiers templates avec les valeurs chargées 618 try: 619 conf.instance() 620 except: 621 traceback.print_exc() 622 print '\n!! erreur de génération de la configuration prelude !!\n' 623 saved = False 624 return saved
625
626 -def update_logs_conf(ip_manager):
627 """met à jour la configuration creole du serveur 628 """ 629 # mise en place de la configuration 630 try: 631 conf = EoleDict() 632 conf.read(os.path.join('/etc/eole/dicos/', '1_logs.xml')) 633 # instanciation des fichier de configuration prelude 634 conf = EoleDict() 635 # on récupère les autres variables 636 conf.read_dir(eoledirs) 637 # on lit la configuration dans config.eol (ou zephir.eol si non instancié) 638 if os.path.isfile('/etc/eole/config.eol'): 639 conf.load_values('/etc/eole/config.eol') 640 else: 641 conf.load_values('/root/zephir.eol') 642 except: 643 print "Erreur à la lecture de la configuration du serveur" 644 return False 645 conf.set_value('adresse_ip_zephirlogs' , ip_manager) 646 saved = True 647 for conf_file in ['/etc/eole/config.eol', '/root/zephir.eol']: 648 if os.path.isfile(conf_file): 649 if not conf.save_values(conf_file): 650 saved = False 651 return saved
652
653 -def register_sonde(sonde, id_man, ip_manager, zephir_proxy):
654 retry = True 655 num_tries = 0 656 while retry: 657 retry = False 658 # lancement du serveur d'enregistrement à distance 659 code, pass_register = convert(zephir_proxy.prelude.register_server(id_man)) 660 if code == -1: 661 # si le serveur est déjà occupé, on attend au maximum 30 secondes (essai toutes les 5 secondes) 662 print "Un enregistrement est déjà en cours sur prelude-manager. nouvelle tentative dans 5 secondes..." 663 if num_tries < 6: 664 num_tries += 1 665 retry = True 666 time.sleep(4) 667 continue 668 else: 669 return False 670 elif code == 0: 671 return False 672 # attente de la dispo du serveur 673 print "Attente du lancement du serveur d'enregistrement sur prelude-manager" 674 conn_ok = wait_for_port(ip_manager, 5553) 675 # lancer adduser avec les paramêtres donnés 676 if conn_ok: 677 print " - enregistrement de la sonde %s" % sonde 678 options = get_options(zephir_dir) 679 if sonde in options: 680 permissions, uid, gid, services = options[sonde] 681 else: 682 permissions = "idmef:w admin:r" 683 uid = "root" 684 gid = "root" 685 services = [sonde] 686 cmd_register = '/usr/bin/prelude-admin register %s "%s" %s --uid %s --gid %s --passwd=%s 2>/dev/null' % (sonde, permissions, ip_manager, uid, gid, pass_register) 687 res = os.system(cmd_register) 688 if res != 0: 689 print "\terreur lors de l'enregistrement de %s \n\t(%s)" % (sonde, cmd_register) 690 else: 691 pass 692 res = os.system('/bin/chown %s.%s /etc/prelude/profile/%s/analyzerid' % (uid, gid, sonde)) 693 for serv in services: 694 print " - relance du service %s ..." % serv 695 res = os.system('/etc/init.d/%s restart &> /dev/null' % serv) 696 else: 697 print "\nserveur d'enregistrement non lancé ?" 698 return False 699 return True
700
701 -def register_prelude(zephir_proxy):
702 """mise en place de la configuration prelude si nécessaire""" 703 # recherche des managers disponibles 704 try: 705 ret_code, managers = convert(zephir_proxy.prelude.get_managers()) 706 except xmlrpclib.ProtocolError: 707 print("Vous n'êtes pas autorisé à utiliser les fonctionnalités prelude") 708 return False 709 except: 710 print "\n!! erreur de lecture de la configuration prelude sur zephir" 711 return False 712 if managers != {}: 713 ip_conf, sondes = check_prelude_conf() 714 id_man, ip_manager = select_manager(ip_conf, managers) 715 if id_man == "": 716 print_orange("\nEnregistrement auprès du serveur PreludeManager ignoré\n\n") 717 else: 718 if ip_manager != ip_conf: 719 if not update_prelude_conf(ip_manager): 720 print_red("""\nL'adresse ip du serveur PreludeManager n'a pas pu être sauvegardée\n\n""") 721 return False 722 else: 723 print_green("""\nNouvelle adresse PreludeManager enregistrée dans la configuration : %s\n\n""" % ip_manager) 724 # pour chaque sonde définie dans la configuration, on effectue un enregistrement (prelude-adduser) 725 err_sonde = False 726 for sonde in sondes: 727 if not register_sonde(sonde, id_man, ip_manager, zephir_proxy): 728 err_sonde = True 729 print_red ("\n Echec de l'enregistrement de la sonde %s sur le serveur Preludemanager (%s) \n\n" % (sonde, ip_manager)) 730 if err_sonde: 731 return False 732 return True
733