How to use org.keycloak.models.sessions.infinispan.initializer

@Override
protected boolean isFinished() {
  // Check if we should skipLoadingSessions. This can happen if someone else already did the task (For example in cross-dc environment, it was done by different DC)
  boolean isFinishedAlready = this.sessionLoader.isFinished(this);
  if (isFinishedAlready) {
    return true;
  }
  InitializerState state = getStateFromCache();
  return state != null && state.isFinished();
}

private void saveStateToCache(final InitializerState state) {
  // 3 attempts to send the message (it may fail if some node fails in the meantime)
  retry(3, new Runnable() {
    @Override
    public void run() {
      // Save this synchronously to ensure all nodes read correct state
      InfinispanUserSessionInitializer.this.cache.getAdvancedCache().
          withFlags(Flag.IGNORE_RETURN_VALUES, Flag.FORCE_SYNCHRONOUS)
          .put(stateKey, state);
    }
  });
}

public static WorkerResult create (Integer segment, boolean success) {
  WorkerResult res = new WorkerResult();
  res.setSegment(segment);
  res.setSuccess(success);
  return res;
}

@Override
public void run(KeycloakSession session) {
  InfinispanConnectionProvider connections = session.getProvider(InfinispanConnectionProvider.class);
  Cache<String, Serializable> workCache = connections.getCache(InfinispanConnectionProvider.WORK_CACHE_NAME);
  InfinispanCacheInitializer ispnInitializer = new InfinispanCacheInitializer(sessionFactory, workCache,
      new OfflinePersistentUserSessionLoader(sessionsPerSegment), "offlineUserSessions", sessionsPerSegment, maxErrors);
  // DB-lock to ensure that persistent sessions are loaded from DB just on one DC. The other DCs will load them from remote cache.
  CacheInitializer initializer = new DBLockBasedCacheInitializer(session, ispnInitializer);
  initializer.initCache();
  initializer.loadSessions();
  // Initialize persister for periodically doing bulk DB updates of lastSessionRefresh timestamps of refreshed sessions
  persisterLastSessionRefreshStore = new PersisterLastSessionRefreshStoreFactory().createAndInit(session, true);
}

@Override
public void run(KeycloakSession session) {
  InfinispanConnectionProvider connections = session.getProvider(InfinispanConnectionProvider.class);
  Cache<String, SessionEntity> cache = connections.getCache(InfinispanConnectionProvider.OFFLINE_SESSION_CACHE_NAME);
  InfinispanUserSessionInitializer initializer = new InfinispanUserSessionInitializer(sessionFactory, cache, new OfflineUserSessionLoader(), maxErrors, sessionsPerSegment, "offlineUserSessions");
  initializer.initCache();
  initializer.loadPersistentSessions();
}

@Override
public WorkerResult createFailedWorkerResult(RemoteCacheSessionsLoaderContext loaderContext, WorkerContext workerContext) {
  return new WorkerResult(false, workerContext.getSegment(), workerContext.getWorkerId());
}

@Override
public OfflinePersistentWorkerResult createFailedWorkerResult(OfflinePersistentLoaderContext loaderContext, OfflinePersistentWorkerContext workerContext) {
  return new OfflinePersistentWorkerResult(false, workerContext.getSegment(), workerContext.getWorkerId(), -1, FIRST_SESSION_ID);
}

@Override
public void run(KeycloakSession session) {
  int count = sessionLoader.getSessionsCount(session);
  for (int i=0 ; i<count ; i+=sessionsPerSegment) {
    sessionLoader.loadSessions(session, i, sessionsPerSegment);
  }
}

@Override
public void run(KeycloakSession session) {
  sessionLoader.loadSessions(session, first, max);
}

@Override
public void run(KeycloakSession session) {
  sessionLoader.init(session);
}

private void updateLowestUnfinishedSegment() {
  this.lowestUnfinishedSegment = getNextUnfinishedSegmentFromIndex(lowestUnfinishedSegment);
}

protected void saveStateToCache(final InitializerState state) {
  // 3 attempts to send the message (it may fail if some node fails in the meantime)
  retry(3, new Runnable() {
    @Override
    public void run() {
      // Save this synchronously to ensure all nodes read correct state
      // We ignore cacheStore for now, so that in Cross-DC scenario (with RemoteStore enabled) is the remoteStore ignored.
      BaseCacheInitializer.this.workCache.getAdvancedCache().
          withFlags(Flag.IGNORE_RETURN_VALUES, Flag.FORCE_SYNCHRONOUS, Flag.SKIP_CACHE_STORE, Flag.SKIP_CACHE_LOAD)
          .put(stateKey, state);
    }
  });
}

@Override
public void run(KeycloakSession session) {
  count[0] = sessionLoader.getSessionsCount(session);
}

@Override
protected boolean isCoordinator() {
  return delegate.isCoordinator();
}

@Override
public WorkerContext computeWorkerContext(RemoteCacheSessionsLoaderContext loaderCtx, int segment, int workerId, List<WorkerResult> previousResults) {
  return new WorkerContext(segment, workerId);
}

public OfflinePersistentLoaderContext(int sessionsTotal, int sessionsPerSegment) {
  super(computeSegmentsCount(sessionsTotal, sessionsPerSegment));
  this.sessionsTotal = sessionsTotal;
  this.sessionsPerSegment = sessionsPerSegment;
}

@Override
public void run(KeycloakSession session) {
  ctx[0] = sessionLoader.computeLoaderContext(session);
}

@Override
protected boolean isFinished() {
  return delegate.isFinished();
}

@Override
public void run(KeycloakSession session) {
  ref[0] = sessionLoader.loadSessions(session, loaderCtx, workerCtx);
}

@Override
public void run(KeycloakSession session) {
  sessionLoader.init(session);
}