@Override public StateTransferConfiguration get() { boolean timeoutEnabled = this.timeout > 0; return new ConfigurationBuilder().clustering().stateTransfer() .chunkSize(this.chunkSize) .fetchInMemoryState(true) .awaitInitialTransfer(timeoutEnabled) .timeout(timeoutEnabled ? this.timeout : Long.MAX_VALUE) .create(); }
@Override public StateTransferConfiguration get() { boolean timeoutEnabled = this.timeout > 0; return new ConfigurationBuilder().clustering().stateTransfer() .chunkSize(this.chunkSize) .fetchInMemoryState(true) .awaitInitialTransfer(timeoutEnabled) .timeout(timeoutEnabled ? this.timeout : Long.MAX_VALUE) .create(); }
@BeforeClass public void setUp() { // create cache configuration ConfigurationBuilder cb = new ConfigurationBuilder(); cb.clustering().invocationBatching().enable() .clustering().cacheMode(CacheMode.DIST_SYNC) .clustering().stateTransfer().timeout(10000) .locking().lockAcquisitionTimeout(TestingUtil.shortTimeoutMillis()) .locking().isolationLevel(IsolationLevel.REPEATABLE_READ); configuration = cb.build(); mockExecutorService = mock(ExecutorService.class); cache = mock(Cache.class); when(cache.getName()).thenReturn("testCache"); rpcManager = mock(RpcManager.class); commandsFactory = mock(CommandsFactory.class); cacheNotifier = mock(ClusterCacheNotifier.class); persistenceManager = mock(PersistenceManager.class); dataContainer = mock(InternalDataContainer.class); transactionTable = mock(TransactionTable.class); stateTransferLock = mock(StateTransferLock.class); distributionManager = mock(DistributionManager.class); ef = mock(InternalEntryFactory.class); when(distributionManager.getCacheTopology()).thenAnswer(invocation -> cacheTopology); }
protected void createCacheManagers() throws Throwable { ConfigurationBuilder build = getDefaultClusteredCacheConfig(CacheMode.REPL_SYNC, true); build.clustering().stateTransfer().timeout(10000); createClusteredCaches(2, "replication", build); }
private void parseStateTransfer(final XMLExtendedStreamReader reader, final ConfigurationBuilder builder) throws XMLStreamException { for (int i = 0; i < reader.getAttributeCount(); i++) { ParseUtils.requireNoNamespaceAttribute(reader, i); String value = replaceProperties(reader.getAttributeValue(i)); Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i)); switch (attribute) { case FETCH_IN_MEMORY_STATE: builder.clustering().stateTransfer().fetchInMemoryState(Boolean.parseBoolean(value)); break; case AWAIT_INITIAL_TRANSFER: builder.clustering().stateTransfer().awaitInitialTransfer(Boolean.parseBoolean(value)); break; case TIMEOUT: builder.clustering().stateTransfer().timeout(Long.parseLong(value)); break; case CHUNK_SIZE: builder.clustering().stateTransfer().chunkSize(Integer.parseInt(value)); break; default: throw ParseUtils.unexpectedAttribute(reader, i); } } ParseUtils.requireNoContent(reader); }
builder.clustering().stateTransfer().timeout(timeout); builder.clustering().stateTransfer().chunkSize(chunkSize);
private ConfigurationBuilder configuration() { ConfigurationBuilder builder = getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC, false); builder.clustering() .hash() .numSegments(1) .numOwners(1) .consistentHashFactory(new SingleKeyConsistentHashFactory()) .stateTransfer() .timeout(30, TimeUnit.SECONDS); return builder; }
@Override protected void createCacheManagers() throws Throwable { ConfigurationBuilder c = getDefaultClusteredCacheConfig(isSync ? CacheMode.INVALIDATION_SYNC : CacheMode.INVALIDATION_ASYNC, false); c.clustering().stateTransfer().timeout(10000) .locking().lockAcquisitionTimeout(TestingUtil.shortTimeoutMillis()); createClusteredCaches(2, "invalidation", c); if (isSync) { c = getDefaultClusteredCacheConfig(CacheMode.INVALIDATION_SYNC, true); c.clustering().stateTransfer().timeout(10000) .locking().lockAcquisitionTimeout(TestingUtil.shortTimeoutMillis()); defineConfigurationOnAllManagers("invalidationTx", c); waitForClusterToForm("invalidationTx"); } }
@Override protected void createCacheManagers() throws Throwable { cchf = new ControlledConsistentHashFactory.Default(new int[][]{{0, 1}, {1, 2}, {2, 3}, {3, 0}}); configBuilder = getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC); configBuilder.clustering().partitionHandling().whenSplit(PartitionHandling.DENY_READ_WRITES); configBuilder.clustering().hash().numSegments(4).stateTransfer().timeout(30000); }
@Override protected void createCacheManagers() throws Throwable { configuration = getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC); configuration.transaction().transactionMode(TransactionMode.TRANSACTIONAL); configuration.locking().lockAcquisitionTimeout(60000).useLockStriping(false); configuration.clustering().stateTransfer().timeout(30, SECONDS); addClusterEnabledCacheManager(configuration); }
@Override protected void createCacheManagers() throws Throwable { ConfigurationBuilder builder = getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC); // cache stop takes quite long when the view splits builder.clustering().stateTransfer().timeout(10, TimeUnit.SECONDS); builder.clustering().remoteTimeout(5, TimeUnit.SECONDS); createCluster(builder, 3); waitForClusterToForm(); key = getKeyForCache(cache(1), cache(2)); }
@Override protected void createCacheManagers() throws Throwable { localConfig = new ConfigurationBuilder(); clusteredConfig = new ConfigurationBuilder(); clusteredConfig.clustering().cacheMode(CacheMode.REPL_SYNC).stateTransfer().timeout(30, TimeUnit.SECONDS); for (int i = 0; i < 2; i++) addClusterEnabledCacheManager(localConfig, new TransportFlags().withFD(true)); d1 = TestingUtil.getDiscardForCache(manager(0)); d2 = TestingUtil.getDiscardForCache(manager(1)); }
private ConfigurationBuilder getCB(){ ConfigurationBuilder cb = new ConfigurationBuilder(); cb.clustering() .cacheMode(CacheMode.DIST_SYNC) .remoteTimeout(60000) .stateTransfer().timeout(180000).fetchInMemoryState(true) .hash().numOwners(1); // transactions cb.transaction() .transactionMode(TransactionMode.TRANSACTIONAL) .lockingMode(LockingMode.PESSIMISTIC); // cb.transaction().transactionMode(TransactionMode.NON_TRANSACTIONAL); cb.persistence().passivation(false); // Make it really shared by adding the test's name as store name cb.persistence() .addStore(DummyInMemoryStoreConfigurationBuilder.class).preload(true).shared(true) .storeName(getClass().getSimpleName()).async() .disable(); return cb; }
@Override protected void createCacheManagers() throws Throwable { builderUsed = new ConfigurationBuilder(); builderUsed.clustering().cacheMode(cacheMode); builderUsed.clustering().hash().numOwners(3); builderUsed.clustering().stateTransfer().chunkSize(25000); // This is increased just for the put all command when doing full tracing builderUsed.clustering().remoteTimeout(12000000); // This way if an iterator gets stuck we know earlier builderUsed.clustering().stateTransfer().timeout(240, TimeUnit.SECONDS); createClusteredCaches(CACHE_COUNT, CACHE_NAME, builderUsed); }
@Override protected void createCacheManagers() throws Throwable { cfgBuilder = getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC, true); cfgBuilder.transaction().transactionManagerLookup(new EmbeddedTransactionManagerLookup()); cfgBuilder.clustering().hash().numOwners(2); cfgBuilder.clustering().stateTransfer().fetchInMemoryState(true); cfgBuilder.clustering().stateTransfer().timeout(20000); gcfgBuilder = new GlobalConfigurationBuilder(); gcfgBuilder.transport().transport(mockTransport); }
protected ConfigurationBuilder createTopologyCacheConfig(long distSyncTimeout) { ConfigurationBuilder builder = new ConfigurationBuilder(); builder.clustering().cacheMode(CacheMode.REPL_SYNC).remoteTimeout(configuration.topologyReplTimeout()) .locking().lockAcquisitionTimeout(configuration.topologyLockTimeout()) .clustering().partitionHandling().mergePolicy(null) .expiration().lifespan(-1).maxIdle(-1); if (configuration.topologyStateTransfer()) { builder .clustering() .stateTransfer() .awaitInitialTransfer(configuration.topologyAwaitInitialTransfer()) .fetchInMemoryState(true) .timeout(distSyncTimeout + configuration.topologyReplTimeout()); } else { builder.persistence().addClusterLoader().remoteCallTimeout(configuration.topologyReplTimeout()); } return builder; }
@Override protected void createCacheManagers() { tmpDir = new File(TestingUtil.tmpDirectory(this.getClass())); Util.recursiveFileRemove(tmpDir); // reproduce the MODE-1754 config as closely as possible builder = getDefaultClusteredCacheConfig(CacheMode.REPL_SYNC, true, true); builder.transaction().transactionMode(TransactionMode.TRANSACTIONAL).lockingMode(LockingMode.PESSIMISTIC) .transactionManagerLookup(new EmbeddedTransactionManagerLookup()) .memory().size(1000) .locking().lockAcquisitionTimeout(20000) .concurrencyLevel(5000) // lowering this to 50 makes the test pass also on 5.2 but it's just a temporary workaround .useLockStriping(false).isolationLevel(IsolationLevel.READ_COMMITTED) .dataContainer().storeAsBinary() .clustering().remoteTimeout(20000) .stateTransfer().timeout(240000).fetchInMemoryState(false).chunkSize(10000) .persistence().passivation(false).addSingleFileStore().location(new File(tmpDir, "store0").getAbsolutePath()).shared(false).preload(false) .fetchPersistentState(true) .ignoreModifications(false) .purgeOnStartup(false); createCluster(builder, 1); waitForClusterToForm(); }
private EmbeddedCacheManager createCacheManager(String name1, JChannel ch1) { GlobalConfigurationBuilder gcb1 = new GlobalConfigurationBuilder(); gcb1.transport().nodeName(ch1.getName()).distributedSyncTimeout(10, SECONDS); CustomChannelLookup.registerChannel(gcb1, ch1, name1, false); ConfigurationBuilder replCfg = new ConfigurationBuilder(); replCfg.clustering().cacheMode(CacheMode.REPL_SYNC); replCfg.clustering().stateTransfer().timeout(10, SECONDS); EmbeddedCacheManager cm1 = new DefaultCacheManager(gcb1.build(), replCfg.build(), false); registerCacheManager(cm1); cm1.defineConfiguration(CACHE_NAME, replCfg.build()); return cm1; }
replCfg.clustering().cacheMode(CacheMode.REPL_SYNC).stateTransfer().timeout(30, TimeUnit.SECONDS);
@Override protected void createCacheManagers() throws Throwable { cfgBuilder = getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC, true); cfgBuilder.transaction().transactionManagerLookup(new EmbeddedTransactionManagerLookup()); cfgBuilder.clustering().hash().numOwners(2); cfgBuilder.clustering().stateTransfer().fetchInMemoryState(true); cfgBuilder.clustering().stateTransfer().timeout(20000); GlobalConfigurationBuilder gcb0 = new GlobalConfigurationBuilder().clusteredDefault(); addClusterEnabledCacheManager(gcb0, cfgBuilder, new TransportFlags().withFD(true)); GlobalConfigurationBuilder gcb1 = new GlobalConfigurationBuilder().clusteredDefault(); addClusterEnabledCacheManager(gcb1, cfgBuilder, new TransportFlags().withFD(true)); }