def getJarOutputStream(self):
if not self._jarOutputStream:
if self._manifest:
self._jarOutputStream = JarOutputStream(FileOutputStream(self._jarFile), self._manifest)
else:
self._jarOutputStream = JarOutputStream(FileOutputStream(self._jarFile))
return self._jarOutputStream
def produce_jar(outdir, jarname):
"""
Produce a jar from a directory
This function does not use the 'jar' utility, so it does work on the JRE.
"""
fout = FileOutputStream(jarname)
jarOut = JarOutputStream(fout)
add_to_jar(jarOut, outdir)
jarOut.close()
fout.close()
return jarname
def setup(self):
manifest = Manifest()
manifest.getMainAttributes()[Attributes.Name.MANIFEST_VERSION] = "1.0"
if self.runpy and os.path.exists(self.runpy):
manifest.getMainAttributes()[Attributes.Name.MAIN_CLASS] = "org.python.util.JarRunner"
else:
log.debug("No __run__.py defined, so defaulting to Jython command line")
manifest.getMainAttributes()[Attributes.Name.MAIN_CLASS] = "org.python.util.jython"
self.output = open(self.output_path, "wb")
self.jar = JarOutputStream(self.output, manifest)
self.created_paths = set()
self.build_time = int(time.time() * 1000)
class OutputJar(object):
# Derived, with heavy modifications, from
# http://stackoverflow.com/questions/1281229/how-to-use-jaroutputstream-to-create-a-jar-file
def __init__(self, jar=None, output_path="output.jar"):
self.output_path = output_path
if jar is not None:
self.jar = jar
self.output = None
return
self.runpy = None
self.setup()
def __enter__(self):
return self
def __exit__(self, type, value, tb):
self.close()
def setup(self):
manifest = Manifest()
manifest.getMainAttributes()[Attributes.Name.MANIFEST_VERSION] = "1.0"
if self.runpy and os.path.exists(self.runpy):
manifest.getMainAttributes()[
Attributes.Name.MAIN_CLASS] = "org.python.util.JarRunner"
else:
log.debug(
"No __run__.py defined, so defaulting to Jython command line")
manifest.getMainAttributes()[
Attributes.Name.MAIN_CLASS] = "org.python.util.jython"
self.output = open(self.output_path, "wb")
self.jar = JarOutputStream(self.output, manifest)
self.created_paths = set()
self.build_time = int(time.time() * 1000)
def close(self):
self.jar.close()
if self.output:
self.output.close()
def create_ancestry(self, path_parts):
for i in xrange(len(path_parts), 0, -1): # right to left
ancestor = "/".join(path_parts[:-i]) + "/"
if ancestor == "/":
continue # FIXME shouldn't need to do this special casing
if ancestor not in self.created_paths:
entry = JarEntry(ancestor)
entry.time = self.build_time
try:
self.jar.putNextEntry(entry)
self.jar.closeEntry()
except ZipException, e:
if not "duplicate entry" in str(e):
log.error("Problem in creating entry %r",
entry,
exc_info=True)
raise
self.created_paths.add(ancestor)
def setup(self):
manifest = Manifest()
manifest.getMainAttributes()[Attributes.Name.MANIFEST_VERSION] = "1.0"
if self.runpy and os.path.exists(self.runpy):
manifest.getMainAttributes()[Attributes.Name.MAIN_CLASS] = "org.python.util.JarRunner"
else:
log.debug("No __run__.py defined, so defaulting to Jython command line")
manifest.getMainAttributes()[Attributes.Name.MAIN_CLASS] = "org.python.util.jython"
self.output = open(self.output_path, "wb")
self.jar = JarOutputStream(self.output, manifest)
self.created_paths = set()
self.build_time = int(time.time() * 1000)
class OutputJar(object):
# Derived, with heavy modifications, from
# http://stackoverflow.com/questions/1281229/how-to-use-jaroutputstream-to-create-a-jar-file
def __init__(self, jar=None, output_path="output.jar"):
self.output_path = output_path
if jar is not None:
self.jar = jar
self.output = None
return
self.runpy = None
self.setup()
def __enter__ (self):
return self
def __exit__ (self, type, value, tb):
self.close()
def setup(self):
manifest = Manifest()
manifest.getMainAttributes()[Attributes.Name.MANIFEST_VERSION] = "1.0"
if self.runpy and os.path.exists(self.runpy):
manifest.getMainAttributes()[Attributes.Name.MAIN_CLASS] = "org.python.util.JarRunner"
else:
log.debug("No __run__.py defined, so defaulting to Jython command line")
manifest.getMainAttributes()[Attributes.Name.MAIN_CLASS] = "org.python.util.jython"
self.output = open(self.output_path, "wb")
self.jar = JarOutputStream(self.output, manifest)
self.created_paths = set()
self.build_time = int(time.time() * 1000)
def close(self):
self.jar.close()
if self.output:
self.output.close()
def create_ancestry(self, path_parts):
for i in xrange(len(path_parts), 0, -1): # right to left
ancestor = "/".join(path_parts[:-i]) + "/"
if ancestor == "/":
continue # FIXME shouldn't need to do this special casing
if ancestor not in self.created_paths:
entry = JarEntry(ancestor)
entry.time = self.build_time
try:
self.jar.putNextEntry(entry)
self.jar.closeEntry()
except ZipException, e:
if not "duplicate entry" in str(e):
log.error("Problem in creating entry %r", entry, exc_info=True)
raise
self.created_paths.add(ancestor)
# This was needed to intentionally trigger a version error.
import jpype
import jpype.imports
jpype.startJVM()
from java.util.jar import JarOutputStream
from java.util.jar import JarInputStream
from java.util.jar import JarFile
from java.util.zip import CRC32
from java.io import File
from java.io import FileInputStream
from java.io import FileOutputStream
jar = JarInputStream(FileInputStream(File("build/lib/org.jpype.jar")))
manifest = jar.getManifest()
target = JarOutputStream(FileOutputStream(File("build/lib/org.jpype2.jar")),
manifest)
while 1:
entry = jar.getNextEntry()
if not entry:
break
out = []
l3 = 512
while 1:
bt = jpype.JArray(jpype.JByte)(l3)
l = jar.read(bt, 0, l3)
if l == -1:
break
out.append((l, bt))
if out:
def buildLarchJar(outputStream,
additionalFilesAsNameBytesPairs,
filterFn=None,
larchJarURL=None):
"""
Build a JAR from an existing Larch JAR, along with additional files to make a packaged program
:param outputStream: The output stream to which the JAR is to be written
:param additionalFilesAsNameBytesPairs: Additional files in the form of a sequence of tuples consisting of (path, bytes)
:param filterFn: (optional) A filter function that can be used to exclude files from the existing Larch JAR; takes the form of function(name) -> boolean, should return True if file should be included
:param larchJarURL: (optional) A URL at which the existing Larch JAR can be obtained. If None, it will use the JAR from which Larch was started. Raises an error if no URL provided and Larch was not started from a JAR
"""
if larchJarURL is None:
larchJarURL = _larchJarURL
if larchJarURL is None:
raise RuntimeError, 'Larch was not loaded from a JAR file and no Larch JAR file was provided'
jarIn = JarInputStream(larchJarURL.openStream())
manifestIn = jarIn.getManifest()
manifestOut = Manifest(manifestIn)
jarOut = JarOutputStream(outputStream, manifestOut)
bytesBuffer = jarray.zeros(_BYTES_BUFFER_SIZE, 'b')
entryIn = jarIn.getNextJarEntry()
while entryIn is not None:
name = entryIn.getName()
if filterFn is None or filterFn(name):
bufferStream = ByteArrayOutputStream()
while True:
bytesRead = jarIn.read(bytesBuffer, 0, _BYTES_BUFFER_SIZE)
if bytesRead == -1:
break
bufferStream.write(bytesBuffer, 0, bytesRead)
entryOut = ZipEntry(name)
entryOut.setSize(bufferStream.size())
jarOut.putNextEntry(entryOut)
bufferStream.writeTo(jarOut)
jarOut.closeEntry()
entryIn = jarIn.getNextJarEntry()
for name, bytes in additionalFilesAsNameBytesPairs:
size = len(bytes)
entryOut = ZipEntry(name)
entryOut.setSize(size)
jarOut.putNextEntry(entryOut)
jarOut.write(bytes, 0, size)
jarOut.closeEntry()
jarOut.finish()
