Refactor L2 cache tenant awareness - add TenantAwareCache

ebean-api/src/main/java/io/ebean/cache/ServerCache.java

@@ -104,4 +104,11 @@ default ServerCacheStatistics statistics(boolean reset) {
  default void visit(MetricVisitor visitor) {
  // do nothing by default
  }
+
+ /**
+ * Unwrap the underlying ServerCache.
+ */
+ default <T> T unwrap(Class<T> cls) {
+ return (T) this;
+ }
 }

ebean-api/src/main/java/io/ebean/cache/ServerCacheConfig.java

@@ -13,6 +13,7 @@ public class ServerCacheConfig {
  private final ServerCacheOptions cacheOptions;
  private final CurrentTenantProvider tenantProvider;
  private final QueryCacheEntryValidate queryCacheEntryValidate;
+ private final TenantAwareKey tenantAwareKey;
 
  public ServerCacheConfig(ServerCacheType type, String cacheKey, String shortName, ServerCacheOptions cacheOptions, CurrentTenantProvider tenantProvider, QueryCacheEntryValidate queryCacheEntryValidate) {
  this.type = type;
@@ -21,6 +22,14 @@ public ServerCacheConfig(ServerCacheType type, String cacheKey, String shortName
  this.cacheOptions = cacheOptions;
  this.tenantProvider = tenantProvider;
  this.queryCacheEntryValidate = queryCacheEntryValidate;
+ this.tenantAwareKey = (tenantProvider == null) ? null : new TenantAwareKey(tenantProvider);
+ }
+
+ /**
+ * Return the ServerCache taking into account if multi-tenant is used.
+ */
+ public ServerCache tenantAware(ServerCache cache) {
+ return tenantAwareKey == null ? cache : new TenantAwareCache(cache, tenantAwareKey);
  }
 
  /**

ebean-api/src/main/java/io/ebean/cache/TenantAwareCache.java

@@ -0,0 +1,104 @@
+package io.ebean.cache;
+
+import io.ebean.meta.MetricVisitor;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+/**
+ * A ServerCache proxy that is tenant aware.
+ */
+public final class TenantAwareCache implements ServerCache {
+
+ private final ServerCache delegate;
+ private final TenantAwareKey tenantAwareKey;
+
+ /**
+ * Create given the TenantAwareKey and delegate cache to proxy to.
+ *
+ * @param delegate The cache to proxy to
+ * @param tenantAwareKey Provides tenant aware keys to use in the cache
+ */
+ public TenantAwareCache(ServerCache delegate, TenantAwareKey tenantAwareKey) {
+ this.delegate = delegate;
+ this.tenantAwareKey = tenantAwareKey;
+ }
+
+ /**
+ * Return the underlying ServerCache that is being delegated to.
+ */
+ @Override
+ public <T> T unwrap(Class<T> cls) {
+ return (T)delegate;
+ }
+
+ @Override
+ public void visit(MetricVisitor visitor) {
+ delegate.visit(visitor);
+ }
+
+ private Object key(Object key) {
+ return tenantAwareKey.key(key);
+ }
+
+ @Override
+ public Object get(Object id) {
+ return delegate.get(key(id));
+ }
+
+ @Override
+ public void put(Object id, Object value) {
+ delegate.put(key(id), value);
+ }
+
+ @Override
+ public void remove(Object id) {
+ delegate.remove(key(id));
+ }
+
+ @Override
+ public void clear() {
+ delegate.clear();
+ }
+
+ @Override
+ public int size() {
+ return delegate.size();
+ }
+
+ @Override
+ public int getHitRatio() {
+ return delegate.getHitRatio();
+ }
+
+ @Override
+ public ServerCacheStatistics getStatistics(boolean reset) {
+ return delegate.getStatistics(reset);
+ }
+
+ @Override
+ public Map<Object, Object> getAll(Set<Object> keys) {
+ Map<Object, Object> keyMapping = new HashMap<>(keys.size());
+ keys.forEach(k -> keyMapping.put(key(k), k));
+ Map<Object, Object> tmp = delegate.getAll(keyMapping.keySet());
+ Map<Object, Object> ret = new HashMap<>(keys.size());
+ // unwrap tenant info here
+ tmp.forEach((k,v)-> ret.put(((TenantAwareKey.CacheKey) k).key, v));
+ return ret;
+ }
+
+ @Override
+ public void putAll(Map<Object, Object> keyValues) {
+ Map<Object, Object> tmp = new HashMap<>();
+ keyValues.forEach((k, v) -> tmp.put(key(k), v));
+ delegate.putAll(tmp);
+ }
+
+ @Override
+ public void removeAll(Set<Object> keys) {
+ delegate.removeAll(keys.stream().map(this::key).collect(Collectors.toSet()));
+ }
+
+}

ebean-api/src/test/java/io/ebean/cache/TenantAwareCacheTest.java

@@ -0,0 +1,122 @@
+package io.ebean.cache;
+
+import io.ebean.cache.TenantAwareKey.CacheKey;
+import io.ebean.config.CurrentTenantProvider;
+import org.junit.jupiter.api.Test;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class TenantAwareCacheTest {
+
+ ServerCache serverCache;
+ TenantAwareCache cache;
+
+ TenantAwareCacheTest() {
+ TenantAwareKey key = new TenantAwareKey(new TenantProv());
+ this.serverCache = new Cache();
+ this.cache = new TenantAwareCache(serverCache, key);
+ }
+
+ @Test
+ void put_get_remove() {
+ cache.put("A", "a");
+ Object val = cache.get("A");
+ assertThat(val).isEqualTo("a");
+
+ CacheKey cacheKey = new CacheKey("A", 42);
+ Object val2 = serverCache.get(cacheKey);
+ assertThat(val2).isEqualTo("a");
+
+ cache.put("B", "bb");
+ assertThat(cache.size()).isEqualTo(2);
+ cache.remove("A");
+ assertThat(cache.get("A")).isNull();
+ assertThat(cache.size()).isEqualTo(1);
+
+ cache.clear();
+ assertThat(cache.size()).isEqualTo(0);
+ assertThat(cache.get("B")).isNull();
+ }
+
+ @Test
+ void putAll_getAll_removeAll() {
+ Map<Object,Object> map = new HashMap<>();
+ map.put("A", "a");
+ map.put("B", "b");
+ map.put("C", "c");
+
+ cache.putAll(map);
+ assertThat(cache.size()).isEqualTo(3);
+ assertThat(cache.get("A")).isEqualTo("a");
+ assertThat(serverCache.get(new CacheKey("A", 42))).isEqualTo("a");
+
+
+ Map<Object, Object> result = cache.getAll(Set.of("A", "B", "C", "D"));
+ assertThat(result).hasSize(3);
+ assertThat(result).containsOnlyKeys("A", "B", "C");
+ assertThat(result.values()).containsOnly("a", "b", "c");
+
+ cache.removeAll(Set.of("A", "C", "D"));
+ assertThat(cache.size()).isEqualTo(1);
+
+ assertThat(cache.get("B")).isEqualTo("b");
+ assertThat(serverCache.get(new CacheKey("B", 42))).isEqualTo("b");
+
+ cache.remove("B");
+ assertThat(cache.size()).isEqualTo(0);
+ }
+
+
+ static class TenantProv implements CurrentTenantProvider {
+
+ @Override
+ public Object currentId() {
+ return 42;
+ }
+ }
+
+ static class Cache implements ServerCache {
+
+ Map<Object, Object> map = new ConcurrentHashMap<>();
+
+ @Override
+ public Object get(Object id) {
+ return map.get(id);
+ }
+
+ @Override
+ public void put(Object id, Object value) {
+ map.put(id, value);
+ }
+
+ @Override
+ public void remove(Object id) {
+ map.remove(id);
+ }
+
+ @Override
+ public void clear() {
+ map.clear();
+ }
+
+ @Override
+ public int size() {
+ return map.size();
+ }
+
+ @Override
+ public int getHitRatio() {
+ return 0;
+ }
+
+ @Override
+ public ServerCacheStatistics getStatistics(boolean reset) {
+ return null;
+ }
+ }
+}

ebean-core/src/main/java/io/ebeaninternal/server/cache/DefaultServerCache.java

@@ -52,14 +52,12 @@ public class DefaultServerCache implements ServerCache {
  private final int trimFrequency;
  private final int maxIdleSecs;
  private final int maxSecsToLive;
- private final TenantAwareKey tenantAwareKey;
 
  public DefaultServerCache(DefaultServerCacheConfig config) {
  this.name = config.getName();
  this.shortName = config.getShortName();
  this.map = config.getMap();
  this.maxSize = config.getMaxSize();
- this.tenantAwareKey = new TenantAwareKey(config.getTenantProvider());
  this.maxIdleSecs = config.getMaxIdleSecs();
  this.maxSecsToLive = config.getMaxSecsToLive();
  this.trimFrequency = config.determineTrimFrequency();
@@ -152,19 +150,12 @@ public void clear() {
  map.clear();
  }
 
- /**
- * Return the tenant aware key.
- */
- protected Object key(Object id) {
- return tenantAwareKey.key(id);
- }
-
  /**
  * Return a value from the cache.
  */
  @Override
- public Object get(Object id) {
- CacheEntry entry = getCacheEntry(id);
+ public Object get(Object key) {
+ CacheEntry entry = getCacheEntry(key);
  if (entry == null) {
  missCount.increment();
  return null;
@@ -184,8 +175,8 @@ protected Object unwrapEntry(CacheEntry entry) {
  /**
  * Get the cache entry - override for query cache to validate dependent tables.
  */
- protected CacheEntry getCacheEntry(Object id) {
- final SoftReference<CacheEntry> ref = map.get(key(id));
+ protected CacheEntry getCacheEntry(Object key) {
+ final SoftReference<CacheEntry> ref = map.get(key);
  return ref != null ? ref.get() : null;
  }
 
@@ -198,8 +189,7 @@ public void putAll(Map<Object, Object> keyValues) {
  * Put a value into the cache.
  */
  @Override
- public void put(Object id, Object value) {
- Object key = key(id);
+ public void put(Object key, Object value) {
  map.put(key, new SoftReference<>(new CacheEntry(key, value)));
  putCount.increment();
  }
@@ -208,8 +198,8 @@ public void put(Object id, Object value) {
  * Remove an entry from the cache.
  */
  @Override
- public void remove(Object id) {
- SoftReference<CacheEntry> entry = map.remove(key(id));
+ public void remove(Object key) {
+ SoftReference<CacheEntry> entry = map.remove(key);
  if (entry != null && entry.get() != null) {
  removeCount.increment();
  }

ebean-core/src/main/java/io/ebeaninternal/server/cache/DefaultServerCacheConfig.java

@@ -3,7 +3,6 @@
 import io.ebean.cache.QueryCacheEntryValidate;
 import io.ebean.cache.ServerCacheConfig;
 import io.ebean.cache.ServerCacheOptions;
-import io.ebean.config.CurrentTenantProvider;
 import io.ebeaninternal.server.cache.DefaultServerCache.CacheEntry;
 
 import java.lang.ref.SoftReference;
@@ -34,10 +33,6 @@ public DefaultServerCacheConfig(ServerCacheConfig config, Map<Object, SoftRefere
  this.maxSize = options.getMaxSize();
  }
 
- public CurrentTenantProvider getTenantProvider() {
- return config.getTenantProvider();
- }
-
  public QueryCacheEntryValidate getQueryCacheEntryValidate() {
  return config.getQueryCacheEntryValidate();
  }

ebean-core/src/main/java/io/ebeaninternal/server/cache/DefaultServerCacheFactory.java

@@ -41,7 +41,7 @@ public ServerCache createCache(ServerCacheConfig config) {
  if (executor != null) {
  cache.periodicTrim(executor);
  }
- return cache;
+ return config.tenantAware(cache);
  }
 
  @Override

ebean-core/src/main/java/io/ebeaninternal/server/cache/DefaultServerQueryCache.java

@@ -27,8 +27,7 @@ protected Object unwrapEntry(CacheEntry entry) {
  }
 
  @Override
- protected CacheEntry getCacheEntry(Object id) {
- Object key = key(id);
+ protected CacheEntry getCacheEntry(Object key) {
  final SoftReference<CacheEntry> ref = map.get(key);
  CacheEntry entry = ref != null ? ref.get() : null;
  if (entry == null) {

ebean-core/src/main/java/io/ebeaninternal/server/profile/DCountMetric.java

@@ -48,7 +48,6 @@ public long get(boolean reset) {
 
  @Override
  public void visit(MetricVisitor visitor) {
-
  long val = visitor.reset() ? count.sumThenReset() : count.sum();
  if (val > 0) {
  visitor.visitCount(new DCountMetricStats(name, val));