Distribution EOLE

#!/usr/bin/env python

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

import sys

if '/usr/share/eole/orl' not in sys.path:

        sys.path.append('/usr/share/eole/orl')

if '/usr/share/eole/orl/scripts' not in sys.path:

        sys.path.append('/usr/share/eole/orl/scripts')

###########################################################################

# Eole - 2014

# Copyright Pole de Competence Eole  (Ministere Education - Academie Dijon)

# Licence CeCill  cf /root/LicenceEole.txt

# eole@ac-dijon.fr

#

# migration_2.4.py

#

# squelette de script permettant de générer des configurations de migration

# en mode batch (via l'API XMLRPC de Zéphir)

#

# Ce script génère une configuration de la même façon qu'en utilisant

# le bouton "générer un configuration de migration' de l'application web.

#

# Il est possible de personnaliser la fonction update_conf pour gérer

# des variables supplémentaires non gérées par la fonction d'origine.

# (variables déclarées au niveau des variantes / serveurs).

#

###########################################################################

import csv,getpass,os

import base64,xmlrpclib

from zephir.utils.creolewrap import ZephirDict

import sys

reload(sys)

import string

# force l'encodage par défaut à utf-8 pour les chaînes unicode

sys.setdefaultencoding('utf-8')

# à redéfinir si utilisé à distance

adresse_zephir='localhost'

# délimiteur de champ pour le fichier CSV décrivant les serveurs à traiter

delimiter = ';'

# contenu des champs du fichier csv:

# id_serveur;id_variante_destination

# !!  mettre à True pour vérifier les valeurs lors de tests (la configuration ne sera pas sauvegardée) !!

debug = True

#######################################################

## FONCTIONS UTILITAIRES POUR LE TRAITEMENT DES VALEURS

def is_empty(value):

    # renvoie True si value est 'vide' :

    # liste vide / chaine vide / liste de chaines vides

    return len(u"".join(value)) == 0

def is_equal(dico, nom_var, test):

    """renvoie True si la valeur de la variable nom_var est équivalente à test

    gère le cas des chaines unicode ou non et des listes 'vides'

    """

    if nom_var in dico.liste_vars:

        if test in ([], [''], [u'']):

            if dico.get_value(nom_var) in ([], [''], [u'']):

                return True

        if dico.get_value(nom_var) == test or \

           dico.get_value(nom_var) == [test] or \

           dico.get_value(nom_var) == [unicode(test)]:

            return True

        return False

    else:

        print u"Appel de is_equal sur une variable inconnue : {0}".format(nom_var)

def copy_val(dico, nom_var, value):

    """ définit une valeur sur une variable en transformant

    les chaînes non unicode en unicode dico est une configuration 2.4

    """

    if nom_var in dico.liste_vars:

        if value == "[u'']" or  value == "['']":

            value = []

        if value != '[]' and type(value) != list:

            if value.startswith(u"["):

                value = eval(value)

        # si le dictionnaire de destination est de type 'creole3' (eole 2.4),

        # on transforme les type 'str' en 'unicode'

        if dico.version == 'creole3':

            if type(value) == list:

                for  index ,val in enumerate(value):

                    if type(val) == str:

                        value[index] = unicode(val, 'utf-8')

            elif type(value) == str:

                value = unicode(value, 'utf-8')

        dico.get_var(nom_var)

        dico.set_value(value)

    else:

        print u"Appel de copy_val sur une variable inconnue : {0}".format(nom_var)

def read_val(dico, nom_var):

    if nom_var in dico.liste_vars:

        value = dico.get_value(nom_var)

        if value == "[u'']" or  value == "['']" or value == ['']:

            value = []

        if value != '[]' and type(value) != list:

            if value.startswith(u"["):

                value = eval(value)

        if type(value) == list:

            for index,v in enumerate(value):

                if type(v) == str:

                        value[index] = unicode(v, 'utf-8')

            return value

        else:

            return unicode(dico.get_value(nom_var), 'utf-8')

    else:

        print u"Appel de read_val sur une variable inconnue : {0}".format(nom_var)

