refine strategy to spot ip address, keep on calling guest_ipv4

[build.git] / module-tools.py

diff --git a/module-tools.py b/module-tools.py
index db72e18..7678bdc 100755 (executable)
--- a/module-tools.py
+++ b/module-tools.py
@@ -1,50 +1,57 @@
-#!/usr/bin/python -u
-
-subversion_id = "$Id$"
+#!/usr/bin/env python3

 
 import sys, os, os.path
 import re
 import time
 
 import sys, os, os.path
 import re
 import time

+import tempfile

 from glob import glob
 from optparse import OptionParser
 
 from glob import glob
 from optparse import OptionParser
 

-# e.g. other_choices = [ ('d','iff') , ('g','uess') ] - lowercase 
-def prompt (question,default=True,other_choices=[],allow_outside=False):
-    if not isinstance (other_choices,list):
+# e.g. other_choices = [ ('d','iff') , ('g','uess') ] - lowercase
+def prompt(question, default=True, other_choices=[], allow_outside=False):
+    if not isinstance(other_choices, list):

         other_choices = [ other_choices ]
     chars = [ c for (c,rest) in other_choices ]
 
     choices = []
     if 'y' not in chars:
         other_choices = [ other_choices ]
     chars = [ c for (c,rest) in other_choices ]
 
     choices = []
     if 'y' not in chars:

-        if default is True: choices.append('[y]')
-        else : choices.append('y')
+        if default is True:
+            choices.append('[y]')
+        else :
+            choices.append('y')

     if 'n' not in chars:
     if 'n' not in chars:

-        if default is False: choices.append('[n]')
-        else : choices.append('n')
+        if default is False:
+            choices.append('[n]')
+        else:
+            choices.append('n')

 
 

-    for (char,choice) in other_choices:
+    for char, choice in other_choices:

         if default == char:
         if default == char:

-            choices.append("["+char+"]"+choice)
+            choices.append("[{}]{}".format(char, choice))

         else:
         else:

-            choices.append("<"+char+">"+choice)
+            choices.append("<{}>{}>".format(char, choice))

     try:
     try:

-        answer=raw_input(question + " " + "/".join(choices) + " ? ")
+        answer = input(question + " " + "/".join(choices) + " ? ")

         if not answer:
             return default
         if not answer:
             return default

-        answer=answer[0].lower()
+        answer = answer[0].lower()

         if answer == 'y':
         if answer == 'y':

-            if 'y' in chars: return 'y'
-            else: return True
+            if 'y' in chars:
+                return 'y'
+            else:
+                return True

         elif answer == 'n':
         elif answer == 'n':

-            if 'n' in chars: return 'n'
-            else: return False
+            if 'n' in chars:
+                return 'n'
+            else:
+                return False

         elif other_choices:
             for (char,choice) in other_choices:
                 if answer == char:
                     return char
             if allow_outside:
                 return answer
         elif other_choices:
             for (char,choice) in other_choices:
                 if answer == char:
                     return char
             if allow_outside:
                 return answer

-        return prompt(question,default,other_choices)
+        return prompt(question, default, other_choices)

     except:
         raise
 
     except:
         raise
 


@@ -55,921 +62,1397 @@ def default_editor():
         editor = "emacs"
     return editor
 
         editor = "emacs"
     return editor
 

+### fold long lines
+fold_length = 132
+
+def print_fold(line):
+    while len(line) >= fold_length:
+        print(line[:fold_length],'\\')
+        line = line[fold_length:]
+    print(line)
+

 class Command:
 class Command:

-    def __init__ (self,command,options):
-        self.command=command
-        self.options=options
-        self.tmp="/tmp/command-%d"%os.getpid()
+    def __init__(self, command, options):
+        self.command = command
+        self.options = options
+        self.tmp = "/tmp/command-{}".format(os.getpid())

 
 

-    def run (self):
+    def run(self):
+        if self.options.dry_run:
+            print('dry_run', self.command)
+            return 0

         if self.options.verbose and self.options.mode not in Main.silent_modes:
         if self.options.verbose and self.options.mode not in Main.silent_modes:

-            print '+',self.command
+            print('+', self.command)

             sys.stdout.flush()
         return os.system(self.command)
 
             sys.stdout.flush()
         return os.system(self.command)
 

-    def run_silent (self):
+    def run_silent(self):
+        if self.options.dry_run:
+            print('dry_run', self.command)
+            return 0

         if self.options.verbose:
         if self.options.verbose:

-            print '+',self.command,' .. ',
+            print('>', os.getcwd())
+            print('+', self.command, ' .. ', end=' ')

             sys.stdout.flush()
             sys.stdout.flush()

-        retcod=os.system(self.command + " &> " + self.tmp)
+        retcod = os.system("{} &> {}".format(self.command, self.tmp))

         if retcod != 0:
         if retcod != 0:

-            print "FAILED ! -- out+err below (command was %s)"%self.command
-            os.system("cat " + self.tmp)
-            print "FAILED ! -- end of quoted output"
+            print("FAILED ! -- out+err below (command was {})".format(self.command))
+            os.system("cat {}".format(self.tmp))
+            print("FAILED ! -- end of quoted output")

         elif self.options.verbose:
         elif self.options.verbose:

-            print "OK"
+            print("OK")

         os.unlink(self.tmp)
         return retcod
 
     def run_fatal(self):
         os.unlink(self.tmp)
         return retcod
 
     def run_fatal(self):

-        if self.run_silent() !=0:
-            raise Exception,"Command %s failed"%self.command
+        if self.run_silent() != 0:
+            raise Exception("Command {} failed".format(self.command))

 
     # returns stdout, like bash's $(mycommand)
 
     # returns stdout, like bash's $(mycommand)

-    def output_of (self,with_stderr=False):
-        tmp="/tmp/status-%d"%os.getpid()
+    def output_of(self, with_stderr=False, binary=False):
+        if self.options.dry_run:
+            print('dry_run', self.command)
+            return 'dry_run output'
+        tmp="/tmp/status-{}".format(os.getpid())

         if self.options.debug:
         if self.options.debug:

-            print '+',self.command,' .. ',
+            print('+',self.command,' .. ', end=' ')

             sys.stdout.flush()
             sys.stdout.flush()

-        command=self.command
+        command = self.command

         if with_stderr:
             command += " &> "
         else:
             command += " > "
         command += tmp
         os.system(command)
         if with_stderr:
             command += " &> "
         else:
             command += " > "
         command += tmp
         os.system(command)

-        result=file(tmp).read()
+        mode = "r" if not binary else "rb"
+        with open(tmp, mode) as f:
+            result=f.read()

         os.unlink(tmp)
         if self.options.debug:
         os.unlink(tmp)
         if self.options.debug:

-            print 'Done',
+            print('Done', end=' ')

         return result
 
         return result
 

-class Svnpath:
-    def __init__(self,path,options):
-        self.path=path
-        self.options=options
+class GitRepository:
+    type = "git"
+
+    def __init__(self, path, options):
+        self.path = path
+        self.options = options
+
+    def name(self):
+        return os.path.basename(self.path)
+
+    def url(self):
+        return self.repo_root()
+
+    def gitweb(self):
+        c = Command("git show | grep commit | awk '{{print $2;}}'", self.options)
+        out = self.__run_in_repo(c.output_of).strip()
+        return "http://git.onelab.eu/?p={}.git;a=commit;h={}".format(self.name(), out)
+
+    def repo_root(self):
+        c = Command("git remote show origin", self.options)
+        out = self.__run_in_repo(c.output_of)
+        for line in out.split('\n'):
+            if line.strip().startswith("Fetch URL:"):
+                return line.split()[2]
+
+    @classmethod
+    def clone(cls, remote, local, options, depth=None):
+        Command("rm -rf {}".format(local), options).run_silent()
+        depth_option = "" if depth is None else " --depth {}".format(depth)
+        Command("git clone{} {} {}".format(depth_option, remote, local), options).run_fatal()
+        return GitRepository(local, options)
+
+    @classmethod
+    def remote_exists(cls, remote, options):
+        return Command("git --no-pager ls-remote {} &> /dev/null".format(remote), options).run()==0
+
+    def tag_exists(self, tagname):
+        command = 'git tag -l | grep "^{}$"'.format(tagname)
+        c = Command(command, self.options)
+        out = self.__run_in_repo(c.output_of, with_stderr=True)
+        return len(out) > 0
+
+    def __run_in_repo(self, fun, *args, **kwargs):
+        cwd = os.getcwd()
+        os.chdir(self.path)
+        ret = fun(*args, **kwargs)
+        os.chdir(cwd)
+        return ret
+
+    def __run_command_in_repo(self, command, ignore_errors=False):
+        c = Command(command, self.options)
+        if ignore_errors:
+            return self.__run_in_repo(c.output_of)
+        else:
+            return self.__run_in_repo(c.run_fatal)
+
+    def __is_commit_id(self, id):
+        c = Command("git show {} | grep commit | awk '{{print $2;}}'".format(id), self.options)
+        ret = self.__run_in_repo(c.output_of, with_stderr=False)
+        if ret.strip() == id:
+            return True
+        return False
+
+    def update(self, subdir=None, recursive=None, branch="master"):
+        if branch == "master":
+            self.__run_command_in_repo("git checkout {}".format(branch))
+        else:
+            self.to_branch(branch, remote=True)
+        self.__run_command_in_repo("git fetch origin --tags", ignore_errors=True)
+        self.__run_command_in_repo("git fetch origin")
+        if not self.__is_commit_id(branch):
+            # we don't need to merge anything for commit ids.
+            self.__run_command_in_repo("git merge --ff origin/{}".format(branch))
+
+    def to_branch(self, branch, remote=True):
+        self.revert()
+        if remote:
+            command = "git branch --track {} origin/{}".format(branch, branch)
+            c = Command(command, self.options)
+            self.__run_in_repo(c.output_of, with_stderr=True)
+        return self.__run_command_in_repo("git checkout {}".format(branch))
+
+    def to_tag(self, tag):
+        self.revert()
+        return self.__run_command_in_repo("git checkout {}".format(tag))
+
+    def tag(self, tagname, logfile):
+        self.__run_command_in_repo("git tag {} -F {}".format(tagname, logfile))
+        self.commit(logfile)
+
+    def diff(self, f=""):
+        c = Command("git diff {}".format(f), self.options)
+        try:
+            return self.__run_in_repo(c.output_of, with_stderr=True)
+        except:
+            return self.__run_in_repo(c.output_of, with_stderr=True, binary=True)
+
+    def diff_with_tag(self, tagname):
+        c = Command("git diff {}".format(tagname), self.options)
+        try:
+            return self.__run_in_repo(c.output_of, with_stderr=True)
+        except:
+            return self.__run_in_repo(c.output_of, with_stderr=True, binary=True)
+
+    def commit(self, logfile, branch="master"):
+        self.__run_command_in_repo("git add .", ignore_errors=True)
+        self.__run_command_in_repo("git add -u", ignore_errors=True)
+        self.__run_command_in_repo("git commit -F  {}".format(logfile), ignore_errors=True)
+        if branch == "master" or self.__is_commit_id(branch):
+            self.__run_command_in_repo("git push")
+        else:
+            self.__run_command_in_repo("git push origin {}:{}".format(branch, branch))
+        self.__run_command_in_repo("git push --tags", ignore_errors=True)
+
+    def revert(self, f=""):
+        if f:
+            self.__run_command_in_repo("git checkout {}".format(f))
+        else:
+            # revert all
+            self.__run_command_in_repo("git --no-pager reset --hard")
+            self.__run_command_in_repo("git --no-pager clean -f")
+
+    def is_clean(self):
+        def check_commit():
+            command = "git status"
+            s = "nothing to commit, working directory clean"
+            return Command(command, self.options).output_of(True).find(s) >= 0
+        return self.__run_in_repo(check_commit)
+
+    def is_valid(self):
+        return os.path.exists(os.path.join(self.path, ".git"))
+
+
+class Repository:
+    """
+    Generic repository
+    From old times when we had svn and git
+    """
+    supported_repo_types = [ GitRepository ]
+
+    def __init__(self, path, options):
+        self.path = path
+        self.options = options
+        for repo_class in self.supported_repo_types:
+            self.repo = repo_class(self.path, self.options)
+            if self.repo.is_valid():
+                break
+
+    @classmethod
+    def remote_exists(cls, remote, options):
+        for repo_class in Repository.supported_repo_types:
+            if repo_class.remote_exists(remote, options):
+                return True
+        return False

 
 

