}                // if the content root is not set, unpack and save                if (jarRoot == null) {                    jarRoot = jarNode.addNode(NODE_JARCONTENTS, "nt:folder");                    unpack(jarRoot);                    jarNode.save();                }            } finally {                // rollback changes on the jar node in case of problems                if (jarNode != null && jarNode.isModified()) {                    // rollback incomplete modifications                    log.warn("Rolling back unsaved changes on JAR node {}",                        getPath());                    try {                        jarNode.refresh(false);                    } catch (RepositoryException re) {                        log.warn("Cannot rollback changes after failure to " +                                "expand " + getPath(), re);                    }                }            }            jarContents = jarRoot;        }        return jarContents;    }    /**     * Expands the archive stored in the property of this class path entry into     * the repositroy below the given <code>jarRoot</code> node.     * <p>     * This method leaves the subtree at and below <code>jarRoot</code> unsaved.     * It is the task of the caller to save or rollback as appropriate.     *     * @param jarRoot The <code>Node</code> below which the archive is to be     *      unpacked.     *     * @throws RepositoryException If an error occurrs creating the item     *      structure to unpack the archive or if an error occurrs reading     *      the archive.     */    private void unpack(Node jarRoot) throws RepositoryException {        ZipInputStream zin = null;        try {            zin = new ZipInputStream(getProperty().getStream());            ZipEntry entry = zin.getNextEntry();            while (entry != null) {                if (entry.isDirectory()) {                    unpackFolder(jarRoot, entry.getName());                } else {                    unpackFile(jarRoot, entry, zin);                }                entry = zin.getNextEntry();            }        } catch (IOException ioe) {            throw new RepositoryException(                "Problem reading JAR contents of " + getPath(), ioe);        } finally {            // close the JAR stream if open            if (zin != null) {                try {                    zin.close();                } catch (IOException ignore) {}            }        }    }    /**     * Makes sure a node exists at the <code>path</code> relative to     * <code>root</code>. In other words, this method returns the node     * <code>root.getNode(path)</code>, creating child nodes as required. Newly     * created nodes are created with node type <code>nt:folder</code>.     * <p>     * If intermediate nodes or the actual node required already exist, they     * must be typed such, that they may either accept child node creations     * of type <code>nt:file</code> or <code>nt:folder</code>.     *     * @param root The <code>Node</code> relative to which a node representing     *      a folder is to created if required.     * @param path The path relative to <code>root</code> of the folder to     *      ensure.     *     * @return The <code>Node</code> representing the folder below     *      <code>root</code>.     *     * @throws RepositoryException If an error occurrs accessing the repository     *      or creating missing node(s).     */    private Node unpackFolder(Node root, String path) throws RepositoryException {        // remove trailing slash        while (path.endsWith("/")) {            path = path.substring(0, path.length()-1);        }        // quick check if the folder already exists        if (root.hasNode(path)) {            return root.getNode(path);        }        // go down and create the path        StringTokenizer tokener = new StringTokenizer(path, "/");        while (tokener.hasMoreTokens()) {            String label = tokener.nextToken();            if (root.hasNode(label)) {                root = root.getNode(label);            } else {                root = root.addNode(label, "nt:folder");            }        }        // return the final node        return root;    }    /**     * Creates a <code>nt:file</code> node with the path     * <code>entry.getName()</code> relative to the <code>root</code> node. The     * contents of the <code>jcr:content/jcr:data</code> property of the file     * node is retrieved from <code>ins</code>.     * <p>     * The <code>jcr:content/jcr:lastModified</code> property is set to the     * value of the <code>time</code> field of the <code>entry</code>. The     * <code>jcr:content/jcr:mimeType</code> property is set to a best-effort     * guess of the content type of the entry. To guess the content type, the     * <code>java.net.URLConnection.guessContentType(String)</code> method     * is called. If this results in no content type, the default     * <code>application/octet-stream</code> is set.     *     * @param root The node relative to which the <code>nt:file</code> node     *      is created.     * @param entry The <code>ZipEntry</code> providing information on the     *      file to be created. Namely the <code>name</code> and     *      <code>time</code> fields are used.     * @param ins The <code>InputStream</code> providing the data to be written     *      to the <code>jcr:content/jcr:data</code> property.     *     * @throws RepositoryException If an error occurrs creating and filling     *      the <code>nt:file</code> node.     */    private void unpackFile(Node root, ZipEntry entry, InputStream ins) throws RepositoryException {        int slash = entry.getName().lastIndexOf('/');        String label = entry.getName().substring(slash+1);        Node parent = (slash <= 0)                ? root                : unpackFolder(root, entry.getName().substring(0, slash));        // remove existing node (and all children by the way !!)        if (parent.hasNode(label)) {            parent.getNode(label).remove();        }        // prepare property values        Calendar lastModified = Calendar.getInstance();        lastModified.setTimeInMillis(entry.getTime());        String mimeType = URLConnection.guessContentTypeFromName(label);        if (mimeType == null) {            mimeType = "application/octet-stream";        }        // create entry nodes        Node ntFile = parent.addNode(label, "nt:file");        Node content = ntFile.addNode("jcr:content", "nt:resource");        content.setProperty("jcr:mimeType", mimeType);        content.setProperty("jcr:data", ins);        content.setProperty("jcr:lastModified", lastModified);    }    /**     * Checks whether it is possible to use this class for archive class path     * entries in the workspace (and repository) to which the <code>session</code>     * provides access.     * <p>     * This method works as follows. If the node type <code>rep:jarFile</code>     * is defined in the session's repository, <code>true</code> is immediately     * returned. If an error checking for the node type, <code>false</code> is     * immediately returned.     * <p>     * If the node type is not defined, the     * {@link NodeTypeSupport#registerNodeType(Workspace)} method is called     * to register the node type. Any errors occurring while calling or     * executing this method is logged an <code>false</code> is returned.     * Otherwise, if node type registration succeeded, <code>true</code> is     * returned.     * <p>     * This method is synchronized such that two paralell threads do not try     * to create the node, which might yield wrong negatives.     *     * @param session The <code>Session</code> providing access to the     *      repository.     *     * @return <code>true</code> if this class can be used to handle archive     *      class path entries. See above for a description of the test used.     */    /* package */ synchronized static boolean canExpandArchives(Session session) {        // quick check for the node type, succeed if defined        try {            session.getWorkspace().getNodeTypeManager().getNodeType(TYPE_JARFILE);            log.debug("Required node type exists, can expand archives");            return true;        } catch (NoSuchNodeTypeException nst) {            log.debug("Required node types does not exist, try to define");        } catch (RepositoryException re) {            log.info("Cannot check for required node type, cannot expand " +                    "archives", re);            return false;        }        try {            Workspace workspace = session.getWorkspace();            return NodeTypeSupport.registerNodeType(workspace);        } catch (Throwable t) {            // Prevent anything from hapening if node type registration fails            // due to missing libraries or other errors            log.info("Error registering node type", t);        }        // fallback to failure        return false;    }}