How to use

getActualMembers

method

in

org.infinispan.distribution.LocalizedCacheTopology

public void assertActualMembers() {
  Set<org.infinispan.remoting.transport.Address> expected =
   cachesInThisPartition().stream()
               .map(c -> c.getAdvancedCache().getRpcManager().getAddress())
               .collect(Collectors.toSet());
  for (Cache c : cachesInThisPartition()) {
   eventuallyEquals(expected, () -> new HashSet<>(c.getAdvancedCache().getDistributionManager().getCacheTopology().getActualMembers()));
  }
}

public static void assertHashTopology20Received(AbstractTestTopologyAwareResponse topoResp,
                        List<HotRodServer> servers, String cacheName, int expectedTopologyId) {
 TestHashDistAware20Response hashTopologyResp = (TestHashDistAware20Response) topoResp;
 assertEquals(expectedTopologyId, hashTopologyResp.topologyId);
 assertEquals(hashTopologyResp.members.size(), servers.size());
 Set<ServerAddress> serverAddresses = servers.stream().map(HotRodServer::getAddress).collect(Collectors.toSet());
 hashTopologyResp.members.forEach(member -> assertTrue(serverAddresses.contains(member)));
 assertEquals(hashTopologyResp.hashFunction, 3);
 // Assert segments
 Cache cache = servers.get(0).getCacheManager().getCache(cacheName);
 LocalizedCacheTopology cacheTopology = cache.getAdvancedCache().getDistributionManager().getCacheTopology();
 assertEquals(cacheTopology.getActualMembers().size(), servers.size());
 ConsistentHash ch = cacheTopology.getCurrentCH();
 int numSegments = ch.getNumSegments();
 int numOwners = ch.getNumOwners();
 assertEquals(hashTopologyResp.segments.size(), numSegments);
 for (int i = 0; i < numSegments; ++i) {
   List<Address> segment = ch.locateOwnersForSegment(i);
   Iterable<ServerAddress> members = hashTopologyResp.segments.get(i);
   assertEquals(Math.min(numOwners, ch.getMembers().size()), segment.size());
   int count = 0;
   for (ServerAddress member : members) {
    count++;
    assertTrue(serverAddresses.contains(member));
   }
   // The number of servers could be smaller than the number of CH members (same as the number of actual members)
   assertEquals(Math.min(numOwners, servers.size()), count);
 }
}

  private Future<Void> simulateTopologyUpdate(Cache<Object, Object> cache) {
   StateTransferLock stl4 = TestingUtil.extractComponent(cache, StateTransferLock.class);
   DistributionManager dm4 = cache.getAdvancedCache().getDistributionManager();
   LocalizedCacheTopology cacheTopology = dm4.getCacheTopology();
   int newTopologyId = cacheTopology.getTopologyId() + 1;
   CacheTopology newTopology = new CacheTopology(newTopologyId, cacheTopology.getRebalanceId(),
                          cacheTopology.getCurrentCH(), cacheTopology.getPendingCH(),
                          cacheTopology.getUnionCH(),
                          cacheTopology.getPhase(), cacheTopology.getActualMembers(),
                          cacheTopology.getMembersPersistentUUIDs());
   dm4.setCacheTopology(newTopology);
   return fork(() -> stl4.notifyTransactionDataReceived(newTopologyId));
  }
}

