org.keycloak.services.managers.UserStorageSyncManager クラス

org.keycloak.services.managers.UserStorageSyncManager 連携図

クラス
class	Holder
class	UserStorageClusterListener
class	UserStorageProviderClusterEvent

公開メンバ関数
void	bootstrapPeriodic (final KeycloakSessionFactory sessionFactory, final TimerProvider timer)
SynchronizationResult	syncAllUsers (final KeycloakSessionFactory sessionFactory, final String realmId, final UserStorageProviderModel provider)
SynchronizationResult	syncChangedUsers (final KeycloakSessionFactory sessionFactory, final String realmId, final UserStorageProviderModel provider)
void	notifyToRefreshPeriodicSync (KeycloakSession session, RealmModel realm, UserStorageProviderModel provider, boolean removed)

限定公開メンバ関数
void	refreshPeriodicSyncForProvider (final KeycloakSessionFactory sessionFactory, TimerProvider timer, final UserStorageProviderModel provider, final String realmId)
void	removePeriodicSyncForProvider (TimerProvider timer, UserStorageProviderModel fedProvider)

非公開メンバ関数
boolean	shouldPerformNewPeriodicSync (int lastSyncTime, int period)
void	updateLastSyncInterval (final KeycloakSessionFactory sessionFactory, UserStorageProviderModel provider, final String realmId)

静的非公開変数類
static final String	USER_STORAGE_TASK_KEY = "user-storage"
static final Logger	logger = Logger.getLogger(UserStorageSyncManager.class)

詳解

著者

Marek Posolda

関数詳解

bootstrapPeriodic()

void org.keycloak.services.managers.UserStorageSyncManager.bootstrapPeriodic ( final KeycloakSessionFactory  sessionFactory, final TimerProvider  timer  )

inline

Check federationProviderModel of all realms and possibly start periodic sync for them

引数

sessionFactory
timer

                                                                                                          {
        KeycloakModelUtils.runJobInTransaction(sessionFactory, new KeycloakSessionTask() {

            @Override
            public void run(KeycloakSession session) {
                List<RealmModel> realms = session.realms().getRealms();
                for (final RealmModel realm : realms) {
                    List<UserStorageProviderModel> providers = realm.getUserStorageProviders();
                    for (final UserStorageProviderModel provider : providers) {
                        UserStorageProviderFactory factory = (UserStorageProviderFactory) session.getKeycloakSessionFactory().getProviderFactory(UserStorageProvider.class, provider.getProviderId());
                        if (factory instanceof ImportSynchronization && provider.isImportEnabled()) {
                            refreshPeriodicSyncForProvider(sessionFactory, timer, provider, realm.getId());
                        }
                    }
                }

                ClusterProvider clusterProvider = session.getProvider(ClusterProvider.class);
                clusterProvider.registerListener(USER_STORAGE_TASK_KEY, new UserStorageClusterListener(sessionFactory));
            }
        });
    }

notifyToRefreshPeriodicSync()

void org.keycloak.services.managers.UserStorageSyncManager.notifyToRefreshPeriodicSync ( KeycloakSession  session, RealmModel  realm, UserStorageProviderModel  provider, boolean  removed  )

inline

                                                                                                                                           {
        UserStorageProviderFactory factory = (UserStorageProviderFactory) session.getKeycloakSessionFactory().getProviderFactory(UserStorageProvider.class, provider.getProviderId());
        if (!(factory instanceof ImportSynchronization) || !provider.isImportEnabled()) {
            return;

        }
        UserStorageProviderClusterEvent event = UserStorageProviderClusterEvent.createEvent(removed, realm.getId(), provider);
        session.getProvider(ClusterProvider.class).notify(USER_STORAGE_TASK_KEY, event, false, ClusterProvider.DCNotify.ALL_DCS);
    }

refreshPeriodicSyncForProvider()

void org.keycloak.services.managers.UserStorageSyncManager.refreshPeriodicSyncForProvider ( final KeycloakSessionFactory  sessionFactory, TimerProvider  timer, final UserStorageProviderModel  provider, final String  realmId  )