###AJOUT ORLEANS

nat_agr={"18":"20",

        "28":"21",

        "36":"22",

        "37":"23",

        "41":"24",

        "45":"25",

        "99":"25"

        }

def sub_octet_4(ip, octet4):

    octets=ip.split(".")

    octets.__delitem__(3)

    octets.append(str(octet4))

    return ".".join(octets)

def sub_octet_1D(ip):

    octets=ip.split(".")

    octets[1]="1"+octets[1]

    return ".".join(octets)

def concat_list(liste1, liste2):

    new_liste=[]

    for i in liste1:

        new_liste.append(i)

    for j in liste2:

        new_liste.append(j)

    return new_liste

######################################

## FONCTION PERSONNALISEE DE MIGRATION

def update_conf(d_eole1, d_eole2, variante, domaine, ip_amon, smtp, type_etab, statut, vm, sid, version):

    """

        traitement automatique des variables

    met à jour la configuration de migration en fonction de la configuration actuelle

    d_eole1 : dictionnaire avec la configuration d'origine du serveur

    d_eole2 : dictionnaire qui sera sauvegardé sur Zéphir comme 'migration.eol'

              (configuration à appliquer sur le serveur migré)

    variante: identifiant de la variante du serveur après migration

    proxy: proxy XMLRPC utilisable pour faire des appels à l'API Zéphir

    lire la valeur d'une variable (dico 1 ou 2):

          d_eoleX.get_value('nom_var')

          !ATTENTION! : get_value renvoie toujours une liste de valeur.

          En cas de test sur une valeur, récupérer la valeur voulue

          ex: if read_val(d_eole1,'activer_squid_auth')[0] == 'pedago':

    copier la valeur d'une variable de dico1 vers une variabel de dico2:

          copy_val(d_eole2,'nom_variable2.4',d_eole1.get_value('nom_variable2.2'))

    modifier la valeur d'une variable du dictionnaire eole 2:

          copy_val(d_eole2,'nom_var',u'valeur')

    pour une variable multiple :  copy_val(d_eole2,'nom_var',[u'valeur1',u'valeur2', ...])

    vérifier si une variable est présente dans un dictionnaire:

          if 'nom_variable' in d_eoleX.liste_vars:

              .....

    une bonne pratique peut être de créer des sous fonctions spécifiques à chaque variante

    Pour plus d'informations sur l'utilisation de l'API de Zéphir:

    https://<adresse_ip_zephir>:8070/aide/devel

    https://<adresse_ip_zephir>:8070/aide/api

    """

    # ----- inclure les traitements des variables ici

    # --- !! pour éviter des problèmes d'indentation, configurez l'éditeur pour remplacer

    # --- les tabulations par 4 espaces (ou éditez le fichier avec vi sur un module eole)

    #

    # --- Dans la mesure du possible, utilisez de préférence la modification des valeurs par défaut

    # --- des modules/variantes eole NG dans l'application web si les valeurs à renseigner sont les mêmes

    # --- pour tous les serveurs d'un(e) variante/module.

    ### Attention, pour la migration vers EOLE 2.4 :

    #

    # pour set_value sur d_eole2, il faut utiliser des chaînes unicode pour les chaînes de caractères :

    # par exemple:

    # - d_eole2.get_var('passerelle_smtp') : sélectionne la variable

    # - d_eole2.set_value(u'smtp.in.ac-dijon.fr') : applique la valeur (unicode)

    #

    # utiliser de préférence les fonction copy_val et read_val, qui convertissent les chaînes si besoin :

    # copy_val(d_eole2, 'passerelle_smtp', u'smtp.in.ac-dijon.fr') : ici, u est optionnel

    ###

    # exemple1 : mettre le nombre de cartes à 3 si le modèle de pare-feu dans la configuration amon-1.5

    # contient la chaine '3zones'

    #

    #if 'type_amon' in d_eole1.liste_vars:

    #    if '3zones' in d_eole1.get_value('type_amon'):

    #        d_eole2.dico.set_value('nombre_interfaces','3')

    # exemple2 : pour la variante 8, activer le serveur sso si le frontend ead-web est activé

    #

    #if variante == 8:

    #    if isequal(d_eole2, 'ead_web', 'oui'):

    #        copy_val(d_eole2,'adresse_ip_sso', read_val(d_eole1,'adresse_ip_eth0'))

    # exemple 3:

    #

    # passage à oui de 'activer_ajout_hosts' si des noms supplémentaires ont été ajoutés par la variante 2.4

    # (forcé à non au moment de l'upgrade si la configuration d_eole1 ne contient pas de noms supplémentaire)

    #

    #if len(d_eole2.get_value('adresse_ip_hosts')) != 0:

    #    copy_val(d_eole2, 'activer_ajout_hosts', u'oui')

        ###

    # Migration vers 2.4.2 => dictionnaire inchangé

        # Calul du département

    #

    #Cas particulier de l'upgrade 2.4.2 vers 2.5.2 => recopier le dico à l'identique

    #if version=="2.4.2":

    #    return d_eole2

    #

    rne=read_val(d_eole1,'numero_etab')[0]

    dept=rne[1:3]

    # Mise à jour des variables

    copy_val(d_eole2,'nom_domaine_local',domaine+".lan")

    copy_val(d_eole2,'web_url', read_val(d_eole1,'adresse_ip_eth0')[0])

    copy_val(d_eole2,'web_redirection','/roundcube')

    copy_val(d_eole2,'activer_exim_relay_smtp','oui')

    copy_val(d_eole2,'exim_relay_smtp', string.lower(smtp))

    copy_val(d_eole2,'system_mail_from','noreply-'+rne+'@ac-orleans-tours.fr')

    copy_val(d_eole2,'exim_address_rewrite','oui')

    copy_val(d_eole2,'exim_address_rewrite_pattern','bacula@*')

    copy_val(d_eole2,'exim_address_rewrite_replacement','noreply-'+rne+'@ac-orleans-tours.fr')

    copy_val(d_eole2,'system_mail_from_for_headers','oui') # new

    #copy_val(d_eole2,'exim_address_rewrite_flags','Ffrs') obsolète

    copy_val(d_eole2,'serveur_maj','eole.ac-dijon.fr')

    copy_val(d_eole2,'synchro_aaf_sendmail','oui') # new

    copy_val(d_eole2,'interface_gw','eth0') # forcer eth0

    copy_val(d_eole2,'nom_carte_eth0','eth0') # forcer eth0

    copy_val(d_eole2,'nom_zone_eth0','eth0') # forcer eth0

    copy_val(d_eole2,'synchro_aaf_mail','eole-exploitation@ac-orleans-tours.fr') # new

    if dept=="37" and type_etab=="clg" and statut=="PU":

        copy_val(d_eole2,'orl_bcdi','oui')

    copy_val(d_eole2,'orl_active_infoquota',read_val(d_eole1,'orl_active_infoquota')[0])

    copy_val(d_eole2,'ip_ssh_eth0','0.0.0.0')

    copy_val(d_eole2,'netmask_ssh_eth0','0.0.0.0')

    copy_val(d_eole2,'ip_admin_eth0','0.0.0.0')

    copy_val(d_eole2,'netmask_admin_eth0','0.0.0.0')

    copy_val(d_eole2,'esu_proxy','oui')

    copy_val(d_eole2,'esu_proxy_server',ip_amon)

    copy_val(d_eole2,'activer_snmpd','oui')

    copy_val(d_eole2,'snmp_allow_ip',['195.83.89.139','127.0.0.1'])

    copy_val(d_eole2,'snmp_allow_mask',['255.255.255.255','255.255.255.255'])

    copy_val(d_eole2,'snmp_community',['public','public'])

    copy_val(d_eole2,'orl_nagios','oui')

    copy_val(d_eole2,'ssh_allow_groups','nagios')

    if dept=="37" and type_etab=="clg" and statut=="PU":

        copy_val(d_eole2,'esu_proxy_bypass',['172.19.*','172.20.*','172.21.*','172.22.*','172.23.*','localhost','127.0.0.1','192.168.227.125','10.137.*'])

    else:

        copy_val(d_eole2,'esu_proxy_bypass',['172.19.*','172.20.*','172.21.*','172.22.*','172.23.*','localhost','127.0.0.1'])

    copy_val(d_eole2,'activer_bareos_dir','oui')

    copy_val(d_eole2,'activer_bareos_sd','oui')

    copy_val(d_eole2,'bareos_db_type','mysql')

    copy_val(d_eole2,'bareos_full_retention','40')

    copy_val(d_eole2,'bareos_full_retention_unit','days')

    copy_val(d_eole2,'bareos_diff_retention','40')

    copy_val(d_eole2,'bareos_diff_retention_unit','days')

    copy_val(d_eole2,'bareos_inc_retention','8')

    copy_val(d_eole2,'bareos_inc_retention_unit','days')

    if (version=="2.2" and read_val(d_eole1,'dhcp')[0]=='oui') or (version=="2.3" and read_val(d_eole1,'activer_dhcp')[0]=='oui'):

        copy_val(d_eole2,'activer_dhcp','oui')

        if read_val(d_eole1,'orl_multi_vlan_dhcp')[0] == 'oui' and read_val(d_eole1,'adresse_network_dhcp') != ['']:

            copy_val(d_eole2,'adresse_network_dhcp',concat_list(read_val(d_eole1,'adresse_network_dhcp'),read_val(d_eole1,'orl_adresse_network_dhcp')))

            copy_val(d_eole2,'adresse_netmask_dhcp',concat_list(read_val(d_eole1,'adresse_netmask_dhcp'),read_val(d_eole1,'orl_adresse_netmask_dhcp')))

            copy_val(d_eole2,'ip_basse_dhcp',concat_list(read_val(d_eole1,'ip_basse_dhcp'),read_val(d_eole1,'orl_ip_basse_dhcp')))

            copy_val(d_eole2,'ip_haute_dhcp',concat_list(read_val(d_eole1,'ip_haute_dhcp'),read_val(d_eole1,'orl_ip_haute_dhcp')))

            copy_val(d_eole2,'adresse_ip_gw_dhcp',concat_list(read_val(d_eole1,'adresse_ip_gw_dhcp'),read_val(d_eole1,'orl_adresse_ip_gw_dhcp')))

            copy_val(d_eole2,'adresse_ip_dns_dhcp',concat_list(read_val(d_eole1,'adresse_ip_dns_dhcp'),read_val(d_eole1,'orl_adresse_ip_dns_dhcp')))

            copy_val(d_eole2,'nom_domaine_dhcp',(domaine+".lan"+(','+domaine+".lan")*(len(read_val(d_eole1,'adresse_network_dhcp')) - 1)).split(","))

            copy_val(d_eole2,'orl_multi_vlan_dhcp','non')

        elif read_val(d_eole1,'orl_multi_vlan_dhcp')[0] == 'oui' and read_val(d_eole1,'adresse_network_dhcp') == ['']:

            copy_val(d_eole2,'adresse_network_dhcp',read_val(d_eole1,'orl_adresse_network_dhcp'))

            copy_val(d_eole2,'adresse_netmask_dhcp',read_val(d_eole1,'orl_adresse_netmask_dhcp'))

            copy_val(d_eole2,'ip_basse_dhcp',read_val(d_eole1,'orl_ip_basse_dhcp'))

            copy_val(d_eole2,'ip_haute_dhcp',read_val(d_eole1,'orl_ip_haute_dhcp'))

            copy_val(d_eole2,'adresse_ip_gw_dhcp',read_val(d_eole1,'orl_adresse_ip_gw_dhcp'))

            copy_val(d_eole2,'adresse_ip_dns_dhcp',read_val(d_eole1,'orl_adresse_ip_dns_dhcp'))

            if len(read_val(d_eole1,'adresse_network_dhcp')) == 1:

                copy_val(d_eole2,'nom_domaine_dhcp',domaine+".lan")

            elif len(read_val(d_eole1,'adresse_network_dhcp')) > 1:

                copy_val(d_eole2,'nom_domaine_dhcp',(domaine+".lan"+(','+domaine+".lan")*(len(read_val(d_eole1,'adresse_network_dhcp')) - 1)).split(","))

            copy_val(d_eole2,'orl_multi_vlan_dhcp','non')

        elif len(read_val(d_eole1,'adresse_network_dhcp')) == 1:

            copy_val(d_eole2,'nom_domaine_dhcp',domaine+".lan")

        elif len(read_val(d_eole1,'adresse_network_dhcp')) > 1:

            copy_val(d_eole2,'nom_domaine_dhcp',(domaine+".lan"+(','+domaine+".lan")*(len(read_val(d_eole1,'adresse_network_dhcp')) - 1)).split(","))

    if vm=="1":

        copy_val(d_eole2,'orl_vmware_tools','oui')

    #réplication

    copy_val(d_eole2,'ldap_replication','oui')

    copy_val(d_eole2,'serverID',sid)

    #paratage scan du cd45

    if dept=="45" and type_etab=="clg" and statut=="PU":

            copy_val(d_eole2,'orl_scantofolder_cd45','oui')

    if version=="2.3":

        if dept=="41" and type_etab=="clg" and statut=="PU":

        #wpkg

        #le 41 n'en veut plus

            copy_val(d_eole2,'activer_wpkg','non')

        elif version=="2.2":

            copy_val(d_eole2,'activer_wpkg','non')

        else:

            copy_val(d_eole2,'activer_wpkg',read_val(d_eole1,'orl_active_wpkg')[0])

    #ocs

    copy_val(d_eole2,'ocsinventory_agent','oui')

    copy_val(d_eole2,'ocs_agent_server_port','80')

    copy_val(d_eole2,'ocs_agent_server','http://ocs-eple.adr.ac-orleans-tours.fr')

    if vm=="1":

        copy_val(d_eole2,'ocs_agent_use_rne_as_tag','oui')

    #clamav samba - on le desactive car pose des soucis au niveau de W10

    copy_val(d_eole2,'activer_clam','non')

    #Désactivation antivirus temps réel à cause du problème  https://dev-eole.ac-dijon.fr/issues/12454

    #copy_val(d_eole2,'smb_vscan','non')

    #logs samba

    copy_val(d_eole2,'smb_log_level','1')

    #limite ibdata mysql

    copy_val(d_eole2,'orl_limit_size_mysql','oui')

    #sinon les acces ead bug

    copy_val(d_eole2,'eolesso_adresse', read_val(d_eole1,'adresse_ip_eth0')[0])

    #GLPI #0121882

    copy_val(d_eole2,'smb_socket_options', 'TCP_NODELAY')

    # ---- fin des traitements

    return d_eole2

