org.keycloak.models.sessions.infinispan.changes.InfinispanChangelogBasedTransaction< K, V extends SessionEntity > クラステンプレート

org.keycloak.models.sessions.infinispan.changes.InfinispanChangelogBasedTransaction< K, V extends SessionEntity > の継承関係図

org.keycloak.models.sessions.infinispan.changes.InfinispanChangelogBasedTransaction< K, V extends SessionEntity > 連携図

公開メンバ関数
	InfinispanChangelogBasedTransaction (KeycloakSession kcSession, Cache< K, SessionEntityWrapper< V >> cache, RemoteCacheInvoker remoteCacheInvoker)
void	addTask (K key, SessionUpdateTask< V > task)
void	addTask (K key, SessionUpdateTask< V > task, V entity)
void	reloadEntityInCurrentTransaction (RealmModel realm, K key, SessionEntityWrapper< V > entity)
SessionEntityWrapper< V >	get (K key)
void	begin ()
void	commit ()
void	rollback ()
void	setRollbackOnly ()
boolean	getRollbackOnly ()
boolean	isActive ()
TransactionState	getState ()

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

限定公開メンバ関数
void	commitImpl ()
void	rollbackImpl ()

限定公開変数類
TransactionState	state = TransactionState.NOT_STARTED

非公開メンバ関数
void	runOperationInCluster (K key, MergedUpdate< V > task, SessionEntityWrapper< V > sessionWrapper)
void	replace (K key, MergedUpdate< V > task, SessionEntityWrapper< V > oldVersionEntity)
SessionEntityWrapper< V >	generateNewVersionAndWrapEntity (V entity, Map< String, String > localMetadata)

非公開変数類
final KeycloakSession	kcSession
final String	cacheName
final Cache< K, SessionEntityWrapper< V > >	cache
final RemoteCacheInvoker	remoteCacheInvoker
final Map< K, SessionUpdatesList< V > >	updates = new HashMap<>()

詳解

著者

Marek Posolda

構築子と解体子

InfinispanChangelogBasedTransaction()

org.keycloak.models.sessions.infinispan.changes.InfinispanChangelogBasedTransaction< K, V extends SessionEntity >.InfinispanChangelogBasedTransaction ( KeycloakSession  kcSession, Cache< K, SessionEntityWrapper< V >>  cache, RemoteCacheInvoker  remoteCacheInvoker  )

inline

                                                                                                                                                          {
        this.kcSession = kcSession;
        this.cacheName = cache.getName();
        this.cache = cache;
        this.remoteCacheInvoker = remoteCacheInvoker;
    }

関数詳解

addTask() [1/2]

void org.keycloak.models.sessions.infinispan.changes.InfinispanChangelogBasedTransaction< K, V extends SessionEntity >.addTask ( K  key, SessionUpdateTask< V >  task  )

inline

                                                          {
        SessionUpdatesList<V> myUpdates = updates.get(key);
        if (myUpdates == null) {
            // Lookup entity from cache
            SessionEntityWrapper<V> wrappedEntity = cache.get(key);
            if (wrappedEntity == null) {
                logger.warnf("Not present cache item for key %s", key);
                return;
            }

            RealmModel realm = kcSession.realms().getRealm(wrappedEntity.getEntity().getRealmId());

            myUpdates = new SessionUpdatesList<>(realm, wrappedEntity);
            updates.put(key, myUpdates);
        }

        // Run the update now, so reader in same transaction can see it (TODO: Rollback may not work correctly. See if it's an issue..)
        task.runUpdate(myUpdates.getEntityWrapper().getEntity());
        myUpdates.add(task);
    }

addTask() [2/2]

void org.keycloak.models.sessions.infinispan.changes.InfinispanChangelogBasedTransaction< K, V extends SessionEntity >.addTask ( K  key, SessionUpdateTask< V >  task, V  entity  )

inline

                                                                    {
        if (entity == null) {
            throw new IllegalArgumentException("Null entity not allowed");
        }

        RealmModel realm = kcSession.realms().getRealm(entity.getRealmId());
        SessionEntityWrapper<V> wrappedEntity = new SessionEntityWrapper<>(entity);
        SessionUpdatesList<V> myUpdates = new SessionUpdatesList<>(realm, wrappedEntity);
        updates.put(key, myUpdates);

        // Run the update now, so reader in same transaction can see it
        task.runUpdate(entity);
        myUpdates.add(task);
    }

begin()

void org.keycloak.models.AbstractKeycloakTransaction.begin ( )

inlineinherited

org.keycloak.models.KeycloakTransactionを実装しています。

                        {
        if (state != TransactionState.NOT_STARTED) {
            throw new IllegalStateException("Transaction already started");
        }

        state = TransactionState.STARTED;
    }

commit()

void org.keycloak.models.AbstractKeycloakTransaction.commit ( )

inlineinherited

