コード例 #1
0
 private void publishWithValue(
     Set<EventRegistration> registrationsWithValue, EntryEventData event, int orderKey) {
   final NodeEngine nodeEngine = mapServiceContext.getNodeEngine();
   nodeEngine
       .getEventService()
       .publishEvent(mapServiceContext.serviceName(), registrationsWithValue, event, orderKey);
 }
コード例 #2
0
 private void flushInvalidationMessages(
     String cacheName, InvalidationEventQueue invalidationMessageQueue) {
   // If still in progress, no need to another attempt. So just ignore.
   if (invalidationMessageQueue.tryAcquire()) {
     try {
       CacheBatchInvalidationMessage batchInvalidationMessage =
           new CacheBatchInvalidationMessage(cacheName, invalidationMessageQueue.size());
       CacheSingleInvalidationMessage invalidationMessage;
       final int size = invalidationMessageQueue.size();
       // At most, poll from the invalidation queue as the current size of the queue before start
       // to polling.
       // So skip new invalidation queue items offered while the polling in progress in this round.
       for (int i = 0; i < size; i++) {
         invalidationMessage = invalidationMessageQueue.poll();
         if (invalidationMessage == null) {
           break;
         }
         batchInvalidationMessage.addInvalidationMessage(invalidationMessage);
       }
       EventService eventService = nodeEngine.getEventService();
       Collection<EventRegistration> registrations =
           eventService.getRegistrations(ICacheService.SERVICE_NAME, cacheName);
       if (!registrations.isEmpty()) {
         eventService.publishEvent(
             ICacheService.SERVICE_NAME,
             registrations,
             batchInvalidationMessage,
             cacheName.hashCode());
       }
     } finally {
       invalidationMessageQueue.release();
     }
   }
 }
コード例 #3
0
 public void publishMapEvent(
     Address caller, String mapName, EntryEventType eventType, int numberOfEntriesAffected) {
   final NodeEngine nodeEngine = mapServiceContext.getNodeEngine();
   final Collection<EventRegistration> registrations =
       nodeEngine.getEventService().getRegistrations(mapServiceContext.serviceName(), mapName);
   if (registrations.isEmpty()) {
     return;
   }
   final String source = nodeEngine.getThisAddress().toString();
   final MapEventData mapEventData =
       new MapEventData(source, mapName, caller, eventType.getType(), numberOfEntriesAffected);
   nodeEngine
       .getEventService()
       .publishEvent(
           mapServiceContext.serviceName(), registrations, mapEventData, mapName.hashCode());
 }
コード例 #4
0
  Collection<EventRegistration> getRegistrations(String mapName) {
    final MapServiceContext mapServiceContext = this.mapServiceContext;
    final NodeEngine nodeEngine = mapServiceContext.getNodeEngine();
    final EventService eventService = nodeEngine.getEventService();

    return eventService.getRegistrations(SERVICE_NAME, mapName);
  }
コード例 #5
0
  /**
   * - Sends eviction event. - Invalidates near cache.
   *
   * @param key the key to be processed.
   * @param value the value to be processed.
   */
  @Override
  public void doPostEvictionOperations(Data key, Object value, boolean isExpired) {
    MapEventPublisher mapEventPublisher = mapServiceContext.getMapEventPublisher();
    NodeEngine nodeEngine = mapServiceContext.getNodeEngine();
    EventService eventService = nodeEngine.getEventService();

    if (!eventService.hasEventRegistration(SERVICE_NAME, name)) {
      return;
    }

    Address thisAddress = nodeEngine.getThisAddress();

    // Fire EVICTED event also in case of expiration because historically eviction-listener
    // listens all kind of eviction and expiration events and by firing EVICTED event we are
    // preserving
    // this behavior.
    mapEventPublisher.publishEvent(thisAddress, name, EVICTED, key, value, null);

    if (isExpired) {
      // We will be in this if in two cases:
      // 1. In case of TTL or max-idle-seconds expiration.
      // 2. When evicting due to the size-based eviction, we are also firing an EXPIRED event
      //    because there is a possibility that evicted entry may be also an expired one. Trying to
      // catch
      //    as much as possible expired entries.
      mapEventPublisher.publishEvent(thisAddress, name, EXPIRED, key, value, null);
    }
  }
コード例 #6
0
 public void destroyDistributedObject(String name) {
   for (MultiMapPartitionContainer container : partitionContainers) {
     if (container != null) {
       container.destroyCollection(name);
     }
   }
   nodeEngine.getEventService().deregisterAllListeners(SERVICE_NAME, name);
 }
コード例 #7
0
  void publishEventInternal(
      Collection<EventRegistration> registrations, Object eventData, int orderKey) {
    final MapServiceContext mapServiceContext = this.mapServiceContext;
    final NodeEngine nodeEngine = mapServiceContext.getNodeEngine();
    final EventService eventService = nodeEngine.getEventService();

    eventService.publishEvent(SERVICE_NAME, registrations, eventData, orderKey);
  }