-    def url_exists (self):
-        return os.system("svn list %s &> /dev/null"%self.path) == 0
+    def __getattr__(self, attr):
+        return getattr(self.repo, attr)

 
 

-    def dir_needs_revert (self):
-        command="svn status %s"%self.path
-        return len(Command(command,self.options).output_of(True)) != 0
-    # turns out it's the same implem.
-    def file_needs_commit (self):
-        command="svn status %s"%self.path
-        return len(Command(command,self.options).output_of(True)) != 0

 
 

+
+# support for tagged module is minimal, and is for the Build class only

 class Module:
 
 class Module:
 

-    svn_magic_line="--This line, and those below, will be ignored--"
-    
-    redirectors=[ # ('module_name_varname','name'),
-                  ('module_version_varname','version'),
-                  ('module_taglevel_varname','taglevel'), ]
+    edit_magic_line = "--This line, and those below, will be ignored--"
+    setting_tag_format = "Setting tag {}"
+
+    redirectors = [
+        # ('module_name_varname', 'name'),
+        ('module_version_varname', 'version'),
+        ('module_taglevel_varname', 'taglevel'),
+    ]

 
     # where to store user's config
 
     # where to store user's config

-    config_storage="CONFIG"
-    # 
-    config={}
-
-    import commands
-    configKeys=[ ('svnpath',"Enter your toplevel svnpath",
-                  "svn+ssh://%s@svn.planet-lab.org/svn/"%commands.getoutput("id -un")),
-                 ("build", "Enter the name of your build module","build"),
-                 ('username',"Enter your firstname and lastname for changelogs",""),
-                 ("email","Enter your email address for changelogs",""),
-                 ]
+    config_storage = "CONFIG"
+    #
+    config = {}
+
+    import subprocess
+    configKeys = [
+        ('gitserver', "Enter your git server's hostname", "git.onelab.eu"),
+        ('gituser', "Enter your user name (login name) on git server", subprocess.getoutput("id -un")),
+        ("build", "Enter the name of your build module", "build"),
+        ('username', "Enter your firstname and lastname for changelogs", ""),
+        ("email", "Enter your email address for changelogs", ""),
+    ]
+
+    @classmethod
+    def prompt_config_option(cls, key, message, default):
+        cls.config[key]=input("{} [{}] : ".format(message,default)).strip() or default
+
+    @classmethod
+    def prompt_config(cls):
+        for (key,message,default) in cls.configKeys:
+            cls.config[key]=""
+            while not cls.config[key]:
+                cls.prompt_config_option(key, message, default)

 
 

-    @staticmethod
-    def prompt_config ():
-        for (key,message,default) in Module.configKeys:
-            Module.config[key]=""
-            while not Module.config[key]:
-                Module.config[key]=raw_input("%s [%s] : "%(message,default)).strip() or default
+    # for parsing module spec name:branch
+    matcher_branch_spec = re.compile("\A(?P<name>[\w\.\-\/]+):(?P<branch>[\w\.\-]+)\Z")
+    # special form for tagged module - for Build
+    matcher_tag_spec = re.compile("\A(?P<name>[\w\.\-\/]+)@(?P<tagname>[\w\.\-]+)\Z")

 
 

+    # parsing specfiles
+    matcher_rpm_define = re.compile("%(define|global)\s+(\S+)\s+(\S*)\s*")

 
 

-    # for parsing module spec name:branch
-    matcher_branch_spec=re.compile("\A(?P<name>[\w-]+):(?P<branch>[\w\.-]+)\Z")
-    matcher_rpm_define=re.compile("%(define|global)\s+(\S+)\s+(\S*)\s*")
+    @classmethod
+    def parse_module_spec(cls, module_spec):
+        name = branch_or_tagname = module_type = ""

 
 

-    def __init__ (self,module_spec,options):
-        # parse module spec
-        attempt=Module.matcher_branch_spec.match(module_spec)
+        attempt = Module.matcher_branch_spec.match(module_spec)

         if attempt:
         if attempt:

-            self.name=attempt.group('name')
-            self.branch=attempt.group('branch')
+            module_type = "branch"
+            name=attempt.group('name')
+            branch_or_tagname=attempt.group('branch')

         else:
         else:

-            self.name=module_spec
-            self.branch=None
+            attempt = Module.matcher_tag_spec.match(module_spec)
+            if attempt:
+                module_type = "tag"
+                name=attempt.group('name')
+                branch_or_tagname=attempt.group('tagname')
+            else:
+                name = module_spec
+        return name, branch_or_tagname, module_type

 
 

-        self.options=options
-        self.moddir="%s/%s"%(options.workdir,self.name)

 
 

-    def friendly_name (self):
-        if not self.branch:
-            return self.name
-        else:
-            return "%s:%s"%(self.name,self.branch)
+    def __init__(self, module_spec, options):
+        # parse module spec
+        self.pathname, branch_or_tagname, module_type = self.parse_module_spec(module_spec)
+        self.name = os.path.basename(self.pathname)

 
 

-    def edge_dir (self):
-        if not self.branch:
-            return "%s/trunk"%(self.moddir)
-        else:
-            return "%s/branches/%s"%(self.moddir,self.branch)
+        if module_type == "branch":
+            self.branch = branch_or_tagname
+        elif module_type == "tag":
+            self.tagname = branch_or_tagname

 
 

-    def tags_dir (self):
-        return "%s/tags"%(self.moddir)
+        self.options=options
+        self.module_dir="{}/{}".format(options.workdir,self.pathname)
+        self.repository = None
+        self.build = None

 
 

-    def run (self,command):
+    def run(self,command):

         return Command(command,self.options).run()
         return Command(command,self.options).run()

-    def run_fatal (self,command):
+    def run_fatal(self,command):

         return Command(command,self.options).run_fatal()
         return Command(command,self.options).run_fatal()

-    def run_prompt (self,message,command):
+    def run_prompt(self,message,fun, *args):
+        fun_msg = "{}({})".format(fun.__name__, ",".join(args))

         if not self.options.verbose:
             while True:
         if not self.options.verbose:
             while True:

-                choice=prompt(message,True,('s','how'))
-                if choice is True:
-                    self.run(command)
-                    return
-                elif choice is False:
+                choice = prompt(message, True, ('s','how'))
+                if choice:
+                    fun(*args)

                     return
                 else:
                     return
                 else:

-                    print 'About to run:',command
+                    print('About to run function:', fun_msg)
+        else:
+            question = "{} - want to run function: {}".format(message, fun_msg)
+            if prompt(question, True):
+                fun(*args)
+
+    def friendly_name(self):
+        if hasattr(self, 'branch'):
+            return "{}:{}".format(self.pathname, self.branch)
+        elif hasattr(self, 'tagname'):
+            return "{}@{}".format(self.pathname, self.tagname)

         else:
         else:

-            question=message+" - want to run " + command
-            if prompt(question,True):
-                self.run(command)            
+            return self.pathname

 
 

-    @staticmethod
-    def init_homedir (options):
-        topdir=options.workdir
+    @classmethod
+    def git_remote_dir(cls, name):
+        return "{}@{}:/git/{}.git".format(cls.config['gituser'], cls.config['gitserver'], name)
+
+    ####################
+    @classmethod
+    def init_homedir(cls, options):

         if options.verbose and options.mode not in Main.silent_modes:
         if options.verbose and options.mode not in Main.silent_modes:

-            print 'Checking for',topdir
-        storage="%s/%s"%(topdir,Module.config_storage)
+            print('Checking for', options.workdir)
+        storage="{}/{}".format(options.workdir, cls.config_storage)

         # sanity check. Either the topdir exists AND we have a config/storage
         # or topdir does not exist and we create it
         # sanity check. Either the topdir exists AND we have a config/storage
         # or topdir does not exist and we create it

-        # to avoid people use their own daily svn repo
-        if os.path.isdir(topdir) and not os.path.isfile(storage):
-            print """The directory %s exists and has no CONFIG file
+        # to avoid people use their own daily work repo
+        if os.path.isdir(options.workdir) and not os.path.isfile(storage):
+            print("""The directory {} exists and has no CONFIG file

 If this is your regular working directory, please provide another one as the
 If this is your regular working directory, please provide another one as the

-module-* commands need a fresh working dir. Make sure that you do not use 
-that for other purposes than tagging"""%topdir
+module-* commands need a fresh working dir. Make sure that you do not use
+that for other purposes than tagging""".format(options.workdir))

             sys.exit(1)
             sys.exit(1)

-        if not os.path.isdir (topdir):
-            print "Cannot find",topdir,"let's create it"
-            Module.prompt_config()
-            print "Checking ...",
-            Command("svn co -N %s %s"%(Module.config['svnpath'],topdir),options).run_fatal()
-            Command("svn co -N %s/%s %s/%s"%(Module.config['svnpath'],
-                                             Module.config['build'],
-                                             topdir,
-                                             Module.config['build']),options).run_fatal()
-            print "OK"
-            
-            # store config
-            f=file(storage,"w")
-            for (key,message,default) in Module.configKeys:
-                f.write("%s=%s\n"%(key,Module.config[key]))
-            f.close()
+
+        def clone_build():
+            print("Checking out build module...")
+            remote = cls.git_remote_dir(cls.config['build'])
+            local = os.path.join(options.workdir, cls.config['build'])
+            GitRepository.clone(remote, local, options, depth=1)
+            print("OK")
+
+        def store_config():
+            with open(storage, 'w') as f:
+                for (key, message, default) in Module.configKeys:
+                    f.write("{}={}\n".format(key, Module.config[key]))

             if options.debug:
             if options.debug:

-                print 'Stored',storage
-                Command("cat %s"%storage,options).run()
-        else:
+                print('Stored', storage)
+                Command("cat {}".format(storage),options).run()
+
+        def read_config():

             # read config
             # read config

-            f=open(storage)
-            for line in f.readlines():
-                (key,value)=re.compile("^(.+)=(.+)$").match(line).groups()
-                Module.config[key]=value                
-            f.close()
+            with open(storage) as f:
+                for line in f.readlines():
+                    key, value = re.compile("^(.+)=(.+)$").match(line).groups()
+                    Module.config[key] = value
+
+            # owerride config variables using options.
+            if options.build_module:
+                Module.config['build'] = options.build_module
+
+        if not os.path.isdir(options.workdir):
+            print("Cannot find {}, let's create it".format(options.workdir))
+            Command("mkdir -p {}".format(options.workdir), options).run_silent()
+            cls.prompt_config()
+            clone_build()
+            store_config()
+        else:
+            read_config()
+            # check missing config options
+            old_layout = False
+            for key, message, default in cls.configKeys:
+                if key not in Module.config:
+                    print("Configuration changed for module-tools")
+                    cls.prompt_config_option(key, message, default)
+                    old_layout = True
+
+            if old_layout:
+                Command("rm -rf {}".format(options.workdir), options).run_silent()
+                Command("mkdir -p {}".format(options.workdir), options).run_silent()
+                clone_build()
+                store_config()
+
+            build_dir = os.path.join(options.workdir, cls.config['build'])
+            if not os.path.isdir(build_dir):
+                clone_build()
+            else:
+                build = Repository(build_dir, options)
+                if not build.is_clean():
+                    print("build module needs a revert")
+                    build.revert()
+                    print("OK")
+                build.update()
+

         if options.verbose and options.mode not in Main.silent_modes:
         if options.verbose and options.mode not in Main.silent_modes:

-            print '******** Using config'
+            print('******** Using config')

             for (key,message,default) in Module.configKeys:
             for (key,message,default) in Module.configKeys:

-                print '\t',key,'=',Module.config[key]
+                print('\t{} = {}'.format(key,Module.config[key]))

 
 

-    def init_moddir (self):
+    def init_module_dir(self):

         if self.options.verbose:
         if self.options.verbose:

-            print 'Checking for',self.moddir
-        if not os.path.isdir (self.moddir):
-            self.run_fatal("svn up -N %s"%self.moddir)
-        if not os.path.isdir (self.moddir):
-            raise Exception, 'Cannot find %s - check module name'%self.moddir
+            print('Checking for', self.module_dir)
+
+        if not os.path.isdir(self.module_dir):
+            self.repository = GitRepository.clone(self.git_remote_dir(self.pathname),
+                                                  self.module_dir,
+                                                  self.options)
+
+        self.repository = Repository(self.module_dir, self.options)
+
+        if self.repository.type == "git":
+            if hasattr(self, 'branch'):
+                self.repository.to_branch(self.branch)
+            elif hasattr(self, 'tagname'):
+                self.repository.to_tag(self.tagname)
+        else:
+            raise Exception('Cannot find {} - or not a git module'.format(self.module_dir))

 
 

-    def init_subdir (self,fullpath):
-        if self.options.verbose:
-            print 'Checking for',fullpath
-        if not os.path.isdir (fullpath):
-            self.run_fatal("svn up -N %s"%fullpath)

 
 

-    def revert_subdir (self,fullpath):
+    def revert_module_dir(self):

         if self.options.fast_checks:
         if self.options.fast_checks:

-            if self.options.verbose: print 'Skipping revert of %s'%fullpath
+            if self.options.verbose: print('Skipping revert of {}'.format(self.module_dir))

             return
         if self.options.verbose:
             return
         if self.options.verbose:

-            print 'Checking whether',fullpath,'needs being reverted'
-        if Svnpath(fullpath,self.options).dir_needs_revert():
-            self.run_fatal("svn revert -R %s"%fullpath)
+            print('Checking whether', self.module_dir, 'needs being reverted')

 
 

-    def update_subdir (self,fullpath):
+        if not self.repository.is_clean():
+            self.repository.revert()
+
+    def update_module_dir(self):

         if self.options.fast_checks:
         if self.options.fast_checks:

-            if self.options.verbose: print 'Skipping update of %s'%fullpath
+            if self.options.verbose: print('Skipping update of {}'.format(self.module_dir))

             return
         if self.options.verbose:
             return
         if self.options.verbose:

-            print 'Updating',fullpath
-        self.run_fatal("svn update -N %s"%fullpath)
-
-    def init_edge_dir (self):
-        # if branch, edge_dir is two steps down
-        if self.branch:
-            self.init_subdir("%s/branches"%self.moddir)
-        self.init_subdir(self.edge_dir())
+            print('Updating', self.module_dir)

 
 

-    def revert_edge_dir (self):
-        self.revert_subdir(self.edge_dir())
-
-    def update_edge_dir (self):
-        self.update_subdir(self.edge_dir())
-
-    def main_specname (self):
-        attempt="%s/%s.spec"%(self.edge_dir(),self.name)
-        if os.path.isfile (attempt):
-            return attempt
+        if hasattr(self, 'branch'):
+            self.repository.update(branch=self.branch)
+        elif hasattr(self, 'tagname'):
+            self.repository.update(branch=self.tagname)

         else:
         else:

-            try:
-                return glob("%s/*.spec"%self.edge_dir())[0]
-            except:
-                raise Exception, 'Cannot guess specfile for module %s'%self.name
-
-    def all_specnames (self):
-        return glob("%s/*.spec"%self.edge_dir())
+            self.repository.update()

 
 

-    def parse_spec (self, specfile, varnames):
+    def main_specname(self):
+        attempt = "{}/{}.spec".format(self.module_dir, self.name)
+        if os.path.isfile(attempt):
+            return attempt
+        pattern1 = "{}/*.spec".format(self.module_dir)
+        level1 = glob(pattern1)
+        if level1:
+            return level1[0]
+        pattern2 = "{}/*/*.spec".format(self.module_dir)
+        level2 = glob(pattern2)
+
+        if level2:
+            return level2[0]
+        raise Exception('Cannot guess specfile for module {} -- patterns were {} or {}'\
+                        .format(self.pathname,pattern1,pattern2))
+
+    def all_specnames(self):
+        level1 = glob("{}/*.spec".format(self.module_dir))
+        if level1:
+            return level1
+        level2 = glob("{}/*/*.spec".format(self.module_dir))
+        return level2
+
+    def parse_spec(self, specfile, varnames):

         if self.options.verbose:
         if self.options.verbose:

-            print 'Parsing',specfile,
+            print('Parsing',specfile, end=' ')

             for var in varnames:
             for var in varnames:

-                print "[%s]"%var,
-            print ""
+                print("[{}]".format(var), end=' ')
+            print("")

         result={}
         result={}

-        f=open(specfile)
-        for line in f.readlines():
-            attempt=Module.matcher_rpm_define.match(line)
-            if attempt:
-                (define,var,value)=attempt.groups()
-                if var in varnames:
-                    result[var]=value
-        f.close()
+        with open(specfile, encoding='utf-8') as f:
+            for line in f.readlines():
+                attempt = Module.matcher_rpm_define.match(line)
+                if attempt:
+                    define, var, value = attempt.groups()
+                    if var in varnames:
+                        result[var] = value

         if self.options.debug:
         if self.options.debug:

-            print 'found',len(result),'keys'
-            for (k,v) in result.iteritems():
-                print k,'=',v
+            print('found {} keys'.format(len(result)))
+            for k, v in result.items():
+                print('{} = {}'.format(k, v))

         return result
         return result

-                
+

     # stores in self.module_name_varname the rpm variable to be used for the module's name
     # and the list of these names in self.varnames
     # stores in self.module_name_varname the rpm variable to be used for the module's name
     # and the list of these names in self.varnames

-    def spec_dict (self):
-        specfile=self.main_specname()
-        redirector_keys = [ varname for (varname,default) in Module.redirectors]
-        redirect_dict = self.parse_spec(specfile,redirector_keys)
+    def spec_dict(self):
+        specfile = self.main_specname()
+        redirector_keys = [ varname for (varname, default) in Module.redirectors]
+        redirect_dict = self.parse_spec(specfile, redirector_keys)

         if self.options.debug:
         if self.options.debug:

-            print '1st pass parsing done, redirect_dict=',redirect_dict
-        varnames=[]
-        for (varname,default) in Module.redirectors:
-            if redirect_dict.has_key(varname):
-                setattr(self,varname,redirect_dict[varname])
+            print('1st pass parsing done, redirect_dict=', redirect_dict)
+        varnames = []
+        for varname, default in Module.redirectors:
+            if varname in redirect_dict:
+                setattr(self, varname, redirect_dict[varname])

                 varnames += [redirect_dict[varname]]
             else:
                 varnames += [redirect_dict[varname]]
             else:

-                setattr(self,varname,default)
-                varnames += [ default ] 
+                setattr(self, varname, default)
+                varnames += [ default ]

         self.varnames = varnames
         self.varnames = varnames

-        result = self.parse_spec (specfile,self.varnames)
+        result = self.parse_spec(specfile, self.varnames)

         if self.options.debug:
         if self.options.debug:

-            print '2st pass parsing done, varnames=',varnames,'result=',result
+            print('2st pass parsing done, varnames={} result={}'.format(varnames, result))

         return result
 
         return result
 

-    def patch_spec_var (self, patch_dict,define_missing=False):
+    def patch_spec_var(self, patch_dict,define_missing=False):

         for specfile in self.all_specnames():
             # record the keys that were changed
         for specfile in self.all_specnames():
             # record the keys that were changed

-            changed = dict ( [ (x,False) for x in patch_dict.keys() ] )
-            newspecfile=specfile+".new"
+            changed = {x : False  for x in list(patch_dict.keys()) }
+            newspecfile = "{}.new".format(specfile)

             if self.options.verbose:
             if self.options.verbose:

-                print 'Patching',specfile,'for',patch_dict.keys()
-            spec=open (specfile)
-            new=open(newspecfile,"w")
-
-            for line in spec.readlines():
-                attempt=Module.matcher_rpm_define.match(line)
-                if attempt:
-                    (define,var,value)=attempt.groups()
-                    if var in patch_dict.keys():
-                        if self.options.debug:
-                            print 'rewriting %s as %s'%(var,patch_dict[var])
-                        new.write('%%%s %s %s\n'%(define,var,patch_dict[var]))
-                        changed[var]=True
-                        continue
-                new.write(line)
-            if define_missing:
-                for (key,was_changed) in changed.iteritems():
-                    if not was_changed:
-                        if self.options.debug:
-                            print 'rewriting missing %s as %s'%(key,patch_dict[key])
-                        new.write('\n%%define %s %s\n'%(key,patch_dict[key]))
-            spec.close()
-            new.close()
-            os.rename(newspecfile,specfile)
-
-    def unignored_lines (self, logfile):
-        result=[]
-        exclude="Tagging module %s"%self.name
+                print('Patching', specfile, 'for', list(patch_dict.keys()))
+
+            with open(specfile, encoding='utf-8') as spec:
+                with open(newspecfile, "w", encoding='utf-8') as new:
+                    for line in spec.readlines():
+                        attempt = Module.matcher_rpm_define.match(line)
+                        if attempt:
+                            define, var, value = attempt.groups()
+                            if var in list(patch_dict.keys()):
+                                if self.options.debug:
+                                    print('rewriting {} as {}'.format(var, patch_dict[var]))
+                                new.write('%{} {} {}\n'.format(define, var, patch_dict[var]))
+                                changed[var] = True
+                                continue
+                        new.write(line)
+                    if define_missing:
+                        for key, was_changed in changed.items():
+                            if not was_changed:
+                                if self.options.debug:
+                                    print('rewriting missing {} as {}'.format(key, patch_dict[key]))
+                                new.write('\n%define {} {}\n'.format(key, patch_dict[key]))
+            os.rename(newspecfile, specfile)
+
+    # returns all lines until the magic line
+    def unignored_lines(self, logfile):
+        result = []

         white_line_matcher = re.compile("\A\s*\Z")
         white_line_matcher = re.compile("\A\s*\Z")

