package org.apache.archiva.redback.components.cache.oscache;
/*
* 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 com.opensymphony.oscache.base.CacheEntry;
import com.opensymphony.oscache.base.NeedsRefreshException;
import com.opensymphony.oscache.general.GeneralCacheAdministrator;
import org.apache.archiva.redback.components.cache.AbstractCache;
import org.apache.archiva.redback.components.cache.Cache;
import org.apache.archiva.redback.components.cache.CacheStatistics;
import javax.annotation.PostConstruct;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
/**
* For configuration see documentation : http://opensymphony.com/oscache/wiki/Configuration.html
*
* @author @author Olivier Lamy
*/
public class OsCacheCache<V, T>
extends AbstractCache<V, T>
implements Cache<V, T>
{
private GeneralCacheAdministrator generalCacheAdministrator;
private OsCacheStatistics osCacheStatistics;
//---------------------------------------------
// Configuration attributes
//---------------------------------------------
/**
* use memory cache
*/
private boolean cacheMemory = true;
/**
* maximum item numbers default value -1 means unlimited
*/
private int capacity = -1;
/**
* cache algorithm
*/
private String cacheAlgorithm;
/**
*
*/
private boolean blockingCache = false;
/**
*
*/
private boolean cacheUnlimitedDisk = false;
/**
*
*/
private String cachePersistenceClass;
/**
*
*/
private String cachePath;
/**
*
*/
private boolean cachePersistenceOverflowOnly = false;
/**
* A default one will be added to provided CacheStatistics
*/
private List cacheEventListeners;
/**
*
*/
private String cacheKey;
/**
*
*/
private boolean cacheUseHostDomainInKey = false;
/**
* in order to add some other osCache properties
*/
private Map additionnalProperties;
/**
* default Value {@link CacheEntry#INDEFINITE_EXPIRY}
*/
private int refreshPeriod = CacheEntry.INDEFINITE_EXPIRY;
//---------------------------------------------
// Component lifecycle
//---------------------------------------------
@PostConstruct
public void initialize()
{
Properties cacheProperties = new Properties();
if ( this.getAdditionnalProperties() != null )
{
cacheProperties.putAll( this.getAdditionnalProperties() );
}
if ( this.getCacheAlgorithm() != null )
{
cacheProperties.put( GeneralCacheAdministrator.CACHE_ALGORITHM_KEY, this.getCacheAlgorithm() );
}
cacheProperties.put( GeneralCacheAdministrator.CACHE_BLOCKING_KEY, Boolean.toString( this.isBlockingCache() ) );
cacheProperties.put( GeneralCacheAdministrator.CACHE_CAPACITY_KEY, Integer.toString( this.getCapacity() ) );
cacheProperties.put( GeneralCacheAdministrator.CACHE_DISK_UNLIMITED_KEY,
Boolean.toString( this.isCacheUnlimitedDisk() ) );
String cacheEventListenersAsString = this.getCacheEventListenersAsString();
if ( cacheEventListenersAsString != null )
{
cacheProperties.put( GeneralCacheAdministrator.CACHE_ENTRY_EVENT_LISTENERS_KEY,
cacheEventListenersAsString );
}
cacheProperties.put( GeneralCacheAdministrator.CACHE_MEMORY_KEY, Boolean.toString( this.isCacheMemory() ) );
cacheProperties.put( GeneralCacheAdministrator.CACHE_PERSISTENCE_OVERFLOW_KEY,
Boolean.toString( this.isCachePersistenceOverflowOnly() ) );
if ( this.getCachePersistenceClass() != null )
{
cacheProperties.put( GeneralCacheAdministrator.PERSISTENCE_CLASS_KEY, this.getCachePersistenceClass() );
}
cacheProperties.put( "cache.unlimited.disk", Boolean.toString( this.isCacheUnlimitedDisk() ) );
if ( this.getCachePath() != null )
{
cacheProperties.put( "cache.path", this.getCachePath() );
}
if ( this.getCacheKey() != null )
{
cacheProperties.put( "cache.key", this.getCacheKey() );
}
cacheProperties.put( "cache.use.host.domain.in.key", Boolean.toString( this.isCacheUseHostDomainInKey() ) );
this.generalCacheAdministrator = new GeneralCacheAdministrator( cacheProperties );
this.osCacheStatistics = new OsCacheStatistics( this.generalCacheAdministrator.getCache() );
}
//---------------------------------------------
// Interface implementation
//---------------------------------------------
public void clear()
{
this.generalCacheAdministrator.flushAll();
}
public T get( V key )
{
try
{
T object = null;
if ( this.getRefreshPeriod() >= 0 )
{
object = (T) this.generalCacheAdministrator.getFromCache( key.toString(), this.getRefreshPeriod() );
}
else
{
object = (T) this.generalCacheAdministrator.getFromCache( key.toString() );
}
if ( object != null )
{
this.osCacheStatistics.hit();
}
else
{
this.osCacheStatistics.miss();
}
return object;
}
catch ( NeedsRefreshException e )
{
this.generalCacheAdministrator.cancelUpdate( key.toString() );
this.osCacheStatistics.miss();
return null;
}
}
public CacheStatistics getStatistics()
{
// osCacheStatistics to update ??
return this.osCacheStatistics;
}
public boolean hasKey( V key )
{
// TODO if null increase/decrease statistics ?
return this.get( key ) == null;
}
public void register( V key, T value )
{
this.generalCacheAdministrator.putInCache( key.toString(), value );
}
public T put( V key, T value )
{
Object previous = null;
try
{
previous = this.generalCacheAdministrator.getFromCache( key.toString(), this.getRefreshPeriod() );
}
catch ( NeedsRefreshException e )
{
// ignore this because the content will be updated
}
this.generalCacheAdministrator.putInCache( key.toString(), value );
return (T) previous;
}
public T remove( V key )
{
Object previous = null;
try
{
previous = this.generalCacheAdministrator.getFromCache( key.toString(), this.getRefreshPeriod() );
}
catch ( NeedsRefreshException e )
{
// ignore this because the content will be updated
}
this.generalCacheAdministrator.cancelUpdate( key.toString() );
this.generalCacheAdministrator.flushEntry( key.toString() );
return (T) previous;
}
//---------------------------------------------
// getters/setters
//---------------------------------------------
public Map getAdditionnalProperties()
{
return additionnalProperties;
}
public void setAdditionnalProperties( Map additionnalProperties )
{
this.additionnalProperties = additionnalProperties;
}
public boolean isBlockingCache()
{
return blockingCache;
}
public void setBlockingCache( boolean blockingCache )
{
this.blockingCache = blockingCache;
}
public String getCacheAlgorithm()
{
return cacheAlgorithm == null ? "com.opensymphony.oscache.base.algorithm.UnlimitedCache" : cacheAlgorithm;
}
public void setCacheAlgorithm( String cacheAlgorithm )
{
this.cacheAlgorithm = cacheAlgorithm;
}
public List getCacheEventListeners()
{
return cacheEventListeners;
}
/**
* @return list values in a String separated with comma
*/
private String getCacheEventListenersAsString()
{
if ( this.getCacheEventListeners() == null )
{
return null;
}
if ( this.getCacheEventListeners().isEmpty() )
{
return null;
}
StringBuilder stringBuffer = new StringBuilder();
for ( Iterator iterator = this.getCacheEventListeners().iterator(); iterator.hasNext(); )
{
stringBuffer.append( iterator.next() ).append( ',' );
}
return stringBuffer.toString().substring( 0, stringBuffer.toString().length() - 1 );
}
public void setCacheEventListeners( List cacheEventListeners )
{
this.cacheEventListeners = cacheEventListeners;
}
public String getCacheKey()
{
return cacheKey == null ? "cacheKey" : cacheKey;
}
public void setCacheKey( String cacheKey )
{
this.cacheKey = cacheKey;
}
public boolean isCacheMemory()
{
return cacheMemory;
}
public void setCacheMemory( boolean cacheMemory )
{
this.cacheMemory = cacheMemory;
}
public String getCachePath()
{
return cachePath;
}
public void setCachePath( String cachePath )
{
this.cachePath = cachePath;
}
public String getCachePersistenceClass()
{
return cachePersistenceClass;
}
public void setCachePersistenceClass( String cachePersistenceClass )
{
this.cachePersistenceClass = cachePersistenceClass;
}
public boolean isCachePersistenceOverflowOnly()
{
return cachePersistenceOverflowOnly;
}
public void setCachePersistenceOverflowOnly( boolean cachePersistenceOverflowOnly )
{
this.cachePersistenceOverflowOnly = cachePersistenceOverflowOnly;
}
public boolean isCacheUnlimitedDisk()
{
return cacheUnlimitedDisk;
}
public void setCacheUnlimitedDisk( boolean cacheUnlimitedDisk )
{
this.cacheUnlimitedDisk = cacheUnlimitedDisk;
}
public boolean isCacheUseHostDomainInKey()
{
return cacheUseHostDomainInKey;
}
public void setCacheUseHostDomainInKey( boolean cacheUseHostDomainInKey )
{
this.cacheUseHostDomainInKey = cacheUseHostDomainInKey;
}
public int getCapacity()
{
return capacity;
}
public void setCapacity( int capacity )
{
this.capacity = capacity;
}
public GeneralCacheAdministrator getGeneralCacheAdministrator()
{
return generalCacheAdministrator;
}
public void setGeneralCacheAdministrator( GeneralCacheAdministrator generalCacheAdministrator )
{
this.generalCacheAdministrator = generalCacheAdministrator;
}
public int getRefreshPeriod()
{
return refreshPeriod;
}
public void setRefreshPeriod( int refreshPeriod )
{
this.refreshPeriod = refreshPeriod;
}
}