spring-cache-providers/spring-cache-ehcache/src/main/java/org/apache/archiva/redback/components/cache/ehcache/EhcacheCache.java

package org.apache.archiva.redback.components.cache.ehcache;

/*
 * 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 net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;
import net.sf.ehcache.Status;
import net.sf.ehcache.config.CacheConfiguration;
import net.sf.ehcache.config.Configuration;
import net.sf.ehcache.config.DiskStoreConfiguration;
import net.sf.ehcache.config.MemoryUnit;
import net.sf.ehcache.store.MemoryStoreEvictionPolicy;
import org.apache.archiva.redback.components.cache.CacheStatistics;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

/**
 * EhcacheCache
 * configuration document available <a href="http://www.ehcache.org/documentation/configuration/index">EhcacheUserGuide</a>
 *
 * @author <a href="mailto:joakim@erdfelt.com">Joakim Erdfelt</a>
 */
public class EhcacheCache<V, T>
    implements org.apache.archiva.redback.components.cache.Cache<V, T>
{

    private Logger log = LoggerFactory.getLogger( getClass() );

    class Stats
        implements CacheStatistics
    {
        public void clear()
        {
            // TODO not supported anymore
            //ehcache.getStatistics().clearStatistics();
        }

        public double getCacheHitRate()
        {
            double hits = getCacheHits();
            double miss = getCacheMiss();

            if ( ( hits == 0 ) && ( hits == 0 ) )
            {
                return 0.0;
            }

            return hits / ( hits + miss );
        }

        public long getCacheHits()
        {
            return ehcache.getStatistics().cacheHitCount();//.getCacheHits();
        }

        public long getCacheMiss()
        {
            return ehcache.getStatistics().cacheMissCount();// .getCacheMisses();
        }

        public long getSize()
        {
            //
            return ehcache.getStatistics().getSize();
        }

        public long getInMemorySize()
        {
            return ehcache.getStatistics().getLocalHeapSizeInBytes();
            //return ehcache.calculateInMemorySize();
        }
    }

    /**
     * how often to run the disk store expiry thread. A large number of 120 seconds plus is recommended
     */
    private long diskExpiryThreadIntervalSeconds = 600;

    /**
     * Whether to persist the cache to disk between JVM restarts.
     */
    private boolean diskPersistent = true;

    /**
     * Location on disk for the ehcache store.
     */
    private String diskStorePath = System.getProperty( "java.io.tmpdir" ) + "/ehcache";

    private boolean eternal = false;

    private int maxElementsInMemory = 0;

    private String memoryEvictionPolicy = "LRU";

    private String name = "cache";

    /**
     * Flag indicating when to use the disk store.
     */
    private boolean overflowToDisk = false;

    private int timeToIdleSeconds = 600;

    private int timeToLiveSeconds = 300;

    /**
     * @since 2.0
     */
    private boolean overflowToOffHeap = false;

    /**
     * @since 2.0
     */
    private long maxBytesLocalHeap;

    /**
     * @since 2.0
     */
    private long maxBytesLocalOffHeap;

    private boolean failOnDuplicateCache = false;

    /**
     * @since 2.1
     */
    private int maxElementsOnDisk;

    /**
     * @since 2.1
     */
    //private String persistenceStrategy = PersistenceConfiguration.Strategy.LOCALTEMPSWAP.name();

    /**
     * @since 2.1
     */
    //private boolean synchronousWrites = false;

    private boolean statisticsEnabled = true;

    private CacheManager cacheManager = null;//CacheManager.getInstance();

    private net.sf.ehcache.Cache ehcache;

    private Stats stats;

    public void clear()
    {
        ehcache.removeAll();
        stats.clear();
    }

    @PostConstruct
    public void initialize()
    {
        stats = new Stats();

        boolean cacheManagerExists = CacheManager.getCacheManager( getName() ) != null;

        if ( cacheManagerExists )
        {
            if ( failOnDuplicateCache )
            {
                throw new RuntimeException( "A previous cacheManager with name [" + getName() + "] exists." );
            }
            else
            {
                log.warn( "skip duplicate cache {}", getName() );
                cacheManager = CacheManager.getCacheManager( getName() );
            }
        }
        else
        {
            this.cacheManager = new CacheManager( new Configuration().name( getName() ).diskStore(
                new DiskStoreConfiguration().path( getDiskStorePath() ) ) );
        }

        boolean cacheExists = cacheManager.cacheExists( getName() );

        if ( cacheExists )
        {
            if ( failOnDuplicateCache )
            {
                throw new RuntimeException( "A previous cache with name [" + getName() + "] exists." );
            }
            else
            {
                log.warn( "skip duplicate cache {}", getName() );
                ehcache = cacheManager.getCache( getName() );
            }
        }

        if ( !cacheExists )
        {
            CacheConfiguration cacheConfiguration =
                new CacheConfiguration().name( getName() ).memoryStoreEvictionPolicy(
                    getMemoryStoreEvictionPolicy() ).eternal( isEternal() ).timeToLiveSeconds(
                    getTimeToLiveSeconds() ).timeToIdleSeconds(
                    getTimeToIdleSeconds() ).diskExpiryThreadIntervalSeconds(
                    getDiskExpiryThreadIntervalSeconds() ).overflowToOffHeap(
                    isOverflowToOffHeap() ).maxEntriesLocalDisk( getMaxElementsOnDisk() ).diskPersistent(
                    isDiskPersistent() ).overflowToDisk( overflowToDisk );

            if ( getMaxElementsInMemory() > 0 )
            {
                cacheConfiguration = cacheConfiguration.maxEntriesLocalHeap( getMaxElementsInMemory() );
            }

            if ( getMaxBytesLocalHeap() > 0 )
            {
                cacheConfiguration = cacheConfiguration.maxBytesLocalHeap( getMaxBytesLocalHeap(), MemoryUnit.BYTES );
            }
            if ( getMaxBytesLocalOffHeap() > 0 )
            {
                cacheConfiguration =
                    cacheConfiguration.maxBytesLocalOffHeap( getMaxBytesLocalOffHeap(), MemoryUnit.BYTES );
            }

            ehcache = new Cache( cacheConfiguration );

            cacheManager.addCache( ehcache );
            // TODO not supported anymore?
            //ehcache.setStatisticsEnabled( statisticsEnabled );
        }
    }

    @PreDestroy
    public void dispose()
    {
        if ( cacheManager.getStatus().equals( Status.STATUS_ALIVE ) )
        {
            log.info( "Disposing cache: {}", ehcache );
            if ( this.ehcache != null )
            {
                cacheManager.removeCache( this.ehcache.getName() );
                ehcache = null;
            }
        }
        else
        {
            log.debug( "Not disposing cache, because cacheManager is not alive: {}", ehcache );
        }
    }

    public T get( V key )
    {
        if ( key == null )
        {
            return null;
        }

        Element elem = ehcache.get( key );
        if ( elem == null )
        {
            return null;
        }
        return (T) elem.getObjectValue();
    }

    public long getDiskExpiryThreadIntervalSeconds()
    {
        return diskExpiryThreadIntervalSeconds;
    }

    public String getDiskStorePath()
    {
        return diskStorePath;
    }

    public int getMaxElementsInMemory()
    {
        return maxElementsInMemory;
    }

    public String getMemoryEvictionPolicy()
    {
        return memoryEvictionPolicy;
    }

    public MemoryStoreEvictionPolicy getMemoryStoreEvictionPolicy()
    {
        return MemoryStoreEvictionPolicy.fromString( memoryEvictionPolicy );
    }

    public String getName()
    {
        return name;
    }

    public CacheStatistics getStatistics()
    {
        return stats;
    }

    public int getTimeToIdleSeconds()
    {
        return timeToIdleSeconds;
    }

    public int getTimeToLiveSeconds()
    {
        return timeToLiveSeconds;
    }

    public boolean hasKey( V key )
    {
        return ehcache.isKeyInCache( key );
    }

    public boolean isDiskPersistent()
    {
        return diskPersistent;
    }

    public boolean isEternal()
    {
        return eternal;
    }

    public boolean isOverflowToDisk()
    {
        return overflowToDisk;
    }

    public void register( V key, T value )
    {
        ehcache.put( new Element( key, value ) );
    }

    public T put( V key, T value )
    {
        // Multiple steps done to satisfy Cache API requirement for Previous object return.
        Element elem = null;
        Object previous = null;
        elem = ehcache.get( key );
        if ( elem != null )
        {
            previous = elem.getObjectValue();
        }
        elem = new Element( key, value );
        ehcache.put( elem );
        return (T) previous;
    }

    public T remove( V key )
    {
        Element elem = null;
        Object previous = null;
        elem = ehcache.get( key );
        if ( elem != null )
        {
            previous = elem.getObjectValue();
            ehcache.remove( key );
        }

        return (T) previous;
    }

    public void setDiskExpiryThreadIntervalSeconds( long diskExpiryThreadIntervalSeconds )
    {
        this.diskExpiryThreadIntervalSeconds = diskExpiryThreadIntervalSeconds;
    }

    public void setDiskPersistent( boolean diskPersistent )
    {
        this.diskPersistent = diskPersistent;
    }

    public void setDiskStorePath( String diskStorePath )
    {
        this.diskStorePath = diskStorePath;
    }

    public void setEternal( boolean eternal )
    {
        this.eternal = eternal;
    }


    public void setMaxElementsInMemory( int maxElementsInMemory )
    {
        this.maxElementsInMemory = maxElementsInMemory;
        if ( this.ehcache != null )
        {
            this.ehcache.getCacheConfiguration().setMaxElementsInMemory( this.maxElementsInMemory );
            this.ehcache.getCacheConfiguration().setMaxEntriesLocalHeap( this.maxElementsInMemory );

        }
    }

    public void setMemoryEvictionPolicy( String memoryEvictionPolicy )
    {
        this.memoryEvictionPolicy = memoryEvictionPolicy;
    }

    public void setName( String name )
    {
        this.name = name;
    }

    public void setOverflowToDisk( boolean overflowToDisk )
    {
        this.overflowToDisk = overflowToDisk;
    }

    public void setTimeToIdleSeconds( int timeToIdleSeconds )
    {
        if ( this.ehcache != null )
        {
            this.ehcache.getCacheConfiguration().setTimeToIdleSeconds( timeToIdleSeconds );
        }
        this.timeToIdleSeconds = timeToIdleSeconds;
    }

    public void setTimeToLiveSeconds( int timeToLiveSeconds )
    {
        if ( this.ehcache != null )
        {
            this.ehcache.getCacheConfiguration().setTimeToLiveSeconds( timeToIdleSeconds );
        }
        this.timeToLiveSeconds = timeToLiveSeconds;
    }

    public boolean isStatisticsEnabled()
    {
        return statisticsEnabled;
    }

    public void setStatisticsEnabled( boolean statisticsEnabled )
    {
        this.statisticsEnabled = statisticsEnabled;
    }

    public boolean isFailOnDuplicateCache()
    {
        return failOnDuplicateCache;
    }

    public void setFailOnDuplicateCache( boolean failOnDuplicateCache )
    {
        this.failOnDuplicateCache = failOnDuplicateCache;
    }

    public boolean isOverflowToOffHeap()
    {
        return overflowToOffHeap;
    }

    public void setOverflowToOffHeap( boolean overflowToOffHeap )
    {
        this.overflowToOffHeap = overflowToOffHeap;
    }

    public long getMaxBytesLocalHeap()
    {
        return maxBytesLocalHeap;
    }

    public void setMaxBytesLocalHeap( long maxBytesLocalHeap )
    {
        this.maxBytesLocalHeap = maxBytesLocalHeap;
    }

    public long getMaxBytesLocalOffHeap()
    {
        return maxBytesLocalOffHeap;
    }

    public void setMaxBytesLocalOffHeap( long maxBytesLocalOffHeap )
    {
        this.maxBytesLocalOffHeap = maxBytesLocalOffHeap;
    }

    public int getMaxElementsOnDisk()
    {
        return maxElementsOnDisk;
    }

    public void setMaxElementsOnDisk( int maxElementsOnDisk )
    {
        this.maxElementsOnDisk = maxElementsOnDisk;
        if ( this.ehcache != null )
        {
            this.ehcache.getCacheConfiguration().setMaxElementsOnDisk( this.maxElementsOnDisk );
            this.ehcache.getCacheConfiguration().maxEntriesLocalDisk( this.maxElementsOnDisk );
        }
    }

    /*public String getPersistenceStrategy()
    {
        return persistenceStrategy;
    }

    public void setPersistenceStrategy( String persistenceStrategy )
    {
        this.persistenceStrategy = persistenceStrategy;
    }

    public boolean isSynchronousWrites()
    {
        return synchronousWrites;
    }

    public void setSynchronousWrites( boolean synchronousWrites )
    {
        this.synchronousWrites = synchronousWrites;
    }*/
}