X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=module-tools.py;h=29fb2470c39bd9e1fe4e6bccdcdef096098022da;hb=9e898ec0d9738a02e67cb0a770b0249bb3360ec9;hp=d755c19a50cfce260c70314f0b3a9932d9b7a282;hpb=e25ec49f666b9d60201b453bc959492e543c9f2a;p=build.git diff --git a/module-tools.py b/module-tools.py index d755c19a..29fb2470 100755 --- a/module-tools.py +++ b/module-tools.py @@ -1,13 +1,31 @@ #!/usr/bin/python -u -subversion_id = "$Id$" - -import sys, os, os.path +import sys, os import re import time from glob import glob from optparse import OptionParser +# HARDCODED NAME CHANGES +# +# Moving to git we decided to rename some of the repositories. Here is +# a map of name changes applied in git repositories. +RENAMED_SVN_MODULES = { + "PLEWWW": "plewww" + } + +def svn_to_git_name(module): + if RENAMED_SVN_MODULES.has_key(module): + return RENAMED_SVN_MODULES[module] + return module + +def git_to_svn_name(module): + for key in RENAMED_SVN_MODULES: + if module == RENAMED_SVN_MODULES[key]: + return key + return module + + # 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): @@ -122,21 +140,219 @@ class Command: print 'Done', return result -class Svnpath: - def __init__(self,path,options): - self.path=path - self.options=options - def url_exists (self): - return os.system("svn list %s &> /dev/null"%self.path) == 0 +class SvnRepository: + type = "svn" + + def __init__(self, path, options): + self.path = path + self.options = options + + def name(self): + return os.path.basename(self.path) + + def url(self): + out = Command("svn info %s" % self.path, self.options).output_of() + for line in out.split('\n'): + if line.startswith("URL:"): + return line.split()[1].strip() + + def repo_root(self): + out = Command("svn info %s" % self.path, self.options).output_of() + for line in out.split('\n'): + if line.startswith("Repository Root:"): + repo_root = line.split()[2].strip() + return "%s/svn/%s" (repo_root, self.name) + + @classmethod + def checkout(cls, remote, local, options, recursive=False): + if recursive: + svncommand = "svn co %s %s" % (remote, local) + else: + svncommand = "svn co -N %s %s" % (remote, local) + Command("rm -rf %s" % local, options).run_silent() + Command(svncommand, options).run_fatal() + + return SvnRepository(local, options) + + @classmethod + def remote_exists(cls, remote): + return os.system("svn list %s &> /dev/null" % remote) == 0 + + def tag_exists(self, tagname): + url = "%s/tags/%s" % (self.repo_root(), tagname) + return SvnRepository.remote_exists(url) + + def update(self, subdir="", recursive=True): + path = os.path.join(self.path, subdir) + if recursive: + svncommand = "svn up %s" % path + else: + svncommand = "svn up -N %s" % path + Command(svncommand, self.options).run_fatal() + + def commit(self, logfile): + # add all new files to the repository + Command("svn status %s | grep '^\?' | sed -e 's/? *//' | sed -e 's/ /\\ /g' | xargs svn add" % + self.path, self.options).run_silent() + Command("svn commit -F %s %s" % (logfile, self.path), self.options).run_fatal() + + def to_branch(self, branch): + remote = "%s/branches/%s" % (self.repo_root(), branch) + SvnRepository.checkout(remote, self.path, self.options, recursive=True) + + def to_tag(self, tag): + remote = "%s/tags/%s" % (self.repo_root(), branch) + SvnRepository.checkout(remote, self.path, self.options, recursive=True) + + def tag(self, tagname, logfile): + tag_url = "%s/tags/%s" % (self.repo_root(), tagname) + self_url = self.url() + Command("svn copy -F %s %s %s" % (logfile, self_url, tag_url), self.options).run_fatal() + + def diff(self): + return Command("svn diff %s" % self.path, self.options).output_of(True) + + def diff_with_tag(self, tagname): + tag_url = "%s/tags/%s" % (self.repo_root(), tagname) + return Command("svn diff %s %s" % (tag_url, self.url()), + self.options).output_of(True) + + def revert(self): + Command("svn revert %s -R" % self.path, self.options).run_fatal() + Command("svn status %s | grep '^\?' | sed -e 's/? *//' | sed -e 's/ /\\ /g' | xargs rm -rf " % + self.path, self.options).run_silent() + + def is_clean(self): + command="svn status %s" % self.path + return len(Command(command,self.options).output_of(True)) == 0 + + def is_valid(self): + return os.path.exists(os.path.join(self.path, ".svn")) + + +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): + self.repo_root() + + 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:"): + repo = line.split()[2] + + @classmethod + def checkout(cls, remote, local, options, depth=1): + Command("rm -rf %s" % local, options).run_silent() + Command("git clone --depth %d %s %s" % (depth, remote, local), options).run_fatal() + return GitRepository(local, options) + + @classmethod + def remote_exists(cls, remote): + return os.system("git --no-pager ls-remote %s &> /dev/null" % remote) == 0 + + def tag_exists(self, tagname): + command = 'git tag -l | grep "^%s$"' % 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 update(self, subdir=None, recursive=None): + return self.__run_command_in_repo("git pull") + + def to_branch(self, branch, remote=True): + if remote: + branch = "origin/%s" % branch + return self.__run_command_in_repo("git checkout %s" % branch) + + def to_tag(self, tag): + return self.__run_command_in_repo("git checkout %s" % tag) + + def tag(self, tagname, logfile): + self.__run_command_in_repo("git tag %s -F %s" % (tagname, logfile)) + self.commit(logfile) + + def diff(self): + c = Command("git diff", self.options) + return self.__run_in_repo(c.output_of, with_stderr=True) + + def diff_with_tag(self, tagname): + c = Command("git diff %s" % tagname, self.options) + return self.__run_in_repo(c.output_of, with_stderr=True) + + def commit(self, logfile): + self.__run_command_in_repo("git add -A", ignore_errors=True) + self.__run_command_in_repo("git commit -F %s" % logfile, ignore_errors=True) + self.__run_command_in_repo("git push") + self.__run_command_in_repo("git push --tags") + + def revert(self): + 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 """ + supported_repo_types = [SvnRepository, GitRepository] + + def __init__(self, path, options): + self.path = path + self.options = options + for repo in self.supported_repo_types: + self.repo = repo(self.path, self.options) + if self.repo.is_valid(): + break + + @classmethod + def has_moved_to_git(cls, module, svnpath): + module = git_to_svn_name(module) + return SvnRepository.remote_exists("%s/%s/aaaa-has-moved-to-git" % (svnpath, module)) + + @classmethod + def remote_exists(cls, remote): + for repo in Repository.supported_repo_types: + if repo.remote_exists(remote): + return True + return False + + 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: @@ -156,17 +372,23 @@ class Module: import commands configKeys=[ ('svnpath',"Enter your toplevel svnpath", "svn+ssh://%s@svn.planet-lab.org/svn/"%commands.getoutput("id -un")), + ('gitserver', "Enter your git server's hostname", "git.onelab.eu"), + ('gituser', "Enter your user name (login name) on git server", os.getlogin()), ("build", "Enter the name of your build module","build"), ('username',"Enter your firstname and lastname for changelogs",""), ("email","Enter your email address for changelogs",""), ] - @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 + @classmethod + def prompt_config_option(cls, key, message, default): + cls.config[key]=raw_input("%s [%s] : "%(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) # for parsing module spec name:branch @@ -190,153 +412,88 @@ class Module: else: self.name=module_spec + # when available prefer to use git module name internally + self.name = svn_to_git_name(self.name) + self.options=options self.module_dir="%s/%s"%(options.workdir,self.name) - - def friendly_name (self): - if hasattr(self,'branch'): - return "%s:%s"%(self.name,self.branch) - elif hasattr(self,'tagname'): - return "%s@%s"%(self.name,self.tagname) - else: - return self.name - - def edge_dir (self): - if hasattr(self,'branch'): - return "%s/branches/%s"%(self.module_dir,self.branch) - elif hasattr(self,'tagname'): - return "%s/tags/%s"%(self.module_dir,self.tagname) - else: - return "%s/trunk"%(self.module_dir) - - def tags_dir (self): - return "%s/tags"%(self.module_dir) + self.repository = None + self.build = None def run (self,command): return Command(command,self.options).run() def run_fatal (self,command): return Command(command,self.options).run_fatal() - def run_prompt (self,message,command): + def run_prompt (self,message,fun, *args): + fun_msg = "%s(%s)" % (fun.func_name, ",".join(args)) if not self.options.verbose: while True: choice=prompt(message,True,('s','how')) if choice is True: - self.run(command) + fun(*args) return elif choice is False: - return - else: - print 'About to run:',command + print 'About to run function:', fun_msg else: - question=message+" - want to run " + command + question=message+" - want to run function: " + fun_msg if prompt(question,True): - self.run(command) + fun(*args) - #################### - # store and restitute html fragments - @staticmethod - def html_href (url,text): return '%s'%(url,text) - @staticmethod - def html_anchor (url,text): return '%s'%(url,text) - # there must be some smarter means to do that - dirty for now - @staticmethod - def html_quote (text): - return text.replace('&','&').replace('<','<').replace('>','>') - - # 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 += '
' + self.html_quote(text) + '' - - def html_print (self, txt): - if not self.options.www: - print txt + def friendly_name (self): + if hasattr(self,'branch'): + return "%s:%s"%(self.name,self.branch) + elif hasattr(self,'tagname'): + return "%s@%s"%(self.name,self.tagname) else: - if not hasattr(self,'in_list') or not self.in_list: - self.html_store_raw('
%s - status on %s at %s
-',self.html_href('#','Back to top'),'
' + @classmethod + def git_remote_dir (cls, name): + return "%s@%s:/git/%s.git" % (cls.config['gituser'], cls.config['gitserver'], name) + + @classmethod + def svn_remote_dir (cls, name): + name = git_to_svn_name(name) + svn = cls.config['svnpath'] + if svn.endswith('/'): + return "%s%s" % (svn, name) + return "%s/%s" % (svn, name) + + def svn_selected_remote(self): + svn_name = git_to_svn_name(self.name) + remote = self.svn_remote_dir(svn_name) + if hasattr(self,'branch'): + remote = "%s/branches/%s" % (remote, self.branch) + elif hasattr(self,'tagname'): + remote = "%s/tags/%s" % (remote, self.tagname) + else: + remote = "%s/trunk" % remote + return remote #################### - @staticmethod - def init_homedir (options): - topdir=options.workdir + @classmethod + def init_homedir (cls, options): 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="%s/%s"%(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 # to avoid people use their own daily svn repo - if os.path.isdir(topdir) and not os.path.isfile(storage): + if os.path.isdir(options.workdir) and not os.path.isfile(storage): print """The directory %s exists and has no CONFIG file 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 +that for other purposes than tagging""" % options.workdir 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 %s/%s %s/%s"%(Module.config['svnpath'], - Module.config['build'], - topdir, - Module.config['build']),options).run_fatal() + + def checkout_build(): + print "Checking out build module..." + remote = cls.git_remote_dir(cls.config['build']) + local = os.path.join(options.workdir, cls.config['build']) + GitRepository.checkout(remote, local, options, depth=1) print "OK" - - # store config + + def store_config(): f=file(storage,"w") for (key,message,default) in Module.configKeys: f.write("%s=%s\n"%(key,Module.config[key])) @@ -344,13 +501,45 @@ that for other purposes than tagging"""%topdir if options.debug: print 'Stored',storage Command("cat %s"%storage,options).run() - else: + + def 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() + + if not os.path.isdir (options.workdir): + print "Cannot find",options.workdir,"let's create it" + Command("mkdir -p %s" % options.workdir, options).run_silent() + cls.prompt_config() + checkout_build() + store_config() + else: + read_config() + # check missing config options + old_layout = False + for (key,message,default) in cls.configKeys: + if not Module.config.has_key(key): + print "Configuration changed for module-tools" + cls.prompt_config_option(key, message, default) + old_layout = True + + if old_layout: + Command("rm -rf %s" % options.workdir, options).run_silent() + Command("mkdir -p %s" % options.workdir, options).run_silent() + checkout_build() + store_config() + + build_dir = os.path.join(options.workdir, cls.config['build']) + 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: print '******** Using config' for (key,message,default) in Module.configKeys: @@ -359,68 +548,76 @@ that for other purposes than tagging"""%topdir def init_module_dir (self): if self.options.verbose: print 'Checking for',self.module_dir + if not os.path.isdir (self.module_dir): - self.run_fatal("svn update -N %s"%self.module_dir) - if not os.path.isdir (self.module_dir): + if Repository.has_moved_to_git(self.name, Module.config['svnpath']): + self.repository = GitRepository.checkout(self.git_remote_dir(self.name), + self.module_dir, + self.options) + else: + remote = self.svn_selected_remote() + self.repository = SvnRepository.checkout(remote, + self.module_dir, + self.options, recursive=False) + + self.repository = Repository(self.module_dir, self.options) + if self.repository.type == "svn": + # check if module has moved to git + if Repository.has_moved_to_git(self.name, Module.config['svnpath']): + Command("rm -rf %s" % self.module_dir, self.options).run_silent() + self.init_module_dir() + # check if we have the required branch/tag + if self.repository.url() != self.svn_selected_remote(): + Command("rm -rf %s" % self.module_dir, self.options).run_silent() + self.init_module_dir() + + elif 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 %s - check module name'%self.module_dir - def init_subdir (self,fullpath, deep=False): - if self.options.verbose: - print 'Checking for',fullpath - opt="" - if not deep: opt="-N" - if not os.path.isdir (fullpath): - self.run_fatal("svn update %s %s"%(opt,fullpath)) - def revert_subdir (self,fullpath): + def revert_module_dir (self): if self.options.fast_checks: - if self.options.verbose: print 'Skipping revert of %s'%fullpath + if self.options.verbose: print 'Skipping revert of %s' % self.module_dir 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' + + if not self.repository.is_clean(): + self.repository.revert() - def update_subdir (self,fullpath): + def update_module_dir (self): if self.options.fast_checks: - if self.options.verbose: print 'Skipping update of %s'%fullpath + if self.options.verbose: print 'Skipping update of %s' % self.module_dir return if self.options.verbose: - print 'Updating',fullpath - self.run_fatal("svn update %s"%fullpath) - - def init_edge_dir (self): - # if branch, edge_dir is two steps down - if hasattr(self,'branch'): - self.init_subdir("%s/branches"%self.module_dir,deep=False) - elif hasattr(self,'tagname'): - self.init_subdir("%s/tags"%self.module_dir,deep=False) - self.init_subdir(self.edge_dir(),deep=True) - - def revert_edge_dir (self): - self.revert_subdir(self.edge_dir()) - - def update_edge_dir (self): - self.update_subdir(self.edge_dir()) + print 'Updating', self.module_dir + self.repository.update() def main_specname (self): - attempt="%s/%s.spec"%(self.edge_dir(),self.name) + attempt="%s/%s.spec"%(self.module_dir,self.name) if os.path.isfile (attempt): return attempt - pattern1="%s/*.spec"%self.edge_dir() + pattern1="%s/*.spec"%self.module_dir level1=glob(pattern1) if level1: return level1[0] - pattern2="%s/*/*.spec"%self.edge_dir() + pattern2="%s/*/*.spec"%self.module_dir level2=glob(pattern2) + if level2: return level2[0] raise Exception, 'Cannot guess specfile for module %s -- patterns were %s or %s'%(self.name,pattern1,pattern2) def all_specnames (self): - level1=glob("%s/*.spec"%self.edge_dir()) + level1=glob("%s/*.spec" % self.module_dir) if level1: return level1 - level2=glob("%s/*/*.spec"%self.edge_dir()) + level2=glob("%s/*/*.spec" % self.module_dir) return level2 def parse_spec (self, specfile, varnames): @@ -546,194 +743,19 @@ that for other purposes than tagging"""%topdir 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 hasattr(self,'branch'): - return "%s/branches/%s"%(self.mod_url(),self.branch) - elif hasattr(self,'tagname'): - return "%s/tags/%s"%(self.mod_url(),self.tagname) - else: - return "%s/trunk"%(self.mod_url()) - def last_tag (self, spec_dict): - return "%s-%s"%(spec_dict[self.module_version_varname],spec_dict[self.module_taglevel_varname]) - - def tag_name (self, spec_dict): try: - return "%s-%s"%(self.name, - self.last_tag(spec_dict)) + return "%s-%s" % (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)) + raise Exception,'Something is wrong with module %s, cannot determine %s - exiting'%(self.name,err) - def check_svnpath_exists (self, url, message): - if self.options.fast_checks: - return - 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) - - 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) - - # locate specfile, parse it, check it and show values - -############################## - def do_version (self): - self.init_module_dir() - self.init_edge_dir() - self.revert_edge_dir() - self.update_edge_dir() - spec_dict = self.spec_dict() - if self.options.www: - self.html_store_title('Version for module %s (%s)' % (self.friendly_name(),self.last_tag(spec_dict))) - for varname in self.varnames: - if not spec_dict.has_key(varname): - self.html_print ('Could not find %%define for %s'%varname) - return - else: - self.html_print ("%-16s %s"%(varname,spec_dict[varname])) - if self.options.show_urls: - self.html_print ("%-16s %s"%('edge url',self.edge_url())) - self.html_print ("%-16s %s"%('latest tag url',self.tag_url(spec_dict))) - if self.options.verbose: - self.html_print ("%-16s %s"%('main specfile:',self.main_specname())) - self.html_print ("%-16s %s"%('specfiles:',self.all_specnames())) - self.html_print_end() - -############################## - 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 hasattr(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) - - 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) - -############################## - 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""" - - def do_sync(self): - if self.options.verbose: - print Module.sync_warning - if not prompt('Want to proceed anyway'): - return - - self.init_module_dir() - self.init_edge_dir() - self.revert_edge_dir() - self.update_edge_dir() - spec_dict = self.spec_dict() - - 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") - - if self.options.message: - svnopt='--message "%s"'%self.options.message - else: - svnopt='--editor-cmd=%s'%self.options.editor - self.run_prompt("Create initial tag", - "svn copy %s %s %s"%(svnopt,edge_url,tag_url)) - -############################## - def do_diff (self,compute_only=False): - self.init_module_dir() - self.init_edge_dir() - self.revert_edge_dir() - self.update_edge_dir() - spec_dict = self.spec_dict() - self.show_dict(spec_dict) - - 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: - thename=self.friendly_name() - do_print=False - if self.options.www and diff_output: - self.html_store_title("Diffs in module %s (%s) : %d chars"%(\ - thename,self.last_tag(spec_dict),len(diff_output))) - link=self.html_href(tag_url,tag_url) - self.html_store_raw ('< (left) %s
'%link) - link=self.html_href(edge_url,edge_url) - self.html_store_raw ('> (right) %s
'%link) - self.html_store_pre (diff_output) - elif not self.options.www: - print 'x'*30,'module',thename - print 'x'*20,'<',tag_url - print 'x'*20,'>',edge_url - print diff_output + def tag_name (self, spec_dict, old_svn_name=False): + base_tag_name = self.name + if old_svn_name: + base_tag_name = git_to_svn_name(self.name) + return "%s-%s" % (base_tag_name, self.last_tag(spec_dict)) + ############################## # using fine_grain means replacing only those instances that currently refer to this tag @@ -780,19 +802,44 @@ The module-sync function has the following limitations if self.options.verbose: print "%d changes"%matches return matches + def check_tag(self, tagname, need_it=False, old_svn_tag_name=None): + if self.options.verbose: + print "Checking %s repository tag: %s - " % (self.repository.type, tagname), + + found_tagname = tagname + found = self.repository.tag_exists(tagname) + if not found and old_svn_tag_name: + if self.options.verbose: + print "KO" + print "Checking %s repository tag: %s - " % (self.repository.type, old_svn_tag_name), + found = self.repository.tag_exists(old_svn_tag_name) + if found: + found_tagname = old_svn_tag_name + + if (found and need_it) or (not found and not need_it): + print "OK " + else: + print "KO" + if found: + raise Exception, "tag (%s) is already there" % tagname + else: + raise Exception, "can not find required tag (%s)" % tagname + + return found_tagname + + def do_tag (self): self.init_module_dir() - self.init_edge_dir() - self.revert_edge_dir() - self.update_edge_dir() + self.revert_module_dir() + self.update_module_dir() # 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) + old_svn_tag_name = self.tag_name(spec_dict, old_svn_name=True) + if (self.options.new_version): # new version set on command line spec_dict[self.module_version_varname] = self.options.new_version @@ -802,16 +849,14 @@ The module-sync function has the following limitations new_taglevel = str ( int (spec_dict[self.module_taglevel_varname]) + 1) spec_dict[self.module_taglevel_varname] = new_taglevel - # sanity check 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 + old_tag_name = self.check_tag(old_tag_name, need_it=True, old_svn_tag_name=old_svn_tag_name) + new_tag_name = self.check_tag(new_tag_name, need_it=False) # checking for diffs - diff_output=Command("svn diff %s %s"%(old_tag_url,edge_url), - self.options).output_of() + diff_output = self.repository.diff_with_tag(old_tag_name) if len(diff_output) == 0: if not prompt ("No pending difference in module %s, want to tag anyway"%self.name,False): return @@ -848,19 +893,15 @@ Please write a changelog for this new tag in the section above self.insert_changelog (changelog,old_tag_name,new_tag_name) ## 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: - buildname+=":"+self.options.build_branch - build = Module(buildname,self.options) - build.init_module_dir() - build.init_edge_dir() - build.revert_edge_dir() - build.update_edge_dir() - - tagsfiles=glob(build.edge_dir()+"/*-tags*.mk") + build.to_branch(self.options.build_branch) + if not build.is_clean(): + build.revert() + + tagsfiles=glob(build.path+"/*-tags*.mk") tagsdict=dict( [ (x,'todo') for x in tagsfiles ] ) default_answer = 'y' tagsfiles.sort() @@ -902,12 +943,17 @@ n: move to next file"""%locals() else: break - paths="" - paths += self.edge_dir() + " " - paths += build.edge_dir() + " " - self.run_prompt("Review module and build","svn diff " + paths) - self.run_prompt("Commit module and build","svn commit --file %s %s"%(changelog_svn,paths)) - self.run_prompt("Create tag","svn copy --file %s %s %s"%(changelog_svn,edge_url,new_tag_url)) + def diff_all_changes(): + print build.diff() + print self.repository.diff() + + def commit_all_changes(log): + 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_svn) + self.run_prompt("Create tag", self.repository.tag, new_tag_name, changelog_svn) if self.options.debug: print 'Preserving',changelog,'and stripped',changelog_svn @@ -915,313 +961,12 @@ n: move to next file"""%locals() os.unlink(changelog) os.unlink(changelog_svn) -############################## - 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 hasattr(self,'branch'): - new_trunk_name=self.branch - del self.branch - elif self.options.new_version: - new_trunk_name = self.options.new_version - - # 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] - try: - m=re.compile("\A(?P