def call(self,
context,
args,
outputHandler,
options,
cwd=None,
environs=None):
try:
args = flatten([
context.expandPropertyValues(x, expandList=True) for x in args
])
try:
outputHandlerInstance = outputHandler(os.path.basename(
args[0]),
options=options)
except Exception, e:
# backwards compatibility for output handlers that don't pass kwargs down
outputHandlerInstance = outputHandler(os.path.basename(
args[0]))
call(args,
outputHandler=outputHandlerInstance,
cwd=cwd,
env=self.getExpandedEnvirons(context, environs),
timeout=options['process.timeout'])
def clean(self, context):
BaseTarget.clean(self, context)
options = context.mergeOptions(self)
args = [ options['docker.path'] ]
environs = { 'DOCKER_HOST' : options['docker.host'] } if options['docker.host'] else {}
args.extend(['rmi', context.expandPropertyValues(self.imagename)])
call(args, outputHandler=options['docker.processoutputhandler']('docker-rmi', False, options=options), timeout=options['process.timeout'], env=environs)
def signjar(path, keystore, options, alias=None, storepass=None, outputHandler=None): """ Signs an existing jar. @param path: Jar file to sign @param keystore: The keystore with which to sign it @param options: The current set of options to be used @param alias: An alias for the key (optional) @param storepass: The password for the keystore (optional) @param outputHandler: the output handler (optional) """ if options['java.home']: binary = os.path.join(options['java.home'], "bin/jarsigner") else: binary = "jarsigner" args = [binary] args.extend(options['jarsigner.options']) args.extend(['-keystore', keystore]) if storepass: args.extend(['-storepass', storepass]) args.append(path) if alias: args.append(alias) call(args, outputHandler=outputHandler, timeout=options['process.timeout'])
def run(self, context):
libs = self.libs.resolve(context)
libnames = map(lambda x: os.path.basename(x), libs)
libpaths = map(lambda x: os.path.dirname(x), libs)
flags = [context.expandPropertyValues(x) for x in self.flags]
args = [self.getOption('csharp.compiler'), "-out:" + self.path]
if libnames:
args.extend([
"-reference:" + ",".join(libnames),
"-lib:" + ",".join(libpaths)
])
if self.main:
args.extend(["-target:exe", "-main:" + self.main])
else:
args.append("-target:library")
for (file, id) in self.resources:
args.append('-resource:%s,%s' %
(context.expandPropertyValues(file),
context.expandPropertyValues(id)))
args.extend(self.options['csharp.options'])
args.extend(flags)
args.extend(self.compile.resolve(context))
mkdir(os.path.dirname(self.path))
call(args,
outputHandler=self.getOption('csharp.outputHandlerFactory')(
'csc', False, options=self.options),
timeout=self.options['process.timeout'])
def jar(path,
manifest,
sourcedir,
options,
preserveManifestFormatting=False,
update=False,
outputHandler=None):
""" Create a jar file containing a manifest and some other files
@param path: jar file to create. Typically this file does not already exist, but if it does
then the specified files or manifest will be merged into it.
@param manifest: path to the manifest.mf file (or None to disable manifest entirely)
@param sourcedir: the directory to pack everything from (this method may add extra files to this dir)
@param options: options map. jar.options is a list of additional arguments
@param preserveManifestFormatting: an advanced option that prevents that jar executable from
reformatting the specified manifest file to comply with Java conventions
(also prevents manifest merging if jar already exists)
"""
# work out if we need to create a parent directory
dir = os.path.dirname(path)
if dir and not os.path.exists(dir): mkdir(dir)
# location of jar
if options['java.home']:
binary = os.path.join(options['java.home'], "bin/jar")
else:
binary = "jar"
# build up arguments
args = [binary]
args.extend(options['jar.options'])
if update:
mode = '-u'
else:
mode = '-c'
if not manifest:
args.extend([mode + "fM", path])
elif preserveManifestFormatting:
mkdir(sourcedir + '/META-INF')
srcf = normLongPath(sourcedir + '/META-INF/manifest.mf')
with open(manifest, 'rb') as s:
with openForWrite(srcf, 'wb') as d:
d.write(s.read())
args.extend([mode + "f", path])
else:
args.extend([mode + "fm", path, manifest])
if sourcedir:
args.extend(["-C", sourcedir, "."])
# actually call jar
call(args, outputHandler=outputHandler, timeout=options['process.timeout'])
def blame(self, ref, path, lineno=None):
if lineno:
result = call(self.repository,
'blame -L %s,%s --porcelain %s -- %s' % (
lineno, lineno, ref, path))
else:
result = call(self.repository,
'blame -p -CM %s -- %s' % (ref, path))
result = format_blame(result['stdout'], self.repository)
return self.show(ref), result
def clean(self, context):
BaseTarget.clean(self, context)
args = [ self.getOption('docker.path') ]
environs = { 'DOCKER_HOST' : self.getOption('docker.host') } if self.getOption('docker.host') else {}
args.extend(['rmi', context.expandPropertyValues(self.imagename)])
try:
call(args, outputHandler=self.getOption('docker.processoutputhandler')('docker-rmi', False, options=self.options), timeout=self.getOption('process.timeout'), env=environs)
except Exception as e:
logger = logging.getLogger('DockerBase')
logger.info('Exception cleaning Docker target: %s' % e)
def call(self, context, args, outputHandler, options, cwd=None, environs=None): try: args = flatten([context.expandPropertyValues(x, expandList=True) for x in args]) try: outputHandlerInstance=outputHandler(os.path.basename(args[0]), options=options) except Exception, e: # backwards compatibility for output handlers that don't pass kwargs down outputHandlerInstance = outputHandler(os.path.basename(args[0])) call(args, outputHandler=outputHandlerInstance, cwd=cwd, env=self.getExpandedEnvirons(context, environs), timeout=options['process.timeout'])
def jar(path, manifest, sourcedir, options, preserveManifestFormatting=False, update=False, outputHandler=None): """ Create a jar file containing a manifest and some other files @param path: jar file to create. Typically this file does not already exist, but if it does then the specified files or manifest will be merged into it. @param manifest: path to the manifest.mf file (or None to disable manifest entirely) @param sourcedir: the directory to pack everything from (this method may add extra files to this dir) @param options: options map. jar.options is a list of additional arguments @param preserveManifestFormatting: an advanced option that prevents that jar executable from reformatting the specified manifest file to comply with Java conventions (also prevents manifest merging if jar already exists) """ # work out if we need to create a parent directory dir = os.path.dirname(path) if dir and not os.path.exists(dir): mkdir(dir) # location of jar if options['java.home']: binary = os.path.join(options['java.home'], "bin/jar") else: binary = "jar" # build up arguments args = [binary] args.extend(options['jar.options']) if update: mode='-u' else: mode='-c' if not manifest: args.extend([mode+"fM", path]) elif preserveManifestFormatting: mkdir(sourcedir+'/META-INF') srcf = normLongPath(sourcedir+'/META-INF/manifest.mf') with open(manifest, 'rb') as s: with openForWrite(srcf, 'wb') as d: d.write(s.read()) args.extend([mode+"f", path]) else: args.extend([mode+"fm", path, manifest]) if sourcedir: args.extend(["-C", sourcedir, "."]) # actually call jar call(args, outputHandler=outputHandler, timeout=options['process.timeout'])
def run(self, context):
args = [ self.getOption('docker.path') ]
environs = { 'DOCKER_HOST' : self.getOption('docker.host') } if self.getOption('docker.host') else {}
dargs = list(args)
dargs.extend([
'build', '--rm=true', '-t', context.expandPropertyValues(self.imagename),
])
if self.buildArgs: dargs.extend(["--build-arg=%s" % context.expandPropertyValues(x) for x in self.buildArgs])
if self.dockerfile: dargs.extend(["-f", context.expandPropertyValues(self.dockerfile)])
inputs = self.inputs.resolve(context)
if len(inputs) != 1: raise BuildException("Must specify a single input for Docker.BUILD", location = self.location)
dargs.append(inputs[0])
cwd = os.path.dirname(inputs[0])
call(dargs, outputHandler=self.getOption('docker.processoutputhandler')('docker-build', False, options=self.options), timeout=self.getOption('process.timeout'), env=environs, cwd=cwd)
# update the stamp file
self.updateStampFile()
def run(self, context):
args = [ self.getOption('docker.path') ]
environs = { 'DOCKER_HOST' : self.getOption('docker.host') } if self.getOption('docker.host') else {}
inputs = self.inputs.resolve(context)
if len(inputs) != 0: raise BuildException("Must not specify inputs for Docker.PUSHTAG", location = self.location)
dargs = list(args)
dargs.extend([
'tag', context.expandPropertyValues(self.depimage), context.expandPropertyValues(self.imagename),
])
call(dargs, outputHandler=self.getOption('docker.processoutputhandler')('docker-tag', False, options=self.options), timeout=self.getOption('process.timeout'), env=environs)
dargs = list(args)
dargs.extend([
'push', context.expandPropertyValues(self.imagename),
])
call(dargs, outputHandler=self.getOption('docker.processoutputhandler')('docker-push', False, options=self.options), timeout=self.getOption('process.timeout'), env=environs)
# update the stamp file
self.updateStampFile()
def javadoc(path, sources, classpath, options, outputHandler):
""" Create javadoc from sources and a set of options
@param path: The directory under which to create the javadoc
@param sources: a list of source files
@param classpath: a list of jars for the classpath
@param options: the current set of options to use
@param outputHandler: the output handler (optional)
"""
deleteDir(path)
mkdir(path)
# location of javadoc
if options['java.home']:
binary = os.path.join(options['java.home'], "bin/javadoc")
else:
binary = "javadoc"
# store the list of files in a temporary file, then build from that.
mkdir(options['tmpdir'])
inputlistfile = os.path.join(options['tmpdir'], "javadoc.inputs")
with openForWrite(inputlistfile, 'wb') as f:
f.writelines(
map(lambda x: '"' + x.replace('\\', '\\\\') + '"' + os.linesep,
sources))
# build up arguments
args = [binary]
args.extend(options['javadoc.options'])
if options['javadoc.ignoreSourceFilesFromClasspath']:
args.extend(['-sourcepath', path + '/xpybuild_fake_sourcepath'])
args.extend([
"-d", path, "-classpath", classpath, "-windowtitle",
options['javadoc.title'], "-doctitle", options['javadoc.title'],
"-%s" % options['javadoc.access'],
"@%s" % inputlistfile
])
# actually call javadoc
call(args, outputHandler=outputHandler, timeout=options['process.timeout'])
def run(self, context):
options = context.mergeOptions(self) # get the merged options
libs = self.libs.resolve(context)
libnames = map(lambda x:os.path.basename(x), libs)
libpaths = map(lambda x:os.path.dirname(x), libs)
flags = [context.expandPropertyValues(x) for x in self.flags]
args = [options['csharp.compiler'], "-out:"+self.path]
if libnames: args.extend(["-reference:"+",".join(libnames), "-lib:"+",".join(libpaths)])
if self.main:
args.extend(["-target:exe", "-main:"+self.main])
else:
args.append("-target:library")
for (file, id) in self.resources:
args.append('-resource:%s,%s' % (context.expandPropertyValues(file), context.expandPropertyValues(id)))
args.extend(options['csharp.options'])
args.extend(flags)
args.extend(self.compile.resolve(context))
mkdir(os.path.dirname(self.path))
call(args, outputHandler=options['csharp.processoutputhandler']('csc', False, options=options), timeout=options['process.timeout'])
def merge(self, ref, msg='automerge', commit_msg='', no_ff=False, _raise=True, _env=None):
cmd = ['merge', ref]
if msg:
cmd.append('-m')
cmd.append(msg)
if commit_msg:
cmd.append('-m')
cmd.append(commit_msg)
if no_ff:
cmd.append('--no-ff')
errcode = call(self.repository, cmd, env=_env)
return errcode
def javadoc(path, sources, classpath, options, outputHandler):
""" Create javadoc from sources and a set of options
@param path: The directory under which to create the javadoc
@param sources: a list of source files
@param classpath: a list of jars for the classpath
@param options: the current set of options to use
@param outputHandler: the output handler (optional)
"""
deleteDir(path)
mkdir(path)
# location of javadoc
if options['java.home']:
binary = os.path.join(options['java.home'], "bin/javadoc")
else:
binary = "javadoc"
# store the list of files in a temporary file, then build from that.
mkdir(options['tmpdir'])
inputlistfile = os.path.join(options['tmpdir'], "javadoc.inputs")
with openForWrite(inputlistfile, 'wb') as f:
f.writelines(map(lambda x: '"'+x.replace('\\','\\\\')+'"'+os.linesep, sources))
# build up arguments
args = [binary]
args.extend(options['javadoc.options'])
args.extend([
"-d", path,
"-classpath", classpath,
"-windowtitle", options['javadoc.title'],
"-doctitle", options['javadoc.title'],
"-%s" % options['javadoc.access'],
"@%s" % inputlistfile
])
# actually call javadoc
call(args, outputHandler=outputHandler, timeout=options['process.timeout'])
def run(self, context):
options = context.mergeOptions(self)
args = [ options['docker.path'] ]
environs = { 'DOCKER_HOST' : options['docker.host'] } if options['docker.host'] else {}
if self.mode == Docker.BUILD:
dargs = list(args)
dargs.extend([
'build', '--rm=true', '-t', context.expandPropertyValues(self.imagename),
])
if self.buildArgs: dargs.extend(["--build-arg=%s" % [context.expandPropertyValues(x) for x in self.buildArgs]])
if self.dockerfile: dargs.extend(["-f", context.expandPropertyValues(self.dockerfile)])
inputs = self.inputs.resolve(context)
if len(inputs) != 1: raise BuildException("Must specify a single input for Docker.BUILD", location = self.location)
dargs.append(inputs[0])
cwd = os.path.dirname(inputs[0])
call(dargs, outputHandler=options['docker.processoutputhandler']('docker-build', False, options=options), timeout=options['process.timeout'], env=environs, cwd=cwd)
elif self.mode == Docker.PUSHTAG:
inputs = self.inputs.resolve(context)
if len(inputs) != 0: raise BuildException("Must not specify inputs for Docker.PUSHTAG", location = self.location)
dargs = list(args)
dargs.extend([
'tag', context.expandPropertyValues(self.depimage), context.expandPropertyValues(self.imagename),
])
call(dargs, outputHandler=options['docker.processoutputhandler']('docker-tag', False, options=options), timeout=options['process.timeout'], env=environs)
dargs = list(args)
dargs.extend([
'push', context.expandPropertyValues(self.imagename),
])
call(dargs, outputHandler=options['docker.processoutputhandler']('docker-push', False, options=options), timeout=options['process.timeout'], env=environs)
else:
raise BuildException('Unknown Docker mode. Must be Docker.BUILD or Docker.PUSHTAG', location = self.location)
# update the stamp file
path = normLongPath(self.path)
mkdir(os.path.dirname(path))
with openForWrite(path, 'wb') as f:
pass
def push(self, remote, ref):
cmd = ['push', remote, ref]
errcode = call(self.repository, cmd)
return errcode
def format_patch(self, ref, from_ref=None):
if from_ref:
result = call(self.repository, 'format-patch --stdout %s...%s' % (from_ref, ref))
else:
result = call(self.repository, 'format-patch -1 --stdout %s' % ref)
return result['stdout']
def update_server_info(repository):
return call(repository, 'update-server-info')
def javac(output, inputs, classpath, options, logbasename, targetname):
""" Compile some java files to class files.
Will raise BuildException if compilation fails.
@param output: path to a directory in which to put the class files (will be created)
@param inputs: list of paths (.java files) to be compiled
@param classpath: classpath to compile with, as a string
@param options: options map. javac.options is a list of additional arguments, javac.source is the source version,
javac.target is the target version
@param logbasename: absolute, expanded, path to a directory and filename prefix
to use for files such as .err, .out, etc files
@param targetname: to log appropriate error messages
"""
assert logbasename and '$' not in logbasename
logbasename = os.path.normpath(logbasename)
# make the output directory
if not os.path.exists(output): mkdir(output)
# location of javac
if options['java.home']:
javacpath = os.path.join(options['java.home'], "bin/javac")
else:
javacpath = "javac" # just get it from the path
# store the list of files in a temporary file, then build from that.
mkdir(options['tmpdir'])
argsfile = os.path.join(options['tmpdir'], "javac_args.txt")
# build up the arguments
args = ["-d", output]
if options["javac.source"]: args.extend(["-source", options["javac.source"]])
if options["javac.target"]: args.extend(["-source", options["javac.target"]])
if options["javac.encoding"]: args.extend(["-encoding", options["javac.encoding"]])
if options["javac.debug"]:
args.append('-g')
if options['javac.warningsAsErrors']:
args.append('-Werror')
# TODO: should add -Xlint options here I think
args.extend(getStringList(options['javac.options']))
if classpath: args.extend(['-cp', classpath])
args.extend([x for x in inputs if x.endswith('.java')]) # automatically filter out non-java files
with openForWrite(argsfile, 'wb') as f:
for a in args:
a = '"%s"'%a.replace('\\','\\\\')
print >>f, a
success=False
try:
log.info('Executing javac for %s, writing output to %s: %s', targetname, logbasename+'.out', ''.join(['\n\t"%s"'%x for x in [javacpath]+args]))
# make sure we have no old ones hanging around still
try:
deleteFile(logbasename+'-errors.txt', allowRetry=True)
deleteFile(logbasename+'-warnings.txt', allowRetry=True)
deleteFile(logbasename+'.out', allowRetry=True)
except Exception as e:
log.info('Cleaning up file failed: %s' % e)
outputHandler = JavacProcessOutputHandler(targetname, options=options)
outputHandler.setJavacLogBasename(logbasename)
call([javacpath, "@%s" % argsfile], outputHandler=outputHandler, outputEncoding='UTF-8', cwd=output, timeout=options['process.timeout'])
if (not os.listdir(output)): # unlikely, but useful failsafe
raise EnvironmentError('javac command failed to create any target files (but returned no error code); see output at "%s"'%(logbasename+'.out'))
success = True
finally:
if not success and classpath:
log.info('Classpath for failed javac was: \n %s', '\n '.join(classpath.split(os.pathsep)))
