org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider クラス

org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider の継承関係図

org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider 連携図

クラス
class	RegisterClientSessionTask

公開メンバ関数
	InfinispanUserSessionProvider (KeycloakSession session, RemoteCacheInvoker remoteCacheInvoker, LastSessionRefreshStore lastSessionRefreshStore, LastSessionRefreshStore offlineLastSessionRefreshStore, InfinispanKeyGenerator keyGenerator, Cache< String, SessionEntityWrapper< UserSessionEntity >> sessionCache, Cache< String, SessionEntityWrapper< UserSessionEntity >> offlineSessionCache, Cache< UUID, SessionEntityWrapper< AuthenticatedClientSessionEntity >> clientSessionCache, Cache< UUID, SessionEntityWrapper< AuthenticatedClientSessionEntity >> offlineClientSessionCache, Cache< LoginFailureKey, SessionEntityWrapper< LoginFailureEntity >> loginFailureCache)
AuthenticatedClientSessionModel	createClientSession (RealmModel realm, ClientModel client, UserSessionModel userSession)
UserSessionModel	createUserSession (RealmModel realm, UserModel user, String loginUsername, String ipAddress, String authMethod, boolean rememberMe, String brokerSessionId, String brokerUserId)
UserSessionModel	createUserSession (String id, RealmModel realm, UserModel user, String loginUsername, String ipAddress, String authMethod, boolean rememberMe, String brokerSessionId, String brokerUserId)
UserSessionModel	getUserSession (RealmModel realm, String id)
AuthenticatedClientSessionAdapter	getClientSession (UserSessionModel userSession, ClientModel client, UUID clientSessionId, boolean offline)
List< UserSessionModel >	getUserSessions (final RealmModel realm, UserModel user)
List< UserSessionModel >	getUserSessionByBrokerUserId (RealmModel realm, String brokerUserId)
UserSessionModel	getUserSessionByBrokerSessionId (RealmModel realm, String brokerSessionId)
List< UserSessionModel >	getUserSessions (RealmModel realm, ClientModel client)
List< UserSessionModel >	getUserSessions (RealmModel realm, ClientModel client, int firstResult, int maxResults)
UserSessionModel	getUserSessionWithPredicate (RealmModel realm, String id, boolean offline, Predicate< UserSessionModel > predicate)
long	getActiveUserSessions (RealmModel realm, ClientModel client)
Map< String, Long >	getActiveClientSessionStats (RealmModel realm, boolean offline)
void	removeUserSession (RealmModel realm, UserSessionModel session)
void	removeUserSessions (RealmModel realm, UserModel user)
void	removeExpired (RealmModel realm)
void	removeUserSessions (RealmModel realm)
UserLoginFailureModel	getUserLoginFailure (RealmModel realm, String userId)
UserLoginFailureModel	addUserLoginFailure (RealmModel realm, String userId)
void	removeUserLoginFailure (RealmModel realm, String userId)
void	removeAllUserLoginFailures (RealmModel realm)
void	onRealmRemoved (RealmModel realm)
void	onClientRemoved (RealmModel realm, ClientModel client)
void	close ()
UserSessionModel	createOfflineUserSession (UserSessionModel userSession)
UserSessionAdapter	getOfflineUserSession (RealmModel realm, String userSessionId)
void	removeOfflineUserSession (RealmModel realm, UserSessionModel userSession)
AuthenticatedClientSessionModel	createOfflineClientSession (AuthenticatedClientSessionModel clientSession, UserSessionModel offlineUserSession)
List< UserSessionModel >	getOfflineUserSessions (RealmModel realm, UserModel user)
long	getOfflineSessionsCount (RealmModel realm, ClientModel client)
List< UserSessionModel >	getOfflineUserSessions (RealmModel realm, ClientModel client, int first, int max)
UserSessionAdapter	importUserSession (UserSessionModel userSession, boolean offline, boolean importAuthenticatedClientSessions)

限定公開メンバ関数
Cache< String, SessionEntityWrapper< UserSessionEntity > >	getCache (boolean offline)
InfinispanChangelogBasedTransaction< String, UserSessionEntity >	getTransaction (boolean offline)
Cache< UUID, SessionEntityWrapper< AuthenticatedClientSessionEntity > >	getClientSessionCache (boolean offline)
InfinispanChangelogBasedTransaction< UUID, AuthenticatedClientSessionEntity >	getClientSessionTransaction (boolean offline)
LastSessionRefreshStore	getLastSessionRefreshStore ()
LastSessionRefreshStore	getOfflineLastSessionRefreshStore ()
UserSessionAdapter	getUserSession (RealmModel realm, String id, boolean offline)
List< UserSessionModel >	getUserSessions (RealmModel realm, Predicate< Map.Entry< String, SessionEntityWrapper< UserSessionEntity >>> predicate, boolean offline)
List< UserSessionModel >	getUserSessions (final RealmModel realm, ClientModel client, int firstResult, int maxResults, final boolean offline)
List< UserSessionModel >	getUserSessionModels (RealmModel realm, int firstResult, int maxResults, boolean offline, UserSessionPredicate predicate)
long	getUserSessionsCount (RealmModel realm, ClientModel client, boolean offline)
void	removeUserSessions (RealmModel realm, UserModel user, boolean offline)
void	onRemoveUserSessionsEvent (String realmId)
void	onRemoveAllUserLoginFailuresEvent (String realmId)
void	onRealmRemovedEvent (String realmId)
void	onClientRemovedEvent (String realmId, String clientUuid)
void	onUserRemoved (RealmModel realm, UserModel user)
void	removeUserSession (UserSessionEntity sessionEntity, boolean offline)

限定公開変数類
final KeycloakSession	session
final Cache< String, SessionEntityWrapper< UserSessionEntity > >	sessionCache
final Cache< String, SessionEntityWrapper< UserSessionEntity > >	offlineSessionCache
final Cache< UUID, SessionEntityWrapper< AuthenticatedClientSessionEntity > >	clientSessionCache
final Cache< UUID, SessionEntityWrapper< AuthenticatedClientSessionEntity > >	offlineClientSessionCache
final Cache< LoginFailureKey, SessionEntityWrapper< LoginFailureEntity > >	loginFailureCache
final InfinispanChangelogBasedTransaction< String, UserSessionEntity >	sessionTx
final InfinispanChangelogBasedTransaction< String, UserSessionEntity >	offlineSessionTx
final InfinispanChangelogBasedTransaction< UUID, AuthenticatedClientSessionEntity >	clientSessionTx
final InfinispanChangelogBasedTransaction< UUID, AuthenticatedClientSessionEntity >	offlineClientSessionTx
final InfinispanChangelogBasedTransaction< LoginFailureKey, LoginFailureEntity >	loginFailuresTx
final SessionEventsSenderTransaction	clusterEventsSenderTx
final LastSessionRefreshStore	lastSessionRefreshStore
final LastSessionRefreshStore	offlineLastSessionRefreshStore
final InfinispanKeyGenerator	keyGenerator

