@Override public UserSessionModel getUserSessionByBrokerSessionId(RealmModel realm, String brokerSessionId) { Map<String, UserSessionEntity> sessions = new MapReduceTask(sessionCache) .mappedWith(UserSessionMapper.create(realm.getId()).brokerSessionId(brokerSessionId)) .reducedWith(new FirstResultReducer()) .execute(); List<UserSessionModel> userSessionModels = wrapUserSessions(realm, sessions.values(), false); if (userSessionModels.isEmpty()) return null; return userSessionModels.get(0); }
.mappedWith(ClientSessionMapper.create(realm.getId()).client(client.getId()).emitUserSessionAndTimestamp()) .reducedWith(new LargestResultReducer()) .execute();
public Void run() { MapReduceTask<CacheKey, Object, Void, Void> task = new MapReduceTask<CacheKey, Object, Void, Void>(cache); task.mappedWith(new ClearCacheMapper(getOwnerId())).reducedWith(new IdentityReducer()); task.execute(); return null; } });
@Override public Void run() { MapReduceTask<CacheKey<K>, V, Void, Void> task = new MapReduceTask<CacheKey<K>, V, Void, Void>(cache); task.mappedWith(new ClearCacheMapper<K, V>(fullName)).reducedWith(new ClearCacheReducer()); task.execute(); return null; }
@Override public Map<K, V> run() { MapReduceTask<CacheKey<K>, V, K, V> task = new MapReduceTask<CacheKey<K>, V, K, V>(cache); task.mappedWith(new GetEntriesMapper<K, V>(fullName)).reducedWith(new GetEntriesReducer<K, V>()); return task.execute(); }
@Override public List<ClientInitialAccessModel> listClientInitialAccess(RealmModel realm) { Map<String, ClientInitialAccessEntity> entities = new MapReduceTask(sessionCache) .mappedWith(ClientInitialAccessMapper.create(realm.getId())) .reducedWith(new FirstResultReducer()) .execute(); return wrapClientInitialAccess(realm, entities.values()); }
public Map<String, Integer> run() { MapReduceTask<CacheKey, Object, String, Integer> task = new MapReduceTask<CacheKey, Object, String, Integer>(cache); task.mappedWith(new GetSizeMapper(getOwnerId())).reducedWith(new GetSizeReducer<String>()); return task.execute(); }
public Void run() { MapReduceTask<CacheKey, Object, Void, Void> task = new MapReduceTask<CacheKey, Object, Void, Void>(cache); task.mappedWith(new UpdateChildsACLMapper(getOwnerId(), parentPath, acl)).reducedWith( new IdentityReducer()); task.execute(); return null; } });
@Override public Map<String, Integer> run() { MapReduceTask<CacheKey<K>, V, String, Integer> task = new MapReduceTask<CacheKey<K>, V, String, Integer>(cache); task.mappedWith(new GetSizeMapper<K, V>(fullName)).reducedWith(new GetSizeReducer<String>()); return task.execute(); }
public Void run() { MapReduceTask<CacheKey, Object, Void, Void> task = new MapReduceTask<CacheKey, Object, Void, Void>(cache); task.mappedWith(new UpdateTreePathMapper(getOwnerId(), prevRootPath, newRootPath)).reducedWith( new IdentityReducer()); task.execute(); return null; } });
@Override public Map<String, List<V>> run() { MapReduceTask<CacheKey<K>, V, String, List<V>> task = new MapReduceTask<CacheKey<K>, V, String, List<V>>(cache); task.mappedWith(new GetCachedObjectsMapper<K, V>(fullName)).reducedWith( new GetCachedObjectsReducer<String, V>()); return task.execute(); }
@Override public List<UserSessionModel> getUserSessionByBrokerUserId(RealmModel realm, String brokerUserId) { Map<String, UserSessionEntity> sessions = new MapReduceTask(sessionCache) .mappedWith(UserSessionMapper.create(realm.getId()).brokerUserId(brokerUserId)) .reducedWith(new FirstResultReducer()) .execute(); return wrapUserSessions(realm, sessions.values(), false); }
@Override public void removeAllUserLoginFailures(RealmModel realm) { Map<LoginFailureKey, Object> sessions = new MapReduceTask(loginFailureCache) .mappedWith(UserLoginFailureMapper.create(realm.getId()).emitKey()) .reducedWith(new FirstResultReducer()) .execute(); for (LoginFailureKey id : sessions.keySet()) { tx.remove(loginFailureCache, id); } }
private void onClientRemoved(RealmModel realm, ClientModel client, boolean offline) { Cache<String, SessionEntity> cache = getCache(offline); Map<String, ClientSessionEntity> map = new MapReduceTask(cache) .mappedWith(ClientSessionMapper.create(realm.getId()).client(client.getId())) .reducedWith(new FirstResultReducer()) .execute(); for (Map.Entry<String, ClientSessionEntity> entry : map.entrySet()) { // detach from userSession ClientSessionAdapter adapter = wrap(realm, entry.getValue(), offline); adapter.setUserSession(null); tx.remove(cache, entry.getKey()); } }
@Override public List<ClientSessionModel> getOfflineClientSessions(RealmModel realm, UserModel user) { Map<String, UserSessionEntity> sessions = new MapReduceTask(offlineSessionCache) .mappedWith(UserSessionMapper.create(realm.getId()).user(user.getId())) .reducedWith(new FirstResultReducer()) .execute(); List<ClientSessionEntity> clientSessions = new LinkedList<>(); for (UserSessionEntity userSession : sessions.values()) { Set<String> currClientSessions = userSession.getClientSessions(); for (String clientSessionId : currClientSessions) { ClientSessionEntity cls = (ClientSessionEntity) offlineSessionCache.get(clientSessionId); if (cls != null) { clientSessions.add(cls); } } } return wrapClientSessions(realm, clientSessions, true); }
@Override public List<UserSessionModel> getUserSessions(RealmModel realm, UserModel user) { Map<String, UserSessionEntity> sessions = new MapReduceTask(sessionCache) .mappedWith(UserSessionMapper.create(realm.getId()).user(user.getId())) .reducedWith(new FirstResultReducer()) .execute(); return wrapUserSessions(realm, sessions.values(), false); }
protected void removeUserSessions(RealmModel realm, boolean offline) { Cache<String, SessionEntity> cache = getCache(offline); Map<String, String> ids = new MapReduceTask(cache) .mappedWith(SessionMapper.create(realm.getId()).emitKey()) .reducedWith(new FirstResultReducer()) .execute(); for (String id : ids.keySet()) { cache.remove(id); } }
protected long getUserSessionsCount(RealmModel realm, ClientModel client, boolean offline) { Cache<String, SessionEntity> cache = getCache(offline); Map map = new MapReduceTask(cache) .mappedWith(ClientSessionMapper.create(realm.getId()).client(client.getId()).emitUserSessionAndTimestamp()) .reducedWith(new LargestResultReducer()).execute(); return map.size(); }
protected void removeUserSessions(RealmModel realm, UserModel user, boolean offline) { Cache<String, SessionEntity> cache = getCache(offline); Map<String, String> sessions = new MapReduceTask(cache) .mappedWith(UserSessionMapper.create(realm.getId()).user(user.getId()).emitKey()) .reducedWith(new FirstResultReducer()) .execute(); for (String id : sessions.keySet()) { removeUserSession(realm, id, offline); } }
protected void removeUserSession(RealmModel realm, String userSessionId, boolean offline) { Cache<String, SessionEntity> cache = getCache(offline); tx.remove(cache, userSessionId); // TODO: Isn't more effective to retrieve from userSessionEntity directly? Map<String, String> map = new MapReduceTask(cache) .mappedWith(ClientSessionMapper.create(realm.getId()).userSession(userSessionId).emitKey()) .reducedWith(new FirstResultReducer()) .execute(); for (String id : map.keySet()) { tx.remove(cache, id); } }