private void disableWithClusteredConfiguration(ConfigurationBuilder builder) { EmbeddedCacheManager cacheManager = null; try { cacheManager = TestCacheManagerFactory.createClusteredCacheManager(builder); checkAndDisableStore(cacheManager); } finally { TestingUtil.killCacheManagers(cacheManager); } } }
/** * Creates an cache manager that does support clustering. */ public static EmbeddedCacheManager createClusteredCacheManager() { return createClusteredCacheManager(new ConfigurationBuilder(), new TransportFlags()); }
private void assertCacheConfiguration(String config) throws IOException { ConfigurationBuilderHolder holder = parseToHolder(config); withCacheManager(new CacheManagerCallable(TestCacheManagerFactory.createClusteredCacheManager(holder)) { @Override public void call() { Assert.assertEquals(cm.getDefaultCacheConfiguration().module(MyModuleConfiguration.class).attribute(), "test-value"); } }); }
@BeforeClass private void init() { cacheManager = TestCacheManagerFactory.createClusteredCacheManager(); internalCacheRegistry = cacheManager.getGlobalComponentRegistry().getComponent(InternalCacheRegistry.class); clusterHealth = new ClusterHealthImpl(cacheManager); }
@Override protected void createCacheManagers() throws Throwable { ConfigurationBuilder config = getDefaultClusteredCacheConfig(CacheMode.REPL_SYNC, true); registerCacheManager(TestCacheManagerFactory.createClusteredCacheManager(config)); registerCacheManager(TestCacheManagerFactory.createClusteredCacheManager(config)); TestingUtil.blockUntilViewsReceived(10000, cache(0), cache(1)); }
private EmbeddedCacheManager createCacheManager() { EmbeddedCacheManager cm = TestCacheManagerFactory.createClusteredCacheManager(); ConfigurationBuilder cfg = getDefaultClusteredCacheConfig(CacheMode.REPL_SYNC, false); cm.defineConfiguration(CACHE_NAME, cfg.build()); return cm; } }
@Override protected void createCacheManagers() { for (int i = 0; i < 2; i++) { EmbeddedCacheManager cm = TestCacheManagerFactory.createClusteredCacheManager(hotRodCacheConfiguration()); cacheManagers.add(cm); if (i == 0) { cm.defineConfiguration(cacheName(), createCacheConfig().build()); } } }
@Override protected void createCacheManagers() throws Throwable { GlobalConfigurationBuilder globalCfg1 = createForeignExternalizerGlobalConfig(); GlobalConfigurationBuilder globalCfg2 = createForeignExternalizerGlobalConfig(); ConfigurationBuilder cfg = getDefaultClusteredCacheConfig(CacheMode.REPL_SYNC, false); CacheContainer cm1 = TestCacheManagerFactory.createClusteredCacheManager(globalCfg1, cfg); CacheContainer cm2 = TestCacheManagerFactory.createClusteredCacheManager(globalCfg2, cfg); registerCacheManager(cm1, cm2); defineConfigurationOnAllManagers(getCacheName(), cfg); waitForClusterToForm(getCacheName()); }
@Override protected void createCacheManagers() throws Throwable { GlobalConfigurationBuilder globalCfg1 = createForeignExternalizerGlobalConfig(); GlobalConfigurationBuilder globalCfg2 = createForeignExternalizerGlobalConfig(); ConfigurationBuilder cfg = getDefaultClusteredCacheConfig(CacheMode.REPL_SYNC, false); CacheContainer cm1 = TestCacheManagerFactory.createClusteredCacheManager(globalCfg1, cfg); CacheContainer cm2 = TestCacheManagerFactory.createClusteredCacheManager(globalCfg2, cfg); registerCacheManager(cm1, cm2); defineConfigurationOnAllManagers(getCacheName(), cfg); waitForClusterToForm(getCacheName()); }
@Override protected void createCacheManagers() throws Throwable { ConfigurationBuilder cfg = getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC, true); cfg .locking().lockAcquisitionTimeout(TestingUtil.shortTimeoutMillis()) .transaction().lockingMode(LockingMode.PESSIMISTIC); EmbeddedCacheManager cm1 = TestCacheManagerFactory.createClusteredCacheManager(cfg); EmbeddedCacheManager cm2 = TestCacheManagerFactory.createClusteredCacheManager(cfg); registerCacheManager(cm1, cm2); c1 = cm1.getCache(); c2 = cm2.getCache(); }
@Override protected void createCacheManagers() throws Throwable { for (int i = 0; i < CLUSTER_SIZE; i++) { GlobalConfigurationBuilder gc = GlobalConfigurationBuilder.defaultClusteredBuilder(); gc.transport().initialClusterSize(CLUSTER_SIZE).initialClusterTimeout(CLUSTER_TIMEOUT_SECONDS, TimeUnit.SECONDS); cacheManagers.add(TestCacheManagerFactory.createClusteredCacheManager(false, gc, getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC), new TransportFlags().withPortRange(i), false)); } }
@Test public void testIndexingOnCacheItself() throws CyclicDependencyException { EmbeddedCacheManager cacheManager = createClusteredCacheManager(); cacheManager.defineConfiguration("single", getIndexedConfigWithCustomCaches("single", "single", "single").build()); startAndIndexData("single", cacheManager); cacheManager.stop(); assertEquals(cacheManager.getStatus(), ComponentStatus.TERMINATED); }
private EmbeddedCacheManager createCacheManager() { ConfigurationBuilder c = TestCacheManagerFactory.getDefaultCacheConfiguration(false); c.clustering().cacheMode(CacheMode.REPL_SYNC) .transaction().transactionMode(TransactionMode.NON_TRANSACTIONAL); GlobalConfigurationBuilder gc = GlobalConfigurationBuilder.defaultClusteredBuilder(); return TestCacheManagerFactory.createClusteredCacheManager(gc, c); }
private void withClusteredServer(HotRodServerConfigurationBuilder builder, BiConsumer<Configuration, Long> consumer) { Stoppable.useCacheManager(TestCacheManagerFactory.createClusteredCacheManager(hotRodCacheConfiguration()), cm -> Stoppable.useServer(startHotRodServer(cm, serverPort(), builder), server -> { Configuration cfg = cm.getCacheConfiguration(server.getConfiguration().topologyCacheName()); consumer.accept(cfg, cm.getCacheManagerConfiguration().transport().distributedSyncTimeout()); })); }
private CacheContainer createManager(ConfigurationBuilder builder) { GlobalConfigurationBuilder gcb1 = GlobalConfigurationBuilder.defaultClusteredBuilder(); gcb1.globalJmxStatistics().enable().jmxDomain(jmxDomain) .mBeanServerLookup(new PerThreadMBeanServerLookup()); CacheContainer cacheManager = TestCacheManagerFactory.createClusteredCacheManager(gcb1, builder, new TransportFlags(), true); cacheManager.start(); return cacheManager; }
public void testStoppedCacheForDistributedExecutor() { ConfigurationBuilder config = TestCacheManagerFactory.getDefaultCacheConfiguration(true); config.clustering().cacheMode(CacheMode.REPL_SYNC); EmbeddedCacheManager cacheManager = TestCacheManagerFactory.createClusteredCacheManager(config); try { Cache<Object, Object> cache = cacheManager.getCache(); cache.stop(); expectException(IllegalStateException.class, () -> new DefaultExecutorService(cache)); } finally { TestingUtil.killCacheManagers(cacheManager); } }
@Override protected EmbeddedCacheManager createCacheManager() throws Exception { ConfigurationBuilder builder = getDefaultStandaloneCacheConfig(false); builder.clustering().cacheMode(CacheMode.DIST_SYNC) .hash().numOwners(2).numSegments(2); configurePersistence(builder); configureEviction(builder); return TestCacheManagerFactory.createClusteredCacheManager(builder); }
@Override protected void createCacheManagers() throws Throwable { ConfigurationBuilder cfg = getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC, true); cfg.clustering().hash().numOwners(NUM_CACHES) .locking().lockAcquisitionTimeout(TestingUtil.shortTimeoutMillis()); for (int i = 0; i < NUM_CACHES; i++) { EmbeddedCacheManager cm = TestCacheManagerFactory.createClusteredCacheManager(cfg); registerCacheManager(cm); } waitForClusterToForm(); }
@BeforeClass public void setUp() { // Use a clustered cache manager to be able to test global marshaller interaction too GlobalConfigurationBuilder globalBuilder = GlobalConfigurationBuilder.defaultClusteredBuilder(); globalBuilder.serialization().addAdvancedExternalizer(new PojoWithExternalAndInternal.Externalizer()); globalBuilder.serialization().addAdvancedExternalizer(new PojoWithExternalizer.Externalizer()); globalBuilder.serialization().addAdvancedExternalizer(new PojoWithMultiExternalizer.Externalizer()); ConfigurationBuilder builder = new ConfigurationBuilder(); builder.clustering().cacheMode(CacheMode.DIST_SYNC); cm = TestCacheManagerFactory.createClusteredCacheManager(globalBuilder, builder); marshaller = extractGlobalMarshaller(cm); }
@Test public void testIndexingHierarchically() throws CyclicDependencyException { EmbeddedCacheManager cacheManager = createClusteredCacheManager(); cacheManager.defineConfiguration("cacheC", getIndexedConfigWithCustomCaches("cacheB", "cacheB", "cacheB").build()); cacheManager.defineConfiguration("cacheB", getIndexedConfigWithCustomCaches("cacheA", "cacheA", "cacheA").build()); cacheManager.defineConfiguration("cacheA", getIndexedConfig().build()); startAndIndexData("cacheA", cacheManager); startAndIndexData("cacheB", cacheManager); startAndIndexData("cacheC", cacheManager); cacheManager.stop(); assertEquals(cacheManager.getStatus(), ComponentStatus.TERMINATED); }