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

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

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

公開メンバ関数
	UserCacheSession (UserCacheManager cache, KeycloakSession session)
void	clear ()
UserProvider	getDelegate ()
void	registerUserInvalidation (RealmModel realm, CachedUser user)
void	evict (RealmModel realm, UserModel user)
void	evict (RealmModel realm)
UserModel	getUserById (String id, RealmModel realm)
UserModel	getUserByUsername (String username, RealmModel realm)
UserModel	getUserByEmail (String email, RealmModel realm)
void	close ()
UserModel	getUserByFederatedIdentity (FederatedIdentityModel socialLink, RealmModel realm)
List< UserModel >	getGroupMembers (RealmModel realm, GroupModel group, int firstResult, int maxResults)
List< UserModel >	getGroupMembers (RealmModel realm, GroupModel group)
List< UserModel >	getRoleMembers (RealmModel realm, RoleModel role, int firstResult, int maxResults)
List< UserModel >	getRoleMembers (RealmModel realm, RoleModel role)
UserModel	getServiceAccount (ClientModel client)
UserModel	findServiceAccount (ClientModel client)
List< UserModel >	getUsers (RealmModel realm, boolean includeServiceAccounts)
int	getUsersCount (RealmModel realm, boolean includeServiceAccount)
int	getUsersCount (RealmModel realm)
List< UserModel >	getUsers (RealmModel realm, int firstResult, int maxResults, boolean includeServiceAccounts)
List< UserModel >	getUsers (RealmModel realm)
List< UserModel >	getUsers (RealmModel realm, int firstResult, int maxResults)
List< UserModel >	searchForUser (String search, RealmModel realm)
List< UserModel >	searchForUser (String search, RealmModel realm, int firstResult, int maxResults)
List< UserModel >	searchForUser (Map< String, String > attributes, RealmModel realm)
List< UserModel >	searchForUser (Map< String, String > attributes, RealmModel realm, int firstResult, int maxResults)
List< UserModel >	searchForUserByUserAttribute (String attrName, String attrValue, RealmModel realm)
Set< FederatedIdentityModel >	getFederatedIdentities (UserModel user, RealmModel realm)
FederatedIdentityModel	getFederatedIdentity (UserModel user, String socialProvider, RealmModel realm)
void	updateConsent (RealmModel realm, String userId, UserConsentModel consent)
boolean	revokeConsentForClient (RealmModel realm, String userId, String clientInternalId)
void	addConsent (RealmModel realm, String userId, UserConsentModel consent)
UserConsentModel	getConsentByClient (RealmModel realm, String userId, String clientId)
List< UserConsentModel >	getConsents (RealmModel realm, String userId)
void	setNotBeforeForUser (RealmModel realm, UserModel user, int notBefore)
int	getNotBeforeOfUser (RealmModel realm, UserModel user)
UserModel	addUser (RealmModel realm, String id, String username, boolean addDefaultRoles, boolean addDefaultRequiredActions)
UserModel	addUser (RealmModel realm, String username)
boolean	removeUser (RealmModel realm, UserModel user)
void	addFederatedIdentity (RealmModel realm, UserModel user, FederatedIdentityModel socialLink)
void	updateFederatedIdentity (RealmModel realm, UserModel federatedUser, FederatedIdentityModel federatedIdentityModel)
boolean	removeFederatedIdentity (RealmModel realm, UserModel user, String socialProvider)
void	grantToAllUsers (RealmModel realm, RoleModel role)
void	preRemove (RealmModel realm)
void	preRemove (RealmModel realm, RoleModel role)
void	preRemove (RealmModel realm, GroupModel group)
void	preRemove (RealmModel realm, ClientModel client)
void	preRemove (ProtocolMapperModel protocolMapper)
void	preRemove (ClientScopeModel clientScope)
void	preRemove (RealmModel realm, ComponentModel component)
void	removeImportedUsers (RealmModel realm, String storageProviderId)
void	unlinkUsers (RealmModel realm, String storageProviderId)

限定公開メンバ関数
void	runInvalidations ()
UserModel	getUserAdapter (RealmModel realm, String userId, Long loaded, UserModel delegate)
UserModel	validateCache (RealmModel realm, CachedUser cached)
UserModel	cacheUser (RealmModel realm, UserModel delegate, Long revision)
void	fullyInvalidateUser (RealmModel realm, UserModel user)

限定公開変数類
UserCacheManager	cache
KeycloakSession	session
UserProvider	delegate
boolean	transactionActive
boolean	setRollbackOnly
final long	startupRevision
Set< String >	invalidations = new HashSet<>()
Set< String >	realmInvalidations = new HashSet<>()
Set< InvalidationEvent >	invalidationEvents = new HashSet<>()
Map< String, UserModel >	managedUsers = new HashMap<>()

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

静的関数
static String	getUserByUsernameCacheKey (String realmId, String username)
static String	getUserByEmailCacheKey (String realmId, String email)
static String	getUserByFederatedIdentityCacheKey (String realmId, String identityProvider, String socialUserId)
static String	getFederatedIdentityLinksCacheKey (String userId)
static String	getConsentCacheKey (String userId)

非公開メンバ関数
KeycloakTransaction	getTransaction ()
boolean	isRegisteredForInvalidation (RealmModel realm, String userId)
void	onCache (RealmModel realm, UserAdapter adapter, UserModel delegate)
void	invalidateConsent (String userId)
UserConsentModel	toConsentModel (RealmModel realm, CachedUserConsent cachedConsent)
void	invalidateFederationLink (String userId)
void	addRealmInvalidation (String realmId)

静的非公開メンバ関数
static String	getUserByFederatedIdentityCacheKey (String realmId, FederatedIdentityModel socialLink)

詳解

著者

Bill Burke

バージョン

Revision

