Examples of org.infinispan.test.fwk.CheckPoint

org.infinispan.test.fwk.CheckPoint
Behaves more or less like a map of {@link java.util.concurrent.Semaphore}s. One thread will wait for an event via {@code await(...)} or {@code awaitStrict(...)}, and one or more other threads will trigger the event via {@code trigger(...)} or {@code triggerForever(...)}. @author Dan Berindei @since 5.3

      assertEquals(cache2.getAdvancedCache().getListeners().size(), initialCache2ListenerSize + 1);


      // Make sure cache0 will  be the one will get the cluster listener request
      assertEquals(manager(0).getAddress(), manager(0).getMembers().get(0));


      CheckPoint checkPoint = new CheckPoint();


      waitUntilRequestingListeners(cache0, checkPoint);
      checkPoint.triggerForever("post_cluster_listeners_release_" + cache0);
      waitUntilViewChangeOccurs(manager(1), "manager1", checkPoint);


      // We let the first view change occur just fine on cache1 (this will be the addition of cache3).
      // What we want to block is the second one which is the removal of cache0
      checkPoint.trigger("pre_view_listener_release_" + "manager1");


      // First we add the new node, but block the dist exec execution
      log.info("Adding a new node ..");
      addClusterEnabledCacheManager(builderUsed);
      log.info("Added a new node");


      waitUntilViewChangeOccurs(manager(3), "manager3", checkPoint);
      // We don't want to block the view listener change on cache3
      checkPoint.trigger("pre_view_listener_release_" + "manager3");


      Future<Cache<Object, String>> future = fork(new Callable<Cache<Object, String>>() {
         @Override
         public Cache<Object, String> call() throws Exception {
            return cache(3, CACHE_NAME);
         }
      });


      // Wait for view change to occur on cache1 for the addition of cache3
      // Note we haven't triggered the view change for cache1 for the following removal yet
      checkPoint.awaitStrict("post_view_listener_invoked_" + "manager1", 10, TimeUnit.SECONDS);
      // Wait for the cluster listener request to come into cache0 which is from cache3
      checkPoint.awaitStrict("pre_cluster_listeners_invoked_" + cache0, 10, TimeUnit.SECONDS);


      // Now we kill cache0 while it is processing the request from cache3, which will in turn force it to ask cache1
      log.info("Killing node 0 ..");
      TestingUtil.killCacheManagers(manager(0));
      cacheManagers.remove(0);
      log.info("Node 0 killed");


      // TODO: need a away to verify that the response was sent back to cache3 before releasing the next line.  However
      // with no reference to cache I don't think this is possible.  If this can be fixed then test can be reenabled
      Cache<Object, String> cache3 = future.get(10, TimeUnit.SECONDS);


      // Now we can finally let the view change complete on cache1
      checkPoint.triggerForever("pre_view_listener_release_" + "manager1");


      // Now wait for cache3 to come up fully
      TestingUtil.blockUntilViewsReceived(60000, false, cache1, cache2);
      TestingUtil.waitForRehashToComplete(cache1, cache2);

View Full Code Here

   public void testMemberJoinsWhileClusterListenerInstalled() throws TimeoutException, InterruptedException,
                                                                     ExecutionException {
      Cache<Object, String> cache0 = cache(0, CACHE_NAME);
      final Cache<Object, String> cache1 = cache(1, CACHE_NAME);


      CheckPoint checkPoint = new CheckPoint();
      waitUntilListenerInstalled(cache0, checkPoint);
      // We don't want this blocking
      checkPoint.triggerForever("post_add_listener_release_" + cache0);


      final ClusterListener clusterListener = new ClusterListener();
      Future<Void> future = fork(new Callable<Void>() {


         @Override
         public Void call() throws Exception {


            cache1.addListener(clusterListener);
            return null;
         }
      });


      // Now wait until the listener is about to be installed on cache1
      checkPoint.awaitStrict("pre_add_listener_invoked_" + cache0, 10, TimeUnit.SECONDS);


      // First we add the new node, but block the dist exec execution
      log.info("Adding a new node ..");
      addClusterEnabledCacheManager(builderUsed);
      log.info("Added a new node");


      // Now wait for cache3 to come up fully
      waitForClusterToForm(CACHE_NAME);


      Cache<Object, String> cache3 = cache(3, CACHE_NAME);


      // Finally let the listener be added
      checkPoint.triggerForever("pre_add_listener_release_" + cache0);
      future.get(10, TimeUnit.SECONDS);


      MagicKey key = new MagicKey(cache3);
      verifySimpleInsertion(cache3, key, FIRST_VALUE, null, clusterListener, FIRST_VALUE);
   }

