org.keycloak.storage.UserStorageManager クラス

org.keycloak.storage.UserStorageManager の継承関係図

org.keycloak.storage.UserStorageManager 連携図

クラス
interface	PaginatedQuery

公開メンバ関数
	UserStorageManager (KeycloakSession session)
UserModel	addUser (RealmModel realm, String id, String username, boolean addDefaultRoles, boolean addDefaultRequiredActions)
UserModel	addUser (RealmModel realm, String username)
boolean	removeUser (RealmModel realm, UserModel user)
UserFederatedStorageProvider	getFederatedStorage ()
void	addFederatedIdentity (RealmModel realm, UserModel user, FederatedIdentityModel socialLink)
void	updateFederatedIdentity (RealmModel realm, UserModel federatedUser, FederatedIdentityModel federatedIdentityModel)
boolean	removeFederatedIdentity (RealmModel realm, UserModel user, String socialProvider)
void	addConsent (RealmModel realm, String userId, UserConsentModel consent)
UserConsentModel	getConsentByClient (RealmModel realm, String userId, String clientInternalId)
List< UserConsentModel >	getConsents (RealmModel realm, String userId)
void	updateConsent (RealmModel realm, String userId, UserConsentModel consent)
boolean	revokeConsentForClient (RealmModel realm, String userId, String clientInternalId)
void	setNotBeforeForUser (RealmModel realm, UserModel user, int notBefore)
int	getNotBeforeOfUser (RealmModel realm, UserModel user)
UserModel	getUserById (String id, RealmModel realm)
List< UserModel >	getGroupMembers (RealmModel realm, GroupModel group)
List< UserModel >	getRoleMembers (RealmModel realm, RoleModel role)
UserModel	getUserByUsername (String username, RealmModel realm)
UserModel	getUserByEmail (String email, RealmModel realm)
UserModel	getUserByFederatedIdentity (FederatedIdentityModel socialLink, RealmModel realm)
UserModel	getServiceAccount (ClientModel client)
List< UserModel >	getUsers (RealmModel realm, boolean includeServiceAccounts)
List< UserModel >	getUsers (RealmModel realm)
List< UserModel >	getUsers (RealmModel realm, int firstResult, int maxResults)
int	getUsersCount (RealmModel realm, boolean includeServiceAccount)
int	getUsersCount (RealmModel realm)
List< UserModel >	getUsers (final RealmModel realm, int firstResult, int maxResults, final boolean includeServiceAccounts)
List< UserModel >	searchForUser (String search, RealmModel realm)
List< UserModel >	searchForUser (String search, RealmModel realm, int firstResult, int maxResults)
List< UserModel >	searchForUser (Map< String, String > attributes, RealmModel realm)
List< UserModel >	searchForUser (Map< String, String > attributes, RealmModel realm, int firstResult, int maxResults)
List< UserModel >	searchForUserByUserAttribute (String attrName, String attrValue, RealmModel realm)
Set< FederatedIdentityModel >	getFederatedIdentities (UserModel user, RealmModel realm)
FederatedIdentityModel	getFederatedIdentity (UserModel user, String socialProvider, RealmModel realm)
void	grantToAllUsers (RealmModel realm, RoleModel role)
List< UserModel >	getGroupMembers (final RealmModel realm, final GroupModel group, int firstResult, int maxResults)
List< UserModel >	getRoleMembers (final RealmModel realm, final RoleModel role, int firstResult, int maxResults)
void	preRemove (RealmModel realm)
void	preRemove (RealmModel realm, GroupModel group)
void	preRemove (RealmModel realm, RoleModel role)
void	preRemove (RealmModel realm, ClientModel client)
void	preRemove (ProtocolMapperModel protocolMapper)
void	preRemove (ClientScopeModel clientScope)
void	preRemove (RealmModel realm, ComponentModel component)
void	removeImportedUsers (RealmModel realm, String storageProviderId)
void	unlinkUsers (RealmModel realm, String storageProviderId)
void	onCache (RealmModel realm, CachedUserModel user, UserModel delegate)
void	close ()
void	onCreate (KeycloakSession session, RealmModel realm, ComponentModel model)
void	onUpdate (KeycloakSession session, RealmModel realm, ComponentModel oldModel, ComponentModel newModel)

静的公開メンバ関数
static boolean	isStorageProviderEnabled (RealmModel realm, String providerId)
static List< UserStorageProviderModel >	getStorageProviders (RealmModel realm)
static UserStorageProvider	getStorageProviderInstance (KeycloakSession session, UserStorageProviderModel model, UserStorageProviderFactory factory)
static< T > List< T >	getStorageProviders (KeycloakSession session, RealmModel realm, Class< T > type)
static< T > List< T >	getEnabledStorageProviders (KeycloakSession session, RealmModel realm, Class< T > type)
static UserStorageProviderModel	getStorageProviderModel (RealmModel realm, String componentId)
static UserStorageProvider	getStorageProvider (KeycloakSession session, RealmModel realm, String componentId)

