use of org.infinispan.distribution.ch.KeyPartitioner in project wildfly by wildfly.
the class KeyPartitionerFactory method construct.
@Override
public Object construct(String componentName) {
if (!this.configuration.clustering().cacheMode().isClustered() && !this.configuration.persistence().usingSegmentedStore()) {
return SingleSegmentKeyPartitioner.getInstance();
}
HashConfiguration hashConfiguration = this.configuration.clustering().hash();
KeyPartitioner partitioner = hashConfiguration.keyPartitioner();
partitioner.init(hashConfiguration);
this.basicComponentRegistry.wireDependencies(partitioner, false);
return (this.groupManager != null) ? new GroupingPartitioner(partitioner, this.groupManager) : partitioner;
}
use of org.infinispan.distribution.ch.KeyPartitioner in project wildfly by wildfly.
the class DefaultKeyAffinityServiceTestCase method test.
@Test
public void test() {
KeyPartitioner partitioner = mock(KeyPartitioner.class);
KeyGenerator<UUID> generator = mock(KeyGenerator.class);
AdvancedCache<UUID, Object> cache = mock(AdvancedCache.class);
Address local = mock(Address.class);
Address remote = mock(Address.class);
Address standby = mock(Address.class);
Address ignored = mock(Address.class);
KeyAffinityService<UUID> service = new DefaultKeyAffinityService<>(cache, partitioner, generator, address -> (address != ignored));
DistributionManager dist = mock(DistributionManager.class);
CacheTopology topology = mock(CacheTopology.class);
ConsistentHash hash = mock(ConsistentHash.class);
List<Address> members = Arrays.asList(local, remote, standby, ignored);
when(cache.getAdvancedCache()).thenReturn(cache);
when(cache.getDistributionManager()).thenReturn(dist);
when(topology.getActualMembers()).thenReturn(members);
when(topology.getCurrentCH()).thenReturn(hash);
when(topology.getMembers()).thenReturn(members);
when(topology.getMembersPersistentUUIDs()).thenReturn(Arrays.asList(PersistentUUID.randomUUID(), PersistentUUID.randomUUID(), PersistentUUID.randomUUID(), PersistentUUID.randomUUID()));
when(topology.getPendingCH()).thenReturn(null);
when(topology.getPhase()).thenReturn(CacheTopology.Phase.NO_REBALANCE);
when(topology.getReadConsistentHash()).thenReturn(hash);
when(topology.getRebalanceId()).thenReturn(0);
when(topology.getTopologyId()).thenReturn(0);
when(topology.getUnionCH()).thenReturn(null);
when(topology.getWriteConsistentHash()).thenReturn(hash);
when(hash.getMembers()).thenReturn(members);
when(hash.getNumSegments()).thenReturn(SEGMENTS);
when(hash.locatePrimaryOwnerForSegment(LOCAL_SEGMENT)).thenReturn(local);
when(hash.locatePrimaryOwnerForSegment(REMOTE_SEGMENT)).thenReturn(remote);
when(hash.locatePrimaryOwnerForSegment(FILTERED_SEGMENT)).thenReturn(ignored);
when(hash.locateOwnersForSegment(LOCAL_SEGMENT)).thenReturn(Collections.singletonList(local));
when(hash.locateOwnersForSegment(REMOTE_SEGMENT)).thenReturn(Collections.singletonList(remote));
when(hash.locateOwnersForSegment(FILTERED_SEGMENT)).thenReturn(Collections.singletonList(ignored));
when(hash.getPrimarySegmentsForOwner(local)).thenReturn(Collections.singleton(LOCAL_SEGMENT));
when(hash.getPrimarySegmentsForOwner(remote)).thenReturn(Collections.singleton(REMOTE_SEGMENT));
when(hash.getPrimarySegmentsForOwner(standby)).thenReturn(Collections.emptySet());
when(hash.getPrimarySegmentsForOwner(ignored)).thenReturn(Collections.singleton(FILTERED_SEGMENT));
when(hash.getSegmentsForOwner(local)).thenReturn(Collections.singleton(LOCAL_SEGMENT));
when(hash.getSegmentsForOwner(remote)).thenReturn(Collections.singleton(REMOTE_SEGMENT));
when(hash.getSegmentsForOwner(standby)).thenReturn(Collections.emptySet());
when(hash.getSegmentsForOwner(ignored)).thenReturn(Collections.singleton(FILTERED_SEGMENT));
LocalizedCacheTopology localizedTopology = new LocalizedCacheTopology(CacheMode.DIST_SYNC, topology, partitioner, local, true);
when(dist.getCacheTopology()).thenReturn(localizedTopology);
// Mock a sufficient number of keys
OngoingStubbing<UUID> stub = when(generator.getKey());
for (int i = 0; i < 1000; ++i) {
UUID key = UUID.randomUUID();
int segment = getSegment(key);
stub = stub.thenReturn(key);
when(partitioner.getSegment(key)).thenReturn(segment);
}
assertThrows(IllegalStateException.class, () -> service.getKeyForAddress(local));
assertThrows(IllegalStateException.class, () -> service.getKeyForAddress(remote));
assertThrows(IllegalStateException.class, () -> service.getKeyForAddress(standby));
// This should throw IAE, since address does not pass filter
assertThrows(IllegalArgumentException.class, () -> service.getKeyForAddress(ignored));
service.start();
try {
for (int i = 0; i < 50; ++i) {
UUID key = service.getKeyForAddress(local);
int segment = getSegment(key);
assertEquals(LOCAL_SEGMENT, segment);
key = service.getCollocatedKey(key);
segment = getSegment(key);
assertEquals(LOCAL_SEGMENT, segment);
key = service.getKeyForAddress(remote);
segment = getSegment(key);
assertEquals(REMOTE_SEGMENT, segment);
key = service.getCollocatedKey(key);
segment = getSegment(key);
assertEquals(REMOTE_SEGMENT, segment);
}
// This should return a random key
assertNotNull(service.getKeyForAddress(standby));
// This should throw IAE, since address does not pass filter
assertThrows(IllegalArgumentException.class, () -> service.getKeyForAddress(ignored));
} finally {
service.stop();
}
}
use of org.infinispan.distribution.ch.KeyPartitioner in project wildfly by wildfly.
the class ConsistentHashKeyDistributionTestCase method test.
@Test
public void test() {
KeyPartitioner partitioner = mock(KeyPartitioner.class);
ConsistentHash hash = mock(ConsistentHash.class);
KeyDistribution distribution = new ConsistentHashKeyDistribution(partitioner, hash);
Address address = mock(Address.class);
Object key = new Object();
int segment = 128;
when(partitioner.getSegment(key)).thenReturn(segment);
when(hash.locatePrimaryOwnerForSegment(segment)).thenReturn(address);
Address result = distribution.getPrimaryOwner(key);
assertSame(address, result);
}
Aggregations