org.keycloak.models.cache.infinispan.RealmCacheManager クラス

org.keycloak.models.cache.infinispan.RealmCacheManager の継承関係図

org.keycloak.models.cache.infinispan.RealmCacheManager 連携図

公開メンバ関数
	RealmCacheManager (Cache< String, Revisioned > cache, Cache< String, Long > revisions)
void	realmUpdated (String id, String name, Set< String > invalidations)
void	realmRemoval (String id, String name, Set< String > invalidations)
void	roleAdded (String roleContainerId, Set< String > invalidations)
void	roleUpdated (String roleContainerId, String roleName, Set< String > invalidations)
void	roleRemoval (String id, String roleName, String roleContainerId, Set< String > invalidations)
void	groupQueriesInvalidations (String realmId, Set< String > invalidations)
void	clientAdded (String realmId, String clientUUID, String clientId, Set< String > invalidations)
void	clientUpdated (String realmId, String clientUuid, String clientId, Set< String > invalidations)
void	clientRemoval (String realmId, String clientUUID, String clientId, Set< String > invalidations)
Cache< String, Revisioned >	getCache ()
long	getCurrentCounter ()
Long	getCurrentRevision (String id)
void	endRevisionBatch ()
Object	invalidateObject (String id)
void	addRevisioned (Revisioned object, long startupRevision)
void	addRevisioned (Revisioned object, long startupRevision, long lifespan)
void	clear ()
void	addInvalidations (Predicate< Map.Entry< String, Revisioned >> predicate, Set< String > invalidations)
void	sendInvalidationEvents (KeycloakSession session, Collection< InvalidationEvent > invalidationEvents, String eventKey)
void	invalidationEventReceived (InvalidationEvent event)

限定公開メンバ関数
Logger	getLogger ()
void	addInvalidationsFromEvent (InvalidationEvent event, Set< String > invalidations)
void	bumpVersion (String id)

限定公開変数類
final Cache< String, Long >	revisions
final Cache< String, Revisioned >	cache
final UpdateCounter	counter = new UpdateCounter()

関数
public< T extends Revisioned > T	get (String id, Class< T > type)

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

詳解

著者

Stian Thorgersen

構築子と解体子

RealmCacheManager()

org.keycloak.models.cache.infinispan.RealmCacheManager.RealmCacheManager ( Cache< String, Revisioned >  cache, Cache< String, Long >  revisions  )

inline

                                                                                             {
        super(cache, revisions);
    }

関数詳解

addInvalidations()

void org.keycloak.models.cache.infinispan.CacheManager.addInvalidations ( Predicate< Map.Entry< String, Revisioned >>  predicate, Set< String >  invalidations  )

inlineinherited

                                                                                                                {
        Iterator<Map.Entry<String, Revisioned>> it = getEntryIterator(predicate);
        while (it.hasNext()) {
            invalidations.add(it.next().getKey());
        }
    }

addInvalidationsFromEvent()

void org.keycloak.models.cache.infinispan.RealmCacheManager.addInvalidationsFromEvent ( InvalidationEvent  event, Set< String >  invalidations  )

inlineprotected

                                                                                                 {
        invalidations.add(event.getId());

        ((RealmCacheInvalidationEvent) event).addInvalidations(this, invalidations);
    }

addRevisioned() [1/2]

void org.keycloak.models.cache.infinispan.CacheManager.addRevisioned ( Revisioned  object, long  startupRevision  )

inlineinherited

                                                                       {
        addRevisioned(object, startupRevision, -1);
    }

addRevisioned() [2/2]

void org.keycloak.models.cache.infinispan.CacheManager.addRevisioned ( Revisioned  object, long  startupRevision, long  lifespan  )

