package org.apache.commons.jcs.admin;
/*
* 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.
*/
import org.apache.commons.jcs.access.exception.CacheException;
import org.apache.commons.jcs.auxiliary.remote.server.RemoteCacheServer;
import org.apache.commons.jcs.auxiliary.remote.server.RemoteCacheServerFactory;
import org.apache.commons.jcs.engine.CacheElementSerialized;
import org.apache.commons.jcs.engine.behavior.ICacheElement;
import org.apache.commons.jcs.engine.behavior.IElementAttributes;
import org.apache.commons.jcs.engine.control.CompositeCache;
import org.apache.commons.jcs.engine.control.CompositeCacheManager;
import org.apache.commons.jcs.engine.memory.behavior.IMemoryCache;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.text.DateFormat;
import java.util.Arrays;
import java.util.Date;
import java.util.LinkedList;
import java.util.Set;
/**
* A servlet which provides HTTP access to JCS. Allows a summary of regions to be viewed, and
* removeAll to be run on individual regions or all regions. Also provides the ability to remove
* items (any number of key arguments can be provided with action 'remove'). Should be initialized
* with a properties file that provides at least a classpath resource loader.
*/
public class JCSAdminBean implements JCSJMXBean
{
/** The cache manager. */
private final CompositeCacheManager cacheHub;
/**
* Default constructor
*/
public JCSAdminBean()
{
super();
try
{
this.cacheHub = CompositeCacheManager.getInstance();
}
catch (CacheException e)
{
throw new RuntimeException("Could not retrieve cache manager instance", e);
}
}
/**
* Parameterized constructor
*
* @param cacheHub the cache manager instance
*/
public JCSAdminBean(CompositeCacheManager cacheHub)
{
super();
this.cacheHub = cacheHub;
}
/**
* Builds up info about each element in a region.
* <p>
* @param cacheName
* @return Array of CacheElementInfo objects
* @throws Exception
*/
@Override
public CacheElementInfo[] buildElementInfo( String cacheName )
throws Exception
{
CompositeCache<Serializable, Serializable> cache = cacheHub.getCache( cacheName );
Serializable[] keys = cache.getMemoryCache().getKeySet().toArray(new Serializable[0]);
// Attempt to sort keys according to their natural ordering. If that
// fails, get the key array again and continue unsorted.
try
{
Arrays.sort( keys );
}
catch ( Exception e )
{
keys = cache.getMemoryCache().getKeySet().toArray(new Serializable[0]);
}
LinkedList<CacheElementInfo> records = new LinkedList<CacheElementInfo>();
ICacheElement<Serializable, Serializable> element;
IElementAttributes attributes;
CacheElementInfo elementInfo;
DateFormat format = DateFormat.getDateTimeInstance( DateFormat.SHORT, DateFormat.SHORT );
long now = System.currentTimeMillis();
for (Serializable key : keys)
{
element = cache.getMemoryCache().getQuiet( key );
attributes = element.getElementAttributes();
elementInfo = new CacheElementInfo(
String.valueOf( key ),
attributes.getIsEternal(),
format.format(new Date(attributes.getCreateTime())),
attributes.getMaxLife(),
(now - attributes.getCreateTime() - attributes.getMaxLife() * 1000 ) / -1000);
records.add( elementInfo );
}
return records.toArray(new CacheElementInfo[0]);
}
/**
* Builds up data on every region.
* <p>
* TODO we need a most light weight method that does not count bytes. The byte counting can
* really swamp a server.
* @return list of CacheRegionInfo objects
* @throws Exception
*/
@Override
public CacheRegionInfo[] buildCacheInfo()
throws Exception
{
String[] cacheNames = cacheHub.getCacheNames();
Arrays.sort( cacheNames );
LinkedList<CacheRegionInfo> cacheInfo = new LinkedList<CacheRegionInfo>();
CacheRegionInfo regionInfo;
CompositeCache<?, ?> cache;
for ( int i = 0; i < cacheNames.length; i++ )
{
cache = cacheHub.getCache( cacheNames[i] );
regionInfo = new CacheRegionInfo(
cache.getCacheName(),
cache.getSize(),
cache.getStatus().toString(),
cache.getStats(),
cache.getHitCountRam(),
cache.getHitCountAux(),
cache.getMissCountNotFound(),
cache.getMissCountExpired(),
getByteCount( cache ));
cacheInfo.add( regionInfo );
}
return cacheInfo.toArray(new CacheRegionInfo[0]);
}
/**
* Tries to estimate how much data is in a region. This is expensive. If there are any non serializable objects in
* the region or an error occurs, suppresses exceptions and returns 0.
* <p>
*
* @return int The size of the region in bytes.
*/
@Override
public int getByteCount(String cacheName)
{
return getByteCount(cacheHub.getCache(cacheName));
}
/**
* Tries to estimate how much data is in a region. This is expensive. If there are any non serializable objects in
* the region or an error occurs, suppresses exceptions and returns 0.
* <p>
*
* @return int The size of the region in bytes.
*/
public <K, V> int getByteCount(CompositeCache<K, V> cache)
{
if (cache == null)
{
throw new IllegalArgumentException("The cache object specified was null.");
}
long size = 0;
IMemoryCache<K, V> memCache = cache.getMemoryCache();
for (K key : memCache.getKeySet())
{
ICacheElement<K, V> ice = null;
try
{
ice = memCache.get(key);
}
catch (IOException e)
{
throw new RuntimeException("IOException while trying to get a cached element", e);
}
if (ice == null)
{
continue;
}
if (ice instanceof CacheElementSerialized)
{
size = size + ((CacheElementSerialized<K, V>) ice).getSerializedValue().length;
}
else
{
Object element = ice.getVal();
//CountingOnlyOutputStream: Keeps track of the number of bytes written to it, but doesn't write them anywhere.
CountingOnlyOutputStream counter = new CountingOnlyOutputStream();
ObjectOutputStream out = null;
try
{
out = new ObjectOutputStream(counter);
out.writeObject(element);
}
catch (IOException e)
{
throw new RuntimeException("IOException while trying to measure the size of the cached element", e);
}
finally
{
try
{
if (out != null)
{
out.close();
}
}
catch (IOException e)
{
// ignore
}
try
{
counter.close();
}
catch (IOException e)
{
// ignore
}
}
// 4 bytes lost for the serialization header
size = size + counter.getCount() - 4;
}
}
if (size > Integer.MAX_VALUE)
{
throw new IllegalStateException("The size of cache " + cache.getCacheName() + " (" + size + " bytes) is too large to be represented as an integer.");
}
return (int) size;
}
/**
* Clears all regions in the cache.
* <p>
* If this class is running within a remote cache server, clears all regions via the <code>RemoteCacheServer</code>
* API, so that removes will be broadcast to client machines. Otherwise clears all regions in the cache directly via
* the usual cache API.
*/
@Override
public void clearAllRegions() throws IOException
{
if (RemoteCacheServerFactory.getRemoteCacheServer() == null)
{
// Not running in a remote cache server.
// Remove objects from the cache directly, as no need to broadcast removes to client machines...
String[] names = cacheHub.getCacheNames();
for (int i = 0; i < names.length; i++)
{
cacheHub.getCache(names[i]).removeAll();
}
}
else
{
// Running in a remote cache server.
// Remove objects via the RemoteCacheServer API, so that removes will be broadcast to client machines...
try
{
String[] cacheNames = cacheHub.getCacheNames();
// Call remoteCacheServer.removeAll(String) for each cacheName...
RemoteCacheServer<?, ?> remoteCacheServer = RemoteCacheServerFactory.getRemoteCacheServer();
for (int i = 0; i < cacheNames.length; i++)
{
String cacheName = cacheNames[i];
remoteCacheServer.removeAll(cacheName);
}
}
catch (IOException e)
{
throw new IllegalStateException("Failed to remove all elements from all cache regions: " + e, e);
}
}
}
/**
* Clears a particular cache region.
* <p>
* If this class is running within a remote cache server, clears the region via the <code>RemoteCacheServer</code>
* API, so that removes will be broadcast to client machines. Otherwise clears the region directly via the usual
* cache API.
*/
@Override
public void clearRegion(String cacheName) throws IOException
{
if (cacheName == null)
{
throw new IllegalArgumentException("The cache name specified was null.");
}
if (RemoteCacheServerFactory.getRemoteCacheServer() == null)
{
// Not running in a remote cache server.
// Remove objects from the cache directly, as no need to broadcast removes to client machines...
cacheHub.getCache(cacheName).removeAll();
}
else
{
// Running in a remote cache server.
// Remove objects via the RemoteCacheServer API, so that removes will be broadcast to client machines...
try
{
// Call remoteCacheServer.removeAll(String)...
RemoteCacheServer<?, ?> remoteCacheServer = RemoteCacheServerFactory.getRemoteCacheServer();
remoteCacheServer.removeAll(cacheName);
}
catch (IOException e)
{
throw new IllegalStateException("Failed to remove all elements from cache region [" + cacheName + "]: " + e, e);
}
}
}
/**
* Removes a particular item from a particular region.
* <p>
* If this class is running within a remote cache server, removes the item via the <code>RemoteCacheServer</code>
* API, so that removes will be broadcast to client machines. Otherwise clears the region directly via the usual
* cache API.
*
* @param cacheName
* @param key
*
* @throws IOException
*/
@Override
public void removeItem(String cacheName, String key) throws IOException
{
if (cacheName == null)
{
throw new IllegalArgumentException("The cache name specified was null.");
}
if (key == null)
{
throw new IllegalArgumentException("The key specified was null.");
}
if (RemoteCacheServerFactory.getRemoteCacheServer() == null)
{
// Not running in a remote cache server.
// Remove objects from the cache directly, as no need to broadcast removes to client machines...
cacheHub.getCache(cacheName).remove(key);
}
else
{
// Running in a remote cache server.
// Remove objects via the RemoteCacheServer API, so that removes will be broadcast to client machines...
try
{
Object keyToRemove = null;
CompositeCache<?, ?> cache = CompositeCacheManager.getInstance().getCache(cacheName);
// A String key was supplied, but to remove elements via the RemoteCacheServer API, we need the
// actual key object as stored in the cache (i.e. a Serializable object). To find the key in this form,
// we iterate through all keys stored in the memory cache until we find one whose toString matches
// the string supplied...
Set<?> allKeysInCache = cache.getMemoryCache().getKeySet();
for (Object keyInCache : allKeysInCache)
{
if (keyInCache.toString().equals(key))
{
if (keyToRemove == null)
{
keyToRemove = keyInCache;
}
else
{
// A key matching the one specified was already found...
throw new IllegalStateException("Unexpectedly found duplicate keys in the cache region matching the key specified.");
}
}
}
if (keyToRemove == null)
{
throw new IllegalStateException("No match for this key could be found in the set of keys retrieved from the memory cache.");
}
// At this point, we have retrieved the matching K key.
// Call remoteCacheServer.remove(String, Serializable)...
RemoteCacheServer<Serializable, Serializable> remoteCacheServer = RemoteCacheServerFactory.getRemoteCacheServer();
remoteCacheServer.remove(cacheName, key);
}
catch (Exception e)
{
throw new IllegalStateException("Failed to remove element with key [" + key + ", " + key.getClass() + "] from cache region [" + cacheName + "]: " + e, e);
}
}
}
}