限定公開メンバ関数
UserProvider	localStorage ()
UserModel	importValidation (RealmModel realm, UserModel user)
void	deleteInvalidUser (final RealmModel realm, final UserModel user)
List< UserModel >	importValidation (RealmModel realm, List< UserModel > users)
List< UserModel >	query (PaginatedQuery pagedQuery, RealmModel realm, int firstResult, int maxResults)

限定公開変数類
KeycloakSession	session

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

詳解

著者

Bill Burke

バージョン

Revision

1

構築子と解体子

UserStorageManager()

org.keycloak.storage.UserStorageManager.UserStorageManager ( KeycloakSession  session )

inline

                                                       {
        this.session = session;
    }

関数詳解

addConsent()

void org.keycloak.storage.UserStorageManager.addConsent ( RealmModel  realm, String  userId, UserConsentModel  consent  )

inline

                                                                                      {
        if (StorageId.isLocalStorage(userId)) {
            localStorage().addConsent(realm, userId, consent);
        } else {
            getFederatedStorage().addConsent(realm, userId, consent);
        }

    }

addFederatedIdentity()

void org.keycloak.storage.UserStorageManager.addFederatedIdentity ( RealmModel  realm, UserModel  user, FederatedIdentityModel  socialLink  )

inline

                                                                                                          {
        if (StorageId.isLocalStorage(user)) {
            localStorage().addFederatedIdentity(realm, user, socialLink);
        } else {
            getFederatedStorage().addFederatedIdentity(realm, user.getId(), socialLink);
        }
    }

addUser() [1/2]

UserModel org.keycloak.storage.UserStorageManager.addUser ( RealmModel  realm, String  id, String  username, boolean  addDefaultRoles, boolean  addDefaultRequiredActions  )

inline

                                                                                                                                       {
        return localStorage().addUser(realm, id, username.toLowerCase(), addDefaultRoles, addDefaultRequiredActions);
    }

addUser() [2/2]

UserModel org.keycloak.storage.UserStorageManager.addUser ( RealmModel  realm, String  username  )

inline

                                                                {
        for (UserRegistrationProvider provider : getEnabledStorageProviders(session, realm, UserRegistrationProvider.class)) {
            UserModel user = provider.addUser(realm, username);
            if (user != null) return user;
        }

        return localStorage().addUser(realm, username.toLowerCase());
    }

close()

void org.keycloak.storage.UserStorageManager.close ( )

inline

                        {
    }

deleteInvalidUser()

void org.keycloak.storage.UserStorageManager.deleteInvalidUser ( final RealmModel  realm, final UserModel  user  )

inlineprotected

                                                                                   {
        String userId = user.getId();
        String userName = user.getUsername();
        UserCache userCache = session.userCache();
        if (userCache != null) {
            userCache.evict(realm, user);
        }
        runJobInTransaction(session.getKeycloakSessionFactory(), new KeycloakSessionTask() {

            @Override
            public void run(KeycloakSession session) {
                RealmModel realmModel = session.realms().getRealm(realm.getId());
                if (realmModel == null) return;
                UserModel deletedUser = session.userLocalStorage().getUserById(userId, realmModel);
                new UserManager(session).removeUser(realmModel, deletedUser, session.userLocalStorage());
                logger.debugf("Removed invalid user '%s'", userName);
            }

        });
    }

getConsentByClient()

UserConsentModel org.keycloak.storage.UserStorageManager.getConsentByClient ( RealmModel  realm, String  userId, String  clientInternalId  )

inline

                                                                                                         {
        if (StorageId.isLocalStorage(userId)) {
            return localStorage().getConsentByClient(realm, userId, clientInternalId);
        } else {
            return getFederatedStorage().getConsentByClient(realm, userId, clientInternalId);
        }
    }

getConsents()

List<UserConsentModel> org.keycloak.storage.UserStorageManager.getConsents ( RealmModel  realm, String  userId  )

inline

                                                                               {
        if (StorageId.isLocalStorage(userId)) {
            return localStorage().getConsents(realm, userId);

        } else {
            return getFederatedStorage().getConsents(realm, userId);
        }
    }

getEnabledStorageProviders()

static <T> List<T> org.keycloak.storage.UserStorageManager.getEnabledStorageProviders ( KeycloakSession  session, RealmModel  realm, Class< T >  type  )

