From f3c028005acd04706060dc00e732b1d45eff87af Mon Sep 17 00:00:00 2001
From: Jephte Clain <Jephte.Clain@univ-reunion.fr>
Date: Thu, 15 Jun 2017 01:51:48 +0400
Subject: [PATCH] =?UTF-8?q?impl=C3=A9mentation=20initiale:=20host,=20group?=
 =?UTF-8?q?,=20attr?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib/ulib/support/deploy-data.py | 489 ++++++++++++++++++++++++++++++++
 1 file changed, 489 insertions(+)
 create mode 100755 lib/ulib/support/deploy-data.py

diff --git a/lib/ulib/support/deploy-data.py b/lib/ulib/support/deploy-data.py
new file mode 100755
index 0000000..6c020e5
--- /dev/null
+++ b/lib/ulib/support/deploy-data.py
@@ -0,0 +1,489 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 mode: python -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
+
+import os, sys, re
+from os import path
+from argparse import ArgumentParser, REMAINDER
+from glob import glob
+
+USER_CONFDIR = '~/etc/deploy'
+SYSTEM_CONFDIR = '/var/local/deploy'
+
+class EOL(object):
+    __repr__ = __string__ = lambda self: 'EOL'
+EOL = EOL()
+class EOF(object):
+    __repr__ = __string__ = lambda self: 'EOF'
+EOF = EOF()
+
+class Lexer(object):
+    file = None
+    lexems = None
+    _inf = None
+    _lcount = None
+    _line = None
+
+    def __init__(self, file, parse=True):
+        self.file = file
+        if parse: self.parse()
+
+    def next_line(self):
+        line = self._inf.readline()
+        if line == '': return None
+        if line.endswith("\r\n"): line = line[:-2]
+        elif line.endswith("\n"): line = line[:-1]
+        elif line.endswith("\r"): line = line[:-1]
+        self._lcount += 1
+        self._line = line
+        return line
+
+    def is_empty(self): return self._line == ''
+    def isa_comment(self): return self._line[:1] == '#'
+    def isa_squote(self): return self._line[:1] == "'"
+    def isa_dquote(self): return self._line[:1] == '"'
+
+    RE_SPACE = re.compile(r'\s+')
+    RE_COMMENT = re.compile(r'#.*')
+    def parse_ws(self):
+        mo = self.RE_SPACE.match(self._line)
+        if mo is not None:
+            self._line = self._line[mo.end(0):]
+        mo = self.RE_COMMENT.match(self._line)
+        if mo is not None:
+            self._line = self._line[mo.end(0):]
+    def isa_space(self): return self.RE_SPACE.match(self._line) is not None
+    def isa_comment(self): return self.RE_COMMENT.match(self._line) is not None
+
+    RE_SQUOTE = re.compile(r"'")
+    def parse_sstring(self):
+        slos = self._lcount
+        lexem = ''
+        self._line = self._line[1:]
+        mo = self.RE_SQUOTE.search(self._line)
+        while mo is None:
+            lexem += self._line
+            if self.next_line() is None:
+                raise ValueError("unterminated quoted string starting at line %i" % slos)
+            lexem += "\n"
+            mo = self.RE_SQUOTE.search(self._line)
+        lexem += self._line[0:mo.start(0)]
+        self._line = self._line[mo.end(0):]
+        return lexem
+
+    RE_DQUOTE = re.compile(r'"')
+    def parse_dstring(self):
+        slos = self._lcount
+        lexem = ''
+        self._line = self._line[1:]
+        mo = self.RE_DQUOTE.search(self._line)
+        while mo is None:
+            lexem += self._line
+            if self.next_line() is None:
+                raise ValueError("unterminated double-quoted string starting at line %i" % slos)
+            lexem += "\n"
+            mo = self.RE_DQUOTE.search(self._line)
+        lexem += self._line[0:mo.start(0)]
+        self._line = self._line[mo.end(0):]
+        lexem = lexem.replace('\\"', '"')
+        lexem = lexem.replace("\\'", "'")
+        lexem = lexem.replace('\\\\', '\\')
+        return lexem
+
+    RE_EOS = re.compile(r'''\s|(?<!\\)['"]''')
+    def parse_string(self):
+        mo = self.RE_EOS.search(self._line)
+        if mo is not None:
+            lexem = self._line[0:mo.start(0)]
+            self._line = self._line[mo.start(0):]
+        else:
+            lexem = self._line
+            self._line = ''
+        lexem = lexem.replace('\\"', '"')
+        lexem = lexem.replace("\\'", "'")
+        lexem = lexem.replace('\\\\', '\\')
+        return lexem
+
+    def parse(self):
+        if self.lexems is not None: return self.lexems
+
+        lexems = self.lexems = []
+        self._inf = open(self.file, 'rb')
+        self._lcount = 0
+        self._line = ''
+        try:
+            SOL = False
+            while True:
+                # Ignorer lignes vides et commentaires
+                self.parse_ws()
+                stop = False
+                while self.is_empty():
+                    if SOL:
+                        lexems.append(EOL)
+                        SOL = False
+                    if self.next_line() is None:
+                        stop = True
+                        break
+                    self.parse_ws()
+                if stop: break
+                SOL = True
+                # Construire une chaine
+                lexem = ''
+                while True:
+                    if self.is_empty(): break
+                    elif self.isa_space(): break
+                    if self.isa_squote(): lexem += self.parse_sstring()
+                    elif self.isa_dquote(): lexem += self.parse_dstring()
+                    else: lexem += self.parse_string()
+                lexems.append(lexem)
+            lexems.append(EOF)
+            return lexems
+        finally:
+            self._inf.close()
+            self._inf = None
+        return lexems
+
+    def get_predicates(self):
+        predicates = []
+        predicate = []
+        for lexem in self.parse():
+            if lexem is EOF: break
+            elif lexem is EOL:
+                predicates.append(predicate)
+                predicate = []
+            else:
+                predicate.append(lexem)
+        return predicates
+
+class HostObject(object):
+    id = None
+    dir = None
+    hosts = None
+    attrs = None
+
+    def __init__(self, id):
+        self.id = id
+        self.hosts = []
+        self.attrs = {}
+    def get_id(self): return self.id
+    def get_dir(self): return self.dir
+    def set_dir(self, dir): self.dir = dir
+    def get_hosts(self): return self.hosts
+    def add_host(self, host):
+        if host not in self.hosts: self.hosts.append(host)
+    def get_attrs(self): return self.attrs
+    def get_attr(self, name): return self.attrs.get(name, None)
+    def set_attr(self, name, value):
+        if name not in self.attrs: self.attrs[name] = []
+        self.attrs[name].append(value)
+    def reset_attr(self, name, value=None):
+        if name in self.attrs: del self.attrs[name]
+        if value is not None: self.set_attr(name, value)
+    def copy_attrs(self, other, reset=True):
+        for name, values in other.attrs.items():
+            for value in values:
+                if reset: self.reset_attr(name, value)
+                else: self.set_attr(name, value)
+
+def split_scalar(arg):
+    if '=' in arg:
+        name, value = arg.split('=', 1)
+    else:
+        name = arg
+        value = None
+    if name.endswith('%'):
+        name = name[:-1]
+        reset = True
+    else:
+        reset = False
+    return name, reset, value
+
+def split_list(arg):
+    if '=' in arg:
+        name, values = arg.split('=', 1)
+        values = values.split(',')
+    else:
+        name = None
+        values = arg.split(',')
+    return name, values
+
+class Parser(object):
+    lexer = None
+    predicates = None
+
+    known_profiles = None
+    default_profile = None
+    default_domain = None
+
+    objects = None
+    groups = None
+    attr_otype = None
+
+    def __init__(self, lexer, parse=True):
+        self.lexer = lexer
+        self.objects = {}
+        self.groups = {}
+        self.__setup_hosts()
+        if parse: self.parse()
+
+    def parse(self):
+        self.predicates = self.lexer.get_predicates()
+        for p in self.predicates:
+            cmd = p[0]
+            args = p[1:]
+            if cmd == 'default_profile': self.handle_default_profile(args)
+            elif cmd == 'default_domain': self.handle_default_domain(args)
+            elif cmd == 'group': self.handle_group(args)
+            elif cmd == 'attr': self.handle_attr(args)
+            elif cmd == 'host': self.handle_host(args)
+
+    def get_objects(self, otype):
+        objects = self.objects[otype]
+        return [objects[id] for id in objects if id is not None]
+
+    ############################################################################
+    def reset_group(self, otype):
+        self.groups[otype]['current'] = {}
+    def reset_group_maybe(self, otype):
+        if self.groups[otype]['type'] in ('defaults', 'once'):
+            self.reset_group(otype)
+            self.groups[otype]['type'] = 'once'
+    def add_group(self, otype, id):
+        self.groups[otype]['current'][id] = True
+
+    def handle_group(self, args):
+        """group otype gtype
+        gtype peut valoir:
+        - defaults: revenir à l'état initial, permettant de spécifier les
+          attributs et liens pour tous les hôtes définis à partir de cette ligne
+        - once: un nouveau groupe est défini à chaque nouvelle ligne 'group'
+        - until: définir un groupe qui va jusqu'à la prochaine ligne 'group'
+        """
+        otype = args[0:1] and args[0] or 'host'
+        gtype = args[1:2] and args[1] or 'until'
+        self.groups[otype]['type'] = gtype
+        if gtype == 'defaults':
+            self.groups[otype]['current'] = {None: True}
+        elif gtype in ('once', 'until'):
+            self.groups[otype]['current'] = {}
+
+    ############################################################################
+    def handle_attr(self, args):
+        otype = self.attr_otype
+        assert otype is not None, "attr_otype should not be None"
+        for nv in args:
+            name, reset, value = split_scalar(nv)
+            if value is None:
+                reset = True
+                value = '1'
+            for id in self.groups[otype]['current']:
+                if reset: self.objects[otype][id].reset_attr(name)
+                self.objects[otype][id].set_attr(name, value)
+
+    ############################################################################
+    def handle_default_profile(self, args):
+        if not args or not args[0]:
+            profile = None
+        else:
+            profile = args[0]
+            if self.known_profiles is None: self.known_profiles = {}
+            self.known_profiles[profile] = True
+        self.default_profile = profile
+
+    ############################################################################
+    def handle_default_domain(self, args):
+        if not args or not args[0]:
+            domain = None
+        else:
+            domain = args[0]
+        self.default_domain = domain
+
+    ############################################################################
+    def __setup_hosts(self):
+        self.objects['host'] = {}
+        self.__host_object(None)
+        self.groups['host'] = {}
+        self.handle_group(['host', 'defaults'])
+        self.attr_otype = 'host'
+    def __fix_host(self, host):
+        if host.endswith('.'):
+            host = host[:-1]
+        elif '.' not in host and self.default_domain:
+            host = '%s.%s' % (host, self.default_domain)
+        return host
+    def __hostid(self, host):
+        host = re.sub(r'\..*', '', host)
+        host = re.sub(r'[^a-zA-Z0-9]', '_', host)
+        host = host.lower()
+        return host
+    def __hostib(self, id):
+        if re.match(r'\d+$', id): return id
+        ib = re.sub(r'^(.*?)\d+$', r'\1', id)
+        return ib
+    def __host_object(self, id):
+        ho = self.objects['host'].get(id, None)
+        if ho is None:
+            ho = HostObject(id)
+            self.objects['host'][id] = ho
+        return ho
+
+    def handle_host(self, args):
+        """host [id=]host,...
+        """
+        AP = ArgumentParser()
+        AP.add_argument('-b', '--basedir', action='append', dest='basedirs')
+        AP.add_argument('-d', '--dirspec', action='append', dest='dirspecs')
+        AP.add_argument('nvss', nargs=REMAINDER)
+        o = AP.parse_args(args)
+        # construire la liste des hôtes à traiter
+        nvss = []
+        if o.basedirs is not None:
+            for basedir in [path.expanduser(basedir) for basedir in o.basedirs]:
+                nvss.extend([path.abspath(path.join(basedir, name))
+                             for name in os.listdir(basedir)
+                             if path.isdir(path.join(basedir, name))])
+        if o.dirspecs is not None:
+            for dirspec in [path.expanduser(dirspec) for dirspec in o.dirspecs]:
+                nvss.extend([path.abspath(dir)
+                             for dir in glob(dirspec)
+                             if path.isdir(dir)])
+        nvss.extend(o.nvss)
+        # préparer la mise à jour du groupe courant
+        self.reset_group_maybe('host')
+        self.attr_otype = 'host'
+        default_ho = self.__host_object(None)
+        # traiter les hôtes
+        for nvs in nvss:
+            name, values = split_list(nvs)
+            for host in values:
+                if '/' in host:
+                    dir, host = path.split(path.abspath(path.expanduser(host)))
+                else:
+                    dir = None
+                host = self.__fix_host(host)
+                if name:
+                    ho = self.__host_object(name)
+                    ho.add_host(host)
+                    ho.copy_attrs(default_ho)
+                    if dir is not None: ho.reset_attr('dir', dir)
+                    self.add_group('host', name)
+                else:
+                    id = self.__hostid(host)
+                    ho = self.__host_object(id)
+                    ho.add_host(host)
+                    ho.copy_attrs(default_ho)
+                    if dir is not None: ho.reset_attr('dir', dir)
+                    self.add_group('host', id)
+                    ib = self.__hostib(id)
+                    ho = self.__host_object(ib)
+                    ho.add_host(host)
+                    ho.copy_attrs(default_ho)
+                    if dir is not None: ho.reset_attr('dir', dir)
+                    self.add_group('host', ib)
+
+def run_qdd(o):
+    # fichier de configuration
+    confname = o.confname or 'deploy'
+    if '/' in confname:
+        conf = path.abspath(confname)
+    elif path.exists('%s.conf' % confname):
+        conf = '%s.conf' % confname
+    else:
+        conf = confname
+        if not conf.endswith('.conf'): conf = '%s.conf' % conf
+        user_conf = path.join(path.expanduser(USER_CONFDIR), conf)
+        system_conf = path.join(SYSTEM_CONFDIR, conf)
+        if path.exists(user_conf): conf = user_conf
+        elif path.exists(system_conf): conf = system_conf
+    lexer = Lexer(conf)
+
+    if o.action == 'nop':
+        pass
+    elif o.action == 'dump': #XXX
+        parser = Parser(lexer)
+        print "=== predicates"
+        for p in parser.predicates:
+            print ' '.join(map(repr, p))
+        print "=== hosts"
+        for ho in parser.get_objects('host'):
+            id, dir, hosts = ho.get_id(), ho.get_dir(), ho.get_hosts()
+            attrs = ho.get_attrs()
+            print id
+            if dir: print "    dir=%s" % dir
+            print "    hosts=%r" % hosts
+            if attrs: print "    attrs=%r" % attrs
+    elif o.action == 'query':
+        parser = Parser(lexer)
+
+if __name__ == '__main__':
+    from argparse import ArgumentParser, HelpFormatter
+    if sys.argv[1:2] == ['--compat']:
+        # Avec l'argument --compat, désactiver la classe FancyHelpFormatter qui
+        # se base sur une API non documentée
+        sys.argv = sys.argv[0:1] + sys.argv[2:]
+        FancyHelpFormatter = HelpFormatter
+    else:
+        class FancyHelpFormatter(HelpFormatter):
+            """Comme HelpFormatter, mais ne touche pas aux lignes qui commencent par les
+            caractères '>>>'. Cela permet de mixer du texte formaté et du texte non
+            formaté.
+            """
+            def _fill_text(self, text, width, indent):
+                return ''.join([indent + line for line in text.splitlines(True)])
+            def _split_lines(self, text, width):
+                lines = ['']
+                for line in text.splitlines():
+                    if line.startswith('>>>'):
+                        lines.append(line)
+                        lines.append('')
+                    else:
+                        lines[-1] += '\n' + line
+                lines = filter(None, lines)
+                texts = []
+                for line in lines:
+                    if line.startswith('>>>'):
+                        line = line[3:]
+                        if line: texts.append(line)
+                    else:
+                        texts.extend(super(FancyHelpFormatter, self)._split_lines(line, width))
+                return texts
+    AP = ArgumentParser(
+        usage=u"%(prog)s --query FILTER",
+        description=__doc__,
+        formatter_class=FancyHelpFormatter,
+    )
+    AP.set_defaults(action='query')
+    AP.add_argument('-Q', '--query-action', action='store_const', dest='action', const='query',
+                    help=u"Interroger la base de données. C'est l'option par défaut")
+    AP.add_argument('-N', '--nop-action', action='store_const', dest='action', const='nop',
+                    help=u"Ne rien faire. Utile pour vérifier si le fichier ne contient pas d'erreur de syntaxe.")
+    AP.add_argument('-P', '--dump-action', action='store_const', dest='action', const='dump',
+                    help=u"Afficher le contenu de la base de données.")
+    AP.add_argument('-c', '--config', dest='confname',
+                    help=u"Spécifier le nom de la configuration à utiliser. Par défaut, utiliser le nom générique deploy.")
+    AP.add_argument('-q', '--query-type', dest='query_type',
+                    help=u"")
+    AP.add_argument('-j', '--object-type', dest='object_type',
+                    help=u"")
+    AP.add_argument('-t', '--link-type', dest='link_type',
+                    help=u"")
+    AP.add_argument('-p', '--profile', dest='profile',
+                    help=u"Spécifier le profil de déploiement")
+    AP.add_argument('-F', '--format', dest='format',
+                    help=u"Spécifier le format pour la sortie. La valeur par défaut est shell.")
+    AP.add_argument('-v', '--include-vars', dest='vars', metavar='VARS...',
+                    help=u"Spécifier les variables qui doivent être affichées. Par défaut, toutes les variables sont affichées.")
+    AP.add_argument('-o', '--object-vars', action='store_true', dest='object_vars',
+                    help=u"Afficher les variables associées aux objets.")
+    AP.add_argument('-d', '--dest-vars', action='store_true', dest='dest_vars',
+                    help=u"Afficher les variables associées aux hôtes destination.")
+    AP.add_argument('-l', '--link-vars', action='store_true', dest='link_vars',
+                    help=u"Afficher les variables associées aux liens.")
+    AP.add_argument('--of', '--object-func', dest='object_func', metavar='FUNC',
+                    help=u"Avec le format shell, spécifier le nom d'une fonction à afficher après les variables associées aux objets.")
+    AP.add_argument('--df', '--dest-func', dest='dest_func', metavar='FUNC',
+                    help=u"Avec le format shell, spécifier le nom d'une fonction à afficher après les variables associées aux hôtes destination.")
+    AP.add_argument('--lf', '--link-func', dest='link_func', metavar='FUNC',
+                    help=u"Avec le format shell, spécifier le nom d'une fonction à afficher après les variables associées aux liens.")
+    o = AP.parse_args()
+
+    run_qdd(o)