org.keycloak.models.sessions.infinispan.remotestore.ClientListenerExecutorDecorator< K > クラステンプレート

org.keycloak.models.sessions.infinispan.remotestore.ClientListenerExecutorDecorator< K > 連携図

クラス
class	MyClientEvent
class	MyClientEventContext

公開メンバ関数
	ClientListenerExecutorDecorator (ExecutorService decorated)
void	submit (ClientCacheEntryCreatedEvent< K > cacheEntryCreatedEvent, Runnable r)
void	submit (ClientCacheEntryModifiedEvent< K > cacheEntryModifiedEvent, Runnable r)
void	submit (ClientCacheEntryRemovedEvent< K > cacheEntryRemovedEvent, Runnable r)
MyClientEvent	convertIspnClientEvent (ClientEvent ispnClientEvent)

非公開メンバ関数
void	submit (MyClientEvent event, Runnable r)
void	submitImpl (K key, MyClientEvent event, Runnable r)
void	pollQueue (K key)
void	putEventToTheQueue (K key, MyClientEvent event, Runnable r)

非公開変数類
final Object	lock = new Object()
final ExecutorService	decorated
Map< K, MyClientEvent >	eventsInProgress = new HashMap<>()
MultivaluedHashMap< K, MyClientEventContext >	eventsQueue = new MultivaluedHashMap<>()

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

詳解

著者

Marek Posolda

構築子と解体子

ClientListenerExecutorDecorator()

org.keycloak.models.sessions.infinispan.remotestore.ClientListenerExecutorDecorator< K >.ClientListenerExecutorDecorator ( ExecutorService  decorated )

inline

                                                                      {
        this.decorated = decorated;
    }

関数詳解

convertIspnClientEvent()

MyClientEvent org.keycloak.models.sessions.infinispan.remotestore.ClientListenerExecutorDecorator< K >.convertIspnClientEvent ( ClientEvent  ispnClientEvent )

inline

                                                                             {
        if (ispnClientEvent instanceof ClientCacheEntryCreatedEvent) {
            ClientCacheEntryCreatedEvent<K> ev = (ClientCacheEntryCreatedEvent<K>) ispnClientEvent;
            return new MyClientEvent(ev.getKey(), ev.getVersion(), ev.getType());
        } else if (ispnClientEvent instanceof ClientCacheEntryModifiedEvent) {
            ClientCacheEntryModifiedEvent<K> ev = (ClientCacheEntryModifiedEvent<K>) ispnClientEvent;
            return new MyClientEvent(ev.getKey(), ev.getVersion(), ev.getType());
        } else if (ispnClientEvent instanceof ClientCacheEntryRemovedEvent) {
            ClientCacheEntryRemovedEvent<K> ev = (ClientCacheEntryRemovedEvent<K>) ispnClientEvent;
            return new MyClientEvent(ev.getKey(), -1l, ev.getType());
        } else {
            throw new IllegalStateException("Unsupported event type: " + ispnClientEvent.getType());
        }
    }

pollQueue()

void org.keycloak.models.sessions.infinispan.remotestore.ClientListenerExecutorDecorator< K >.pollQueue ( K  key )

inlineprivate

                                  {
        if (eventsQueue.containsKey(key)) {
            List<MyClientEventContext> events = eventsQueue.get(key);

            if (events.size() > 0) {
                MyClientEventContext nextEvent = events.remove(0);

                // Was last event in the queue for that key
                if (events.size() == 0) {
                    eventsQueue.remove(key);
                }

                submitImpl(key, nextEvent.event, nextEvent.r);

            } else {
                // Shouldn't happen
                throw new IllegalStateException("Illegal state. Size was 0 for key " + key);
            }
        }
    }

putEventToTheQueue()

void org.keycloak.models.sessions.infinispan.remotestore.ClientListenerExecutorDecorator< K >.putEventToTheQueue ( K  key, MyClientEvent  event, Runnable  r  )

inlineprivate

                                                                            {
        logger.debugf("Calling putEventToTheQueue: %s", event.toString());

        if (!eventsQueue.containsKey(key)) {
            eventsQueue.putSingle(key, new MyClientEventContext(event, r));
        } else {

            List<MyClientEventContext> existingEvents = eventsQueue.get(key);
            MyClientEventContext myNewEvent = new MyClientEventContext(event, r);

            // Try to optimize queue (EG. in case we have REMOVE event, we can ignore the previous CREATE or MODIFIED events)
            switch (event.type) {
                case CLIENT_CACHE_ENTRY_CREATED:
                    boolean add = true;
                    for (MyClientEventContext ctx : existingEvents) {
                        if (ctx.event.type == CLIENT_CACHE_ENTRY_REMOVED) {
                            // Ignore. TODO: Log me?
                            add = false;
                            break;
                        } else if (ctx.event.type == CLIENT_CACHE_ENTRY_CREATED) {
                            // Ignore. Already on the list
                            add = false;
                            break;
                        }
                    }

                    // Add to the beginning before the MODIFIED events
                    if (add) {
                        existingEvents.add(0, myNewEvent);
                    }
                    break;
                case CLIENT_CACHE_ENTRY_MODIFIED:

                    boolean addd = true;
                    for (int i=0 ; i<existingEvents.size() ; i++) {
                        MyClientEventContext ctx = existingEvents.get(i);
                        if (ctx.event.type == CLIENT_CACHE_ENTRY_REMOVED) {
                            // Ignore.
                            addd = false;
                            break;
                        } else if (ctx.event.type == CLIENT_CACHE_ENTRY_CREATED) {
                            // Shift to the next element. CREATE event go first.
                        } else {
                            // Can ignore the previous MODIFY event if we have newer version
                            if (ctx.event.version < myNewEvent.event.version) {
                                existingEvents.remove(i);
                            } else {
                                addd = false;
                            }
                        }

                        if (addd) {
                            // Add to the end
                            existingEvents.add(myNewEvent);
                        }
                    }
                    break;

                case CLIENT_CACHE_ENTRY_REMOVED:
                    // Can just ignore the other events in the queue in case of REMOVE
                    eventsQueue.putSingle(key, new MyClientEventContext(event, r));
                    break;
                default:
                    throw new IllegalStateException("Unsupported event type: " + event.type);
            }

        }

        logger.debugf("Event queued. Current events for the key '%s': %s", key.toString(), eventsQueue.getList(key));
    }