inlinestatic

                                                                                                                   {
        List<T> list = new LinkedList<>();
        for (UserStorageProviderModel model : getStorageProviders(realm)) {
            if (!model.isEnabled()) continue;
            UserStorageProviderFactory factory = (UserStorageProviderFactory) session.getKeycloakSessionFactory().getProviderFactory(UserStorageProvider.class, model.getProviderId());
            if (factory == null) {
                logger.warnv("Configured UserStorageProvider {0} of provider id {1} does not exist in realm {2}", model.getName(), model.getProviderId(), realm.getName());
                continue;
            }
            if (Types.supports(type, factory, UserStorageProviderFactory.class)) {
                list.add(type.cast(getStorageProviderInstance(session, model, factory)));
            }


        }
        return list;
    }

getFederatedIdentities()

Set<FederatedIdentityModel> org.keycloak.storage.UserStorageManager.getFederatedIdentities ( UserModel  user, RealmModel  realm  )

inline

                                                                                                {
        if (user == null) throw new IllegalStateException("Federated user no longer valid");
        Set<FederatedIdentityModel> set = new HashSet<>();
        if (StorageId.isLocalStorage(user)) {
            set.addAll(localStorage().getFederatedIdentities(user, realm));
        }
        if (getFederatedStorage() != null) set.addAll(getFederatedStorage().getFederatedIdentities(user.getId(), realm));
        return set;
    }

getFederatedIdentity()

FederatedIdentityModel org.keycloak.storage.UserStorageManager.getFederatedIdentity ( UserModel  user, String  socialProvider, RealmModel  realm  )

inline

                                                                                                                {
        if (user == null) throw new IllegalStateException("Federated user no longer valid");
        if (StorageId.isLocalStorage(user)) {
            FederatedIdentityModel model = localStorage().getFederatedIdentity(user, socialProvider, realm);
            if (model != null) return model;
        }
        if (getFederatedStorage() != null) return getFederatedStorage().getFederatedIdentity(user.getId(), socialProvider, realm);
        else return null;
    }

getFederatedStorage()

UserFederatedStorageProvider org.keycloak.storage.UserStorageManager.getFederatedStorage ( )

inline

                                                              {
        return session.userFederatedStorage();
    }

getGroupMembers() [1/2]

List<UserModel> org.keycloak.storage.UserStorageManager.getGroupMembers ( RealmModel  realm, GroupModel  group  )

inline

                                                                               {
        return getGroupMembers(realm, group, -1, -1);
    }

getGroupMembers() [2/2]

List<UserModel> org.keycloak.storage.UserStorageManager.getGroupMembers ( final RealmModel  realm, final GroupModel  group, int  firstResult, int  maxResults  )

inline

                                                                                                                            {
        List<UserModel> results = query((provider, first, max) -> {
            if (provider instanceof UserQueryProvider) {
                return ((UserQueryProvider)provider).getGroupMembers(realm, group, first, max);

            } else if (provider instanceof UserFederatedStorageProvider) {
                List<String> ids = ((UserFederatedStorageProvider)provider).getMembership(realm, group, first, max);
                List<UserModel> rs = new LinkedList<UserModel>();
                for (String id : ids) {
                    UserModel user = getUserById(id, realm);
                    if (user != null) rs.add(user);
                }
                return rs;

            }
            return Collections.EMPTY_LIST;
        }, realm, firstResult, maxResults);
        return importValidation(realm, results);
    }

getNotBeforeOfUser()

int org.keycloak.storage.UserStorageManager.getNotBeforeOfUser ( RealmModel  realm, UserModel  user  )

inline

                                                                    {
        if (StorageId.isLocalStorage(user)) {
            return localStorage().getNotBeforeOfUser(realm, user);

        } else {
            return getFederatedStorage().getNotBeforeOfUser(realm, user.getId());
        }
    }

getRoleMembers() [1/2]

List<UserModel> org.keycloak.storage.UserStorageManager.getRoleMembers ( RealmModel  realm, RoleModel  role  )

inline

                                                                            {
        return getRoleMembers(realm, role, -1, -1);
    }

getRoleMembers() [2/2]

List<UserModel> org.keycloak.storage.UserStorageManager.getRoleMembers ( final RealmModel  realm, final RoleModel  role, int  firstResult, int  maxResults  )

inline

                                                                                                                         {
        List<UserModel> results = query((provider, first, max) -> {
            if (provider instanceof UserQueryProvider) {
                return ((UserQueryProvider)provider).getRoleMembers(realm, role, first, max);
            } 
            return Collections.EMPTY_LIST;
        }, realm, firstResult, maxResults);
        return importValidation(realm, results);
    }

getServiceAccount()

UserModel org.keycloak.storage.UserStorageManager.getServiceAccount ( ClientModel  client )

inline

                                                           {
        return localStorage().getServiceAccount(client);
    }

getStorageProvider()

