private ConsistentHash getConsistentHash(Cache cache) { DistributionManager dm = cache.getAdvancedCache().getDistributionManager(); return (dm != null) ? dm.getReadConsistentHash() : null; }
<S> CompletionRehashPublisherDecorator<S> createDecorator(ConsistentHash ch, Set<Integer> segmentsForOwner, Set<Integer> primarySegmentsForOwner, Consumer<Supplier<PrimitiveIterator.OfInt>> internalListener, Consumer<Object> entryConsumer) { Address address = Mockito.mock(Address.class); if (segmentsForOwner != null) { when(ch.getSegmentsForOwner(eq(address))).thenReturn(segmentsForOwner); } if (primarySegmentsForOwner != null) { when(ch.getPrimarySegmentsForOwner(eq(address))).thenReturn(primarySegmentsForOwner); } DistributionManager dm = mock(DistributionManager.class); when(dm.getReadConsistentHash()).thenReturn(ch); return new CompletionRehashPublisherDecorator<>(AbstractCacheStream.IteratorOperation.NO_MAP, dm, address, // Just ignore early completed segments and lost ones internalListener, i -> {}, i -> {}, new WithinThreadExecutor(), entryConsumer, e -> ((Map.Entry) e).getKey()); }
ConsistentHash ch = distManager.getReadConsistentHash(); int numSegments = ch.getNumSegments();
public void ensureOldMapsRemoved() { for (Cache<Object, Object> cache : caches(CACHE_NAME)) { DataContainer dc = TestingUtil.extractComponent(cache, InternalDataContainer.class); assertTrue(dc instanceof DefaultSegmentedDataContainer); DefaultSegmentedDataContainer segmentedDataContainer = (DefaultSegmentedDataContainer) dc; DistributionManager dm = TestingUtil.extractComponent(cache, DistributionManager.class); Address address = cache.getCacheManager().getAddress(); Set<Integer> segments = dm.getReadConsistentHash().getSegmentsForOwner(address); int mapCount = 0; for (int i = 0; i < segmentedDataContainer.maps.length(); ++i) { if (segmentedDataContainer.maps.get(i) != null) { assertTrue("Segment " + i + " has non null map, but wasn't owned by node: " + address + "!", segments.contains(i)); mapCount++; } } assertEquals(mapCount, segments.size()); } } }
private void assertCapacityFactors(float... expectedCapacityFactors) { ConsistentHash ch = cache(0).getAdvancedCache().getDistributionManager().getReadConsistentHash(); DefaultConsistentHash dch = (DefaultConsistentHash) TestingUtil.extractField(PartitionerConsistentHash.class, ch, "ch"); int numNodes = expectedCapacityFactors.length; Map<Address,Float> capacityFactors = dch.getCapacityFactors(); for (int i = 0; i < numNodes; i++) { assertEquals(expectedCapacityFactors[i], capacityFactors.get(address(i)), 0.0); } }
c1.addListener(rehashListener); ConsistentHash ch1Node = advancedCache(0).getDistributionManager().getReadConsistentHash(); assertEquals(rehashListener.removeEvents().size(), 0); TestingUtil.waitForNoRebalance(cache(0), cache(1)); ConsistentHash ch2Nodes = advancedCache(0).getDistributionManager().getReadConsistentHash(); rehashListener.waitForEvents(2); List<DataRehashedEvent<Object, Object>> events = rehashListener.removeEvents(); TestingUtil.waitForNoRebalance(cache(0), cache(1), cache(2)); ConsistentHash ch3Nodes = advancedCache(0).getDistributionManager().getReadConsistentHash(); rehashListener.waitForEvents(2); events = rehashListener.removeEvents(); ConsistentHash chAfterLeave = advancedCache(0).getDistributionManager().getReadConsistentHash(); rehashListener.waitForEvents(2); events = rehashListener.removeEvents();
private void assertPrimaryOwned(int... expectedPrimaryOwned) { ConsistentHash ch = cache(0).getAdvancedCache().getDistributionManager().getReadConsistentHash(); OwnershipStatistics stats = new OwnershipStatistics(ch, ch.getMembers()); int numNodes = expectedPrimaryOwned.length; for (int i = 0; i < numNodes; i++) { double delta = expectedPrimaryOwned[i] * 0.15; assertBetween(expectedPrimaryOwned[i] - 2 * delta, expectedPrimaryOwned[i] + delta, stats.getPrimaryOwned(address(i))); } }
private void assertOwned(int... expectedOwned) { ConsistentHash ch = cache(0).getAdvancedCache().getDistributionManager().getReadConsistentHash(); OwnershipStatistics stats = new OwnershipStatistics(ch, ch.getMembers()); int numNodes = expectedOwned.length; for (int i = 0; i < numNodes; i++) { double delta = expectedOwned[i] * 0.25; assertBetween(expectedOwned[i] - 2 * delta, expectedOwned[i] + delta, stats.getOwned(address(i))); } } }
private void checkVersion(Cache<Object, Object> c, MagicKey hello) { Address address = c.getCacheManager().getAddress(); ConsistentHash readConsistentHash = c.getAdvancedCache().getDistributionManager().getReadConsistentHash(); if (readConsistentHash.isKeyLocalToNode(address, hello)) { InternalCacheEntry ice = c.getAdvancedCache().getDataContainer().get(hello); assertNotNull("Entry not found on owner cache " + c, ice); assertNotNull("Version is null on owner cache " + c, ice.getMetadata().version()); } } }
eventuallyEquals(address(2), () -> advancedCache(0).getDistributionManager().getReadConsistentHash().locatePrimaryOwnerForSegment(1));
ConsistentHash ch = cache(a0).getAdvancedCache().getDistributionManager().getReadConsistentHash(); assertEquals(3, ch.getMembers().size()); for (Object k : allKeys) {