/* Copyright (C) 2003 Vladimir Roubtsov. All rights reserved.
*
* This program and the accompanying materials are made available under
* the terms of the Common Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/cpl-v10.html
*
* $Id: IPathEnumerator.java,v 1.1.1.1.2.1 2004/07/16 23:32:04 vlad_r Exp $
*/
package com.vladium.util;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.jar.Attributes;
import java.util.jar.JarFile;
import java.util.jar.JarInputStream;
import java.util.jar.Manifest;
import java.util.zip.ZipEntry;
import com.vladium.logging.Logger;
import com.vladium.util.asserts.$assert;
// ----------------------------------------------------------------------------
/**
* @author Vlad Roubtsov, (C) 2003
*/
public
interface IPathEnumerator
{
// public: ................................................................
// TODO: archives inside archives? (.war ?)
public static interface IPathHandler
{
void handleDirStart (File pathDir, File dir); // not generated for path dirs themselves
void handleFile (File pathDir, File file);
void handleDirEnd (File pathDir, File dir);
/**
* Called just after the enumerator's zip input stream for this archive
* is opened and the manifest entry is read.
*/
void handleArchiveStart (File parentDir, File archive, Manifest manifest);
void handleArchiveEntry (JarInputStream in, ZipEntry entry);
/**
* Called after the enumerator's zip input stream for this archive
* has been closed.
*/
void handleArchiveEnd (File parentDir, File archive);
} // end of nested interface
void enumerate () throws IOException;
public static abstract class Factory
{
public static IPathEnumerator create (final File [] path, final boolean canonical, final IPathHandler handler)
{
return new PathEnumerator (path, canonical, handler);
}
private static final class PathEnumerator implements IPathEnumerator
{
public void enumerate () throws IOException
{
final IPathHandler handler = m_handler;
for (m_pathIndex = 0; m_pathIndex < m_path.size (); ++ m_pathIndex) // important not to cache m_path.size()
{
final File f = (File) m_path.get (m_pathIndex);
if (! f.exists ())
{
if (IGNORE_INVALID_ENTRIES)
continue;
else
throw new IllegalArgumentException ("path entry does not exist: [" + f + "]");
}
if (f.isDirectory ())
{
if (m_verbose) m_log.verbose ("processing dir path entry [" + f.getAbsolutePath () + "] ...");
m_currentPathDir = f;
enumeratePathDir (null);
}
else
{
final String name = f.getName ();
final String lcName = name.toLowerCase ();
if (lcName.endsWith (".zip") || lcName.endsWith (".jar"))
{
if (m_verbose) m_log.verbose ("processing archive path entry [" + f.getAbsolutePath () + "] ...");
final File parent = f.getParentFile (); // could be null
final File archive = new File (name);
m_currentPathDir = parent;
// move to enumeratePathArchive(): handler.handleArchiveStart (parent, archive);
enumeratePathArchive (name);
handler.handleArchiveEnd (parent, archive); // note: it is important that this is called after the zip stream has been closed
}
else if (! IGNORE_INVALID_ENTRIES)
{
throw new IllegalArgumentException ("path entry is not a directory or an archive: [" + f + "]");
}
}
}
}
PathEnumerator (final File [] path, final boolean canonical, final IPathHandler handler)
{
m_path = new ArrayList (path.length);
for (int p = 0; p < path.length; ++ p) m_path.add (path [p]);
m_canonical = canonical;
if (handler == null) throw new IllegalArgumentException ("null input: handler");
m_handler = handler;
m_processManifest = true; // TODO
if (m_processManifest)
{
m_pathSet = new HashSet (path.length);
for (int p = 0; p < path.length; ++ p)
{
m_pathSet.add (path [p].getPath ()); // set of [possibly canonical] paths
}
}
else
{
m_pathSet = null;
}
m_log = Logger.getLogger (); // each path enumerator caches its logger at creation time
m_verbose = m_log.atVERBOSE ();
m_trace1 = m_log.atTRACE1 ();
}
private void enumeratePathDir (final String dir)
throws IOException
{
final boolean trace1 = m_trace1;
final File currentPathDir = m_currentPathDir;
final File fullDir = dir != null ? new File (currentPathDir, dir) : currentPathDir;
final String [] children = fullDir.list ();
final IPathHandler handler = m_handler;
for (int c = 0, cLimit = children.length; c < cLimit; ++ c)
{
final String childName = children [c];
final File child = dir != null ? new File (dir, childName) : new File (childName);
final File fullChild = new File (fullDir, childName);
if (fullChild.isDirectory ())
{
handler.handleDirStart (currentPathDir, child);
if (trace1) m_log.trace1 ("enumeratePathDir", "recursing into [" + child.getName () + "] ...");
enumeratePathDir (child.getPath ());
handler.handleDirEnd (currentPathDir, child);
}
else
{
// final String lcName = childName.toLowerCase ();
//
// if (lcName.endsWith (".zip") || lcName.endsWith (".jar"))
// {
// handler.handleArchiveStart (currentPathDir, child);
// enumeratePathArchive (child.getPath ());
// handler.handleArchiveEnd (currentPathDir, child);
// }
// else
{
if (trace1) m_log.trace1 ("enumeratePathDir", "processing file [" + child.getName () + "] ...");
handler.handleFile (currentPathDir, child);
}
}
}
}
private void enumeratePathArchive (final String archive)
throws IOException
{
final boolean trace1 = m_trace1;
final File fullArchive = new File (m_currentPathDir, archive);
JarInputStream in = null;
try
{
// note: Sun's JarFile uses native code and has been known to
// crash the JVM in some builds; however, it uses random file
// access and can find "bad" manifests that are not the first
// entries in their archives (which JarInputStream can't do);
// [bugs: 4263225, 4696354, 4338238]
//
// there is really no good solution here but as a compromise
// I try to read the manifest again via a JarFile if the stream
// returns null for it:
in = new JarInputStream (new BufferedInputStream (new FileInputStream (fullArchive), 32 * 1024));
final IPathHandler handler = m_handler;
Manifest manifest = in.getManifest (); // can be null
if (manifest == null) manifest = readManifestViaJarFile (fullArchive); // can be null
handler.handleArchiveStart (m_currentPathDir, new File (archive), manifest);
// note: this loop does not skip over the manifest-related
// entries [the handler needs to be smart about that]
for (ZipEntry entry; (entry = in.getNextEntry ()) != null; )
{
// TODO: handle nested archives
if (trace1) m_log.trace1 ("enumeratePathArchive", "processing archive entry [" + entry.getName () + "] ...");
handler.handleArchiveEntry (in, entry);
in.closeEntry ();
}
// TODO: this needs major testing
if (m_processManifest)
{
// note: JarInputStream only reads the manifest if it the
// first jar entry
if (manifest == null) manifest = in.getManifest ();
if (manifest != null)
{
final Attributes attributes = manifest.getMainAttributes ();
if (attributes != null)
{
// note: Sun's documentation says that multiple Class-Path:
// entries are merged sequentially (http://java.sun.com/products/jdk/1.2/docs/guide/extensions/spec.html)
// however, their own code does not implement this
final String jarClassPath = attributes.getValue (Attributes.Name.CLASS_PATH);
if (jarClassPath != null)
{
final StringTokenizer tokenizer = new StringTokenizer (jarClassPath);
for (int p = 1; tokenizer.hasMoreTokens (); )
{
final String relPath = tokenizer.nextToken ();
final File archiveParent = fullArchive.getParentFile ();
final File path = archiveParent != null ? new File (archiveParent, relPath) : new File (relPath);
final String fullPath = m_canonical ? Files.canonicalizePathname (path.getPath ()) : path.getPath ();
if (m_pathSet.add (fullPath))
{
if (m_verbose) m_log.verbose (" added manifest Class-Path entry [" + path + "]");
m_path.add (m_pathIndex + (p ++), path); // insert after the current m_path entry
}
}
}
}
}
}
}
catch (FileNotFoundException fnfe) // ignore: this should not happen
{
if ($assert.ENABLED) throw fnfe;
}
finally
{
if (in != null) try { in.close (); } catch (Exception ignore) {}
}
}
// see comments at the start of enumeratePathArchive()
private static Manifest readManifestViaJarFile (final File archive)
{
Manifest result = null;
JarFile jarfile = null;
try
{
jarfile = new JarFile (archive, false); // 3-arg constructor is not in J2SE 1.2
result = jarfile.getManifest ();
}
catch (IOException ignore)
{
}
finally
{
if (jarfile != null) try { jarfile.close (); } catch (IOException ignore) {}
}
return result;
}
private final ArrayList /* File */ m_path;
private final boolean m_canonical;
private final Set /* String */ m_pathSet;
private final IPathHandler m_handler;
private final boolean m_processManifest;
private final Logger m_log;
private boolean m_verbose, m_trace1;
private int m_pathIndex;
private File m_currentPathDir;
// if 'true', non-existent or non-archive or non-directory path entries
// will be silently ignored:
private static final boolean IGNORE_INVALID_ENTRIES = true; // this is consistent with the normal JVM behavior
} // end of nested class
} // end of nested class
} // end of interface
// ---------------------------------------------------------------------------- |
