/*
* 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.nio.channels.FileChannel;
import java.nio.channels.FileLock;
import java.util.*;
import org.apache.felix.framework.Logger;
import org.apache.felix.framework.util.SecureAction;
import org.apache.felix.framework.util.WeakZipFileFactory;
import org.osgi.framework.Constants;
/**
* <p>
* This class, combined with <tt>BundleArchive</tt>, and concrete
* <tt>BundleRevision</tt> subclasses, implement the Felix bundle cache.
* It is possible to configure the default behavior of this class by
* passing properties into Felix' constructor. The configuration properties
* for this class are (properties starting with "<tt>felix</tt>" are specific
* to Felix, while those starting with "<tt>org.osgi</tt>" are standard OSGi
* properties):
* </p>
* <ul>
* <li><tt>felix.cache.filelimit</tt> - The integer value of this string
* sets an upper limit on how many files the cache will open. The default
* value is zero, which means there is no limit.
* </li>
* <li><tt>org.osgi.framework.storage</tt> - Sets the directory to use as
* the bundle cache; by default bundle cache directory is
* <tt>felix-cache</tt> in the current working directory. The value
* should be a valid directory name. The directory name can be either absolute
* or relative. Relative directory names are relative to the current working
* directory. The specified directory will be created if it does
* not exist.
* </li>
* <li><tt>felix.cache.rootdir</tt> - Sets the root directory to use to
* calculate the bundle cache directory for relative directory names. If
* <tt>org.osgi.framework.storage</tt> is set to a relative name, by
* default it is relative to the current working directory. If this
* property is set, then it will be calculated as being relative to
* the specified root directory.
* </li>
* <li><tt>felix.cache.locking</tt> - Enables or disables bundle cache locking,
* which is used to prevent concurrent access to the bundle cache. This is
* enabled by default, but on older/smaller JVMs file channel locking is
* not available; set this property to <tt>false</tt> to disable it.
* </li>
* <li><tt>felix.cache.bufsize</tt> - Sets the buffer size to be used by
* the cache; the default value is 4096. The integer value of this
* string provides control over the size of the internal buffer of the
* disk cache for performance reasons.
* </li>
* <p>
* For specific information on how to configure the Felix framework, refer
* to the Felix framework usage documentation.
* </p>
* @see org.apache.felix.framework.cache.BundleArchive
**/
public class BundleCache
{
public static final String CACHE_BUFSIZE_PROP = "felix.cache.bufsize";
public static final String CACHE_ROOTDIR_PROP = "felix.cache.rootdir";
public static final String CACHE_LOCKING_PROP = "felix.cache.locking";
public static final String CACHE_FILELIMIT_PROP = "felix.cache.filelimit";
// TODO: CACHE - This should eventually be removed along with the code
// supporting the old multi-file bundle cache format.
public static final String CACHE_SINGLEBUNDLEFILE_PROP = "felix.cache.singlebundlefile";
protected static transient int BUFSIZE = 4096;
private static transient final String CACHE_DIR_NAME = "felix-cache";
private static transient final String CACHE_ROOTDIR_DEFAULT = ".";
private static transient final String CACHE_LOCK_NAME = "cache.lock";
static transient final String BUNDLE_DIR_PREFIX = "bundle";
private static final SecureAction m_secureAction = new SecureAction();
private final Logger m_logger;
private final Map m_configMap;
private final WeakZipFileFactory m_zipFactory;
private final Object m_lock;
public BundleCache(Logger logger, Map configMap)
throws Exception
{
m_logger = logger;
m_configMap = configMap;
int limit = 0;
String limitStr = (String) m_configMap.get(CACHE_FILELIMIT_PROP);
if (limitStr != null)
{
try
{
limit = Integer.parseInt(limitStr);
}
catch (NumberFormatException ex)
{
limit = 0;
}
}
m_zipFactory = new WeakZipFileFactory(limit);
// Create the cache directory, if it does not exist.
File cacheDir = determineCacheDir(m_configMap);
if (!getSecureAction().fileExists(cacheDir))
{
if (!getSecureAction().mkdirs(cacheDir))
{
m_logger.log(
Logger.LOG_ERROR,
"Unable to create cache directory: " + cacheDir);
throw new RuntimeException("Unable to create cache directory.");
}
}
Object locking = m_configMap.get(CACHE_LOCKING_PROP);
locking = (locking == null)
? Boolean.TRUE.toString()
: locking.toString().toLowerCase();
if (((String) locking).equals(Boolean.TRUE.toString()))
{
File lockFile = new File(cacheDir, CACHE_LOCK_NAME);
FileChannel fc = null;
FileOutputStream fos = null;
try
{
if (!getSecureAction().fileExists(lockFile))
{
fos = getSecureAction().getFileOutputStream(lockFile);
fc = fos.getChannel();
}
else
{
fos = getSecureAction().getFileOutputStream(lockFile);
fc = fos.getChannel();
}
}
catch (Exception ex)
{
try
{
if (fos != null) fos.close();
if (fc != null) fc.close();
}
catch (Exception ex2)
{
// Ignore.
}
throw new Exception("Unable to create bundle cache lock file: " + ex);
}
try
{
m_lock = fc.tryLock();
}
catch (Exception ex)
{
throw new Exception("Unable to lock bundle cache: " + ex);
}
}
else
{
m_lock = null;
}
}
public synchronized void release()
{
if (m_lock != null)
{
try
{
((FileLock) m_lock).release();
((FileLock) m_lock).channel().close();
}
catch (Exception ex)
{
// Not much we can do here, just log it.
m_logger.log(
Logger.LOG_WARNING,
"Exception releasing bundle cache.", ex);
}
}
}
/* package */ static SecureAction getSecureAction()
{
return m_secureAction;
}
public synchronized void delete() throws Exception
{
// Delete the cache directory.
File cacheDir = determineCacheDir(m_configMap);
deleteDirectoryTree(cacheDir);
}
public BundleArchive[] getArchives()
throws Exception
{
// Get buffer size value.
try
{
String sBufSize = (String) m_configMap.get(CACHE_BUFSIZE_PROP);
if (sBufSize != null)
{
BUFSIZE = Integer.parseInt(sBufSize);
}
}
catch (NumberFormatException ne)
{
// Use the default value.
}
// Create the existing bundle archives in the directory, if any exist.
File cacheDir = determineCacheDir(m_configMap);
List archiveList = new ArrayList();
File[] children = getSecureAction().listDirectory(cacheDir);
for (int i = 0; (children != null) && (i < children.length); i++)
{
// Ignore directories that aren't bundle directories or
// is the system bundle directory.
if (children[i].getName().startsWith(BUNDLE_DIR_PREFIX) &&
!children[i].getName().equals(BUNDLE_DIR_PREFIX + Long.toString(0)))
{
// Recreate the bundle archive.
try
{
archiveList.add(
new BundleArchive(
m_logger, m_configMap, m_zipFactory, children[i]));
}
catch (Exception ex)
{
// Log exception and remove bundle archive directory.
m_logger.log(Logger.LOG_ERROR,
"Error reloading cached bundle, removing it: " + children[i], ex);
deleteDirectoryTree(children[i]);
}
}
}
return (BundleArchive[])
archiveList.toArray(new BundleArchive[archiveList.size()]);
}
public BundleArchive create(long id, int startLevel, String location, InputStream is)
throws Exception
{
File cacheDir = determineCacheDir(m_configMap);
// Construct archive root directory.
File archiveRootDir =
new File(cacheDir, BUNDLE_DIR_PREFIX + Long.toString(id));
try
{
// Create the archive and add it to the list of archives.
BundleArchive ba =
new BundleArchive(
m_logger, m_configMap, m_zipFactory, archiveRootDir,
id, startLevel, location, is);
return ba;
}
catch (Exception ex)
{
if (m_secureAction.fileExists(archiveRootDir))
{
if (!BundleCache.deleteDirectoryTree(archiveRootDir))
{
m_logger.log(
Logger.LOG_ERROR,
"Unable to delete the archive directory: "
+ archiveRootDir);
}
}
throw ex;
}
}
/**
* Provides the system bundle access to its private storage area; this
* special case is necessary since the system bundle is not really a
* bundle and therefore must be treated in a special way.
* @param fileName the name of the file in the system bundle's private area.
* @return a <tt>File</tt> object corresponding to the specified file name.
* @throws Exception if any error occurs.
**/
public File getSystemBundleDataFile(String fileName)
throws Exception
{
// Make sure system bundle directory exists.
File sbDir = new File(determineCacheDir(m_configMap), BUNDLE_DIR_PREFIX + Long.toString(0));
// If the system bundle directory exists, then we don't
// need to initialize since it has already been done.
if (!getSecureAction().fileExists(sbDir))
{
// Create system bundle directory, if it does not exist.
if (!getSecureAction().mkdirs(sbDir))
{
m_logger.log(
Logger.LOG_ERROR,
"Unable to create system bundle directory.");
throw new IOException("Unable to create system bundle directory.");
}
}
// 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.");
// Return the data file.
return new File(sbDir, fileName);
}
//
// Static file-related utility methods.
//
/**
* This method copies an input stream to the specified file.
* @param is the input stream to copy.
* @param outputFile the file to which the input stream should be copied.
**/
static void copyStreamToFile(InputStream is, File outputFile)
throws IOException
{
OutputStream os = null;
try
{
os = getSecureAction().getFileOutputStream(outputFile);
os = new BufferedOutputStream(os, BUFSIZE);
byte[] b = new byte[BUFSIZE];
int len = 0;
while ((len = is.read(b)) != -1)
{
os.write(b, 0, len);
}
}
finally
{
if (is != null) is.close();
if (os != null) os.close();
}
}
static boolean deleteDirectoryTree(File target)
{
if (!deleteDirectoryTreeRecursive(target))
{
// We might be talking windows and native libs -- hence,
// try to trigger a gc and try again. The hope is that
// this releases the classloader that loaded the native
// lib and allows us to delete it because it then
// would not be used anymore.
System.gc();
System.gc();
return deleteDirectoryTreeRecursive(target);
}
return true;
}
//
// Private methods.
//
private static File determineCacheDir(Map configMap)
{
File cacheDir;
// Check to see if the cache directory is specified in the storage
// configuration property.
String cacheDirStr = (String) configMap.get(Constants.FRAMEWORK_STORAGE);
// Get the cache root directory for relative paths; the default is ".".
String rootDirStr = (String) configMap.get(CACHE_ROOTDIR_PROP);
rootDirStr = (rootDirStr == null) ? CACHE_ROOTDIR_DEFAULT : rootDirStr;
if (cacheDirStr != null)
{
// If the specified cache directory is relative, then use the
// root directory to calculate the absolute path.
cacheDir = new File(cacheDirStr);
if (!cacheDir.isAbsolute())
{
cacheDir = new File(rootDirStr, cacheDirStr);
}
}
else
{
// If no cache directory was specified, then use the default name
// in the root directory.
cacheDir = new File(rootDirStr, CACHE_DIR_NAME);
}
return cacheDir;
}
private static boolean deleteDirectoryTreeRecursive(File target)
{
if (!getSecureAction().fileExists(target))
{
return true;
}
if (getSecureAction().isFileDirectory(target))
{
File[] files = getSecureAction().listDirectory(target);
if (files != null)
{
for (int i = 0; i < files.length; i++)
{
deleteDirectoryTreeRecursive(files[i]);
}
}
}
return getSecureAction().deleteFile(target);
}
}