1

構築子と解体子

UserCacheSession()

org.keycloak.models.cache.infinispan.UserCacheSession.UserCacheSession ( UserCacheManager  cache, KeycloakSession  session  )

inline

                                                                             {
        this.cache = cache;
        this.session = session;
        this.startupRevision = cache.getCurrentCounter();
        session.getTransactionManager().enlistAfterCompletion(getTransaction());
    }

関数詳解

addConsent()

void org.keycloak.models.cache.infinispan.UserCacheSession.addConsent ( RealmModel  realm, String  userId, UserConsentModel  consent  )

inline

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

                                                                                      {
        invalidateConsent(userId);
        getDelegate().addConsent(realm, userId, consent);
    }

addFederatedIdentity()

void org.keycloak.models.cache.infinispan.UserCacheSession.addFederatedIdentity ( RealmModel  realm, UserModel  user, FederatedIdentityModel  socialLink  )

inline

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

                                                                                                          {
        invalidateFederationLink(user.getId());
        getDelegate().addFederatedIdentity(realm, user, socialLink);
    }

addRealmInvalidation()

void org.keycloak.models.cache.infinispan.UserCacheSession.addRealmInvalidation ( String  realmId )

inlineprivate

                                                      {
        realmInvalidations.add(realmId);
        invalidationEvents.add(UserCacheRealmInvalidationEvent.create(realmId));
    }

addUser() [1/2]

UserModel org.keycloak.models.cache.infinispan.UserCacheSession.addUser ( RealmModel  realm, String  id, String  username, boolean  addDefaultRoles, boolean  addDefaultRequiredActions  )

inline

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

                                                                                                                                       {
        UserModel user = getDelegate().addUser(realm, id, username, addDefaultRoles, addDefaultRoles);
        // just in case the transaction is rolled back you need to invalidate the user and all cache queries for that user
        fullyInvalidateUser(realm, user);
        managedUsers.put(user.getId(), user);
        return user;
    }

addUser() [2/2]

UserModel org.keycloak.models.cache.infinispan.UserCacheSession.addUser ( RealmModel  realm, String  username  )

inline

org.keycloak.storage.user.UserRegistrationProviderを実装しています。

                                                                {
        UserModel user = getDelegate().addUser(realm, username);
        // just in case the transaction is rolled back you need to invalidate the user and all cache queries for that user
        fullyInvalidateUser(realm, user);
        managedUsers.put(user.getId(), user);
        return user;
    }

cacheUser()

UserModel org.keycloak.models.cache.infinispan.UserCacheSession.cacheUser ( RealmModel  realm, UserModel  delegate, Long  revision  )

inlineprotected

                                                                                       {
        int notBefore = getDelegate().getNotBeforeOfUser(realm, delegate);

        StorageId storageId = delegate.getFederationLink() != null ?
                new StorageId(delegate.getFederationLink(), delegate.getId()) : new StorageId(delegate.getId());
        CachedUser cached = null;
        UserAdapter adapter = null;

        if (!storageId.isLocal()) {
            ComponentModel component = realm.getComponent(storageId.getProviderId());
            UserStorageProviderModel model = new UserStorageProviderModel(component);
            if (!model.isEnabled()) {
                return new ReadOnlyUserModelDelegate(delegate) {
                    @Override
                    public boolean isEnabled() {
                        return false;
                    }
                };
            }
            UserStorageProviderModel.CachePolicy policy = model.getCachePolicy();
            if (policy != null && policy == UserStorageProviderModel.CachePolicy.NO_CACHE) {
                return delegate;
            }

            cached = new CachedUser(revision, realm, delegate, notBefore);
            adapter = new UserAdapter(cached, this, session, realm);
            onCache(realm, adapter, delegate);

            long lifespan = model.getLifespan();
            if (lifespan > 0) {
                cache.addRevisioned(cached, startupRevision, lifespan);
            } else {
                cache.addRevisioned(cached, startupRevision);
            }
        } else {
            cached = new CachedUser(revision, realm, delegate, notBefore);
            adapter = new UserAdapter(cached, this, session, realm);
            onCache(realm, adapter, delegate);
            cache.addRevisioned(cached, startupRevision);
        }

        return adapter;
    }

clear()

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

inline

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

                        {
        cache.clear();
        ClusterProvider cluster = session.getProvider(ClusterProvider.class);
        cluster.notify(InfinispanUserCacheProviderFactory.USER_CLEAR_CACHE_EVENTS, new ClearCacheEvent(), true, ClusterProvider.DCNotify.ALL_DCS);
    }

close()

void org.keycloak.models.cache.infinispan.UserCacheSession.close ( )

inline

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

                        {
        if (delegate != null) delegate.close();
    }

evict() [1/2]

void org.keycloak.models.cache.infinispan.UserCacheSession.evict ( RealmModel  realm, UserModel  user  )

inline

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

                                                        {
        if (!transactionActive) throw new IllegalStateException("Cannot call evict() without a transaction");
        getDelegate(); // invalidations need delegate set
        if (user instanceof CachedUserModel) {
            ((CachedUserModel)user).invalidate();
        } else {
            cache.userUpdatedInvalidations(user.getId(), user.getUsername(), user.getEmail(), realm.getId(), invalidations);
            invalidationEvents.add(UserUpdatedEvent.create(user.getId(), user.getUsername(), user.getEmail(), realm.getId()));
        }
    }

evict() [2/2]

void org.keycloak.models.cache.infinispan.UserCacheSession.evict ( RealmModel  realm )

inline

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

                                        {
        addRealmInvalidation(realm.getId());
    }

findServiceAccount()

UserModel org.keycloak.models.cache.infinispan.UserCacheSession.findServiceAccount ( ClientModel  client )

