org.keycloak.models.sessions.infinispan.remotestore.RemoteCacheInvoker クラス

org.keycloak.models.sessions.infinispan.remotestore.RemoteCacheInvoker 連携図

クラス
interface	MaxIdleTimeLoader
class	RemoteCacheContext

公開メンバ関数
void	addRemoteCache (String cacheName, RemoteCache remoteCache, MaxIdleTimeLoader maxIdleLoader)
Set< String >	getRemoteCacheNames ()

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

関数
public< K, V extends SessionEntity > void	runTask (KeycloakSession kcSession, RealmModel realm, String cacheName, K key, SessionUpdateTask< V > task, SessionEntityWrapper< V > sessionWrapper)
private< K, V extends SessionEntity > void	runOnRemoteCache (TopologyInfo topology, RemoteCache< K, SessionEntityWrapper< V >> remoteCache, long maxIdleMs, K key, SessionUpdateTask< V > task, SessionEntityWrapper< V > sessionWrapper)
private< K, V extends SessionEntity > void	replace (TopologyInfo topology, RemoteCache< K, SessionEntityWrapper< V >> remoteCache, long lifespanMs, long maxIdleMs, K key, SessionUpdateTask< V > task)

非公開メンバ関数
String	logTopologyData (TopologyInfo topology, int iteration)

非公開変数類
final Map< String, RemoteCacheContext >	remoteCaches = new HashMap<>()

詳解

著者

Marek Posolda

関数詳解

addRemoteCache()

void org.keycloak.models.sessions.infinispan.remotestore.RemoteCacheInvoker.addRemoteCache ( String  cacheName, RemoteCache  remoteCache, MaxIdleTimeLoader  maxIdleLoader  )

inline

                                                                                                           {
        RemoteCacheContext ctx = new RemoteCacheContext(remoteCache, maxIdleLoader);
        remoteCaches.put(cacheName, ctx);
    }

getRemoteCacheNames()

Set<String> org.keycloak.models.sessions.infinispan.remotestore.RemoteCacheInvoker.getRemoteCacheNames ( )

inline

                                             {
        return Collections.unmodifiableSet(remoteCaches.keySet());
    }

logTopologyData()

String org.keycloak.models.sessions.infinispan.remotestore.RemoteCacheInvoker.logTopologyData ( TopologyInfo  topology, int  iteration  )

inlineprivate

                                                                         {
        return topology.toString() + ", replaceIteration: " + iteration;
    }

replace()

private<K, V extends SessionEntity> void org.keycloak.models.sessions.infinispan.remotestore.RemoteCacheInvoker.replace ( TopologyInfo  topology, RemoteCache< K, SessionEntityWrapper< V >>  remoteCache, long  lifespanMs, long  maxIdleMs, K  key, SessionUpdateTask< V >  task  )

inlinepackage

                                                                                                                                                                                                     {
        boolean replaced = false;
        int replaceIteration = 0;
        while (!replaced && replaceIteration < InfinispanUtil.MAXIMUM_REPLACE_RETRIES) {
            replaceIteration++;

            VersionedValue<SessionEntityWrapper<V>> versioned = remoteCache.getWithMetadata(key);
            if (versioned == null) {
                logger.warnf("Not found entity to replace for key '%s'", key);
                return;
            }

            SessionEntityWrapper<V> sessionWrapper = versioned.getValue();
            final V session = sessionWrapper.getEntity();

            // Run task on the remote session
            task.runUpdate(session);

            if (logger.isTraceEnabled()) {
                logger.tracef("%s: Before replaceWithVersion. Entity to write version %d: %s", logTopologyData(topology, replaceIteration),
                        versioned.getVersion(), session);
            }

            replaced = remoteCache.replaceWithVersion(key, SessionEntityWrapper.forTransport(session), versioned.getVersion(), lifespanMs, TimeUnit.MILLISECONDS, maxIdleMs, TimeUnit.MILLISECONDS);

            if (!replaced) {
                logger.debugf("%s: Failed to replace entity '%s' version %d. Will retry again", logTopologyData(topology, replaceIteration), key, versioned.getVersion());
            } else {
                if (logger.isTraceEnabled()) {
                    logger.tracef("%s: Replaced entity version %d in remote cache: %s", logTopologyData(topology, replaceIteration), versioned.getVersion(), session);
                }
            }
        }

        if (!replaced) {
            logger.warnf("Failed to replace entity '%s' in remote cache '%s'", key, remoteCache.getName());
        }
    }