public void testNewTopologySentAfterCleanMerge() {
 TestingUtil.waitForNoRebalanceAcrossManagers(managers());
 int initialTopology = advancedCache(0).getRpcManager().getTopologyId();
 expectCompleteTopology(client, initialTopology);
 PartitionDescriptor p0 = new PartitionDescriptor(0);
 PartitionDescriptor p1 = new PartitionDescriptor(1);
 splitCluster(p0.getNodes(), p1.getNodes());
 eventuallyEquals(1, () -> advancedCache(0).getDistributionManager().getCacheTopology().getActualMembers().size());
 eventuallyEquals(1, () -> advancedCache(1).getDistributionManager().getCacheTopology().getActualMembers().size());
 expectPartialTopology(client, initialTopology + 1);
 partition(0).merge(partition(1));
 int finalTopologyId =  initialTopology + (partitionHandling == PartitionHandling.DENY_READ_WRITES ? 4 : 8);
 eventuallyExpectCompleteTopology(client, finalTopologyId);
 // Check that we got the number of topology updates to NO_REBALANCE right
 // With DENY_READ_WRITES:
 // T+1: DEGRADED_MODE in both partitions
 // T+3: merged, still DEGRADED_MODE
 // T+4: back to AVAILABLE
 // With ALLOW_READ_WRITES:
 // T+2: NO_REBALANCE in partition [B] before merge
 // T+3: CONFLICT_RESOLUTION, preferred CH: owners = (1) [test-NodeA-22368: 256+0]
 // T+4: NO_REBALANCE update topology after CR and before rebalance begins
 // T+5:READ_OLD (rebalance starts), T+6:READ_ALL, T+7:READ_NEW, T+8: NO_REBALANCE
 LocalizedCacheTopology newTopology = advancedCache(0).getDistributionManager().getCacheTopology();
 assertEquals(CacheTopology.Phase.NO_REBALANCE, newTopology.getPhase());
 assertEquals(finalTopologyId, newTopology.getTopologyId());
}

public void testNewTopologySentAfterOverlappingMerge() {
 TestingUtil.waitForNoRebalanceAcrossManagers(managers());
 int initialTopology = advancedCache(0).getRpcManager().getTopologyId();
 expectCompleteTopology(client, initialTopology);
 PartitionDescriptor p1 = new PartitionDescriptor(0);
 // isolatePartitions will always result in a CR fail as Node 0 tries to contact Node 1 in order to receive segments
 // which is not possible as all messages received by Node 1 from Node 0 are discarded by the DISCARD protocol.
 // Therefore, it is necessary for the state transfer timeout to be < then the timeout utilised by TestingUtil::waitForNoRebalance
 isolatePartition(p1.getNodes());
 eventuallyEquals(1, () -> advancedCache(0).getDistributionManager().getCacheTopology().getActualMembers().size());
 eventuallyExpectPartialTopology(client, initialTopology + 1);
 partition(0).merge(partition(1));
 int finalTopologyId = initialTopology + (partitionHandling == PartitionHandling.DENY_READ_WRITES ? 2 : 7);
 eventuallyExpectCompleteTopology(client, finalTopologyId);
 // Check that we got the number of topology updates to NO_REBALANCE right
 // With DENY_READ_WRITES:
 // T+1: DEGRADED_MODE in partition [A]
 // T+2: back to AVAILABLE
 // With ALLOW_READ_WRITES:
 // With ALLOW_READ_WRITES:
 // T+2: CONFLICT_RESOLUTION, preferred CH: owners = (1) [test-NodeA-22368: 256+0]
 // T+3: NO_REBALANCE update topology after CR and before rebalance begins
 // T+4:READ_OLD (rebalance starts), T+5:READ_ALL, T+6:READ_NEW, T+7: NO_REBALANCE
 LocalizedCacheTopology newTopology = advancedCache(0).getDistributionManager().getCacheTopology();
 assertEquals(CacheTopology.Phase.NO_REBALANCE, newTopology.getPhase());
}

eventuallyEquals(2, () -> dmP0N1.getCacheTopology().getActualMembers().size());
assertEquals(AvailabilityMode.AVAILABLE, partitionHandlingManager(p0.node(0)).getAvailabilityMode());

eventuallyEquals(2, () -> dmP0N1.getCacheTopology().getActualMembers().size());
assertEquals(AvailabilityMode.AVAILABLE, partitionHandlingManager(p0.node(0)).getAvailabilityMode());