inline

                                                            {
        String username = ServiceAccountConstants.SERVICE_ACCOUNT_USER_PREFIX + client.getClientId();
        logger.tracev("getServiceAccount: {0}", username);
        username = username.toLowerCase();
        RealmModel realm = client.getRealm();
        if (realmInvalidations.contains(realm.getId())) {
            logger.tracev("realmInvalidations");
            return getDelegate().getServiceAccount(client);
        }
        String cacheKey = getUserByUsernameCacheKey(realm.getId(), username);
        if (invalidations.contains(cacheKey)) {
            logger.tracev("invalidations");
            return getDelegate().getServiceAccount(client);
        }
        UserListQuery query = cache.get(cacheKey, UserListQuery.class);

        String userId = null;
        if (query == null) {
            logger.tracev("query null");
            Long loaded = cache.getCurrentRevision(cacheKey);
            UserModel model = getDelegate().getServiceAccount(client);
            if (model == null) {
                logger.tracev("model from delegate null");
                return null;
            }
            userId = model.getId();
            if (invalidations.contains(userId)) return model;
            if (managedUsers.containsKey(userId)) {
                logger.tracev("return managed user");
                return managedUsers.get(userId);
            }

            UserModel adapter = getUserAdapter(realm, userId, loaded, model);
            if (adapter instanceof UserAdapter) { // this was cached, so we can cache query too
                query = new UserListQuery(loaded, cacheKey, realm, model.getId());
                cache.addRevisioned(query, startupRevision);
            }
            managedUsers.put(userId, adapter);
            return adapter;
        } else {
            userId = query.getUsers().iterator().next();
            if (invalidations.contains(userId)) {
                logger.tracev("invalidated cache return delegate");
                return getDelegate().getUserByUsername(username, realm);

            }
            logger.trace("return getUserById");
            return getUserById(userId, realm);
        }
    }

fullyInvalidateUser()

void org.keycloak.models.cache.infinispan.UserCacheSession.fullyInvalidateUser ( RealmModel  realm, UserModel  user  )

inlineprotected

                                                                         {
        Set<FederatedIdentityModel> federatedIdentities = realm.isIdentityFederationEnabled() ? getFederatedIdentities(user, realm) : null;

        UserFullInvalidationEvent event = UserFullInvalidationEvent.create(user.getId(), user.getUsername(), user.getEmail(), realm.getId(), realm.isIdentityFederationEnabled(), federatedIdentities);

        cache.fullUserInvalidation(user.getId(), user.getUsername(), user.getEmail(), realm.getId(), realm.isIdentityFederationEnabled(), event.getFederatedIdentities(), invalidations);
        invalidationEvents.add(event);
    }

getConsentByClient()

UserConsentModel org.keycloak.models.cache.infinispan.UserCacheSession.getConsentByClient ( RealmModel  realm, String  userId, String  clientId  )

inline

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

                                                                                                 {
        logger.tracev("getConsentByClient: {0}", userId);

        String cacheKey = getConsentCacheKey(userId);
        if (realmInvalidations.contains(realm.getId()) || invalidations.contains(userId) || invalidations.contains(cacheKey)) {
            return getDelegate().getConsentByClient(realm, userId, clientId);
        }

        CachedUserConsents cached = cache.get(cacheKey, CachedUserConsents.class);

        if (cached == null) {
            Long loaded = cache.getCurrentRevision(cacheKey);
            List<UserConsentModel> consents = getDelegate().getConsents(realm, userId);
            cached = new CachedUserConsents(loaded, cacheKey, realm, consents);
            cache.addRevisioned(cached, startupRevision);
        }
        CachedUserConsent cachedConsent = cached.getConsents().get(clientId);
        if (cachedConsent == null) return null;
        return toConsentModel(realm, cachedConsent);
    }

getConsentCacheKey()

static String org.keycloak.models.cache.infinispan.UserCacheSession.getConsentCacheKey ( String  userId )

inlinestaticpackage

                                                    {
        return userId + ".consents";
    }

getConsents()

List<UserConsentModel> org.keycloak.models.cache.infinispan.UserCacheSession.getConsents ( RealmModel  realm, String  userId  )

inline

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

                                                                               {
        logger.tracev("getConsents: {0}", userId);

        String cacheKey = getConsentCacheKey(userId);
        if (realmInvalidations.contains(realm.getId()) || invalidations.contains(userId) || invalidations.contains(cacheKey)) {
            return getDelegate().getConsents(realm, userId);
        }

        CachedUserConsents cached = cache.get(cacheKey, CachedUserConsents.class);

        if (cached == null) {
            Long loaded = cache.getCurrentRevision(cacheKey);
            List<UserConsentModel> consents = getDelegate().getConsents(realm, userId);
            cached = new CachedUserConsents(loaded, cacheKey, realm, consents);
            cache.addRevisioned(cached, startupRevision);
            return consents;
        } else {
            List<UserConsentModel> result = new LinkedList<>();
            for (CachedUserConsent cachedConsent : cached.getConsents().values()) {
                UserConsentModel consent = toConsentModel(realm, cachedConsent);
                if (consent != null) {
                    result.add(consent);
                }
            }
            return result;
        }
    }

getDelegate()

UserProvider org.keycloak.models.cache.infinispan.UserCacheSession.getDelegate ( )

inline

                                      {
        if (!transactionActive) throw new IllegalStateException("Cannot access delegate without a transaction");
        if (delegate != null) return delegate;
        delegate = session.userStorageManager();

        return delegate;
    }

getFederatedIdentities()

Set<FederatedIdentityModel> org.keycloak.models.cache.infinispan.UserCacheSession.getFederatedIdentities ( UserModel  user, RealmModel  realm  )