関数
void	updateSessionEntity (UserSessionEntity entity, RealmModel realm, UserModel user, String loginUsername, String ipAddress, String authMethod, boolean rememberMe, String brokerSessionId, String brokerUserId)
InfinispanChangelogBasedTransaction< LoginFailureKey, LoginFailureEntity >	getLoginFailuresTx ()
UserSessionAdapter	wrap (RealmModel realm, UserSessionEntity entity, boolean offline)
AuthenticatedClientSessionAdapter	wrap (UserSessionModel userSession, ClientModel client, AuthenticatedClientSessionEntity entity, boolean offline)
UserLoginFailureModel	wrap (LoginFailureKey key, LoginFailureEntity entity)
UserSessionEntity	getUserSessionEntity (UserSessionModel userSession, boolean offline)

非公開メンバ関数
UserSessionEntity	getUserSessionEntity (String id, boolean offline)
AuthenticatedClientSessionEntity	getClientSessionEntity (UUID id, boolean offline)
void	removeExpiredUserSessions (RealmModel realm)
void	removeExpiredOfflineUserSessions (RealmModel realm)
void	removeLocalUserSessions (String realmId, boolean offline)
LoginFailureEntity	getLoginFailureEntity (LoginFailureKey key)
void	removeAllLocalUserLoginFailuresEvent (String realmId)
AuthenticatedClientSessionAdapter	importClientSession (UserSessionAdapter sessionToImportInto, AuthenticatedClientSessionModel clientSession, InfinispanChangelogBasedTransaction< String, UserSessionEntity > userSessionUpdateTx, InfinispanChangelogBasedTransaction< UUID, AuthenticatedClientSessionEntity > clientSessionUpdateTx, boolean offline)

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

詳解

著者

Stian Thorgersen

構築子と解体子

InfinispanUserSessionProvider()

org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.InfinispanUserSessionProvider ( KeycloakSession  session, RemoteCacheInvoker  remoteCacheInvoker, LastSessionRefreshStore  lastSessionRefreshStore, LastSessionRefreshStore  offlineLastSessionRefreshStore, InfinispanKeyGenerator  keyGenerator, Cache< String, SessionEntityWrapper< UserSessionEntity >>  sessionCache, Cache< String, SessionEntityWrapper< UserSessionEntity >>  offlineSessionCache, Cache< UUID, SessionEntityWrapper< AuthenticatedClientSessionEntity >>  clientSessionCache, Cache< UUID, SessionEntityWrapper< AuthenticatedClientSessionEntity >>  offlineClientSessionCache, Cache< LoginFailureKey, SessionEntityWrapper< LoginFailureEntity >>  loginFailureCache  )

inline

                                                                                                                             {
        this.session = session;

        this.sessionCache = sessionCache;
        this.clientSessionCache = clientSessionCache;
        this.offlineSessionCache = offlineSessionCache;
        this.offlineClientSessionCache = offlineClientSessionCache;
        this.loginFailureCache = loginFailureCache;

        this.sessionTx = new InfinispanChangelogBasedTransaction<>(session, sessionCache, remoteCacheInvoker);
        this.offlineSessionTx = new InfinispanChangelogBasedTransaction<>(session, offlineSessionCache, remoteCacheInvoker);
        this.clientSessionTx = new InfinispanChangelogBasedTransaction<>(session, clientSessionCache, remoteCacheInvoker);
        this.offlineClientSessionTx = new InfinispanChangelogBasedTransaction<>(session, offlineClientSessionCache, remoteCacheInvoker);

        this.loginFailuresTx = new InfinispanChangelogBasedTransaction<>(session, loginFailureCache, remoteCacheInvoker);

        this.clusterEventsSenderTx = new SessionEventsSenderTransaction(session);

        this.lastSessionRefreshStore = lastSessionRefreshStore;
        this.offlineLastSessionRefreshStore = offlineLastSessionRefreshStore;
        this.keyGenerator = keyGenerator;

        session.getTransactionManager().enlistAfterCompletion(clusterEventsSenderTx);
        session.getTransactionManager().enlistAfterCompletion(sessionTx);
        session.getTransactionManager().enlistAfterCompletion(offlineSessionTx);
        session.getTransactionManager().enlistAfterCompletion(clientSessionTx);
        session.getTransactionManager().enlistAfterCompletion(offlineClientSessionTx);
        session.getTransactionManager().enlistAfterCompletion(loginFailuresTx);
    }

関数詳解

addUserLoginFailure()

UserLoginFailureModel org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.addUserLoginFailure ( RealmModel  realm, String  userId  )

inline

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

                                                                                      {
        LoginFailureKey key = new LoginFailureKey(realm.getId(), userId);
        LoginFailureEntity entity = new LoginFailureEntity();
        entity.setRealmId(realm.getId());
        entity.setUserId(userId);

        SessionUpdateTask<LoginFailureEntity> createLoginFailureTask = Tasks.addIfAbsentSync();
        loginFailuresTx.addTask(key, createLoginFailureTask, entity);

        return wrap(key, entity);
    }

close()

void org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.close ( )

inline

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

                        {
    }

createClientSession()

AuthenticatedClientSessionModel org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.createClientSession ( RealmModel  realm, ClientModel  client, UserSessionModel  userSession  )

inline

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

                                                                                                                                   {
        final UUID clientSessionId = keyGenerator.generateKeyUUID(session, clientSessionCache);
        AuthenticatedClientSessionEntity entity = new AuthenticatedClientSessionEntity(clientSessionId);
        entity.setRealmId(realm.getId());
        entity.setTimestamp(Time.currentTime());

        InfinispanChangelogBasedTransaction<String, UserSessionEntity> userSessionUpdateTx = getTransaction(false);
        InfinispanChangelogBasedTransaction<UUID, AuthenticatedClientSessionEntity> clientSessionUpdateTx = getClientSessionTransaction(false);
        AuthenticatedClientSessionAdapter adapter = new AuthenticatedClientSessionAdapter(session, this, entity, client, userSession, userSessionUpdateTx, clientSessionUpdateTx, false);

        SessionUpdateTask<AuthenticatedClientSessionEntity> createClientSessionTask = Tasks.addIfAbsentSync();
        clientSessionUpdateTx.addTask(clientSessionId, createClientSessionTask, entity);

        SessionUpdateTask registerClientSessionTask = new RegisterClientSessionTask(client.getId(), clientSessionId);
        userSessionUpdateTx.addTask(userSession.getId(), registerClientSessionTask);

        return adapter;
    }

createOfflineClientSession()

AuthenticatedClientSessionModel org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.createOfflineClientSession ( AuthenticatedClientSessionModel  clientSession, UserSessionModel  offlineUserSession  )

