basic support for max age in default impls

Author: craig-day

src/main/java/io/vertx/redis/client/CachingRedisClient.java

@@ -48,7 +48,7 @@ static CachingRedisClient create(Vertx vertx) {
    * @return the caching client
    */
   static CachingRedisClient create(Vertx vertx, Redis redis) {
-    return create(vertx, redis, ClientSideCache.lfu(CachingRedisOptions.DEFAULT_MAX_SIZE));
+    return create(vertx, redis, ClientSideCache.lfu(new CachingRedisOptions()));
   }
 
   /**
@@ -83,7 +83,7 @@ static CachingRedisClient create(Vertx vertx, Redis redis, ClientSideCache cache
    * @return the caching client
    */
   static CachingRedisClient create(Vertx vertx, Redis redis, CachingRedisOptions options) {
-    return create(vertx, redis, ClientSideCache.lfu(options.getMaxCacheSize()), options);
+    return create(vertx, redis, ClientSideCache.lfu(options), options);
   }
 
   /**

src/main/java/io/vertx/redis/client/ClientSideCache.java

@@ -26,23 +26,23 @@
 public interface ClientSideCache {
 
   /**
-   * Create a simple least-frequently-used (LFU) cache store with a max size.
+   * Create a simple least-frequently-used (LFU) cache store with a max size and max item age.
    *
-   * @param maxSize the max size
+   * @param options the cache options
    * @return the new cache store
    */
-  static ClientSideCache lfu(int maxSize) {
-    return new LFUClientSideCache(maxSize);
+  static ClientSideCache lfu(CachingRedisOptions options) {
+    return new LFUClientSideCache(options);
   }
 
   /**
-   * Create a simple least-recently-used (LRU) cache store with max size.
+   * Create a simple least-recently-used (LRU) cache store with a max size and max item age.
    *
-   * @param maxSize the max size
+   * @param options the cache options
    * @return the new cache store
    */
-  static ClientSideCache lru(int maxSize) {
-    return new LRUClientSideCache(maxSize);
+  static ClientSideCache lru(CachingRedisOptions options) {
+    return new LRUClientSideCache(options);
   }
 
   /**

src/main/java/io/vertx/redis/client/impl/cache/AbstractClientSideCache.java

@@ -16,6 +16,7 @@
 package io.vertx.redis.client.impl.cache;
 
 import io.vertx.codegen.annotations.Nullable;
+import io.vertx.redis.client.CachingRedisOptions;
 import io.vertx.redis.client.ClientSideCache;
 import io.vertx.redis.client.Response;
 
@@ -29,14 +30,16 @@
 public abstract class AbstractClientSideCache implements ClientSideCache {
 
   protected final int maxSize;
-  protected final ConcurrentMap<CacheKey, Response> data;
+  protected final long maxAgeMillis;
+  protected final ConcurrentMap<CacheKey, CacheEntry> data;
   protected final ConcurrentMap<CacheKey, Long> sorting;
 
-  protected AbstractClientSideCache(int maxSize) {
-    if (maxSize <= 1) {
+  protected AbstractClientSideCache(CachingRedisOptions options) {
+    if (options.getMaxCacheSize() <= 1) {
       throw new IllegalArgumentException("maxSize must be > 1");
     }
-    this.maxSize = maxSize;
+    this.maxSize = options.getMaxCacheSize();
+    this.maxAgeMillis = options.getMaxAgeUnit().toMillis(options.getMaxAge());
     this.data = new ConcurrentHashMap<>();
     this.sorting = new ConcurrentHashMap<>();
   }
@@ -48,14 +51,25 @@ protected AbstractClientSideCache(int maxSize) {
   @Override
   public @Nullable Response get(CacheKey key) {
     sorting.computeIfPresent(key, this::valueAfterGet);
-    return data.get(key);
+    final CacheEntry entry = data.get(key);
+
+    if (entry == null) {
+      return null;
+    }
+
+    if (entry.getAgeMillis() > maxAgeMillis) {
+      delete(key);
+      return null;
+    }
+
+    return entry.getResponse();
   }
 
   @Override
   public void put(CacheKey key, Response value) {
+    check(); // check first so we don't remove the key we're about to put
     sorting.put(key, initialValueOnSet(key, value));
-    data.put(key, value);
-    check();
+    data.put(key, new CacheEntry(value));
   }
 
   @Override
@@ -77,7 +91,7 @@ public void close() {
   }
 
   private void check() {
-    if (data.size() <= maxSize) {
+    if (data.size() < maxSize) {
       return;
     }
 
@@ -89,4 +103,27 @@ private void check() {
     data.remove(toRemove);
     sorting.remove(toRemove);
   }
+
+  protected static final class CacheEntry {
+
+    private final Response response;
+    private long insertTime;
+
+    CacheEntry(Response response) {
+      this.response = response;
+      this.insertTime = System.currentTimeMillis();
+    }
+
+    Response getResponse() {
+      return response;
+    }
+
+    long getAgeMillis() {
+      return System.currentTimeMillis() - insertTime;
+    }
+
+    void touch() {
+      this.insertTime = System.currentTimeMillis();
+    }
+  }
 }

src/main/java/io/vertx/redis/client/impl/cache/LFUClientSideCache.java

@@ -15,13 +15,14 @@
  */
 package io.vertx.redis.client.impl.cache;
 
+import io.vertx.redis.client.CachingRedisOptions;
 import io.vertx.redis.client.ClientSideCache;
 import io.vertx.redis.client.Response;
 
 public class LFUClientSideCache extends AbstractClientSideCache implements ClientSideCache {
 
-  public LFUClientSideCache(int maxSize) {
-    super(maxSize);
+  public LFUClientSideCache(CachingRedisOptions options) {
+    super(options);
   }
 
   @Override

src/main/java/io/vertx/redis/client/impl/cache/LRUClientSideCache.java

@@ -15,13 +15,14 @@
  */
 package io.vertx.redis.client.impl.cache;
 
+import io.vertx.redis.client.CachingRedisOptions;
 import io.vertx.redis.client.ClientSideCache;
 import io.vertx.redis.client.Response;
 
 public class LRUClientSideCache extends AbstractClientSideCache implements ClientSideCache {
 
-  public LRUClientSideCache(int maxSize) {
-    super(maxSize);
+  public LRUClientSideCache(CachingRedisOptions options) {
+    super(options);
   }
 
   @Override