Merge pull request #99 from k-r-g/CacheMessageManager_MethodValueCach…

…e_Updates

Make CacheMessageManager support the EntityStore method value cache

gemini/src/main/java/com/techempower/cache/EntityStore.java

@@ -280,6 +280,45 @@ protected <T extends Identifiable> boolean isIndexed(Class<T> type, String metho
     }
   }
 
+  /**
+   * Whether the provided class uses the @Indexed annotation and therefore uses
+   * the method value cache.
+   */
+  public boolean usesMethodValueCache(Class<? extends Identifiable> type)
+  {
+    return methodValueCaches.get(type) != null;
+  }
+
+  /**
+   * Update the specified method value cache.
+   */
+  public void methodValueCacheUpdate(Class<? extends Identifiable> type, long... ids)
+  {
+    final MethodValueCache<?> methodValueCache = methodValueCaches.get(type);
+    if (methodValueCache != null)
+    {
+      for (long id : ids)
+      {
+        methodValueCache.update(id);
+      }
+    }
+  }
+
+  /**
+   * Delete from the specified method value cache.
+   */
+  public void methodValueCacheDelete(Class<? extends Identifiable> type, long... ids)
+  {
+    final MethodValueCache<?> methodValueCache = methodValueCaches.get(type);
+    if (methodValueCache != null)
+    {
+      for (long id : ids)
+      {
+        methodValueCache.delete(id);
+      }
+    }
+  }
+
   /**
    * Reset all entity groups controlled by this controller.
    */
@@ -1028,14 +1067,9 @@ public <T extends Identifiable> T get(Class<T> type, String methodName, Object v
   public void refresh(Class<? extends Identifiable> type, long... ids)
   {
     getGroupSafe(type).refresh(ids);
-
-    final MethodValueCache<?> methodValueCache = methodValueCaches.get(type);
-    if (methodValueCache != null)
-    {
-      for (long id : ids) {
-        methodValueCache.update(id);
-      }
-    }
+
+    // Update index/methodValueCache.
+    methodValueCacheUpdate(type, ids);
 
     // Notify the listeners.
     notifyListenersCacheObjectExpired(true, type, ids);
@@ -1085,11 +1119,7 @@ public <T extends Identifiable> void put(T entity)
     if (!useAffectedRows || rowsUpdated > 0)
     {
       // Update method value caches.
-      final MethodValueCache<?> methodValueCache = methodValueCaches.get(entity.getClass());
-      if (methodValueCache != null)
-      {
-        methodValueCache.update(entity.getId());
-      }
+      methodValueCacheUpdate(entity.getClass(), entity.getId());
 
       // Notify the listeners.
       final CacheListener[] toNotify = listeners;
@@ -1133,12 +1163,8 @@ public <T extends Identifiable> void remove(T entity)
     }
 
     // Update method value cache.
-    final MethodValueCache<?> methodValueCache = methodValueCaches.get(entity.getClass());
-    if (methodValueCache != null)
-    {
-      methodValueCache.delete(entity.getId());
-    }
-
+    methodValueCacheDelete(entity.getClass(), entity.getId());
+
     // Notify the listeners.
     final CacheListener[] toNotify = listeners;
     for (CacheListener listener : toNotify)

gemini/src/main/java/com/techempower/cache/annotation/Indexed.java

@@ -29,10 +29,18 @@
 import java.lang.annotation.*;
 
 /**
- * This annotation is used to mark entity classes or methods as indexed.  
- * Classes or methods marked as @Indexed should always cache method values, 
- * even if method value caching is turned off.
+ * This annotation is used to mark entity classes or methods as indexed. Classes
+ * or methods marked as @Indexed should always cache method values, even if
+ * method value caching is turned off.
+ * <p>
+ * <b>IMPORTANT</b>: If you use this annotation in an application that uses the
+ * CacheMessageManager to distribute cache updates to other instances, it is
+ * your responsibility to ensure that your corresponding EntityGroup
+ * ("distribute" defaulting to false) or CacheGroup ("distribute" defaulting to
+ * true) has the "distribute" flag set to true. Otherwise each instance will
+ * risk having a stale method value cache and you'll get wrong answers from
+ * EntityStore.get() and list() and honestly it won't be very fun.
  */
-@Target({ElementType.METHOD, ElementType.TYPE})
+@Target({ ElementType.METHOD, ElementType.TYPE })
 @Retention(RetentionPolicy.RUNTIME)
 public @interface Indexed { }

gemini/src/main/java/com/techempower/data/EntityGroup.java

@@ -2269,6 +2269,13 @@ public static class Builder<T extends Identifiable>
      * need to notify DistributionListeners. However, if some instances use a
      * CacheGroup for this entity, then it may be useful to set this to true so
      * those instances can update their cache.
+     * <p>
+     * <b>IMPORTANT</b>: If you use the @Indexed annotation on this entity in an
+     * application that uses the CacheMessageManager to distribute cache updates to
+     * other instances, it is your responsibility to ensure that "distribute" is set
+     * to true. Otherwise each instance will risk having a stale method value cache
+     * and you'll get wrong answers from EntityStore.get() and list() and it
+     * honestly won't be very fun.
      */
     protected boolean distribute = false;
 
@@ -2364,6 +2371,13 @@ public Builder<T> readOnly()
     /**
      * Specifies updates to the resulting EntityGroup should be passed to
      * DistributionListeners.
+     * <p>
+     * <b>IMPORTANT</b>: If you use the @Indexed annotation on this entity in an
+     * application that uses the CacheMessageManager to distribute cache updates to
+     * other instances, it is your responsibility to ensure that "distribute" is set
+     * to true. Otherwise each instance will risk having a stale method value cache
+     * and you'll get wrong answers from EntityStore.get() and list() and it
+     * honestly won't be very fun.
      */
     public Builder<T> distribute(boolean distribute)
     {

gemini/src/main/java/com/techempower/gemini/cluster/jms/CacheMessageManager.java

@@ -489,6 +489,9 @@ else if (group instanceof EntityGroup)
               log.info("Receiving 'cache object expired' but group id is invalid:{}, group: {}",
                   cacheMessage, group);
             }
+            // Now that the object is updated in the cache, update the method value cache if
+            // needed.
+            store.methodValueCacheUpdate(group.getType(), cacheMessage.getObjectId());
 
             break;
           }
@@ -514,6 +517,9 @@ else if (group instanceof EntityGroup)
                   "invalid: {}, group: {}, cacheMessage: {}",
                   cacheMessage.getGroupId(), group, cacheMessage);
             }
+            // Now that the object is deleted from the cache, also delete from the method
+            // value cache if needed.
+            store.methodValueCacheDelete(group.getType(), cacheMessage.getObjectId());
             break;
           }
           case (CacheMessage.ACTION_GROUP_RESET):