static UserStorageProvider org.keycloak.storage.UserStorageManager.getStorageProvider ( KeycloakSession  session, RealmModel  realm, String  componentId  )

inlinestatic

                                                                                                                        {
        ComponentModel model = realm.getComponent(componentId);
        if (model == null) return null;
        UserStorageProviderModel storageModel = new UserStorageProviderModel(model);
        UserStorageProviderFactory factory = (UserStorageProviderFactory)session.getKeycloakSessionFactory().getProviderFactory(UserStorageProvider.class, model.getProviderId());
        if (factory == null) {
            throw new ModelException("Could not find UserStorageProviderFactory for: " + model.getProviderId());
        }
        return getStorageProviderInstance(session, storageModel, factory);
    }

getStorageProviderInstance()

static UserStorageProvider org.keycloak.storage.UserStorageManager.getStorageProviderInstance ( KeycloakSession  session, UserStorageProviderModel  model, UserStorageProviderFactory  factory  )

inlinestatic

                                                                                                                                                              {
        UserStorageProvider instance = (UserStorageProvider)session.getAttribute(model.getId());
        if (instance != null) return instance;
        instance = factory.create(session, model);
        if (instance == null) {
            throw new IllegalStateException("UserStorageProvideFactory (of type " + factory.getClass().getName() + ") produced a null instance");
        }
        session.enlistForClose(instance);
        session.setAttribute(model.getId(), instance);
        return instance;
    }

getStorageProviderModel()

static UserStorageProviderModel org.keycloak.storage.UserStorageManager.getStorageProviderModel ( RealmModel  realm, String  componentId  )

inlinestatic

                                                                                                         {
        ComponentModel model = realm.getComponent(componentId);
        if (model == null) return null;
        return new UserStorageProviderModel(model);
    }

getStorageProviders() [1/2]

static List<UserStorageProviderModel> org.keycloak.storage.UserStorageManager.getStorageProviders ( RealmModel  realm )

inlinestatic

                                                                                       {
        return realm.getUserStorageProviders();
    }

getStorageProviders() [2/2]

static <T> List<T> org.keycloak.storage.UserStorageManager.getStorageProviders ( KeycloakSession  session, RealmModel  realm, Class< T >  type  )

inlinestatic

                                                                                                            {
        List<T> list = new LinkedList<>();
        for (UserStorageProviderModel model : getStorageProviders(realm)) {
            UserStorageProviderFactory factory = (UserStorageProviderFactory) session.getKeycloakSessionFactory().getProviderFactory(UserStorageProvider.class, model.getProviderId());
            if (factory == null) {
                logger.warnv("Configured UserStorageProvider {0} of provider id {1} does not exist in realm {2}", model.getName(), model.getProviderId(), realm.getName());
                continue;
            }
            if (Types.supports(type, factory, UserStorageProviderFactory.class)) {
                list.add(type.cast(getStorageProviderInstance(session, model, factory)));
            }


        }
        return list;
    }

getUserByEmail()

UserModel org.keycloak.storage.UserStorageManager.getUserByEmail ( String  email, RealmModel  realm  )

inline

                                                                    {
        UserModel user = localStorage().getUserByEmail(email, realm);
        if (user != null) {
            return importValidation(realm, user);
        }
        for (UserLookupProvider provider : getEnabledStorageProviders(session, realm, UserLookupProvider.class)) {
            user = provider.getUserByEmail(email, realm);
            if (user != null) {
                return user;
            }
        }
        return null;
    }

getUserByFederatedIdentity()

UserModel org.keycloak.storage.UserStorageManager.getUserByFederatedIdentity ( FederatedIdentityModel  socialLink, RealmModel  realm  )

inline

                                                                                                     {
        UserModel user = localStorage().getUserByFederatedIdentity(socialLink, realm);
        if (user != null) {
            return importValidation(realm, user);
        }
        if (getFederatedStorage() == null) return null;
        String id = getFederatedStorage().getUserByFederatedIdentity(socialLink, realm);
        if (id != null) return getUserById(id, realm);
        return null;
    }

getUserById()

UserModel org.keycloak.storage.UserStorageManager.getUserById ( String  id, RealmModel  realm  )

inline

                                                              {
        StorageId storageId = new StorageId(id);
        if (storageId.getProviderId() == null) {
            UserModel user = localStorage().getUserById(id, realm);
            return importValidation(realm, user);
        }
        UserLookupProvider provider = (UserLookupProvider)getStorageProvider(session, realm, storageId.getProviderId());
        if (provider == null) return null;
        if (!isStorageProviderEnabled(realm, storageId.getProviderId())) return null;
        return provider.getUserById(id, realm);
    }

getUserByUsername()

UserModel org.keycloak.storage.UserStorageManager.getUserByUsername ( String  username, RealmModel  realm  )