-        for logline in file(logfile).readlines():
-            if logline.strip() == Module.svn_magic_line:
-                break
-            if logline.find(exclude) >= 0:
-                continue
-            elif white_line_matcher.match(logline):
-                continue
-            else:
-                result.append(logline.strip()+'\n')
+        with open(logfile) as f:
+            for logline in f.readlines():
+                if logline.strip() == Module.edit_magic_line:
+                    break
+                elif white_line_matcher.match(logline):
+                    continue
+                else:
+                    result.append(logline.strip()+'\n')

         return result
 
         return result
 

-    def insert_changelog (self, logfile, oldtag, newtag):
+    # creates a copy of the input with only the unignored lines
+    def strip_magic_line_filename(self, filein, fileout ,new_tag_name):
+       with open(fileout,'w') as f:
+           f.write(self.setting_tag_format.format(new_tag_name) + '\n')
+           for line in self.unignored_lines(filein):
+               f.write(line)
+
+    def insert_changelog(self, logfile, newtag):

         for specfile in self.all_specnames():
         for specfile in self.all_specnames():

-            newspecfile=specfile+".new"
+            newspecfile = "{}.new".format(specfile)

             if self.options.verbose:
             if self.options.verbose:

-                print 'Inserting changelog from %s into %s'%(logfile,specfile)
-            spec=open (specfile)
-            new=open(newspecfile,"w")
-            for line in spec.readlines():
-                new.write(line)
-                if re.compile('%changelog').match(line):
-                    dateformat="* %a %b %d %Y"
-                    datepart=time.strftime(dateformat)
-                    logpart="%s <%s> - %s"%(Module.config['username'],
-                                                 Module.config['email'],
-                                                 newtag)
-                    new.write(datepart+" "+logpart+"\n")
-                    for logline in self.unignored_lines(logfile):
-                        new.write("- " + logline)
-                    new.write("\n")
-            spec.close()
-            new.close()
+                print('Inserting changelog from {} into {}'.format(logfile, specfile))
+
+            with open(specfile) as spec:
+                with open(newspecfile,"w") as new:
+                    for line in spec.readlines():
+                        new.write(line)
+                        if re.compile('%changelog').match(line):
+                            dateformat="* %a %b %d %Y"
+                            datepart=time.strftime(dateformat)
+                            logpart="{} <{}> - {}".format(Module.config['username'],
+                                                          Module.config['email'],
+                                                          newtag)
+                            new.write("{} {}\n".format(datepart,logpart))
+                            for logline in self.unignored_lines(logfile):
+                                new.write("- " + logline)
+                            new.write("\n")

             os.rename(newspecfile,specfile)
             os.rename(newspecfile,specfile)

-            
-    def show_dict (self, spec_dict):
-        if self.options.verbose:
-            for (k,v) in spec_dict.iteritems():
-                print k,'=',v
-
-    def mod_url (self):
-        return "%s/%s"%(Module.config['svnpath'],self.name)

 
 

-    def edge_url (self):
-        if not self.branch:
-            return "%s/trunk"%(self.mod_url())
-        else:
-            return "%s/branches/%s"%(self.mod_url(),self.branch)
-
-    def tag_name (self, spec_dict):
-        try:
-            return "%s-%s-%s"%(#spec_dict[self.module_name_varname],
-                self.name,
-                spec_dict[self.module_version_varname],
-                spec_dict[self.module_taglevel_varname])
-        except KeyError,err:
-            raise Exception, 'Something is wrong with module %s, cannot determine %s - exiting'%(self.name,err)
-
-    def tag_url (self, spec_dict):
-        return "%s/tags/%s"%(self.mod_url(),self.tag_name(spec_dict))
-
-    def check_svnpath_exists (self, url, message):
-        if self.options.fast_checks:
-            return
+    def show_dict(self, spec_dict):

         if self.options.verbose:
         if self.options.verbose:

-            print 'Checking url (%s) %s'%(url,message),
-        ok=Svnpath(url,self.options).url_exists()
-        if ok:
-            if self.options.verbose: print 'exists - OK'
-        else:
-            if self.options.verbose: print 'KO'
-            raise Exception, 'Could not find %s URL %s'%(message,url)
+            for k, v in spec_dict.items():
+                print('{} = {}'.format(k, v))

 
 

-    def check_svnpath_not_exists (self, url, message):
-        if self.options.fast_checks:
-            return
-        if self.options.verbose:
-            print 'Checking url (%s) %s'%(url,message),
-        ok=not Svnpath(url,self.options).url_exists()
-        if ok:
-            if self.options.verbose: print 'does not exist - OK'
-        else:
-            if self.options.verbose: print 'KO'
-            raise Exception, '%s URL %s already exists - exiting'%(message,url)
+    def last_tag(self, spec_dict):
+        try:
+            return "{}-{}".format(spec_dict[self.module_version_varname],
+                                  spec_dict[self.module_taglevel_varname])
+        except KeyError as err:
+            raise Exception('Something is wrong with module {}, cannot determine {} - exiting'\
+                            .format(self.name, err))

 
 

-    # locate specfile, parse it, check it and show values
+    def tag_name(self, spec_dict):
+        return "{}-{}".format(self.name, self.last_tag(spec_dict))

 
 

-##############################
-    def do_version (self):
-        self.init_moddir()
-        self.init_edge_dir()
-        self.revert_edge_dir()
-        self.update_edge_dir()
-        spec_dict = self.spec_dict()
-        for varname in self.varnames:
-            if not spec_dict.has_key(varname):
-                print 'Could not find %%define for %s'%varname
-                return
-            else:
-                print "%-16s %s"%(varname,spec_dict[varname])
-        if self.options.show_urls:
-            print "%-16s %s"%('edge url',self.edge_url())
-            print "%-16s %s"%('latest tag url',self.tag_url(spec_dict))
-        if self.options.verbose:
-            print "%-16s %s"%('main specfile:',self.main_specname())
-            print "%-16s %s"%('specfiles:',self.all_specnames())

 
 

-##############################
-    def do_list (self):
-#        print 'verbose',self.options.verbose
-#        print 'list_tags',self.options.list_tags
-#        print 'list_branches',self.options.list_branches
-#        print 'all_modules',self.options.all_modules
-        
-        (verbose,branches,pattern,exact) = (self.options.verbose,self.options.list_branches,
-                                            self.options.list_pattern,self.options.list_exact)
-
-        extra_command=""
-        extra_message=""
-        if self.branch:
-            pattern=self.branch
-        if pattern or exact:
-            if exact:
-                if verbose: grep="%s/$"%exact
-                else: grep="^%s$"%exact
-            else:
-                grep=pattern
-            extra_command=" | grep %s"%grep
-            extra_message=" matching %s"%grep
-
-        if not branches:
-            message="==================== tags for %s"%self.friendly_name()
-            command="svn list "
-            if verbose: command+="--verbose "
-            command += "%s/tags"%self.mod_url()
-            command += extra_command
-            message += extra_message
-            if verbose: print message
-            self.run(command)
+    pattern_format="\A\s*{module}-(GITPATH)\s*(=|:=)\s*(?P<url_main>[^\s]+)/{module}[^\s]+"

 
 

-        else:
-            message="==================== branches for %s"%self.friendly_name()
-            command="svn list "
-            if verbose: command+="--verbose "
-            command += "%s/branches"%self.mod_url()
-            command += extra_command
-            message += extra_message
-            if verbose: print message
-            self.run(command)
+    def is_mentioned_in_tagsfile(self, tagsfile):
+        # so that {module} gets replaced from format
+        module = self.name
+        module_matcher = re.compile(Module.pattern_format.format(**locals()))
+        with open(tagsfile) as f:
+            for line in f.readlines():
+                if module_matcher.match(line):
+                    return True
+        return False

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

-    sync_warning="""*** WARNING
-The module-sync function has the following limitations
-* it does not handle changelogs
-* it does not scan the -tags*.mk files to adopt the new tags"""
+    # using fine_grain means replacing only those instances that currently refer to this tag
+    # otherwise, <module>-GITPATH is replaced unconditionnally
+    def patch_tags_file(self, tagsfile, oldname, newname, fine_grain=True):
+        newtagsfile = "{}.new".format(tagsfile)
+
+        with open(tagsfile) as tags:
+            with open(newtagsfile,"w") as new:
+                matches = 0
+                # fine-grain : replace those lines that refer to oldname
+                if fine_grain:
+                    if self.options.verbose:
+                        print('Replacing {} into {}\n\tin {} .. '.format(oldname, newname, tagsfile), end=' ')
+                    matcher = re.compile("^(.*){}(.*)".format(oldname))
+                    for line in tags.readlines():
+                        if not matcher.match(line):
+                            new.write(line)
+                        else:
+                            begin, end = matcher.match(line).groups()
+                            new.write(begin+newname+end+"\n")
+                            matches += 1
+                # brute-force : change uncommented lines that define <module>-GITPATH
+                else:
+                    if self.options.verbose:
+                        print('Searching for -GITPATH lines referring to /{}/\n\tin {} .. '\
+                              .format(self.pathname, tagsfile), end=' ')
+                    # so that {module} gets replaced from format
+                    module = self.name
+                    module_matcher = re.compile(Module.pattern_format.format(**locals()))
+                    for line in tags.readlines():
+                        attempt = module_matcher.match(line)
+                        if attempt:
+                            if line.find("-GITPATH") >= 0:
+                                modulepath = "{}-GITPATH".format(self.name)
+                                replacement = "{:<32}:= {}/{}.git@{}\n"\
+                                    .format(modulepath, attempt.group('url_main'), self.pathname, newname)
+                            else:
+                                print("Could not locate {}-GITPATH (be aware that support for svn has been removed)"\
+                                      .format(self.name))
+                                return
+                            if self.options.verbose:
+                                print(' ' + modulepath, end=' ')
+                            new.write(replacement)
+                            matches += 1
+                        else:
+                            new.write(line)

 
 

-    def do_sync(self):
+        os.rename(newtagsfile,tagsfile)

         if self.options.verbose:
         if self.options.verbose:

-            print Module.sync_warning
-            if not prompt('Want to proceed anyway'):
-                return
+            print("{} changes".format(matches))
+        return matches

 
 

-        self.init_moddir()
-        self.init_edge_dir()
-        self.revert_edge_dir()
-        self.update_edge_dir()
-        spec_dict = self.spec_dict()
+    def check_tag(self, tagname, need_it=False):
+        if self.options.verbose:
+            print("Checking {} repository tag: {} - ".format(self.repository.type, tagname), end=' ')

 
 

-        edge_url=self.edge_url()
-        tag_name=self.tag_name(spec_dict)
-        tag_url=self.tag_url(spec_dict)
-        # check the tag does not exist yet
-        self.check_svnpath_not_exists(tag_url,"new tag")
+        found_tagname = tagname
+        found = self.repository.tag_exists(tagname)

 
 

-        if self.options.message:
-            svnopt='--message "%s"'%self.options.message
+        if (found and need_it) or (not found and not need_it):
+            if self.options.verbose:
+                print("OK", end=' ')
+                print("- found" if found else "- not found")

         else:
         else:

-            svnopt='--editor-cmd=%s'%self.options.editor
-        self.run_prompt("Create initial tag",
-                        "svn copy %s %s %s"%(svnopt,edge_url,tag_url))
+            if self.options.verbose:
+                print("KO")
+            exception_format = "tag ({}) is already there" if found else "can not find required tag ({})"
+            raise Exception(exception_format.format(tagname))

 
 

-##############################
-    def do_diff (self,compute_only=False):
-        self.init_moddir()
-        self.init_edge_dir()
-        self.revert_edge_dir()
-        self.update_edge_dir()
-        spec_dict = self.spec_dict()
-        self.show_dict(spec_dict)
+        return found_tagname

 
 

-        edge_url=self.edge_url()
-        tag_url=self.tag_url(spec_dict)
-        self.check_svnpath_exists(edge_url,"edge track")
-        self.check_svnpath_exists(tag_url,"latest tag")
-        command="svn diff %s %s"%(tag_url,edge_url)
-        if compute_only:
-            if self.options.verbose:
-                print 'Getting diff with %s'%command
-        diff_output = Command(command,self.options).output_of()
-        # if used as a utility
-        if compute_only:
-            return (spec_dict,edge_url,tag_url,diff_output)
-        # otherwise print the result
-        if self.options.list:
-            if diff_output:
-                print self.name
-        else:
-            if not self.options.only or diff_output:
-                print 'x'*30,'module',self.friendly_name()
-                print 'x'*20,'<',tag_url
-                print 'x'*20,'>',edge_url
-                print diff_output

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

-    # using fine_grain means replacing only those instances that currently refer to this tag
-    # otherwise, <module>-SVNPATH is replaced unconditionnally
-    def patch_tags_file (self, tagsfile, oldname, newname,fine_grain=True):
-        newtagsfile=tagsfile+".new"
-        tags=open (tagsfile)
-        new=open(newtagsfile,"w")
-
-        matches=0
-        # fine-grain : replace those lines that refer to oldname
-        if fine_grain:
-            if self.options.verbose:
-                print 'Replacing %s into %s\n\tin %s .. '%(oldname,newname,tagsfile),
-            matcher=re.compile("^(.*)%s(.*)"%oldname)
-            for line in tags.readlines():
-                if not matcher.match(line):
-                    new.write(line)
-                else:
-                    (begin,end)=matcher.match(line).groups()
-                    new.write(begin+newname+end+"\n")
-                    matches += 1
-        # brute-force : change uncommented lines that define <module>-SVNPATH
-        else:
-            if self.options.verbose:
-                print 'Setting %s-SVNPATH for using %s\n\tin %s .. '%(self.name,newname,tagsfile),
-            pattern="\A\s*%s-SVNPATH\s*(=|:=)\s*(?P<url_main>[^\s]+)/%s/[^\s]+"\
-                                          %(self.name,self.name)
-            matcher_module=re.compile(pattern)
-            for line in tags.readlines():
-                attempt=matcher_module.match(line)
-                if attempt:
-                    svnpath="%s-SVNPATH"%self.name
-                    replacement = "%-32s:= %s/%s/tags/%s\n"%(svnpath,attempt.group('url_main'),self.name,newname)
-                    new.write(replacement)
-                    matches += 1
-                else:
-                    new.write(line)
-        tags.close()
-        new.close()
-        os.rename(newtagsfile,tagsfile)
-        if self.options.verbose: print "%d changes"%matches
-        return matches
-
-    def do_tag (self):
-        self.init_moddir()
-        self.init_edge_dir()
-        self.revert_edge_dir()
-        self.update_edge_dir()
+    def do_tag(self):
+        self.init_module_dir()
+        self.revert_module_dir()
+        self.update_module_dir()

         # parse specfile
         spec_dict = self.spec_dict()
         self.show_dict(spec_dict)
         # parse specfile
         spec_dict = self.spec_dict()
         self.show_dict(spec_dict)

-        
-        # side effects
-        edge_url=self.edge_url()
-        old_tag_name = self.tag_name(spec_dict)
-        old_tag_url=self.tag_url(spec_dict)
-        if (self.options.new_version):
+
+        # compute previous tag - if not bypassed
+        if not self.options.bypass:
+            old_tag_name = self.tag_name(spec_dict)
+            # sanity check
+            old_tag_name = self.check_tag(old_tag_name, need_it=True)
+
+        if self.options.new_version:

             # new version set on command line
             spec_dict[self.module_version_varname] = self.options.new_version
             spec_dict[self.module_taglevel_varname] = 0
         else:
             # increment taglevel
             # new version set on command line
             spec_dict[self.module_version_varname] = self.options.new_version
             spec_dict[self.module_taglevel_varname] = 0
         else:
             # increment taglevel

-            new_taglevel = str ( int (spec_dict[self.module_taglevel_varname]) + 1)
+            new_taglevel = str( int(spec_dict[self.module_taglevel_varname]) + 1)

             spec_dict[self.module_taglevel_varname] = new_taglevel
 
             spec_dict[self.module_taglevel_varname] = new_taglevel
 

-        # sanity check

         new_tag_name = self.tag_name(spec_dict)
         new_tag_name = self.tag_name(spec_dict)

-        new_tag_url=self.tag_url(spec_dict)
-        self.check_svnpath_exists (edge_url,"edge track")
-        self.check_svnpath_exists (old_tag_url,"previous tag")
-        self.check_svnpath_not_exists (new_tag_url,"new tag")
+        # sanity check
+        new_tag_name = self.check_tag(new_tag_name, need_it=False)

 
         # checking for diffs
 
         # checking for diffs

-        diff_output=Command("svn diff %s %s"%(old_tag_url,edge_url),
-                            self.options).output_of()
-        if len(diff_output) == 0:
-            if not prompt ("No difference in trunk for module %s, want to tag anyway"%self.name,False):
-                return
+        if not self.options.bypass:
+            diff_output = self.repository.diff_with_tag(old_tag_name)
+            if len(diff_output) == 0:
+                if not prompt("No pending difference in module {}, want to tag anyway".format(self.pathname), False):
+                    return

 
 

-        # side effect in trunk's specfile
+        # side effect in head's specfile

         self.patch_spec_var(spec_dict)
 
         self.patch_spec_var(spec_dict)
 

-        # prepare changelog file 
-        # we use the standard subversion magic string (see svn_magic_line)
+        # prepare changelog file
+        # we use the standard subversion magic string (see edit_magic_line)

         # so we can provide useful information, such as version numbers and diff
         # in the same file
         # so we can provide useful information, such as version numbers and diff
         # in the same file

-        changelog="/tmp/%s-%d.txt"%(self.name,os.getpid())
-        file(changelog,"w").write("""Tagging module %s - %s
-
-%s
+        changelog_plain  = "/tmp/{}-{}.edit".format(self.name, os.getpid())
+        changelog_strip  = "/tmp/{}-{}.strip".format(self.name, os.getpid())
+        setting_tag_line = Module.setting_tag_format.format(new_tag_name)
+        with open(changelog_plain, 'w') as f:
+            f.write("""
+{}
+{}

 Please write a changelog for this new tag in the section above
 Please write a changelog for this new tag in the section above

-"""%(self.name,new_tag_name,Module.svn_magic_line))
+""".format(Module.edit_magic_line, setting_tag_line))
+
+        if self.options.bypass:
+            pass
+        elif prompt('Want to see diffs while writing changelog', True):
+            with open(changelog_plain, "a") as f:
+                f.write('DIFF=========\n' + diff_output)

 
 

-        if not self.options.verbose or prompt('Want to see diffs while writing changelog',True):
-            file(changelog,"a").write('DIFF=========\n' + diff_output)
-        

         if self.options.debug:
             prompt('Proceed ?')
 
         if self.options.debug:
             prompt('Proceed ?')
 

-        # edit it        
-        self.run("%s %s"%(self.options.editor,changelog))
+        # edit it
+        self.run("{} {}".format(self.options.editor, changelog_plain))
+        # strip magic line in second file
+        self.strip_magic_line_filename(changelog_plain, changelog_strip, new_tag_name)

         # insert changelog in spec
         if self.options.changelog:
         # insert changelog in spec
         if self.options.changelog:

-            self.insert_changelog (changelog,old_tag_name,new_tag_name)
+            self.insert_changelog(changelog_plain, new_tag_name)

 
         ## update build
 
         ## update build

-        try:
-            buildname=Module.config['build']
-        except:
-            buildname="build"
+        build_path = os.path.join(self.options.workdir, Module.config['build'])
+        build = Repository(build_path, self.options)

         if self.options.build_branch:
         if self.options.build_branch:

-            buildname+=":"+self.options.build_branch
-        build = Module(buildname,self.options)
-        build.init_moddir()
-        build.init_edge_dir()
-        build.revert_edge_dir()
-        build.update_edge_dir()
-        
-        tagsfiles=glob(build.edge_dir()+"/*-tags*.mk")
-        tagsdict=dict( [ (x,'todo') for x in tagsfiles ] )
+            build.to_branch(self.options.build_branch)
+        if not build.is_clean():
+            build.revert()
+
+        tagsfiles = glob(build.path+"/*-tags.mk")
+        tagsdict = { x : 'todo' for x in tagsfiles }

         default_answer = 'y'
         default_answer = 'y'

+        tagsfiles.sort()

         while True:
         while True:

-            for (tagsfile,status) in tagsdict.iteritems():
-                basename=os.path.basename(tagsfile)
-                print ".................... Dealing with %s"%basename
+            # do not bother if in bypass mode
+            if self.options.bypass:
+                break
+            for tagsfile in tagsfiles:
+                if not self.is_mentioned_in_tagsfile(tagsfile):
+                    if self.options.verbose:
+                        print("tagsfile {} does not mention {} - skipped".format(tagsfile, self.name))
+                    continue
+                status = tagsdict[tagsfile]
+                basename = os.path.basename(tagsfile)
+                print(".................... Dealing with {}".format(basename))

                 while tagsdict[tagsfile] == 'todo' :
                 while tagsdict[tagsfile] == 'todo' :

