org.keycloak.models.jpa.session.JpaUserSessionPersisterProvider クラス

org.keycloak.models.jpa.session.JpaUserSessionPersisterProvider の継承関係図

org.keycloak.models.jpa.session.JpaUserSessionPersisterProvider 連携図

公開メンバ関数
	JpaUserSessionPersisterProvider (KeycloakSession session, EntityManager em)
void	createUserSession (UserSessionModel userSession, boolean offline)
void	createClientSession (AuthenticatedClientSessionModel clientSession, boolean offline)
void	updateUserSession (UserSessionModel userSession, boolean offline)
void	removeUserSession (String userSessionId, boolean offline)
void	removeClientSession (String userSessionId, String clientUUID, boolean offline)
void	onRealmRemoved (RealmModel realm)
void	onClientRemoved (RealmModel realm, ClientModel client)
void	onUserRemoved (RealmModel realm, UserModel user)
void	clearDetachedUserSessions ()
void	updateAllTimestamps (int time)
List< UserSessionModel >	loadUserSessions (int firstResult, int maxResults, boolean offline)
int	getUserSessionsCount (boolean offline)
void	close ()

非公開メンバ関数
List< PersistentClientSessionEntity >	getClientSessionsByUserSession (String userSessionId, boolean offline)
void	onClientRemoved (String clientUUID)
void	onUserRemoved (RealmModel realm, String userId)
PersistentUserSessionAdapter	toAdapter (RealmModel realm, PersistentUserSessionEntity entity)
PersistentAuthenticatedClientSessionAdapter	toAdapter (RealmModel realm, PersistentUserSessionAdapter userSession, PersistentClientSessionEntity entity)
String	offlineToString (boolean offline)
boolean	offlineFromString (String offlineStr)

非公開変数類
final KeycloakSession	session
final EntityManager	em

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

詳解

著者

Marek Posolda

構築子と解体子

JpaUserSessionPersisterProvider()

org.keycloak.models.jpa.session.JpaUserSessionPersisterProvider.JpaUserSessionPersisterProvider ( KeycloakSession  session, EntityManager  em  )

inline

                                                                                      {
        this.session = session;
        this.em = em;
    }

関数詳解

clearDetachedUserSessions()

void org.keycloak.models.jpa.session.JpaUserSessionPersisterProvider.clearDetachedUserSessions ( )

inline

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

                                            {
        int num = em.createNamedQuery("deleteDetachedClientSessions").executeUpdate();
        num = em.createNamedQuery("deleteDetachedUserSessions").executeUpdate();
    }

close()

void org.keycloak.models.jpa.session.JpaUserSessionPersisterProvider.close ( )

inline

org.keycloak.provider.Providerを実装しています。

                        {

    }

createClientSession()

void org.keycloak.models.jpa.session.JpaUserSessionPersisterProvider.createClientSession ( AuthenticatedClientSessionModel  clientSession, boolean  offline  )

inline

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

                                                                                                    {
        PersistentAuthenticatedClientSessionAdapter adapter = new PersistentAuthenticatedClientSessionAdapter(clientSession);
        PersistentClientSessionModel model = adapter.getUpdatedModel();

        PersistentClientSessionEntity entity = new PersistentClientSessionEntity();
        StorageId clientStorageId = new StorageId(clientSession.getClient().getId());
        if (clientStorageId.isLocal()) {
            entity.setClientId(clientStorageId.getId());
            entity.setClientStorageProvider(PersistentClientSessionEntity.LOCAL);
            entity.setExternalClientId(PersistentClientSessionEntity.LOCAL);

        } else {
            entity.setClientId(PersistentClientSessionEntity.EXTERNAL);
            entity.setClientStorageProvider(clientStorageId.getProviderId());
            entity.setExternalClientId(clientStorageId.getExternalId());
        }
        entity.setTimestamp(clientSession.getTimestamp());
        String offlineStr = offlineToString(offline);
        entity.setOffline(offlineStr);
        entity.setUserSessionId(clientSession.getUserSession().getId());
        entity.setData(model.getData());
        em.persist(entity);
        em.flush();
    }

createUserSession()

void org.keycloak.models.jpa.session.JpaUserSessionPersisterProvider.createUserSession ( UserSessionModel  userSession, boolean  offline  )

