/** Creates a new JAR file. */
void create(OutputStream out, Manifest manifest) throws IOException {
ZipOutputStream zos = new JarOutputStream(out);
if (flag0) {
zos.setMethod(ZipOutputStream.STORED);
}
if (manifest != null) {
if (vflag) {
output(getMsg("out.added.manifest"));
}
ZipEntry e = new ZipEntry(MANIFEST_DIR);
e.setTime(System.currentTimeMillis());
e.setSize(0);
e.setCrc(0);
zos.putNextEntry(e);
e = new ZipEntry(MANIFEST_NAME);
e.setTime(System.currentTimeMillis());
if (flag0) {
crc32Manifest(e, manifest);
}
zos.putNextEntry(e);
manifest.write(zos);
zos.closeEntry();
}
for (File file : entries) {
addFile(zos, file);
}
zos.close();
}
@Test
public void shouldSetTimestampOfEntries() throws IOException {
Calendar cal = Calendar.getInstance();
cal.set(1999, SEPTEMBER, 10);
long old = getTimeRoundedToSeconds(cal.getTime());
long now = getTimeRoundedToSeconds(new Date());
try (CustomZipOutputStream out = ZipOutputStreams.newOutputStream(output)) {
ZipEntry oldAndValid = new ZipEntry("oldAndValid");
oldAndValid.setTime(old);
out.putNextEntry(oldAndValid);
ZipEntry current = new ZipEntry("current");
current.setTime(now);
out.putNextEntry(current);
}
try (ZipInputStream in = new ZipInputStream(Files.newInputStream(output))) {
ZipEntry entry = in.getNextEntry();
assertEquals("oldAndValid", entry.getName());
assertEquals(old, entry.getTime());
entry = in.getNextEntry();
assertEquals("current", entry.getName());
assertEquals(now, entry.getTime());
}
}
/*
* (non-Javadoc)
*
* @see org.xmind.core.io.IOutputTarget#setEntryTime(java.lang.String, long)
*/
public void setEntryTime(String entryName, long time) {
if (entryName != null) {
if (currentEntry != null && currentEntry.getName().equals(entryName)) {
currentEntry.setTime(time);
}
}
}
public void addTozip(ContentItem inContent, String inName, ZipOutputStream finalZip)
throws IOException {
InputStream is = inContent.getInputStream();
if (is == null) {
log.error("Couldn't add file to zip: " + inContent.getAbsolutePath());
return;
}
ZipEntry entry = null;
if (getFolderToStripOnZip() != null) {
if (inName.contains(getFolderToStripOnZip())) {
String stripped = inName.substring(getFolderToStripOnZip().length(), inName.length());
entry = new ZipEntry(stripped);
} else {
entry = new ZipEntry(inName);
}
} else {
entry = new ZipEntry(inName);
}
entry.setSize(inContent.getLength());
entry.setTime(inContent.lastModified().getTime());
finalZip.putNextEntry(entry);
try {
new OutputFiller().fill(is, finalZip);
} finally {
is.close();
}
finalZip.closeEntry();
}
/** Adds byte content into the zip as a file. */
public static void addToZip(ZipOutputStream zos, byte[] content, String path, String comment)
throws IOException {
while (path.length() != 0 && path.charAt(0) == '/') {
path = path.substring(1);
}
if (StringUtil.endsWithChar(path, '/')) {
path = path.substring(0, path.length() - 1);
}
ZipEntry zipEntry = new ZipEntry(path);
zipEntry.setTime(System.currentTimeMillis());
if (comment != null) {
zipEntry.setComment(comment);
}
zos.putNextEntry(zipEntry);
InputStream is = new ByteArrayInputStream(content);
try {
StreamUtil.copy(is, zos);
} finally {
StreamUtil.close(is);
}
zos.closeEntry();
}
public void testCryptRoundtrip() throws Exception {
ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
ZipOutputStream zipOut = new ZipOutputStream(byteOut);
ZipEntry dataEntry = new ZipEntry("Data");
dataEntry.setTime(1000000L);
zipOut.putNextEntry(dataEntry);
DataOutputStream out = new DataOutputStream(zipOut);
for (int i = 0; i < 100; i++) {
out.writeInt(i);
out.writeUTF(" ");
}
out.close();
byte[] bytes = byteOut.toByteArray();
ZipInputStream zipIn = new ZipInputStream(new ByteArrayInputStream(bytes));
ZipEntry entry = zipIn.getNextEntry();
while (entry != null && !entry.getName().equals("Data")) {
entry = zipIn.getNextEntry();
}
if (entry == null) fail("Could not find the data entry");
DataInputStream in = new DataInputStream(zipIn);
for (int i = 0; i < 100; i++) {
assertEquals(i, in.readInt());
assertEquals("Expected an empty string here.", in.readUTF(), " ");
}
in.close();
}
/**
* Adds a file to the Zip file
*
* @param file The file to add
* @param entryName
* @param zOut
* @throws IOException
*/
public static void addFileToZip(File file, String entryName, ZipOutputStream zOut)
throws IOException {
// Don't add directories
if (file.isDirectory()) {
return;
}
int bytesRead;
final int bufSize = 1024;
byte buf[] = new byte[bufSize];
ZipEntry zipEntry = new ZipEntry(entryName);
// Set time stamp to file's
zipEntry.setTime(file.lastModified());
try {
zOut.putNextEntry(zipEntry);
} catch (IOException ex) {
/*
* Ignore things like duplicate entries and just carry on
*/
return;
}
BufferedInputStream in = new BufferedInputStream(new FileInputStream(file), bufSize);
while ((bytesRead = in.read(buf)) != -1) {
zOut.write(buf, 0, bytesRead);
}
zOut.closeEntry();
in.close();
}
/*
* public void zipFilesIn( File inDir,String inIncludePath, OutputStream
* inToBrowser ) throws IOException, OpenEditException {
*
* String startingdir = inDir.getAbsolutePath(); if (
* !startingdir.endsWith(File.separator)) { startingdir = startingdir +
* File.separator; } if( inIncludePath.length() > 1) { inDir = new File(
* inDir, inIncludePath); }
*
* ZipOutputStream finalZip = new ZipOutputStream(inToBrowser);
*
* File[] children = inDir.listFiles(); if ( children != null) { for (int i
* = 0; i < children.length; i++) { addToZip( children[i], startingdir,
* finalZip); } } finalZip.close(); }
*/
public void addTozip(String inContent, String inName, ZipOutputStream finalZip)
throws IOException {
ZipEntry entry = new ZipEntry(inName);
entry.setSize(inContent.length());
entry.setTime(new Date().getTime());
finalZip.putNextEntry(entry);
finalZip.write(inContent.getBytes("UTF-8"));
finalZip.closeEntry();
}
public AesZipEntry(ZipEntry zipEntry) {
super(zipEntry.getName());
super.setMethod(zipEntry.getMethod());
super.setSize(zipEntry.getSize());
super.setCompressedSize(zipEntry.getCompressedSize() + 28);
super.setTime(zipEntry.getTime());
flag |= 1; // bit0 - encrypted
// flag |= 8; // bit3 - use data descriptor
}
/**
* Writes an entity to a given ZIP output stream with a given ZIP entry name.
*
* @param entity The entity to write.
* @param out The ZIP output stream.
* @param entryName The ZIP entry name.
* @return True if the writing was successful.
* @throws IOException
*/
private boolean writeEntityStream(Representation entity, ZipOutputStream out, String entryName)
throws IOException {
if (entity != null && !entryName.endsWith("/")) {
ZipEntry entry = new ZipEntry(entryName);
if (entity.getModificationDate() != null)
entry.setTime(entity.getModificationDate().getTime());
else {
entry.setTime(System.currentTimeMillis());
}
out.putNextEntry(entry);
BioUtils.copy(new BufferedInputStream(entity.getStream()), out);
out.closeEntry();
return true;
}
out.putNextEntry(new ZipEntry(entryName));
out.closeEntry();
return false;
}
protected void packBundle(ZipOutputStream output, Bundle bundle, String path, Filter filter)
throws IOException {
if (filter != null && !filter.accept(path)) {
log(Level.FINE, "exclude {0}/{1}", new Object[] {bundle.getBundleID(), path});
return;
}
BundleFile bundleFile = bundle.getBundleFile();
if (bundleFile.isDirectory(path)) {
List<String> entries = bundleFile.getEntryPaths(path);
for (String entry : entries) {
packBundle(output, bundle, entry, filter);
}
return;
}
// pack the JAR/ZIP
BundleEntry bundleEntry = bundleFile.getEntry(path);
if (path.endsWith(".jar") || path.endsWith(".zip")) {
File tempZipFile = createTempFile(bundleEntry);
try {
ZipFile zipFile = new ZipFile(tempZipFile);
try {
packZip(output, bundleEntry, zipFile, filter);
} finally {
zipFile.close();
}
} finally {
tempZipFile.delete();
}
return;
}
// pack the normal entry
if (existingEntries.contains(path)) {
log(Level.WARNING, "duplicate {0}/{1}", new Object[] {bundle.getBundleID(), path});
return;
}
existingEntries.add(path);
InputStream input = bundleEntry.getInputStream();
try {
ZipEntry zipEntry = new ZipEntry(bundleEntry.getName());
zipEntry.setTime(bundleEntry.getTime());
zipEntry.setSize(bundleEntry.getSize());
output.putNextEntry(zipEntry);
try {
copyStream(input, output);
} finally {
output.closeEntry();
}
} finally {
input.close();
}
}
private void addIndex(JarIndex index, ZipOutputStream zos) throws IOException {
ZipEntry e = new ZipEntry(INDEX_NAME);
e.setTime(System.currentTimeMillis());
if (flag0) {
CRC32OutputStream os = new CRC32OutputStream();
index.write(os);
os.updateEntry(e);
}
zos.putNextEntry(e);
index.write(zos);
zos.closeEntry();
}
/** Adds a new file entry to the ZIP output stream. */
void addFile(ZipOutputStream zos, File file) throws IOException {
String name = file.getPath();
boolean isDir = file.isDirectory();
if (isDir) {
name = name.endsWith(File.separator) ? name : (name + File.separator);
}
name = entryName(name);
if (name.equals("") || name.equals(".") || name.equals(zname)) {
return;
} else if ((name.equals(MANIFEST_DIR) || name.equals(MANIFEST_NAME)) && !Mflag) {
if (vflag) {
output(formatMsg("out.ignore.entry", name));
}
return;
}
long size = isDir ? 0 : file.length();
if (vflag) {
out.print(formatMsg("out.adding", name));
}
ZipEntry e = new ZipEntry(name);
e.setTime(file.lastModified());
if (size == 0) {
e.setMethod(ZipEntry.STORED);
e.setSize(0);
e.setCrc(0);
} else if (flag0) {
crc32File(e, file);
}
zos.putNextEntry(e);
if (!isDir) {
copy(file, zos);
}
zos.closeEntry();
/* report how much compression occurred. */
if (vflag) {
size = e.getSize();
long csize = e.getCompressedSize();
out.print(formatMsg2("out.size", String.valueOf(size), String.valueOf(csize)));
if (e.getMethod() == ZipEntry.DEFLATED) {
long ratio = 0;
if (size != 0) {
ratio = ((size - csize) * 100) / size;
}
output(formatMsg("out.deflated", String.valueOf(ratio)));
} else {
output(getMsg("out.stored"));
}
}
}
@Test
public void shouldBeAbleToAddTwoZeroLengthFiles() throws IOException {
File reference = File.createTempFile("reference", ".zip");
try (CustomZipOutputStream out = ZipOutputStreams.newOutputStream(output);
ZipOutputStream ref = new ZipOutputStream(new FileOutputStream(reference))) {
ZipEntry entry = new ZipEntry("example.txt");
entry.setTime(System.currentTimeMillis());
out.putNextEntry(entry);
ref.putNextEntry(entry);
ZipEntry entry2 = new ZipEntry("example2.txt");
entry2.setTime(System.currentTimeMillis());
out.putNextEntry(entry2);
ref.putNextEntry(entry2);
}
byte[] seen = Files.readAllBytes(output);
byte[] expected = Files.readAllBytes(reference.toPath());
assertArrayEquals(expected, seen);
}
// Used to investigate date roundtrip behaviour across zip versions
public void testZipStuff() throws IOException {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ZipOutputStream zos = new ZipOutputStream(baos);
// name the file inside the zip file
final File oddFile = new File("src/test/resources/zip-timestamp/file-with-odd-time.txt");
final File evenFile = new File("src/test/resources/zip-timestamp/file-with-even-time.txt");
final ZipEntry oddZe = new ZipEntry(oddFile.getName());
oddZe.setTime(oddFile.lastModified());
zos.putNextEntry(oddZe);
final ZipEntry evenZe = new ZipEntry(evenFile.getName());
evenZe.setTime(evenFile.lastModified());
zos.putNextEntry(evenZe);
zos.close();
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
ZipInputStream zipInputStream = new ZipInputStream(bais);
final java.util.zip.ZipEntry oddEntry = zipInputStream.getNextEntry();
System.out.println("oddEntry.getTime() = " + new Date(oddEntry.getTime()).toString());
System.out.println("oddEntry.getName() = " + oddEntry.getName());
final java.util.zip.ZipEntry evenEntry = zipInputStream.getNextEntry();
System.out.println("evenEntry.getName() = " + evenEntry.getName());
System.out.println("evenEntry.getTime() = " + new Date(evenEntry.getTime()).toString());
}
private HashCode writeSimpleJarAndGetHash() throws Exception {
try (FileOutputStream fileOutputStream = new FileOutputStream(output.toFile());
ZipOutputStream out = new JarOutputStream(fileOutputStream)) {
ZipEntry entry = new CustomZipEntry("test");
out.putNextEntry(entry);
out.write(new byte[0]);
entry = new ZipEntry("test1");
entry.setTime(ZipConstants.getFakeTime());
out.putNextEntry(entry);
out.write(new byte[0]);
}
return Hashing.sha1().hashBytes(Files.readAllBytes(output));
}
private static void zipDirectory(ZipOutputStream out, String rootPath, File... inputDirs)
throws IOException {
LinkedHashMap<String, File> files = newLinkedHashMap();
for (File inputDir : Lists.reverse(Arrays.asList(inputDirs))) {
listFilesRecursive(rootPath, files, inputDir);
}
for (Entry<String, File> entry : files.entrySet()) {
String path = entry.getKey();
File file = entry.getValue();
if (file.isDirectory()) {
if (!path.endsWith("/")) {
path = path + "/";
}
ZipEntry dirEntry = new ZipEntry(path);
dirEntry.setTime(file.lastModified());
out.putNextEntry(dirEntry);
} else {
ZipEntry fileEntry = new ZipEntry(path);
fileEntry.setTime(file.lastModified());
out.putNextEntry(fileEntry);
Files.copy(file, out);
}
}
}
private static void addToZip(
IPath path, IResource resource, ZipOutputStream zip, boolean adjustGMTOffset)
throws IOException, CoreException {
switch (resource.getType()) {
case IResource.FILE:
ZipEntry zipEntry = new ZipEntry(path.toString());
zip.putNextEntry(zipEntry);
InputStream contents = ((IFile) resource).getContents();
if (adjustGMTOffset) {
TimeZone currentTimeZone = TimeZone.getDefault();
Calendar currentDt = new GregorianCalendar(currentTimeZone, Locale.getDefault());
// Get the Offset from GMT taking current TZ into account
int gmtOffset =
currentTimeZone.getOffset(
currentDt.get(Calendar.ERA), currentDt.get(Calendar.YEAR),
currentDt.get(Calendar.MONTH), currentDt.get(Calendar.DAY_OF_MONTH),
currentDt.get(Calendar.DAY_OF_WEEK), currentDt.get(Calendar.MILLISECOND));
zipEntry.setTime(System.currentTimeMillis() + (gmtOffset * -1));
}
try {
IOUtils.copy(contents, zip);
} finally {
contents.close();
}
break;
case IResource.FOLDER:
case IResource.PROJECT:
IContainer container = (IContainer) resource;
IResource[] members = container.members();
for (IResource res : members) {
addToZip(path.append(res.getName()), res, zip, adjustGMTOffset);
}
}
}
public void zip(File from, String to) throws FITTESTException {
File toFile = new File(to);
try {
FileOutputStream fos = new FileOutputStream(toFile);
ZipOutputStream zos = new ZipOutputStream(new BufferedOutputStream(fos));
byte data[] = new byte[BUFFER];
Vector<File> files = collectFiles(from);
URI base = null;
if (from.isDirectory()) {
base = from.toURI();
}
for (File f : files) {
String name = null;
if (base != null) {
name = from.getName() + "/" + base.relativize(f.toURI()).getPath();
} else {
name = f.getName();
}
if (f.isDirectory()) {
name = name.endsWith("/") ? name : name + "/";
}
ZipEntry entry = new ZipEntry(name);
entry.setTime(f.lastModified());
zos.putNextEntry(entry);
if (f.isFile()) {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(f), BUFFER);
int count;
while ((count = bis.read(data, 0, BUFFER)) != -1) {
zos.write(data, 0, count);
}
bis.close();
}
zos.closeEntry();
}
zos.close();
} catch (Exception e) {
throw new FITTESTException(e.getMessage());
}
}
/**
* Adds the specified entry to the output stream.
*
* @param entry entry descriptor
* @param con contents
* @param out output archive
* @param level default compression level
* @throws QueryException query exception
* @throws IOException I/O exception
*/
private void add(final Item entry, final Item con, final ArchiveOut out, final int level)
throws QueryException, IOException {
// create new zip entry
final String name = string(entry.string(info));
if (name.isEmpty()) ARCH_EMPTY.thrw(info);
final ZipEntry ze = new ZipEntry(name);
String en = null;
// compression level
byte[] lvl = null;
if (entry instanceof ANode) {
final ANode el = (ANode) entry;
lvl = el.attribute(Q_LEVEL);
// last modified
final byte[] mod = el.attribute(Q_LAST_MOD);
if (mod != null) {
try {
ze.setTime(new Int(new Dtm(mod, info)).itr());
} catch (final QueryException qe) {
ARCH_DATETIME.thrw(info, mod);
}
}
// encoding
final byte[] enc = el.attribute(Q_ENCODING);
if (enc != null) {
en = string(enc);
if (!Charset.isSupported(en)) ARCH_ENCODING.thrw(info, enc);
}
}
// data to be compressed
byte[] val = checkStrBin(con);
if (con instanceof AStr && en != null && en != Token.UTF8) val = encode(val, en);
try {
out.level(lvl == null ? level : toInt(lvl));
} catch (final IllegalArgumentException ex) {
ARCH_LEVEL.thrw(info, lvl);
}
out.write(ze, val);
}
/**
* Write the contents of the file to the tar archive.
*
* @param entry
* @param contents
* @exception java.io.IOException
* @exception org.eclipse.core.runtime.CoreException
*/
private void write(ZipEntry entry, IFile contents) throws IOException, CoreException {
byte[] readBuffer = new byte[4096];
// If the contents are being compressed then we get the below for free.
if (!useCompression) {
entry.setMethod(ZipEntry.STORED);
InputStream contentStream = contents.getContents(false);
int length = 0;
CRC32 checksumCalculator = new CRC32();
try {
int n;
while ((n = contentStream.read(readBuffer)) > 0) {
checksumCalculator.update(readBuffer, 0, n);
length += n;
}
} finally {
if (contentStream != null) {
contentStream.close();
}
}
entry.setSize(length);
entry.setCrc(checksumCalculator.getValue());
}
// set the timestamp
long localTimeStamp = contents.getLocalTimeStamp();
if (localTimeStamp != IResource.NULL_STAMP) entry.setTime(localTimeStamp);
outputStream.putNextEntry(entry);
InputStream contentStream = contents.getContents(false);
try {
int n;
while ((n = contentStream.read(readBuffer)) > 0) {
outputStream.write(readBuffer, 0, n);
}
} finally {
if (contentStream != null) {
contentStream.close();
}
}
outputStream.closeEntry();
}
protected void packZip(
ZipOutputStream output, BundleEntry bundleEntry, ZipFile zipFile, Filter filter)
throws IOException {
Enumeration<? extends ZipEntry> entries = zipFile.entries();
while (entries.hasMoreElements()) {
ZipEntry srcEntry = entries.nextElement();
String entryName = srcEntry.getName();
if (filter != null && !filter.accept(bundleEntry.getName() + "/" + entryName)) {
log(
Level.FINE,
"exclude {0}/{1}/{2}",
new Object[] {bundleEntry.getBundleID(), bundleEntry.getName(), entryName});
continue;
}
if (entryName.endsWith("/")) {
continue;
}
if (existingEntries.contains(entryName)) {
log(
Level.WARNING,
"duplicate {0}/{1}/{2}",
new Object[] {bundleEntry.getBundleID(), bundleEntry.getName(), entryName});
continue;
}
existingEntries.add(entryName);
ZipEntry tgtEntry = new ZipEntry(entryName);
tgtEntry.setTime(srcEntry.getTime());
output.putNextEntry(tgtEntry);
try {
InputStream input = zipFile.getInputStream(srcEntry);
try {
copyStream(input, output);
} finally {
input.close();
}
} finally {
output.closeEntry();
}
}
}
/**
* Stores all the files in the given JAR file. Also attempts to root the paths of the filenames to
* each element of a list of classpaths.
*
* @param jarFile the JAR file to create
* @param classPath an array of paths to try to use as root for classes
* @param files a list of files to store in the JAR file
* @throws IOException
*/
void createJar(File jarFile, String[] classPath, File... files) throws IOException {
logger.info("Creating " + jarFile);
JarOutputStream jos = new JarOutputStream(new FileOutputStream(jarFile));
for (File f : files) {
String name = f.getPath();
if (classPath != null) {
// Store only the path relative to the classpath so that
// our Loader may use the package name of the associated
// class to get the file as a resource from the ClassLoader.
String[] names = new String[classPath.length];
for (int i = 0; i < classPath.length; i++) {
String path = new File(classPath[i]).getCanonicalPath();
if (name.startsWith(path)) {
names[i] = name.substring(path.length() + 1);
}
}
// Retain only the shortest relative name.
for (int i = 0; i < names.length; i++) {
if (names[i] != null && names[i].length() < name.length()) {
name = names[i];
}
}
}
ZipEntry e = new ZipEntry(name.replace(File.separatorChar, '/'));
e.setTime(f.lastModified());
jos.putNextEntry(e);
FileInputStream fis = new FileInputStream(f);
byte[] buffer = new byte[1024];
int length;
while ((length = fis.read(buffer)) != -1) {
jos.write(buffer, 0, length);
}
fis.close();
jos.closeEntry();
// f.delete();
// f.getParentFile().delete();
}
jos.close();
}
private boolean updateManifest(Manifest m, ZipOutputStream zos) throws IOException {
addVersion(m);
addCreatedBy(m);
if (ename != null) {
addMainClass(m, ename);
}
if (pname != null) {
if (!addProfileName(m, pname)) {
return false;
}
}
ZipEntry e = new ZipEntry(MANIFEST_NAME);
e.setTime(System.currentTimeMillis());
if (flag0) {
crc32Manifest(e, m);
}
zos.putNextEntry(e);
m.write(zos);
if (vflag) {
output(getMsg("out.update.manifest"));
}
return true;
}
@Test
public void shouldBeAbleToSimplyStoreInputFilesWithoutCompressing() throws IOException {
File reference = File.createTempFile("reference", ".zip");
try (CustomZipOutputStream out = ZipOutputStreams.newOutputStream(output);
ZipOutputStream ref = new ZipOutputStream(new FileOutputStream(reference))) {
byte[] bytes = "cheese".getBytes();
ZipEntry entry = new ZipEntry("example.txt");
entry.setMethod(ZipEntry.STORED);
entry.setTime(System.currentTimeMillis());
entry.setSize(bytes.length);
entry.setCrc(Hashing.crc32().hashBytes(bytes).padToLong());
out.putNextEntry(entry);
ref.putNextEntry(entry);
out.write(bytes);
ref.write(bytes);
}
byte[] seen = Files.readAllBytes(output);
byte[] expected = Files.readAllBytes(reference.toPath());
assertArrayEquals(expected, seen);
}
public static void addFolderToZip(ZipOutputStream zos, String path, String comment)
throws IOException {
while (path.length() != 0 && path.charAt(0) == '/') {
path = path.substring(1);
}
// add folder record
if (!StringUtil.endsWithChar(path, '/')) {
path += '/';
}
ZipEntry zipEntry = new ZipEntry(path);
zipEntry.setTime(System.currentTimeMillis());
if (comment != null) {
zipEntry.setComment(comment);
}
zipEntry.setSize(0);
zipEntry.setCrc(0);
zos.putNextEntry(zipEntry);
zos.closeEntry();
}
@TaskAction
public void doTask() throws IOException {
setup();
if (getOutJar().exists()) {
getOutJar().delete();
}
ZipFile in = new ZipFile(getInJar());
ZipInputStream classesIn = new ZipInputStream(new FileInputStream(getClassesJar()));
ZipOutputStream out =
new ZipOutputStream(new BufferedOutputStream(new FileOutputStream(getOutJar())));
try {
// DO PATCHES
log("Patching Class:");
for (ZipEntry e : Collections.list(in.entries())) {
if (e.isDirectory()) {
out.putNextEntry(e);
} else {
ZipEntry n = new ZipEntry(e.getName());
n.setTime(e.getTime());
out.putNextEntry(n);
byte[] data = ByteStreams.toByteArray(in.getInputStream(e));
ClassPatch patch = patchlist.get(e.getName().replace('\\', '/'));
if (patch != null) {
log(
"\t%s (%s) (input size %d)",
patch.targetClassName, patch.sourceClassName, data.length);
int inputChecksum = adlerHash(data);
if (patch.inputChecksum != inputChecksum) {
throw new RuntimeException(
String.format(
"There is a binary discrepency between the expected input class %s (%s) and the actual class. Checksum on disk is %x, in patch %x. Things are probably about to go very wrong. Did you put something into the jar file?",
patch.targetClassName,
patch.sourceClassName,
inputChecksum,
patch.inputChecksum));
}
synchronized (patcher) {
data = patcher.patch(data, patch.patch);
}
}
out.write(data);
}
}
// COPY DATA
ZipEntry entry = null;
while ((entry = classesIn.getNextEntry()) != null) {
// no META or dirs. wel take care of dirs later.
if (entry.getName().contains("META-INF")
|| entry.getName().equals("cpw/mods/fml/relauncher/Side.class")
|| entry.getName().equals("cpw/mods/fml/relauncher/SideOnly.class")) {
continue;
}
out.putNextEntry(entry);
out.write(ByteStreams.toByteArray(classesIn));
}
} finally {
classesIn.close();
in.close();
out.close();
}
}
/**
* Creates a zip archive of the currently serialized files in getCurrentDirectory(), placing the
* archive in getArchiveDirectory().
*
* @throws RuntimeException if clazz cannot be serialized. This exception has an informative
* message and wraps the originally thrown exception as root cause.
* @see #getCurrentDirectory()
* @see #getArchiveDirectory()
*/
public void archiveCurrentDirectory() throws RuntimeException {
System.out.println(
"Making zip archive of files in "
+ getCurrentDirectory()
+ ", putting it in "
+ getArchiveDirectory()
+ ".");
File current = new File(getCurrentDirectory());
if (!current.exists() || !current.isDirectory()) {
throw new IllegalArgumentException(
"There is no "
+ current.getAbsolutePath()
+ " directory. "
+ "\nThis is where the serialized classes should be. "
+ "Please run serializeCurrentDirectory() first.");
}
File archive = new File(getArchiveDirectory());
if (archive.exists() && !archive.isDirectory()) {
throw new IllegalArgumentException(
"Output directory " + archive.getAbsolutePath() + " is not a directory.");
}
if (!archive.exists()) {
boolean success = archive.mkdirs();
}
String[] filenames = current.list();
// Create a buffer for reading the files
byte[] buf = new byte[1024];
try {
String version = Version.currentRepositoryVersion().toString();
// Create the ZIP file
String outFilename = "serializedclasses-" + version + ".zip";
File _file = new File(getArchiveDirectory(), outFilename);
FileOutputStream fileOut = new FileOutputStream(_file);
ZipOutputStream out = new ZipOutputStream(fileOut);
// Compress the files
for (String filename : filenames) {
File file = new File(current, filename);
FileInputStream in = new FileInputStream(file);
// Add ZIP entry to output stream.
ZipEntry entry = new ZipEntry(filename);
entry.setSize(file.length());
entry.setTime(file.lastModified());
out.putNextEntry(entry);
// Transfer bytes from the file to the ZIP file
int len;
while ((len = in.read(buf)) > 0) {
out.write(buf, 0, len);
}
// Complete the entry
out.closeEntry();
in.close();
}
// Complete the ZIP file
out.close();
System.out.println("Finished writing zip file " + outFilename + ".");
} catch (IOException e) {
throw new RuntimeException(
"There was an I/O error associated with "
+ "the process of zipping up files in "
+ getCurrentDirectory()
+ ".",
e);
}
}
/**
* Export the object (Item, Collection, or Community) to a package file on the indicated
* OutputStream. Gets an exception of the object cannot be packaged or there is a failure creating
* the package.
*
* @param context - DSpace context.
* @param dso - DSpace object (item, collection, etc)
* @param pkg - output stream on which to write package
* @throws PackageException if package cannot be created or there is a fatal error in creating it.
*/
public void disseminate(
Context context, DSpaceObject dso, PackageParameters params, OutputStream pkg)
throws PackageValidationException, CrosswalkException, AuthorizeException, SQLException,
IOException {
if (dso.getType() == Constants.ITEM) {
Item item = (Item) dso;
long lmTime = item.getLastModified().getTime();
// how to handle unauthorized bundle/bitstream:
String unauth = (params == null) ? null : params.getProperty("unauthorized");
if (params != null && params.getProperty("manifestOnly") != null) {
extraFiles = null;
writeManifest(context, item, params, pkg);
} else {
extraFiles = new HashMap();
ZipOutputStream zip = new ZipOutputStream(pkg);
zip.setComment("METS archive created by DSpace METSDisseminationCrosswalk");
// write manifest first.
ZipEntry me = new ZipEntry(MANIFEST_FILE);
me.setTime(lmTime);
zip.putNextEntry(me);
writeManifest(context, item, params, zip);
zip.closeEntry();
// copy extra (meta?) bitstreams into zip
Iterator fi = extraFiles.keySet().iterator();
while (fi.hasNext()) {
String fname = (String) fi.next();
ZipEntry ze = new ZipEntry(fname);
ze.setTime(lmTime);
zip.putNextEntry(ze);
Utils.copy((InputStream) extraFiles.get(fname), zip);
zip.closeEntry();
}
// copy all non-meta bitstreams into zip
Bundle bundles[] = item.getBundles();
for (int i = 0; i < bundles.length; i++) {
if (!PackageUtils.isMetaInfoBundle(bundles[i])) {
// unauthorized bundle?
if (!AuthorizeManager.authorizeActionBoolean(context, bundles[i], Constants.READ)) {
if (unauth != null && (unauth.equalsIgnoreCase("skip"))) {
log.warn(
"Skipping Bundle[\""
+ bundles[i].getName()
+ "\"] because you are not authorized to read it.");
continue;
} else
throw new AuthorizeException(
"Not authorized to read Bundle named \"" + bundles[i].getName() + "\"");
}
Bitstream[] bitstreams = bundles[i].getBitstreams();
for (int k = 0; k < bitstreams.length; k++) {
boolean auth =
AuthorizeManager.authorizeActionBoolean(context, bitstreams[k], Constants.READ);
if (auth || (unauth != null && unauth.equalsIgnoreCase("zero"))) {
ZipEntry ze = new ZipEntry(makeBitstreamName(bitstreams[k]));
ze.setTime(lmTime);
ze.setSize(auth ? bitstreams[k].getSize() : 0);
zip.putNextEntry(ze);
if (auth) Utils.copy(bitstreams[k].retrieve(), zip);
else
log.warn(
"Adding zero-length file for Bitstream, SID="
+ String.valueOf(bitstreams[k].getSequenceID())
+ ", not authorized for READ.");
zip.closeEntry();
} else if (unauth != null && unauth.equalsIgnoreCase("skip")) {
log.warn(
"Skipping Bitstream, SID="
+ String.valueOf(bitstreams[k].getSequenceID())
+ ", not authorized for READ.");
} else {
throw new AuthorizeException(
"Not authorized to read Bitstream, SID="
+ String.valueOf(bitstreams[k].getSequenceID()));
}
}
}
}
zip.close();
extraFiles = null;
}
} else throw new PackageValidationException("Can only disseminate an Item now.");
}
private ZipEntry entryFor(final String name, final FileContent content)
throws FileSystemException {
final ZipEntry entry = new ZipEntry(name);
entry.setTime(content.getLastModifiedTime());
return entry;
}
