Cascade cache invalidations to dependent cached type graphs to avoid failure scenario when a chain of cached graphs as an invalidation in internal node of chain.

Author: realityforge

CHANGELOG.md

@@ -3,6 +3,7 @@
 ### Unreleased
 
 * Remove `CacheType.EXTERNAL` as no longer in use.
+* Cascade cache invalidations to dependent cached type graphs to avoid failure scenario when a chain of cached graphs as an invalidation in internal node of chain.
 
 ### [v6.126](https://github.com/replicant4j/replicant/tree/v6.126) (2022-09-27) · [Full Changelog](https://github.com/spritz/spritz/compare/v6.125...v6.126)
 

server/src/main/java/org/realityforge/replicant/server/transport/ChannelMetaData.java

@@ -1,8 +1,13 @@
 package org.realityforge.replicant.server.transport;
 
+import java.util.Collections;
+import java.util.HashSet;
 import java.util.Objects;
+import java.util.Set;
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.UnmodifiableView;
 
 @SuppressWarnings( "WeakerAccess" )
 public final class ChannelMetaData
@@ -62,6 +67,8 @@ public enum CacheType
   private final boolean _external;
   @Nonnull
   private final ChannelMetaData[] _requiredTypeChannels;
+  @Nonnull
+  private final Set<ChannelMetaData> _dependentChannels = new HashSet<>();
 
   public ChannelMetaData( final int channelId,
                           @Nonnull final String name,
@@ -97,6 +104,7 @@ else if ( hasFilterParameter() && null == filterParameterType )
         throw new IllegalArgumentException( "Specified RequiredTypeChannel " + requiredTypeChannel.getName() +
                                             " is not a type channel" );
       }
+      requiredTypeChannel._dependentChannels.add( this );
     }
   }
 
@@ -172,4 +180,12 @@ public ChannelMetaData[] getRequiredTypeChannels()
   {
     return _requiredTypeChannels;
   }
+
+  @Contract( pure = true )
+  @Nonnull
+  @UnmodifiableView
+  public Set<ChannelMetaData> getDependentChannels()
+  {
+    return Collections.unmodifiableSet( _dependentChannels );
+  }
 }

server/src/main/java/org/realityforge/replicant/server/transport/ReplicantSessionManagerImpl.java

@@ -958,7 +958,27 @@ protected boolean deleteCacheEntry( @Nonnull final ChannelAddress address )
     _cacheLock.writeLock().lock();
     try
     {
-      return null != _cache.remove( address );
+      final ChannelMetaData metaData = getSystemMetaData().getChannelMetaData( address );
+      final boolean cacheRemoved = null != _cache.remove( address );
+      if ( cacheRemoved )
+      {
+        // If we expire the cache then any dependent type graphs must also be expired. This is
+        // required as when a cache is on a client then we send back a "use-cache" message immediately
+        // whereas if a message for a cached has to be loaded and sent back then we queue it on
+        // ReplicantSession._pendingSubscriptionPackets and will be sent back. Unfortunately as we chain
+        // up required graphs when sending cached results this may cause the later "use-cached" to arrive
+        // before cache response and thus causing a failure on client. The "fix" is to queue the use-cache
+        // on _pendingSubscriptionPackets but until that is implemented when we invalidate a cache we
+        // invalidate all dependent cached type graphs to avoid this scenario.
+        for ( final ChannelMetaData channel : metaData.getDependentChannels() )
+        {
+          if( channel.isTypeGraph() && channel.isCacheable() )
+          {
+            _cache.remove( new ChannelAddress( channel.getChannelId() ) );
+          }
+        }
+      }
+      return cacheRemoved;
     }
     finally
     {