@Override public void accept(Map.Entry<String, SessionEntity> entry) { SessionEntity e = entry.getValue(); sessions.add(provider.wrap(realm, (UserSessionEntity) e, offline)); }
List<ClientInitialAccessModel> wrapClientInitialAccess(RealmModel realm, Collection<ClientInitialAccessEntity> entities) { List<ClientInitialAccessModel> models = new LinkedList<>(); for (ClientInitialAccessEntity e : entities) { models.add(wrap(realm, e)); } return models; }
@Override public void accept(Map.Entry<String, SessionEntity> entry) { SessionEntity e = entry.getValue(); sessions.add(provider.wrap(realm, (UserSessionEntity) e, offline)); }
List<ClientSessionModel> wrapClientSessions(RealmModel realm, Collection<ClientSessionEntity> entities, boolean offline) { List<ClientSessionModel> models = new LinkedList<>(); for (ClientSessionEntity e : entities) { models.add(wrap(realm, e, offline)); } return models; }
@Override public AuthenticatedClientSessionAdapter getClientSession(UserSessionModel userSession, ClientModel client, UUID clientSessionId, boolean offline) { AuthenticatedClientSessionEntity entity = getClientSessionEntity(clientSessionId, offline); return wrap(userSession, client, entity, offline); }
@Override public void accept(UserSessionTimestamp userSessionTimestamp) { SessionEntity entity = cache.get(userSessionTimestamp.getUserSessionId()); if (entity != null) { sessions.add(wrap(realm, (UserSessionEntity) entity, offline)); } } });
protected List<UserSessionModel> getUserSessions(RealmModel realm, Predicate<Map.Entry<String, SessionEntity>> predicate, boolean offline) { CacheStream<Map.Entry<String, SessionEntity>> cacheStream = getCache(offline).entrySet().stream(); Iterator<Map.Entry<String, SessionEntity>> itr = cacheStream.filter(predicate).iterator(); List<UserSessionModel> sessions = new LinkedList<>(); while (itr.hasNext()) { UserSessionEntity e = (UserSessionEntity) itr.next().getValue(); sessions.add(wrap(realm, e, offline)); } return sessions; }
@Override public List<ClientInitialAccessModel> listClientInitialAccess(RealmModel realm) { Iterator<Map.Entry<String, SessionEntity>> itr = sessionCache.entrySet().stream().filter(ClientInitialAccessPredicate.create(realm.getId())).iterator(); List<ClientInitialAccessModel> list = new LinkedList<>(); while (itr.hasNext()) { list.add(wrap(realm, (ClientInitialAccessEntity) itr.next().getValue())); } return list; }
@Override public UsernameLoginFailureModel getUserLoginFailure(RealmModel realm, String username) { LoginFailureKey key = new LoginFailureKey(realm.getId(), username); return wrap(key, loginFailureCache.get(key)); }
protected UserSessionAdapter getUserSession(RealmModel realm, String id, boolean offline) { Cache<String, SessionEntity> cache = getCache(offline); UserSessionEntity entity = (UserSessionEntity) cache.get(id); // Chance created in this transaction if (entity == null) { entity = (UserSessionEntity) tx.get(cache, id); } return wrap(realm, entity, offline); }
@Override public ClientInitialAccessModel getClientInitialAccessModel(RealmModel realm, String id) { Cache<String, SessionEntity> cache = getCache(false); ClientInitialAccessEntity entity = (ClientInitialAccessEntity) cache.get(id); // If created in this transaction if (entity == null) { entity = (ClientInitialAccessEntity) tx.get(cache, id); } return wrap(realm, entity); }
protected ClientSessionModel getClientSession(RealmModel realm, String id, boolean offline) { Cache<String, SessionEntity> cache = getCache(offline); ClientSessionEntity entity = (ClientSessionEntity) cache.get(id); // Chance created in this transaction if (entity == null) { entity = (ClientSessionEntity) tx.get(cache, id); } return wrap(realm, entity, offline); }
@Override public UserLoginFailureModel getUserLoginFailure(RealmModel realm, String userId) { LoginFailureKey key = new LoginFailureKey(realm.getId(), userId); LoginFailureEntity entity = getLoginFailureEntity(key); return wrap(key, entity); }
private void onClientRemoved(RealmModel realm, ClientModel client, boolean offline) { Cache<String, SessionEntity> cache = getCache(offline); Iterator<Map.Entry<String, SessionEntity>> itr = cache.entrySet().stream().filter(ClientSessionPredicate.create(realm.getId()).client(client.getId())).iterator(); while (itr.hasNext()) { ClientSessionEntity entity = (ClientSessionEntity) itr.next().getValue(); ClientSessionAdapter adapter = wrap(realm, entity, offline); adapter.setUserSession(null); tx.remove(cache, entity.getId()); } }
@Override public UserSessionModel createUserSession(String id, RealmModel realm, UserModel user, String loginUsername, String ipAddress, String authMethod, boolean rememberMe, String brokerSessionId, String brokerUserId) { 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); }
protected UserSessionAdapter importUserSession(UserSessionModel userSession, boolean offline) { UserSessionEntity entity = createUserSessionEntityInstance(userSession); 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); return importedSession; }
@Override public UsernameLoginFailureModel addUserLoginFailure(RealmModel realm, String username) { LoginFailureKey key = new LoginFailureKey(realm.getId(), username); LoginFailureEntity entity = new LoginFailureEntity(); entity.setRealm(realm.getId()); entity.setUsername(username); tx.put(loginFailureCache, key, entity); return wrap(key, entity); }
@Override public UserLoginFailureModel addUserLoginFailure(RealmModel realm, String userId) { 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); }
@Override public ClientSessionModel createClientSession(RealmModel realm, ClientModel client) { String id = KeycloakModelUtils.generateId(); ClientSessionEntity entity = new ClientSessionEntity(); entity.setId(id); entity.setRealm(realm.getId()); entity.setTimestamp(Time.currentTime()); entity.setClient(client.getId()); tx.put(sessionCache, id, entity); return wrap(realm, entity, false); }
@Override public ClientInitialAccessModel createClientInitialAccessModel(RealmModel realm, int expiration, int count) { String id = KeycloakModelUtils.generateId(); ClientInitialAccessEntity entity = new ClientInitialAccessEntity(); entity.setId(id); entity.setRealm(realm.getId()); entity.setTimestamp(Time.currentTime()); entity.setExpiration(expiration); entity.setCount(count); entity.setRemainingCount(count); tx.put(sessionCache, id, entity); return wrap(realm, entity); }