inline

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

                                                                                                {
        logger.tracev("getFederatedIdentities: {0}", user.getUsername());

        String cacheKey = getFederatedIdentityLinksCacheKey(user.getId());
        if (realmInvalidations.contains(realm.getId()) || invalidations.contains(user.getId()) || invalidations.contains(cacheKey)) {
            return getDelegate().getFederatedIdentities(user, realm);
        }

        CachedFederatedIdentityLinks cachedLinks = cache.get(cacheKey, CachedFederatedIdentityLinks.class);

        if (cachedLinks == null) {
            Long loaded = cache.getCurrentRevision(cacheKey);
            Set<FederatedIdentityModel> federatedIdentities = getDelegate().getFederatedIdentities(user, realm);
            cachedLinks = new CachedFederatedIdentityLinks(loaded, cacheKey, realm, federatedIdentities);
            cache.addRevisioned(cachedLinks, startupRevision);
            return federatedIdentities;
        } else {
            return new HashSet<>(cachedLinks.getFederatedIdentities());
        }
    }

getFederatedIdentity()

FederatedIdentityModel org.keycloak.models.cache.infinispan.UserCacheSession.getFederatedIdentity ( UserModel  user, String  socialProvider, RealmModel  realm  )

inline

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

                                                                                                                {
        logger.tracev("getFederatedIdentity: {0} {1}", user.getUsername(), socialProvider);

        String cacheKey = getFederatedIdentityLinksCacheKey(user.getId());
        if (realmInvalidations.contains(realm.getId()) || invalidations.contains(user.getId()) || invalidations.contains(cacheKey)) {
            return getDelegate().getFederatedIdentity(user, socialProvider, realm);
        }

        Set<FederatedIdentityModel> federatedIdentities = getFederatedIdentities(user, realm);
        for (FederatedIdentityModel socialLink : federatedIdentities) {
            if (socialLink.getIdentityProvider().equals(socialProvider)) {
                return socialLink;
            }
        }
        return null;
    }

getFederatedIdentityLinksCacheKey()

static String org.keycloak.models.cache.infinispan.UserCacheSession.getFederatedIdentityLinksCacheKey ( String  userId )

inlinestaticpackage

                                                                   {
        return userId + ".idplinks";
    }

getGroupMembers() [1/2]

List<UserModel> org.keycloak.models.cache.infinispan.UserCacheSession.getGroupMembers ( RealmModel  realm, GroupModel  group, int  firstResult, int  maxResults  )

inline

org.keycloak.storage.user.UserQueryProviderを実装しています。

                                                                                                                {
        return getDelegate().getGroupMembers(realm, group, firstResult, maxResults);
    }

getGroupMembers() [2/2]

List<UserModel> org.keycloak.models.cache.infinispan.UserCacheSession.getGroupMembers ( RealmModel  realm, GroupModel  group  )

inline

org.keycloak.storage.user.UserQueryProviderを実装しています。

                                                                               {
        return getDelegate().getGroupMembers(realm, group);
    }

getNotBeforeOfUser()

int org.keycloak.models.cache.infinispan.UserCacheSession.getNotBeforeOfUser ( RealmModel  realm, UserModel  user  )

inline

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

                                                                    {
        if (isRegisteredForInvalidation(realm, user.getId())) {
            return getDelegate().getNotBeforeOfUser(realm, user);
        }

        UserModel foundUser = getUserById(user.getId(), realm);
        if (foundUser instanceof UserAdapter) {
            return ((UserAdapter) foundUser).cached.getNotBefore();
        } else {
            return getDelegate().getNotBeforeOfUser(realm, user);
        }
    }

getRoleMembers() [1/2]

List<UserModel> org.keycloak.models.cache.infinispan.UserCacheSession.getRoleMembers ( RealmModel  realm, RoleModel  role, int  firstResult, int  maxResults  )

inline

org.keycloak.storage.user.UserQueryProviderを実装しています。

                                                                                                             {
        return getDelegate().getRoleMembers(realm, role, firstResult, maxResults);
    }

getRoleMembers() [2/2]

List<UserModel> org.keycloak.models.cache.infinispan.UserCacheSession.getRoleMembers ( RealmModel  realm, RoleModel  role  )

inline

org.keycloak.storage.user.UserQueryProviderを実装しています。

                                                                            {
        return getDelegate().getRoleMembers(realm, role);
    }    

getServiceAccount()

UserModel org.keycloak.models.cache.infinispan.UserCacheSession.getServiceAccount ( ClientModel  client )

inline

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

                                                           {
        // Just an attempt to find the user from cache by default serviceAccount username
        UserModel user = findServiceAccount(client);
        if (user != null && user.getServiceAccountClientLink() != null && user.getServiceAccountClientLink().equals(client.getId())) {
            return user;
        }

        return getDelegate().getServiceAccount(client);
    }

getTransaction()

KeycloakTransaction org.keycloak.models.cache.infinispan.UserCacheSession.getTransaction ( )

inlineprivate

                                                 {
        return new KeycloakTransaction() {
            @Override
            public void begin() {
                transactionActive = true;
            }

            @Override
            public void commit() {
                runInvalidations();
                transactionActive = false;
            }

            @Override
            public void rollback() {
                setRollbackOnly = true;
                runInvalidations();
                transactionActive = false;
            }

            @Override
            public void setRollbackOnly() {
                setRollbackOnly = true;
            }

            @Override
            public boolean getRollbackOnly() {
                return setRollbackOnly;
            }

            @Override
            public boolean isActive() {
                return transactionActive;
            }
        };
    }

getUserAdapter()

UserModel org.keycloak.models.cache.infinispan.UserCacheSession.getUserAdapter ( RealmModel  realm, String  userId, Long  loaded, UserModel  delegate  )

inlineprotected

                                                                                                         {
        CachedUser cached = cache.get(userId, CachedUser.class);
        if (cached == null) {
            return cacheUser(realm, delegate, loaded);
        } else {
            return validateCache(realm, cached);
        }
    }