-                    choice = prompt ("insert %s in %s    "%(new_tag_name,basename),default_answer,
-                                     [ ('y','es'), ('n', 'ext'), ('f','orce'), 
-                                       ('d','iff'), ('r','evert'), ('h','elp') ] ,
+                    choice = prompt("insert {} in {}    ".format(new_tag_name, basename),
+                                     default_answer,
+                                     [ ('y','es'), ('n', 'ext'), ('f','orce'),
+                                       ('d','iff'), ('r','evert'), ('c', 'at'), ('h','elp') ] ,

                                      allow_outside=True)
                     if choice == 'y':
                                      allow_outside=True)
                     if choice == 'y':

-                        self.patch_tags_file(tagsfile,old_tag_name,new_tag_name,fine_grain=True)
+                        self.patch_tags_file(tagsfile, old_tag_name, new_tag_name, fine_grain=True)

                     elif choice == 'n':
                     elif choice == 'n':

-                        print 'Done with %s'%os.path.basename(tagsfile)
-                        tagsdict[tagsfile]='done'
+                        print('Done with {}'.format(os.path.basename(tagsfile)))
+                        tagsdict[tagsfile] = 'done'

                     elif choice == 'f':
                     elif choice == 'f':

-                        self.patch_tags_file(tagsfile,old_tag_name,new_tag_name,fine_grain=False)
+                        self.patch_tags_file(tagsfile, old_tag_name, new_tag_name, fine_grain=False)

                     elif choice == 'd':
                     elif choice == 'd':

-                        self.run("svn diff %s"%tagsfile)
+                        print(build.diff(f=os.path.basename(tagsfile)))

                     elif choice == 'r':
                     elif choice == 'r':

-                        self.run("svn revert %s"%tagsfile)
+                        build.revert(f=tagsfile)
+                    elif choice == 'c':
+                        self.run("cat {}".format(tagsfile))

                     else:
                     else:

-                        name=self.name
-                        print """y: change %(name)s-SVNPATH only if it currently refers to %(old_tag_name)s
-f: unconditionnally change any line setting %(name)s-SVNPATH to using %(new_tag_name)s
+                        name = self.name
+                        print(
+"""y: change {name}-GITPATH only if it currently refers to {old_tag_name}
+f: unconditionnally change any line that assigns {name}-GITPATH to using {new_tag_name}

 d: show current diff for this tag file
 r: revert that tag file
 d: show current diff for this tag file
 r: revert that tag file

-n: move to next file"""%locals()
+c: cat the current tag file
+n: move to next file""".format(**locals()))

 
 

-            if prompt("Want to review changes on tags files",False):
-                tagsdict = dict ( [ (x, 'todo') for tagsfile in tagsfiles ] )
-                default_answer='d'
+            if prompt("Want to review changes on tags files", False):
+                tagsdict = {x : 'todo' for x in tagsfiles }
+                default_answer = 'd'

             else:
                 break
 
             else:
                 break
 

-        paths=""
-        paths += self.edge_dir() + " "
-        paths += build.edge_dir() + " "
-        self.run_prompt("Review trunk and build","svn diff " + paths)
-        self.run_prompt("Commit trunk and build","svn commit --file %s %s"%(changelog,paths))
-        self.run_prompt("Create tag","svn copy --file %s %s %s"%(changelog,edge_url,new_tag_url))
+        def diff_all_changes():
+            print(build.diff())
+            print(self.repository.diff())
+
+        def commit_all_changes(log):
+            if hasattr(self, 'branch'):
+                self.repository.commit(log, branch=self.branch)
+            else:
+                self.repository.commit(log)
+            build.commit(log)
+
+        self.run_prompt("Review module and build", diff_all_changes)
+        self.run_prompt("Commit module and build", commit_all_changes, changelog_strip)
+        self.run_prompt("Create tag", self.repository.tag, new_tag_name, changelog_strip)

 
         if self.options.debug:
 
         if self.options.debug:

-            print 'Preserving',changelog
+            print('Preserving {} and stripped {}', changelog_plain, changelog_strip)
+        else:
+            os.unlink(changelog_plain)
+            os.unlink(changelog_strip)
+
+
+##############################
+    def do_version(self):
+        self.init_module_dir()
+        self.revert_module_dir()
+        self.update_module_dir()
+        spec_dict = self.spec_dict()
+        if self.options.www:
+            self.html_store_title('Version for module {} ({})'\
+                                  .format(self.friendly_name(), self.last_tag(spec_dict)))
+        for varname in self.varnames:
+            if varname not in spec_dict:
+                self.html_print('Could not find %define for {}'.format(varname))
+                return
+            else:
+                self.html_print("{:<16} {}".format(varname, spec_dict[varname]))
+        self.html_print("{:<16} {}".format('url', self.repository.url()))
+        if self.options.verbose:
+            self.html_print("{:<16} {}".format('main specfile:', self.main_specname()))
+            self.html_print("{:<16} {}".format('specfiles:', self.all_specnames()))
+        self.html_print_end()
+
+
+##############################
+    def do_diff(self):
+        self.init_module_dir()
+        self.revert_module_dir()
+        self.update_module_dir()
+        spec_dict = self.spec_dict()
+        self.show_dict(spec_dict)
+
+        # side effects
+        tag_name = self.tag_name(spec_dict)
+
+        # sanity check
+        tag_name = self.check_tag(tag_name, need_it=True)
+
+        if self.options.verbose:
+            print('Getting diff')
+        diff_output = self.repository.diff_with_tag(tag_name)
+
+        if self.options.list:
+            if diff_output:
+                print(self.pathname)

         else:
         else:

-            os.unlink(changelog)
-            
+            thename = self.friendly_name()
+            do_print = False
+            if self.options.www and diff_output:
+                self.html_store_title("Diffs in module {} ({}) : {} chars"\
+                                      .format(thename, self.last_tag(spec_dict), len(diff_output)))
+
+                self.html_store_raw('<p> &lt; (left) {} </p>'.format(tag_name))
+                self.html_store_raw('<p> &gt; (right) {} </p>'.format(thename))
+                self.html_store_pre(diff_output)
+            elif not self.options.www:
+                print('x'*30, 'module', thename)
+                print('x'*20, '<', tag_name)
+                print('x'*20, '>', thename)
+                print(diff_output)
+

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

-    def do_branch (self):
-
-        # save self.branch if any, as a hint for the new branch 
-        # do this before anything else and restore .branch to None, 
-        # as this is part of the class's logic
-        new_trunk_name=None
-        if self.branch:
-            new_trunk_name=self.branch
-            self.branch=None
-
-        # compute diff - a way to initialize the whole stuff
-        # do_diff already does edge_dir initialization
-        # and it checks that edge_url and tag_url exist as well
-        (spec_dict,edge_url,tag_url,diff_listing) = self.do_diff(compute_only=True)
-
-        # the version name in the trunk becomes the new branch name
-        branch_name = spec_dict[self.module_version_varname]
-
-        # figure new branch name (the one for the trunk) if not provided on the command line
-        if not new_trunk_name:
-            # heuristic is to assume 'version' is a dot-separated name
-            # we isolate the rightmost part and try incrementing it by 1
-            version=spec_dict[self.module_version_varname]
+    # store and restitute html fragments
+    @staticmethod
+    def html_href(url,text):
+        return '<a href="{}">{}</a>'.format(url, text)
+
+    @staticmethod
+    def html_anchor(url,text):
+        return '<a name="{}">{}</a>'.format(url,text)
+
+    @staticmethod
+    def html_quote(text):
+        return text.replace('&', '&#38;').replace('<', '&lt;').replace('>', '&gt;')
+
+    # only the fake error module has multiple titles
+    def html_store_title(self, title):
+        if not hasattr(self,'titles'):
+            self.titles=[]
+        self.titles.append(title)
+
+    def html_store_raw(self, html):
+        if not hasattr(self,'body'):
+            self.body=''
+        self.body += html
+
+    def html_store_pre(self, text):
+        if not hasattr(self,'body'):
+            self.body=''
+        self.body += '<pre>{}</pre>'.format(self.html_quote(text))
+
+    def html_print(self, txt):
+        if not self.options.www:
+            print(txt)
+        else:
+            if not hasattr(self, 'in_list') or not self.in_list:
+                self.html_store_raw('<ul>')
+                self.in_list = True
+            self.html_store_raw('<li>{}</li>'.format(txt))
+
+    def html_print_end(self):
+        if self.options.www:
+            self.html_store_raw('</ul>')
+
+    @staticmethod
+    def html_dump_header(title):
+        nowdate = time.strftime("%Y-%m-%d")
+        nowtime = time.strftime("%H:%M (%Z)")
+        print("""<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
+<head>
+<title> {} </title>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+<style type="text/css">
+body {{ font-family:georgia, serif; }}
+h1 {{font-size: large; }}
+p.title {{font-size: x-large; }}
+span.error {{text-weight:bold; color: red; }}
+</style>
+</head>
+<body>
+<p class='title'> {} - status on {} at {}</p>
+<ul>
+""".format(title, title, nowdate, nowtime))
+
+    @staticmethod
+    def html_dump_middle():
+        print("</ul>")
+
+    @staticmethod
+    def html_dump_footer():
+        print("</body></html")
+
+    def html_dump_toc(self):
+        if hasattr(self,'titles'):
+            for title in self.titles:
+                print('<li>', self.html_href('#'+self.friendly_name(),title), '</li>')
+
+    def html_dump_body(self):
+        if hasattr(self,'titles'):
+            for title in self.titles:
+                print('<hr /><h1>', self.html_anchor(self.friendly_name(),title), '</h1>')
+        if hasattr(self,'body'):
+            print(self.body)
+            print('<p class="top">', self.html_href('#','Back to top'), '</p>')
+
+
+
+class Build(Module):
+
+    def __get_modules(self, tagfile):
+        self.init_module_dir()
+        modules = {}
+
+        tagfile = os.path.join(self.module_dir, tagfile)
+        for line in open(tagfile):

             try:
             try:

-                m=re.compile("\A(?P<leftpart>.+)\.(?P<rightmost>[^\.]+)\Z")
-                (leftpart,rightmost)=m.match(version).groups()
-                incremented = int(rightmost)+1
-                new_trunk_name="%s.%d"%(leftpart,incremented)
+                name, url = line.split(':=')
+                name, git_path = name.rsplit('-', 1)
+                modules[name] = (git_path.strip(), url.strip())

             except:
             except:

-                raise Exception, 'Cannot figure next branch name from %s - exiting'%version
+                pass
+        return modules
+
+    def get_modules(self, tagfile):
+        modules = self.__get_modules(tagfile)
+        for module in modules:
+            module_type = tag_or_branch = ""
+
+            path_type, url = modules[module]
+            if path_type == "GITPATH":
+                module_spec = os.path.split(url)[-1].replace(".git","")
+                name, tag_or_branch, module_type = self.parse_module_spec(module_spec)
+            else:
+                tag_or_branch = os.path.split(url)[-1].strip()
+                if url.find('/tags/') >= 0:
+                    module_type = "tag"
+                elif url.find('/branches/') >= 0:
+                    module_type = "branch"

 
 

