Distribution EOLE » Commun » creole

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

"""

Parseur LXML des fichiers XML de collecte des variables EOLE

"""

import xml.dom.minidom

from lxml import etree

#from creole.error import *

from creole.error import ConfigError

from creole.utils import string_to_bool #, get_text_node

from creole.config import VIRTMASTER

service_level = 0

file_level = 0

def parse_xml_file(filename):

    """

    @param filename: nom du fichier xml source

    @return: structure de données permettant de créer les objets Eole

    """

    try:

        document = etree.iterparse(filename, events=('end',), tag='creole')

        #document = xml.dom.minidom.parse(filename)

        return _parse_root_node(document)

    except Exception, err:

        import traceback

        traceback.print_exc()

        raise ConfigError, "Erreur lors du parsing du fichier %s : %s" % (filename, str(err))

def parse_string(string):

    # FIXME !!!

    try:

        document = xml.dom.minidom.parseString(string)

        return _parse_root_node(document)

    except Exception, err:

        raise ConfigError, "Erreur lors du parsing : %s" % str(err)

def _parse_root_node(document):

    """

    @param document: le document DOM contenant l'arborescence xml

    """

    for _, first_node in document:

        root_node = first_node

    variables = parse_variables(root_node.find('variables'))

    families, order = parse_families(root_node.find('variables'))

    # balise <files> (données sur le maître)

    file_node = root_node.findall('files')

    softwares = {}

    if file_node != []:

        if len(file_node) != 1:

            raise Exception("Erreur plusieurs balises <files> par dictionnaire")

        file_root_node = file_node[0]

        files = parse_files(file_root_node)

        file_packages = parse_packages(file_root_node)

        file_services = parse_services(file_root_node)

        softwares[VIRTMASTER] = [files, file_packages, file_services, {}, '1', '', '']

    # balise <containers> (données dans les conteneurs)

    containers_node = root_node.findall('containers')

    if containers_node != []:

        for container in containers_node:

            softwares.update(parse_containers(container))

    # gestion des contraintes

    constraint_node = root_node.findall('constraints')

    if constraint_node != []:

        constraints = parse_constraints(constraint_node[0])

    else:

        constraints = {'checks' : {},

                       'fills' : {},

                       'conditions' : {},

                       'auto' : {}

                      }

    # gestion des groupes de variables

    group_node = root_node.findall('constraints')

    if group_node != []:

        groups = parse_groups(group_node[0])

    else:

        groups = {}

    # gestion de l'aide

    help_node = root_node.findall('help')

    if help_node != []:

        helps = parse_help(help_node[0])

    else:

        helps = {'variables':{},

                 'families':{}

                }

    # gestion des séparateurs

    sep_node = root_node.findall('separators')

    if sep_node != []:

        separators = parse_separators(sep_node[0])

    else:

        separators = {}

    return softwares, variables, families, order, constraints, groups, helps, separators

def _get_boolean_attr(node, attr_name):

    """

    Gestion spécifique pour les attributs booléens

    Ils sont à False par défaut

    """

    val = node.get(attr_name)

    return str(val).lower() == 'true'

def _get_optionnal(node, attr_name):

    """

    Valeur d'un attribut optionnel

    renvoie une chaine vide au lieu de None

    """

    val = node.get(attr_name)

    if val is None:

        val = ''

    return val

def _parse_value(varnode, attr='value'):

    """

    récupération des valeurs d'une variable

    """

    return [val.text for val in varnode.findall(attr)]

def parse_variables(var_node):

    """

    traitement des variables

    @param var_node: noeud <variables>

    """

    result = {}

    for var in var_node.getiterator('variable'):

        hidden = _get_boolean_attr(var, 'hidden')

        multi = _get_boolean_attr(var, 'multi')

        redefine = _get_boolean_attr(var, 'redefine')

        exists = _get_boolean_attr(var, 'exists')

        mode = var.get('mode')

        if mode != 'expert': mode = 'normal'

        name = var.attrib['name']

        value = _parse_value(var)

        typ = _get_optionnal(var, 'type')

        desc = _get_optionnal(var, 'description')

        result[name] = dict(value=value,

                            type=typ,

                            description=desc,

                            hidden=hidden,

                            multi=multi,

                            auto='',

                            redefine=redefine,

                            exists=exists,

                            mode=mode

                            )

    return result