inline

                                                                          {
        UserModel user = localStorage().getUserByUsername(username, realm);
        if (user != null) {
            return importValidation(realm, user);
        }
        for (UserLookupProvider provider : getEnabledStorageProviders(session, realm, UserLookupProvider.class)) {
            user = provider.getUserByUsername(username, realm);
            if (user != null) return user;
        }
        return null;
    }

getUsers() [1/4]

List<UserModel> org.keycloak.storage.UserStorageManager.getUsers ( RealmModel  realm, boolean  includeServiceAccounts  )

inline

                                                                                      {
        return getUsers(realm, 0, Integer.MAX_VALUE - 1, includeServiceAccounts);

    }

getUsers() [2/4]

List<UserModel> org.keycloak.storage.UserStorageManager.getUsers ( RealmModel  realm )

inline

                                                      {
        return getUsers(realm, false);
    }

getUsers() [3/4]

List<UserModel> org.keycloak.storage.UserStorageManager.getUsers ( RealmModel  realm, int  firstResult, int  maxResults  )

inline

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

getUsers() [4/4]

List<UserModel> org.keycloak.storage.UserStorageManager.getUsers ( final RealmModel  realm, int  firstResult, int  maxResults, final boolean  includeServiceAccounts  )

inline

                                                                                                                                   {
        List<UserModel> results =  query((provider, first, max) -> {
            if (provider instanceof UserProvider) { // it is local storage
                return ((UserProvider) provider).getUsers(realm, first, max, includeServiceAccounts);
            } else if (provider instanceof UserQueryProvider) {
                return ((UserQueryProvider)provider).getUsers(realm, first, max);

            }
            return Collections.EMPTY_LIST;
        }
        , realm, firstResult, maxResults);
        return importValidation(realm, results);
    }

getUsersCount() [1/2]

int org.keycloak.storage.UserStorageManager.getUsersCount ( RealmModel  realm, boolean  includeServiceAccount  )

inline

                                                                              {
        int size = localStorage().getUsersCount(realm, includeServiceAccount);
        for (UserQueryProvider provider : getEnabledStorageProviders(session, realm, UserQueryProvider.class)) {
            size += provider.getUsersCount(realm);
        }
        return size;
    }

getUsersCount() [2/2]

int org.keycloak.storage.UserStorageManager.getUsersCount ( RealmModel  realm )

inline

                                               {
        return getUsersCount(realm, false);
    }

grantToAllUsers()

void org.keycloak.storage.UserStorageManager.grantToAllUsers ( RealmModel  realm, RoleModel  role  )

inline

                                                                  {
        List<UserBulkUpdateProvider> storageProviders = getEnabledStorageProviders(session, realm, UserBulkUpdateProvider.class);
        LinkedList<UserBulkUpdateProvider> providers = new LinkedList<>();
        providers.add(localStorage());
        providers.addAll(storageProviders);
        for (UserBulkUpdateProvider provider : providers) {
            provider.grantToAllUsers(realm, role);
        }
    }

importValidation() [1/2]

UserModel org.keycloak.storage.UserStorageManager.importValidation ( RealmModel  realm, UserModel  user  )

inlineprotected

Allows a UserStorageProvider to proxy and/or synchronize an imported user.

引数

realm
user

戻り値

                                                                           {
        if (user == null || user.getFederationLink() == null) return user;
        UserStorageProvider provider = getStorageProvider(session, realm, user.getFederationLink());
        if (provider != null && provider instanceof ImportedUserValidation) {
            if (!isStorageProviderEnabled(realm, user.getFederationLink())) {
                return new ReadOnlyUserModelDelegate(user) {
                    @Override
                    public boolean isEnabled() {
                        return false;
                    }
                };
            }
            UserModel validated = ((ImportedUserValidation) provider).validate(realm, user);
            if (validated == null) {
                deleteInvalidUser(realm, user);
                return null;
            } else {
                return validated;
            }

        } else if (provider == null) {
            // remove linked user with unknown storage provider.
            logger.debugf("Removed user with federation link of unknown storage provider '%s'", user.getUsername());
            deleteInvalidUser(realm, user);
            return null;
        } else {
            return user;
        }

    }

importValidation() [2/2]

List<UserModel> org.keycloak.storage.UserStorageManager.importValidation ( RealmModel  realm, List< UserModel >  users  )

inlineprotected

                                                                                        {
        List<UserModel> tmp = new LinkedList<>();
        for (UserModel user : users) {
            UserModel model = importValidation(realm, user);
            if (model == null) continue;
            tmp.add(model);
        }
        return tmp;
    }

isStorageProviderEnabled()

static boolean org.keycloak.storage.UserStorageManager.isStorageProviderEnabled ( RealmModel  realm, String  providerId  )

