@Override public <K> KeyAffinityService<K> createService(Cache<K, ?> cache, KeyGenerator<K> generator) { CacheMode mode = cache.getCacheConfiguration().clustering().cacheMode(); return mode.isDistributed() || mode.isReplicated() ? new KeyAffinityServiceImpl<>(executor, cache, generator, bufferSize, Collections.singleton(cache.getCacheManager().getAddress()), false) : new SimpleKeyAffinityService<>(generator); } };
public static boolean isTriangleAlgorithm(CacheMode cacheMode, boolean transactional) { return cacheMode.isDistributed() && !transactional; }
protected BaseCacheNotifierImplInitialTransferTest(CacheMode mode) { if (mode.isDistributed()) { throw new IllegalArgumentException("This test only works with non distributed cache modes"); } this.cacheMode = mode; }
protected Object getKey() { return cacheMode.isDistributed() ? getKeyForCache(0) : "k"; } }
@Override protected int[][] assignOwners(int numSegments, int numOwners, List<Address> members) { if (cacheMode.isDistributed()) { assertEquals(2, numOwners); switch (members.size()) { case 1: return new int[][]{{0}}; case 2: return new int[][]{{0, 1}}; default: return new int[][]{{members.size() - 1, 0}}; } } else if (cacheMode.isScattered()) { return new int[][]{{0}}; } else { throw new IllegalStateException(); } } }
@Override public <K> KeyAffinityService<K> createService(Cache<K, ?> cache, KeyGenerator<K> generator) { boolean distributed = cache.getCacheConfiguration().clustering().cacheMode().isDistributed(); return distributed ? new KeyAffinityServiceImpl<>(this.executor, cache, generator, this.bufferSize, Collections.singleton(cache.getCacheManager().getAddress()), false) : new SimpleKeyAffinityService<>(generator); }
@Override public <K> KeyAffinityService<K> createService(Cache<K, ?> cache, KeyGenerator<K> generator) { CacheMode mode = cache.getCacheConfiguration().clustering().cacheMode(); return mode.isDistributed() || mode.isReplicated() ? new KeyAffinityServiceImpl<>(executor, cache, generator, bufferSize, Collections.singleton(cache.getCacheManager().getAddress()), false) : new SimpleKeyAffinityService<>(generator); } };
private void verifyTopologyUpdate() { verify(topologyManager).broadcastTopologyUpdate(CACHE_NAME, status.getCurrentTopology(), AvailabilityMode.AVAILABLE, JOIN_INFO.isTotalOrder(), JOIN_INFO.getCacheMode().isDistributed()); }
private void verifyStableTopologyUpdate() { verify(topologyManager).broadcastStableTopologyUpdate(CACHE_NAME, status.getStableTopology(), JOIN_INFO.isTotalOrder(), JOIN_INFO.getCacheMode().isDistributed()); }
private void verifyRebalanceStart() { verify(topologyManager).broadcastRebalanceStart(CACHE_NAME, status.getCurrentTopology(), JOIN_INFO.isTotalOrder(), JOIN_INFO.getCacheMode().isDistributed()); }
public void waitForClusterToForm(String cacheName, long timeout, TimeUnit timeUnit) { List<Cache<Object, Object>> caches = getCaches(cacheName); Cache<Object, Object> cache = caches.get(0); TestingUtil.blockUntilViewsReceived((int) timeUnit.toMillis(timeout), false, caches); if (cache.getCacheConfiguration().clustering().cacheMode().isDistributed()) { TestingUtil.waitForNoRebalance(caches); } }
public void waitForClusterToForm(String cacheName) { List<Cache<Object, Object>> caches = getCaches(cacheName); Cache<Object, Object> cache = caches.get(0); TestingUtil.blockUntilViewsReceived(10000, caches); if (cache.getCacheConfiguration().clustering().cacheMode().isDistributed()) { TestingUtil.waitForNoRebalance(caches); } }
@Override protected void configureCache(ConfigurationBuilder builder) { super.configureCache(builder); if (builder.clustering().cacheMode().isDistributed()) { builder.clustering().l1().enable(); } }
@Test public void testClusterListenerNodeGoesDown() { Cache<Object, String> cache0 = cache(0, CACHE_NAME); Cache<Object, String> cache1 = cache(1, CACHE_NAME); Cache<Object, String> cache2 = cache(2, CACHE_NAME); ClusterListener clusterListener = listener(); cache0.addListener(clusterListener); int cache1ListenerSize = cache1.getAdvancedCache().getListeners().size(); int cache2ListenerSize = cache2.getAdvancedCache().getListeners().size(); log.info("Killing node 0 .."); TestingUtil.killCacheManagers(manager(0)); cacheManagers.remove(0); log.info("Node 0 killed"); TestingUtil.blockUntilViewsReceived(60000, false, cache1, cache2); TestingUtil.waitForNoRebalance(cache1, cache2); assertEquals(cache1.getAdvancedCache().getListeners().size(), cache1ListenerSize - (cacheMode.isDistributed() ? 1 : 0)); assertEquals(cache2.getAdvancedCache().getListeners().size(), cache2ListenerSize - (cacheMode.isDistributed() ? 1 : 0)); }
@Test public void testSimpleClusterListenerRemoved() { Cache<Object, String> cache0 = cache(0, CACHE_NAME); Cache<Object, String> cache1 = cache(1, CACHE_NAME); Cache<Object, String> cache2 = cache(2, CACHE_NAME); int initialCache0ListenerSize = cache0.getAdvancedCache().getListeners().size(); int initialCache1ListenerSize = cache1.getAdvancedCache().getListeners().size(); int initialCache2ListenerSize = cache2.getAdvancedCache().getListeners().size(); ClusterListener clusterListener = listener(); cache0.addListener(clusterListener); // Adding a cluster listener should add to each node in cluster assertEquals(cache0.getAdvancedCache().getListeners().size(), initialCache0ListenerSize + 1); assertEquals(cache1.getAdvancedCache().getListeners().size(), initialCache1ListenerSize + (cacheMode.isDistributed() ? 1 : 0)); assertEquals(cache2.getAdvancedCache().getListeners().size(), initialCache2ListenerSize + (cacheMode.isDistributed() ? 1 : 0)); cache0.removeListener(clusterListener); assertEquals(cache0.getAdvancedCache().getListeners().size(), initialCache0ListenerSize); assertEquals(cache1.getAdvancedCache().getListeners().size(), initialCache1ListenerSize); assertEquals(cache2.getAdvancedCache().getListeners().size(), initialCache2ListenerSize); }
protected synchronized AccessDelegate createAccessDelegate(AccessType accessType) { if (accessType == null) { throw new IllegalArgumentException(); } if (this.accessType != null && !this.accessType.equals(accessType)) { throw new IllegalStateException("This region was already set up for " + this.accessType + ", cannot use using " + accessType); } this.accessType = accessType; CacheMode cacheMode = cache.getCacheConfiguration().clustering().cacheMode(); if (accessType == AccessType.NONSTRICT_READ_WRITE) { prepareForVersionedEntries(cacheMode); return new NonStrictAccessDelegate(this, getCacheDataDescription().getVersionComparator()); } if (cacheMode.isDistributed() || cacheMode.isReplicated()) { prepareForTombstones(cacheMode); return new TombstoneAccessDelegate(this); } else { prepareForValidation(); if (cache.getCacheConfiguration().transaction().transactionMode().isTransactional()) { return new TxInvalidationCacheAccessDelegate(this, validator); } else { return new NonTxInvalidationCacheAccessDelegate(this, validator); } } }
@Override public void init(InitializationContext ctx) { this.configuration = ctx.getConfiguration(); this.cacheName = ctx.getCache().getName(); this.globalConfiguration = ctx.getCache().getCacheManager().getCacheManagerConfiguration(); this.marshalledEntryFactory = ctx.getMarshalledEntryFactory(); this.marshaller = ctx.getMarshaller(); this.timeService = ctx.getTimeService(); this.keyPartitioner = configuration.segmented() ? ctx.getKeyPartitioner() : null; this.isDistributedCache = ctx.getCache().getCacheConfiguration() != null && ctx.getCache().getCacheConfiguration().clustering().cacheMode().isDistributed(); }
private ConfigurationBuilder getClusteredCfg(CacheMode mode, boolean l1) { ConfigurationBuilder cfg = getBaseCfg(); cfg .locking().lockAcquisitionTimeout(60000) .clustering().cacheMode(mode).remoteTimeout(60000).stateTransfer().fetchInMemoryState(false); if (mode.isDistributed()) { cfg.clustering().l1().enabled(l1).lifespan(120000); } return cfg; }
private void createEmbeddedCache() { GlobalConfigurationBuilder globalBuilder; if (cacheMode.isClustered()) { globalBuilder = new GlobalConfigurationBuilder(); globalBuilder.transport().defaultTransport(); } else { globalBuilder = new GlobalConfigurationBuilder().nonClusteredDefault(); } globalBuilder.addModule(PrivateGlobalConfigurationBuilder.class).serverMode(true); org.infinispan.configuration.cache.ConfigurationBuilder builder = new org.infinispan.configuration.cache.ConfigurationBuilder(); builder.clustering().cacheMode(cacheMode) .compatibility().enable().marshaller(marshaller); if (cacheMode.isDistributed() && numOwners != DEFAULT_NUM_OWNERS) { builder.clustering().hash().numOwners(numOwners); } if (cacheMode.isDistributed() && l1Enable) { builder.clustering().l1().enable(); } cacheManager = cacheMode.isClustered() ? TestCacheManagerFactory.createClusteredCacheManager(globalBuilder, builder) : TestCacheManagerFactory.createCacheManager(globalBuilder, builder); if (!cacheName.isEmpty()) cacheManager.defineConfiguration(cacheName, builder.build()); embeddedCache = cacheName.isEmpty() ? cacheManager.getCache() : cacheManager.getCache(cacheName); }
if (!cacheMode.isClustered() || cacheMode.isDistributed() && nodeCount == 1) { return;