expandingarchiveclasspathentry.java

jsr170接口的java实现。是个apache的开源项目。

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * 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.classloader;

import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;
import java.util.Calendar;
import java.util.StringTokenizer;
import java.util.jar.Manifest;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;

import javax.jcr.Item;
import javax.jcr.Node;
import javax.jcr.Property;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import javax.jcr.Workspace;
import javax.jcr.nodetype.NoSuchNodeTypeException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * The <code>ExpandingArchiveClassPathEntry</code> extends the
 * {@link org.apache.jackrabbit.classloader.ArchiveClassPathEntry} class with support
 * to automatically expand the archive (JAR or ZIP) into the repository
 * below the path entry node. The path used to construct the instance is the
 * path of an item resolving to a property containing the jar archive to access.
 *
 * @author Felix Meschberger
 *
 * @see org.apache.jackrabbit.classloader.ArchiveClassPathEntry
 * @see org.apache.jackrabbit.classloader.ClassPathEntry
 */
/* package */ class ExpandingArchiveClassPathEntry extends ArchiveClassPathEntry {

    /** The name of the node type required to expand the archive */
    public static final String TYPE_JARFILE = "rep:jarFile";

    /** The name of the child node taking the expanded archive */
    public static final String NODE_JARCONTENTS = "rep:jarContents";

    /**
     * The name of the property taking the time at which the archive was
     * expanded
     */
    public static final String PROP_EXPAND_DATE = "rep:jarExpanded";

    /** Default logger */
    private static final Logger log =
        LoggerFactory.getLogger(ExpandingArchiveClassPathEntry.class);

    /** The node of the unpacked JAR contents */
    private Node jarContents;

    /**
     * Creates an instance of the <code>ExpandingArchiveClassPathEntry</code>
     * class.
     *
     * @param prop The <code>Property</code> containing the archive and
     *      the session used to access the repository.
     * @param path The original class path entry leading to the creation of
     *      this instance. This is not necessairily the same path as the
     *      property's path if the property was found through the primary
     *      item chain.
     *
     * @throws RepositoryException If an error occurrs retrieving the session
     *      from the property.
     */
    ExpandingArchiveClassPathEntry(Property prop, String path)
            throws RepositoryException {
        super(prop, path);
    }

    /**
     * Clones the indicated <code>ExpandingArchiveClassPathEntry</code> object
     * by taking over its path, session and property.
     *
     * @param base The base <code>ExpandingArchiveClassPathEntry</code> entry
     *      to clone.
     *
     * @see ClassPathEntry#ClassPathEntry(ClassPathEntry)
     */
    private ExpandingArchiveClassPathEntry(ExpandingArchiveClassPathEntry base) {
        super(base);
    }

    /**
     * Returns a {@link ClassLoaderResource} for the named resource if it
     * can be found in the archive identified by the path given at
     * construction time. Note that if the archive property would exist but is
     * not readable by the current session, no resource is returned.
     *
     * @param name The name of the resource to return. If the resource would
     *      be a class the name must already be modified to denote a valid
     *      path, that is dots replaced by slashes and the <code>.class</code>
     *      extension attached.
     *
     * @return The {@link ClassLoaderResource} identified by the name or
     *      <code>null</code> if no resource is found for that name.
     */
    public ClassLoaderResource getResource(final String name) {

        try {
            // find the resource for the name in the expanded archive contents
            Node jarContents = getJarContents();
            Item resItem = null;
            if (jarContents.hasNode(name)) {
                resItem = jarContents.getNode(name);
            } else if (jarContents.hasProperty(name)) {
                resItem = jarContents.getProperty(name);
            }

            // if the name resolved to an item, resolve the item to a
            // single-valued non-reference property
            Property resProp = (resItem != null)
                    ? Util.getProperty(resItem)
                    : null;

            // if found create the resource to return
            if (resProp != null) {
                return new ClassLoaderResource(this, name, resProp) {
                    public URL getURL() {
                        return ExpandingArchiveClassPathEntry.this.getURL(getName());
                    }

                    public URL getCodeSourceURL() {
                        return ExpandingArchiveClassPathEntry.this.getCodeSourceURL();
                    }

                    public Manifest getManifest() {
                        return ExpandingArchiveClassPathEntry.this.getManifest();
                    }

                    protected Property getExpiryProperty() {
                        return ExpandingArchiveClassPathEntry.this.getProperty();
                    }
                };
            }

            log.debug("getResource: resource {} not found in archive {}", name,
                path);

        } catch (RepositoryException re) {

            log.warn("getResource: problem accessing the archive {} for {}",
                new Object[] { path, name }, re.toString());

        }
        // invariant : not found or problem accessing the archive

        return null;
    }

    /**
     * Returns a <code>ClassPathEntry</code> with the same configuration as
     * this <code>ClassPathEntry</code>.
     * <p>
     * The <code>ExpandingArchiveClassPathEntry</code> class has internal state.
     * Therefore a new instance is created from the unmodifiable configuration
     * of this instance.
     */
    ClassPathEntry copy() {
        return new ExpandingArchiveClassPathEntry(this);
    }

    //----------- internal helper to find the entry ------------------------

    /**
     * Returns the root node of the expanded archive. If the archive's node
     * does not contain the expanded archive, it is expanded on demand. If the
     * archive has already been expanded, it is checked whether it is up to
     * date and expanded again if not.
     *
     * @throws RepositoryException if an error occurrs expanding the archive
     *      into the repository.
     */
    private Node getJarContents() throws RepositoryException {
        if (jarContents == null) {
            Node jarNode = null; // the node containing the jar file
            Node jarRoot = null; // the root node of the expanded contents
            try {
                Item jarItem = session.getItem(getPath());
                jarNode = (jarItem.isNode()) ? (Node) jarItem : jarItem.getParent();

                // if the jar been unpacked once, check for updated jar file,
                // which must be unpacked
                if (jarNode.isNodeType(TYPE_JARFILE)) {
                    long lastMod = Util.getLastModificationTime(getProperty());
                    long expanded =
                        jarNode.getProperty(PROP_EXPAND_DATE).getLong();

                    // get the content, remove if outdated or use if ok
                    jarRoot = jarNode.getNode(NODE_JARCONTENTS);

                    // if expanded content is outdated, remove it
                    if (lastMod <= expanded) {
                        jarRoot.remove();
                        jarRoot = null; // have to unpack below
                    }

                } else if (!jarNode.canAddMixin(TYPE_JARFILE)) {
                    // this is actually a problem, because I expect to be able
                    // to add the mixin node type due to checkExpandArchives
                    // having returned true earlier
                    throw new RepositoryException(
                        "Cannot unpack JAR file contents into "
                            + jarNode.getPath());

                } else {
                    jarNode.addMixin(TYPE_JARFILE);
                    jarNode.setProperty(PROP_EXPAND_DATE, Calendar.getInstance());