getUserByEmail()

UserModel org.keycloak.models.cache.infinispan.UserCacheSession.getUserByEmail ( String  email, RealmModel  realm  )

inline

org.keycloak.storage.user.UserLookupProviderを実装しています。

                                                                    {
        if (email == null) return null;
        email = email.toLowerCase();
        if (realmInvalidations.contains(realm.getId())) {
            return getDelegate().getUserByEmail(email, realm);
        }
        String cacheKey = getUserByEmailCacheKey(realm.getId(), email);
        if (invalidations.contains(cacheKey)) {
            return getDelegate().getUserByEmail(email, realm);
        }
        UserListQuery query = cache.get(cacheKey, UserListQuery.class);

        String userId = null;
        if (query == null) {
            Long loaded = cache.getCurrentRevision(cacheKey);
            UserModel model = getDelegate().getUserByEmail(email, realm);
            if (model == null) return null;
            userId = model.getId();
            if (invalidations.contains(userId)) return model;
            if (managedUsers.containsKey(userId)) return managedUsers.get(userId);

            UserModel adapter = getUserAdapter(realm, userId, loaded, model);
            if (adapter instanceof UserAdapter) {
                query = new UserListQuery(loaded, cacheKey, realm, model.getId());
                cache.addRevisioned(query, startupRevision);
            }
            managedUsers.put(userId, adapter);
            return adapter;
        } else {
            userId = query.getUsers().iterator().next();
            if (invalidations.contains(userId)) {
                return getDelegate().getUserByEmail(email, realm);

            }
            return getUserById(userId, realm);
        }
    }

getUserByEmailCacheKey()

static String org.keycloak.models.cache.infinispan.UserCacheSession.getUserByEmailCacheKey ( String  realmId, String  email  )

inlinestaticpackage

                                                                       {
        return realmId + ".email." + email;
    }

getUserByFederatedIdentity()

UserModel org.keycloak.models.cache.infinispan.UserCacheSession.getUserByFederatedIdentity ( FederatedIdentityModel  socialLink, RealmModel  realm  )

inline

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

                                                                                                     {
        if (socialLink == null) return null;
        if (!realm.isIdentityFederationEnabled()) return null;

        if (realmInvalidations.contains(realm.getId())) {
            return getDelegate().getUserByFederatedIdentity(socialLink, realm);
        }
        String cacheKey = getUserByFederatedIdentityCacheKey(realm.getId(), socialLink);
        if (invalidations.contains(cacheKey)) {
            return getDelegate().getUserByFederatedIdentity(socialLink, realm);
        }
        UserListQuery query = cache.get(cacheKey, UserListQuery.class);

        String userId = null;
        if (query == null) {
            Long loaded = cache.getCurrentRevision(cacheKey);
            UserModel model = getDelegate().getUserByFederatedIdentity(socialLink, realm);
            if (model == null) return null;
            userId = model.getId();
            if (invalidations.contains(userId)) return model;
            if (managedUsers.containsKey(userId)) return managedUsers.get(userId);

            UserModel adapter = getUserAdapter(realm, userId, loaded, model);
            if (adapter instanceof UserAdapter) {
                query = new UserListQuery(loaded, cacheKey, realm, model.getId());
                cache.addRevisioned(query, startupRevision);
            }

            managedUsers.put(userId, adapter);
            return adapter;
        } else {
            userId = query.getUsers().iterator().next();
            if (invalidations.contains(userId)) {
                invalidations.add(cacheKey);
                return getDelegate().getUserByFederatedIdentity(socialLink, realm);

            }
            return getUserById(userId, realm);
        }
    }

getUserByFederatedIdentityCacheKey() [1/2]

static String org.keycloak.models.cache.infinispan.UserCacheSession.getUserByFederatedIdentityCacheKey ( String  realmId, FederatedIdentityModel  socialLink  )

inlinestaticprivate

                                                                                                                {
        return getUserByFederatedIdentityCacheKey(realmId, socialLink.getIdentityProvider(), socialLink.getUserId());
    }

getUserByFederatedIdentityCacheKey() [2/2]

static String org.keycloak.models.cache.infinispan.UserCacheSession.getUserByFederatedIdentityCacheKey ( String  realmId, String  identityProvider, String  socialUserId  )

inlinestaticpackage

                                                                                                                   {
        return realmId + ".idp." + identityProvider + "." + socialUserId;
    }

getUserById()

UserModel org.keycloak.models.cache.infinispan.UserCacheSession.getUserById ( String  id, RealmModel  realm  )

inline

org.keycloak.storage.user.UserLookupProviderを実装しています。

                                                              {
        logger.tracev("getuserById {0}", id);
        if (isRegisteredForInvalidation(realm, id)) {
            logger.trace("registered for invalidation return delegate");
            return getDelegate().getUserById(id, realm);
        }
        if (managedUsers.containsKey(id)) {
            logger.trace("return managedusers");
            return managedUsers.get(id);
        }

        CachedUser cached = cache.get(id, CachedUser.class);
        UserModel adapter = null;
        if (cached == null) {
            logger.trace("not cached");
            Long loaded = cache.getCurrentRevision(id);
            UserModel delegate = getDelegate().getUserById(id, realm);
            if (delegate == null) {
                logger.trace("delegate returning null");
                return null;
            }
            adapter = cacheUser(realm, delegate, loaded);
        } else {
            adapter = validateCache(realm, cached);
        }
        managedUsers.put(id, adapter);
        return adapter;
    }

getUserByUsername()

UserModel org.keycloak.models.cache.infinispan.UserCacheSession.getUserByUsername ( String  username, RealmModel  realm  )

inline

