/*******************************************************************************
* Copyright (c) 2001, 2010 IBM Corporation, Red Hat, and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.jst.common.internal.modulecore.util;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.zip.ZipEntry;
import java.util.zip.ZipException;
import java.util.zip.ZipFile;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.jem.util.emf.workbench.WorkbenchByteArrayOutputStream;
import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
import org.eclipse.wst.common.componentcore.resources.IVirtualFile;
import com.ibm.icu.util.StringTokenizer;
public class ManifestUtilities {
public static final String MANIFEST_HEADER = "Manifest-Version: 1.0\r\nClass-Path: \r\n\r\n"; //$NON-NLS-1$
public static void createManifestFile(IFile file) throws CoreException, IOException {
try {
WorkbenchByteArrayOutputStream out = new WorkbenchByteArrayOutputStream(file);
out.write(MANIFEST_HEADER.getBytes());
out.close();
} catch (IOException ioe) {
throw ioe;
}
}
public static String[] getTokens(String aString) {
return getTokens(aString, null);
}
public static String[] getTokens(String aString, String delimiter) {
StringTokenizer tok = (delimiter == null) ? new StringTokenizer(aString) : new StringTokenizer(aString, delimiter);
int size = tok.countTokens();
String[] tokens = new String[size];
for (int i = 0; i < size && tok.hasMoreTokens(); i++) {
tokens[i] = tok.nextToken();
}
return tokens;
}
/**
* getValueIgnoreKeyCase method comment.
*/
public static java.lang.String getValueIgnoreKeyCase(java.lang.String key, java.util.jar.Attributes attr) {
Iterator keysAndValues = attr.entrySet().iterator();
while (keysAndValues.hasNext()) {
Map.Entry entry = (Map.Entry) keysAndValues.next();
String entryKey = entry.getKey().toString();
if (entryKey.equalsIgnoreCase(key))
return entry.getValue() == null ? null : entry.getValue().toString();
}
return null;
}
public static ArchiveManifest getManifest(IVirtualComponent component, IPath manifestPath) {
if( !component.isBinary() )
return getNonBinaryComponentManifest(component, manifestPath);
return getBinaryComponentManifest(component, manifestPath);
}
public static ArchiveManifest getBinaryComponentManifest(IVirtualComponent component, IPath manifestPath) {
java.io.File file = (File)component.getAdapter(File.class);
if( file != null && file.exists()) {
ArchiveManifest manifest = readBinaryManifest(file, manifestPath);
return manifest;
}
return null;
}
public static ArchiveManifest getManifest(IFile f) {
File f2 = f.getLocation().toFile();
return getManifest(f2);
}
public static ArchiveManifest getManifest(File f) {
if( f != null && f.exists()) {
InputStream in;
try {
in = new FileInputStream(f);
ArchiveManifest manifest = new ArchiveManifestImpl(in);
return manifest;
} catch (FileNotFoundException e) {
} catch (IOException e) {
}
}
return null;
}
public static void writeManifest(IFile aFile, ArchiveManifest manifest) throws java.io.IOException {
OutputStream out = new WorkbenchByteArrayOutputStream(aFile);
manifest.writeSplittingClasspath(out);
out.close();
}
public static ArchiveManifest getNonBinaryComponentManifest(IVirtualComponent component, IPath manifestPath) {
try {
if(!component.isBinary()){
IVirtualFile vManifest = component.getRootFolder().getFile(manifestPath);
if (vManifest.exists()) {
IFile manifestFile = vManifest.getUnderlyingFile();
InputStream in = null;
try {
in = manifestFile.getContents();
ArchiveManifest manifest = new ArchiveManifestImpl(in);
return manifest;
} finally {
if (in != null) {
in.close();
in = null;
}
}
}
}
} catch( IOException ioe ) {
} catch(CoreException ce) {
}
return null;
}
public static String[] getManifestClasspath(IVirtualComponent component, IPath manifestPath) {
ArchiveManifest mf = getManifest(component, manifestPath);
if( mf != null )
return mf.getClassPathTokenized();
return new String[]{};
}
public static ArchiveManifest readBinaryManifest(File file, IPath manifestPath) {
ArchiveManifest manifest = null;
ZipFile zipFile = null;
if( file != null ) {
try {
zipFile = ManifestUtilities.newZipFile(file);
ZipEntry entry = zipFile.getEntry(manifestPath.toString());
if( entry != null ) {
InputStream entryStream = getInputstreamForZipEntry(zipFile, manifestPath.toString());
manifest = new ArchiveManifestImpl(entryStream);
zipFile.close();
}
} catch( IOException ioe) {
if( zipFile != null ) {
try {
zipFile.close();
} catch( IOException ioe2) {}
}
}
}
return manifest;
}
public static InputStream getInputstreamForZipEntry(ZipFile zipFile, String uri) throws IOException {
try {
ZipEntry entry = zipFile.getEntry(uri);
if (entry == null) {
// this is a hack, but zip files are sensitive to the difference
// between '/' and '\\'
// so the hack is to try all combinations to see if any exist
char[] chars = uri.toCharArray();
int[] slashIndices = new int[chars.length];
int slashCount = 0;
for (int i = 0; i < uri.length(); i++) {
if (chars[i] == '/' || chars[i] == '\\') {
slashIndices[slashCount] = i;
slashCount++;
}
}
int slashPow = (int) Math.pow(2, slashCount);
boolean foundIt = false;
for (int i = 0; i < slashPow && !foundIt; i++) {
for (int j = 0; j < slashCount; j++) {
if ((i >> j & 1) == 1) {
chars[slashIndices[j]] = '/';
} else {
chars[slashIndices[j]] = '\\';
}
}
entry = zipFile.getEntry(new String(chars));
if (entry != null) {
foundIt = true;
}
}
if (entry == null) {
Exception del = new FileNotFoundException(uri);
throw new IOException(del.toString());
}
}
return new java.io.BufferedInputStream(zipFile.getInputStream(entry));
} catch (IllegalStateException zipClosed) {
throw new IOException(zipClosed.toString());
}
}
public static String[] getNonBinaryComponentManifestClasspath(IVirtualComponent component, IPath manifestPath)
throws IOException, CoreException {
String[] manifestClasspath = null;
if(!component.isBinary()){
IVirtualFile vManifest = component.getRootFolder().getFile(manifestPath);
if (vManifest.exists()) {
IFile manifestFile = vManifest.getUnderlyingFile();
InputStream in = null;
try {
in = manifestFile.getContents();
ArchiveManifest manifest = new ArchiveManifestImpl(in);
manifestClasspath = manifest.getClassPathTokenized();
} finally {
if (in != null) {
in.close();
in = null;
}
}
}
}
return manifestClasspath;
}
public static ZipFile newZipFile(String fileName)throws ZipException, IOException {
return ManifestUtilities.newZipFile(new File(fileName), ZipFile.OPEN_READ);
}
public static ZipFile newZipFile(File aFile)throws ZipException, IOException {
return ManifestUtilities.newZipFile(aFile, ZipFile.OPEN_READ);
}
/**
* Utility to create ZipFiles which avoid memory leaks
* because closing them fails to close open inputstreams.
* There is a SUN bug open for this: http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6735255
* but it looks like the "fix" will be to change the Javadoc :-(
* @param aFile mode
* @return
* @throws ZipException
* @throws IOException
*/
public static ZipFile newZipFile(File aFile, int mode) throws ZipException, IOException {
return new ZipFile(aFile, mode){
Collection <InputStream> openStreams = null;
@Override
public InputStream getInputStream(ZipEntry entry) throws IOException {
InputStream in = super.getInputStream(entry);
if(in != null){
if(openStreams == null){
openStreams = new ArrayList<InputStream>();
}
openStreams.add(in);
}
return in;
}
@Override
public void close() throws IOException {
closeOpenStreams();
super.close();
}
private void closeOpenStreams() {
if(openStreams != null){
for (Iterator iterator = openStreams.iterator(); iterator.hasNext();) {
InputStream in = (InputStream) iterator.next();
try {
in.close();
} catch (IOException e) {
org.eclipse.jem.util.logger.proxy.Logger.getLogger().logWarning(e);
}
iterator.remove();
}
}
}
};
}
public static ArchiveManifest readManifest(IFile aFile) {
InputStream in = null;
try {
if (aFile == null || !aFile.exists())
return null;
in = aFile.getContents();
return new ArchiveManifestImpl(in);
} catch (Exception ex) {
// TODO J2EEPlugin.logError(ex);
return null;
} finally {
if (in != null) {
try {
in.close();
} catch (IOException weTried) {
}
}
}
}
private static ConcurrentHashMap<String, String> manifestClasspaths = new ConcurrentHashMap<String, String>();
/**
* Generates new MANIFEST.MF with a dynamically updated classpath that is written to the specified
* output stream.
* @param manifestFile The current MANIFEST.MF file.
* @param dynamicURIs Is List of URIs to dynamically add to the manifest classpath.
* @param outputStream Stream to which the modified entry should be written.
* @throws IOException
* @throws FileNotFoundException
*/
public static void updateManifestClasspath(final IFile manifestFile, final List dynamicURIs, final OutputStream outputStream) throws IOException, FileNotFoundException {
updateManifestClasspathImpl(manifestFile, dynamicURIs, null, outputStream);
}
/**
* Generates new MANIFEST.MF with a dynamically updated classpath that is written to the specified
* output stream.
* @param manifestFile The current MANIFEST.MF file.
* @param dynamicURIs Is List of URIs to dynamically add to the manifest classpath.
* @param outputFile File to which the modified entry should be written.
* @throws IOException
* @throws FileNotFoundException
*/
public static void updateManifestClasspath(final IFile manifestFile, final List dynamicURIs, final File outputFile) throws IOException, FileNotFoundException {
updateManifestClasspathImpl(manifestFile, dynamicURIs, outputFile, null);
}
/**
* Generates new MANIFEST.MF with a dynamically updated classpath that is written to the specified
* file or output stream, with the stream taking precedence.
* @param manifestFile The current MANIFEST.MF file.
* @param dynamicURIs Is List of URIs to dynamically add to the manifest classpath.
* @param outputFile File to which the modified entry should be written.
* @param OutputStream stream Stream to which the modified entry should be written. If not null,
* the stream will be written and the outputFile ignored.
* @throws IOException
* @throws FileNotFoundException
*/
private static void updateManifestClasspathImpl(final IFile manifestFile, final List dynamicURIs, final File outputFile, final OutputStream stream) throws IOException, FileNotFoundException {
OutputStream outputStream = stream;
try {
InputStream in = null;
ArchiveManifest manifest = null;
try {
in = manifestFile.getContents();
manifest = new ArchiveManifestImpl(in);
} catch (CoreException ce) {
throw new IOException(ce.getLocalizedMessage());
} finally {
if (in != null) {
try {
in.close();
in = null;
} catch (IOException e) {
org.eclipse.jem.util.logger.proxy.Logger.getLogger().logWarning(e);
}
}
}
final String[] manifestClasspath = manifest.getClassPathTokenized();
final List updatedCP = new ArrayList();
for (int i = 0; i < manifestClasspath.length; i++) {
updatedCP.add(manifestClasspath[i]);
}
// update manifest classpath to include dynamic entries
for (int j = 0; j < dynamicURIs.size(); j++) {
final String containerURI = (String) dynamicURIs.get(j);
// need to check existing entries to ensure it doesn't are exist on the classpath
boolean exists = false;
for (int i = 0; i < manifestClasspath.length; i++) {
if (manifestClasspath[i].equals(containerURI)) {
exists = true;
break;
}
}
if (!exists) {
updatedCP.add(containerURI);
}
}
final StringBuffer cpBuffer = new StringBuffer();
boolean first = true;
for (int j = 0; j < updatedCP.size(); j++) {
if (!first) {
cpBuffer.append(" "); //$NON-NLS-1$
} else {
first = false;
}
cpBuffer.append((String) updatedCP.get(j));
}
String cp = cpBuffer.toString();
// If we have an output stream, always write to the stream
if (outputStream != null) {
manifest.setClassPath(cp);
manifest.write(outputStream);
outputStream.flush();
}
// Else, without an output stream, conditionally update the specified file
else {
// To avoid making the internally generated manifest file appear to projects
// as a perpetually modified resource, check if the file needs to change.
// This checking helps with the usefulness of "delta" deployment with
// utility projects.
String manifestPath = manifestFile.getFullPath().toString();
String priorClasspath = manifestClasspaths.get(manifestPath);
if (priorClasspath == null || !priorClasspath.equals(cp) || !outputFile.exists()) {
manifestClasspaths.put(manifestPath, cp);
manifest.setClassPath(cp);
outputStream = new FileOutputStream(outputFile);
manifest.write(outputStream);
outputStream.flush();
}
}
} finally {
if (outputStream != null) {
outputStream.close();
}
}
}
}