inline

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

                                                                                                                                                          {
        UserSessionAdapter userSessionAdapter = (offlineUserSession instanceof UserSessionAdapter) ? (UserSessionAdapter) offlineUserSession :
                getOfflineUserSession(offlineUserSession.getRealm(), offlineUserSession.getId());

        InfinispanChangelogBasedTransaction<String, UserSessionEntity> userSessionUpdateTx = getTransaction(true);
        InfinispanChangelogBasedTransaction<UUID, AuthenticatedClientSessionEntity> clientSessionUpdateTx = getClientSessionTransaction(true);
        AuthenticatedClientSessionAdapter offlineClientSession = importClientSession(userSessionAdapter, clientSession, userSessionUpdateTx, clientSessionUpdateTx, true);

        // update timestamp to current time
        offlineClientSession.setTimestamp(Time.currentTime());

        return offlineClientSession;
    }

createOfflineUserSession()

UserSessionModel org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.createOfflineUserSession ( UserSessionModel  userSession )

inline

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

                                                                                   {
        UserSessionAdapter offlineUserSession = importUserSession(userSession, true, false);

        // started and lastSessionRefresh set to current time
        int currentTime = Time.currentTime();
        offlineUserSession.getEntity().setStarted(currentTime);
        offlineUserSession.setLastSessionRefresh(currentTime);

        return offlineUserSession;
    }

createUserSession() [1/2]

UserSessionModel org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.createUserSession ( RealmModel  realm, UserModel  user, String  loginUsername, String  ipAddress, String  authMethod, boolean  rememberMe, String  brokerSessionId, String  brokerUserId  )

inline

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

                                                                                                                                                                                                            {
        final String userSessionId = keyGenerator.generateKeyString(session, sessionCache);
        return createUserSession(userSessionId, realm, user, loginUsername, ipAddress, authMethod, rememberMe, brokerSessionId, brokerUserId);
    }

createUserSession() [2/2]

UserSessionModel org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.createUserSession ( String  id, RealmModel  realm, UserModel  user, String  loginUsername, String  ipAddress, String  authMethod, boolean  rememberMe, String  brokerSessionId, String  brokerUserId  )

inline

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

                                                                                                                                                                                                                       {
        UserSessionEntity entity = new UserSessionEntity();
        entity.setId(id);
        updateSessionEntity(entity, realm, user, loginUsername, ipAddress, authMethod, rememberMe, brokerSessionId, brokerUserId);

        SessionUpdateTask<UserSessionEntity> createSessionTask = Tasks.addIfAbsentSync();
        sessionTx.addTask(id, createSessionTask, entity);

        return wrap(realm, entity, false);
    }

getActiveClientSessionStats()

Map<String, Long> org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.getActiveClientSessionStats ( RealmModel  realm, boolean  offline  )

inline

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

                                                                                            {
        Cache<String, SessionEntityWrapper<UserSessionEntity>> cache = getCache(offline);
        cache = CacheDecorators.skipCacheLoaders(cache);
        return cache.entrySet().stream()
                .filter(UserSessionPredicate.create(realm.getId()))
                .map(Mappers.authClientSessionSetMapper())
                .flatMap((Serializable & Function<Set<String>, Stream<? extends String>>)Mappers::toStream)
                .collect(
                        CacheCollectors.serializableCollector(
                                () -> Collectors.groupingBy(Function.identity(), Collectors.counting())
                        )
                );
    }

getActiveUserSessions()

long org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.getActiveUserSessions ( RealmModel  realm, ClientModel  client  )

inline

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

                                                                            {
        return getUserSessionsCount(realm, client, false);
    }

getCache()

Cache<String, SessionEntityWrapper<UserSessionEntity> > org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.getCache ( boolean  offline )

inlineprotected

                                                                                               {
        return offline ? offlineSessionCache : sessionCache;
    }

getClientSession()

AuthenticatedClientSessionAdapter org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.getClientSession ( UserSessionModel  userSession, ClientModel  client, UUID  clientSessionId, boolean  offline  )

inline

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

                                                                                                                                                       {
        AuthenticatedClientSessionEntity entity = getClientSessionEntity(clientSessionId, offline);
        return wrap(userSession, client, entity, offline);
    }

getClientSessionCache()

Cache<UUID, SessionEntityWrapper<AuthenticatedClientSessionEntity> > org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.getClientSessionCache ( boolean  offline )

inlineprotected

                                                                                                                         {
        return offline ? offlineClientSessionCache : clientSessionCache;
    }

getClientSessionEntity()

AuthenticatedClientSessionEntity org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.getClientSessionEntity ( UUID  id, boolean  offline  )

inlineprivate

                                                                                              {
        InfinispanChangelogBasedTransaction<UUID, AuthenticatedClientSessionEntity> tx = getClientSessionTransaction(offline);
        SessionEntityWrapper<AuthenticatedClientSessionEntity> entityWrapper = tx.get(id);
        return entityWrapper == null ? null : entityWrapper.getEntity();
    }

getClientSessionTransaction()

InfinispanChangelogBasedTransaction<UUID, AuthenticatedClientSessionEntity> org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.getClientSessionTransaction ( boolean  offline )

inlineprotected

                                                                                                                                       {
        return offline ? offlineClientSessionTx : clientSessionTx;
    }

getLastSessionRefreshStore()

LastSessionRefreshStore org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.getLastSessionRefreshStore ( )

inlineprotected

                                                                   {
        return lastSessionRefreshStore;
    }

getLoginFailureEntity()

LoginFailureEntity org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.getLoginFailureEntity ( LoginFailureKey  key )

inlineprivate

                                                                          {
        InfinispanChangelogBasedTransaction<LoginFailureKey, LoginFailureEntity> tx = getLoginFailuresTx();
        SessionEntityWrapper<LoginFailureEntity> entityWrapper = tx.get(key);
        return entityWrapper==null ? null : entityWrapper.getEntity();
    }

getLoginFailuresTx()

InfinispanChangelogBasedTransaction<LoginFailureKey, LoginFailureEntity> org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.getLoginFailuresTx ( )

inlinepackage

                                                                                                  {
        return loginFailuresTx;
    }

getOfflineLastSessionRefreshStore()

LastSessionRefreshStore org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.getOfflineLastSessionRefreshStore ( )

inlineprotected

                                                                          {
        return offlineLastSessionRefreshStore;
    }

getOfflineSessionsCount()

long org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.getOfflineSessionsCount ( RealmModel  realm, ClientModel  client  )

inline

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

                                                                              {
        return getUserSessionsCount(realm, client, true);
    }

getOfflineUserSession()

UserSessionAdapter org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.getOfflineUserSession ( RealmModel  realm, String  userSessionId  )

inline

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

                                                                                            {
        return getUserSession(realm, userSessionId, true);
    }

getOfflineUserSessions() [1/2]

List<UserSessionModel> org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.getOfflineUserSessions ( RealmModel  realm, UserModel  user  )

inline

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

                                                                                           {
        List<UserSessionModel> userSessions = new LinkedList<>();

        Cache<String, SessionEntityWrapper<UserSessionEntity>> cache = CacheDecorators.skipCacheLoaders(offlineSessionCache);

        Iterator<UserSessionEntity> itr = cache.entrySet().stream()
                .filter(UserSessionPredicate.create(realm.getId()).user(user.getId()))
                .map(Mappers.userSessionEntity())
                .iterator();

        while (itr.hasNext()) {
            UserSessionEntity userSessionEntity = itr.next();
            UserSessionModel userSession = wrap(realm, userSessionEntity, true);
            userSessions.add(userSession);
        }

        return userSessions;
    }