def _get_vars_name(family_node, family_name, family_parse):

    """

    récupération de la liste des variables associées à une famille

    """

    varsname = []

    for var in family_node.getiterator('variable'):

        # FIXME : code qui ne sert pas ?

        #try:

        #    redefine = string_to_bool(var.getAttribute('redefine'))

        #except:

        #    redefine = False

        varsname.append(var.attrib['name'])

    return varsname

def parse_families(var_node):

    """

    traitement des familles

    @param var_node: noeud <variables>

    """

    result = {}

    order = []

    for family in var_node.getiterator('family'):

        family_name = family.attrib['name']

        order.append(family_name)

        hidden = _get_boolean_attr(family, 'hidden')

        mode = family.get('mode')

        if mode != 'expert': mode = 'normal'

        result[family_name] = {'hidden':hidden, 'mode':mode,

                               'vars':_get_vars_name(family,

                                                 family_name,

                                                 result)}

    return result, order

def parse_files(file_node):

    """

    Parsing des balises <file>

    @file_node : noeud xml

    """

    global file_level

    result = {}

    for fic in file_node.getiterator('file'):

        file_level += 1

        result[fic.attrib['name']] = {'hidden':False,

                                      'source': _get_optionnal(fic,'source'),

                                      'mode': _get_optionnal(fic, 'mode'),

                                      'owner': _get_optionnal(fic, 'owner'),

                                      'group': _get_optionnal(fic, 'group'),

                                      'mkdir': _get_boolean_attr(fic, 'mkdir'),

                                      'filelist': _get_optionnal(fic, 'filelist'),

                                      'rm': _get_boolean_attr(fic, 'rm'),

                                      'del_comment': _get_optionnal(fic, 'del_comment'),

                                      'container_only': _get_boolean_attr(fic, 'container_only'),

                                      'level': file_level

                                      }

    return result

def parse_packages(package_node):

    """

    Traitement de balises <package>

    """

    return _parse_value(package_node, 'package')

def parse_services(service_node):

    """

    Traitement des balises <service>

    """

    global service_level

    result = {}

    for serv in service_node.getiterator('service'):

        service_level += 1

        method = serv.get('method')

        if not method:

            method = 'service'

        # FIXME : cas inverse de d'habitude !

        try:

            pty = string_to_bool(serv.get('pty'))

        except (TypeError, ValueError):

            pty = True

        # FIXME : cas encore différent !

        try:

            #True : seulement en mode conteneur

            #False : seulement en mode non conteneur

            #None : dans les deux modes

            in_container = string_to_bool(serv.get('in_container'))

        except (TypeError, ValueError):

            in_container = None

        #result[str(get_text_node(serv))] = {'servicelist':serv.getAttribute('servicelist'),

        result[serv.text] = {'servicelist': _get_optionnal(serv, 'servicelist'),

                             'startlevel': _get_optionnal(serv, 'startlevel'),

                             'stoplevel': _get_optionnal(serv, 'stoplevel'),

                             'method': method,

                             'pty': pty,

                             'level': service_level,

                             'in_container': in_container}

    return result

def parse_disknod(disknod_node):

    """

    Traitement de balises <disknod>

    """

    return _parse_value(disknod_node, 'disknod')

def parse_interfaces(interface_node):

    """

    Traitement des balises <interface>

    """

    result = {}

    for interface in interface_node.getiterator('interface'):

        method = interface.get('method')

        if not method:

            method = 'macvlan'

        if method not in ['macvlan', 'bridge']:

            raise Exception('method pour une interface doit être macvlan ou bridge et pas {0}'.format(method))

        result[interface.text] = {'interfacelist': _get_optionnal(interface, 'interfacelist'),

                                  'linkto': _get_optionnal(interface, 'linkto'),

                                  'ip': _get_optionnal(interface, 'ip'),

                                  'mask': _get_optionnal(interface, 'mask'),

                                  'bcast': _get_optionnal(interface, 'bcast'),

                                  'method': method

                                 }

    return result