submit() [1/4]

void org.keycloak.models.sessions.infinispan.remotestore.ClientListenerExecutorDecorator< K >.submit ( ClientCacheEntryCreatedEvent< K >  cacheEntryCreatedEvent, Runnable  r  )

inline

                                                                                           {
        MyClientEvent event = convertIspnClientEvent(cacheEntryCreatedEvent);
        submit(event, r);
    }

submit() [2/4]

void org.keycloak.models.sessions.infinispan.remotestore.ClientListenerExecutorDecorator< K >.submit ( ClientCacheEntryModifiedEvent< K >  cacheEntryModifiedEvent, Runnable  r  )

inline

                                                                                             {
        MyClientEvent event = convertIspnClientEvent(cacheEntryModifiedEvent);
        submit(event, r);
    }

submit() [3/4]

void org.keycloak.models.sessions.infinispan.remotestore.ClientListenerExecutorDecorator< K >.submit ( ClientCacheEntryRemovedEvent< K >  cacheEntryRemovedEvent, Runnable  r  )

inline

                                                                                           {
        MyClientEvent event = convertIspnClientEvent(cacheEntryRemovedEvent);
        submit(event, r);
    }

submit() [4/4]

void org.keycloak.models.sessions.infinispan.remotestore.ClientListenerExecutorDecorator< K >.submit ( MyClientEvent  event, Runnable  r  )

inlineprivate

                                                         {
        K key = event.key;

        synchronized (lock) {
            if (!eventsInProgress.containsKey(key)) {
                submitImpl(key, event, r);
            } else {
                putEventToTheQueue(key, event, r);
            }
        }
    }

submitImpl()

void org.keycloak.models.sessions.infinispan.remotestore.ClientListenerExecutorDecorator< K >.submitImpl ( K  key, MyClientEvent  event, Runnable  r  )

inlineprivate

                                                                    {
        logger.debugf("Submitting event to the executor: %s . eventsInProgress size: %d, eventsQueue size: %d", event.toString(), eventsInProgress.size(), eventsQueue.size());

        eventsInProgress.put(key, event);

        Runnable decoratedRunnable = () -> {
            Long start = null;
            try {
                if (logger.isDebugEnabled()) {
                    start = Time.currentTimeMillis();
                }

                r.run();
            } finally {
                synchronized (lock) {
                    eventsInProgress.remove(key);

                    if (logger.isDebugEnabled()) {
                        long took = Time.currentTimeMillis() - start;
                        logger.debugf("Finished processing event by the executor: %s, took: %d ms. EventsInProgress size: %d", event.toString(), took, eventsInProgress.size());
                    }

                    pollQueue(key);
                }
            }
        };

        try {
            decorated.submit(decoratedRunnable);
        } catch (RejectedExecutionException ree) {
            eventsInProgress.remove(key);

            logger.errorf("Rejected execution of task for the event '%s' . Try to increase the pool size. Pool is '%s'", event.toString(), decorated.toString());
            throw ree;
        }
    }

メンバ詳解

decorated

final ExecutorService org.keycloak.models.sessions.infinispan.remotestore.ClientListenerExecutorDecorator< K >.decorated

private

eventsInProgress

Map<K, MyClientEvent> org.keycloak.models.sessions.infinispan.remotestore.ClientListenerExecutorDecorator< K >.eventsInProgress = new HashMap<>()

private

eventsQueue

MultivaluedHashMap<K, MyClientEventContext> org.keycloak.models.sessions.infinispan.remotestore.ClientListenerExecutorDecorator< K >.eventsQueue = new MultivaluedHashMap<>()

private

lock

final Object org.keycloak.models.sessions.infinispan.remotestore.ClientListenerExecutorDecorator< K >.lock = new Object()

private

logger

final Logger org.keycloak.models.sessions.infinispan.remotestore.ClientListenerExecutorDecorator< K >.logger = Logger.getLogger(ClientListenerExecutorDecorator.class)

staticprivate

---

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

• D:/AppData/doxygen/keycloak/src/keycloak/src/main/java/org/keycloak/models/sessions/infinispan/remotestore/ClientListenerExecutorDecorator.java