org.keycloak.models.sessions.infinispan.remotestore.RemoteCacheSessionListener< K, V extends SessionEntity >.DontFetchInitialStateCacheListener クラス

org.keycloak.models.sessions.infinispan.remotestore.RemoteCacheSessionListener< K, V extends SessionEntity >.DontFetchInitialStateCacheListener の継承関係図

org.keycloak.models.sessions.infinispan.remotestore.RemoteCacheSessionListener< K, V extends SessionEntity >.DontFetchInitialStateCacheListener 連携図

公開メンバ関数
void	created (ClientCacheEntryCreatedEvent event)
void	updated (ClientCacheEntryModifiedEvent event)
void	removed (ClientCacheEntryRemovedEvent event)

静的公開メンバ関数
static< K, V extends SessionEntity > RemoteCacheSessionListener	createListener (KeycloakSession session, Cache< K, SessionEntityWrapper< V >> cache, RemoteCache< K, SessionEntityWrapper< V >> remoteCache)

限定公開メンバ関数
void	init (KeycloakSession session, Cache< K, SessionEntityWrapper< V >> cache, RemoteCache< K, SessionEntityWrapper< V >> remoteCache)
void	createRemoteEntityInCache (K key, long eventVersion)
void	replaceRemoteEntityInCache (K key, long eventVersion)
boolean	shouldUpdateLocalCache (ClientEvent.Type type, K key, boolean commandRetried)

静的限定公開変数類
static final Logger	logger = Logger.getLogger(RemoteCacheSessionListener.class)

詳解

関数詳解

created()

void org.keycloak.models.sessions.infinispan.remotestore.RemoteCacheSessionListener< K, V extends SessionEntity >.created ( ClientCacheEntryCreatedEvent  event )

inlineinherited

                                                            {
        K key = (K) event.getKey();

        if (shouldUpdateLocalCache(event.getType(), key, event.isCommandRetried())) {
            this.executor.submit(event, () -> {

                // Doesn't work due https://issues.jboss.org/browse/ISPN-9323. Needs to explicitly retrieve and create it
                //cache.get(key);

                createRemoteEntityInCache(key, event.getVersion());

            });
        }
    }

createListener()

static <K, V extends SessionEntity> RemoteCacheSessionListener org.keycloak.models.sessions.infinispan.remotestore.RemoteCacheSessionListener< K, V extends SessionEntity >.createListener ( KeycloakSession  session, Cache< K, SessionEntityWrapper< V >>  cache, RemoteCache< K, SessionEntityWrapper< V >>  remoteCache  )

inlinestaticinherited

                                                                                                                                                                                                                {
        /*boolean isCoordinator = InfinispanUtil.isCoordinator(cache);

        // Just cluster coordinator will fetch userSessions from remote cache.
        // In case that coordinator is failover during state fetch, there is slight risk that not all userSessions will be fetched to local cluster. Assume acceptable for now
        RemoteCacheSessionListener listener;
        if (isCoordinator) {
            logger.infof("Will fetch initial state from remote cache for cache '%s'", cache.getName());
            listener = new FetchInitialStateCacheListener();
        } else {
            logger.infof("Won't fetch initial state from remote cache for cache '%s'", cache.getName());
            listener = new DontFetchInitialStateCacheListener();
        }*/

        RemoteCacheSessionListener<K, V> listener = new RemoteCacheSessionListener<>();
        listener.init(session, cache, remoteCache);

        return listener;
    }

createRemoteEntityInCache()

void org.keycloak.models.sessions.infinispan.remotestore.RemoteCacheSessionListener< K, V extends SessionEntity >.createRemoteEntityInCache ( K  key, long  eventVersion  )

inlineprotectedinherited

                                                                       {
        VersionedValue<SessionEntityWrapper<V>> remoteSessionVersioned = remoteCache.getWithMetadata(key);

        // Maybe can happen under some circumstances that remoteCache doesn't yet contain the value sent in the event (maybe just theoretically...)
        if (remoteSessionVersioned == null || remoteSessionVersioned.getValue() == null) {
            logger.debugf("Entity '%s' not present in remoteCache. Ignoring create",
                    key.toString());
            return;
        }


        V remoteSession = remoteSessionVersioned.getValue().getEntity();
        SessionEntityWrapper<V> newWrapper = new SessionEntityWrapper<>(remoteSession);

        logger.debugf("Read session entity wrapper from the remote cache: %s", remoteSession.toString());

        // Using putIfAbsent. Theoretic possibility that entity was already put to cache by someone else
        cache.getAdvancedCache().withFlags(Flag.SKIP_CACHE_STORE, Flag.SKIP_CACHE_LOAD, Flag.IGNORE_RETURN_VALUES)
                .putIfAbsent(key, newWrapper);
    }

init()

void org.keycloak.models.sessions.infinispan.remotestore.RemoteCacheSessionListener< K, V extends SessionEntity >.init ( KeycloakSession  session, Cache< K, SessionEntityWrapper< V >>  cache, RemoteCache< K, SessionEntityWrapper< V >>  remoteCache  )