inline

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

                                                                                 {
        PersistentUserSessionAdapter adapter = new PersistentUserSessionAdapter(userSession);
        PersistentUserSessionModel model = adapter.getUpdatedModel();

        PersistentUserSessionEntity entity = new PersistentUserSessionEntity();
        entity.setUserSessionId(model.getUserSessionId());
        entity.setRealmId(adapter.getRealm().getId());
        entity.setUserId(adapter.getUser().getId());
        String offlineStr = offlineToString(offline);
        entity.setOffline(offlineStr);
        entity.setLastSessionRefresh(model.getLastSessionRefresh());
        entity.setData(model.getData());
        em.persist(entity);
        em.flush();
    }

getClientSessionsByUserSession()

List<PersistentClientSessionEntity> org.keycloak.models.jpa.session.JpaUserSessionPersisterProvider.getClientSessionsByUserSession ( String  userSessionId, boolean  offline  )

inlineprivate

                                                                                                                      {
        String offlineStr = offlineToString(offline);

        TypedQuery<PersistentClientSessionEntity> query = em.createNamedQuery("findClientSessionsByUserSession", PersistentClientSessionEntity.class);
        query.setParameter("userSessionId", userSessionId);
        query.setParameter("offline", offlineStr);
        return query.getResultList();
    }

getUserSessionsCount()

int org.keycloak.models.jpa.session.JpaUserSessionPersisterProvider.getUserSessionsCount ( boolean  offline )

inline

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

                                                     {
        String offlineStr = offlineToString(offline);

        Query query = em.createNamedQuery("findUserSessionsCount");
        query.setParameter("offline", offlineStr);
        Number n = (Number) query.getSingleResult();
        return n.intValue();
    }

loadUserSessions()

List<UserSessionModel> org.keycloak.models.jpa.session.JpaUserSessionPersisterProvider.loadUserSessions ( int  firstResult, int  maxResults, boolean  offline  )

inline

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

                                                                                                     {
        String offlineStr = offlineToString(offline);

        TypedQuery<PersistentUserSessionEntity> query = em.createNamedQuery("findUserSessions", PersistentUserSessionEntity.class);
        query.setParameter("offline", offlineStr);

        if (firstResult != -1) {
            query.setFirstResult(firstResult);
        }
        if (maxResults != -1) {
            query.setMaxResults(maxResults);
        }

        List<PersistentUserSessionEntity> results = query.getResultList();
        List<UserSessionModel> result = new ArrayList<>();
        List<String> userSessionIds = new ArrayList<>();
        for (PersistentUserSessionEntity entity : results) {
            RealmModel realm = session.realms().getRealm(entity.getRealmId());
            try {
                UserModel user = session.users().getUserById(entity.getUserId(), realm);
                // Case when user was deleted in the meantime
                if (user == null) {
                    onUserRemoved(realm, entity.getUserId());
                    return loadUserSessions(firstResult, maxResults, offline);
                }
            } catch (Exception e) {
                logger.debugv(e,"Failed to load user with id {0}", entity.getUserId());
            }


            result.add(toAdapter(realm, entity));
            userSessionIds.add(entity.getUserSessionId());
        }

        Set<String> removedClientUUIDs = new HashSet<>();

        if (!userSessionIds.isEmpty()) {
            TypedQuery<PersistentClientSessionEntity> query2 = em.createNamedQuery("findClientSessionsByUserSessions", PersistentClientSessionEntity.class);
            query2.setParameter("userSessionIds", userSessionIds);
            query2.setParameter("offline", offlineStr);
            List<PersistentClientSessionEntity> clientSessions = query2.getResultList();

            // Assume both userSessions and clientSessions ordered by userSessionId
            int j = 0;
            for (UserSessionModel ss : result) {
                PersistentUserSessionAdapter userSession = (PersistentUserSessionAdapter) ss;
                Map<String, AuthenticatedClientSessionModel> currentClientSessions = userSession.getAuthenticatedClientSessions(); // This is empty now and we want to fill it

                boolean next = true;
                while (next && j < clientSessions.size()) {
                    PersistentClientSessionEntity clientSession = clientSessions.get(j);
                    if (clientSession.getUserSessionId().equals(userSession.getId())) {
                        PersistentAuthenticatedClientSessionAdapter clientSessAdapter = toAdapter(userSession.getRealm(), userSession, clientSession);

                        // Case when client was removed in the meantime
                        if (clientSessAdapter.getClient() == null) {
                            removedClientUUIDs.add(clientSession.getClientId());
                        } else {
                            currentClientSessions.put(clientSession.getClientId(), clientSessAdapter);
                        }
                        j++;
                    } else {
                        next = false;
                    }
                }
            }
        }

        for (String clientUUID : removedClientUUIDs) {
            onClientRemoved(clientUUID);
        }

        return result;
    }