inlinestatic

                                                                                        {
        UserStorageProviderModel model = getStorageProviderModel(realm, providerId);
        return model.isEnabled();
    }

localStorage()

UserProvider org.keycloak.storage.UserStorageManager.localStorage ( )

inlineprotected

                                          {
        return session.userLocalStorage();
    }

onCache()

void org.keycloak.storage.UserStorageManager.onCache ( RealmModel  realm, CachedUserModel  user, UserModel  delegate  )

inline

                                                                                    {
        if (StorageId.isLocalStorage(user)) {
            if (session.userLocalStorage() instanceof OnUserCache) {
                ((OnUserCache)session.userLocalStorage()).onCache(realm, user, delegate);
            }
        } else {
            Object provider = getStorageProvider(session, realm, StorageId.resolveProviderId(user));
            if (provider != null && provider instanceof OnUserCache) {
                ((OnUserCache)provider).onCache(realm, user, delegate);
            }
        }
    }

onCreate()

void org.keycloak.storage.UserStorageManager.onCreate ( KeycloakSession  session, RealmModel  realm, ComponentModel  model  )

inline

                                                                                          {
        ComponentFactory factory = ComponentUtil.getComponentFactory(session, model);
        if (!(factory instanceof UserStorageProviderFactory)) return;
        new UserStorageSyncManager().notifyToRefreshPeriodicSync(session, realm, new UserStorageProviderModel(model), false);

    }

onUpdate()

void org.keycloak.storage.UserStorageManager.onUpdate ( KeycloakSession  session, RealmModel  realm, ComponentModel  oldModel, ComponentModel  newModel  )

inline

                                                                                                                      {
        ComponentFactory factory = ComponentUtil.getComponentFactory(session, newModel);
        if (!(factory instanceof UserStorageProviderFactory)) return;
        UserStorageProviderModel old = new UserStorageProviderModel(oldModel);
        UserStorageProviderModel newP= new UserStorageProviderModel(newModel);
        if (old.getChangedSyncPeriod() != newP.getChangedSyncPeriod() || old.getFullSyncPeriod() != newP.getFullSyncPeriod()
                || old.isImportEnabled() != newP.isImportEnabled()) {
            new UserStorageSyncManager().notifyToRefreshPeriodicSync(session, realm, new UserStorageProviderModel(newModel), false);
        }

    }

preRemove() [1/7]

void org.keycloak.storage.UserStorageManager.preRemove ( RealmModel  realm )

inline

                                            {
        localStorage().preRemove(realm);
        if (getFederatedStorage() != null) {
            getFederatedStorage().preRemove(realm);
            for (UserStorageProvider provider : getEnabledStorageProviders(session, realm, UserStorageProvider.class)) {
                provider.preRemove(realm);
            }
        }
    }

preRemove() [2/7]

void org.keycloak.storage.UserStorageManager.preRemove ( RealmModel  realm, GroupModel  group  )

inline

                                                              {
        localStorage().preRemove(realm, group);
        if (getFederatedStorage() != null) {
            getFederatedStorage().preRemove(realm, group);
            for (UserStorageProvider provider : getEnabledStorageProviders(session, realm, UserStorageProvider.class)) {
                provider.preRemove(realm, group);
            }
        }
    }

preRemove() [3/7]

void org.keycloak.storage.UserStorageManager.preRemove ( RealmModel  realm, RoleModel  role  )

inline

                                                            {
        localStorage().preRemove(realm, role);
        if (getFederatedStorage() != null) {
            getFederatedStorage().preRemove(realm, role);
            for (UserStorageProvider provider : getEnabledStorageProviders(session, realm, UserStorageProvider.class)) {
                provider.preRemove(realm, role);
            }
        }
    }

preRemove() [4/7]

void org.keycloak.storage.UserStorageManager.preRemove ( RealmModel  realm, ClientModel  client  )

inline

                                                                {
        localStorage().preRemove(realm, client);
        if (getFederatedStorage() != null) getFederatedStorage().preRemove(realm, client);

    }

preRemove() [5/7]

void org.keycloak.storage.UserStorageManager.preRemove ( ProtocolMapperModel  protocolMapper )

inline

                                                              {
        localStorage().preRemove(protocolMapper);
        if (getFederatedStorage() != null) getFederatedStorage().preRemove(protocolMapper);
    }

preRemove() [6/7]

void org.keycloak.storage.UserStorageManager.preRemove ( ClientScopeModel  clientScope )

inline

                                                        {
        localStorage().preRemove(clientScope);
        if (getFederatedStorage() != null) getFederatedStorage().preRemove(clientScope);
    }

preRemove() [7/7]

void org.keycloak.storage.UserStorageManager.preRemove ( RealmModel  realm, ComponentModel  component  )