inlineprotectedinherited

                                                                                                                                               {
        this.cache = cache;
        this.remoteCache = remoteCache;

        this.topologyInfo = InfinispanUtil.getTopologyInfo(session);

        ExecutorService executor = session.getProvider(ExecutorsProvider.class).getExecutor("client-listener-" + cache.getName());
        this.executor = new ClientListenerExecutorDecorator<>(executor);
    }

removed()

void org.keycloak.models.sessions.infinispan.remotestore.RemoteCacheSessionListener< K, V extends SessionEntity >.removed ( ClientCacheEntryRemovedEvent  event )

inlineinherited

                                                            {
        K key = (K) event.getKey();

        if (shouldUpdateLocalCache(event.getType(), key, event.isCommandRetried())) {

            this.executor.submit(event, () -> {

                // We received event from remoteCache, so we won't update it back
                cache.getAdvancedCache().withFlags(Flag.SKIP_CACHE_STORE, Flag.SKIP_CACHE_LOAD, Flag.IGNORE_RETURN_VALUES)
                        .remove(key);

            });
        }
    }

replaceRemoteEntityInCache()

void org.keycloak.models.sessions.infinispan.remotestore.RemoteCacheSessionListener< K, V extends SessionEntity >.replaceRemoteEntityInCache ( K  key, long  eventVersion  )

inlineprotectedinherited

                                                                        {
        // TODO can be optimized and remoteSession sent in the event itself?
        boolean replaced = false;
        int replaceRetries = 0;
        int sleepInterval = 25;
        do {
            replaceRetries++;
            
            SessionEntityWrapper<V> localEntityWrapper = cache.get(key);
            VersionedValue<SessionEntityWrapper<V>> remoteSessionVersioned = remoteCache.getWithMetadata(key);

            // Probably already removed
            if (remoteSessionVersioned == null || remoteSessionVersioned.getValue() == null) {
                logger.debugf("Entity '%s' not present in remoteCache. Ignoring replace",
                        key.toString());
                return;
            }

            if (remoteSessionVersioned.getVersion() < eventVersion) {
                try {
                    logger.debugf("Got replace remote entity event prematurely for entity '%s', will try again. Event version: %d, got: %d",
                      key.toString(), eventVersion, remoteSessionVersioned == null ? -1 : remoteSessionVersioned.getVersion());
                    Thread.sleep(new Random().nextInt(sleepInterval));  // using exponential backoff
                    continue;
                } catch (InterruptedException ex) {
                    continue;
                } finally {
                    sleepInterval = sleepInterval << 1;
                }
            }
            SessionEntity remoteSession = remoteSessionVersioned.getValue().getEntity();

            logger.debugf("Read session entity from the remote cache: %s . replaceRetries=%d", remoteSession.toString(), replaceRetries);

            SessionEntityWrapper<V> sessionWrapper = remoteSession.mergeRemoteEntityWithLocalEntity(localEntityWrapper);

            // We received event from remoteCache, so we won't update it back
            replaced = cache.getAdvancedCache().withFlags(Flag.SKIP_CACHE_STORE, Flag.SKIP_CACHE_LOAD, Flag.IGNORE_RETURN_VALUES)
                    .replace(key, localEntityWrapper, sessionWrapper);

            if (! replaced) {
                logger.debugf("Did not succeed in merging sessions, will try again: %s", remoteSession.toString());
            }
        } while (replaceRetries < MAXIMUM_REPLACE_RETRIES && ! replaced);
    }

shouldUpdateLocalCache()

boolean org.keycloak.models.sessions.infinispan.remotestore.RemoteCacheSessionListener< K, V extends SessionEntity >.shouldUpdateLocalCache ( ClientEvent.Type  type, K  key, boolean  commandRetried  )

inlineprotectedinherited

                                                                                                   {
        boolean result;

        // Case when cache is stopping or stopped already
        if (!cache.getStatus().allowInvocations()) {
            return false;
        }

        if (commandRetried) {
            result = true;
        } else {
            result = topologyInfo.amIOwner(cache, key);
        }

        logger.debugf("Received event from remote store. Event '%s', key '%s', skip '%b'", type.toString(), key, !result);

        return result;
    }

updated()

void org.keycloak.models.sessions.infinispan.remotestore.RemoteCacheSessionListener< K, V extends SessionEntity >.updated ( ClientCacheEntryModifiedEvent  event )

inlineinherited

                                                             {
        K key = (K) event.getKey();

        if (shouldUpdateLocalCache(event.getType(), key, event.isCommandRetried())) {

            this.executor.submit(event, () -> {

                replaceRemoteEntityInCache(key, event.getVersion());

            });
        }
    }

メンバ詳解

logger

final Logger org.keycloak.models.sessions.infinispan.remotestore.RemoteCacheSessionListener< K, V extends SessionEntity >.logger = Logger.getLogger(RemoteCacheSessionListener.class)

staticprotectedinherited

---

このクラス詳解は次のファイルから抽出されました:

• D:/AppData/doxygen/keycloak/src/keycloak/src/main/java/org/keycloak/models/sessions/infinispan/remotestore/RemoteCacheSessionListener.java