org.keycloak.models.KeycloakTransactionを実装しています。

                         {
        if (state != TransactionState.STARTED) {
            throw new IllegalStateException("Transaction in illegal state for commit: " + state);
        }

        commitImpl();

        state = TransactionState.FINISHED;
    }

commitImpl()

void org.keycloak.models.sessions.infinispan.changes.InfinispanChangelogBasedTransaction< K, V extends SessionEntity >.commitImpl ( )

inlineprotected

                                {
        for (Map.Entry<K, SessionUpdatesList<V>> entry : updates.entrySet()) {
            SessionUpdatesList<V> sessionUpdates = entry.getValue();
            SessionEntityWrapper<V> sessionWrapper = sessionUpdates.getEntityWrapper();

            RealmModel realm = sessionUpdates.getRealm();

            MergedUpdate<V> merged = MergedUpdate.computeUpdate(sessionUpdates.getUpdateTasks(), sessionWrapper);

            if (merged != null) {
                // Now run the operation in our cluster
                runOperationInCluster(entry.getKey(), merged, sessionWrapper);

                // Check if we need to send message to second DC
                remoteCacheInvoker.runTask(kcSession, realm, cacheName, entry.getKey(), merged, sessionWrapper);
            }
        }
    }

generateNewVersionAndWrapEntity()

SessionEntityWrapper<V> org.keycloak.models.sessions.infinispan.changes.InfinispanChangelogBasedTransaction< K, V extends SessionEntity >.generateNewVersionAndWrapEntity ( V  entity, Map< String, String >  localMetadata  )

inlineprivate

                                                                                                                 {
        return new SessionEntityWrapper<>(localMetadata, entity);
    }

get()

SessionEntityWrapper<V> org.keycloak.models.sessions.infinispan.changes.InfinispanChangelogBasedTransaction< K, V extends SessionEntity >.get ( K  key )

inline

                                              {
        SessionUpdatesList<V> myUpdates = updates.get(key);
        if (myUpdates == null) {
            SessionEntityWrapper<V> wrappedEntity = cache.get(key);
            if (wrappedEntity == null) {
                return null;
            }

            RealmModel realm = kcSession.realms().getRealm(wrappedEntity.getEntity().getRealmId());

            myUpdates = new SessionUpdatesList<>(realm, wrappedEntity);
            updates.put(key, myUpdates);

            return wrappedEntity;
        } else {
            V entity = myUpdates.getEntityWrapper().getEntity();

            // If entity is scheduled for remove, we don't return it.
            boolean scheduledForRemove = myUpdates.getUpdateTasks().stream().filter((SessionUpdateTask task) -> {

                return task.getOperation(entity) == SessionUpdateTask.CacheOperation.REMOVE;

            }).findFirst().isPresent();

            return scheduledForRemove ? null : myUpdates.getEntityWrapper();
        }
    }

getRollbackOnly()

boolean org.keycloak.models.AbstractKeycloakTransaction.getRollbackOnly ( )

inlineinherited

org.keycloak.models.KeycloakTransactionを実装しています。

                                     {
        return state == TransactionState.ROLLBACK_ONLY;
    }

getState()

TransactionState org.keycloak.models.AbstractKeycloakTransaction.getState ( )

inlineinherited

                                       {
        return state;
    }

isActive()

boolean org.keycloak.models.AbstractKeycloakTransaction.isActive ( )

inlineinherited

org.keycloak.models.KeycloakTransactionを実装しています。

                              {
        return state == TransactionState.STARTED || state == TransactionState.ROLLBACK_ONLY;
    }

reloadEntityInCurrentTransaction()

void org.keycloak.models.sessions.infinispan.changes.InfinispanChangelogBasedTransaction< K, V extends SessionEntity >.reloadEntityInCurrentTransaction ( RealmModel  realm, K  key, SessionEntityWrapper< V >  entity  )

inline

                                                                                                          {
        if (entity == null) {
            throw new IllegalArgumentException("Null entity not allowed");
        }

        SessionEntityWrapper<V> latestEntity = cache.get(key);
        if (latestEntity == null) {
            return;
        }

        SessionUpdatesList<V> newUpdates = new SessionUpdatesList<>(realm, latestEntity);

        SessionUpdatesList<V> existingUpdates = updates.get(key);
        if (existingUpdates != null) {
            newUpdates.setUpdateTasks(existingUpdates.getUpdateTasks());
        }

        updates.put(key, newUpdates);
    }

replace()

void org.keycloak.models.sessions.infinispan.changes.InfinispanChangelogBasedTransaction< K, V extends SessionEntity >.replace ( K  key, MergedUpdate< V >  task, SessionEntityWrapper< V >  oldVersionEntity  )