-        # record starting point tagname
-        latest_tag_name = self.tag_name(spec_dict)
+            modules[module] = {"module_type" : module_type,
+                               "path_type": path_type,
+                               "tag_or_branch": tag_or_branch,
+                               "url":url}
+        return modules

 
 

-        print "**********"
-        print "Using starting point %s (%s)"%(tag_url,latest_tag_name)
-        print "Creating branch %s  &  moving trunk to %s"%(branch_name,new_trunk_name)
-        print "**********"

 
 

-        # print warning if pending diffs
-        if diff_listing:
-            print """*** WARNING : Module %s has pending diffs on its trunk
-It is safe to proceed, but please note that branch %s
-will be based on latest tag %s and *not* on the current trunk"""%(self.name,branch_name,latest_tag_name)
-            while True:
-                answer = prompt ('Are you sure you want to proceed with branching',True,('d','iff'))
-                if answer is True:
-                    break
-                elif answer is False:
-                    raise Exception,"User quit"
-                elif answer == 'd':
-                    print '<<<< %s'%tag_url
-                    print '>>>> %s'%edge_url
-                    print diff_listing
-
-        branch_url = "%s/%s/branches/%s"%(Module.config['svnpath'],self.name,branch_name)
-        self.check_svnpath_not_exists (branch_url,"new branch")
-        
-        # patching trunk
-        spec_dict[self.module_version_varname]=new_trunk_name
-        spec_dict[self.module_taglevel_varname]='0'
-        # remember this in the trunk for easy location of the current branch
-        spec_dict['module_current_branch']=branch_name
-        self.patch_spec_var(spec_dict,True)
-        
-        # create commit log file
-        tmp="/tmp/branching-%d"%os.getpid()
-        f=open(tmp,"w")
-        f.write("Branch %s for module %s created (as new trunk) from tag %s\n"%(new_trunk_name,self.name,latest_tag_name))
-        f.close()
-
-        # we're done, let's commit the stuff
-        command="svn diff %s"%self.edge_dir()
-        self.run_prompt("Review changes in trunk",command)
-        command="svn copy --file %s %s %s"%(tmp,self.edge_url(),branch_url)
-        self.run_prompt("Create branch",command)
-        command="svn commit --file %s %s"%(tmp,self.edge_dir())
-        self.run_prompt("Commit trunk",command)
-        new_tag_url=self.tag_url(spec_dict)
-        command="svn copy --file %s %s %s"%(tmp,self.edge_url(),new_tag_url)
-        self.run_prompt("Create initial tag in trunk",command)
-        os.unlink(tmp)
+
+def modules_diff(first, second):
+    diff = {}
+
+    for module in first:
+        if module not in second:
+            print("=== module {} missing in right-hand side ===".format(module))
+            continue
+        if first[module]['tag_or_branch'] != second[module]['tag_or_branch']:
+            diff[module] = (first[module]['tag_or_branch'], second[module]['tag_or_branch'])
+
+    first_set = set(first.keys())
+    second_set = set(second.keys())
+
+    new_modules = list(second_set - first_set)
+    removed_modules = list(first_set - second_set)
+
+    return diff, new_modules, removed_modules
+
+def release_changelog(options, buildtag_old, buildtag_new):
+
+    # the command line expects new old, so we treat the tagfiles in the same order
+    nb_tags = len(options.distrotags)
+    if nb_tags == 1:
+        tagfile_new = tagfile_old = options.distrotags[0]
+    elif nb_tags == 2:
+        tagfile_new, tagfile_old = options.distrotags
+    else:
+        print("ERROR: provide one or two tagfile name (eg. onelab-k32-tags.mk)")
+        print("two tagfiles can be mentioned when a tagfile has been renamed")
+        return
+
+    if options.dry_run:
+        print("------------------------------ Computing Changelog from")
+        print("buildtag_old", buildtag_old, "tagfile_old", tagfile_old)
+        print("buildtag_new", buildtag_new, "tagfile_new", tagfile_new)
+        return
+
+    print('----')
+    print('----')
+    print('----')
+    print('= build tag {} to {} ='.format(buildtag_old, buildtag_new))
+    print('== distro {} ({} to {}) =='.format(tagfile_new, buildtag_old, buildtag_new))
+
+    build = Build("build@{}".format(buildtag_old), options)
+    build.init_module_dir()
+    first = build.get_modules(tagfile_old)
+
+    print(' * from', buildtag_old, build.repository.gitweb())
+
+    build = Build("build@{}".format(buildtag_new), options)
+    build.init_module_dir()
+    second = build.get_modules(tagfile_new)
+
+    print(' * to', buildtag_new, build.repository.gitweb())
+
+    diff, new_modules, removed_modules = modules_diff(first, second)
+
+
+    def get_module(name, tag):
+        if not tag or  tag == "trunk":
+            return Module("{}".format(module), options)
+        else:
+            return Module("{}@{}".format(module, tag), options)
+
+
+    for module in diff:
+        print('=== {} - {} to {} : package {} ==='.format(tagfile_new, buildtag_old, buildtag_new, module))
+
+        first, second = diff[module]
+        m = get_module(module, first)
+        os.system('rm -rf {}'.format(m.module_dir)) # cleanup module dir
+        m.init_module_dir()
+
+        print(' * from', first, m.repository.gitweb())
+
+        specfile = m.main_specname()
+        (tmpfd, tmpfile) = tempfile.mkstemp()
+        os.system("cp -f /{} {}".format(specfile, tmpfile))
+
+        m = get_module(module, second)
+        # patch for ipfw that, being managed in a separate repo, won't work for now
+        try:
+            m.init_module_dir()
+        except Exception as e:
+            print("""Could not retrieve module {} - skipped
+{{{{{{ {} }}}}}}
+""".format( m.friendly_name(), e))
+            continue
+        specfile = m.main_specname()
+
+        print(' * to', second, m.repository.gitweb())
+
+        print('{{{')
+        os.system("diff -u {} {} | sed -e 's,{},[[previous version]],'"\
+                  .format(tmpfile, specfile, tmpfile))
+        print('}}}')
+
+        os.unlink(tmpfile)
+
+    for module in new_modules:
+        print('=== {} : new package in build {} ==='.format(tagfile_new, module))
+
+    for module in removed_modules:
+        print('=== {} : removed package from build {} ==='.format(tagfile_new, module))
+
+
+def adopt_tag(options, args):
+    modules=[]
+    for module in options.modules:
+        modules += module.split()
+    for module in modules:
+        modobj=Module(module,options)
+        for tags_file in args:
+            if options.verbose:
+                print('adopting tag {} for {} in {}'.format(options.tag, module, tags_file))
+            modobj.patch_tags_file(tags_file, '_unused_', options.tag, fine_grain=False)
+    if options.verbose:
+        Command("git diff {}".format(" ".join(args)), options).run()

 
 ##############################
 class Main:
 
 
 ##############################
 class Main:
 

-    usage="""Usage: %prog options module_desc [ .. module_desc ]
-Purpose:
-  manage subversion tags and specfile
-  requires the specfile to define *version* and *taglevel*
-  OR alternatively 
-  redirection variables module_version_varname / module_taglevel_varname
-Trunk:
-  by default, the trunk of modules is taken into account
+    module_usage="""Usage: %prog [options] module_desc [ .. module_desc ]
+
+module-tools : a set of tools to manage subversion tags and specfile
+  requires the specfile to either
+  * define *version* and *taglevel*
+  OR alternatively
+  * define redirection variables module_version_varname / module_taglevel_varname
+Master:
+  by default, the 'master' branch of modules is the target

   in this case, just mention the module name as <module_desc>
 Branches:
   in this case, just mention the module name as <module_desc>
 Branches:

-  if you wish to work on a branch rather than on the trunk, 
+  if you wish to work on another branch,

   you can use something like e.g. Mom:2.1 as <module_desc>
   you can use something like e.g. Mom:2.1 as <module_desc>

-More help:
-  see http://svn.planet-lab.org/wiki/ModuleTools

 """
 """

+    release_usage="""Usage: %prog [options] tag1 .. tagn
+  Extract release notes from the changes in specfiles between several build tags, latest first
+  Examples:
+      release-changelog 4.2-rc25 4.2-rc24 4.2-rc23 4.2-rc22
+  You can refer to a (build) branch by prepending a colon, like in
+      release-changelog :4.2 4.2-rc25
+  You can refer to the build trunk by just mentioning 'trunk', e.g.
+      release-changelog -t coblitz-tags.mk coblitz-2.01-rc6 trunk
+  You can use 2 different tagfile names if that was renamed meanwhile
+      release-changelog -t onelab-tags.mk 5.0-rc29 -t onelab-k32-tags.mk 5.0-rc28
+"""
+    adopt_usage="""Usage: %prog [options] tag-file[s]
+  With this command you can adopt a specifi tag or branch in your tag files
+    This should be run in your daily build workdir; no call of git is done
+  Examples:
+    adopt-tag -m "plewww plcapi" -m Monitor onelab*tags.mk
+    adopt-tag -m sfa -t sfa-1.0-33 *tags.mk
+"""
+    common_usage="""More help:
+  see http://svn.planet-lab.org/wiki/ModuleTools"""

 
 

