import sys, os
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 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=%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 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")
+ 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*")
elif self.repository.type == "git":
if hasattr(self,'branch'):
- print "to branch", self.branch
self.repository.to_branch(self.branch)
elif hasattr(self,'tagname'):
- print "to tag", self.tagname
self.repository.to_tag(self.tagname)
else:
-def release_changelog(options, buildtag1, buildtag2, tagfile):
- build = Module("build@%s" % buildtag1, options)
- build.init_module_dir()
+class Build(Module):
-# tagfile = os.path.join(build.module_dir, tagfile)
-# for line in open(tagfile):
-# try:
-# url = line.split(':=')[1]
-# print build.parse_module_spec(url)
-# except:
-# pass
+ 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
+
+
- os.system("cp %s/%s /tmp" % (build.module_dir, tagfile))
+def modules_diff(first, second):
+ diff = {}
- build = Module("build@%s" % buildtag2, options)
- build.init_module_dir()
+ 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):
+
+ tagfile = options.distrotags[0]
+ if not tagfile:
+ print "ERROR: provide a tagfile name (eg. onelab, onelab-k27, planetlab)"
+ return
+ tagfile = "%s-tags.mk" % tagfile
- print os.system("diff -u /tmp/%s %s/%s" % (tagfile, build.module_dir, 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" % (tmpfile, specfile))
+ 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_master (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 master for',module,'in',tags_file
+ modobj.patch_tags_file(tags_file,'_unused_','master',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
+"""
+ master_usage="""Usage: %prog [options] tag-file[s]
+ With this command you can adopt one or several masters in your tag files
+ This should be run in your daily build workdir; no call of git nor svn is done
+ Examples:
+ module-master -m "plewww plcapi" -m Monitor onelab*tags.mk
"""
common_usage="""More help:
see http://svn.planet-lab.org/wiki/ModuleTools"""
this is a last resort option, mostly for repairs""",
'changelog' : """extract changelog between build tags
expected arguments are a list of tags""",
+ 'master' : """locally adopt master or trunk for some modules""",
}
silent_modes = ['list']
- release_modes = ['changelog']
+ # 'changelog' is for release-changelog
+ # 'master' is for 'adopt-master'
+ regular_modes = set(modes.keys()).difference(set(['changelog','master']))
@staticmethod
def optparse_list (option, opt, value, parser):
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=='master':
+ usage = Main.master_usage
+ usage += Main.common_usage
parser=OptionParser(usage=usage)
+ # the 'master' mode is really special and doesn't share any option
+ if mode=='master':
+ parser.add_option("-m","--module",action="append",dest="modules",default=[],
+ help="modules, can be used several times or with quotes")
+ 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='master'
+ if len(args)==0 or len(options.modules)==0:
+ parser.print_help()
+ sys.exit(1)
+ adopt_master (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")
options.www=False
options.debug=False
+
+
########## module-*
if len(args) == 0:
if options.all_modules:
Module.init_homedir(options)
- if mode not in Main.release_modes:
+ 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)