/* This code is part of Freenet. It is distributed under the GNU General
* Public License, version 2 (or at your option any later version). See
* http://www.gnu.org/ for further details of the GPL. */
package freenet.client;
import java.io.BufferedOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;
import java.util.zip.GZIPInputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import net.contrapunctus.lzma.LzmaInputStream;
import org.apache.commons.compress.compressors.bzip2.BZip2CompressorInputStream;
import org.apache.commons.compress.archivers.ArchiveEntry;
import org.apache.commons.compress.archivers.tar.TarArchiveInputStream;
import freenet.client.async.ClientContext;
import freenet.keys.FreenetURI;
import freenet.support.ExceptionWrapper;
import freenet.support.LRUMap;
import freenet.support.Logger;
import freenet.support.MutableBoolean;
import freenet.support.Logger.LogLevel;
import freenet.support.api.Bucket;
import freenet.support.api.BucketFactory;
import freenet.support.compress.CompressionOutputSizeException;
import freenet.support.compress.Compressor;
import freenet.support.compress.Compressor.COMPRESSOR_TYPE;
import freenet.support.io.BucketTools;
import freenet.support.io.Closer;
/**
* Cache of recently decoded archives:
* - Keep up to N ArchiveHandler's in RAM (this can be large; we don't keep the
* files open due to the limitations of the java.util.zip API)
* - Keep up to Y bytes (after padding and overheads) of decoded data on disk
* (the OS is quite capable of determining what to keep in actual RAM)
*
* Always take the lock on ArchiveStoreContext before the lock on ArchiveManager, NOT the other way around.
*/
public class ArchiveManager {
public static final String METADATA_NAME = ".metadata";
private static boolean logMINOR;
public enum ARCHIVE_TYPE {
// WARNING: This enum is persisted. Changing member names may break downloads/uploads.
ZIP((short)0, new String[] { "application/zip", "application/x-zip" }), /* eventually get rid of ZIP support at some point */
TAR((short)1, new String[] { "application/x-tar" });
public final short metadataID;
public final String[] mimeTypes;
/** cached values(). Never modify or pass this array to outside code! */
private static final ARCHIVE_TYPE[] values = values();
private ARCHIVE_TYPE(short metadataID, String[] mimeTypes) {
this.metadataID = metadataID;
this.mimeTypes = mimeTypes;
}
public static boolean isValidMetadataID(short id) {
for(ARCHIVE_TYPE current : values)
if(id == current.metadataID)
return true;
return false;
}
/**
* Is the given MIME type an archive type that we can deal with?
*/
public static boolean isUsableArchiveType(String type) {
for(ARCHIVE_TYPE current : values)
for(String ctype : current.mimeTypes)
if(ctype.equalsIgnoreCase(type))
return true;
return false;
}
/** If the given MIME type is an archive type that we can deal with,
* get its archive type number (see the ARCHIVE_ constants in Metadata).
*/
public static ARCHIVE_TYPE getArchiveType(String type) {
for(ARCHIVE_TYPE current : values)
for(String ctype : current.mimeTypes)
if(ctype.equalsIgnoreCase(type))
return current;
return null;
}
public static ARCHIVE_TYPE getArchiveType(short type) {
for(ARCHIVE_TYPE current : values)
if(current.metadataID == type)
return current;
return null;
}
public static ARCHIVE_TYPE getDefault() {
return TAR;
}
}
final long maxArchivedFileSize;
// ArchiveHandler's
final int maxArchiveHandlers;
private final LRUMap<FreenetURI, ArchiveStoreContext> archiveHandlers;
// Data cache
/** Maximum number of cached ArchiveStoreItems */
final int maxCachedElements;
/** Maximum cached data in bytes */
final long maxCachedData;
/** Currently cached data in bytes */
private long cachedData;
/** Map from ArchiveKey to ArchiveStoreElement */
private final LRUMap<ArchiveKey, ArchiveStoreItem> storedData;
/** Bucket Factory */
private final BucketFactory tempBucketFactory;
/**
* Create an ArchiveManager.
* @param maxHandlers The maximum number of cached ArchiveHandler's i.e. the
* maximum number of containers to track.
* @param maxCachedData The maximum size of the cache directory, in bytes.
* @param maxArchiveSize The maximum size of an archive.
* @param maxArchivedFileSize The maximum extracted size of a single file in any
* archive.
* @param maxCachedElements The maximum number of cached elements (an element is a
* file extracted from an archive. It is stored, encrypted and padded, in a single
* file.
* @param tempBucketFactory
*/
public ArchiveManager(int maxHandlers, long maxCachedData, long maxArchivedFileSize, int maxCachedElements, BucketFactory tempBucketFactory) {
maxArchiveHandlers = maxHandlers;
// FIXME PERFORMANCE I'm assuming there isn't much locality here, so it's faster to use the FAST_COMPARATOR.
// This may not be true if there are a lot of sites with many containers all inserted as individual SSKs?
archiveHandlers = LRUMap.createSafeMap(FreenetURI.FAST_COMPARATOR);
this.maxCachedElements = maxCachedElements;
this.maxCachedData = maxCachedData;
storedData = new LRUMap<ArchiveKey, ArchiveStoreItem>();
this.maxArchivedFileSize = maxArchivedFileSize;
this.tempBucketFactory = tempBucketFactory;
logMINOR = Logger.shouldLog(LogLevel.MINOR, this);
}
/** Add an ArchiveHandler by key */
private synchronized void putCached(FreenetURI key, ArchiveStoreContext zip) {
if(logMINOR) Logger.minor(this, "Put cached AH for "+key+" : "+zip);
archiveHandlers.push(key, zip);
while(archiveHandlers.size() > maxArchiveHandlers)
archiveHandlers.popKey(); // dump it
}
/** Get an ArchiveHandler by key */
ArchiveStoreContext getCached(FreenetURI key) {
if(logMINOR) Logger.minor(this, "Get cached AH for "+key);
ArchiveStoreContext handler = archiveHandlers.get(key);
if(handler == null) return null;
archiveHandlers.push(key, handler);
return handler;
}
/**
* Create an archive handler. This does not need to know how to
* fetch the key, because the methods called later will ask.
* It will try to serve from cache, but if that fails, will
* re-fetch.
* @param key The key of the archive that we are extracting data from.
* @param archiveType The archive type, defined in Metadata.
* @return An archive handler.
*/
synchronized ArchiveStoreContext makeContext(FreenetURI key, ARCHIVE_TYPE archiveType, COMPRESSOR_TYPE ctype, boolean returnNullIfNotFound) {
ArchiveStoreContext handler = null;
handler = getCached(key);
if(handler != null) return handler;
if(returnNullIfNotFound) return null;
handler = new ArchiveStoreContext(key, archiveType);
putCached(key, handler);
return handler;
}
/**
* Create an archive handler. This does not need to know how to
* fetch the key, because the methods called later will ask.
* It will try to serve from cache, but if that fails, will
* re-fetch.
* @param key The key of the archive that we are extracting data from.
* @param archiveType The archive type, defined in Metadata.
* @return An archive handler.
*/
public ArchiveHandler makeHandler(FreenetURI key, ARCHIVE_TYPE archiveType, COMPRESSOR_TYPE ctype, boolean forceRefetch, boolean persistent) {
return new ArchiveHandlerImpl(key, archiveType, ctype, forceRefetch);
}
/**
* Get a cached, previously extracted, file from an archive.
* @param key The key used to fetch the archive.
* @param filename The name of the file within the archive.
* @return A Bucket containing the data requested, or null.
* @throws ArchiveFailureException
*/
public Bucket getCached(FreenetURI key, String filename) throws ArchiveFailureException {
if(logMINOR) Logger.minor(this, "Fetch cached: "+key+ ' ' +filename);
ArchiveKey k = new ArchiveKey(key, filename);
ArchiveStoreItem asi = null;
synchronized (this) {
asi = storedData.get(k);
if(asi == null) return null;
// Promote to top of LRU
storedData.push(k, asi);
}
if(logMINOR) Logger.minor(this, "Found data");
return asi.getReaderBucket();
}
/**
* Remove a file from the cache. Called after it has been removed from its
* ArchiveHandler.
* @param item The ArchiveStoreItem to remove.
*/
synchronized void removeCachedItem(ArchiveStoreItem item) {
long size = item.spaceUsed();
storedData.removeKey(item.key);
// Hard disk space limit = remove it here.
// Soft disk space limit would be to remove it outside the lock.
// Soft disk space limit = we go over the limit significantly when we
// are overloaded.
cachedData -= size;
if(logMINOR) Logger.minor(this, "removeCachedItem: "+item);
item.close();
}
/**
* Extract data to cache. Call synchronized on ctx.
* @param key The key the data was fetched from.
* @param archiveType The archive type. Must be Metadata.ARCHIVE_ZIP | Metadata.ARCHIVE_TAR.
* @param data The actual data fetched.
* @param archiveContext The context for the whole fetch process.
* @param ctx The ArchiveStoreContext for this key.
* @param element A particular element that the caller is especially interested in, or null.
* @param callback A callback to be called if we find that element, or if we don't.
* @throws ArchiveFailureException If we could not extract the data, or it was too big, etc.
* @throws ArchiveRestartException
* @throws ArchiveRestartException If the request needs to be restarted because the archive
* changed.
*/
public void extractToCache(FreenetURI key, ARCHIVE_TYPE archiveType, COMPRESSOR_TYPE ctype, final Bucket data, ArchiveContext archiveContext, ArchiveStoreContext ctx, String element, ArchiveExtractCallback callback, ClientContext context) throws ArchiveFailureException, ArchiveRestartException {
logMINOR = Logger.shouldLog(LogLevel.MINOR, this);
MutableBoolean gotElement = element != null ? new MutableBoolean() : null;
if(logMINOR) Logger.minor(this, "Extracting "+key);
ctx.removeAllCachedItems(this); // flush cache anyway
final long expectedSize = ctx.getLastSize();
final long archiveSize = data.size();
/** Set if we need to throw a RestartedException rather than returning success,
* after we have unpacked everything.
*/
boolean throwAtExit = false;
if((expectedSize != -1) && (archiveSize != expectedSize)) {
throwAtExit = true;
ctx.setLastSize(archiveSize);
}
byte[] expectedHash = ctx.getLastHash();
if(expectedHash != null) {
byte[] realHash;
try {
realHash = BucketTools.hash(data);
} catch (IOException e) {
throw new ArchiveFailureException("Error reading archive data: "+e, e);
}
if(!Arrays.equals(realHash, expectedHash))
throwAtExit = true;
ctx.setLastHash(realHash);
}
if(archiveSize > archiveContext.maxArchiveSize)
throw new ArchiveFailureException("Archive too big ("+archiveSize+" > "+archiveContext.maxArchiveSize+")!");
else if(archiveSize <= 0)
throw new ArchiveFailureException("Archive too small! ("+archiveSize+')');
else if(logMINOR)
Logger.minor(this, "Container size (possibly compressed): "+archiveSize+" for "+data);
InputStream is = null;
try {
final ExceptionWrapper wrapper;
if((ctype == null) || (ARCHIVE_TYPE.ZIP == archiveType)) {
if(logMINOR) Logger.minor(this, "No compression");
is = data.getInputStream();
wrapper = null;
} else if(ctype == COMPRESSOR_TYPE.BZIP2) {
if(logMINOR) Logger.minor(this, "dealing with BZIP2");
is = new BZip2CompressorInputStream(data.getInputStream());
wrapper = null;
} else if(ctype == COMPRESSOR_TYPE.GZIP) {
if(logMINOR) Logger.minor(this, "dealing with GZIP");
is = new GZIPInputStream(data.getInputStream());
wrapper = null;
} else if(ctype == COMPRESSOR_TYPE.LZMA_NEW) {
// LZMA internally uses pipe streams, so we may as well do it here.
// In fact we need to for LZMA_NEW, because of the properties bytes.
PipedInputStream pis = new PipedInputStream();
PipedOutputStream pos = new PipedOutputStream();
pis.connect(pos);
final OutputStream os = new BufferedOutputStream(pos);
wrapper = new ExceptionWrapper();
context.mainExecutor.execute(new Runnable() {
@Override
public void run() {
InputStream is = null;
try {
Compressor.COMPRESSOR_TYPE.LZMA_NEW.decompress(is = data.getInputStream(), os, data.size(), expectedSize);
} catch (CompressionOutputSizeException e) {
Logger.error(this, "Failed to decompress archive: "+e, e);
wrapper.set(e);
} catch (IOException e) {
Logger.error(this, "Failed to decompress archive: "+e, e);
wrapper.set(e);
} finally {
try {
os.close();
} catch (IOException e) {
Logger.error(this, "Failed to close PipedOutputStream: "+e, e);
}
Closer.close(is);
}
}
});
is = pis;
} else if(ctype == COMPRESSOR_TYPE.LZMA) {
if(logMINOR) Logger.minor(this, "dealing with LZMA");
is = new LzmaInputStream(data.getInputStream());
wrapper = null;
} else {
wrapper = null;
}
if(ARCHIVE_TYPE.ZIP == archiveType)
handleZIPArchive(ctx, key, is, element, callback, gotElement, throwAtExit, context);
else if(ARCHIVE_TYPE.TAR == archiveType)
handleTARArchive(ctx, key, is, element, callback, gotElement, throwAtExit, context);
else
throw new ArchiveFailureException("Unknown or unsupported archive algorithm " + archiveType);
if(wrapper != null) {
Exception e = wrapper.get();
if(e != null) throw new ArchiveFailureException("An exception occured decompressing: "+e.getMessage(), e);
}
} catch (IOException ioe) {
throw new ArchiveFailureException("An IOE occured: "+ioe.getMessage(), ioe);
}finally {
Closer.close(is);
}
}
private void handleTARArchive(ArchiveStoreContext ctx, FreenetURI key, InputStream data, String element, ArchiveExtractCallback callback, MutableBoolean gotElement, boolean throwAtExit, ClientContext context) throws ArchiveFailureException, ArchiveRestartException {
if(logMINOR) Logger.minor(this, "Handling a TAR Archive");
TarArchiveInputStream tarIS = null;
try {
tarIS = new TarArchiveInputStream(data);
// MINOR: Assumes the first entry in the tarball is a directory.
ArchiveEntry entry;
byte[] buf = new byte[32768];
HashSet<String> names = new HashSet<String>();
boolean gotMetadata = false;
outerTAR: while(true) {
try {
entry = tarIS.getNextEntry();
} catch (IllegalArgumentException e) {
// Annoyingly, it can throw this on some corruptions...
throw new ArchiveFailureException("Error reading archive: "+e.getMessage(), e);
}
if(entry == null) break;
if(entry.isDirectory()) continue;
String name = stripLeadingSlashes(entry.getName());
if(names.contains(name)) {
Logger.error(this, "Duplicate key "+name+" in archive "+key);
continue;
}
long size = entry.getSize();
if(name.equals(".metadata"))
gotMetadata = true;
if(size > maxArchivedFileSize && !name.equals(element)) {
addErrorElement(ctx, key, name, "File too big: "+size+" greater than current archived file size limit "+maxArchivedFileSize, true);
} else {
// Read the element
long realLen = 0;
Bucket output = tempBucketFactory.makeBucket(size);
OutputStream out = output.getOutputStream();
try {
int readBytes;
while((readBytes = tarIS.read(buf)) > 0) {
out.write(buf, 0, readBytes);
readBytes += realLen;
if(readBytes > maxArchivedFileSize) {
addErrorElement(ctx, key, name, "File too big: "+maxArchivedFileSize+" greater than current archived file size limit "+maxArchivedFileSize, true);
out.close();
out = null;
output.free();
continue outerTAR;
}
}
} finally {
if(out != null) out.close();
}
if(size <= maxArchivedFileSize) {
addStoreElement(ctx, key, name, output, gotElement, element, callback, context);
names.add(name);
trimStoredData();
} else {
// We are here because they asked for this file.
callback.gotBucket(output, context);
gotElement.value = true;
addErrorElement(ctx, key, name, "File too big: "+size+" greater than current archived file size limit "+maxArchivedFileSize, true);
}
}
}
// If no metadata, generate some
if(!gotMetadata) {
generateMetadata(ctx, key, names, gotElement, element, callback, context);
trimStoredData();
}
if(throwAtExit) throw new ArchiveRestartException("Archive changed on re-fetch");
if((!gotElement.value) && element != null)
callback.notInArchive(context);
} catch (IOException e) {
throw new ArchiveFailureException("Error reading archive: "+e.getMessage(), e);
} finally {
Closer.close(tarIS);
}
}
private void handleZIPArchive(ArchiveStoreContext ctx, FreenetURI key, InputStream data, String element, ArchiveExtractCallback callback, MutableBoolean gotElement, boolean throwAtExit, ClientContext context) throws ArchiveFailureException, ArchiveRestartException {
if(logMINOR) Logger.minor(this, "Handling a ZIP Archive");
ZipInputStream zis = null;
try {
zis = new ZipInputStream(data);
// MINOR: Assumes the first entry in the zip is a directory.
ZipEntry entry;
byte[] buf = new byte[32768];
HashSet<String> names = new HashSet<String>();
boolean gotMetadata = false;
outerZIP: while(true) {
entry = zis.getNextEntry();
if(entry == null) break;
if(entry.isDirectory()) continue;
String name = stripLeadingSlashes(entry.getName());
if(names.contains(name)) {
Logger.error(this, "Duplicate key "+name+" in archive "+key);
continue;
}
long size = entry.getSize();
if(name.equals(".metadata"))
gotMetadata = true;
if(size > maxArchivedFileSize && !name.equals(element)) {
addErrorElement(ctx, key, name, "File too big: "+maxArchivedFileSize+" greater than current archived file size limit "+maxArchivedFileSize, true);
} else {
// Read the element
long realLen = 0;
Bucket output = tempBucketFactory.makeBucket(size);
OutputStream out = output.getOutputStream();
try {
int readBytes;
while((readBytes = zis.read(buf)) > 0) {
out.write(buf, 0, readBytes);
readBytes += realLen;
if(readBytes > maxArchivedFileSize) {
addErrorElement(ctx, key, name, "File too big: "+maxArchivedFileSize+" greater than current archived file size limit "+maxArchivedFileSize, true);
out.close();
out = null;
output.free();
continue outerZIP;
}
}
} finally {
if(out != null) out.close();
}
if(size <= maxArchivedFileSize) {
addStoreElement(ctx, key, name, output, gotElement, element, callback, context);
names.add(name);
trimStoredData();
} else {
// We are here because they asked for this file.
callback.gotBucket(output, context);
gotElement.value = true;
addErrorElement(ctx, key, name, "File too big: "+size+" greater than current archived file size limit "+maxArchivedFileSize, true);
}
}
}
// If no metadata, generate some
if(!gotMetadata) {
generateMetadata(ctx, key, names, gotElement, element, callback, context);
trimStoredData();
}
if(throwAtExit) throw new ArchiveRestartException("Archive changed on re-fetch");
if((!gotElement.value) && element != null)
callback.notInArchive(context);
} catch (IOException e) {
throw new ArchiveFailureException("Error reading archive: "+e.getMessage(), e);
} finally {
if(zis != null) {
try {
zis.close();
} catch (IOException e) {
Logger.error(this, "Failed to close stream: "+e, e);
}
}
}
}
private String stripLeadingSlashes(String name) {
while(name.length() > 1 && name.charAt(0) == '/')
name = name.substring(1);
return name;
}
/**
* Generate fake metadata for an archive which doesn't have any.
* @param ctx The context object.
* @param key The key from which the archive we are unpacking was fetched.
* @param names Set of names in the archive.
* @param element2
* @param gotElement
* @param callbackName If we generate a
* @throws ArchiveFailureException
*/
private ArchiveStoreItem generateMetadata(ArchiveStoreContext ctx, FreenetURI key, Set<String> names, MutableBoolean gotElement, String element2, ArchiveExtractCallback callback, ClientContext context) throws ArchiveFailureException {
/* What we have to do is to:
* - Construct a filesystem tree of the names.
* - Turn each level of the tree into a Metadata object, including those below it, with
* simple manifests and archive internal redirects.
* - Turn the master Metadata object into binary metadata, with all its subsidiaries.
* - Create a .metadata entry containing this data.
*/
// Root directory.
// String -> either itself, or another HashMap
HashMap<String, Object> dir = new HashMap<String, Object>();
for (String name : names) {
addToDirectory(dir, name, "");
}
Metadata metadata = new Metadata(dir, "");
int x = 0;
Bucket bucket = null;
while(true) {
try {
bucket = metadata.toBucket(tempBucketFactory);
return addStoreElement(ctx, key, ".metadata", bucket, gotElement, element2, callback, context);
} catch (MetadataUnresolvedException e) {
try {
x = resolve(e, x, tempBucketFactory, ctx, key, gotElement, element2, callback, context);
} catch (IOException e1) {
throw new ArchiveFailureException("Failed to create metadata: "+e1, e1);
}
} catch (IOException e1) {
Logger.error(this, "Failed to create metadata: "+e1, e1);
throw new ArchiveFailureException("Failed to create metadata: "+e1, e1);
}
}
}
private int resolve(MetadataUnresolvedException e, int x, BucketFactory bf, ArchiveStoreContext ctx, FreenetURI key, MutableBoolean gotElement, String element2, ArchiveExtractCallback callback, ClientContext context) throws IOException, ArchiveFailureException {
for(Metadata m: e.mustResolve) {
try {
addStoreElement(ctx, key, ".metadata-"+(x++), m.toBucket(bf), gotElement, element2, callback, context);
} catch (MetadataUnresolvedException e1) {
x = resolve(e, x, bf, ctx, key, gotElement, element2, callback, context);
continue;
}
}
return x;
}
private void addToDirectory(HashMap<String, Object> dir, String name, String prefix) throws ArchiveFailureException {
int x = name.indexOf('/');
if(x < 0) {
if(dir.containsKey(name)) {
throw new ArchiveFailureException("Invalid archive: contains "+prefix+name+" twice");
}
dir.put(name, name);
} else {
String before = name.substring(0, x);
String after;
if(x == name.length()-1) {
// Last char
after = "";
} else
after = name.substring(x+1, name.length());
Object o = dir.get(before);
if (o == null) {
dir.put(before, o = new HashMap<String, Object>());
} else if (o instanceof String) {
throw new ArchiveFailureException("Invalid archive: contains "+name+" as both file and dir");
}
addToDirectory(Metadata.forceMap(o), after, prefix + before + '/');
}
}
/**
* Add an error element to the cache. This happens when a single file in the archive
* is invalid (usually because it is too large).
* @param ctx The ArchiveStoreContext which must be notified about this element's creation.
* @param key The key from which the archive was fetched.
* @param name The name of the file within the archive.
* @param error The error message to be included on the eventual exception thrown,
* if anyone tries to extract the data for this element.
*/
private void addErrorElement(ArchiveStoreContext ctx, FreenetURI key, String name, String error, boolean tooBig) {
ErrorArchiveStoreItem element = new ErrorArchiveStoreItem(ctx, key, name, error, tooBig);
element.addToContext();
if(logMINOR) Logger.minor(this, "Adding error element: "+element+" for "+key+ ' ' +name);
ArchiveStoreItem oldItem;
synchronized (this) {
oldItem = storedData.get(element.key);
storedData.push(element.key, element);
if(oldItem != null) {
oldItem.close();
cachedData -= oldItem.spaceUsed();
if(logMINOR) Logger.minor(this, "Dropping old store element from archive cache: "+oldItem);
}
}
}
/**
* Add a store element.
* @param callbackName If set, the name of the file for which we must call the callback if this file happens to
* match.
* @param gotElement Flag indicating whether we've already found the file for the callback. If so we must not call
* it again.
* @param callback Callback to be called if we do find it. We must getReaderBucket() before adding the data to the
* LRU, otherwise it may be deleted before it reaches the client.
* @throws ArchiveFailureException If a failure occurred resulting in the data not being readable. Only happens if
* callback != null.
*/
private ArchiveStoreItem addStoreElement(ArchiveStoreContext ctx, FreenetURI key, String name, Bucket temp, MutableBoolean gotElement, String callbackName, ArchiveExtractCallback callback, ClientContext context) throws ArchiveFailureException {
RealArchiveStoreItem element = new RealArchiveStoreItem(ctx, key, name, temp);
element.addToContext();
if(logMINOR) Logger.minor(this, "Adding store element: "+element+" ( "+key+ ' ' +name+" size "+element.spaceUsed()+" )");
ArchiveStoreItem oldItem;
// Let it throw, if it does something is drastically wrong
Bucket matchBucket = null;
if((!gotElement.value) && name.equals(callbackName)) {
matchBucket = element.getReaderBucket();
}
synchronized (this) {
oldItem = storedData.get(element.key);
storedData.push(element.key, element);
cachedData += element.spaceUsed();
if(oldItem != null) {
cachedData -= oldItem.spaceUsed();
if(logMINOR) Logger.minor(this, "Dropping old store element from archive cache: "+oldItem);
oldItem.close();
}
}
if(matchBucket != null) {
callback.gotBucket(matchBucket, context);
gotElement.value = true;
}
return element;
}
/**
* Drop any stored data beyond the limit.
* Call synchronized on storedData.
*/
private void trimStoredData() {
synchronized(this) {
while(true) {
ArchiveStoreItem item;
if(cachedData <= maxCachedData && storedData.size() <= maxCachedElements) return;
if(storedData.isEmpty()) {
// Race condition? cachedData out of sync?
Logger.error(this, "storedData is empty but still over limit: cachedData="+cachedData+" / "+maxCachedData);
return;
}
item = storedData.popValue();
long space = item.spaceUsed();
cachedData -= space;
// Hard limits = delete file within lock, soft limits = delete outside of lock
// Here we use a hard limit
if(logMINOR)
Logger.minor(this, "Dropping "+item+" : cachedData="+cachedData+" of "+maxCachedData+" stored items : "+storedData.size()+" of "+maxCachedElements);
item.close();
}
}
}
}