@Override public void accept(ConfigurationBuilder builder) { super.accept(builder); builder.clustering() .biasAcquisition((this.biasLifespan > 0) ? BiasAcquisition.ON_WRITE : BiasAcquisition.NEVER) .biasLifespan(this.biasLifespan, TimeUnit.MILLISECONDS) .invalidationBatchSize(this.invalidationBatchSize) ; }
@Override public void accept(ConfigurationBuilder builder) { super.accept(builder); builder.clustering() .biasAcquisition((this.biasLifespan > 0) ? BiasAcquisition.ON_WRITE : BiasAcquisition.NEVER) .biasLifespan(this.biasLifespan, TimeUnit.MILLISECONDS) .invalidationBatchSize(this.invalidationBatchSize) ; }
@Override protected ConfigurationBuilder buildConfiguration() { ConfigurationBuilder builder = super.buildConfiguration(); builder.clustering().biasAcquisition(biasAcquisition); return builder; }
@Override protected void createCacheManagers() throws Throwable { ConfigurationBuilder dcc = getDefaultClusteredCacheConfig(cacheMode, transactional); if (biasAcquisition != null) { dcc.clustering().biasAcquisition(biasAcquisition); } createCluster(dcc, 2); waitForClusterToForm(); }
@Override protected void createCacheManagers() throws Throwable { ConfigurationBuilder builder = getDefaultClusteredCacheConfig(cacheMode, false); if (biasAcquisition != null) { builder.clustering().biasAcquisition(biasAcquisition); } createCluster(builder, 4); waitForClusterToForm(); }
@Override protected void createCacheManagers() throws Throwable { ConfigurationBuilder dcc = getDefaultClusteredCacheConfig(cacheMode, false); if (biasAcquisition != null) { dcc.clustering().biasAcquisition(biasAcquisition); } dcc.clustering().l1().disable(); createClusteredCaches(nodes, dcc); }
@Override protected void createCacheManagers() throws Throwable { ConfigurationBuilder builder = getDefaultClusteredCacheConfig(cacheMode, false); if (biasAcquisition != null) { builder.clustering().biasAcquisition(biasAcquisition); } builder.clustering().hash().numSegments(60); createClusteredCaches(2, builder); }
@Override protected void createCacheManagers() throws Throwable { ConfigurationBuilder builder = getDefaultClusteredCacheConfig(CacheMode.SCATTERED_SYNC, false); builder.clustering().biasAcquisition(BiasAcquisition.ON_WRITE); // Scan biases frequently builder.expiration().wakeUpInterval(100); createCluster(builder, 3); waitForClusterToForm(); Arrays.stream(managers()).forEach( cm -> TestingUtil.replaceComponent(cm, TimeService.class, timeService, true)); rpcManager0 = ControlledRpcManager.replaceRpcManager(cache(0)); rpcManager1 = CountingRpcManager.replaceRpcManager(cache(1)); TestingUtil.wrapInboundInvocationHandler(cache(0), handler -> handler0 = new RenewWaitingInvocationHandler(handler)); }
@Override protected void createCacheManagers() throws Throwable { ConfigurationBuilder localBuilder = new ConfigurationBuilder(); configureCache(localBuilder); createClusteredCaches(numNodes, localBuilder); // Create distributed caches ConfigurationBuilder distBuilder = new ConfigurationBuilder(); distBuilder.clustering().cacheMode(isSync ? CacheMode.DIST_SYNC : CacheMode.DIST_ASYNC).hash().numOwners(numDistOwners); configureCache(distBuilder); cacheManagers.stream().forEach(cm -> cm.defineConfiguration(DIST, distBuilder.build())); // Create replicated caches ConfigurationBuilder replBuilder = new ConfigurationBuilder(); replBuilder.clustering().cacheMode(isSync ? CacheMode.REPL_SYNC : CacheMode.REPL_ASYNC); configureCache(replBuilder); cacheManagers.stream().forEach(cm -> cm.defineConfiguration(REPL, replBuilder.build())); // Create scattered caches if (!Boolean.TRUE.equals(transactional)) { ConfigurationBuilder scatteredBuilder = new ConfigurationBuilder(); scatteredBuilder.clustering().cacheMode(CacheMode.SCATTERED_SYNC); if (biasAcquisition != null) { scatteredBuilder.clustering().biasAcquisition(biasAcquisition); } configureCache(scatteredBuilder); cacheManagers.stream().forEach(cm -> cm.defineConfiguration(SCATTERED, scatteredBuilder.build())); } // Wait for cluster to form waitForClusterToForm(DIST, REPL, SCATTERED); }
@Override protected void createCacheManagers() throws Throwable { ConfigurationBuilder dcc = getDefaultClusteredCacheConfig(cacheMode, transactional); dcc.transaction().lockingMode(lockingMode); if (writeSkewCheck) { dcc.transaction().locking().isolationLevel(IsolationLevel.REPEATABLE_READ); } if (biasAcquisition != null) { dcc.clustering().biasAcquisition(biasAcquisition); } createCluster(dcc, nodes); waitForClusterToForm(); }
@Override protected void createCacheManagers() throws Throwable { ConfigurationBuilder cfg = getDefaultClusteredCacheConfig(CacheMode.SCATTERED_SYNC, false); if (biasAcquisition != null) { cfg.clustering().biasAcquisition(biasAcquisition); } cfg.clustering().hash().numSegments(16); cfg.clustering().remoteTimeout(1, TimeUnit.DAYS); // for debugging cm1 = TestCacheManagerFactory.createClusteredCacheManager(cfg); cm2 = TestCacheManagerFactory.createClusteredCacheManager(cfg); cm3 = TestCacheManagerFactory.createClusteredCacheManager(cfg); registerCacheManager(cm1, cm2, cm3); // Starting caches and rewiring SVM is not synchronized properly, so we have to first start // them and then rewire for (EmbeddedCacheManager cm : cacheManagers) cm.getCache(); TestingUtil.waitForNoRebalance(caches()); svms = caches().stream().map(c -> { ControlledScatteredVersionManager csvm = new ControlledScatteredVersionManager(); BasicComponentRegistry bcr = c.getAdvancedCache().getComponentRegistry().getComponent(BasicComponentRegistry.class); bcr.replaceComponent(ScatteredVersionManager.class.getName(), csvm, true); bcr.rewire(); return csvm; }).toArray(ControlledScatteredVersionManager[]::new); }
@Override protected void createCacheManagers() throws Throwable { ConfigurationBuilder builder = getDefaultClusteredCacheConfig(CacheMode.SCATTERED_SYNC, false); builder.clustering().biasAcquisition(BiasAcquisition.ON_WRITE).remoteTimeout(1000); createCluster(builder, 3); TestingUtil.wrapComponent(cache(0), RpcManager.class, rpcManager -> rpcManager0 = new FailingRpcManager(rpcManager)); cache(1); // just touch to start it TestingUtil.wrapComponent(cache(2), RpcManager.class, rpcManager -> rpcManager2 = new CountingRpcManager(rpcManager)); }
@Override protected void createCacheManagers() throws Throwable { defaultConfig = getDefaultClusteredCacheConfig(CacheMode.SCATTERED_SYNC, false); defaultConfig.clustering().hash().numSegments(16); defaultConfig.clustering().biasAcquisition(biasAcquisition); defaultConfig.clustering().stateTransfer().fetchInMemoryState(true).chunkSize(3); createClusteredCaches(3, defaultConfig, TRANSPORT_FLAGS, CACHE_NAME); c1 = cache(0, CACHE_NAME); c2 = cache(1, CACHE_NAME); c3 = cache(2, CACHE_NAME); } }
@Override protected void createCacheManagers() { GlobalConfigurationBuilder gcb = GlobalConfigurationBuilder.defaultClusteredBuilder(); if (useTriangle == Boolean.FALSE) { gcb.addModule(PrivateGlobalConfigurationBuilder.class).serverMode(true); } ConfigurationBuilder dcc = getDefaultClusteredCacheConfig(cacheMode, false); if (!cacheMode.isScattered()) { dcc.clustering().hash().numOwners(3).l1().disable(); } if (biasAcquisition != null) { dcc.clustering().biasAcquisition(biasAcquisition); } createCluster(gcb, dcc, 3); waitForClusterToForm(); }
protected ConfigurationBuilder createCacheConfigBuilder() { ConfigurationBuilder c = getDefaultClusteredCacheConfig(cacheMode, transactional); if (!cacheMode.isScattered()) { c.clustering().hash().numOwners(100); } c.clustering().hash().numSegments(4); if (lockingMode != null) { c.transaction().lockingMode(lockingMode); } if (totalOrder != null && totalOrder) { c.transaction().transactionProtocol(TransactionProtocol.TOTAL_ORDER); } if (biasAcquisition != null) { c.clustering().biasAcquisition(biasAcquisition); } return c; }
@Override protected void createCacheManagers() throws Throwable { ConfigurationBuilder dcc = cacheConfiguration(); dcc.clustering().cacheMode(cacheMode).partitionHandling().whenSplit(partitionHandling).mergePolicy(mergePolicy); if (cacheMode == CacheMode.DIST_SYNC) { dcc.clustering().hash().numOwners(numberOfOwners); } if (biasAcquisition != null) { dcc.clustering().biasAcquisition(biasAcquisition); } createClusteredCaches(numMembersInCluster, dcc, new TransportFlags().withFD(true).withMerge(true)); waitForClusterToForm(); }
@Override protected void createCacheManagers() throws Throwable { builderUsed = new ConfigurationBuilder(); builderUsed.clustering().cacheMode(cacheMode); if (!cacheMode.isScattered()) { builderUsed.clustering().hash().numOwners(NUM_OWNERS); } builderUsed.clustering().stateTransfer().chunkSize(25000); // This is increased just for the put all command when doing full tracing builderUsed.clustering().remoteTimeout(12000); if (transactional) { builderUsed.transaction().transactionMode(TransactionMode.TRANSACTIONAL); } if (biasAcquisition != null) { builderUsed.clustering().biasAcquisition(biasAcquisition); } if (enableStore) { builderUsed.persistence() .addStore(DummyInMemoryStoreConfigurationBuilder.class) .shared(true) .storeName(PutMapCommandStressTest.class.toString()); } createClusteredCaches(CACHE_COUNT, CACHE_NAME, builderUsed); }
@Override protected void createCacheManagers() throws Throwable { ConfigurationBuilder cb = new ConfigurationBuilder(); chf = new ControlledConsistentHashFactory.Scattered(new int[] {0, 1, 2}); cb.clustering().cacheMode(CacheMode.SCATTERED_SYNC).hash().numSegments(3).consistentHashFactory(chf); if (biasAcquisition != null) { cb.clustering().biasAcquisition(biasAcquisition); } addClusterEnabledCacheManager(cb); // If the updated topologies from old coord come when it's no longer in the view these are ignored. // Therefore we have to delay the view. viewLatch = new CountDownLatch(1); GlobalConfigurationBuilder gcb = new GlobalConfigurationBuilder(); gcb.transport().transport(new DelayedViewJGroupsTransport(viewLatch)); addClusterEnabledCacheManager(gcb, cb); // we need distinct transport instances on manager(1) and (2) gcb.transport().transport(new DelayedViewJGroupsTransport(viewLatch)); addClusterEnabledCacheManager(gcb, cb); assertTrue(cache(0).getCacheManager().isCoordinator()); // start other caches cache(1); cache(2); waitForClusterToForm(); }
@Override protected void createCacheManagers() throws Throwable { ConfigurationBuilder builder = getDefaultClusteredCacheConfig(cacheMode, transactional, transactional); builder.clustering().hash().numSegments(3) .stateTransfer().fetchInMemoryState(true) .locking().lockAcquisitionTimeout(TestingUtil.shortTimeoutMillis()); if (transactional) { builder.transaction().transactionMode(TransactionMode.TRANSACTIONAL) .transactionManagerLookup(new EmbeddedTransactionManagerLookup()) .lockingMode(lockingMode); } if (biasAcquisition != null) { builder.clustering().biasAcquisition(biasAcquisition); } createCluster(builder, 3); waitForClusterToForm(); c0 = advancedCache(0); c1 = advancedCache(1); c2 = advancedCache(2); }
@Override protected void createCacheManagers() { cacheConfigBuilder = getDefaultClusteredCacheConfig(cacheMode, transactional, true); if (transactional) { cacheConfigBuilder.transaction().transactionMode(TransactionMode.TRANSACTIONAL) .transactionManagerLookup(new EmbeddedTransactionManagerLookup()); cacheConfigBuilder.transaction().lockingMode(lockingMode); if (lockingMode == LockingMode.OPTIMISTIC) { cacheConfigBuilder.locking().isolationLevel(IsolationLevel.REPEATABLE_READ); } } if (biasAcquisition != null) { cacheConfigBuilder.clustering().biasAcquisition(biasAcquisition); } cacheConfigBuilder.clustering().hash().numSegments(10) .l1().disable() .locking().lockAcquisitionTimeout(TestingUtil.shortTimeoutMillis()); cacheConfigBuilder.clustering().stateTransfer().fetchInMemoryState(true).awaitInitialTransfer(false); addClusterEnabledCacheManager(cacheConfigBuilder); waitForClusterToForm(); }