runOnRemoteCache()

private<K, V extends SessionEntity> void org.keycloak.models.sessions.infinispan.remotestore.RemoteCacheInvoker.runOnRemoteCache ( TopologyInfo  topology, RemoteCache< K, SessionEntityWrapper< V >>  remoteCache, long  maxIdleMs, K  key, SessionUpdateTask< V >  task, SessionEntityWrapper< V >  sessionWrapper  )

inlinepackage

                                                                                                                                                                                                                                     {
        final V session = sessionWrapper.getEntity();
        SessionUpdateTask.CacheOperation operation = task.getOperation(session);

        switch (operation) {
            case REMOVE:
                remoteCache.remove(key);
                break;
            case ADD:
                remoteCache.put(key, sessionWrapper.forTransport(), task.getLifespanMs(), TimeUnit.MILLISECONDS, maxIdleMs, TimeUnit.MILLISECONDS);
                break;
            case ADD_IF_ABSENT:
                SessionEntityWrapper<V> existing = remoteCache
                        .withFlags(Flag.FORCE_RETURN_VALUE)
                        .putIfAbsent(key, sessionWrapper.forTransport(), -1, TimeUnit.MILLISECONDS, maxIdleMs, TimeUnit.MILLISECONDS);
                if (existing != null) {
                    logger.debugf("Existing entity in remote cache for key: %s . Will update it", key);

                    replace(topology, remoteCache, task.getLifespanMs(), maxIdleMs, key, task);
                }
                break;
            case REPLACE:
                replace(topology, remoteCache, task.getLifespanMs(), maxIdleMs, key, task);
                break;
            default:
                throw new IllegalStateException("Unsupported state " +  operation);
        }
    }

runTask()

public<K, V extends SessionEntity> void org.keycloak.models.sessions.infinispan.remotestore.RemoteCacheInvoker.runTask ( KeycloakSession  kcSession, RealmModel  realm, String  cacheName, K  key, SessionUpdateTask< V >  task, SessionEntityWrapper< V >  sessionWrapper  )

inlinepackage

                                                                                                                                                                                              {
        RemoteCacheContext context = remoteCaches.get(cacheName);
        if (context == null) {
            return;
        }

        V session = sessionWrapper.getEntity();

        SessionUpdateTask.CacheOperation operation = task.getOperation(session);
        SessionUpdateTask.CrossDCMessageStatus status = task.getCrossDCMessageStatus(sessionWrapper);

        if (status == SessionUpdateTask.CrossDCMessageStatus.NOT_NEEDED) {
            if (logger.isTraceEnabled()) {
                logger.tracef("Skip writing to remoteCache for entity '%s' of cache '%s' and operation '%s'", key, cacheName, operation);
            }
            return;
        }

        long loadedMaxIdleTimeMs = context.maxIdleTimeLoader.getMaxIdleTimeMs(realm);

        // Increase the timeout to ensure that entry won't expire on remoteCache in case that write of some entities to remoteCache is postponed (eg. userSession.lastSessionRefresh)
        final long maxIdleTimeMs = loadedMaxIdleTimeMs + 1800000;

        if (logger.isTraceEnabled()) {
            logger.tracef("Running task '%s' on remote cache '%s' . Key is '%s'", operation, cacheName, key);
        }

        TopologyInfo topology = InfinispanUtil.getTopologyInfo(kcSession);

        Retry.executeWithBackoff((int iteration) -> {

            try {
                runOnRemoteCache(topology, context.remoteCache, maxIdleTimeMs, key, task, sessionWrapper);
            } catch (HotRodClientException re) {
                if (logger.isDebugEnabled()) {
                    logger.debugf(re, "Failed running task '%s' on remote cache '%s' . Key: '%s', iteration '%s'. Will try to retry the task",
                            operation, cacheName, key, iteration);
                }

                // Rethrow the exception. Retry will take care of handle the exception and eventually retry the operation.
                throw re;
            }

        }, 10, 10);
    }

メンバ詳解

logger

final Logger org.keycloak.models.sessions.infinispan.remotestore.RemoteCacheInvoker.logger = Logger.getLogger(RemoteCacheInvoker.class)

static

remoteCaches

final Map<String, RemoteCacheContext> org.keycloak.models.sessions.infinispan.remotestore.RemoteCacheInvoker.remoteCaches = new HashMap<>()

private

---

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

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