inlineinherited

                                                                                      {
        //startRevisionBatch();
        String id = object.getId();
        try {
            //revisions.getAdvancedCache().lock(id);
            Long rev = revisions.get(id);
            if (rev == null) {
                rev = counter.current();
                revisions.put(id, rev);
            }
            revisions.startBatch();
            if (!revisions.getAdvancedCache().lock(id)) {
                if (getLogger().isTraceEnabled()) {
                    getLogger().tracev("Could not obtain version lock: {0}", id);
                }
                return;
            }
            rev = revisions.get(id);
            if (rev == null) {
                return;
            }
            if (rev > startupRevision) { // revision is ahead transaction start. Other transaction updated in the meantime. Don't cache
                if (getLogger().isTraceEnabled()) {
                    getLogger().tracev("Skipped cache. Current revision {0}, Transaction start revision {1}", object.getRevision(), startupRevision);
                }
                return;
            }
            if (rev.equals(object.getRevision())) {
                cache.putForExternalRead(id, object);
                return;
            }
            if (rev > object.getRevision()) { // revision is ahead, don't cache
                if (getLogger().isTraceEnabled()) getLogger().tracev("Skipped cache. Object revision {0}, Cache revision {1}", object.getRevision(), rev);
                return;
            }
            // revisions cache has a lower value than the object.revision, so update revision and add it to cache
            revisions.put(id, object.getRevision());
            if (lifespan < 0) cache.putForExternalRead(id, object);
            else cache.putForExternalRead(id, object, lifespan, TimeUnit.MILLISECONDS);
        } finally {
            endRevisionBatch();
        }

    }

bumpVersion()

void org.keycloak.models.cache.infinispan.CacheManager.bumpVersion ( String  id )

inlineprotectedinherited

                                          {
        long next = counter.next();
        Object rev = revisions.put(id, next);
    }

clear()

void org.keycloak.models.cache.infinispan.CacheManager.clear ( )

inlineinherited

                        {
        cache.clear();
        revisions.clear();
    }

clientAdded()

void org.keycloak.models.cache.infinispan.RealmCacheManager.clientAdded ( String  realmId, String  clientUUID, String  clientId, Set< String >  invalidations  )

inline

                                                                                                           {
        invalidations.add(RealmCacheSession.getRealmClientsQueryCacheKey(realmId));
    }

clientRemoval()

void org.keycloak.models.cache.infinispan.RealmCacheManager.clientRemoval ( String  realmId, String  clientUUID, String  clientId, Set< String >  invalidations  )

inline

                                                                                                             {
        invalidations.add(RealmCacheSession.getRealmClientsQueryCacheKey(realmId));
        invalidations.add(RealmCacheSession.getClientByClientIdCacheKey(clientId, realmId));

        addInvalidations(InClientPredicate.create().client(clientUUID), invalidations);
    }

clientUpdated()

void org.keycloak.models.cache.infinispan.RealmCacheManager.clientUpdated ( String  realmId, String  clientUuid, String  clientId, Set< String >  invalidations  )

inline

                                                                                                             {
        invalidations.add(RealmCacheSession.getClientByClientIdCacheKey(clientId, realmId));
    }

endRevisionBatch()

void org.keycloak.models.cache.infinispan.CacheManager.endRevisionBatch ( )

inlineinherited

                                   {
        try {
            revisions.endBatch(true);
        } catch (Exception e) {
        }

    }

get()

public<T extends Revisioned> T org.keycloak.models.cache.infinispan.CacheManager.get ( String  id, Class< T >  type  )

inlinepackageinherited

                                                                  {
        Revisioned o = (Revisioned)cache.get(id);
        if (o == null) {
            return null;
        }
        Long rev = revisions.get(id);
        if (rev == null) {
            if (getLogger().isTraceEnabled()) {
                getLogger().tracev("get() missing rev {0}", id);
            }
            return null;
        }
        long oRev = o.getRevision() == null ? -1L : o.getRevision().longValue();
        if (rev > oRev) {
            if (getLogger().isTraceEnabled()) {
                getLogger().tracev("get() rev: {0} o.rev: {1}", rev.longValue(), oRev);
            }
            return null;
        }
        return o != null && type.isInstance(o) ? type.cast(o) : null;
    }

getCache()

Cache<String, Revisioned> org.keycloak.models.cache.infinispan.CacheManager.getCache ( )

inlineinherited

                                                {
        return cache;
    }

getCurrentCounter()

long org.keycloak.models.cache.infinispan.CacheManager.getCurrentCounter ( )

inlineinherited

                                    {
        return counter.current();
    }

getCurrentRevision()

Long org.keycloak.models.cache.infinispan.CacheManager.getCurrentRevision ( String  id )

inlineinherited

                                              {
        Long revision = revisions.get(id);
        if (revision == null) {
            revision = counter.current();
        }

        return revision;
    }

getLogger()

Logger org.keycloak.models.cache.infinispan.RealmCacheManager.getLogger ( )

inlineprotected

                                 {
        return logger;
    }

groupQueriesInvalidations()

