| /* |
| * 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.felix.framework.cache; |
| |
| import java.io.*; |
| |
| import java.util.Map; |
| import java.util.SortedMap; |
| import java.util.TreeMap; |
| import org.apache.felix.framework.Logger; |
| import org.apache.felix.framework.util.WeakZipFileFactory; |
| import org.osgi.framework.Bundle; |
| import org.osgi.framework.Constants; |
| |
| /** |
| * <p> |
| * This class is a logical abstraction for a bundle archive. This class, |
| * combined with <tt>BundleCache</tt> and concrete <tt>BundleRevision</tt> |
| * subclasses, implement the bundle cache for Felix. The bundle archive |
| * abstracts the actual bundle content into revisions and the revisions |
| * provide access to the actual bundle content. When a bundle is |
| * installed it has one revision associated with its content. Updating a |
| * bundle adds another revision for the updated content. Any number of |
| * revisions can be associated with a bundle archive. When the bundle |
| * (or framework) is refreshed, then all old revisions are purged and only |
| * the most recent revision is maintained. |
| * </p> |
| * <p> |
| * The content associated with a revision can come in many forms, such as |
| * a standard JAR file or an exploded bundle directory. The bundle archive |
| * is responsible for creating all revision instances during invocations |
| * of the <tt>revise()</tt> method call. Internally, it determines the |
| * concrete type of revision type by examining the location string as an |
| * URL. Currently, it supports standard JAR files, referenced JAR files, |
| * and referenced directories. Examples of each type of URL are, respectively: |
| * </p> |
| * <ul> |
| * <li><tt>http://www.foo.com/bundle.jar</tt></li> |
| * <li><tt>reference:file:/foo/bundle.jar</tt></li> |
| * <li><tt>reference:file:/foo/bundle/</tt></li> |
| * </ul> |
| * <p> |
| * The "<tt>reference:</tt>" notation signifies that the resource should be |
| * used "in place", meaning that they will not be copied. For referenced JAR |
| * files, some resources may still be copied, such as embedded JAR files or |
| * native libraries, but for referenced exploded bundle directories, nothing |
| * will be copied. Currently, reference URLs can only refer to "file:" targets. |
| * </p> |
| * @see org.apache.felix.framework.cache.BundleCache |
| * @see org.apache.felix.framework.cache.BundleRevision |
| **/ |
| public class BundleArchive |
| { |
| public static final transient String FILE_PROTOCOL = "file:"; |
| public static final transient String REFERENCE_PROTOCOL = "reference:"; |
| public static final transient String INPUTSTREAM_PROTOCOL = "inputstream:"; |
| |
| private static final transient String BUNDLE_INFO_FILE = "bundle.info"; |
| private static final transient String REVISION_LOCATION_FILE = "revision.location"; |
| private static final transient String REVISION_DIRECTORY = "version"; |
| private static final transient String DATA_DIRECTORY = "data"; |
| |
| private final Logger m_logger; |
| private final Map m_configMap; |
| private final WeakZipFileFactory m_zipFactory; |
| private final File m_archiveRootDir; |
| private final boolean m_isSingleBundleFile; |
| |
| private long m_id = -1; |
| private String m_originalLocation = null; |
| private int m_persistentState = -1; |
| private int m_startLevel = -1; |
| private long m_lastModified = -1; |
| |
| /** |
| * The refresh count field is used when generating the bundle revision |
| * directory name where native libraries are extracted. This is necessary |
| * because Sun's JVM requires a one-to-one mapping between native libraries |
| * and class loaders where the native library is uniquely identified by its |
| * absolute path in the file system. This constraint creates a problem when |
| * a bundle is refreshed, because it gets a new class loader. Using the |
| * refresh counter to generate the name of the bundle revision directory |
| * resolves this problem because each time bundle is refresh, the native |
| * library will have a unique name. As a result of the unique name, the JVM |
| * will then reload the native library without a problem. |
| **/ |
| private long m_refreshCount = -1; |
| |
| // Maps a Long revision number to a BundleRevision. |
| private final SortedMap<Long, BundleArchiveRevision> m_revisions |
| = new TreeMap<Long, BundleArchiveRevision>(); |
| |
| /** |
| * <p> |
| * This constructor is used for creating new archives when a bundle is |
| * installed into the framework. Each archive receives a logger, a root |
| * directory, its associated bundle identifier, the associated bundle |
| * location string, and an input stream from which to read the bundle |
| * content. The root directory is where any required state can be |
| * stored. The input stream may be null, in which case the location is |
| * used as an URL to the bundle content. |
| * </p> |
| * @param logger the logger to be used by the archive. |
| * @param archiveRootDir the archive root directory for storing state. |
| * @param id the bundle identifier associated with the archive. |
| * @param location the bundle location string associated with the archive. |
| * @param is input stream from which to read the bundle content. |
| * @throws Exception if any error occurs. |
| **/ |
| public BundleArchive(Logger logger, Map configMap, WeakZipFileFactory zipFactory, |
| File archiveRootDir, long id, int startLevel, String location, InputStream is) |
| throws Exception |
| { |
| m_logger = logger; |
| m_configMap = configMap; |
| m_zipFactory = zipFactory; |
| m_archiveRootDir = archiveRootDir; |
| m_id = id; |
| if (m_id <= 0) |
| { |
| throw new IllegalArgumentException( |
| "Bundle ID cannot be less than or equal to zero."); |
| } |
| m_originalLocation = location; |
| m_persistentState = Bundle.INSTALLED; |
| m_startLevel = startLevel; |
| m_lastModified = System.currentTimeMillis(); |
| m_refreshCount = 0; |
| |
| String s = (String) m_configMap.get(BundleCache.CACHE_SINGLEBUNDLEFILE_PROP); |
| m_isSingleBundleFile = (s == null) || (!s.equalsIgnoreCase("true")) ? false : true; |
| |
| // Save state. |
| initialize(); |
| |
| // Add a revision for the content. |
| reviseInternal(false, new Long(0), m_originalLocation, is); |
| } |
| |
| /** |
| * <p> |
| * This constructor is called when an archive for a bundle is being |
| * reconstructed when the framework is restarted. Each archive receives |
| * a logger, a root directory, and its associated bundle identifier. |
| * The root directory is where any required state can be stored. |
| * </p> |
| * @param logger the logger to be used by the archive. |
| * @param archiveRootDir the archive root directory for storing state. |
| * @param configMap configMap for BundleArchive |
| * @throws Exception if any error occurs. |
| **/ |
| public BundleArchive(Logger logger, Map configMap, WeakZipFileFactory zipFactory, |
| File archiveRootDir) |
| throws Exception |
| { |
| m_logger = logger; |
| m_configMap = configMap; |
| m_zipFactory = zipFactory; |
| m_archiveRootDir = archiveRootDir; |
| |
| String s = (String) m_configMap.get(BundleCache.CACHE_SINGLEBUNDLEFILE_PROP); |
| m_isSingleBundleFile = (s == null) || (!s.equalsIgnoreCase("true")) ? false : true; |
| |
| if (m_isSingleBundleFile) |
| { |
| readBundleInfo(); |
| } |
| |
| // Add a revision number for each revision that exists in the file |
| // system. The file system might contain more than one revision if |
| // the bundle was updated in a previous session, but the framework |
| // was not refreshed; this might happen if the framework did not |
| // exit cleanly. We must add the existing revisions so that |
| // they can be properly purged. |
| |
| // Find the existing revision directories, which will be named like: |
| // "${REVISION_DIRECTORY)${refresh-count}.${revision-number}" |
| File[] children = m_archiveRootDir.listFiles(); |
| for (File child : children) |
| { |
| if (child.getName().startsWith(REVISION_DIRECTORY) |
| && child.isDirectory()) |
| { |
| // Determine the revision number and add it to the revision map. |
| int idx = child.getName().lastIndexOf('.'); |
| if (idx > 0) |
| { |
| Long revNum = Long.decode(child.getName().substring(idx + 1)); |
| m_revisions.put(revNum, null); |
| } |
| } |
| } |
| |
| if (m_revisions.isEmpty()) |
| { |
| throw new Exception( |
| "No valid revisions in bundle archive directory: " |
| + archiveRootDir); |
| } |
| |
| // Remove the last revision number since the call to reviseInternal() |
| // will properly add the most recent bundle revision. |
| // NOTE: We do not actually need to add a real revision object for the |
| // older revisions since they will be purged immediately on framework |
| // startup. |
| Long currentRevNum = m_revisions.lastKey(); |
| m_revisions.remove(currentRevNum); |
| |
| // Add the revision object for the most recent revision. |
| reviseInternal(true, currentRevNum, getRevisionLocation(currentRevNum), null); |
| } |
| |
| /** |
| * <p> |
| * Returns the bundle identifier associated with this archive. |
| * </p> |
| * @return the bundle identifier associated with this archive. |
| * @throws Exception if any error occurs. |
| **/ |
| public synchronized long getId() throws Exception |
| { |
| if (m_id <= 0) |
| { |
| m_id = readId(); |
| } |
| return m_id; |
| } |
| |
| /** |
| * <p> |
| * Returns the location string associated with this archive. |
| * </p> |
| * @return the location string associated with this archive. |
| * @throws Exception if any error occurs. |
| **/ |
| public synchronized String getLocation() throws Exception |
| { |
| if (m_originalLocation == null) |
| { |
| m_originalLocation = readLocation(); |
| } |
| return m_originalLocation; |
| } |
| |
| /** |
| * <p> |
| * Returns the persistent state of this archive. The value returned is |
| * one of the following: <tt>Bundle.INSTALLED</tt>, <tt>Bundle.ACTIVE</tt>, |
| * or <tt>Bundle.UNINSTALLED</tt>. |
| * </p> |
| * @return the persistent state of this archive. |
| * @throws Exception if any error occurs. |
| **/ |
| public synchronized int getPersistentState() throws Exception |
| { |
| if (m_persistentState < 0) |
| { |
| m_persistentState = readPersistentState(); |
| } |
| return m_persistentState; |
| } |
| |
| /** |
| * <p> |
| * Sets the persistent state of this archive. The value is |
| * one of the following: <tt>Bundle.INSTALLED</tt>, <tt>Bundle.ACTIVE</tt>, |
| * or <tt>Bundle.UNINSTALLED</tt>. |
| * </p> |
| * @param state the persistent state value to set for this archive. |
| * @throws Exception if any error occurs. |
| **/ |
| public synchronized void setPersistentState(int state) throws Exception |
| { |
| if (m_persistentState != state) |
| { |
| m_persistentState = state; |
| if (m_isSingleBundleFile) |
| { |
| writeBundleInfo(); |
| } |
| else |
| { |
| writePersistentState(); |
| } |
| } |
| } |
| |
| /** |
| * <p> |
| * Returns the start level of this archive. |
| * </p> |
| * @return the start level of this archive. |
| * @throws Exception if any error occurs. |
| **/ |
| public synchronized int getStartLevel() throws Exception |
| { |
| if (m_startLevel < 0) |
| { |
| m_startLevel = readStartLevel(); |
| } |
| return m_startLevel; |
| } |
| |
| /** |
| * <p> |
| * Sets the the start level of this archive this archive. |
| * </p> |
| * @param level the start level to set for this archive. |
| * @throws Exception if any error occurs. |
| **/ |
| public synchronized void setStartLevel(int level) throws Exception |
| { |
| if (m_startLevel != level) |
| { |
| m_startLevel = level; |
| if (m_isSingleBundleFile) |
| { |
| writeBundleInfo(); |
| } |
| else |
| { |
| writeStartLevel(); |
| } |
| } |
| } |
| |
| /** |
| * <p> |
| * Returns the last modification time of this archive. |
| * </p> |
| * @return the last modification time of this archive. |
| * @throws Exception if any error occurs. |
| **/ |
| public synchronized long getLastModified() throws Exception |
| { |
| if (m_lastModified < 0) |
| { |
| m_lastModified = readLastModified(); |
| } |
| return m_lastModified; |
| } |
| |
| /** |
| * <p> |
| * Sets the the last modification time of this archive. |
| * </p> |
| * @param lastModified The time of the last modification to set for |
| * this archive. According to the OSGi specification this time is |
| * set each time a bundle is installed, updated or uninstalled. |
| * |
| * @throws Exception if any error occurs. |
| **/ |
| public synchronized void setLastModified(long lastModified) throws Exception |
| { |
| if (m_lastModified != lastModified) |
| { |
| m_lastModified = lastModified; |
| if (m_isSingleBundleFile) |
| { |
| writeBundleInfo(); |
| } |
| else |
| { |
| writeLastModified(); |
| } |
| } |
| } |
| |
| /** |
| * This utility method is used to retrieve the current refresh |
| * counter value for the bundle. This value is used when generating |
| * the bundle revision directory name where native libraries are extracted. |
| * This is necessary because Sun's JVM requires a one-to-one mapping |
| * between native libraries and class loaders where the native library |
| * is uniquely identified by its absolute path in the file system. This |
| * constraint creates a problem when a bundle is refreshed, because it |
| * gets a new class loader. Using the refresh counter to generate the name |
| * of the bundle revision directory resolves this problem because each time |
| * bundle is refresh, the native library will have a unique name. |
| * As a result of the unique name, the JVM will then reload the |
| * native library without a problem. |
| **/ |
| private long getRefreshCount() throws Exception |
| { |
| // If the refresh counter is not yet initialized, do so now. |
| if (m_refreshCount < 0) |
| { |
| m_refreshCount = readRefreshCount(); |
| } |
| |
| return m_refreshCount; |
| } |
| |
| /** |
| * This utility method is used to retrieve the current refresh |
| * counter value for the bundle. This value is used when generating |
| * the bundle revision directory name where native libraries are extracted. |
| * This is necessary because Sun's JVM requires a one-to-one mapping |
| * between native libraries and class loaders where the native library |
| * is uniquely identified by its absolute path in the file system. This |
| * constraint creates a problem when a bundle is refreshed, because it |
| * gets a new class loader. Using the refresh counter to generate the name |
| * of the bundle revision directory resolves this problem because each time |
| * bundle is refresh, the native library will have a unique name. |
| * As a result of the unique name, the JVM will then reload the |
| * native library without a problem. |
| **/ |
| private void setRefreshCount(long count) |
| throws Exception |
| { |
| if (m_refreshCount != count) |
| { |
| m_refreshCount = count; |
| if (m_isSingleBundleFile) |
| { |
| writeBundleInfo(); |
| } |
| else |
| { |
| writeRefreshCount(); |
| } |
| } |
| } |
| |
| /** |
| * <p> |
| * Returns a <tt>File</tt> object corresponding to the data file |
| * of the relative path of the specified string. |
| * </p> |
| * @return a <tt>File</tt> object corresponding to the specified file name. |
| * @throws Exception if any error occurs. |
| **/ |
| public synchronized File getDataFile(String fileName) throws Exception |
| { |
| // Do some sanity checking. |
| if ((fileName.length() > 0) && (fileName.charAt(0) == File.separatorChar)) |
| { |
| throw new IllegalArgumentException( |
| "The data file path must be relative, not absolute."); |
| } |
| else if (fileName.indexOf("..") >= 0) |
| { |
| throw new IllegalArgumentException( |
| "The data file path cannot contain a reference to the \"..\" directory."); |
| } |
| |
| // Get bundle data directory. |
| File dataDir = new File(m_archiveRootDir, DATA_DIRECTORY); |
| // Create the data directory if necessary. |
| if (!BundleCache.getSecureAction().fileExists(dataDir)) |
| { |
| if (!BundleCache.getSecureAction().mkdir(dataDir)) |
| { |
| throw new IOException("Unable to create bundle data directory."); |
| } |
| } |
| |
| // Return the data file. |
| return new File(dataDir, fileName); |
| } |
| |
| /** |
| * <p> |
| * Returns the current revision object for the archive. |
| * </p> |
| * @return the current revision object for the archive. |
| **/ |
| public synchronized Long getCurrentRevisionNumber() |
| { |
| return (m_revisions.isEmpty()) ? null : m_revisions.lastKey(); |
| } |
| |
| /** |
| * <p> |
| * Returns the current revision object for the archive. |
| * </p> |
| * @return the current revision object for the archive. |
| **/ |
| public synchronized BundleArchiveRevision getCurrentRevision() |
| { |
| return (m_revisions.isEmpty()) ? null : m_revisions.get(m_revisions.lastKey()); |
| } |
| |
| public synchronized boolean isRemovalPending() |
| { |
| return (m_revisions.size() > 1); |
| } |
| |
| /** |
| * <p> |
| * This method adds a revision to the archive using the associated |
| * location and input stream. If the input stream is null, then the |
| * location is used a URL to obtain an input stream. |
| * </p> |
| * @param location the location string associated with the revision. |
| * @param is the input stream from which to read the revision. |
| * @throws Exception if any error occurs. |
| **/ |
| public synchronized void revise(String location, InputStream is) |
| throws Exception |
| { |
| Long revNum = (m_revisions.isEmpty()) |
| ? new Long(0) |
| : new Long(m_revisions.lastKey().longValue() + 1); |
| |
| reviseInternal(false, revNum, location, is); |
| } |
| |
| /** |
| * Actually adds a revision to the bundle archive. This method is also |
| * used to reload cached bundles too. The revision is given the specified |
| * revision number and is read from the input stream if supplied or from |
| * the location URL if not. |
| * @param isReload if the bundle is being reloaded or not. |
| * @param revNum the revision number of the revision. |
| * @param location the location associated with the revision. |
| * @param is the input stream from which to read the revision. |
| * @throws Exception if any error occurs. |
| */ |
| private void reviseInternal( |
| boolean isReload, Long revNum, String location, InputStream is) |
| throws Exception |
| { |
| // If we have an input stream, then we have to use it |
| // no matter what the update location is, so just ignore |
| // the update location and set the location to be input |
| // stream. |
| if (is != null) |
| { |
| location = "inputstream:"; |
| } |
| |
| // Create a bundle revision for revision number. |
| BundleArchiveRevision revision = createRevisionFromLocation(location, is, revNum); |
| if (revision == null) |
| { |
| throw new Exception("Unable to revise archive."); |
| } |
| |
| if (!isReload) |
| { |
| setRevisionLocation(location, revNum); |
| } |
| |
| // Add new revision to revision map. |
| m_revisions.put(revNum, revision); |
| } |
| |
| /** |
| * <p> |
| * This method undoes the previous revision to the archive; this method will |
| * remove the latest revision from the archive. This method is only called |
| * when there are problems during an update after the revision has been |
| * created, such as errors in the update bundle's manifest. This method |
| * can only be called if there is more than one revision, otherwise there |
| * is nothing to undo. |
| * </p> |
| * @return true if the undo was a success false if there is no previous revision |
| * @throws Exception if any error occurs. |
| */ |
| public synchronized boolean rollbackRevise() throws Exception |
| { |
| // Can only undo the revision if there is more than one. |
| if (m_revisions.size() <= 1) |
| { |
| return false; |
| } |
| |
| Long revNum = m_revisions.lastKey(); |
| BundleArchiveRevision revision = m_revisions.remove(revNum); |
| |
| try |
| { |
| revision.close(); |
| } |
| catch(Exception ex) |
| { |
| m_logger.log(Logger.LOG_ERROR, getClass().getName() + |
| ": Unable to dispose latest revision", ex); |
| } |
| |
| File revisionDir = new File(m_archiveRootDir, REVISION_DIRECTORY + |
| getRefreshCount() + "." + revNum.toString()); |
| |
| if (BundleCache.getSecureAction().fileExists(revisionDir)) |
| { |
| BundleCache.deleteDirectoryTree(revisionDir); |
| } |
| |
| return true; |
| } |
| |
| private synchronized String getRevisionLocation(Long revNum) throws Exception |
| { |
| InputStream is = null; |
| BufferedReader br = null; |
| try |
| { |
| is = BundleCache.getSecureAction().getFileInputStream(new File( |
| new File(m_archiveRootDir, REVISION_DIRECTORY + |
| getRefreshCount() + "." + revNum.toString()), REVISION_LOCATION_FILE)); |
| |
| br = new BufferedReader(new InputStreamReader(is)); |
| return br.readLine(); |
| } |
| finally |
| { |
| if (br != null) br.close(); |
| if (is != null) is.close(); |
| } |
| } |
| |
| private synchronized void setRevisionLocation(String location, Long revNum) |
| throws Exception |
| { |
| // Save current revision location. |
| OutputStream os = null; |
| BufferedWriter bw = null; |
| try |
| { |
| os = BundleCache.getSecureAction() |
| .getFileOutputStream(new File( |
| new File(m_archiveRootDir, REVISION_DIRECTORY + |
| getRefreshCount() + "." + revNum.toString()), REVISION_LOCATION_FILE)); |
| bw = new BufferedWriter(new OutputStreamWriter(os)); |
| bw.write(location, 0, location.length()); |
| } |
| finally |
| { |
| if (bw != null) bw.close(); |
| if (os != null) os.close(); |
| } |
| } |
| |
| public synchronized void close() |
| { |
| // Get the current revision count. |
| for (BundleArchiveRevision revision : m_revisions.values()) |
| { |
| // Dispose of the revision, but this might be null in certain |
| // circumstances, such as if this bundle archive was created |
| // for an existing bundle that was updated, but not refreshed |
| // due to a system crash; see the constructor code for details. |
| if (revision != null) |
| { |
| try |
| { |
| revision.close(); |
| } |
| catch (Exception ex) |
| { |
| m_logger.log( |
| Logger.LOG_ERROR, |
| "Unable to close revision - " |
| + revision.getRevisionRootDir(), ex); |
| } |
| } |
| } |
| } |
| |
| /** |
| * <p> |
| * This method closes any revisions and deletes the bundle archive directory. |
| * </p> |
| * @throws Exception if any error occurs. |
| **/ |
| public synchronized void closeAndDelete() |
| { |
| // Close the revisions and delete the archive directory. |
| close(); |
| if (!BundleCache.deleteDirectoryTree(m_archiveRootDir)) |
| { |
| m_logger.log( |
| Logger.LOG_ERROR, |
| "Unable to delete archive directory - " + m_archiveRootDir); |
| } |
| } |
| |
| /** |
| * <p> |
| * This method removes all old revisions associated with the archive |
| * and keeps only the current revision. |
| * </p> |
| * @throws Exception if any error occurs. |
| **/ |
| public synchronized void purge() throws Exception |
| { |
| // Remember current revision number. |
| Long currentRevNum = getCurrentRevisionNumber(); |
| |
| // Record whether the current revision has native libraries, which |
| // we'll use later to determine if we need to rename its directory. |
| boolean hasNativeLibs = getCurrentRevision().getManifestHeader() |
| .containsKey(Constants.BUNDLE_NATIVECODE); |
| |
| // Close all revisions and then delete all but the current revision. |
| // We don't delete it the current revision, because we want to rename it |
| // to the new refresh level. |
| close(); |
| |
| // Delete all old revisions. |
| long refreshCount = getRefreshCount(); |
| for (Long revNum : m_revisions.keySet()) |
| { |
| if (!revNum.equals(currentRevNum)) |
| { |
| File revisionDir = new File( |
| m_archiveRootDir, |
| REVISION_DIRECTORY + refreshCount + "." + revNum.toString()); |
| if (BundleCache.getSecureAction().fileExists(revisionDir)) |
| { |
| BundleCache.deleteDirectoryTree(revisionDir); |
| } |
| } |
| } |
| |
| // If the revision has native libraries, then rename its directory |
| // to avoid the issue of being unable to load the same native library |
| // into two different class loaders. |
| if (hasNativeLibs) |
| { |
| // Increment the refresh count. |
| setRefreshCount(refreshCount + 1); |
| |
| // Rename the current revision directory to the new refresh level. |
| File currentDir = new File(m_archiveRootDir, |
| REVISION_DIRECTORY + (refreshCount + 1) + "." + currentRevNum.toString()); |
| File revisionDir = new File(m_archiveRootDir, |
| REVISION_DIRECTORY + refreshCount + "." + currentRevNum.toString()); |
| BundleCache.getSecureAction().renameFile(revisionDir, currentDir); |
| } |
| |
| // Clear the revision map since they are all invalid now. |
| m_revisions.clear(); |
| |
| // Recreate the revision for the current location. |
| BundleArchiveRevision revision = createRevisionFromLocation( |
| getRevisionLocation(currentRevNum), null, currentRevNum); |
| // Add new revision to the revision map. |
| m_revisions.put(currentRevNum, revision); |
| } |
| |
| /** |
| * <p> |
| * Initializes the bundle archive object by creating the archive |
| * root directory and saving the initial state. |
| * </p> |
| * @throws Exception if any error occurs. |
| **/ |
| private void initialize() throws Exception |
| { |
| OutputStream os = null; |
| BufferedWriter bw = null; |
| |
| try |
| { |
| // If the archive directory exists, then we don't |
| // need to initialize since it has already been done. |
| if (BundleCache.getSecureAction().fileExists(m_archiveRootDir)) |
| { |
| return; |
| } |
| |
| // Create archive directory, if it does not exist. |
| if (!BundleCache.getSecureAction().mkdir(m_archiveRootDir)) |
| { |
| m_logger.log( |
| Logger.LOG_ERROR, |
| getClass().getName() + ": Unable to create archive directory."); |
| throw new IOException("Unable to create archive directory."); |
| } |
| |
| if (m_isSingleBundleFile) |
| { |
| writeBundleInfo(); |
| } |
| else |
| { |
| writeId(); |
| writeLocation(); |
| writePersistentState(); |
| writeStartLevel(); |
| writeLastModified(); |
| } |
| } |
| finally |
| { |
| if (bw != null) bw.close(); |
| if (os != null) os.close(); |
| } |
| } |
| |
| /** |
| * <p> |
| * Creates a revision based on the location string and/or input stream. |
| * </p> |
| * @return the location string associated with this archive. |
| **/ |
| private BundleArchiveRevision createRevisionFromLocation( |
| String location, InputStream is, Long revNum) |
| throws Exception |
| { |
| // The revision directory is named using the refresh count and |
| // the revision number. The revision number is an increasing |
| // counter of the number of times the bundle was revised. |
| // The refresh count is necessary due to how native libraries |
| // are handled in Java; needless to say, every time a bundle is |
| // refreshed we must change the name of its native libraries so |
| // that we can reload them. Thus, we use the refresh counter as |
| // a way to change the name of the revision directory to give |
| // native libraries new absolute names. |
| File revisionRootDir = new File(m_archiveRootDir, |
| REVISION_DIRECTORY + getRefreshCount() + "." + revNum.toString()); |
| |
| BundleArchiveRevision result = null; |
| |
| try |
| { |
| // Check if the location string represents a reference URL. |
| if ((location != null) && location.startsWith(REFERENCE_PROTOCOL)) |
| { |
| // Reference URLs only support the file protocol. |
| location = location.substring(REFERENCE_PROTOCOL.length()); |
| if (!location.startsWith(FILE_PROTOCOL)) |
| { |
| throw new IOException("Reference URLs can only be files: " + location); |
| } |
| |
| // Decode any URL escaped sequences. |
| location = decode(location); |
| |
| // Make sure the referenced file exists. |
| File file = new File(location.substring(FILE_PROTOCOL.length())); |
| if (!BundleCache.getSecureAction().fileExists(file)) |
| { |
| throw new IOException("Referenced file does not exist: " + file); |
| } |
| |
| // If the referenced file is a directory, then create a directory |
| // revision; otherwise, create a JAR revision with the reference |
| // flag set to true. |
| if (BundleCache.getSecureAction().isFileDirectory(file)) |
| { |
| result = new DirectoryRevision(m_logger, m_configMap, |
| m_zipFactory, revisionRootDir, location); |
| } |
| else |
| { |
| result = new JarRevision(m_logger, m_configMap, |
| m_zipFactory, revisionRootDir, location, true, null); |
| } |
| } |
| else if (location.startsWith(INPUTSTREAM_PROTOCOL)) |
| { |
| // Assume all input streams point to JAR files. |
| result = new JarRevision(m_logger, m_configMap, |
| m_zipFactory, revisionRootDir, location, false, is); |
| } |
| else |
| { |
| // Anything else is assumed to be a URL to a JAR file. |
| result = new JarRevision(m_logger, m_configMap, |
| m_zipFactory, revisionRootDir, location, false, null); |
| } |
| } |
| catch (Exception ex) |
| { |
| if (BundleCache.getSecureAction().fileExists(revisionRootDir)) |
| { |
| if (!BundleCache.deleteDirectoryTree(revisionRootDir)) |
| { |
| m_logger.log( |
| Logger.LOG_ERROR, |
| getClass().getName() |
| + ": Unable to delete revision directory - " |
| + revisionRootDir); |
| } |
| } |
| throw ex; |
| } |
| |
| return result; |
| } |
| |
| // Method from Harmony java.net.URIEncoderDecoder (luni subproject) |
| // used by URI to decode uri components. |
| private static String decode(String s) throws UnsupportedEncodingException |
| { |
| StringBuffer result = new StringBuffer(); |
| ByteArrayOutputStream out = new ByteArrayOutputStream(); |
| for (int i = 0; i < s.length();) |
| { |
| char c = s.charAt(i); |
| if (c == '%') |
| { |
| out.reset(); |
| do |
| { |
| if ((i + 2) >= s.length()) |
| { |
| throw new IllegalArgumentException( |
| "Incomplete % sequence at: " + i); |
| } |
| int d1 = Character.digit(s.charAt(i + 1), 16); |
| int d2 = Character.digit(s.charAt(i + 2), 16); |
| if ((d1 == -1) || (d2 == -1)) |
| { |
| throw new IllegalArgumentException("Invalid % sequence (" |
| + s.substring(i, i + 3) |
| + ") at: " + String.valueOf(i)); |
| } |
| out.write((byte) ((d1 << 4) + d2)); |
| i += 3; |
| } |
| while ((i < s.length()) && (s.charAt(i) == '%')); |
| result.append(out.toString("UTF-8")); |
| continue; |
| } |
| result.append(c); |
| i++; |
| } |
| return result.toString(); |
| } |
| |
| private void readBundleInfo() throws Exception |
| { |
| File infoFile = new File(m_archiveRootDir, BUNDLE_INFO_FILE); |
| |
| // Read the bundle start level. |
| InputStream is = null; |
| BufferedReader br= null; |
| try |
| { |
| is = BundleCache.getSecureAction() |
| .getFileInputStream(infoFile); |
| br = new BufferedReader(new InputStreamReader(is)); |
| |
| // Read id. |
| m_id = Long.parseLong(br.readLine()); |
| // Read location. |
| m_originalLocation = br.readLine(); |
| // Read state. |
| m_persistentState = Integer.parseInt(br.readLine()); |
| // Read start level. |
| m_startLevel = Integer.parseInt(br.readLine()); |
| // Read last modified. |
| m_lastModified = Long.parseLong(br.readLine()); |
| // Read refresh count. |
| m_refreshCount = Long.parseLong(br.readLine()); |
| } |
| catch (FileNotFoundException ex) |
| { |
| // If there wasn't an info file, then maybe this is an old-style |
| // bundle cache, so try to read the files individually. We can |
| // delete this eventually. |
| m_id = readId(); |
| m_originalLocation = readLocation(); |
| m_persistentState = readPersistentState(); |
| m_startLevel = readStartLevel(); |
| m_lastModified = readLastModified(); |
| m_refreshCount = readRefreshCount(); |
| } |
| finally |
| { |
| if (br != null) br.close(); |
| if (is != null) is.close(); |
| } |
| } |
| |
| private void writeBundleInfo() throws Exception |
| { |
| // Write the bundle start level. |
| OutputStream os = null; |
| BufferedWriter bw = null; |
| try |
| { |
| os = BundleCache.getSecureAction() |
| .getFileOutputStream(new File(m_archiveRootDir, BUNDLE_INFO_FILE)); |
| bw = new BufferedWriter(new OutputStreamWriter(os)); |
| |
| // Write id. |
| String s = Long.toString(m_id); |
| bw.write(s, 0, s.length()); |
| bw.newLine(); |
| // Write location. |
| s = (m_originalLocation == null) ? "" : m_originalLocation; |
| bw.write(s, 0, s.length()); |
| bw.newLine(); |
| // Write state. |
| s = Integer.toString(m_persistentState); |
| bw.write(s, 0, s.length()); |
| bw.newLine(); |
| // Write start level. |
| s = Integer.toString(m_startLevel); |
| bw.write(s, 0, s.length()); |
| bw.newLine(); |
| // Write last modified. |
| s = Long.toString(m_lastModified); |
| bw.write(s, 0, s.length()); |
| bw.newLine(); |
| // Write refresh count. |
| s = Long.toString(m_refreshCount); |
| bw.write(s, 0, s.length()); |
| bw.newLine(); |
| } |
| catch (IOException ex) |
| { |
| m_logger.log( |
| Logger.LOG_ERROR, |
| getClass().getName() + ": Unable to cache bundle info - " + ex); |
| throw ex; |
| } |
| finally |
| { |
| if (bw != null) bw.close(); |
| if (os != null) os.close(); |
| } |
| } |
| |
| // |
| // Deprecated bundle cache format to be deleted eventually. |
| // |
| |
| private static final transient String BUNDLE_ID_FILE = "bundle.id"; |
| private static final transient String BUNDLE_LOCATION_FILE = "bundle.location"; |
| private static final transient String BUNDLE_STATE_FILE = "bundle.state"; |
| private static final transient String BUNDLE_START_LEVEL_FILE = "bundle.startlevel"; |
| private static final transient String BUNDLE_LASTMODIFIED_FILE = "bundle.lastmodified"; |
| private static final transient String REFRESH_COUNTER_FILE = "refresh.counter"; |
| |
| private void writeId() throws Exception |
| { |
| OutputStream os = BundleCache.getSecureAction() |
| .getFileOutputStream(new File(m_archiveRootDir, BUNDLE_ID_FILE)); |
| BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(os)); |
| bw.write(Long.toString(m_id), 0, Long.toString(m_id).length()); |
| bw.close(); |
| os.close(); |
| } |
| |
| private long readId() throws Exception |
| { |
| long id; |
| |
| InputStream is = null; |
| BufferedReader br = null; |
| try |
| { |
| is = BundleCache.getSecureAction() |
| .getFileInputStream(new File(m_archiveRootDir, BUNDLE_ID_FILE)); |
| br = new BufferedReader(new InputStreamReader(is)); |
| id = Long.parseLong(br.readLine()); |
| } |
| catch (FileNotFoundException ex) |
| { |
| // HACK: Get the bundle identifier from the archive root directory |
| // name, which is of the form "bundle<id>" where <id> is the bundle |
| // identifier numbers. This is a hack to deal with old archives that |
| // did not save their bundle identifier, but instead had it passed |
| // into them. Eventually, this can be removed. |
| id = Long.parseLong( |
| m_archiveRootDir.getName().substring( |
| BundleCache.BUNDLE_DIR_PREFIX.length())); |
| } |
| finally |
| { |
| if (br != null) br.close(); |
| if (is != null) is.close(); |
| } |
| |
| return id; |
| } |
| |
| private void writeLocation() throws Exception |
| { |
| OutputStream os = BundleCache.getSecureAction() |
| .getFileOutputStream(new File(m_archiveRootDir, BUNDLE_LOCATION_FILE)); |
| BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(os)); |
| bw.write(m_originalLocation, 0, m_originalLocation.length()); |
| bw.close(); |
| os.close(); |
| } |
| |
| private String readLocation() throws Exception |
| { |
| InputStream is = null; |
| BufferedReader br = null; |
| try |
| { |
| is = BundleCache.getSecureAction() |
| .getFileInputStream(new File(m_archiveRootDir, BUNDLE_LOCATION_FILE)); |
| br = new BufferedReader(new InputStreamReader(is)); |
| return br.readLine(); |
| } |
| finally |
| { |
| if (br != null) br.close(); |
| if (is != null) is.close(); |
| } |
| } |
| |
| private static final transient String ACTIVE_STATE = "active"; |
| private static final transient String STARTING_STATE = "starting"; |
| private static final transient String INSTALLED_STATE = "installed"; |
| private static final transient String UNINSTALLED_STATE = "uninstalled"; |
| |
| private void writePersistentState() throws Exception |
| { |
| OutputStream os = null; |
| BufferedWriter bw = null; |
| try |
| { |
| os = BundleCache.getSecureAction() |
| .getFileOutputStream(new File(m_archiveRootDir, BUNDLE_STATE_FILE)); |
| bw = new BufferedWriter(new OutputStreamWriter(os)); |
| String s = null; |
| switch (m_persistentState) |
| { |
| case Bundle.ACTIVE: |
| s = ACTIVE_STATE; |
| break; |
| case Bundle.STARTING: |
| s = STARTING_STATE; |
| break; |
| case Bundle.UNINSTALLED: |
| s = UNINSTALLED_STATE; |
| break; |
| default: |
| s = INSTALLED_STATE; |
| break; |
| } |
| bw.write(s, 0, s.length()); |
| } |
| catch (IOException ex) |
| { |
| m_logger.log( |
| Logger.LOG_ERROR, |
| getClass().getName() + ": Unable to record state - " + ex); |
| throw ex; |
| } |
| finally |
| { |
| if (bw != null) bw.close(); |
| if (os != null) os.close(); |
| } |
| } |
| |
| private int readPersistentState() throws Exception |
| { |
| int state = Bundle.INSTALLED; |
| |
| // Get bundle state file. |
| File stateFile = new File(m_archiveRootDir, BUNDLE_STATE_FILE); |
| |
| // If the state file doesn't exist, then |
| // assume the bundle was installed. |
| if (BundleCache.getSecureAction().fileExists(stateFile)) |
| { |
| // Read the bundle state. |
| InputStream is = null; |
| BufferedReader br = null; |
| try |
| { |
| is = BundleCache.getSecureAction() |
| .getFileInputStream(stateFile); |
| br = new BufferedReader(new InputStreamReader(is)); |
| String s = br.readLine(); |
| if ((s != null) && s.equals(ACTIVE_STATE)) |
| { |
| state = Bundle.ACTIVE; |
| } |
| else if ((s != null) && s.equals(STARTING_STATE)) |
| { |
| state = Bundle.STARTING; |
| } |
| else if ((s != null) && s.equals(UNINSTALLED_STATE)) |
| { |
| state = Bundle.UNINSTALLED; |
| } |
| else |
| { |
| state = Bundle.INSTALLED; |
| } |
| } |
| catch (Exception ex) |
| { |
| state = Bundle.INSTALLED; |
| } |
| finally |
| { |
| if (br != null) br.close(); |
| if (is != null) is.close(); |
| } |
| } |
| |
| return state; |
| } |
| |
| private void writeStartLevel() throws Exception |
| { |
| OutputStream os = null; |
| BufferedWriter bw = null; |
| try |
| { |
| os = BundleCache.getSecureAction() |
| .getFileOutputStream(new File(m_archiveRootDir, BUNDLE_START_LEVEL_FILE)); |
| bw = new BufferedWriter(new OutputStreamWriter(os)); |
| String s = Integer.toString(m_startLevel); |
| bw.write(s, 0, s.length()); |
| } |
| catch (IOException ex) |
| { |
| m_logger.log( |
| Logger.LOG_ERROR, |
| getClass().getName() + ": Unable to record start level - " + ex); |
| throw ex; |
| } |
| finally |
| { |
| if (bw != null) bw.close(); |
| if (os != null) os.close(); |
| } |
| } |
| |
| private int readStartLevel() throws Exception |
| { |
| int level = -1; |
| |
| // Get bundle start level file. |
| File levelFile = new File(m_archiveRootDir, BUNDLE_START_LEVEL_FILE); |
| |
| // If the start level file doesn't exist, then |
| // return an error. |
| if (!BundleCache.getSecureAction().fileExists(levelFile)) |
| { |
| level = -1; |
| } |
| else |
| { |
| // Read the bundle start level. |
| InputStream is = null; |
| BufferedReader br= null; |
| try |
| { |
| is = BundleCache.getSecureAction() |
| .getFileInputStream(levelFile); |
| br = new BufferedReader(new InputStreamReader(is)); |
| level = Integer.parseInt(br.readLine()); |
| } |
| finally |
| { |
| if (br != null) br.close(); |
| if (is != null) is.close(); |
| } |
| } |
| return level; |
| } |
| |
| private void writeLastModified() throws Exception |
| { |
| OutputStream os = null; |
| BufferedWriter bw = null; |
| try |
| { |
| os = BundleCache.getSecureAction() |
| .getFileOutputStream(new File(m_archiveRootDir, BUNDLE_LASTMODIFIED_FILE)); |
| bw = new BufferedWriter(new OutputStreamWriter(os)); |
| String s = Long.toString(m_lastModified); |
| bw.write(s, 0, s.length()); |
| } |
| catch (IOException ex) |
| { |
| m_logger.log( |
| Logger.LOG_ERROR, |
| getClass().getName() + ": Unable to record start level - " + ex); |
| throw ex; |
| } |
| finally |
| { |
| if (bw != null) bw.close(); |
| if (os != null) os.close(); |
| } |
| } |
| |
| private long readLastModified() throws Exception |
| { |
| long last = 0; |
| |
| InputStream is = null; |
| BufferedReader br = null; |
| try |
| { |
| is = BundleCache.getSecureAction() |
| .getFileInputStream(new File(m_archiveRootDir, BUNDLE_LASTMODIFIED_FILE)); |
| br = new BufferedReader(new InputStreamReader(is)); |
| last = Long.parseLong(br.readLine()); |
| } |
| catch (Exception ex) |
| { |
| last = 0; |
| } |
| finally |
| { |
| if (br != null) br.close(); |
| if (is != null) is.close(); |
| } |
| |
| return last; |
| } |
| |
| private void writeRefreshCount() throws Exception |
| { |
| OutputStream os = null; |
| BufferedWriter bw = null; |
| try |
| { |
| os = BundleCache.getSecureAction() |
| .getFileOutputStream(new File(m_archiveRootDir, REFRESH_COUNTER_FILE)); |
| bw = new BufferedWriter(new OutputStreamWriter(os)); |
| String s = Long.toString(m_refreshCount); |
| bw.write(s, 0, s.length()); |
| } |
| catch (IOException ex) |
| { |
| m_logger.log( |
| Logger.LOG_ERROR, |
| getClass().getName() + ": Unable to write refresh count: " + ex); |
| throw ex; |
| } |
| finally |
| { |
| if (bw != null) bw.close(); |
| if (os != null) os.close(); |
| } |
| } |
| |
| private long readRefreshCount() throws Exception |
| { |
| long count = 0; |
| |
| InputStream is = null; |
| BufferedReader br = null; |
| try |
| { |
| is = BundleCache.getSecureAction() |
| .getFileInputStream(new File(m_archiveRootDir, REFRESH_COUNTER_FILE)); |
| br = new BufferedReader(new InputStreamReader(is)); |
| count = Long.parseLong(br.readLine()); |
| } |
| catch (Exception ex) |
| { |
| count = 0; |
| } |
| finally |
| { |
| if (br != null) br.close(); |
| if (is != null) is.close(); |
| } |
| |
| return count; |
| } |
| } |