View Full Code Here

   public void testMemberJoinsWhileClusterListenerInstalledDuplicate() throws TimeoutException, InterruptedException,
                                                                     ExecutionException {
      Cache<Object, String> cache0 = cache(0, CACHE_NAME);
      final Cache<Object, String> cache1 = cache(1, CACHE_NAME);


      CheckPoint checkPoint = new CheckPoint();
      waitUntilListenerInstalled(cache0, checkPoint);
      // We want the listener to be able to be added
      checkPoint.triggerForever("pre_add_listener_release_" + cache0);


      final ClusterListener clusterListener = new ClusterListener();
      Future<Void> future = fork(new Callable<Void>() {


         @Override
         public Void call() throws Exception {


            cache1.addListener(clusterListener);
            return null;
         }
      });


      // Now wait until the listener is about to be installed on cache1
      checkPoint.awaitStrict("post_add_listener_invoked_" + cache0, 10, TimeUnit.SECONDS);


      // First we add the new node, but block the dist exec execution
      log.info("Adding a new node ..");
      addClusterEnabledCacheManager(builderUsed);
      log.info("Added a new node");


      // Now wait for cache3 to come up fully
      waitForClusterToForm(CACHE_NAME);


      Cache<Object, String> cache3 = cache(3, CACHE_NAME);


      // Finally let the listener be added
      checkPoint.triggerForever("post_add_listener_release_" + cache0);
      future.get(10, TimeUnit.SECONDS);


      MagicKey key = new MagicKey(cache3);
      verifySimpleInsertion(cache3, key, FIRST_VALUE, null, clusterListener, FIRST_VALUE);
   }

View Full Code Here

      final ClusterListener clusterListener = new ClusterListener();
      cache1.addListener(clusterListener);


      assertEquals(manager(0).getAddress(), manager(0).getMembers().get(0));


      CheckPoint checkPoint = new CheckPoint();
      waitUntilRequestingListeners(cache0, checkPoint);
      checkPoint.triggerForever("pre_cluster_listeners_release_" + cache0);


      // First we add the new node, but block the dist exec execution
      log.info("Adding a new node ..");
      addClusterEnabledCacheManager(builderUsed);
      log.info("Added a new node");


      Future<Cache<Object, String>> future = fork(new Callable<Cache<Object, String>>() {
         @Override
         public Cache<Object, String> call() throws Exception {
            return cache(3, CACHE_NAME);
         }
      });


      checkPoint.awaitStrict("post_cluster_listeners_invoked_" + cache0, 10, TimeUnit.SECONDS);


      log.info("Killing node 1 ..");
      // Notice we are killing the manager that doesn't have a cache with the cluster listener
      TestingUtil.killCacheManagers(manager(1));
      cacheManagers.remove(1);
      log.info("Node 1 killed");


      checkPoint.triggerForever("post_cluster_listeners_release_" + cache0);


      // Now wait for cache3 to come up fully
      TestingUtil.blockUntilViewsReceived(10000, false, cacheManagers);
      TestingUtil.waitForRehashToComplete(caches(CACHE_NAME));

View Full Code Here

      Cache<Object, String> cache2 = cache(2, CACHE_NAME);


      ClusterListener clusterListener = new ClusterListener();
      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);