inlineprotected

                                                                                                                                                                                   {
        logger.debugf("Going to refresh periodic sync for provider '%s' . Full sync period: %d , changed users sync period: %d",
                provider.getName(), provider.getFullSyncPeriod(), provider.getChangedSyncPeriod());

        if (provider.getFullSyncPeriod() > 0) {
            // We want periodic full sync for this provider
            timer.schedule(new Runnable() {

                @Override
                public void run() {
                    try {
                        boolean shouldPerformSync = shouldPerformNewPeriodicSync(provider.getLastSync(), provider.getChangedSyncPeriod());
                        if (shouldPerformSync) {
                            syncAllUsers(sessionFactory, realmId, provider);
                        } else {
                            logger.debugf("Ignored periodic full sync with storage provider %s due small time since last sync", provider.getName());
                        }
                    } catch (Throwable t) {
                        ServicesLogger.LOGGER.errorDuringFullUserSync(t);
                    }
                }

            }, provider.getFullSyncPeriod() * 1000, provider.getId() + "-FULL");
        } else {
            timer.cancelTask(provider.getId() + "-FULL");
        }

        if (provider.getChangedSyncPeriod() > 0) {
            // We want periodic sync of just changed users for this provider
            timer.schedule(new Runnable() {

                @Override
                public void run() {
                    try {
                        boolean shouldPerformSync = shouldPerformNewPeriodicSync(provider.getLastSync(), provider.getChangedSyncPeriod());
                        if (shouldPerformSync) {
                            syncChangedUsers(sessionFactory, realmId, provider);
                        } else {
                            logger.debugf("Ignored periodic changed-users sync with storage provider %s due small time since last sync", provider.getName());
                        }
                    } catch (Throwable t) {
                        ServicesLogger.LOGGER.errorDuringChangedUserSync(t);
                    }
                }

            }, provider.getChangedSyncPeriod() * 1000, provider.getId() + "-CHANGED");

        } else {
            timer.cancelTask(provider.getId() + "-CHANGED");
        }
    }

removePeriodicSyncForProvider()

void org.keycloak.services.managers.UserStorageSyncManager.removePeriodicSyncForProvider ( TimerProvider  timer, UserStorageProviderModel  fedProvider  )

inlineprotected

                                                                                                            {
        logger.debugf("Removing periodic sync for provider %s", fedProvider.getName());
        timer.cancelTask(fedProvider.getId() + "-FULL");
        timer.cancelTask(fedProvider.getId() + "-CHANGED");
    }

shouldPerformNewPeriodicSync()

boolean org.keycloak.services.managers.UserStorageSyncManager.shouldPerformNewPeriodicSync ( int  lastSyncTime, int  period  )

inlineprivate

                                                                               {
        if (lastSyncTime <= 0) {
            return true;
        }

        int currentTime = Time.currentTime();
        int timeSinceLastSync = currentTime - lastSyncTime;

        return (timeSinceLastSync * 2 > period);
    }

syncAllUsers()

SynchronizationResult org.keycloak.services.managers.UserStorageSyncManager.syncAllUsers ( final KeycloakSessionFactory  sessionFactory, final String  realmId, final UserStorageProviderModel  provider  )

inline

                                                                                                                                                          {
        UserStorageProviderFactory factory = (UserStorageProviderFactory) sessionFactory.getProviderFactory(UserStorageProvider.class, provider.getProviderId());
        if (!(factory instanceof ImportSynchronization) || !provider.isImportEnabled() || !provider.isEnabled()) {
            return SynchronizationResult.ignored();

        }

        final Holder holder = new Holder();

        // Ensure not executed concurrently on this or any other cluster node
        KeycloakModelUtils.runJobInTransaction(sessionFactory, new KeycloakSessionTask() {

            @Override
            public void run(KeycloakSession session) {
                ClusterProvider clusterProvider = session.getProvider(ClusterProvider.class);
                // shared key for "full" and "changed" . Improve if needed
                String taskKey = provider.getId() + "::sync";

                // 30 seconds minimal timeout for now
                int timeout = Math.max(30, provider.getFullSyncPeriod());
                holder.result = clusterProvider.executeIfNotExecuted(taskKey, timeout, new Callable<SynchronizationResult>() {

                    @Override
                    public SynchronizationResult call() throws Exception {
                        updateLastSyncInterval(sessionFactory, provider, realmId);
                        return ((ImportSynchronization)factory).sync(sessionFactory, realmId, provider);
                    }

                });
            }

        });

        if (holder.result == null || !holder.result.isExecuted()) {
            logger.debugf("syncAllUsers for federation provider %s was ignored as it's already in progress", provider.getName());
            return SynchronizationResult.ignored();
        } else {
            return holder.result.getResult();
        }
    }

