コード例 #1
0
 @Override
 public void broadcastTopologyUpdate(
     String cacheName,
     CacheTopology cacheTopology,
     AvailabilityMode availabilityMode,
     boolean totalOrder,
     boolean distributed) {
   instance.broadcastTopologyUpdate(
       cacheName, cacheTopology, availabilityMode, totalOrder, distributed);
 }
コード例 #2
0
    @Override
    public org.infinispan.topology.CacheStatusResponse handleJoin(
        String cacheName, Address joiner, CacheJoinInfo joinInfo, int viewId) throws Exception {
      CacheStatusResponse result = instance.handleJoin(cacheName, joiner, joinInfo, viewId);

      // Allow the joiner to receive some commands before the initial cache topology
      log.tracef("Delaying join response");
      Thread.sleep(500);
      return result;
    }
コード例 #3
0
    @Override
    public void broadcastRebalanceStart(
        String cacheName, CacheTopology cacheTopology, boolean totalOrder, boolean distributed) {
      // Allow the joiner to receive some commands between the initial cache topology and the
      // rebalance start
      log.tracef("Delaying rebalance");
      try {
        Thread.sleep(500);
      } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
      }

      instance.broadcastRebalanceStart(cacheName, cacheTopology, totalOrder, distributed);
    }
  public void testReplace() throws Exception {
    cache(0).put("myKey", "myValue");

    // add an interceptor on second node that will block REPLACE commands right after
    // EntryWrappingInterceptor until we are ready
    final CountDownLatch replaceStartedLatch = new CountDownLatch(1);
    final CountDownLatch replaceProceedLatch = new CountDownLatch(1);
    boolean isVersioningEnabled = cache(0).getCacheConfiguration().versioning().enabled();
    cacheConfigBuilder
        .customInterceptors()
        .addInterceptor()
        .after(
            isVersioningEnabled
                ? VersionedEntryWrappingInterceptor.class
                : EntryWrappingInterceptor.class)
        .interceptor(
            new CommandInterceptor() {
              @Override
              protected Object handleDefault(InvocationContext ctx, VisitableCommand cmd)
                  throws Throwable {
                if (cmd instanceof ReplaceCommand) {
                  // signal we encounter a REPLACE
                  replaceStartedLatch.countDown();
                  // wait until it is ok to continue with REPLACE
                  if (!replaceProceedLatch.await(15, TimeUnit.SECONDS)) {
                    throw new TimeoutException();
                  }
                }
                return super.handleDefault(ctx, cmd);
              }
            });

    // do not allow coordinator to send topology updates to node B
    final ClusterTopologyManager ctm0 =
        TestingUtil.extractGlobalComponent(manager(0), ClusterTopologyManager.class);
    ctm0.setRebalancingEnabled(false);

    log.info("Adding a new node ..");
    addClusterEnabledCacheManager(cacheConfigBuilder);
    log.info("Added a new node");

    // node B is not a member yet and rebalance has not started yet
    CacheTopology cacheTopology =
        advancedCache(1).getComponentRegistry().getStateTransferManager().getCacheTopology();
    assertNull(cacheTopology.getPendingCH());
    assertTrue(cacheTopology.getMembers().contains(address(0)));
    assertFalse(cacheTopology.getMembers().contains(address(1)));
    assertFalse(cacheTopology.getCurrentCH().getMembers().contains(address(1)));

    // no keys should be present on node B yet because state transfer is blocked
    assertTrue(cache(1).keySet().isEmpty());

    // initiate a REPLACE
    Future<Object> getFuture =
        fork(
            new Callable<Object>() {
              @Override
              public Object call() throws Exception {
                try {
                  return cache(1).replace("myKey", "newValue");
                } catch (Exception e) {
                  log.errorf(e, "REPLACE failed: %s", e.getMessage());
                  throw e;
                }
              }
            });

    // wait for REPLACE command on node B to reach beyond *EntryWrappingInterceptor, where it will
    // block.
    // the value seen so far is null
    if (!replaceStartedLatch.await(15, TimeUnit.SECONDS)) {
      throw new TimeoutException();
    }

    // paranoia, yes the value is still missing from data container
    assertTrue(cache(1).keySet().isEmpty());

    // allow rebalance to start
    ctm0.setRebalancingEnabled(true);

    // wait for state transfer to end
    TestingUtil.waitForRehashToComplete(cache(0), cache(1));

    // the state should be already transferred now
    assertEquals(1, cache(1).keySet().size());

    // allow REPLACE to continue
    replaceProceedLatch.countDown();

    Object oldVal = getFuture.get(15, TimeUnit.SECONDS);
    assertNotNull(oldVal);
    assertEquals("myValue", oldVal);

    assertEquals("newValue", cache(0).get("myKey"));
    assertEquals("newValue", cache(1).get("myKey"));
  }
コード例 #5
0
 @Override
 public void forceAvailabilityMode(String cacheName, AvailabilityMode availabilityMode) {
   instance.forceAvailabilityMode(cacheName, availabilityMode);
 }
コード例 #6
0
 @Override
 public void forceRebalance(String cacheName) {
   instance.forceRebalance(cacheName);
 }
コード例 #7
0
 @Override
 public void setRebalancingEnabled(boolean enabled) {
   instance.setRebalancingEnabled(enabled);
 }
コード例 #8
0
 @Override
 public boolean isRebalancingEnabled() {
   return instance.isRebalancingEnabled();
 }
コード例 #9
0
 @Override
 public void broadcastStableTopologyUpdate(
     String cacheName, CacheTopology cacheTopology, boolean totalOrder, boolean distributed) {
   instance.broadcastStableTopologyUpdate(cacheName, cacheTopology, totalOrder, distributed);
 }
コード例 #10
0
 @Override
 public void handleClusterView(boolean isMerge, int viewId) {
   instance.handleClusterView(isMerge, viewId);
 }
コード例 #11
0
 @Override
 public void handleRebalanceCompleted(
     String cacheName, Address node, int topologyId, Throwable throwable, int viewId)
     throws Exception {
   instance.handleRebalanceCompleted(cacheName, node, topologyId, throwable, viewId);
 }
コード例 #12
0
 @Override
 public void handleLeave(String cacheName, Address leaver, int viewId) throws Exception {
   instance.handleLeave(cacheName, leaver, viewId);
 }