-    modes={ 
+    modes = {

         'list' : "displays a list of available tags or branches",
         'version' : "check latest specfile and print out details",
         'list' : "displays a list of available tags or branches",
         'version' : "check latest specfile and print out details",

-        'diff' : "show difference between trunk and latest tag",
+        'diff' : "show difference between module (trunk or branch) and latest tag",

         'tag'  : """increment taglevel in specfile, insert changelog in specfile,
         'tag'  : """increment taglevel in specfile, insert changelog in specfile,

-                create new tag and and monitor its adoption in build/*-tags*.mk""",
-        'branch' : """create a branch for this module, from the latest tag on the trunk, 
+                create new tag and and monitor its adoption in build/*-tags.mk""",
+        'branch' : """create a branch for this module, from the latest tag on the trunk,

                   and change trunk's version number to reflect the new branch name;
                   you can specify the new branch name by using module:branch""",
                   and change trunk's version number to reflect the new branch name;
                   you can specify the new branch name by using module:branch""",

-        'sync' : """create a tag from the trunk
+        'sync' : """create a tag from the module

                 this is a last resort option, mostly for repairs""",
                 this is a last resort option, mostly for repairs""",

+        'changelog' : """extract changelog between build tags
+                expected arguments are a list of tags""",
+        'adopt' : """locally adopt a specific tag""",

         }
 
     silent_modes = ['list']
         }
 
     silent_modes = ['list']

+    # 'changelog' is for release-changelog
+    # 'adopt' is for 'adopt-tag'
+    regular_modes = set(modes.keys()).difference(set(['changelog','adopt']))
+
+    @staticmethod
+    def optparse_list(option, opt, value, parser):
+        try:
+            setattr(parser.values,option.dest,getattr(parser.values,option.dest)+value.split())
+        except:
+            setattr(parser.values,option.dest,value.split())

 
     def run(self):
 
         mode=None
 
     def run(self):
 
         mode=None

-        for function in Main.modes.keys():
+        # hack - need to check for adopt first as 'adopt-tag' contains tag..
+        for function in [ 'adopt' ] + list(Main.modes.keys()):

             if sys.argv[0].find(function) >= 0:
                 mode = function
                 break
         if not mode:
             if sys.argv[0].find(function) >= 0:
                 mode = function
                 break
         if not mode:

-            print "Unsupported command",sys.argv[0]
+            print("Unsupported command",sys.argv[0])
+            print("Supported commands:" + " ".join(list(Main.modes.keys())))

             sys.exit(1)
 
             sys.exit(1)
 

-        Main.usage += "\nmodule-%s : %s"%(mode,Main.modes[mode])
-        all_modules=os.path.dirname(sys.argv[0])+"/modules.list"
-
-        parser=OptionParser(usage=Main.usage,version=subversion_id)
-        
-        if mode == 'list':
-            parser.add_option("-b","--branches",action="store_true",dest="list_branches",default=False,
-                              help="list branches")
-            parser.add_option("-t","--tags",action="store_false",dest="list_branches",
-                              help="list tags")
-            parser.add_option("-m","--match",action="store",dest="list_pattern",default=None,
-                               help="grep pattern for filtering output")
-            parser.add_option("-x","--exact-match",action="store",dest="list_exact",default=None,
-                               help="exact grep pattern for filtering output")
-        if mode == "tag" or mode == 'branch':
+        usage='undefined usage, mode={}'.format(mode)
+        if mode in Main.regular_modes:
+            usage = Main.module_usage
+            usage += Main.common_usage
+            usage += "\nmodule-{} : {}".format(mode, Main.modes[mode])
+        elif mode == 'changelog':
+            usage = Main.release_usage
+            usage += Main.common_usage
+        elif mode == 'adopt':
+            usage = Main.adopt_usage
+            usage += Main.common_usage
+
+        parser=OptionParser(usage=usage)
+
+        # the 'adopt' mode is really special and doesn't share any option
+        if mode == 'adopt':
+            parser.add_option("-m","--module",action="append",dest="modules",default=[],
+                              help="modules, can be used several times or with quotes")
+            parser.add_option("-t","--tag",action="store", dest="tag", default='master',
+                              help="specify the tag to adopt, default is 'master'")
+            parser.add_option("-v","--verbose", action="store_true", dest="verbose", default=False,
+                              help="run in verbose mode")
+            (options, args) = parser.parse_args()
+            options.workdir='unused'
+            options.dry_run=False
+            options.mode='adopt'
+            if len(args)==0 or len(options.modules)==0:
+                parser.print_help()
+                sys.exit(1)
+            adopt_tag(options,args)
+            return
+
+        # the other commands (module-* and release-changelog) share the same skeleton
+        if mode in [ 'tag', 'branch'] :

             parser.add_option("-s","--set-version",action="store",dest="new_version",default=None,
                               help="set new version and reset taglevel to 0")
             parser.add_option("-s","--set-version",action="store",dest="new_version",default=None,
                               help="set new version and reset taglevel to 0")

-        if mode == "tag" :
+            parser.add_option("-0","--bypass",action="store_true",dest="bypass",default=False,
+                              help="skip checks on existence of the previous tag")
+        if mode == 'tag' :

             parser.add_option("-c","--no-changelog", action="store_false", dest="changelog", default=True,
                               help="do not update changelog section in specfile when tagging")
             parser.add_option("-b","--build-branch", action="store", dest="build_branch", default=None,
             parser.add_option("-c","--no-changelog", action="store_false", dest="changelog", default=True,
                               help="do not update changelog section in specfile when tagging")
             parser.add_option("-b","--build-branch", action="store", dest="build_branch", default=None,

-                              help="specify a build branch; used for locating the *tags*.mk files where adoption is to take place")
-        if mode == "tag" or mode == "sync" :
+                              help="specify a build branch; used for locating the *tags.mk files where adoption is to take place")
+        if mode in [ 'tag', 'sync' ] :

             parser.add_option("-e","--editor", action="store", dest="editor", default=default_editor(),
                               help="specify editor")
             parser.add_option("-e","--editor", action="store", dest="editor", default=default_editor(),
                               help="specify editor")

-        if mode == "sync" :
-            parser.add_option("-m","--message", action="store", dest="message", default=None,
-                              help="specify log message")
-        if mode == "diff" :
-            parser.add_option("-o","--only", action="store_true", dest="only", default=False,
-                              help="report diff only for modules that exhibit differences")
-        if mode == "diff" :
+
+        if mode in ['diff','version'] :
+            parser.add_option("-W","--www", action="store", dest="www", default=False,
+                              help="export diff in html format, e.g. -W trunk")
+
+        if mode == 'diff' :

             parser.add_option("-l","--list", action="store_true", dest="list", default=False,
                               help="just list modules that exhibit differences")
 
             parser.add_option("-l","--list", action="store_true", dest="list", default=False,
                               help="just list modules that exhibit differences")
 

-        if mode  == 'version':
-            parser.add_option("-u","--url", action="store_true", dest="show_urls", default=False,
-                              help="display URLs")
-            
-        # default verbosity depending on function - temp
+        default_modules_list=os.path.dirname(sys.argv[0])+"/modules.list"

         parser.add_option("-a","--all",action="store_true",dest="all_modules",default=False,
         parser.add_option("-a","--all",action="store_true",dest="all_modules",default=False,

-                          help="run on all modules as found in %s"%all_modules)
-        verbose_default=False
-        if mode in ['tag','sync'] : verbose_default = True
-        parser.add_option("-v","--verbose", action="store_true", dest="verbose", default=verbose_default, 
-                          help="run in verbose mode")
-        if mode not in ['version','list']:
-            parser.add_option("-q","--quiet", action="store_false", dest="verbose", 
-                              help="run in quiet (non-verbose) mode")
-        parser.add_option("-w","--workdir", action="store", dest="workdir", 
-                          default="%s/%s"%(os.getenv("HOME"),"modules"),
+                          help="run on all modules as found in {}".format(default_modules_list))
+        parser.add_option("-f","--file",action="store",dest="modules_list",default=None,
+                          help="run on all modules found in specified file")
+        parser.add_option("-n","--dry-run",action="store_true",dest="dry_run",default=False,
+                          help="dry run - shell commands are only displayed")
+        parser.add_option("-t","--distrotags",action="callback",callback=Main.optparse_list, dest="distrotags",
+                          default=[], nargs=1,type="string",
+                          help="""specify distro-tags files, e.g. onelab-tags-4.2.mk
+-- can be set multiple times, or use quotes""")
+
+        parser.add_option("-w","--workdir", action="store", dest="workdir",
+                          default="{}/{}".format(os.getenv("HOME"),"modules"),

                           help="""name for dedicated working dir - defaults to ~/modules
 ** THIS MUST NOT ** be your usual working directory""")
                           help="""name for dedicated working dir - defaults to ~/modules
 ** THIS MUST NOT ** be your usual working directory""")

-        parser.add_option("-f","--fast-checks",action="store_true",dest="fast_checks",default=False,
-                          help="skip safety checks, such as svn updates -- use with care")
-        parser.add_option("-d","--debug", action="store_true", dest="debug", default=False, 
-                          help="debug mode - mostly more verbose")
-        (options, args) = parser.parse_args()
+        parser.add_option("-F","--fast-checks",action="store_true",dest="fast_checks",default=False,
+                          help="skip safety checks, such as git pulls -- use with care")
+        parser.add_option("-B","--build-module",action="store",dest="build_module",default=None,
+                          help="specify a build module to owerride the one in the CONFIG")
+
+        # default verbosity depending on function - temp
+        verbose_modes= ['tag', 'sync', 'branch']
+
+        if mode not in verbose_modes:
+            parser.add_option("-v","--verbose", action="store_true", dest="verbose", default=False,
+                              help="run in verbose mode")
+        else:
+            parser.add_option("-q","--quiet", action="store_false", dest="verbose", default=True,
+                              help="run in quiet (non-verbose) mode")
+        options, args = parser.parse_args()

         options.mode=mode
         options.mode=mode

+        if not hasattr(options,'dry_run'):
+            options.dry_run=False
+        if not hasattr(options,'www'):
+            options.www=False
+        options.debug=False
+

 
 

+
+        ########## module-*

         if len(args) == 0:
             if options.all_modules:
         if len(args) == 0:
             if options.all_modules:

-                args=Command("grep -v '#' %s"%all_modules,options).output_of().split()
+                options.modules_list=default_modules_list
+            if options.modules_list:
+                args=Command("grep -v '#' {}".format(options.modules_list), options).output_of().split()

             else:
                 parser.print_help()
                 sys.exit(1)
         Module.init_homedir(options)
             else:
                 parser.print_help()
                 sys.exit(1)
         Module.init_homedir(options)

-        for modname in args:
-            module=Module(modname,options)
-            if len(args)>1 and mode not in Main.silent_modes:
-                print '========================================',module.friendly_name()
-            # call the method called do_<mode>
-            method=Module.__dict__["do_%s"%mode]
-            try:
-                method(module)
-            except Exception,e:
-                print 'Skipping failed %s: '%modname,e

 
 

+
+        if mode in Main.regular_modes:
+            modules = [ Module(modname, options) for modname in args ]
+            # hack: create a dummy Module to store errors/warnings
+            error_module = Module('__errors__',options)
+
+            for module in modules:
+                if len(args)>1 and mode not in Main.silent_modes:
+                    if not options.www:
+                        print('========================================', module.friendly_name())
+                # call the method called do_<mode>
+                method = Module.__dict__["do_{}".format(mode)]
+                try:
+                    method(module)
+                except Exception as e:
+                    if options.www:
+                        title='<span class="error"> Skipping module {} - failure: {} </span>'\
+                            .format(module.friendly_name(), str(e))
+                        error_module.html_store_title(title)
+                    else:
+                        import traceback
+                        traceback.print_exc()
+                        print('Skipping module {}: {}'.format(module.name,e))
+
+            if options.www:
+                if mode == "diff":
+                    modetitle="Changes to tag in {}".format(options.www)
+                elif mode == "version":
+                    modetitle="Latest tags in {}".format(options.www)
+                modules.append(error_module)
+                error_module.html_dump_header(modetitle)
+                for module in modules:
+                    module.html_dump_toc()
+                Module.html_dump_middle()
+                for module in modules:
+                    module.html_dump_body()
+                Module.html_dump_footer()
+        else:
+            # if we provide, say a b c d, we want to build (a,b) (b,c) and (c,d)
+            # remember that the changelog in the twiki comes latest first, so
+            # we typically have here latest latest-1 latest-2
+            for (tag_new,tag_old) in zip ( args[:-1], args [1:]):
+                release_changelog(options, tag_old, tag_new)
+
+
+####################

 if __name__ == "__main__" :
     try:
         Main().run()
     except KeyboardInterrupt:
 if __name__ == "__main__" :
     try:
         Main().run()
     except KeyboardInterrupt:

-        print '\nBye'
-        
+        print('\nBye')