Fixed bug when loading entries via a Callable was overseen when a CacheLoader was used. Added further tests to cover this bug for the future.

Author: rafwin

README

@@ -1,2 +1,19 @@
 A Guava cache extension that allows caches to persist cache entries when they cannot longer be stored in memory.
-An implementation that overflows to the file system is provided.
+An implementation that overflows to the file system is provided including a corresponding CacheBuilder with similar semantics than the Guava CacheBuilder.
+
+For creating a cache that overflows to disk, just proceed as when using the Guava CacheBuilder:
+
+Cache<String, String> stringCache =
+  FileSystemCacheBuilder.newBuilder()
+    .maximumSize(100L)
+    .softValues()
+    .build();
+
+Note: This cache implementation has slightly different semantics than the Cache / LoadingCache interface contracts specify:
+* Any limits set for this cache do only concern the cache's memory size. Cache entries exceeding this limit will overflow to disk.
+* When calling the non-argument invalidateAll() method, the RemovalListener is only informed about the expiration of entries that
+  are still stored in memory.
+* When the cache is not longer in use, its invalidateAll() method should be called if the cache's overflow folder is not cleared by
+  the operating system.
+
+Licensed under the Apache Software License, Version 2.0

pom.xml

@@ -15,8 +15,8 @@
         <url>http://www.kantega.no</url>
     </organization>
 
-    <name>Limber web framework</name>
-    <description>A web framework based on DOM manipulation.</description>
+    <name>Guava cache overflow extension</name>
+    <description>An extension to Guava caches that allows cache entries to overflow to disk.</description>
     <url>http://www.kantega.no</url>
 
     <properties>

src/main/java/no/kantega/lab/guava/cache/AbstractLoadingPersistingCache.java

@@ -0,0 +1,81 @@
+package no.kantega.lab.guava.cache;
+
+import com.google.common.cache.CacheBuilder;
+import com.google.common.cache.CacheLoader;
+import com.google.common.cache.LoadingCache;
+import com.google.common.cache.RemovalListener;
+import com.google.common.collect.ImmutableMap;
+
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+
+public abstract class AbstractLoadingPersistingCache<K, V> extends AbstractPersistingCache<K, V> implements LoadingCache<K, V> {
+
+    private final CacheLoader<K, V> cacheLoader;
+
+    protected AbstractLoadingPersistingCache(CacheBuilder<Object, Object> cacheBuilder, CacheLoader<K, V> cacheLoader) {
+        this(cacheBuilder, cacheLoader, null);
+    }
+
+    protected AbstractLoadingPersistingCache(CacheBuilder<Object, Object> cacheBuilder, CacheLoader<K, V> cacheLoader, RemovalListener<K, V> removalListener) {
+        super(cacheBuilder, removalListener);
+        this.cacheLoader = cacheLoader;
+    }
+
+    private class ValueLoaderFromCacheLoader implements Callable<V> {
+
+        private final K key;
+        private final CacheLoader<K, V> cacheLoader;
+
+        private ValueLoaderFromCacheLoader(CacheLoader<K, V> cacheLoader, K key) {
+            this.key = key;
+            this.cacheLoader = cacheLoader;
+        }
+
+        @Override
+        public V call() throws Exception {
+            return cacheLoader.load(key);
+        }
+    }
+
+    @Override
+    public V get(K key) throws ExecutionException {
+        return get(key, new ValueLoaderFromCacheLoader(cacheLoader, key));
+    }
+
+    @Override
+    public V getUnchecked(K key) {
+        try {
+            return get(key, new ValueLoaderFromCacheLoader(cacheLoader, key));
+        } catch (ExecutionException e) {
+            throw new RuntimeException(e.getCause());
+        }
+    }
+
+    @Override
+    public ImmutableMap<K, V> getAll(Iterable<? extends K> keys) throws ExecutionException {
+        ImmutableMap.Builder<K, V> all = ImmutableMap.builder();
+        for (K key : keys) {
+            all.put(key, get(key));
+        }
+        return all.build();
+    }
+
+    @Override
+    public V apply(K key) {
+        try {
+            return cacheLoader.load(key);
+        } catch (Exception e) {
+            throw new RuntimeException(String.format("Could not apply cache on key %s", key), e);
+        }
+    }
+
+    @Override
+    public void refresh(K key) {
+        try {
+            getUnderlyingCache().put(key, cacheLoader.load(key));
+        } catch (Exception e) {
+            throw new RuntimeException(String.format("Could not refresh value for key %s", key), e);
+        }
+    }
+}