###AJOUT ORLEANS

def get_pass():

    fic=open("/root/pwd", "r")

    pwd=fic.readline().strip()

    fic.close()

    os.system("rm -f /root/pwd")

    login=pwd.split(";")[0]

    passwd=pwd.split(";")[1]

    return [login, passwd]

######################

## FONCTION PRINCIPALE

def migrate_serveurs(fic_csv_name="", main_loop=False):

    """

    boucle principal de parcours des serveurs

    """

    login, passwd = get_pass()

    # lecture du fichier csv

    if fic_csv_name == "":

        fic_csv_name = "/root/scribe.csv"

    else:

        fic_csv_name = "/root/"+fic_csv_name

    fic_csv = open(fic_csv_name)

    parser = csv.reader(fic_csv,delimiter=delimiter)

    proxy = xmlrpclib.ServerProxy('http://%s:%s@%s:7081' % (login,passwd,adresse_zephir))

    # informations sur les module et variantes

    # parsing des données

    erreurs = []

    while True:

        try:

            # lecture d'une ligne du fichier csv

            data_serveur = parser.next()

        except StopIteration:

            # fin du fichier

            fic_csv.close()

            break

        # chaque ligne indique un numéro de serveur et le n° de la variante à utiliser après migration

        id_serveur, variante, domaine, ip_amon, smtp, type_etab, statut, vm, sid, version = data_serveur

        id_serveur = int(id_serveur)

        variante = int(variante)

        # migration du serveur (équivalent de 'générer la 'générer les données de migration' dans  l'appli web)

        try:

            # récupération du dictionnaire creole du serveur dans sa version actuelle

            code, data_ori = proxy.serveurs.get_dico(id_serveur,'modif_config',True)

            if version in ("2.2","2.3"): # passage 2.2 ou 2.3 à 2.6.2

                d_eole1 = ZephirDict(mode='')

            elif version in ("2.5.2"): # passage 2.5.2 à 2.6.2

                d_eole1 = ZephirDict(mode='', version='creole3')

            d_eole1.init_from_zephir(data_ori)

            # initialisation du dictionnaire creole2

            code, data_migration = proxy.serveurs.migrate_conf(int(id_serveur), 'migration', int(variante))

            if code == 0:

                raise Exception, data_migration

            ##  IMPORTANT, pour la migration vers eole 2.4, bien spécifier version='creole3'

            d_eole2 = ZephirDict(mode='', version='creole3')

            # initialisation du dictionnaire depuis les valeurs renvoyées par Zéphir

            d_eole2.init_from_zephir(data_migration)

            # déblocage temporaire des variables cachées et vérouillées ?

            #settings = d_eole2.dico.cfgimpl_get_settings()

            #settings.remove('disabled')

            #settings.remove('frozen')

            # mise à jour du dictionnaire de migration

            # APPEL DE LA FONCTION DE MIGRATION PERSONNALISEE

            d_eole2 = update_conf(d_eole1, d_eole2, int(variante), domaine, ip_amon, smtp, type_etab, statut, vm, sid, version)

            if debug:

                print "\n--- configuration du serveur %s\n" % id_serveur

                for var in d_eole2.liste_vars:

                    print var, '-->', d_eole2.get_value(var)

                if not main_loop:

                    # mod debug et appel depuis shell python: on retourne

                    # les 2 dictionnaires pour le premier serveur du fichier CSV

                    # pour faciliter les diagnostics

                    fic_csv.close()

                    return d_eole1, d_eole2

            else:

                save_data = d_eole2.save(force=False) #,eol_file='/tmp/test.txt')

                # sauvegarde de la conf sur zephir (migration.eol)

                code, detail = proxy.serveurs.save_conf(id_serveur, save_data, 'migration')

                print "serveur modifié : %s" % id_serveur

        except Exception, e:

            if debug:

                # trace complète en mode debug

                import traceback

                traceback.print_exc()

            print "erreur de modification du serveur %s : %s" % (id_serveur, str(e))

            erreurs.append(delimiter.join(data_serveur))

    # on stocke dans un fichier csv les serveurs non ajoutés

    if len(erreurs) > 0:

        f=open("error.csv","w")

        f.write('\n'.join(erreurs))

        f.close()

        print "\nDes erreurs ont été rencontrées :\n"

        print "- Vous pouvez consulter les logs du service zephir pour plus d'informations:\n"

        print "     /var/log/rsyslog/local/zephir_backend/zephir_backend.info.log\n"

        print "- un fichier error.csv a été généré pour relancer ce script sur les serveurs en erreur\n"

if __name__ == '__main__':

    try:

        # on regarde si un fichier csv est passé en argument

        assert os.path.isfile(sys.argv[1])

        fic_csv = sys.argv[1]

    except:

        fic_csv = ""

    migrate_serveurs(fic_csv, main_loop=True)