org.keycloak.storage.user.UserLookupProviderを実装しています。

                                                                          {
        logger.tracev("getUserByUsername: {0}", username);
        username = username.toLowerCase();
        if (realmInvalidations.contains(realm.getId())) {
            logger.tracev("realmInvalidations");
            return getDelegate().getUserByUsername(username, realm);
        }
        String cacheKey = getUserByUsernameCacheKey(realm.getId(), username);
        if (invalidations.contains(cacheKey)) {
            logger.tracev("invalidations");
            return getDelegate().getUserByUsername(username, realm);
        }
        UserListQuery query = cache.get(cacheKey, UserListQuery.class);

        String userId = null;
        if (query == null) {
            logger.tracev("query null");
            Long loaded = cache.getCurrentRevision(cacheKey);
            UserModel model = getDelegate().getUserByUsername(username, realm);
            if (model == null) {
                logger.tracev("model from delegate null");
                return null;
            }
            userId = model.getId();
            if (invalidations.contains(userId)) return model;
            if (managedUsers.containsKey(userId)) {
                logger.tracev("return managed user");
                return managedUsers.get(userId);
            }

            UserModel adapter = getUserAdapter(realm, userId, loaded, model);
            if (adapter instanceof UserAdapter) { // this was cached, so we can cache query too
                query = new UserListQuery(loaded, cacheKey, realm, model.getId());
                cache.addRevisioned(query, startupRevision);
            }
            managedUsers.put(userId, adapter);
            return adapter;
        } else {
            userId = query.getUsers().iterator().next();
            if (invalidations.contains(userId)) {
                logger.tracev("invalidated cache return delegate");
                return getDelegate().getUserByUsername(username, realm);

            }
            logger.trace("return getUserById");
            return getUserById(userId, realm);
        }
    }

getUserByUsernameCacheKey()

static String org.keycloak.models.cache.infinispan.UserCacheSession.getUserByUsernameCacheKey ( String  realmId, String  username  )

inlinestaticpackage

                                                                             {
        return realmId + ".username." + username;
    }

getUsers() [1/4]

List<UserModel> org.keycloak.models.cache.infinispan.UserCacheSession.getUsers ( RealmModel  realm, boolean  includeServiceAccounts  )

inline

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

                                                                                      {
        return getDelegate().getUsers(realm, includeServiceAccounts);
    }

getUsers() [2/4]

List<UserModel> org.keycloak.models.cache.infinispan.UserCacheSession.getUsers ( RealmModel  realm, int  firstResult, int  maxResults, boolean  includeServiceAccounts  )

inline

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

                                                                                                                       {
        return getDelegate().getUsers(realm, firstResult, maxResults, includeServiceAccounts);
    }

getUsers() [3/4]

List<UserModel> org.keycloak.models.cache.infinispan.UserCacheSession.getUsers ( RealmModel  realm )

inline

org.keycloak.storage.user.UserQueryProviderを実装しています。

                                                      {
        return getUsers(realm, false);
    }

getUsers() [4/4]

List<UserModel> org.keycloak.models.cache.infinispan.UserCacheSession.getUsers ( RealmModel  realm, int  firstResult, int  maxResults  )

inline

org.keycloak.storage.user.UserQueryProviderを実装しています。

                                                                                       {
         return getUsers(realm, firstResult, maxResults, false);
    }

getUsersCount() [1/2]

int org.keycloak.models.cache.infinispan.UserCacheSession.getUsersCount ( RealmModel  realm, boolean  includeServiceAccount  )

inline

org.keycloak.storage.user.UserQueryProviderを実装しています。

                                                                              {
        return getDelegate().getUsersCount(realm, includeServiceAccount);
    }

getUsersCount() [2/2]

int org.keycloak.models.cache.infinispan.UserCacheSession.getUsersCount ( RealmModel  realm )

inline

org.keycloak.storage.user.UserQueryProviderを実装しています。

                                               {
        return getUsersCount(realm, false);
    }

grantToAllUsers()

void org.keycloak.models.cache.infinispan.UserCacheSession.grantToAllUsers ( RealmModel  realm, RoleModel  role  )

inline

org.keycloak.storage.user.UserBulkUpdateProviderを実装しています。

                                                                  {
        addRealmInvalidation(realm.getId()); // easier to just invalidate whole realm
        getDelegate().grantToAllUsers(realm, role);
    }

invalidateConsent()

void org.keycloak.models.cache.infinispan.UserCacheSession.invalidateConsent ( String  userId )

inlineprivate

                                                  {
        cache.consentInvalidation(userId, invalidations);
        invalidationEvents.add(UserConsentsUpdatedEvent.create(userId));
    }

invalidateFederationLink()

void org.keycloak.models.cache.infinispan.UserCacheSession.invalidateFederationLink ( String  userId )

inlineprivate

                                                         {
        cache.federatedIdentityLinkUpdatedInvalidation(userId, invalidations);
        invalidationEvents.add(UserFederationLinkUpdatedEvent.create(userId));
    }

isRegisteredForInvalidation()

boolean org.keycloak.models.cache.infinispan.UserCacheSession.isRegisteredForInvalidation ( RealmModel  realm, String  userId  )

inlineprivate

                                                                                 {
        return realmInvalidations.contains(realm.getId()) || invalidations.contains(userId);
    }

onCache()

void org.keycloak.models.cache.infinispan.UserCacheSession.onCache ( RealmModel  realm, UserAdapter  adapter, UserModel  delegate  )

inlineprivate

                                                                                    {
        ((OnUserCache)getDelegate()).onCache(realm, adapter, delegate);
        ((OnUserCache)session.userCredentialManager()).onCache(realm, adapter, delegate);
    }

preRemove() [1/7]

void org.keycloak.models.cache.infinispan.UserCacheSession.preRemove ( RealmModel  realm )

