/*
* 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.cocoon.components.store;
import org.apache.avalon.framework.activity.Disposable;
import org.apache.avalon.framework.component.ComponentException;
import org.apache.avalon.framework.component.ComponentManager;
import org.apache.avalon.framework.component.Composable;
import org.apache.avalon.framework.logger.AbstractLogEnabled;
import org.apache.avalon.framework.parameters.Parameters;
import org.apache.avalon.framework.parameters.ParameterException;
import org.apache.avalon.framework.parameters.Parameterizable;
import org.apache.avalon.framework.thread.ThreadSafe;
import org.apache.cocoon.util.ClassUtils;
import org.apache.cocoon.util.MRUBucketMap;
import java.io.IOException;
import java.net.URLEncoder;
import java.util.Enumeration;
import java.util.NoSuchElementException;
import java.util.Iterator;
import java.util.Map;
/**
* This class provides a cache algorithm for the requested documents.
* It combines a HashMap and a LinkedList to create a so called MRU
* (Most Recently Used) cache.
*
* <p>This implementation is based on MRUBucketMap - map with efficient
* O(1) implementation of MRU removal policy.
*
* <p>TODO: Port improvments to the Excalibur implementation
*
* @deprecated Use the Avalon Excalibur Store instead.
*
* @author <a href="mailto:g-froehlich@gmx.de">Gerhard Froehlich</a>
* @author <a href="mailto:dims@yahoo.com">Davanum Srinivas</a>
* @author <a href="mailto:vgritsenko@apache.org">Vadim Gritsenko</a>
* @version CVS $Id$
*/
public final class MRUMemoryStore extends AbstractLogEnabled
implements Store, Parameterizable, Composable, Disposable, ThreadSafe {
private int maxobjects;
private boolean persistent;
protected MRUBucketMap cache;
private Store persistentStore;
private StoreJanitor storeJanitor;
private ComponentManager manager;
/**
* Get components of the ComponentManager
*
* @param manager The ComponentManager
*/
public void compose(ComponentManager manager) throws ComponentException {
this.manager = manager;
if (getLogger().isDebugEnabled()) {
getLogger().debug("Looking up " + Store.PERSISTENT_CACHE);
getLogger().debug("Looking up " + StoreJanitor.ROLE);
}
this.persistentStore = (Store)manager.lookup(Store.PERSISTENT_CACHE);
this.storeJanitor = (StoreJanitor)manager.lookup(StoreJanitor.ROLE);
}
/**
* Initialize the MRUMemoryStore.
* A few options can be used:
* <UL>
* <LI>maxobjects: Maximum number of objects stored in memory (Default: 100 objects)</LI>
* <LI>use-persistent-cache: Use persistent cache to keep objects persisted after
* container shutdown or not (Default: false)</LI>
* </UL>
*
* @param params Store parameters
* @exception ParameterException
*/
public void parameterize(Parameters params) throws ParameterException {
this.maxobjects = params.getParameterAsInteger("maxobjects", 100);
this.persistent = params.getParameterAsBoolean("use-persistent-cache", false);
if ((this.maxobjects < 1)) {
throw new ParameterException("MRUMemoryStore maxobjects must be at least 1!");
}
this.cache = new MRUBucketMap((int)(this.maxobjects * 1.2));
this.storeJanitor.register(this);
}
/**
* Dispose the component
*/
public void dispose() {
if (this.manager != null) {
getLogger().debug("Disposing component!");
if (this.storeJanitor != null)
this.storeJanitor.unregister(this);
this.manager.release(this.storeJanitor);
this.storeJanitor = null;
// save all cache entries to filesystem
if (this.persistent) {
if (getLogger().isDebugEnabled()) {
getLogger().debug("Final cache size: " + this.cache.size());
}
for (Iterator i = this.cache.keySet().iterator(); i.hasNext(); ) {
Object key = i.next();
try {
Object value = this.cache.remove(key);
if(checkSerializable(value)) {
persistentStore.store(getFileName(key.toString()),
value);
}
} catch (IOException ioe) {
getLogger().error("Error in dispose()", ioe);
}
}
}
this.manager.release(this.persistentStore);
this.persistentStore = null;
}
this.manager = null;
}
/**
* Store the given object in a persistent state. It is up to the
* caller to ensure that the key has a persistent state across
* different JVM executions.
*
* @param key The key for the object to store
* @param value The object to store
*/
public void store(Object key, Object value) {
this.hold(key,value);
}
/**
* This method holds the requested object in a HashMap combined
* with a LinkedList to create the MRU.
* It also stores objects onto the filesystem if configured.
*
* @param key The key of the object to be stored
* @param value The object to be stored
*/
public void hold(Object key, Object value) {
if (getLogger().isDebugEnabled()) {
getLogger().debug("Holding object in memory:");
getLogger().debug(" key: " + key);
getLogger().debug(" value: " + value);
}
/** ...first test if the max. objects in cache is reached... */
while (this.cache.size() >= this.maxobjects) {
/** ...ok, heapsize is reached, remove the last element... */
this.free();
}
/** ..put the new object in the cache, on the top of course ... */
this.cache.put(key, value);
}
/**
* Get the object associated to the given unique key.
*
* @param key The key of the requested object
* @return the requested object
*/
public Object get(Object key) {
Object value = this.cache.get(key);
if (value != null) {
if (getLogger().isDebugEnabled()) {
getLogger().debug("Found key: " + key.toString());
}
return value;
}
if (getLogger().isDebugEnabled()) {
getLogger().debug("NOT Found key: " + key.toString());
}
/** try to fetch from filesystem */
if (this.persistent) {
value = this.persistentStore.get(getFileName(key.toString()));
if (value != null) {
try {
this.hold(key, value);
return value;
} catch (Exception e) {
getLogger().error("Error in hold()!", e);
return null;
}
}
}
return null;
}
/**
* Remove the object associated to the given key.
*
* @param key The key of to be removed object
*/
public void remove(Object key) {
if (getLogger().isDebugEnabled()) {
getLogger().debug("Removing object from store");
getLogger().debug(" key: " + key);
}
this.cache.remove(key);
if(this.persistent && key != null) {
this.persistentStore.remove(getFileName(key.toString()));
}
}
/**
* Indicates if the given key is associated to a contained object.
*
* @param key The key of the object
* @return true if the key exists
*/
public boolean containsKey(Object key) {
return cache.containsKey(key) || (persistent && persistentStore.containsKey(key));
}
/**
* Returns the list of used keys as an Enumeration.
*
* @return the enumeration of the cache
*/
public Enumeration keys() {
return new Enumeration() {
private Iterator i = cache.keySet().iterator();
public boolean hasMoreElements() {
return i.hasNext();
}
public Object nextElement() {
return i.next();
}
};
}
/**
* Returns count of the objects in the store, or -1 if could not be
* obtained.
*/
public int size() {
return this.cache.size();
}
/**
* Frees some of the fast memory used by this store.
* It removes the last element in the store.
*/
public void free() {
try {
if (this.cache.size() > 0) {
// This can throw NoSuchElementException
Map.Entry node = this.cache.removeLast();
if (getLogger().isDebugEnabled()) {
getLogger().debug("Freeing cache.");
getLogger().debug(" key: " + node.getKey());
getLogger().debug(" value: " + node.getValue());
}
if (this.persistent) {
// Swap object on fs.
if(checkSerializable(node.getValue())) {
try {
this.persistentStore.store(
getFileName(node.getKey().toString()), node.getValue());
} catch(Exception e) {
getLogger().error("Error storing object on fs", e);
}
}
}
}
} catch (NoSuchElementException e) {
getLogger().warn("Concurrency error in free()", e);
} catch (Exception e) {
getLogger().error("Error in free()", e);
}
}
/**
* This method checks if an object is seriazable.
*
* @param object The object to be checked
* @return true if the object is storeable
*/
private boolean checkSerializable(Object object) {
if (object == null) return false;
try {
String clazz = object.getClass().getName();
if((clazz.equals("org.apache.cocoon.caching.CachedEventObject"))
|| (clazz.equals("org.apache.cocoon.caching.CachedStreamObject"))
|| (ClassUtils.implementsInterface(clazz, "org.apache.cocoon.caching.CacheValidity"))) {
return true;
} else {
return false;
}
} catch (Exception e) {
getLogger().error("Error in checkSerializable()!", e);
return false;
}
}
/**
* This method puts together a filename for
* the object, which shall be stored on the
* filesystem.
*
* @param key The key of the object
* @return the filename of the key
*/
private String getFileName(String key) {
return URLEncoder.encode(key.toString());
}
}