offlineFromString()

boolean org.keycloak.models.jpa.session.JpaUserSessionPersisterProvider.offlineFromString ( String  offlineStr )

inlineprivate

                                                         {
        return "1".equals(offlineStr);
    }

offlineToString()

String org.keycloak.models.jpa.session.JpaUserSessionPersisterProvider.offlineToString ( boolean  offline )

inlineprivate

                                                    {
        return offline ? "1" : "0";
    }

onClientRemoved() [1/2]

void org.keycloak.models.jpa.session.JpaUserSessionPersisterProvider.onClientRemoved ( RealmModel  realm, ClientModel  client  )

inline

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

                                                                      {
        onClientRemoved(client.getId());
    }

onClientRemoved() [2/2]

void org.keycloak.models.jpa.session.JpaUserSessionPersisterProvider.onClientRemoved ( String  clientUUID )

inlineprivate

                                                    {
        int num = 0;
        StorageId clientStorageId = new StorageId(clientUUID);
        if (clientStorageId.isLocal()) {
            num = em.createNamedQuery("deleteClientSessionsByClient").setParameter("clientId", clientUUID).executeUpdate();
        } else {
            num = em.createNamedQuery("deleteClientSessionsByExternalClient")
                    .setParameter("clientStorageProvider", clientStorageId.getProviderId())
                    .setParameter("externalClientId", clientStorageId.getExternalId())
                    .executeUpdate();
        }
        num = em.createNamedQuery("deleteDetachedUserSessions").executeUpdate();
    }

onRealmRemoved()

void org.keycloak.models.jpa.session.JpaUserSessionPersisterProvider.onRealmRemoved ( RealmModel  realm )

inline

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

                                                 {
        int num = em.createNamedQuery("deleteClientSessionsByRealm").setParameter("realmId", realm.getId()).executeUpdate();
        num = em.createNamedQuery("deleteUserSessionsByRealm").setParameter("realmId", realm.getId()).executeUpdate();
    }

onUserRemoved() [1/2]

void org.keycloak.models.jpa.session.JpaUserSessionPersisterProvider.onUserRemoved ( RealmModel  realm, UserModel  user  )

inline

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

                                                                {
        onUserRemoved(realm, user.getId());
    }

onUserRemoved() [2/2]

void org.keycloak.models.jpa.session.JpaUserSessionPersisterProvider.onUserRemoved ( RealmModel  realm, String  userId  )

inlineprivate

                                                                {
        int num = em.createNamedQuery("deleteClientSessionsByUser").setParameter("userId", userId).executeUpdate();
        num = em.createNamedQuery("deleteUserSessionsByUser").setParameter("userId", userId).executeUpdate();
    }

removeClientSession()

void org.keycloak.models.jpa.session.JpaUserSessionPersisterProvider.removeClientSession ( String  userSessionId, String  clientUUID, boolean  offline  )

inline

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

                                                                                              {
        String offlineStr = offlineToString(offline);
        StorageId clientStorageId = new StorageId(clientUUID);
        String clientId = PersistentClientSessionEntity.EXTERNAL;
        String clientStorageProvider = PersistentClientSessionEntity.LOCAL;
        String externalId = PersistentClientSessionEntity.LOCAL;
        if (clientStorageId.isLocal()) {
            clientId = clientUUID;
        } else {
            clientStorageProvider = clientStorageId.getProviderId();
            externalId = clientStorageId.getExternalId();

        }
        PersistentClientSessionEntity sessionEntity = em.find(PersistentClientSessionEntity.class, new PersistentClientSessionEntity.Key(userSessionId, clientId, clientStorageProvider, externalId, offlineStr));
        if (sessionEntity != null) {
            em.remove(sessionEntity);

            // Remove userSession if it was last clientSession
            List<PersistentClientSessionEntity> clientSessions = getClientSessionsByUserSession(sessionEntity.getUserSessionId(), offline);
            if (clientSessions.size() == 0) {
                offlineStr = offlineToString(offline);
                PersistentUserSessionEntity userSessionEntity = em.find(PersistentUserSessionEntity.class, new PersistentUserSessionEntity.Key(sessionEntity.getUserSessionId(), offlineStr));
                if (userSessionEntity != null) {
                    em.remove(userSessionEntity);
                }
            }

            em.flush();
        }
    }