inline

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

                                            {
        addRealmInvalidation(realm.getId());
        getDelegate().preRemove(realm);
    }

preRemove() [2/7]

void org.keycloak.models.cache.infinispan.UserCacheSession.preRemove ( RealmModel  realm, RoleModel  role  )

inline

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

                                                            {
        addRealmInvalidation(realm.getId()); // easier to just invalidate whole realm
        getDelegate().preRemove(realm, role);
    }

preRemove() [3/7]

void org.keycloak.models.cache.infinispan.UserCacheSession.preRemove ( RealmModel  realm, GroupModel  group  )

inline

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

                                                              {
        addRealmInvalidation(realm.getId()); // easier to just invalidate whole realm
        getDelegate().preRemove(realm, group);
    }

preRemove() [4/7]

void org.keycloak.models.cache.infinispan.UserCacheSession.preRemove ( RealmModel  realm, ClientModel  client  )

inline

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

                                                                {
        addRealmInvalidation(realm.getId()); // easier to just invalidate whole realm
        getDelegate().preRemove(realm, client);
    }

preRemove() [5/7]

void org.keycloak.models.cache.infinispan.UserCacheSession.preRemove ( ProtocolMapperModel  protocolMapper )

inline

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

                                                              {
        getDelegate().preRemove(protocolMapper);
    }

preRemove() [6/7]

void org.keycloak.models.cache.infinispan.UserCacheSession.preRemove ( ClientScopeModel  clientScope )

inline

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

                                                        {
        // Not needed to invalidate realm probably. Just consents are affected ATM and they are checked if they exists
        getDelegate().preRemove(clientScope);
    }

preRemove() [7/7]

void org.keycloak.models.cache.infinispan.UserCacheSession.preRemove ( RealmModel  realm, ComponentModel  component  )

inline

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

                                                                      {
        if (!component.getProviderType().equals(UserStorageProvider.class.getName()) && !component.getProviderType().equals(ClientStorageProvider.class.getName())) return;
        addRealmInvalidation(realm.getId()); // easier to just invalidate whole realm
        getDelegate().preRemove(realm, component);

    }

registerUserInvalidation()

void org.keycloak.models.cache.infinispan.UserCacheSession.registerUserInvalidation ( RealmModel  realm, CachedUser  user  )

inline

                                                                           {
        cache.userUpdatedInvalidations(user.getId(), user.getUsername(), user.getEmail(), user.getRealm(), invalidations);
        invalidationEvents.add(UserUpdatedEvent.create(user.getId(), user.getUsername(), user.getEmail(), user.getRealm()));
    }

removeFederatedIdentity()

boolean org.keycloak.models.cache.infinispan.UserCacheSession.removeFederatedIdentity ( RealmModel  realm, UserModel  user, String  socialProvider  )

inline

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

                                                                                                    {
        // Needs to invalidate both directions
        FederatedIdentityModel socialLink = getFederatedIdentity(user, socialProvider, realm);

        UserFederationLinkRemovedEvent event = UserFederationLinkRemovedEvent.create(user.getId(), realm.getId(), socialLink);
        cache.federatedIdentityLinkRemovedInvalidation(user.getId(), realm.getId(), event.getIdentityProviderId(), event.getSocialUserId(), invalidations);
        invalidationEvents.add(event);

        return getDelegate().removeFederatedIdentity(realm, user, socialProvider);
    }

removeImportedUsers()

void org.keycloak.models.cache.infinispan.UserCacheSession.removeImportedUsers ( RealmModel  realm, String  storageProviderId  )

inline

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

                                                                                {
        getDelegate().removeImportedUsers(realm, storageProviderId);
        clear();
        addRealmInvalidation(realm.getId()); // easier to just invalidate whole realm
    }

removeUser()

boolean org.keycloak.models.cache.infinispan.UserCacheSession.removeUser ( RealmModel  realm, UserModel  user  )

inline

org.keycloak.storage.user.UserRegistrationProviderを実装しています。

                                                                {
         fullyInvalidateUser(realm, user);
        return getDelegate().removeUser(realm, user);
    }

revokeConsentForClient()

boolean org.keycloak.models.cache.infinispan.UserCacheSession.revokeConsentForClient ( RealmModel  realm, String  userId, String  clientInternalId  )

inline

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

                                                                                                    {
        invalidateConsent(userId);
        return getDelegate().revokeConsentForClient(realm, userId, clientInternalId);
    }

runInvalidations()

void org.keycloak.models.cache.infinispan.UserCacheSession.runInvalidations ( )

inlineprotected

                                      {
        for (String realmId : realmInvalidations) {
            cache.invalidateRealmUsers(realmId, invalidations);
        }
        for (String invalidation : invalidations) {
            cache.invalidateObject(invalidation);
        }

        cache.sendInvalidationEvents(session, invalidationEvents, InfinispanUserCacheProviderFactory.USER_INVALIDATION_EVENTS);
    }

searchForUser() [1/4]

List<UserModel> org.keycloak.models.cache.infinispan.UserCacheSession.searchForUser ( String  search, RealmModel  realm  )

inline

org.keycloak.storage.user.UserQueryProviderを実装しています。

                                                                          {
        return getDelegate().searchForUser(search, realm);
    }

searchForUser() [2/4]

List<UserModel> org.keycloak.models.cache.infinispan.UserCacheSession.searchForUser ( String  search, RealmModel  realm, int  firstResult, int  maxResults  )

inline

org.keycloak.storage.user.UserQueryProviderを実装しています。

                                                                                                           {
        return getDelegate().searchForUser(search, realm, firstResult, maxResults);
    }

searchForUser() [3/4]

List<UserModel> org.keycloak.models.cache.infinispan.UserCacheSession.searchForUser ( Map< String, String >  attributes, RealmModel  realm  )