inlineprivate

                                                                                                {
        boolean replaced = false;
        int iteration = 0;
        V session = oldVersionEntity.getEntity();

        while (!replaced && iteration < InfinispanUtil.MAXIMUM_REPLACE_RETRIES) {
            iteration++;

            SessionEntityWrapper<V> newVersionEntity = generateNewVersionAndWrapEntity(session, oldVersionEntity.getLocalMetadata());

            // Atomic cluster-aware replace
            replaced = CacheDecorators.skipCacheStore(cache).replace(key, oldVersionEntity, newVersionEntity);

            // Replace fail. Need to load latest entity from cache, apply updates again and try to replace in cache again
            if (!replaced) {
                if (logger.isDebugEnabled()) {
                    logger.debugf("Replace failed for entity: %s, old version %s, new version %s. Will try again", key, oldVersionEntity.getVersion(), newVersionEntity.getVersion());
                }

                oldVersionEntity = cache.get(key);

                if (oldVersionEntity == null) {
                    logger.debugf("Entity %s not found. Maybe removed in the meantime. Replace task will be ignored", key);
                    return;
                }

                session = oldVersionEntity.getEntity();

                task.runUpdate(session);
            } else {
                if (logger.isTraceEnabled()) {
                    logger.tracef("Replace SUCCESS for entity: %s . old version: %d, new version: %d", key, oldVersionEntity.getVersion(), newVersionEntity.getVersion());
                }
            }
        }

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

    }

rollback()

void org.keycloak.models.AbstractKeycloakTransaction.rollback ( )

inlineinherited

org.keycloak.models.KeycloakTransactionを実装しています。

                           {
        if (state != TransactionState.STARTED && state != TransactionState.ROLLBACK_ONLY) {
            throw new IllegalStateException("Transaction in illegal state for rollback: " + state);
        }

        rollbackImpl();

        state = TransactionState.FINISHED;
    }

rollbackImpl()

void org.keycloak.models.sessions.infinispan.changes.InfinispanChangelogBasedTransaction< K, V extends SessionEntity >.rollbackImpl ( )

inlineprotected

                                  {
    }

runOperationInCluster()

void org.keycloak.models.sessions.infinispan.changes.InfinispanChangelogBasedTransaction< K, V extends SessionEntity >.runOperationInCluster ( K  key, MergedUpdate< V >  task, SessionEntityWrapper< V >  sessionWrapper  )

inlineprivate

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

        // Don't need to run update of underlying entity. Local updates were already run
        //task.runUpdate(session);

        switch (operation) {
            case REMOVE:
                // Just remove it
                CacheDecorators.skipCacheStore(cache)
                        .getAdvancedCache().withFlags(Flag.IGNORE_RETURN_VALUES)
                        .remove(key);
                break;
            case ADD:
                CacheDecorators.skipCacheStore(cache)
                        .getAdvancedCache().withFlags(Flag.IGNORE_RETURN_VALUES)
                        .put(key, sessionWrapper, task.getLifespanMs(), TimeUnit.MILLISECONDS);
                break;
            case ADD_IF_ABSENT:
                SessionEntityWrapper<V> existing = CacheDecorators.skipCacheStore(cache).putIfAbsent(key, sessionWrapper);
                if (existing != null) {
                    logger.debugf("Existing entity in cache for key: %s . Will update it", key);

                    // Apply updates on the existing entity and replace it
                    task.runUpdate(existing.getEntity());

                    replace(key, task, existing);
                }
                break;
            case REPLACE:
                replace(key, task, sessionWrapper);
                break;
            default:
                throw new IllegalStateException("Unsupported state " +  operation);
        }

    }

setRollbackOnly()

void org.keycloak.models.AbstractKeycloakTransaction.setRollbackOnly ( )

inlineinherited

org.keycloak.models.KeycloakTransactionを実装しています。

                                  {
        state = TransactionState.ROLLBACK_ONLY;
    }

メンバ詳解

cache

final Cache<K, SessionEntityWrapper<V> > org.keycloak.models.sessions.infinispan.changes.InfinispanChangelogBasedTransaction< K, V extends SessionEntity >.cache

private

cacheName

final String org.keycloak.models.sessions.infinispan.changes.InfinispanChangelogBasedTransaction< K, V extends SessionEntity >.cacheName

private

kcSession

final KeycloakSession org.keycloak.models.sessions.infinispan.changes.InfinispanChangelogBasedTransaction< K, V extends SessionEntity >.kcSession

private

logger

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

static

remoteCacheInvoker

final RemoteCacheInvoker org.keycloak.models.sessions.infinispan.changes.InfinispanChangelogBasedTransaction< K, V extends SessionEntity >.remoteCacheInvoker

private

state

TransactionState org.keycloak.models.AbstractKeycloakTransaction.state = TransactionState.NOT_STARTED

protectedinherited

updates

final Map<K, SessionUpdatesList<V> > org.keycloak.models.sessions.infinispan.changes.InfinispanChangelogBasedTransaction< K, V extends SessionEntity >.updates = new HashMap<>()

private

---

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

• D:/AppData/doxygen/keycloak/src/keycloak/src/main/java/org/keycloak/models/sessions/infinispan/changes/InfinispanChangelogBasedTransaction.java