syncChangedUsers()

SynchronizationResult org.keycloak.services.managers.UserStorageSyncManager.syncChangedUsers ( final KeycloakSessionFactory  sessionFactory, final String  realmId, final UserStorageProviderModel  provider  )

inline

                                                                                                                                                              {
        UserStorageProviderFactory factory = (UserStorageProviderFactory) sessionFactory.getProviderFactory(UserStorageProvider.class, provider.getProviderId());
        if (!(factory instanceof ImportSynchronization) || !provider.isImportEnabled() || !provider.isEnabled()) {
            return SynchronizationResult.ignored();

        }
        final Holder holder = new Holder();

        // Ensure not executed concurrently on this or any other cluster node
        KeycloakModelUtils.runJobInTransaction(sessionFactory, new KeycloakSessionTask() {

            @Override
            public void run(KeycloakSession session) {
                ClusterProvider clusterProvider = session.getProvider(ClusterProvider.class);
                // shared key for "full" and "changed" . Improve if needed
                String taskKey = provider.getId() + "::sync";

                // 30 seconds minimal timeout for now
                int timeout = Math.max(30, provider.getChangedSyncPeriod());
                holder.result = clusterProvider.executeIfNotExecuted(taskKey, timeout, new Callable<SynchronizationResult>() {

                    @Override
                    public SynchronizationResult call() throws Exception {
                        // See when we did last sync.
                        int oldLastSync = provider.getLastSync();
                        updateLastSyncInterval(sessionFactory, provider, realmId);
                        return ((ImportSynchronization)factory).syncSince(Time.toDate(oldLastSync), sessionFactory, realmId, provider);
                    }

                });
            }

        });

        if (holder.result == null || !holder.result.isExecuted()) {
            logger.debugf("syncChangedUsers for federation provider %s was ignored as it's already in progress", provider.getName());
            return SynchronizationResult.ignored();
        } else {
            return holder.result.getResult();
        }
    }

updateLastSyncInterval()

void org.keycloak.services.managers.UserStorageSyncManager.updateLastSyncInterval ( final KeycloakSessionFactory  sessionFactory, UserStorageProviderModel  provider, final String  realmId  )

inlineprivate

                                                                                                                                              {
        KeycloakModelUtils.runJobInTransaction(sessionFactory, new KeycloakSessionTask() {

            @Override
            public void run(KeycloakSession session) {
                RealmModel persistentRealm = session.realms().getRealm(realmId);
                List<UserStorageProviderModel> persistentFedProviders = persistentRealm.getUserStorageProviders();
                for (UserStorageProviderModel persistentFedProvider : persistentFedProviders) {
                    if (provider.getId().equals(persistentFedProvider.getId())) {
                        // Update persistent provider in DB
                        int lastSync = Time.currentTime();
                        persistentFedProvider.setLastSync(lastSync);
                        persistentRealm.updateComponent(persistentFedProvider);

                        // Update "cached" reference
                        provider.setLastSync(lastSync);
                    }
                }
            }

        });
    }

メンバ詳解

logger

final Logger org.keycloak.services.managers.UserStorageSyncManager.logger = Logger.getLogger(UserStorageSyncManager.class)

staticprivate

USER_STORAGE_TASK_KEY

final String org.keycloak.services.managers.UserStorageSyncManager.USER_STORAGE_TASK_KEY = "user-storage"

staticprivate

---

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

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