inline

org.keycloak.storage.user.UserQueryProviderを実装しています。

                                                                                           {
        return getDelegate().searchForUser(attributes, realm);
    }

searchForUser() [4/4]

List<UserModel> org.keycloak.models.cache.infinispan.UserCacheSession.searchForUser ( Map< String, String >  attributes, RealmModel  realm, int  firstResult, int  maxResults  )

inline

org.keycloak.storage.user.UserQueryProviderを実装しています。

                                                                                                                            {
        return getDelegate().searchForUser(attributes, realm, firstResult, maxResults);
    }

searchForUserByUserAttribute()

List<UserModel> org.keycloak.models.cache.infinispan.UserCacheSession.searchForUserByUserAttribute ( String  attrName, String  attrValue, RealmModel  realm  )

inline

org.keycloak.storage.user.UserQueryProviderを実装しています。

                                                                                                             {
        return getDelegate().searchForUserByUserAttribute(attrName, attrValue, realm);
    }

setNotBeforeForUser()

void org.keycloak.models.cache.infinispan.UserCacheSession.setNotBeforeForUser ( RealmModel  realm, UserModel  user, int  notBefore  )

inline

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

                                                                                     {
        if (!isRegisteredForInvalidation(realm, user.getId())) {
            UserModel foundUser = getUserById(user.getId(), realm);
            if (foundUser instanceof UserAdapter) {
                ((UserAdapter) foundUser).invalidate();
            }
        }

        getDelegate().setNotBeforeForUser(realm, user, notBefore);

    }

toConsentModel()

UserConsentModel org.keycloak.models.cache.infinispan.UserCacheSession.toConsentModel ( RealmModel  realm, CachedUserConsent  cachedConsent  )

inlineprivate

                                                                                               {
        ClientModel client = session.realms().getClientById(cachedConsent.getClientDbId(), realm);
        if (client == null) {
            return null;
        }

        UserConsentModel consentModel = new UserConsentModel(client);
        consentModel.setCreatedDate(cachedConsent.getCreatedDate());
        consentModel.setLastUpdatedDate(cachedConsent.getLastUpdatedDate());

        for (String clientScopeId : cachedConsent.getClientScopeIds()) {
            ClientScopeModel clientScope = KeycloakModelUtils.findClientScopeById(realm, clientScopeId);
            if (clientScope != null) {
                consentModel.addGrantedClientScope(clientScope);
            }
        }

        return consentModel;
    }

unlinkUsers()

void org.keycloak.models.cache.infinispan.UserCacheSession.unlinkUsers ( RealmModel  realm, String  storageProviderId  )

inline

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

                                                                        {
        getDelegate().unlinkUsers(realm, storageProviderId);
        clear();
        addRealmInvalidation(realm.getId()); // easier to just invalidate whole realm

    }

updateConsent()

void org.keycloak.models.cache.infinispan.UserCacheSession.updateConsent ( RealmModel  realm, String  userId, UserConsentModel  consent  )

inline

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

                                                                                         {
        invalidateConsent(userId);
        getDelegate().updateConsent(realm, userId, consent);
    }

updateFederatedIdentity()

void org.keycloak.models.cache.infinispan.UserCacheSession.updateFederatedIdentity ( RealmModel  realm, UserModel  federatedUser, FederatedIdentityModel  federatedIdentityModel  )

inline

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

                                                                                                                                  {
        invalidateFederationLink(federatedUser.getId());
        getDelegate().updateFederatedIdentity(realm, federatedUser, federatedIdentityModel);
    }

validateCache()

UserModel org.keycloak.models.cache.infinispan.UserCacheSession.validateCache ( RealmModel  realm, CachedUser  cached  )

inlineprotected

                                                                           {
        if (!realm.getId().equals(cached.getRealm())) {
            return null;
        }

        StorageId storageId = cached.getFederationLink() != null ?
                new StorageId(cached.getFederationLink(), cached.getId()) : new StorageId(cached.getId());

        if (!storageId.isLocal()) {
            ComponentModel component = realm.getComponent(storageId.getProviderId());
            CacheableStorageProviderModel model = new CacheableStorageProviderModel(component);

            // although we do set a timeout, Infinispan has no guarantees when the user will be evicted
            // its also hard to test stuff
            if (model.shouldInvalidate(cached)) {
                registerUserInvalidation(realm, cached);
                return getDelegate().getUserById(cached.getId(), realm);
            }
        }
        return new UserAdapter(cached, this, session, realm);
    }

メンバ詳解

cache

UserCacheManager org.keycloak.models.cache.infinispan.UserCacheSession.cache

protected

delegate

UserProvider org.keycloak.models.cache.infinispan.UserCacheSession.delegate

protected

invalidationEvents

Set<InvalidationEvent> org.keycloak.models.cache.infinispan.UserCacheSession.invalidationEvents = new HashSet<>()

protected

invalidations

Set<String> org.keycloak.models.cache.infinispan.UserCacheSession.invalidations = new HashSet<>()

protected

logger

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

staticprotected

managedUsers

Map<String, UserModel> org.keycloak.models.cache.infinispan.UserCacheSession.managedUsers = new HashMap<>()

protected

realmInvalidations

Set<String> org.keycloak.models.cache.infinispan.UserCacheSession.realmInvalidations = new HashSet<>()

protected

session

KeycloakSession org.keycloak.models.cache.infinispan.UserCacheSession.session

protected

setRollbackOnly

boolean org.keycloak.models.cache.infinispan.UserCacheSession.setRollbackOnly

protected

startupRevision

final long org.keycloak.models.cache.infinispan.UserCacheSession.startupRevision

protected

transactionActive

boolean org.keycloak.models.cache.infinispan.UserCacheSession.transactionActive

protected

---

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

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