inline

                                                                      {
        if (component.getProviderType().equals(ClientStorageProvider.class.getName())) {
            localStorage().preRemove(realm, component);
            if (getFederatedStorage() != null) getFederatedStorage().preRemove(realm, component);
            return;
        }
        if (!component.getProviderType().equals(UserStorageProvider.class.getName())) return;
        localStorage().preRemove(realm, component);
        if (getFederatedStorage() != null) getFederatedStorage().preRemove(realm, component);
        new UserStorageSyncManager().notifyToRefreshPeriodicSync(session, realm, new UserStorageProviderModel(component), true);

    }

query()

List<UserModel> org.keycloak.storage.UserStorageManager.query ( PaginatedQuery  pagedQuery, RealmModel  realm, int  firstResult, int  maxResults  )

inlineprotected

                                                                                                                  {
        if (maxResults == 0) return Collections.EMPTY_LIST;
        if (firstResult < 0) firstResult = 0;
        if (maxResults < 0) maxResults = Integer.MAX_VALUE - 1;

        List<UserQueryProvider> storageProviders = getEnabledStorageProviders(session, realm, UserQueryProvider.class);
        // we can skip rest of method if there are no storage providers
        if (storageProviders.isEmpty()) {
            return pagedQuery.query(localStorage(), firstResult, maxResults);
        }
        LinkedList<Object> providers = new LinkedList<>();
        List<UserModel> results = new LinkedList<UserModel>();
        providers.add(localStorage());
        providers.addAll(storageProviders);
        if (getFederatedStorage() != null) providers.add(getFederatedStorage());

        int leftToRead = maxResults;
        int leftToFirstResult = firstResult;

        Iterator<Object> it = providers.iterator();
        while (it.hasNext() && leftToRead != 0) {
            Object provider = it.next();
            boolean exhausted = false;
            int index = 0;
            if (leftToFirstResult > 0) {
                do {
                    int toRead = Math.min(50, leftToFirstResult);
                    List<UserModel> tmp = pagedQuery.query(provider, index, toRead);
                    leftToFirstResult -= tmp.size();
                    index += tmp.size();
                    if (tmp.size() < toRead) {
                        exhausted = true;
                        break;
                    }
                } while (leftToFirstResult > 0);
            }
            if (exhausted) continue;
            List<UserModel> tmp = pagedQuery.query(provider, index, leftToRead);
            results.addAll(tmp);
            if (leftToRead > 0) leftToRead -= tmp.size();
        }

        return results;
    }

removeFederatedIdentity()

boolean org.keycloak.storage.UserStorageManager.removeFederatedIdentity ( RealmModel  realm, UserModel  user, String  socialProvider  )

inline

                                                                                                    {
        if (StorageId.isLocalStorage(user)) {
            return localStorage().removeFederatedIdentity(realm, user, socialProvider);
        } else {
            return getFederatedStorage().removeFederatedIdentity(realm, user.getId(), socialProvider);
        }
    }

removeImportedUsers()

void org.keycloak.storage.UserStorageManager.removeImportedUsers ( RealmModel  realm, String  storageProviderId  )

inline

                                                                                {
        localStorage().removeImportedUsers(realm, storageProviderId);
    }

removeUser()

boolean org.keycloak.storage.UserStorageManager.removeUser ( RealmModel  realm, UserModel  user  )

inline

                                                                {
        if (getFederatedStorage() != null) getFederatedStorage().preRemove(realm, user);
        StorageId storageId = new StorageId(user.getId());
        if (storageId.getProviderId() == null) {
            boolean linkRemoved = true;
            if (user.getFederationLink() != null) {
                if (isStorageProviderEnabled(realm, user.getFederationLink())) {
                    UserStorageProvider provider = getStorageProvider(session, realm, user.getFederationLink());
                    if (provider != null && provider instanceof UserRegistrationProvider) {
                        ((UserRegistrationProvider) provider).removeUser(realm, user);
                    }
                } else {
                    linkRemoved = false;
                }
            }
            return localStorage().removeUser(realm, user) && linkRemoved;
        }
        UserRegistrationProvider registry = (UserRegistrationProvider)getStorageProvider(session, realm, storageId.getProviderId());
        if (registry == null) {
            throw new ModelException("Could not resolve StorageProvider: " + storageId.getProviderId());
        }
        return registry.removeUser(realm, user);

    }

revokeConsentForClient()

boolean org.keycloak.storage.UserStorageManager.revokeConsentForClient ( RealmModel  realm, String  userId, String  clientInternalId  )

inline

                                                                                                    {
        if (StorageId.isLocalStorage(userId)) {
            return localStorage().revokeConsentForClient(realm, userId, clientInternalId);
        } else {
            return getFederatedStorage().revokeConsentForClient(realm, userId, clientInternalId);
        }
    }