getOfflineUserSessions() [2/2]

List<UserSessionModel> org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.getOfflineUserSessions ( RealmModel  realm, ClientModel  client, int  first, int  max  )

inline

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

                                                                                                                   {
        return getUserSessions(realm, client, first, max, true);
    }

getTransaction()

InfinispanChangelogBasedTransaction<String, UserSessionEntity> org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.getTransaction ( boolean  offline )

inlineprotected

                                                                                                             {
        return offline ? offlineSessionTx : sessionTx;
    }

getUserLoginFailure()

UserLoginFailureModel org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.getUserLoginFailure ( RealmModel  realm, String  userId  )

inline

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

                                                                                      {
        LoginFailureKey key = new LoginFailureKey(realm.getId(), userId);
        LoginFailureEntity entity = getLoginFailureEntity(key);
        return wrap(key, entity);
    }

getUserSession() [1/2]

UserSessionModel org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.getUserSession ( RealmModel  realm, String  id  )

inline

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

                                                                        {
        return getUserSession(realm, id, false);
    }

getUserSession() [2/2]

UserSessionAdapter org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.getUserSession ( RealmModel  realm, String  id, boolean  offline  )

inlineprotected

                                                                                              {
        UserSessionEntity entity = getUserSessionEntity(id, offline);
        return wrap(realm, entity, offline);
    }

getUserSessionByBrokerSessionId()

UserSessionModel org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.getUserSessionByBrokerSessionId ( RealmModel  realm, String  brokerSessionId  )

inline

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

                                                                                                      {
        List<UserSessionModel> userSessions = getUserSessions(realm, UserSessionPredicate.create(realm.getId()).brokerSessionId(brokerSessionId), false);
        return userSessions.isEmpty() ? null : userSessions.get(0);
    }

getUserSessionByBrokerUserId()

List<UserSessionModel> org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.getUserSessionByBrokerUserId ( RealmModel  realm, String  brokerUserId  )

inline

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

                                                                                                      {
        return getUserSessions(realm, UserSessionPredicate.create(realm.getId()).brokerUserId(brokerUserId), false);
    }

getUserSessionEntity() [1/2]

UserSessionEntity org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.getUserSessionEntity ( String  id, boolean  offline  )

inlineprivate

                                                                               {
        InfinispanChangelogBasedTransaction<String, UserSessionEntity> tx = getTransaction(offline);
        SessionEntityWrapper<UserSessionEntity> entityWrapper = tx.get(id);
        return entityWrapper==null ? null : entityWrapper.getEntity();
    }

getUserSessionEntity() [2/2]

UserSessionEntity org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.getUserSessionEntity ( UserSessionModel  userSession, boolean  offline  )

inlinepackage

                                                                                          {
        if (userSession instanceof UserSessionAdapter) {
            return ((UserSessionAdapter) userSession).getEntity();
        } else {
            return getUserSessionEntity(userSession.getId(), offline);
        }
    }

getUserSessionModels()

List<UserSessionModel> org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.getUserSessionModels ( RealmModel  realm, int  firstResult, int  maxResults, boolean  offline, UserSessionPredicate  predicate  )

inlineprotected

                                                                                                                                                              {
        Cache<String, SessionEntityWrapper<UserSessionEntity>> cache = getCache(offline);
        cache = CacheDecorators.skipCacheLoaders(cache);

        Cache<UUID, SessionEntityWrapper<AuthenticatedClientSessionEntity>> clientSessionCache = getClientSessionCache(offline);
        Cache<UUID, SessionEntityWrapper<AuthenticatedClientSessionEntity>> clientSessionCacheDecorated = CacheDecorators.skipCacheLoaders(clientSessionCache);

        Stream<UserSessionEntity> stream = cache.entrySet().stream()
                .filter(predicate)
                .map(Mappers.userSessionEntity())
                .sorted(Comparators.userSessionLastSessionRefresh());

        if (firstResult > 0) {
            stream = stream.skip(firstResult);
        }

        if (maxResults > 0) {
            stream = stream.limit(maxResults);
        }

        final List<UserSessionModel> sessions = new LinkedList<>();
        Iterator<UserSessionEntity> itr = stream.iterator();

        while (itr.hasNext()) {
            UserSessionEntity userSessionEntity = itr.next();
            sessions.add(wrap(realm, userSessionEntity, offline));
        }


        return sessions;
    }

getUserSessions() [1/5]

List<UserSessionModel> org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.getUserSessions ( RealmModel  realm, Predicate< Map.Entry< String, SessionEntityWrapper< UserSessionEntity >>>  predicate, boolean  offline  )

inlineprotected

                                                                                                                                                                         {
        Cache<String, SessionEntityWrapper<UserSessionEntity>> cache = getCache(offline);

        cache = CacheDecorators.skipCacheLoaders(cache);

        Stream<Map.Entry<String, SessionEntityWrapper<UserSessionEntity>>> cacheStream = cache.entrySet().stream();

        List<UserSessionModel> resultSessions = new LinkedList<>();

        Iterator<UserSessionEntity> itr = cacheStream.filter(predicate)
                .map(Mappers.userSessionEntity())
                .iterator();

        while (itr.hasNext()) {
            UserSessionEntity userSessionEntity = itr.next();
            resultSessions.add(wrap(realm, userSessionEntity, offline));
        }

        return resultSessions;
    }

getUserSessions() [2/5]

List<UserSessionModel> org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.getUserSessions ( final RealmModel  realm, UserModel  user  )

inline

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

                                                                                          {
        return getUserSessions(realm, UserSessionPredicate.create(realm.getId()).user(user.getId()), false);
    }

getUserSessions() [3/5]

List<UserSessionModel> org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.getUserSessions ( RealmModel  realm, ClientModel  client  )

inline

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

                                                                                        {
        return getUserSessions(realm, client, -1, -1);
    }

getUserSessions() [4/5]

List<UserSessionModel> org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.getUserSessions ( RealmModel  realm, ClientModel  client, int  firstResult, int  maxResults  )

inline

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

                                                                                                                         {
        return getUserSessions(realm, client, firstResult, maxResults, false);
    }

getUserSessions() [5/5]

List<UserSessionModel> org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.getUserSessions ( final RealmModel  realm, ClientModel  client, int  firstResult, int  maxResults, final boolean  offline  )

inlineprotected

                                                                                                                                                         {
        final String clientUuid = client.getId();
        UserSessionPredicate predicate = UserSessionPredicate.create(realm.getId()).client(clientUuid);

        return getUserSessionModels(realm, firstResult, maxResults, offline, predicate);
    }

getUserSessionsCount()

long org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.getUserSessionsCount ( RealmModel  realm, ClientModel  client, boolean  offline  )

