Distribution EOLE » Modules » Zéphir » zephir-client

#!/usr/bin/env python

# -*- coding: UTF-8 -*-

import xmlrpclib, getpass, sys, os, glob, time, shutil

# recherche des serveurs 2.3 en erreur (https://dev-eole.ac-dijon.fr/issues/7524)

LOG_FILE = '/root/rapport_purge_dico.txt'

BACKUP_DIR = '/root/backup_purge_dicts'

def log(msg, term=True):

    if os.path.isfile(LOG_FILE):

        f_rapport = open(LOG_FILE, 'a')

    else:

        f_rapport = open(LOG_FILE, 'w')

    if term:

        print("{0}".format(msg.encode('utf-8')))

    f_rapport.write("{0}\n".format(msg.encode('utf-8')))

    f_rapport.close()

def purge_dict(id_serv, dict_path):

    if not os.path.isdir(os.path.join(BACKUP_DIR, str(id_serv))):

        os.makedirs(os.path.join(BACKUP_DIR, str(id_serv)))

    shutil.move(dict_path, os.path.join(BACKUP_DIR, str(id_serv), os.path.basename(dict_path)))

def check_serveurs(z_proxy, maj_client=False, envoi_conf=False):

    rc, info_modules = z_proxy.modules.get_module()

    for mod in info_modules:

        if mod['version'] == 5:

            old_client = []

            bad_client = []

            purged = []

            conf_client = []

            log(u"\n* {0} *".format(mod['libelle']))

            rc, groupe_serv = z_proxy.serveurs.groupe_serveur({'module_actuel':mod['id']})

            for serv in groupe_serv:

                id_serv = serv['id']

                rne_serv = serv['rne']

                rc, client_ok = z_proxy.serveurs.check_min_version(id_serv, 'zephir-client', '2.3-eole59')

                if rc == 0 or client_ok == False:

                    old_client.append(str(id_serv))

                    # serveur potentiellement impacté, mise à jour du client si nécessaire

                    rc, client_nok = z_proxy.serveurs.check_min_version(id_serv, 'zephir-client', '2.3-eole58')

                    if rc == 0 or client_nok == True:

                        # client problématique détecté, demander l'installation via zephir ?

                        if maj_client:

                            # on purge les attentes en action avant envoi du nouveau client

                            rc, purge_ok = z_proxy.uucp.purge_actions([id_serv])

                            rc, maj_ok = z_proxy.uucp.maj_client(id_serv)

                            if rc == 0:

                                log(u"  ! Erreur recontrée lors de la mise à jour du client pour le serveur {0}: {1}".format(id_serv, maj_ok))

                # recherche des dictionnaires en erreur

                path_dicos = os.path.join('/var/lib/zephir/conf', rne_serv, str(id_serv), 'dicos')

                for local_dict in glob.glob(os.path.join(path_dicos, 'local', '*.xml')):

                    if os.path.exists(os.path.join(path_dicos, 'module', os.path.basename(local_dict))):

                        # dictionnaire existant au niveau module, on purge le doublon

                        purge_dict(id_serv, local_dict)

                        purged.append(str(id_serv))

                # demande d'un envoi de conf + reconfigure

                if client_ok and envoi_conf:

                    conf_client.append(str(id_serv))

                    rc, conf_ok = z_proxy.uucp.configure(id_serv, restart=1, content=2)

                    if rc == 0:

                        log(u"  ! Erreur recontrée lors de la mise à jour du client pour le serveur {0}: {1}".format(id_serv, conf_ok))

            if old_client:

                log(u"  Serveurs n'ayant pas le dernier client (ou version non remontée): {0}".format(",".join(old_client)))

            if purged:

                log(u"  Dictionnaires purgés sur les serveurs : {0}".format(",".join(purged)))

                log(u"  - Les dictionnaires purgés sont conservés dans le répertoire {0}".format(BACKUP_DIR))

            if conf_client:

                log(u"  Envoi de configuration + reconfigure sur les serveurs : {0}".format(",".join(conf_client)))

    print "\n\nUn rapport a été généré: {0}".format(LOG_FILE)

if __name__ == '__main__':

    # programme principal

    # lancé seulement si lancement en ligne de commande (pas en cas d'import dans un programme python)

    # proxy xmlrpc

    user = raw_input("nom de l'utilisateur zephir :")

    pwd = getpass.getpass("mot de passe                :")

    # pour utiliser à distance, remplacer localhost

    # par l'adresse externe de zephir et utiliser https (port 7080)

    print "\nSeulement si vous avez importé le paquet 'zephir-client_2.3-eole59' dans l'interface d'administration de zephir"

    resp = raw_input("Demander un mise à jour du client pour les serveurs ayant la version posant problème (O/N) ? [N] :")

    maj_client = resp.upper() in ('O', 'OUI')

    resp = raw_input("\nDemander un envoi de configuration (dicos/templates/patch + reconfigure) après vérification (O/N) ? [N] :")

    envoi_conf = resp.upper() in ('O', 'OUI')

    zephir_proxy = xmlrpclib.ServerProxy('http://%s:%s@127.0.0.1:7081' % (user, pwd))

    try:

        # initialisation du fichier de rapport

        log(u"\n\n{0}: -- Vérification des dictionnaires en erreur\n".format(time.ctime()))

        log(u"  Mise à jour du client : {0}".format(maj_client), False)

        log(u"  Envoi de configuration : {0}".format(envoi_conf), False)

        check_serveurs(zephir_proxy, maj_client, envoi_conf)

    except xmlrpclib.ProtocolError, err:

        print "erreur, autorisations insuffisantes"

    except Exception, err:

        print "erreur rencontrée :"

        print err