org.keycloak.models.cache.infinispan.authorization.StoreFactoryCacheManager クラス

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

org.keycloak.models.cache.infinispan.authorization.StoreFactoryCacheManager 連携図

公開メンバ関数
	StoreFactoryCacheManager (Cache< String, Revisioned > cache, Cache< String, Long > revisions)
void	resourceServerUpdated (String id, Set< String > invalidations)
void	resourceServerRemoval (String id, Set< String > invalidations)
void	scopeUpdated (String id, String name, String serverId, Set< String > invalidations)
void	scopeRemoval (String id, String name, String serverId, Set< String > invalidations)
void	resourceUpdated (String id, String name, String type, Set< String > uris, Set< String > scopes, String serverId, String owner, Set< String > invalidations)
void	resourceRemoval (String id, String name, String type, Set< String > uris, String owner, Set< String > scopes, String serverId, Set< String > invalidations)
void	policyUpdated (String id, String name, Set< String > resources, Set< String > resourceTypes, Set< String > scopes, String serverId, Set< String > invalidations)
void	permissionTicketUpdated (String id, String owner, String requester, String resource, String scope, String serverId, Set< String > invalidations)
void	policyRemoval (String id, String name, Set< String > resources, Set< String > resourceTypes, Set< String > scopes, String serverId, Set< String > invalidations)
void	permissionTicketRemoval (String id, String owner, String requester, String resource, String scope, String serverId, 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(StoreFactoryCacheManager.class)

詳解

著者

Bill Burke

バージョン

Revision

1

構築子と解体子

StoreFactoryCacheManager()

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

inlineprotected

                                                                                                 {
        if (event instanceof AuthorizationCacheInvalidationEvent) {
            invalidations.add(event.getId());

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

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.authorization.StoreFactoryCacheManager.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;
    }

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

permissionTicketRemoval()

void org.keycloak.models.cache.infinispan.authorization.StoreFactoryCacheManager.permissionTicketRemoval ( String  id, String  owner, String  requester, String  resource, String  scope, String  serverId, Set< String >  invalidations  )

inline

                                                                                                                                                              {
        permissionTicketUpdated(id, owner, requester, resource, scope, serverId, invalidations);
    }

permissionTicketUpdated()

void org.keycloak.models.cache.infinispan.authorization.StoreFactoryCacheManager.permissionTicketUpdated ( String  id, String  owner, String  requester, String  resource, String  scope, String  serverId, Set< String >  invalidations  )

inline

                                                                                                                                                              {
        invalidations.add(id);
        invalidations.add(StoreFactoryCacheSession.getPermissionTicketByOwner(owner, serverId));
        invalidations.add(StoreFactoryCacheSession.getPermissionTicketByResource(resource, serverId));
        invalidations.add(StoreFactoryCacheSession.getPermissionTicketByGranted(requester, serverId));
        if (scope != null) {
            invalidations.add(StoreFactoryCacheSession.getPermissionTicketByScope(scope, serverId));
        }
    }

policyRemoval()

void org.keycloak.models.cache.infinispan.authorization.StoreFactoryCacheManager.policyRemoval ( String  id, String  name, Set< String >  resources, Set< String >  resourceTypes, Set< String >  scopes, String  serverId, Set< String >  invalidations  )

inline

                                                                                                                                                                        {
        policyUpdated(id, name, resources, resourceTypes, scopes, serverId, invalidations);
    }

policyUpdated()

void org.keycloak.models.cache.infinispan.authorization.StoreFactoryCacheManager.policyUpdated ( String  id, String  name, Set< String >  resources, Set< String >  resourceTypes, Set< String >  scopes, String  serverId, Set< String >  invalidations  )

inline

                                                                                                                                                                        {
        invalidations.add(id);
        invalidations.add(StoreFactoryCacheSession.getPolicyByNameCacheKey(name, serverId));

        if (resources != null) {
            for (String resource : resources) {
                invalidations.add(StoreFactoryCacheSession.getPolicyByResource(resource, serverId));
                if (Objects.nonNull(scopes)) {
                    for (String scope : scopes) {
                        invalidations.add(StoreFactoryCacheSession.getPolicyByResourceScope(scope, resource, serverId));
                    }
                }
            }
        }

        if (resourceTypes != null) {
            for (String type : resourceTypes) {
                invalidations.add(StoreFactoryCacheSession.getPolicyByResourceType(type, serverId));
            }
        }

        if (scopes != null) {
            for (String scope : scopes) {
                invalidations.add(StoreFactoryCacheSession.getPolicyByScope(scope, serverId));
                invalidations.add(StoreFactoryCacheSession.getPolicyByResourceScope(scope, null, serverId));
            }
        }
    }

resourceRemoval()

void org.keycloak.models.cache.infinispan.authorization.StoreFactoryCacheManager.resourceRemoval ( String  id, String  name, String  type, Set< String >  uris, String  owner, Set< String >  scopes, String  serverId, Set< String >  invalidations  )

inline

                                                                                                                                                                     {
        resourceUpdated(id, name, type, uris, scopes, serverId, owner, invalidations);
        addInvalidations(InResourcePredicate.create().resource(id), invalidations);
    }

resourceServerRemoval()

void org.keycloak.models.cache.infinispan.authorization.StoreFactoryCacheManager.resourceServerRemoval ( String  id, Set< String >  invalidations  )

inline

                                                                            {
        resourceServerUpdated(id, invalidations);

        addInvalidations(InResourceServerPredicate.create().resourceServer(id), invalidations);
    }

resourceServerUpdated()

void org.keycloak.models.cache.infinispan.authorization.StoreFactoryCacheManager.resourceServerUpdated ( String  id, Set< String >  invalidations  )

inline

                                                                            {
        invalidations.add(id);
        invalidations.add(StoreFactoryCacheSession.getResourceServerByClientCacheKey(id));
    }

resourceUpdated()

void org.keycloak.models.cache.infinispan.authorization.StoreFactoryCacheManager.resourceUpdated ( String  id, String  name, String  type, Set< String >  uris, Set< String >  scopes, String  serverId, String  owner, Set< String >  invalidations  )

inline

                                                                                                                                                                     {
        invalidations.add(id);
        invalidations.add(StoreFactoryCacheSession.getResourceByNameCacheKey(name, owner, serverId));
        invalidations.add(StoreFactoryCacheSession.getResourceByOwnerCacheKey(owner, serverId));
        invalidations.add(StoreFactoryCacheSession.getResourceByOwnerCacheKey(owner, null));
        invalidations.add(StoreFactoryCacheSession.getPermissionTicketByResource(id, serverId));

        if (type != null) {
            invalidations.add(StoreFactoryCacheSession.getResourceByTypeCacheKey(type, serverId));
            addInvalidations(InResourcePredicate.create().resource(type), invalidations);
        }

        if (uris != null) {
            for (String uri: uris) {
                invalidations.add(StoreFactoryCacheSession.getResourceByUriCacheKey(uri, serverId));
            }
        }

        if (scopes != null) {
            for (String scope : scopes) {
                invalidations.add(StoreFactoryCacheSession.getResourceByScopeCacheKey(scope, serverId));
                addInvalidations(InScopePredicate.create().scope(scope), invalidations);
            }
        }
    }

scopeRemoval()

void org.keycloak.models.cache.infinispan.authorization.StoreFactoryCacheManager.scopeRemoval ( String  id, String  name, String  serverId, Set< String >  invalidations  )

inline

                                                                                                 {
        scopeUpdated(id, name, serverId, invalidations);
        addInvalidations(InScopePredicate.create().scope(id), invalidations);
    }

scopeUpdated()

void org.keycloak.models.cache.infinispan.authorization.StoreFactoryCacheManager.scopeUpdated ( String  id, String  name, String  serverId, Set< String >  invalidations  )

inline

                                                                                                 {
        invalidations.add(id);
        invalidations.add(StoreFactoryCacheSession.getScopeByNameCacheKey(name, serverId));
        invalidations.add(StoreFactoryCacheSession.getResourceByScopeCacheKey(id, serverId));
        invalidations.add(StoreFactoryCacheSession.getPermissionTicketByScope(id, serverId));
    }

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.authorization.StoreFactoryCacheManager.logger = Logger.getLogger(StoreFactoryCacheManager.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/authorization/StoreFactoryCacheManager.java