inlineprotected

                                                                                                {
        Cache<String, SessionEntityWrapper<UserSessionEntity>> cache = getCache(offline);
        cache = CacheDecorators.skipCacheLoaders(cache);

        final String clientUuid = client.getId();

        return cache.entrySet().stream()
                .filter(UserSessionPredicate.create(realm.getId()).client(clientUuid))
                .count();
    }

getUserSessionWithPredicate()

UserSessionModel org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.getUserSessionWithPredicate ( RealmModel  realm, String  id, boolean  offline, Predicate< UserSessionModel >  predicate  )

inline

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

                                                                                                                                             {
        UserSessionModel userSession = getUserSession(realm, id, offline);
        if (userSession == null) {
            return null;
        }

        // We have userSession, which passes predicate. No need for remote lookup.
        if (predicate.test(userSession)) {
            log.debugf("getUserSessionWithPredicate(%s): found in local cache", id);
            return userSession;
        }

        // Try lookup userSession from remoteCache
        Cache<String, SessionEntityWrapper<UserSessionEntity>> cache = getCache(offline);
        RemoteCache remoteCache = InfinispanUtil.getRemoteCache(cache);

        if (remoteCache != null) {
            SessionEntityWrapper<UserSessionEntity> remoteSessionEntityWrapper = (SessionEntityWrapper<UserSessionEntity>) remoteCache.get(id);
            if (remoteSessionEntityWrapper != null) {
                UserSessionEntity remoteSessionEntity = remoteSessionEntityWrapper.getEntity();
                log.debugf("getUserSessionWithPredicate(%s): remote cache contains session entity %s", id, remoteSessionEntity);

                UserSessionModel remoteSessionAdapter = wrap(realm, remoteSessionEntity, offline);
                if (predicate.test(remoteSessionAdapter)) {

                    InfinispanChangelogBasedTransaction<String, UserSessionEntity> tx = getTransaction(offline);

                    // Remote entity contains our predicate. Update local cache with the remote entity
                    SessionEntityWrapper<UserSessionEntity> sessionWrapper = remoteSessionEntity.mergeRemoteEntityWithLocalEntity(tx.get(id));

                    // Replace entity just in ispn cache. Skip remoteStore
                    cache.getAdvancedCache().withFlags(Flag.SKIP_CACHE_STORE, Flag.SKIP_CACHE_LOAD, Flag.IGNORE_RETURN_VALUES)
                            .replace(id, sessionWrapper);

                    tx.reloadEntityInCurrentTransaction(realm, id, sessionWrapper);

                    // Recursion. We should have it locally now
                    return getUserSessionWithPredicate(realm, id, offline, predicate);
                } else {
                    log.debugf("getUserSessionWithPredicate(%s): found, but predicate doesn't pass", id);

                    return null;
                }
            } else {
                log.debugf("getUserSessionWithPredicate(%s): not found", id);

                // Session not available on remoteCache. Was already removed there. So removing locally too.
                // TODO: Can be optimized to skip calling remoteCache.remove
                removeUserSession(realm, userSession);

                return null;
            }
        } else {

            log.debugf("getUserSessionWithPredicate(%s): remote cache not available", id);

            return null;
        }
    }

importClientSession()

AuthenticatedClientSessionAdapter org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.importClientSession ( UserSessionAdapter  sessionToImportInto, AuthenticatedClientSessionModel  clientSession, InfinispanChangelogBasedTransaction< String, UserSessionEntity >  userSessionUpdateTx, InfinispanChangelogBasedTransaction< UUID, AuthenticatedClientSessionEntity >  clientSessionUpdateTx, boolean  offline  )

inlineprivate

                                                                                   {
        final UUID clientSessionId = keyGenerator.generateKeyUUID(session, getClientSessionCache(offline));
        AuthenticatedClientSessionEntity entity = new AuthenticatedClientSessionEntity(clientSessionId);
        entity.setRealmId(sessionToImportInto.getRealm().getId());

        entity.setAction(clientSession.getAction());
        entity.setAuthMethod(clientSession.getProtocol());

        entity.setNotes(clientSession.getNotes() == null ? new ConcurrentHashMap<>() : clientSession.getNotes());
        entity.setRedirectUri(clientSession.getRedirectUri());
        entity.setTimestamp(clientSession.getTimestamp());

        SessionUpdateTask<AuthenticatedClientSessionEntity> createClientSessionTask = Tasks.addIfAbsentSync();
        clientSessionUpdateTx.addTask(entity.getId(), createClientSessionTask, entity);

        AuthenticatedClientSessionStore clientSessions = sessionToImportInto.getEntity().getAuthenticatedClientSessions();
        clientSessions.put(clientSession.getClient().getId(), clientSessionId);

        SessionUpdateTask registerClientSessionTask = new RegisterClientSessionTask(clientSession.getClient().getId(), clientSessionId);
        userSessionUpdateTx.addTask(sessionToImportInto.getId(), registerClientSessionTask);

        return new AuthenticatedClientSessionAdapter(session,this, entity, clientSession.getClient(), sessionToImportInto, userSessionUpdateTx, clientSessionUpdateTx, offline);
    }

importUserSession()

UserSessionAdapter org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.importUserSession ( UserSessionModel  userSession, boolean  offline, boolean  importAuthenticatedClientSessions  )

inline

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

                                                                                                                                          {
        UserSessionEntity entity = new UserSessionEntity();
        entity.setId(userSession.getId());
        entity.setRealmId(userSession.getRealm().getId());

        entity.setAuthMethod(userSession.getAuthMethod());
        entity.setBrokerSessionId(userSession.getBrokerSessionId());
        entity.setBrokerUserId(userSession.getBrokerUserId());
        entity.setIpAddress(userSession.getIpAddress());
        entity.setNotes(userSession.getNotes() == null ? new ConcurrentHashMap<>() : userSession.getNotes());
        entity.setAuthenticatedClientSessions(new AuthenticatedClientSessionStore());
        entity.setRememberMe(userSession.isRememberMe());
        entity.setState(userSession.getState());
        if (userSession instanceof OfflineUserSessionModel) {
            // this is a hack so that UserModel doesn't have to be available when offline token is imported.
            // see related JIRA - KEYCLOAK-5350 and corresponding test
            OfflineUserSessionModel oline = (OfflineUserSessionModel)userSession;
            entity.setUser(oline.getUserId());
            // NOTE: Hack
            // We skip calling entity.setLoginUsername(userSession.getLoginUsername())

        } else {
            entity.setLoginUsername(userSession.getLoginUsername());
            entity.setUser(userSession.getUser().getId());
        }

        entity.setStarted(userSession.getStarted());
        entity.setLastSessionRefresh(userSession.getLastSessionRefresh());

        InfinispanChangelogBasedTransaction<String, UserSessionEntity> userSessionUpdateTx = getTransaction(offline);
        InfinispanChangelogBasedTransaction<UUID, AuthenticatedClientSessionEntity> clientSessionUpdateTx = getClientSessionTransaction(offline);

        SessionUpdateTask<UserSessionEntity> importTask = Tasks.addIfAbsentSync();
        userSessionUpdateTx.addTask(userSession.getId(), importTask, entity);

        UserSessionAdapter importedSession = wrap(userSession.getRealm(), entity, offline);

        // Handle client sessions
        if (importAuthenticatedClientSessions) {
            for (AuthenticatedClientSessionModel clientSession : userSession.getAuthenticatedClientSessions().values()) {
                importClientSession(importedSession, clientSession, userSessionUpdateTx, clientSessionUpdateTx, offline);
            }
        }

        return importedSession;
    }