コード例 #8
0
ファイル: MapService.java プロジェクト: rocio/hazelcast
 public String addEventListener(
     EntryListener entryListener, EventFilter eventFilter, String mapName) {
   EventRegistration registration =
       nodeEngine
           .getEventService()
           .registerListener(SERVICE_NAME, mapName, eventFilter, entryListener);
   return registration.getId();
 }
コード例 #9
0
 void publishEvent(String cacheName, CacheEventSet eventSet, int orderKey) {
   final EventService eventService = nodeEngine.getEventService();
   final Collection<EventRegistration> candidates =
       eventService.getRegistrations(ICacheService.SERVICE_NAME, cacheName);
   if (candidates.isEmpty()) {
     return;
   }
   eventService.publishEvent(ICacheService.SERVICE_NAME, candidates, eventSet, orderKey);
 }
コード例 #10
0
  void publishEvent(CacheEventContext cacheEventContext) {
    final EventService eventService = nodeEngine.getEventService();
    final String cacheName = cacheEventContext.getCacheName();
    final Collection<EventRegistration> candidates =
        eventService.getRegistrations(ICacheService.SERVICE_NAME, cacheName);

    if (candidates.isEmpty()) {
      return;
    }
    final Object eventData;
    final CacheEventType eventType = cacheEventContext.getEventType();
    switch (eventType) {
      case CREATED:
      case UPDATED:
      case REMOVED:
      case EXPIRED:
        final CacheEventData cacheEventData =
            new CacheEventDataImpl(
                cacheName,
                eventType,
                cacheEventContext.getDataKey(),
                cacheEventContext.getDataValue(),
                cacheEventContext.getDataOldValue(),
                cacheEventContext.isOldValueAvailable());
        CacheEventSet eventSet = new CacheEventSet(eventType, cacheEventContext.getCompletionId());
        eventSet.addEventData(cacheEventData);
        eventData = eventSet;
        break;
      case EVICTED:
      case INVALIDATED:
        eventData =
            new CacheEventDataImpl(
                cacheName, eventType, cacheEventContext.getDataKey(), null, null, false);
        break;
      case COMPLETED:
        CacheEventData completedEventData =
            new CacheEventDataImpl(
                cacheName,
                eventType,
                cacheEventContext.getDataKey(),
                cacheEventContext.getDataValue(),
                null,
                false);
        eventSet = new CacheEventSet(eventType, cacheEventContext.getCompletionId());
        eventSet.addEventData(completedEventData);
        eventData = eventSet;
        break;
      default:
        throw new IllegalArgumentException(
            "Event Type not defined to create an eventData during publish : " + eventType.name());
    }
    eventService.publishEvent(
        ICacheService.SERVICE_NAME, candidates, eventData, cacheEventContext.getOrderKey());
  }
コード例 #11
0
 public String addListener(
     String name, EventListener listener, Data key, boolean includeValue, boolean local) {
   EventService eventService = nodeEngine.getEventService();
   EventRegistration registration;
   final MultiMapEventFilter filter = new MultiMapEventFilter(includeValue, key);
   if (local) {
     registration = eventService.registerLocalListener(SERVICE_NAME, name, filter, listener);
   } else {
     registration = eventService.registerListener(SERVICE_NAME, name, filter, listener);
   }
   return registration.getId();
 }
コード例 #12
0
 private void sendSingleInvalidationEvent(String name, Data key, String sourceUuid) {
   EventService eventService = nodeEngine.getEventService();
   Collection<EventRegistration> registrations =
       eventService.getRegistrations(ICacheService.SERVICE_NAME, name);
   if (!registrations.isEmpty()) {
     eventService.publishEvent(
         ICacheService.SERVICE_NAME,
         registrations,
         new CacheSingleInvalidationMessage(name, key, sourceUuid),
         name.hashCode());
   }
 }
コード例 #13
0
 public void fireMapClearedEvent(int deletedEntrySize, String name) {
   EventService eventService = nodeEngine.getEventService();
   Collection<EventRegistration> registrations = eventService.getRegistrations(SERVICE_NAME, name);
   if (registrations.isEmpty()) {
     return;
   }
   MapEventData mapEventData =
       new MapEventData(
           name,
           name,
           nodeEngine.getThisAddress(),
           EntryEventType.CLEAR_ALL.getType(),
           deletedEntrySize);
   eventService.publishEvent(SERVICE_NAME, registrations, mapEventData, name.hashCode());
 }
コード例 #14
0
ファイル: MapService.java プロジェクト: rocio/hazelcast
 public void destroyDistributedObject(String name) {
   MapContainer mapContainer = mapContainers.remove(name);
   if (mapContainer != null) {
     if (mapContainer.isNearCacheEnabled()) {
       NearCache nearCache = nearCacheMap.remove(name);
       if (nearCache != null) {
         nearCache.clear();
       }
     }
     mapContainer.shutDownMapStoreScheduledExecutor();
   }
   final PartitionContainer[] containers = partitionContainers;
   for (PartitionContainer container : containers) {
     if (container != null) {
       container.destroyMap(name);
     }
   }
   nodeEngine.getEventService().deregisterAllListeners(SERVICE_NAME, name);
 }