View Full Code Here

         String value = "value-" + i;
         expectedValues.put(key, value);
         cache.put(key, value);
      }


      final CheckPoint checkPoint = new CheckPoint();


      EntryRetriever retriever = waitUntilRetrievingIterator(cache, checkPoint);
      try {
         Future<Void> future = fork(new Callable<Void>() {


            @Override
            public Void call() throws Exception {
               cache.addListener(listener);
               return null;
            }
         });


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


         String value;
         String keyToChange = findKeyBasedOnOwnership(expectedValues.keySet(),
               cache.getAdvancedCache().getDistributionManager().getConsistentHash(),
               shouldBePrimaryOwner, cache.getCacheManager().getAddress());


         switch (operation) {
            case CREATE:
               keyToChange = "new-key";
               value = "new-value";
               expectedValues.put(keyToChange, value);
               break;
            case PUT:
               value =  cache.get(keyToChange) + "-changed";
               // Now remove the old value and put in the new one
               expectedValues.put(keyToChange, value);
               break;
            case REMOVE:
               value = null;
               expectedValues.remove(keyToChange);
               break;
            default:
               throw new IllegalArgumentException("Unsupported Operation provided " + operation);
         }


         operation.perform(cache, keyToChange, value);


         // Now let the iteration complete
         checkPoint.triggerForever("pre_retrieve_entry_released");


         future.get(10, TimeUnit.SECONDS);


         verifyEvents(isClustered(listener), listener, expectedValues);
      } finally {

View Full Code Here

         String value = "value-" + i;
         expectedValues.put(key, value);
         cache.put(key, value);
      }


      CheckPoint checkPoint = new CheckPoint();


      EntryRetriever retriever = waitUntilClosingIterator(cache, checkPoint);


      try {
         Future<Void> future = fork(new Callable<Void>() {


            @Override
            public Void call() throws Exception {
               cache.addListener(listener);
               return null;
            }
         });


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


         String value;
         String keyToChange = findKeyBasedOnOwnership(expectedValues.keySet(),
                                                      cache.getAdvancedCache().getDistributionManager().getConsistentHash(),
                                                      shouldBePrimaryOwner, cache.getCacheManager().getAddress());


         switch (operation) {
            case CREATE:
               keyToChange = "new-key";
               value = "new-value";
               break;
            case PUT:
               value =  cache.get(keyToChange) + "-changed";
               break;
            case REMOVE:
               value = null;
               break;
            default:
               throw new IllegalArgumentException("Unsupported Operation provided " + operation);
         }


         Object oldValue = operation.perform(cache, keyToChange, value);


         // Now let the iteration complete
         checkPoint.triggerForever("pre_close_iter_released");


         future.get(10, TimeUnit.SECONDS);


         boolean isClustered = isClustered(listener);

View Full Code Here

            break;
         default:
            throw new IllegalArgumentException("Unsupported Operation provided " + operation);
      }


      CheckPoint checkPoint = new CheckPoint();
      int segmentToUse = cache.getAdvancedCache().getDistributionManager().getConsistentHash().getSegment(keyToChange);


      // do the operation, which should put it in the queue.
      ClusterCacheNotifier notifier = waitUntilClosingSegment(cache, segmentToUse, checkPoint);


      Future<Void> future = fork(new Callable<Void>() {


         @Override
         public Void call() throws Exception {
            cache.addListener(listener);
            return null;
         }
      });


      try {
         checkPoint.awaitStrict("pre_complete_segment_invoked", 10, TimeUnit.SECONDS);
         Object oldValue = operation.perform(cache, keyToChange, value);


         // Now let the iteration complete
         checkPoint.triggerForever("pre_complete_segment_released");


         future.get(10, TimeUnit.SECONDS);


         boolean isClustered = isClustered(listener);

View Full Code Here

         // After the barrier  has been hit remove the interceptor, since we can just wake it up through the barrier,
         // this way the state transfer won't be blocked if the normal put occurs before it.
         removeAllBlockingInterceptorsFromCache(primaryOwnerCache);


         // Block the rebalance confirmation on nonOwnerCache
         CheckPoint checkPoint = new CheckPoint();
         log.trace("Adding proxy to state transfer");
         waitUntilStateBeingTransferred(nonOwnerCache, checkPoint);


         backupOwnerCache.getCacheManager().stop();


         // Wait for non owner to just about get state
         checkPoint.awaitStrict("pre_state_apply_invoked_for_" + nonOwnerCache, 10, SECONDS);


         // let prepare complete and thus commit command invalidating on nonOwner
         cyclicBarrier.await(10, SECONDS);


         assertEquals(op.getReturnValue(), future.get(10, SECONDS));


         // let state transfer go
         checkPoint.trigger("pre_state_apply_release_for_" + nonOwnerCache);


         TestingUtil.waitForRehashToComplete(primaryOwnerCache, nonOwnerCache);


         switch (op) {
            case REMOVE:

View Full Code Here

      }


      int preJoinTopologyId = primaryOwnerCache.getComponentRegistry().getStateTransferManager().getCacheTopology().getTopologyId();


      // Block any state response commands on cache0
      CheckPoint checkPoint = new CheckPoint();
      ControlledRpcManager blockingRpcManager0 = blockStateResponseCommand(primaryOwnerCache);


      // Block the rebalance confirmation on cache0
      blockRebalanceConfirmation(primaryOwnerCache.getCacheManager(), checkPoint);


      assertEquals(primaryOwnerCache.getCacheManager().getCoordinator(), primaryOwnerCache.getCacheManager().getAddress());


      // Remove the leaver
      log.trace("Stopping the cache");
      backupOwnerCache.getCacheManager().stop();


      int rebalanceTopologyId = preJoinTopologyId + 2;


      // Wait for the write CH to contain the joiner everywhere
      eventually(new Condition() {
         @Override
         public boolean isSatisfied() throws Exception {
            return primaryOwnerCache.getRpcManager().getMembers().size() == 2 &&
                  nonOwnerCache.getRpcManager().getMembers().size() == 2;
         }
      });


      assertEquals(primaryOwnerCache.getCacheManager().getCoordinator(), primaryOwnerCache.getCacheManager().getAddress());


      // Wait for cache0 to collect the state to send to cache1 (including our previous value).
      blockingRpcManager0.waitForCommandToBlock();


      // Every PutKeyValueCommand will be blocked before committing the entry on cache1
      CyclicBarrier beforeCommitCache1Barrier = new CyclicBarrier(2);
      BlockingInterceptor blockingInterceptor1 = new BlockingInterceptor(beforeCommitCache1Barrier,
                                                                         op.getCommandClass(), true);
      nonOwnerCache.addInterceptorAfter(blockingInterceptor1, EntryWrappingInterceptor.class);


      // Put/Replace/Remove from cache0 with cache0 as primary owner, cache1 will become a backup owner for the retry
      // The put command will be blocked on cache1 just before committing the entry.
      Future<Object> future = fork(new Callable<Object>() {
         @Override
         public Object call() throws Exception {
            return op.perform(primaryOwnerCache, key);
         }
      });


      // Wait for the entry to be wrapped on cache1
      beforeCommitCache1Barrier.await(10, TimeUnit.SECONDS);


      // Remove the interceptor so we don't mess up any other state transfer puts
      removeAllBlockingInterceptorsFromCache(nonOwnerCache);


      // Allow the state to be applied on cache1 (writing the old value for our entry)
      blockingRpcManager0.stopBlocking();


      // Wait for second in line to finish applying the state, but don't allow the rebalance confirmation to be processed.
      // (It would change the topology and it would trigger a retry for the command.)
      checkPoint.awaitStrict("pre_rebalance_confirmation_" + rebalanceTopologyId + "_from_" +
                                   primaryOwnerCache.getCacheManager().getAddress(), 10, SECONDS);


      // Now allow the command to commit on cache1
      beforeCommitCache1Barrier.await(10, TimeUnit.SECONDS);


      // Wait for the command to finish and check that it didn't fail
      Object result = future.get(10, TimeUnit.SECONDS);
      assertEquals(op.getReturnValue(), result);
      log.tracef("%s operation is done", op);


      // Allow the rebalance confirmation to proceed and wait for the topology to change everywhere
      checkPoint.trigger("resume_rebalance_confirmation_" + rebalanceTopologyId + "_from_" + primaryOwnerCache.getCacheManager().getAddress());
      checkPoint.trigger("resume_rebalance_confirmation_" + rebalanceTopologyId + "_from_" + nonOwnerCache.getCacheManager().getAddress());
      TestingUtil.waitForRehashToComplete(primaryOwnerCache, nonOwnerCache);


      switch (op) {
         case REMOVE:
         case REMOVE_EXACT:

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.infinispan.test.fwk.CheckPoint

org.infinispan.client.hotrod.LockingTest

org.infinispan.distribution.BaseDistSyncL1Test

org.infinispan.distribution.groups.BaseGetGroupKeysTest$BlockCommandInterceptor

org.infinispan.distribution.groups.BaseStateTransferGetGroupKeysTest$BlockCommandInterceptor

org.infinispan.distribution.rehash.BaseTxStateTransferOverwriteTest

org.infinispan.distribution.rehash.L1StateTransferRemovesValueTest

org.infinispan.distribution.rehash.NonTxBackupOwnerBecomingPrimaryOwnerTest

org.infinispan.distribution.rehash.NonTxJoinerBecomingBackupOwnerTest

org.infinispan.distribution.rehash.NonTxStateTransferOverwritingValue2Test

org.infinispan.distribution.rehash.NonTxStateTransferOverwritingValueTest

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.