onClientRemoved()

void org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.onClientRemoved ( RealmModel  realm, ClientModel  client  )

inline

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

                                                                      {
//        clusterEventsSenderTx.addEvent(
//                ClientRemovedSessionEvent.createEvent(ClientRemovedSessionEvent.class, InfinispanUserSessionProviderFactory.CLIENT_REMOVED_SESSION_EVENT, session, realm.getId(), true),
//                ClusterProvider.DCNotify.LOCAL_DC_ONLY);
    }

onClientRemovedEvent()

void org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.onClientRemovedEvent ( String  realmId, String  clientUuid  )

inlineprotected

                                                                           {
        // Nothing for now. userSession.getAuthenticatedClientSessions() will check lazily if particular client exists and update userSession on-the-fly.
    }

onRealmRemoved()

void org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.onRealmRemoved ( RealmModel  realm )

inline

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

                                                 {
        // Don't send message to all DCs, just to all cluster nodes in current DC. The remoteCache will notify client listeners for removed userSessions.
        clusterEventsSenderTx.addEvent(
                RealmRemovedSessionEvent.createEvent(RealmRemovedSessionEvent.class, InfinispanUserSessionProviderFactory.REALM_REMOVED_SESSION_EVENT, session, realm.getId(), true),
                ClusterProvider.DCNotify.LOCAL_DC_ONLY);
    }

onRealmRemovedEvent()

void org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.onRealmRemovedEvent ( String  realmId )

inlineprotected

                                                       {
        removeLocalUserSessions(realmId, true);
        removeLocalUserSessions(realmId, false);
        removeAllLocalUserLoginFailuresEvent(realmId);
    }

onRemoveAllUserLoginFailuresEvent()

void org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.onRemoveAllUserLoginFailuresEvent ( String  realmId )

inlineprotected

                                                                     {
        removeAllLocalUserLoginFailuresEvent(realmId);
    }

onRemoveUserSessionsEvent()

void org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.onRemoveUserSessionsEvent ( String  realmId )

inlineprotected

                                                             {
        removeLocalUserSessions(realmId, false);
    }

onUserRemoved()

void org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.onUserRemoved ( RealmModel  realm, UserModel  user  )

inlineprotected

                                                                   {
        removeUserSessions(realm, user, true);
        removeUserSessions(realm, user, false);

        removeUserLoginFailure(realm, user.getId());
    }

removeAllLocalUserLoginFailuresEvent()

void org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.removeAllLocalUserLoginFailuresEvent ( String  realmId )

inlineprivate

                                                                      {
        FuturesHelper futures = new FuturesHelper();

        Cache<LoginFailureKey, SessionEntityWrapper<LoginFailureEntity>> localCache = CacheDecorators.localCache(loginFailureCache);

        Cache<LoginFailureKey, SessionEntityWrapper<LoginFailureEntity>> localCacheStoreIgnore = CacheDecorators.skipCacheLoaders(localCache);

        localCacheStoreIgnore
                .entrySet()
                .stream()
                .filter(UserLoginFailurePredicate.create(realmId))
                .map(Mappers.loginFailureId())
                .forEach(loginFailureKey -> {
                    // Remove loginFailure from remoteCache too. Use removeAsync for better perf
                    Future future = localCache.removeAsync(loginFailureKey);
                    futures.addTask(future);
                });

        futures.waitForAllToFinish();

        log.debugf("Removed %d login failures in realm %s", futures.size(), realmId);
    }

removeAllUserLoginFailures()

void org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.removeAllUserLoginFailures ( RealmModel  realm )

inline

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

                                                             {
        clusterEventsSenderTx.addEvent(
                RemoveAllUserLoginFailuresEvent.createEvent(RemoveAllUserLoginFailuresEvent.class, InfinispanUserSessionProviderFactory.REMOVE_ALL_LOGIN_FAILURES_EVENT, session, realm.getId(), true),
                ClusterProvider.DCNotify.LOCAL_DC_ONLY);
    }

removeExpired()

void org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.removeExpired ( RealmModel  realm )

inline

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

                                                {
        log.debugf("Removing expired sessions");
        removeExpiredUserSessions(realm);
        removeExpiredOfflineUserSessions(realm);
    }

removeExpiredOfflineUserSessions()

void org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.removeExpiredOfflineUserSessions ( RealmModel  realm )

inlineprivate

                                                                    {
        UserSessionPersisterProvider persister = session.getProvider(UserSessionPersisterProvider.class);
        int expiredOffline = Time.currentTime() - realm.getOfflineSessionIdleTimeout() - SessionTimeoutHelper.PERIODIC_CLEANER_IDLE_TIMEOUT_WINDOW_SECONDS;

        // Each cluster node cleanups just local sessions, which are those owned by himself (+ few more taking l1 cache into account)
        Cache<String, SessionEntityWrapper<UserSessionEntity>> localCache = CacheDecorators.localCache(offlineSessionCache);

        UserSessionPredicate predicate = UserSessionPredicate.create(realm.getId()).expired(null, expiredOffline);

        FuturesHelper futures = new FuturesHelper();

        Cache<String, SessionEntityWrapper<UserSessionEntity>> localCacheStoreIgnore = CacheDecorators.skipCacheLoaders(localCache);

        final AtomicInteger userSessionsSize = new AtomicInteger();
        final AtomicInteger clientSessionsSize = new AtomicInteger();

        // Ignore remoteStore for stream iteration. But we will invoke remoteStore for userSession removal propagate
        localCacheStoreIgnore
                .entrySet()
                .stream()
                .filter(predicate)
                .map(Mappers.userSessionEntity())
                .forEach(new Consumer<UserSessionEntity>() {

                    @Override
                    public void accept(UserSessionEntity userSessionEntity) {
                        userSessionsSize.incrementAndGet();

                        Future future = offlineSessionCache.removeAsync(userSessionEntity.getId());
                        futures.addTask(future);
                        userSessionEntity.getAuthenticatedClientSessions().forEach((clientUUID, clientSessionId) -> {
                            clientSessionsSize.incrementAndGet();
                            Future f = offlineClientSessionCache.removeAsync(clientSessionId);
                            futures.addTask(f);
                        });

                        // TODO:mposolda can be likely optimized to delete all expired at one step
                        persister.removeUserSession( userSessionEntity.getId(), true);
                    }
                });

        // Removing detached clientSessions. Ignore remoteStore for stream iteration. But we will invoke remoteStore for clientSession removal propagate
        Cache<UUID, SessionEntityWrapper<AuthenticatedClientSessionEntity>> localClientSessionCache = CacheDecorators.localCache(offlineClientSessionCache);
        Cache<UUID, SessionEntityWrapper<AuthenticatedClientSessionEntity>> localClientSessionCacheStoreIgnore = CacheDecorators.skipCacheLoaders(localClientSessionCache);

        localClientSessionCacheStoreIgnore
                .entrySet()
                .stream()
                .filter(AuthenticatedClientSessionPredicate.create(realm.getId()).expired(expiredOffline))
                .map(Mappers.clientSessionEntity())
                .forEach(new Consumer<AuthenticatedClientSessionEntity>() {

                    @Override
                    public void accept(AuthenticatedClientSessionEntity clientSessionEntity) {
                        clientSessionsSize.incrementAndGet();

                        Future future = offlineClientSessionCache.removeAsync(clientSessionEntity.getId());
                        futures.addTask(future);
                    }

                });

        futures.waitForAllToFinish();

        log.debugf("Removed %d expired offline user sessions and %d expired offline client sessions for realm '%s'",
                userSessionsSize.get(), clientSessionsSize.get(), realm.getName());
    }

