#!/usr/bin/python -u
-import sys, os
+import sys, os, os.path
import re
import time
+import tempfile
from glob import glob
from optparse import OptionParser
"MyPLC": "myplc",
"CoDemux": "codemux",
"NodeManager": "nodemanager",
- "NodeUpdate": "nodeupdate"
+ "NodeUpdate": "nodeupdate",
+ "Monitor": "monitor",
+
}
def svn_to_git_name(module):
def name(self):
return os.path.basename(self.path)
+ def pathname(self):
+ # for svn modules pathname is just the name of the module as
+ # all modules are at the root
+ return self.name()
+
def url(self):
out = Command("svn info %s" % self.path, self.options).output_of()
for line in out.split('\n'):
for line in out.split('\n'):
if line.startswith("Repository Root:"):
root = line.split()[2].strip()
- return "%s/%s" % (root, self.name())
+ return "%s/%s" % (root, self.pathname())
@classmethod
def checkout(cls, remote, local, options, recursive=False):
return os.path.basename(self.path)
def url(self):
- self.repo_root()
+ 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=%s.git;a=commit;h=%s" % (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:"):
- repo = line.split()[2]
+ return line.split()[2]
@classmethod
def checkout(cls, remote, local, options, depth=0):
while not cls.config[key]:
cls.prompt_config_option(key, message, 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")
+ # 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*")
- def __init__ (self,module_spec,options):
- # parse module spec
+ @classmethod
+ def parse_module_spec(cls, module_spec):
+ name = branch_or_tagname = module_type = ""
+
attempt=Module.matcher_branch_spec.match(module_spec)
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:
attempt=Module.matcher_tag_spec.match(module_spec)
if attempt:
- self.name=attempt.group('name')
- self.tagname=attempt.group('tagname')
+ module_type = "tag"
+ name=attempt.group('name')
+ branch_or_tagname=attempt.group('tagname')
else:
- self.name=module_spec
+ name=module_spec
+ return name, branch_or_tagname, module_type
+
+
+ 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)
+
+ if module_type == "branch":
+ self.branch=branch_or_tagname
+ elif module_type == "tag":
+ self.tagname=branch_or_tagname
# 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)
+ self.module_dir="%s/%s"%(options.workdir,self.pathname)
self.repository = None
self.build = None
def friendly_name (self):
if hasattr(self,'branch'):
- return "%s:%s"%(self.name,self.branch)
+ return "%s:%s"%(self.pathname,self.branch)
elif hasattr(self,'tagname'):
- return "%s@%s"%(self.name,self.tagname)
+ return "%s@%s"%(self.pathname,self.tagname)
else:
- return self.name
+ return self.pathname
@classmethod
def git_remote_dir (cls, name):
Module.config[key]=value
f.close()
+ # 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",options.workdir,"let's create it"
Command("mkdir -p %s" % options.workdir, options).run_silent()
print 'Checking for',self.module_dir
if not os.path.isdir (self.module_dir):
- if Repository.has_moved_to_git(self.name, Module.config):
- self.repository = GitRepository.checkout(self.git_remote_dir(self.name),
+ if Repository.has_moved_to_git(self.pathname, Module.config):
+ self.repository = GitRepository.checkout(self.git_remote_dir(self.pathname),
self.module_dir,
self.options)
else:
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):
+ if Repository.has_moved_to_git(self.pathname, Module.config):
Command("rm -rf %s" % self.module_dir, self.options).run_silent()
self.init_module_dir()
# check if we have the required branch/tag
if level2:
return level2[0]
- raise Exception, 'Cannot guess specfile for module %s -- patterns were %s or %s'%(self.name,pattern1,pattern2)
+ raise Exception, 'Cannot guess specfile for module %s -- patterns were %s or %s'%(self.pathname,pattern1,pattern2)
def all_specnames (self):
level1=glob("%s/*.spec" % self.module_dir)
# brute-force : change uncommented lines that define <module>-SVNPATH
else:
if self.options.verbose:
- print 'Searching for -SVNPATH or -GITPATH lines referring to /%s/\n\tin %s .. '%(self.name,tagsfile),
- pattern="\A\s*(?P<make_name>[^\s]+)-(SVNPATH|GITPATH)\s*(=|:=)\s*(?P<url_main>[^\s]+)/%s[^\s]+"\
- %(self.name)
+ print 'Searching for -SVNPATH or -GITPATH lines referring to /%s/\n\tin %s .. '%(self.pathname,tagsfile),
+ pattern="\A\s*%s-(SVNPATH|GITPATH)\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:
if line.find("-GITPATH") >= 0:
- modulepath = "%s-GITPATH"%(attempt.group('make_name'))
- replacement = "%-32s:= %s/%s.git@%s\n"%(modulepath,attempt.group('url_main'),self.name,newname)
+ modulepath = "%s-GITPATH"%self.name
+ replacement = "%-32s:= %s/%s.git@%s\n"%(modulepath,attempt.group('url_main'),self.pathname,newname)
else:
- modulepath = "%s-SVNPATH"%(attempt.group('make_name'))
+ modulepath = "%s-SVNPATH"%self.name
replacement = "%-32s:= %s/%s/tags/%s\n"%(modulepath,attempt.group('url_main'),self.name,newname)
if self.options.verbose:
print ' ' + modulepath,
# checking for diffs
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):
+ if not prompt ("No pending difference in module %s, want to tag anyway"%self.pathname,False):
return
# side effect in trunk's specfile
if not build.is_clean():
build.revert()
- tagsfiles=glob(build.path+"/*-tags*.mk")
+ tagsfiles=glob(build.path+"/*-tags.mk")
tagsdict=dict( [ (x,'todo') for x in tagsfiles ] )
default_answer = 'y'
tagsfiles.sort()
elif choice == 'f':
self.patch_tags_file(tagsfile,old_tag_name,new_tag_name,fine_grain=False)
elif choice == 'd':
- print build.diff(f=tagsfile)
+ print build.diff(f=os.path.basename(tagsfile))
elif choice == 'r':
build.revert(f=tagsfile)
elif choice == 'c':
return
else:
self.html_print ("%-16s %s"%(varname,spec_dict[varname]))
+ self.html_print ("%-16s %s"%('url',self.repository.url()))
if self.options.verbose:
self.html_print ("%-16s %s"%('main specfile:',self.main_specname()))
self.html_print ("%-16s %s"%('specfiles:',self.all_specnames()))
if self.options.list:
if diff_output:
- print self.name
+ print self.pathname
else:
thename=self.friendly_name()
do_print=False
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:
+ name, url = line.split(':=')
+ name, git_or_svn_path = name.rsplit('-', 1)
+ name = svn_to_git_name(name.strip())
+ modules[name] = (git_or_svn_path.strip(), url.strip())
+ except:
+ 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"
+
+ modules[module] = {"module_type" : module_type,
+ "path_type": path_type,
+ "tag_or_branch": tag_or_branch,
+ "url":url}
+ return modules
+
+
+
+def modules_diff(first, second):
+ diff = {}
+
+ for module in first:
+ if module not in second:
+ print "=== module %s missing in right-hand side ==="%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):
+
+ try:
+ tagfile = options.distrotags[0]
+ if not tagfile: raise
+ except:
+ print "ERROR: provide a tagfile name (eg. onelab, onelab-k27, planetlab)"
+ return
+ # mmh, sounds wrong to blindly add the extension
+ # if in a build directory, guess from existing files
+ if os.path.isfile (tagfile):
+ pass
+ elif os.path.isfile ("%s-tags.mk" % tagfile):
+ tagfile="%s-tags.mk" % tagfile
+ else:
+ tagfile = "%s-tags.mk" % tagfile
+
+ print '----'
+ print '----'
+ print '----'
+ print '= build tag %s to %s =' % (buildtag_old, buildtag_new)
+ print '== distro %s (%s to %s) ==' % (tagfile, buildtag_old, buildtag_new)
+
+ build = Build("build@%s" % buildtag_old, options)
+ build.init_module_dir()
+ first = build.get_modules(tagfile)
+
+ print ' * from', buildtag_old, build.repository.gitweb()
+
+ build = Build("build@%s" % buildtag_new, options)
+ build.init_module_dir()
+ second = build.get_modules(tagfile)
+
+ 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("%s" % (module), options)
+ else:
+ return Module("%s@%s" % (module, tag), options)
+
+
+ for module in diff:
+ print '=== %s - %s to %s : package %s ===' % (tagfile, buildtag_old, buildtag_new, module)
+
+ first, second = diff[module]
+ m = get_module(module, first)
+ os.system('rm -rf %s' % m.module_dir) # cleanup module dir
+ m.init_module_dir()
+
+ if m.repository.type == "svn":
+ print ' * from', first, m.repository.url()
+ else:
+ print ' * from', first, m.repository.gitweb()
+
+ specfile = m.main_specname()
+ (tmpfd, tmpfile) = tempfile.mkstemp()
+ os.system("cp -f /%s %s" % (specfile, tmpfile))
+
+ m = get_module(module, second)
+ m.init_module_dir()
+ specfile = m.main_specname()
+
+ if m.repository.type == "svn":
+ print ' * to', second, m.repository.url()
+ else:
+ print ' * to', second, m.repository.gitweb()
+
+ print '{{{'
+ os.system("diff -u %s %s | sed -e 's,%s,[[previous version]],'" % (tmpfile, specfile,tmpfile))
+ print '}}}'
+
+ os.unlink(tmpfile)
+
+ for module in new_modules:
+ print '=== %s : new package in build %s ===' % (tagfile, module)
+
+ for module in removed_modules:
+ print '=== %s : removed package from build %s ===' % (tagfile, 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 %s for %s in %s'%(options.tag,module,tags_file)
+ modobj.patch_tags_file(tags_file,'_unused_',options.tag,fine_grain=False)
+ if options.verbose:
+ Command("git diff %s"%" ".join(args),options).run()
+
##############################
class Main:
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
+"""
+ 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 nor svn 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"""
'version' : "check latest specfile and print out details",
'diff' : "show difference between module (trunk or branch) and latest tag",
'tag' : """increment taglevel in specfile, insert changelog in specfile,
- create new tag and and monitor its adoption in build/*-tags*.mk""",
+ 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""",
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']
- release_modes = ['changelog']
+ # '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):
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' ] + Main.modes.keys():
if sys.argv[0].find(function) >= 0:
mode = function
break
print "Supported commands:" + " ".join(Main.modes.keys())
sys.exit(1)
- if mode not in Main.release_modes:
+ usage='undefined usage, mode=%s'%mode
+ if mode in Main.regular_modes:
usage = Main.module_usage
usage += Main.common_usage
usage += "\nmodule-%s : %s"%(mode,Main.modes[mode])
- else:
+ 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 == "tag" or mode == '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("-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")
+ help="specify a build branch; used for locating the *tags.mk files where adoption is to take place")
if mode == "tag" or mode == "sync" :
parser.add_option("-e","--editor", action="store", dest="editor", default=default_editor(),
help="specify editor")
** 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("-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']
options.www=False
options.debug=False
+
+
########## module-*
if len(args) == 0:
if options.all_modules:
Module.init_homedir(options)
- modules=[ Module(modname,options) for modname in args ]
- # hack: create a dummy Module to store errors/warnings
- error_module = Module('__errors__',options)
+ 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_%s"%mode]
- try:
- method(module)
- except Exception,e:
- if options.www:
- title='<span class="error"> Skipping module %s - failure: %s </span>'%\
- (module.friendly_name(), str(e))
- error_module.html_store_title(title)
- else:
- import traceback
- traceback.print_exc()
- print 'Skipping module %s: '%modname,e
-
- if options.www:
- if mode == "diff":
- modetitle="Changes to tag in %s"%options.www
- elif mode == "version":
- modetitle="Latest tags in %s"%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()
-
+ 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_%s"%mode]
+ try:
+ method(module)
+ except Exception,e:
+ if options.www:
+ title='<span class="error"> Skipping module %s - failure: %s </span>'%\
+ (module.friendly_name(), str(e))
+ error_module.html_store_title(title)
+ else:
+ import traceback
+ traceback.print_exc()
+ print 'Skipping module %s: '%modname,e
+
+ if options.www:
+ if mode == "diff":
+ modetitle="Changes to tag in %s"%options.www
+ elif mode == "version":
+ modetitle="Latest tags in %s"%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_to,tag_from) in zip ( args[:-1], args [1:]):
+ release_changelog(options, tag_from,tag_to)
+
+
####################
if __name__ == "__main__" :
try:
git://git.onelab.eu / build.git / blobdiff