コード例 #15
0
 private void sendBatchInvalidationEvent(String name, Data key, String sourceUuid) {
   EventService eventService = nodeEngine.getEventService();
   Collection<EventRegistration> registrations =
       eventService.getRegistrations(ICacheService.SERVICE_NAME, name);
   if (registrations.isEmpty()) {
     return;
   }
   InvalidationEventQueue invalidationMessageQueue = invalidationMessageMap.get(name);
   if (invalidationMessageQueue == null) {
     InvalidationEventQueue newInvalidationMessageQueue = new InvalidationEventQueue();
     invalidationMessageQueue =
         invalidationMessageMap.putIfAbsent(name, newInvalidationMessageQueue);
     if (invalidationMessageQueue == null) {
       invalidationMessageQueue = newInvalidationMessageQueue;
     }
   }
   CacheSingleInvalidationMessage invalidationMessage =
       new CacheSingleInvalidationMessage(name, key, sourceUuid);
   invalidationMessageQueue.offer(invalidationMessage);
   if (invalidationMessageQueue.size() >= invalidationMessageBatchSize) {
     flushInvalidationMessages(name, invalidationMessageQueue);
   }
 }
コード例 #16
0
 public ReplicatedMapEventPublishingService(ReplicatedMapService replicatedMapService) {
   this.replicatedMapService = replicatedMapService;
   this.nodeEngine = replicatedMapService.getNodeEngine();
   this.config = nodeEngine.getConfig();
   this.eventService = nodeEngine.getEventService();
 }
コード例 #17
0
ファイル: MapService.java プロジェクト: rocio/hazelcast
 public boolean removeEventListener(String mapName, String registrationId) {
   return nodeEngine.getEventService().deregisterListener(SERVICE_NAME, mapName, registrationId);
 }
コード例 #18
0
 private Collection<EventRegistration> getCandidates(String mapName) {
   final NodeEngine nodeEngine = mapServiceContext.getNodeEngine();
   return nodeEngine.getEventService().getRegistrations(mapServiceContext.serviceName(), mapName);
 }
コード例 #19
0
 public boolean removeListener(String name, String registrationId) {
   EventService eventService = nodeEngine.getEventService();
   return eventService.deregisterListener(SERVICE_NAME, name, registrationId);
 }
コード例 #20
0
ファイル: MapService.java プロジェクト: rocio/hazelcast
 public void publishEvent(
     Address caller,
     String mapName,
     EntryEventType eventType,
     Data dataKey,
     Data dataOldValue,
     Data dataValue) {
   Collection<EventRegistration> candidates =
       nodeEngine.getEventService().getRegistrations(SERVICE_NAME, mapName);
   Set<EventRegistration> registrationsWithValue = new HashSet<EventRegistration>();
   Set<EventRegistration> registrationsWithoutValue = new HashSet<EventRegistration>();
   if (candidates.isEmpty()) return;
   Object key = null;
   Object value = null;
   Object oldValue = null;
   for (EventRegistration candidate : candidates) {
     EventFilter filter = candidate.getFilter();
     if (filter instanceof EventServiceImpl.EmptyFilter) {
       registrationsWithValue.add(candidate);
     } else if (filter instanceof QueryEventFilter) {
       Object testValue;
       if (eventType == EntryEventType.REMOVED || eventType == EntryEventType.EVICTED) {
         oldValue = oldValue != null ? oldValue : toObject(dataOldValue);
         testValue = oldValue;
       } else {
         value = value != null ? value : toObject(dataValue);
         testValue = value;
       }
       key = key != null ? key : toObject(dataKey);
       QueryEventFilter queryEventFilter = (QueryEventFilter) filter;
       QueryEntry entry = new QueryEntry(getSerializationService(), dataKey, key, testValue);
       if (queryEventFilter.eval(entry)) {
         if (queryEventFilter.isIncludeValue()) {
           registrationsWithValue.add(candidate);
         } else {
           registrationsWithoutValue.add(candidate);
         }
       }
     } else if (filter.eval(dataKey)) {
       EntryEventFilter eventFilter = (EntryEventFilter) filter;
       if (eventFilter.isIncludeValue()) {
         registrationsWithValue.add(candidate);
       } else {
         registrationsWithoutValue.add(candidate);
       }
     }
   }
   if (registrationsWithValue.isEmpty() && registrationsWithoutValue.isEmpty()) return;
   String source = nodeEngine.getThisAddress().toString();
   if (eventType == EntryEventType.REMOVED || eventType == EntryEventType.EVICTED) {
     dataValue = dataValue != null ? dataValue : dataOldValue;
   }
   EventData event =
       new EventData(
           source, mapName, caller, dataKey, dataValue, dataOldValue, eventType.getType());
   int orderKey = dataKey.hashCode();
   nodeEngine
       .getEventService()
       .publishEvent(SERVICE_NAME, registrationsWithValue, event, orderKey);
   nodeEngine
       .getEventService()
       .publishEvent(
           SERVICE_NAME, registrationsWithoutValue, event.cloneWithoutValues(), orderKey);
 }