| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. The ASF licenses this file to You |
| * under the Apache License, Version 2.0 (the "License"); you may not |
| * use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package org.apache.jackrabbit.net; |
| |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.net.URL; |
| import java.util.jar.JarEntry; |
| import java.util.jar.JarInputStream; |
| |
| import javax.jcr.Property; |
| import javax.jcr.RepositoryException; |
| |
| import org.apache.commons.logging.Log; |
| import org.apache.commons.logging.LogFactory; |
| |
| /** |
| * The <code>JCRJarURLConnection</code> extends the |
| * {@link org.apache.jackrabbit.net.JCRURLConnection} class to support accessing |
| * archive files stored in a JCR Repository. |
| * <p> |
| * Just like the base class, this class requires the URL to resolve, either |
| * directly or through primary item chain, to a repository <code>Property</code>. |
| * <p> |
| * Access to this connections property and archive entry content is perpared |
| * with the {@link #connect()}, which after calling the base class implementation |
| * to find the property tries to find the archive entry and set the connection's |
| * fields according to the entry. This implementation's {@link #connect()} |
| * method fails if the named entry does not exist in the archive. |
| * <p> |
| * The {@link #getInputStream()} method either returns an stream on the archive |
| * entry or on the archive depending on whether an entry path is specified |
| * in the URL or not. Like the base class implementation, this implementation |
| * returns a new <code>InputStream</code> on each invocation. |
| * <p> |
| * If an entry path is defined on the URL, the header fields are set from the |
| * archive entry: |
| * <table border="0" cellspacing="0" cellpadding="3"> |
| * <tr><td><code>Content-Type</code><td>Guessed from the entry name or |
| * <code>application/octet-stream</code> if the type cannot be guessed |
| * from the name</tr> |
| * <tr><td><code>Content-Encoding</code><td><code>null</code></tr> |
| * <tr><td><code>Content-Length</code><td>The size of the entry</tr> |
| * <tr><td><code>Last-Modified</code><td>The last modification time of the |
| * entry</tr> |
| * </table> |
| * <p> |
| * If no entry path is defined on the URL, the header fields are set from the |
| * property by the base class implementation with the exception of the |
| * content type, which is set to <code>application/java-archive</code> by |
| * the {@link #connect()} method. |
| * <p> |
| * <em>Note that this implementation does only support archives stored in the |
| * JCR Repository, no other contained storage such as </em>file<em> or |
| * </em>http<em> is supported.</em> |
| * <p> |
| * This class is not intended to be subclassed or instantiated by clients. |
| * |
| * @author Felix Meschberger |
| */ |
| public class JCRJarURLConnection extends JCRURLConnection { |
| |
| /** default log category */ |
| private static final Log log = LogFactory.getLog(JCRJarURLConnection.class); |
| |
| /** |
| * The name of the MIME content type for this connection's content if |
| * no entry path is defined on the URL (value is "application/java-archive"). |
| */ |
| protected static final String APPLICATION_JAR = "application/java-archive"; |
| |
| /** |
| * Creates an instance of this class for the given <code>url</code> |
| * supported by the <code>handler</code>. |
| * |
| * @param url The URL to base the connection on. |
| * @param handler The URL handler supporting the given URL. |
| */ |
| JCRJarURLConnection(URL url, JCRJarURLHandler handler) { |
| super(url, handler); |
| } |
| |
| /** |
| * Returns the path to the entry contained in the archive or |
| * <code>null</code> if the URL contains no entry specification in the |
| * path. |
| */ |
| String getEntryPath() { |
| return getFileParts().getEntryPath(); |
| } |
| |
| /** |
| * Connects to the URL setting the header fields and preparing for the |
| * {@link #getProperty()} and {@link #getInputStream()} methods. |
| * <p> |
| * After calling the base class implemenation to get the basic connection, |
| * the entry is looked for in the archive to set the content type, content |
| * length and last modification time header fields according to the named |
| * entry. If no entry is defined on the URL, only the content type header |
| * field is set to <code>application/java-archive</code>. |
| * <p> |
| * When this method successfully returns, this connection is considered |
| * connected. In case of an exception thrown, the connection is not |
| * connected. |
| * |
| * @throws IOException if an error occurrs retrieving the data property or |
| * any of the header field value properties or if any other errors |
| * occurrs. Any cuasing exception is set as the cause of this |
| * exception. |
| */ |
| public synchronized void connect() throws IOException { |
| |
| if (!connected) { |
| |
| // have the base class connect to get the jar property |
| super.connect(); |
| |
| // we assume the connection is now (temporarily) connected, |
| // thus calling the getters will not result in a recursive loop |
| Property property = getProperty(); |
| String contentType = getContentType(); |
| String contentEncoding = getContentEncoding(); |
| int contentLength = getContentLength(); |
| long lastModified = getLastModified(); |
| |
| // mark as not connected to not get false positives if the |
| // following code fails |
| connected = false; |
| |
| // Get hold of the data |
| try { |
| |
| JarInputStream jins = null; |
| try { |
| |
| // try to get the jar input stream, fail if no jar |
| jins = new JarInputStream(property.getStream()); |
| |
| String entryPath = getEntryPath(); |
| if (entryPath != null) { |
| |
| JarEntry entry = findEntry(jins, entryPath); |
| |
| if (entry != null) { |
| |
| contentType = guessContentTypeFromName(entryPath); |
| if (contentType == null) { |
| contentType = APPLICATION_OCTET; |
| } |
| |
| contentLength = (int) entry.getSize(); |
| lastModified = entry.getTime(); |
| |
| } else { |
| |
| throw failure("connect", entryPath + |
| " not contained in jar archive", null); |
| |
| } |
| |
| } else { |
| |
| // replaces the base class defined content type |
| contentType = APPLICATION_JAR; |
| |
| } |
| |
| } finally { |
| if (jins != null) { |
| try { |
| jins.close(); |
| } catch (IOException ignore) { |
| } |
| } |
| } |
| |
| log.debug("connect: Using atom '" + property.getPath() |
| + "' with content type '" + contentType + "' for " |
| + String.valueOf(contentLength) + " bytes"); |
| |
| // set the fields |
| setContentType(contentType); |
| setContentEncoding(contentEncoding); |
| setContentLength(contentLength); |
| setLastModified(lastModified); |
| |
| // mark connection open |
| connected = true; |
| |
| } catch (RepositoryException re) { |
| |
| throw failure("connect", re.toString(), re); |
| |
| } |
| } |
| } |
| |
| /** |
| * Returns an input stream that reads from this open connection. If not |
| * entry path is specified in the URL, this method returns the input stream |
| * providing access to the archive as a whole. Otherwise the input stream |
| * returned is a <code>JarInputStream</code> positioned at the start of |
| * the named entry. |
| * <p> |
| * <b>NOTES:</b> |
| * <ul> |
| * <li>Each call to this method returns a new <code>InputStream</code>. |
| * <li>Do not forget to close the return stream when not used anymore for |
| * the system to be able to free resources. |
| * </ul> |
| * <p> |
| * Calling this method implicitly calls {@link #connect()} to ensure the |
| * connection is open. |
| * |
| * @return The <code>InputStream</code> on the archive or the entry if |
| * specified. |
| * |
| * @throws IOException if an error occurrs opening the connection through |
| * {@link #connect()} or creating the <code>InputStream</code> on the |
| * repository <code>Property</code>. |
| */ |
| public InputStream getInputStream() throws IOException { |
| |
| // get the input stream on the archive itself - also enforces connect() |
| InputStream ins = super.getInputStream(); |
| |
| // access the entry in the archive if defined |
| String entryPath = getEntryPath(); |
| if (entryPath != null) { |
| // open the jar input stream |
| JarInputStream jins = new JarInputStream(ins); |
| |
| // position at the correct entry |
| findEntry(jins, entryPath); |
| |
| // return the input stream |
| return jins; |
| } |
| |
| // otherwise just return the stream on the archive |
| return ins; |
| } |
| |
| //----------- internal helper to find the entry ------------------------ |
| |
| /** |
| * Returns the <code>JarEntry</code> for the path from the |
| * <code>JarInputStream</code> or <code>null</code> if the path cannot |
| * be found in the archive. |
| * |
| * @param zins The <code>JarInputStream</code> to search in. |
| * @param path The path of the <code>JarEntry</code> to return. |
| * |
| * @return The <code>JarEntry</code> for the path or <code>null</code> |
| * if no such entry can be found. |
| * |
| * @throws IOException if a problem occurrs reading from the stream. |
| */ |
| static JarEntry findEntry(JarInputStream zins, String path) |
| throws IOException { |
| |
| JarEntry entry = zins.getNextJarEntry(); |
| while (entry != null) { |
| if (path.equals(entry.getName())) { |
| return entry; |
| } |
| |
| entry = zins.getNextJarEntry(); |
| } |
| // invariant : nothing found in the zip matching the path |
| |
| return null; |
| } |
| } |