removeUserSession()

void org.keycloak.models.jpa.session.JpaUserSessionPersisterProvider.removeUserSession ( String  userSessionId, boolean  offline  )

inline

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

                                                                         {
        String offlineStr = offlineToString(offline);

        em.createNamedQuery("deleteClientSessionsByUserSession")
                .setParameter("userSessionId", userSessionId)
                .setParameter("offline", offlineStr)
                .executeUpdate();

        PersistentUserSessionEntity sessionEntity = em.find(PersistentUserSessionEntity.class, new PersistentUserSessionEntity.Key(userSessionId, offlineStr));
        if (sessionEntity != null) {
            em.remove(sessionEntity);
            em.flush();
        }
    }

toAdapter() [1/2]

PersistentUserSessionAdapter org.keycloak.models.jpa.session.JpaUserSessionPersisterProvider.toAdapter ( RealmModel  realm, PersistentUserSessionEntity  entity  )

inlineprivate

                                                                                                         {
        PersistentUserSessionModel model = new PersistentUserSessionModel();
        model.setUserSessionId(entity.getUserSessionId());
        model.setLastSessionRefresh(entity.getLastSessionRefresh());
        model.setData(entity.getData());
        model.setOffline(offlineFromString(entity.getOffline()));

        Map<String, AuthenticatedClientSessionModel> clientSessions = new HashMap<>();
        return new PersistentUserSessionAdapter(session, model, realm, entity.getUserId(), clientSessions);
    }

toAdapter() [2/2]

PersistentAuthenticatedClientSessionAdapter org.keycloak.models.jpa.session.JpaUserSessionPersisterProvider.toAdapter ( RealmModel  realm, PersistentUserSessionAdapter  userSession, PersistentClientSessionEntity  entity  )

inlineprivate

                                                                                                                                                                    {
        String clientId = entity.getClientId();
        if (!entity.getExternalClientId().equals("local")) {
            clientId = new StorageId(entity.getClientId(), entity.getExternalClientId()).getId();
        }
        ClientModel client = realm.getClientById(clientId);

        PersistentClientSessionModel model = new PersistentClientSessionModel();
        model.setClientId(clientId);
        model.setUserSessionId(userSession.getId());
        model.setUserId(userSession.getUserId());
        model.setTimestamp(entity.getTimestamp());
        model.setData(entity.getData());
        return new PersistentAuthenticatedClientSessionAdapter(model, realm, client, userSession);
    }

updateAllTimestamps()

void org.keycloak.models.jpa.session.JpaUserSessionPersisterProvider.updateAllTimestamps ( int  time )

inline

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

                                              {
        int num = em.createNamedQuery("updateClientSessionsTimestamps").setParameter("timestamp", time).executeUpdate();
        num = em.createNamedQuery("updateUserSessionsTimestamps").setParameter("lastSessionRefresh", time).executeUpdate();
    }

updateUserSession()

void org.keycloak.models.jpa.session.JpaUserSessionPersisterProvider.updateUserSession ( UserSessionModel  userSession, boolean  offline  )

inline

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

                                                                                 {
        PersistentUserSessionAdapter adapter;
        if (userSession instanceof PersistentUserSessionAdapter) {
            adapter = (PersistentUserSessionAdapter) userSession;
        } else {
            adapter = new PersistentUserSessionAdapter(userSession);
        }

        PersistentUserSessionModel model = adapter.getUpdatedModel();

        String offlineStr = offlineToString(offline);
        PersistentUserSessionEntity entity = em.find(PersistentUserSessionEntity.class, new PersistentUserSessionEntity.Key(userSession.getId(), offlineStr));
        if (entity == null) {
            throw new ModelException("UserSession with ID " + userSession.getId() + ", offline: " + offline + " not found");
        }
        entity.setLastSessionRefresh(model.getLastSessionRefresh());
        entity.setData(model.getData());
    }

メンバ詳解

em

final EntityManager org.keycloak.models.jpa.session.JpaUserSessionPersisterProvider.em

private

logger

final Logger org.keycloak.models.jpa.session.JpaUserSessionPersisterProvider.logger = Logger.getLogger(JpaUserSessionPersisterProvider.class)

staticprivate

session

final KeycloakSession org.keycloak.models.jpa.session.JpaUserSessionPersisterProvider.session

private

---

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

• D:/AppData/doxygen/keycloak/src/keycloak/src/main/java/org/keycloak/models/jpa/session/JpaUserSessionPersisterProvider.java