void org.keycloak.models.cache.infinispan.RealmCacheManager.groupQueriesInvalidations ( String  realmId, Set< String >  invalidations  )

inline

                                                                                     {
        invalidations.add(RealmCacheSession.getGroupsQueryCacheKey(realmId));
        invalidations.add(RealmCacheSession.getTopGroupsQueryCacheKey(realmId));
        addInvalidations(GroupListPredicate.create().realm(realmId), invalidations);
    }

invalidateObject()

Object org.keycloak.models.cache.infinispan.CacheManager.invalidateObject ( String  id )

inlineinherited

                                              {
        Revisioned removed = (Revisioned)cache.remove(id);

        if (getLogger().isTraceEnabled()) {
            getLogger().tracef("Removed key='%s', value='%s' from cache", id, removed);
        }

        bumpVersion(id);
        return removed;
    }

invalidationEventReceived()

void org.keycloak.models.cache.infinispan.CacheManager.invalidationEventReceived ( InvalidationEvent  event )

inlineinherited

                                                                   {
        Set<String> invalidations = new HashSet<>();

        addInvalidationsFromEvent(event, invalidations);

        getLogger().debugf("[%s] Invalidating %d cache items after received event %s", cache.getCacheManager().getAddress(), invalidations.size(), event);

        for (String invalidation : invalidations) {
            invalidateObject(invalidation);
        }
    }

realmRemoval()

void org.keycloak.models.cache.infinispan.RealmCacheManager.realmRemoval ( String  id, String  name, Set< String >  invalidations  )

inline

                                                                                {
        realmUpdated(id, name, invalidations);

        addInvalidations(InRealmPredicate.create().realm(id), invalidations);
    }

realmUpdated()

void org.keycloak.models.cache.infinispan.RealmCacheManager.realmUpdated ( String  id, String  name, Set< String >  invalidations  )

inline

                                                                                {
        invalidations.add(id);
        invalidations.add(RealmCacheSession.getRealmByNameCacheKey(name));
    }

roleAdded()

void org.keycloak.models.cache.infinispan.RealmCacheManager.roleAdded ( String  roleContainerId, Set< String >  invalidations  )

inline

                                                                             {
        invalidations.add(RealmCacheSession.getRolesCacheKey(roleContainerId));
    }

roleRemoval()

void org.keycloak.models.cache.infinispan.RealmCacheManager.roleRemoval ( String  id, String  roleName, String  roleContainerId, Set< String >  invalidations  )

inline

                                                                                                           {
        invalidations.add(RealmCacheSession.getRolesCacheKey(roleContainerId));
        invalidations.add(RealmCacheSession.getRoleByNameCacheKey(roleContainerId, roleName));

        addInvalidations(HasRolePredicate.create().role(id), invalidations);
    }

roleUpdated()

void org.keycloak.models.cache.infinispan.RealmCacheManager.roleUpdated ( String  roleContainerId, String  roleName, Set< String >  invalidations  )

inline

                                                                                                {
        invalidations.add(RealmCacheSession.getRoleByNameCacheKey(roleContainerId, roleName));
    }

sendInvalidationEvents()

void org.keycloak.models.cache.infinispan.CacheManager.sendInvalidationEvents ( KeycloakSession  session, Collection< InvalidationEvent >  invalidationEvents, String  eventKey  )

inlineinherited

                                                                                                                                   {
        ClusterProvider clusterProvider = session.getProvider(ClusterProvider.class);

        // Maybe add InvalidationEvent, which will be collection of all invalidationEvents? That will reduce cluster traffic even more.
        for (InvalidationEvent event : invalidationEvents) {
            clusterProvider.notify(eventKey, event, true, ClusterProvider.DCNotify.ALL_DCS);
        }
    }

メンバ詳解

cache

final Cache<String, Revisioned> org.keycloak.models.cache.infinispan.CacheManager.cache

protectedinherited

counter

final UpdateCounter org.keycloak.models.cache.infinispan.CacheManager.counter = new UpdateCounter()

protectedinherited

logger

final Logger org.keycloak.models.cache.infinispan.RealmCacheManager.logger = Logger.getLogger(RealmCacheManager.class)

staticprivate

revisions

final Cache<String, Long> org.keycloak.models.cache.infinispan.CacheManager.revisions

protectedinherited

---

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

• D:/AppData/doxygen/keycloak/src/keycloak/src/main/java/org/keycloak/models/cache/infinispan/RealmCacheManager.java