src/main/java/no/kantega/lab/guava/cache/AbstractPersistingCache.java

@@ -8,7 +8,6 @@
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
-import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.Callable;
@@ -20,13 +19,21 @@ public abstract class AbstractPersistingCache<K, V> implements Cache<K, V> {
     private static final Logger LOGGER = LoggerFactory.getLogger(AbstractPersistingCache.class);
 
     private final LoadingCache<K, V> underlyingCache;
+    private final RemovalListener<K, V> removalListener;
 
     protected AbstractPersistingCache(CacheBuilder<Object, Object> cacheBuilder) {
+        this(cacheBuilder, null);
+    }
+
+    protected AbstractPersistingCache(CacheBuilder<Object, Object> cacheBuilder, RemovalListener<K, V> removalListener) {
         this.underlyingCache = makeCache(cacheBuilder);
+        this.removalListener = removalListener;
     }
 
     private LoadingCache<K, V> makeCache(CacheBuilder<Object, Object> cacheBuilder) {
-        return cacheBuilder.removalListener(new PersistingRemovalListener()).build(new PersistedStateCacheLoader());
+        return cacheBuilder
+                .removalListener(new PersistingRemovalListener())
+                .build(new PersistedStateCacheLoader());
     }
 
     private class PersistingRemovalListener implements RemovalListener<K, V> {
@@ -39,6 +46,8 @@ public void onRemoval(RemovalNotification<K, V> notification) {
                     LOGGER.warn(String.format("Could not persist value %s to key %s",
                             notification.getKey(), notification.getValue()), e);
                 }
+            } else if (removalListener != null) {
+                removalListener.onRemoval(notification);
             }
         }
     }
@@ -76,13 +85,19 @@ private PersistedStateValueLoader(K key, Callable<? extends V> valueLoader) {
 
         @Override
         public V call() throws Exception {
-            V value = load(key);
+            V value;
+            try {
+                value = load(key);
+            } catch (NotPersistedException e) {
+                value = null;
+            }
             if (value != null) return value;
             return valueLoader.call();
         }
     }
 
     protected boolean isPersistenceRelevant(RemovalCause removalCause) {
+        // Note: RemovalCause#wasEvicted is package private
         return removalCause != RemovalCause.EXPLICIT
                 && removalCause != RemovalCause.REPLACED;
     }
@@ -136,12 +151,12 @@ public V get(K key, Callable<? extends V> valueLoader) throws ExecutionException
     @Override
     @SuppressWarnings("unchecked")
     public ImmutableMap<K, V> getAllPresent(Iterable<?> keys) {
-        Map<K, V> allPresent = new HashMap<K, V>();
+        ImmutableMap.Builder<K, V> allPresent = ImmutableMap.builder();
         for (Object key : keys) {
             V value = getIfPresent(key);
             if (value != null) allPresent.put((K) key, value);
         }
-        return ImmutableMap.copyOf(allPresent);
+        return allPresent.build();
     }
 
     @Override
@@ -172,9 +187,19 @@ public void invalidateAll(Iterable<?> keys) {
     private void invalidatePersisted(Object key) {
         try {
             K castKey = (K) key;
-            deletePersistedIfExistent(castKey);
+            if (removalListener == null) {
+                deletePersistedIfExistent(castKey);
+            } else {
+                V value = findPersisted(castKey);
+                if (value != null) {
+                    removalListener.onRemoval(RemovalNotifications.make(castKey, value));
+                    deletePersistedIfExistent(castKey);
+                }
+            }
         } catch (ClassCastException e) {
             LOGGER.info(String.format("Could not cast key %s to desired type", key), e);
+        } catch (IOException e) {
+            e.printStackTrace();
         }
     }