removeExpiredUserSessions()

void org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.removeExpiredUserSessions ( RealmModel  realm )

inlineprivate

                                                             {
        int expired = Time.currentTime() - realm.getSsoSessionMaxLifespan();
        int expiredRefresh = Time.currentTime() - realm.getSsoSessionIdleTimeout() - SessionTimeoutHelper.PERIODIC_CLEANER_IDLE_TIMEOUT_WINDOW_SECONDS;

        FuturesHelper futures = new FuturesHelper();

        // Each cluster node cleanups just local sessions, which are those owned by itself (+ few more taking l1 cache into account)
        Cache<String, SessionEntityWrapper<UserSessionEntity>> localCache = CacheDecorators.localCache(sessionCache);
        Cache<String, SessionEntityWrapper<UserSessionEntity>> localCacheStoreIgnore = CacheDecorators.skipCacheLoaders(localCache);

        final AtomicInteger userSessionsSize = new AtomicInteger();
        final AtomicInteger clientSessionsSize = new AtomicInteger();

        // Ignore remoteStore for stream iteration. But we will invoke remoteStore for userSession removal propagate
        localCacheStoreIgnore
                .entrySet()
                .stream()
                .filter(UserSessionPredicate.create(realm.getId()).expired(expired, expiredRefresh))
                .map(Mappers.userSessionEntity())
                .forEach(new Consumer<UserSessionEntity>() {

                    @Override
                    public void accept(UserSessionEntity userSessionEntity) {
                        userSessionsSize.incrementAndGet();

                        Future future = sessionCache.removeAsync(userSessionEntity.getId());
                        futures.addTask(future);

                        userSessionEntity.getAuthenticatedClientSessions().forEach((clientUUID, clientSessionId) -> {
                            clientSessionsSize.incrementAndGet();
                            Future f = clientSessionCache.removeAsync(clientSessionId);
                            futures.addTask(f);
                        });
                    }

                });

        // Removing detached clientSessions. Ignore remoteStore for stream iteration. But we will invoke remoteStore for clientSession removal propagate
        Cache<UUID, SessionEntityWrapper<AuthenticatedClientSessionEntity>> localClientSessionCache = CacheDecorators.localCache(clientSessionCache);
        Cache<UUID, SessionEntityWrapper<AuthenticatedClientSessionEntity>> localClientSessionCacheStoreIgnore = CacheDecorators.skipCacheLoaders(localClientSessionCache);

        localClientSessionCacheStoreIgnore
                .entrySet()
                .stream()
                .filter(AuthenticatedClientSessionPredicate.create(realm.getId()).expired(expired))
                .map(Mappers.clientSessionEntity())
                .forEach(new Consumer<AuthenticatedClientSessionEntity>() {

                    @Override
                    public void accept(AuthenticatedClientSessionEntity clientSessionEntity) {
                        clientSessionsSize.incrementAndGet();

                        Future future = clientSessionCache.removeAsync(clientSessionEntity.getId());
                        futures.addTask(future);
                    }

                });

        futures.waitForAllToFinish();

        log.debugf("Removed %d expired user sessions and %d expired client sessions for realm '%s'", userSessionsSize.get(),
                clientSessionsSize.get(), realm.getName());
    }

removeLocalUserSessions()

void org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.removeLocalUserSessions ( String  realmId, boolean  offline  )

inlineprivate

                                                                          {
        FuturesHelper futures = new FuturesHelper();

        Cache<String, SessionEntityWrapper<UserSessionEntity>> cache = getCache(offline);
        Cache<String, SessionEntityWrapper<UserSessionEntity>> localCache = CacheDecorators.localCache(cache);
        Cache<UUID, SessionEntityWrapper<AuthenticatedClientSessionEntity>> clientSessionCache = getClientSessionCache(offline);
        Cache<UUID, SessionEntityWrapper<AuthenticatedClientSessionEntity>> localClientSessionCache = CacheDecorators.localCache(clientSessionCache);

        Cache<String, SessionEntityWrapper<UserSessionEntity>> localCacheStoreIgnore = CacheDecorators.skipCacheLoaders(localCache);

        final AtomicInteger userSessionsSize = new AtomicInteger();

        localCacheStoreIgnore
                .entrySet()
                .stream()
                .filter(SessionPredicate.create(realmId))
                .map(Mappers.userSessionEntity())
                .forEach(new Consumer<UserSessionEntity>() {

                    @Override
                    public void accept(UserSessionEntity userSessionEntity) {
                        userSessionsSize.incrementAndGet();

                        // Remove session from remoteCache too. Use removeAsync for better perf
                        Future future = localCache.removeAsync(userSessionEntity.getId());
                        futures.addTask(future);
                        userSessionEntity.getAuthenticatedClientSessions().forEach((clientUUID, clientSessionId) -> {
                            Future f = localClientSessionCache.removeAsync(clientSessionId);
                            futures.addTask(f);
                        });
                    }

                });


        futures.waitForAllToFinish();

        log.debugf("Removed %d sessions in realm %s. Offline: %b", (Object) userSessionsSize.get(), realmId, offline);
    }

removeOfflineUserSession()

void org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.removeOfflineUserSession ( RealmModel  realm, UserSessionModel  userSession  )

inline

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

                                                                                         {
        UserSessionEntity userSessionEntity = getUserSessionEntity(userSession, true);
        if (userSessionEntity != null) {
            removeUserSession(userSessionEntity, true);
        }
    }

removeUserLoginFailure()

void org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.removeUserLoginFailure ( RealmModel  realm, String  userId  )

inline

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

                                                                        {
        SessionUpdateTask<LoginFailureEntity> removeTask = Tasks.removeSync();
        loginFailuresTx.addTask(new LoginFailureKey(realm.getId(), userId), removeTask);
    }

removeUserSession() [1/2]

void org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.removeUserSession ( RealmModel  realm, UserSessionModel  session  )

