@CacheEntryModified
 public void handleEvent(CacheEntryModifiedEvent<?, ObjectFilter.FilterResult> event) {
   if (!event.isPre()) {
     ObjectFilter.FilterResult filterResult = event.getValue();
     results.add(filterResult);
   }
 }
  @Test
  public void testPrimaryOwnerGoesDownAfterSendingEvent()
      throws InterruptedException, ExecutionException, TimeoutException {
    final Cache<Object, String> cache0 = cache(0, CACHE_NAME);
    Cache<Object, String> cache1 = cache(1, CACHE_NAME);
    Cache<Object, String> cache2 = cache(2, CACHE_NAME);

    ClusterListener clusterListener = listener();
    cache0.addListener(clusterListener);

    CheckPoint checkPoint = new CheckPoint();
    waitUntilNotificationRaised(cache1, checkPoint);
    checkPoint.triggerForever("pre_raise_notification_release");

    final MagicKey key = new MagicKey(cache1, cache2);
    Future<String> future =
        fork(
            new Callable<String>() {
              @Override
              public String call() throws Exception {
                return cache0.put(key, FIRST_VALUE);
              }
            });

    checkPoint.awaitStrict("post_raise_notification_invoked", 10, TimeUnit.SECONDS);

    // Kill the cache now - note this will automatically unblock the fork thread
    TestingUtil.killCacheManagers(cache1.getCacheManager());

    future.get(10, TimeUnit.SECONDS);

    // We should have received 2 events
    assertEquals(clusterListener.events.size(), 2);
    CacheEntryEvent<Object, String> event = clusterListener.events.get(0);
    assertEquals(event.getType(), Event.Type.CACHE_ENTRY_CREATED);
    CacheEntryCreatedEvent<Object, String> createEvent =
        (CacheEntryCreatedEvent<Object, String>) event;
    assertFalse(createEvent.isCommandRetried());
    assertEquals(createEvent.getKey(), key);
    assertEquals(createEvent.getValue(), FIRST_VALUE);

    event = clusterListener.events.get(1);
    // Since it was a retry but the backup got the write the event isn't a CREATE!!
    assertEquals(event.getType(), Event.Type.CACHE_ENTRY_MODIFIED);
    CacheEntryModifiedEvent<Object, String> modEvent =
        (CacheEntryModifiedEvent<Object, String>) event;
    assertTrue(modEvent.isCommandRetried());
    assertEquals(modEvent.getKey(), key);
    assertEquals(modEvent.getValue(), FIRST_VALUE);
  }
 @CacheEntryModified
 public void entryModified(CacheEntryModifiedEvent event) {
   if (!event.isPre()) {
     log.debugf("Entry modified: %s, let's throw an NPE!!", event);
     throw new NullPointerException();
   }
 }
 @CacheEntryModified
 public void entryModified(CacheEntryModifiedEvent event) {
   if (!event.isPre()) {
     lockAcquiredLatch.countDown();
     try {
       waitLatch.await();
     } catch (InterruptedException e) {
       throw new RuntimeException(e);
     }
   }
 }
 @CacheEntryModified
 public void handleEvent(CacheEntryModifiedEvent<?, ObjectFilter.FilterResult> event) {
   ObjectFilter.FilterResult filterResult = event.getValue();
   modifyEvents.add(filterResult);
 }
Exemplo n.º 6
0
 @CacheEntryModified
 public void cacheEntryModified(CacheEntryModifiedEvent<EntryKey, AbstractEntry> e) {
   if (!e.isPre()) Debug.line(e.getKey(), e.getValue());
 }