def parse_containers(containers_node):

    result = {}

    for container_node in containers_node.getiterator('container'):

        name = container_node.attrib['name']

        containerid = _get_optionnal(container_node, 'id')

        groupid = _get_optionnal(container_node, 'group')

        if name == VIRTMASTER:

            raise Exception("Le nom '%s' est interdit pour une balise <container>" % VIRTMASTER)

        if name in result:

            raise Exception("Le nom %s doit etre unique par dictionnaire" % name)

        file_nodes = parse_files(container_node)

        packages = parse_packages(container_node)

        services = parse_services(container_node)

        interfaces = parse_interfaces(container_node)

        disknods = parse_disknod(container_node)

        result[name] = [file_nodes, packages, services, interfaces, containerid, groupid, disknods]

    return result

def parse_constraints(node):

    """

    @param node: node des contraintes

    """

    constraints = {'checks' : parse_funcs(node,'check'),

                   'fills' : parse_funcs(node,'fill'),

                   'auto' : parse_funcs(node,'auto'),

                   'conditions' : parse_conditions(node)

                  }

    return constraints

def _parse_param(param_node):

    return {'name'  : _get_optionnal(param_node, 'name'),

            'type'  : _get_optionnal(param_node, 'type'),

            'value' : param_node.text,

            'optional' : _get_optionnal(param_node, 'optional'),

            'hidden' : _get_optionnal(param_node, 'hidden'),

            }

def parse_funcs(node, func_type):

    """

    @param node: node des fonctions

    @param func_type: TagName of the functions to find

    """

    # fonctions de vérification

    funcs = {}

    for func in node.getiterator(func_type):

        # lecture des paramètres

        # XXX (adim): est-ce que le fait que params ne soit pas réinitialisé

        #             à chaque tour de boucle "for target in targets" est un bug ?

        params = []

        targets = _parse_value(func, 'target') # [ get_text_node(t) for t in func.getElementsByTagName('target') ]

        if not targets:

            targets = [_get_optionnal(func, 'target')]

        for target in targets:

            if target is not None:

                for param in func.getiterator('param'):

                    params.append(_parse_param(param))

                funcs.setdefault(target, []).append([func.attrib['name'],

                                                     params])

    return funcs

def parse_conditions(node):

    """

    @param node: node des fonctions

    """

    # fonctions de vérification

    funcs = {}

    for func in node.getiterator('condition'):

        # lecture des paramètres

        targets = []

        family_targets = []

        file_targets = []

        filelist_targets = []

        servicelist_targets = []

        interfacelist_targets = []

        # paramètres de la fonction

        params = [_parse_param(param)

                  for param in func.getiterator('param')]

        # cibles de la dépendance

        for target in func.getiterator('target'):

            ttype = target.get('type')

            if ttype == 'family':

                family_targets.append(target.text)

            elif ttype == 'file':

                file_targets.append(target.text)

            elif ttype == 'filelist':

                filelist_targets.append(target.text)

            elif ttype == 'servicelist':

                servicelist_targets.append(target.text)

            elif ttype == 'interfacelist':

                interfacelist_targets.append(target.text)

            else:

                # sinon, c'est une variable EOLE

                targets.append(target.text)

        funcdef = [func.attrib['name'], family_targets, targets,

                   file_targets, filelist_targets, servicelist_targets, interfacelist_targets, params]

        funcs.setdefault(_get_optionnal(func, 'source'), []).append(funcdef)

    return funcs

def parse_groups(node):

    """

    Traitement des groupes de variables

    """

    result = {}

    for group in node.getiterator('group'):

        slaves = _parse_value(group, 'slave')

        result[group.attrib['master']] = slaves

    return result

def parse_help(node):

    """

    Traitement de l'aide

    """

    var_help = dict( (var.attrib['name'], var.text.strip())

                     for var in node.getiterator('variable') )

    fam_help = dict( (var.attrib['name'], var.text.strip())

                     for var in node.getiterator('family') )

    return {'variables':var_help, 'families': fam_help}

def parse_separators(node):

    """dictionnaire des séparateurs, format {'variable':'text'}

    variable : nom de la première variable après le sépateur"""

    var_sep = {}

    for var in node.getiterator('separator'):

        var_sep[var.attrib['name']] = (var.text.strip(), _get_boolean_attr(var, 'never_hidden'))

    return var_sep