inline

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

                                                                              {
        UserSessionEntity entity = getUserSessionEntity(session, false);
        if (entity != null) {
            removeUserSession(entity, false);
        }
    }

removeUserSession() [2/2]

void org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.removeUserSession ( UserSessionEntity  sessionEntity, boolean  offline  )

inlineprotected

                                                                                       {
        InfinispanChangelogBasedTransaction<String, UserSessionEntity> userSessionUpdateTx = getTransaction(offline);
        InfinispanChangelogBasedTransaction<UUID, AuthenticatedClientSessionEntity> clientSessionUpdateTx = getClientSessionTransaction(offline);
        sessionEntity.getAuthenticatedClientSessions().forEach((clientUUID, clientSessionId) -> clientSessionUpdateTx.addTask(clientSessionId, Tasks.removeSync()));
        SessionUpdateTask<UserSessionEntity> removeTask = Tasks.removeSync();
        userSessionUpdateTx.addTask(sessionEntity.getId(), removeTask);
    }

removeUserSessions() [1/3]

void org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.removeUserSessions ( RealmModel  realm, UserModel  user  )

inline

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

                                                                     {
        removeUserSessions(realm, user, false);
    }

removeUserSessions() [2/3]

void org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.removeUserSessions ( RealmModel  realm, UserModel  user, boolean  offline  )

inlineprotected

                                                                                         {
        Cache<String, SessionEntityWrapper<UserSessionEntity>> cache = getCache(offline);

        cache = CacheDecorators.skipCacheLoaders(cache);

        Iterator<UserSessionEntity> itr = cache.entrySet().stream().filter(UserSessionPredicate.create(realm.getId()).user(user.getId())).map(Mappers.userSessionEntity()).iterator();

        while (itr.hasNext()) {
            UserSessionEntity userSessionEntity = itr.next();
            removeUserSession(userSessionEntity, offline);
        }
    }

removeUserSessions() [3/3]

void org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.removeUserSessions ( RealmModel  realm )

inline

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

                                                     {
        // Don't send message to all DCs, just to all cluster nodes in current DC. The remoteCache will notify client listeners for removed userSessions.
        clusterEventsSenderTx.addEvent(
                RemoveUserSessionsEvent.createEvent(RemoveUserSessionsEvent.class, InfinispanUserSessionProviderFactory.REMOVE_USER_SESSIONS_EVENT, session, realm.getId(), true),
                ClusterProvider.DCNotify.LOCAL_DC_ONLY);
    }

updateSessionEntity()

void org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.updateSessionEntity ( UserSessionEntity  entity, RealmModel  realm, UserModel  user, String  loginUsername, String  ipAddress, String  authMethod, boolean  rememberMe, String  brokerSessionId, String  brokerUserId  )

inlinepackage

                                                                                                                                                                                                                     {
        entity.setRealmId(realm.getId());
        entity.setUser(user.getId());
        entity.setLoginUsername(loginUsername);
        entity.setIpAddress(ipAddress);
        entity.setAuthMethod(authMethod);
        entity.setRememberMe(rememberMe);
        entity.setBrokerSessionId(brokerSessionId);
        entity.setBrokerUserId(brokerUserId);

        int currentTime = Time.currentTime();

        entity.setStarted(currentTime);
        entity.setLastSessionRefresh(currentTime);


    }

wrap() [1/3]

UserSessionAdapter org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.wrap ( RealmModel  realm, UserSessionEntity  entity, boolean  offline  )

inlinepackage

                                                                                         {
        InfinispanChangelogBasedTransaction<String, UserSessionEntity> userSessionUpdateTx = getTransaction(offline);
        InfinispanChangelogBasedTransaction<UUID, AuthenticatedClientSessionEntity> clientSessionUpdateTx = getClientSessionTransaction(offline);
        return entity != null ? new UserSessionAdapter(session, this, userSessionUpdateTx, clientSessionUpdateTx, realm, entity, offline) : null;
    }

wrap() [2/3]

AuthenticatedClientSessionAdapter org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.wrap ( UserSessionModel  userSession, ClientModel  client, AuthenticatedClientSessionEntity  entity, boolean  offline  )

inlinepackage

                                                                                                                                                       {
        InfinispanChangelogBasedTransaction<String, UserSessionEntity> userSessionUpdateTx = getTransaction(offline);
        InfinispanChangelogBasedTransaction<UUID, AuthenticatedClientSessionEntity> clientSessionUpdateTx = getClientSessionTransaction(offline);
        return entity != null ? new AuthenticatedClientSessionAdapter(session,this, entity, client, userSession, userSessionUpdateTx, clientSessionUpdateTx, offline) : null;
    }

wrap() [3/3]

UserLoginFailureModel org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.wrap ( LoginFailureKey  key, LoginFailureEntity  entity  )

inlinepackage

                                                                               {
        return entity != null ? new UserLoginFailureAdapter(this, key, entity) : null;
    }

メンバ詳解

clientSessionCache

final Cache<UUID, SessionEntityWrapper<AuthenticatedClientSessionEntity> > org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.clientSessionCache

protected

clientSessionTx

final InfinispanChangelogBasedTransaction<UUID, AuthenticatedClientSessionEntity> org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.clientSessionTx

protected

clusterEventsSenderTx

final SessionEventsSenderTransaction org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.clusterEventsSenderTx

protected

keyGenerator

final InfinispanKeyGenerator org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.keyGenerator

protected

lastSessionRefreshStore

final LastSessionRefreshStore org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.lastSessionRefreshStore

protected

log

final Logger org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.log = Logger.getLogger(InfinispanUserSessionProvider.class)

staticprivate

loginFailureCache

final Cache<LoginFailureKey, SessionEntityWrapper<LoginFailureEntity> > org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.loginFailureCache

protected

loginFailuresTx

final InfinispanChangelogBasedTransaction<LoginFailureKey, LoginFailureEntity> org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.loginFailuresTx

protected

offlineClientSessionCache

final Cache<UUID, SessionEntityWrapper<AuthenticatedClientSessionEntity> > org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.offlineClientSessionCache

protected

offlineClientSessionTx

final InfinispanChangelogBasedTransaction<UUID, AuthenticatedClientSessionEntity> org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.offlineClientSessionTx

protected

offlineLastSessionRefreshStore

final LastSessionRefreshStore org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.offlineLastSessionRefreshStore

protected

offlineSessionCache

final Cache<String, SessionEntityWrapper<UserSessionEntity> > org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.offlineSessionCache

protected

offlineSessionTx

final InfinispanChangelogBasedTransaction<String, UserSessionEntity> org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.offlineSessionTx

protected

session

final KeycloakSession org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.session

protected

sessionCache

final Cache<String, SessionEntityWrapper<UserSessionEntity> > org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.sessionCache

protected

sessionTx

final InfinispanChangelogBasedTransaction<String, UserSessionEntity> org.keycloak.models.sessions.infinispan.InfinispanUserSessionProvider.sessionTx

protected

---

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

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