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

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

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

公開メンバ関数
	UserCacheManager (Cache< String, Revisioned > cache, Cache< String, Long > revisions)
void	clear ()
void	userUpdatedInvalidations (String userId, String username, String email, String realmId, Set< String > invalidations)
void	fullUserInvalidation (String userId, String username, String email, String realmId, boolean identityFederationEnabled, Map< String, String > federatedIdentities, Set< String > invalidations)
void	federatedIdentityLinkUpdatedInvalidation (String userId, Set< String > invalidations)
void	federatedIdentityLinkRemovedInvalidation (String userId, String realmId, String identityProviderId, String socialUserId, Set< String > invalidations)
void	consentInvalidation (String userId, Set< String > invalidations)
void	invalidateRealmUsers (String realm, 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	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)

限定公開変数類
volatile boolean	enabled = true
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)

非公開メンバ関数
InRealmPredicate	getInRealmPredicate (String realmId)

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

詳解

著者

Stian Thorgersen

構築子と解体子

UserCacheManager()

org.keycloak.models.cache.infinispan.UserCacheManager.UserCacheManager ( 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.UserCacheManager.addInvalidationsFromEvent ( InvalidationEvent  event, Set< String >  invalidations  )

inlineprotected

                                                                                                 {
        ((UserCacheInvalidationEvent) 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.UserCacheManager.clear ( )

inline

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

consentInvalidation()

void org.keycloak.models.cache.infinispan.UserCacheManager.consentInvalidation ( String  userId, Set< String >  invalidations  )

inline

                                                                              {
        invalidations.add(UserCacheSession.getConsentCacheKey(userId));
    }

endRevisionBatch()

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

inlineinherited

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

    }

federatedIdentityLinkRemovedInvalidation()

void org.keycloak.models.cache.infinispan.UserCacheManager.federatedIdentityLinkRemovedInvalidation ( String  userId, String  realmId, String  identityProviderId, String  socialUserId, Set< String >  invalidations  )

inline

                                                                                                                                                                   {
        invalidations.add(UserCacheSession.getFederatedIdentityLinksCacheKey(userId));
        if (identityProviderId != null) {
            invalidations.add(UserCacheSession.getUserByFederatedIdentityCacheKey(realmId, identityProviderId, socialUserId));
        }
    }

federatedIdentityLinkUpdatedInvalidation()

void org.keycloak.models.cache.infinispan.UserCacheManager.federatedIdentityLinkUpdatedInvalidation ( String  userId, Set< String >  invalidations  )

inline

                                                                                                   {
        invalidations.add(UserCacheSession.getFederatedIdentityLinksCacheKey(userId));
    }

fullUserInvalidation()

void org.keycloak.models.cache.infinispan.UserCacheManager.fullUserInvalidation ( String  userId, String  username, String  email, String  realmId, boolean  identityFederationEnabled, Map< String, String >  federatedIdentities, Set< String >  invalidations  )

inline

                                                                                                                                                                                                          {
        userUpdatedInvalidations(userId, username, email, realmId, invalidations);

        if (identityFederationEnabled) {
            // Invalidate all keys for lookup this user by any identityProvider link
            for (Map.Entry<String, String> socialLink : federatedIdentities.entrySet()) {
                String fedIdentityCacheKey = UserCacheSession.getUserByFederatedIdentityCacheKey(realmId, socialLink.getKey(), socialLink.getValue());
                invalidations.add(fedIdentityCacheKey);
            }

            // Invalidate federationLinks of user
            invalidations.add(UserCacheSession.getFederatedIdentityLinksCacheKey(userId));
        }

        // Consents
        invalidations.add(UserCacheSession.getConsentCacheKey(userId));
    }

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;
    }

getInRealmPredicate()

InRealmPredicate org.keycloak.models.cache.infinispan.UserCacheManager.getInRealmPredicate ( String  realmId )

inlineprivate

                                                                 {
        return InRealmPredicate.create().realm(realmId);
    }

getLogger()

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

inlineprotected

                                 {
        return logger;
    }

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;
    }

invalidateRealmUsers()

void org.keycloak.models.cache.infinispan.UserCacheManager.invalidateRealmUsers ( String  realm, Set< String >  invalidations  )

inline

                                                                              {
        InRealmPredicate inRealmPredicate = getInRealmPredicate(realm);
        addInvalidations(inRealmPredicate, invalidations);
    }

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);
        }
    }

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);
        }
    }

userUpdatedInvalidations()

void org.keycloak.models.cache.infinispan.UserCacheManager.userUpdatedInvalidations ( String  userId, String  username, String  email, String  realmId, Set< String >  invalidations  )

inline

                                                                                                                                  {
        invalidations.add(userId);
        if (email != null) invalidations.add(UserCacheSession.getUserByEmailCacheKey(realmId, email));
        invalidations.add(UserCacheSession.getUserByUsernameCacheKey(realmId, username));
    }

メンバ詳解

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

enabled

volatile boolean org.keycloak.models.cache.infinispan.UserCacheManager.enabled = true

protected

logger

final Logger org.keycloak.models.cache.infinispan.UserCacheManager.logger = Logger.getLogger(UserCacheManager.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/UserCacheManager.java