searchForUser() [1/4]

List<UserModel> org.keycloak.storage.UserStorageManager.searchForUser ( String  search, RealmModel  realm  )

inline

                                                                          {
        return searchForUser(search, realm, 0, Integer.MAX_VALUE - 1);
    }

searchForUser() [2/4]

List<UserModel> org.keycloak.storage.UserStorageManager.searchForUser ( String  search, RealmModel  realm, int  firstResult, int  maxResults  )

inline

                                                                                                           {
        List<UserModel> results = query((provider, first, max) -> {
            if (provider instanceof UserQueryProvider) {
                return ((UserQueryProvider)provider).searchForUser(search, realm, first, max);

            }
            return Collections.EMPTY_LIST;
        }, realm, firstResult, maxResults);
        return importValidation(realm, results);

    }

searchForUser() [3/4]

List<UserModel> org.keycloak.storage.UserStorageManager.searchForUser ( Map< String, String >  attributes, RealmModel  realm  )

inline

                                                                                           {
        List<UserModel> results = searchForUser(attributes, realm, 0, Integer.MAX_VALUE - 1);
        return importValidation(realm, results);
    }

searchForUser() [4/4]

List<UserModel> org.keycloak.storage.UserStorageManager.searchForUser ( Map< String, String >  attributes, RealmModel  realm, int  firstResult, int  maxResults  )

inline

                                                                                                                            {
        List<UserModel> results = query((provider, first, max) -> {
            if (provider instanceof UserQueryProvider) {
                return ((UserQueryProvider)provider).searchForUser(attributes, realm, first, max);

            }
            return Collections.EMPTY_LIST;
        }
        , realm, firstResult, maxResults);
        return importValidation(realm, results);

    }

searchForUserByUserAttribute()

List<UserModel> org.keycloak.storage.UserStorageManager.searchForUserByUserAttribute ( String  attrName, String  attrValue, RealmModel  realm  )

inline

                                                                                                             {
        List<UserModel> results = query((provider, first, max) -> {
            if (provider instanceof UserQueryProvider) {
                return ((UserQueryProvider)provider).searchForUserByUserAttribute(attrName, attrValue, realm);

            } else if (provider instanceof UserFederatedStorageProvider) {
                List<String> ids = ((UserFederatedStorageProvider)provider).getUsersByUserAttribute(realm, attrName, attrValue);
                List<UserModel> rs = new LinkedList<>();
                for (String id : ids) {
                    UserModel user = getUserById(id, realm);
                    if (user != null) rs.add(user);
                }
                return rs;

            }
            return Collections.EMPTY_LIST;
        }, realm,0, Integer.MAX_VALUE - 1);
        return importValidation(realm, results);
    }

setNotBeforeForUser()

void org.keycloak.storage.UserStorageManager.setNotBeforeForUser ( RealmModel  realm, UserModel  user, int  notBefore  )

inline

                                                                                     {
        if (StorageId.isLocalStorage(user)) {
            localStorage().setNotBeforeForUser(realm, user, notBefore);
        } else {
            getFederatedStorage().setNotBeforeForUser(realm, user.getId(), notBefore);
        }
    }

unlinkUsers()

void org.keycloak.storage.UserStorageManager.unlinkUsers ( RealmModel  realm, String  storageProviderId  )

inline

                                                                        {
        localStorage().unlinkUsers(realm, storageProviderId);
    }

updateConsent()

void org.keycloak.storage.UserStorageManager.updateConsent ( RealmModel  realm, String  userId, UserConsentModel  consent  )

inline

                                                                                         {
        if (StorageId.isLocalStorage(userId)) {
            localStorage().updateConsent(realm, userId, consent);
        } else {
            getFederatedStorage().updateConsent(realm, userId, consent);
        }

    }

updateFederatedIdentity()

void org.keycloak.storage.UserStorageManager.updateFederatedIdentity ( RealmModel  realm, UserModel  federatedUser, FederatedIdentityModel  federatedIdentityModel  )

inline

                                                                                                                                  {
        if (StorageId.isLocalStorage(federatedUser)) {
            localStorage().updateFederatedIdentity(realm, federatedUser, federatedIdentityModel);

        } else {
            getFederatedStorage().updateFederatedIdentity(realm, federatedUser.getId(), federatedIdentityModel);
        }
    }

メンバ詳解

logger

final Logger org.keycloak.storage.UserStorageManager.logger = Logger.getLogger(UserStorageManager.class)

staticprivate

session

KeycloakSession org.keycloak.storage.UserStorageManager.session

protected

---

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

• D:/AppData/doxygen/keycloak/rest-service/src/services/src/main/java/org/keycloak/storage/UserStorageManager.java