@Override public void run() { cm2.startCaches(cacheName); } };
@Override public EmbeddedCacheManager startCaches(String... names) { Set<String> cacheNames = new LinkedHashSet<>(); for (String name: names) { cacheNames.add(this.getCacheName(name)); } this.cm.startCaches(cacheNames.toArray(new String[cacheNames.size()])); return this; }
@Test public void startCaches() { when(this.manager.startCaches("other", "default")).thenReturn(this.manager); EmbeddedCacheManager result = this.subject.startCaches("other", CacheContainer.DEFAULT_CACHE_NAME); assertSame(this.subject, result); } }
public void testStressGetEmptyCache() throws Exception { long start = System.nanoTime(); ConfigurationBuilder replConfig = getDefaultClusteredCacheConfig(CacheMode.REPL_SYNC, true); for (int i = 0; i < NUM_NODES; i++) { EmbeddedCacheManager cm = addClusterEnabledCacheManager(); defineConfigurationOnAllManagers("repl", replConfig); cm.startCaches("repl"); } System.out.println("Caches created: " + manager(0).getMembers()); System.out.println("Explicit txs: " + explicitTxs); System.out.println("Operation count: " + NUM_ITERATIONS + "m"); // Test the performance of get operations in an empty cache Cache<Object, Object> replCache0 = cache(0, "repl"); for (int i = 0; i < NUM_ITERATIONS * 1000000; i++) { if (explicitTxs) tm(0, "repl").begin(); Object o = replCache0.get("k" + i); assertNull(o); if (explicitTxs) tm(0, "repl").commit(); } long end = System.nanoTime(); System.out.println("Test took " + TimeUnit.NANOSECONDS.toSeconds(end - start) + "s"); } }
public void testParallelStartup() throws Exception { // start both caches in parallel cm1.startCaches("cache1", "cache2"); List memb1 = cm1.getMembers(); assert 1 == memb1.size() : "Expected 1 member; was " + memb1; Object coord = memb1.get(0); cm2 = addClusterEnabledCacheManager(); cm2.defineConfiguration("cache1", cfg.build()); cm2.defineConfiguration("cache2", cfg.build()); // again start both caches in parallel cm2.startCaches("cache1", "cache2"); TestingUtil.blockUntilViewsReceived(50000, true, cm1, cm2); memb1 = cm1.getMembers(); List memb2 = cm2.getMembers(); assert 2 == memb1.size(); assert memb1.equals(memb2); cm1.stop(); TestingUtil.blockUntilViewsReceived(50000, false, cm2); memb2 = cm2.getMembers(); assert 1 == memb2.size(); assert !coord.equals(memb2.get(0)); } }
cm2.startCaches("initialCache"); cm3.startCaches("initialCache"); cm3.startCaches(cacheName); assertEquals(cm3.getCache(cacheName).size(), 3); } finally {
@Override protected void createCacheManagers() throws Exception { GlobalConfigurationBuilder globalBuilder = new GlobalConfigurationBuilder(); globalBuilder.addModule(PrivateGlobalConfigurationBuilder.class).serverMode(true); GlobalConfigurationBuilder globalConfiguration = globalBuilder.clusteredDefault(); createCluster(globalConfiguration, getDefaultCacheBuilder(), NUM_SERVERS); for (EmbeddedCacheManager cm : cacheManagers) { this.defineCaches(cm); String[] cacheNames = cm.getCacheNames().toArray(new String[0]); cm.startCaches(cacheNames); cm.getClassWhiteList().addClasses(TestClass.class); waitForClusterToForm(cacheNames); RestServerHelper restServerHelper = new RestServerHelper(cm); restServerHelper.start(TestResourceTracker.getCurrentTestShortName()); restServers.add(restServerHelper); } client = new HttpClient(); client.start(); }
@Override protected void createCacheManagers() throws Throwable { configuration = super.configure(); configuration.transaction().recovery().recoveryInfoCacheName(CUSTOM_CACHE); registerCacheManager(TestCacheManagerFactory.createClusteredCacheManager(configuration)); registerCacheManager(TestCacheManagerFactory.createClusteredCacheManager(configuration)); recoveryCache = getDefaultClusteredCacheConfig(CacheMode.LOCAL, false); recoveryCache.transaction().transactionManagerLookup(null); // Explicitly disable recovery in recovery cache per se. recoveryCache.transaction().recovery().disable(); manager(0).defineConfiguration(CUSTOM_CACHE, recoveryCache.build()); manager(1).defineConfiguration(CUSTOM_CACHE, recoveryCache.build()); manager(0).startCaches(CacheContainer.DEFAULT_CACHE_NAME, CUSTOM_CACHE); manager(1).startCaches(CacheContainer.DEFAULT_CACHE_NAME, CUSTOM_CACHE); waitForClusterToForm(CUSTOM_CACHE); assert manager(0).getCacheNames().contains(CUSTOM_CACHE); assert manager(1).getCacheNames().contains(CUSTOM_CACHE); }
@Override protected void createCacheManagers() throws Throwable { ConfigurationBuilder config = getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC, true); config.clustering().l1().enable().hash().numOwners(1); config.locking().isolationLevel(IsolationLevel.READ_COMMITTED); createCluster(config, 2); manager(0).defineConfiguration("second", config.build()); manager(1).defineConfiguration("second", config.build()); manager(0).startCaches(CacheContainer.DEFAULT_CACHE_NAME, "second"); manager(1).startCaches(CacheContainer.DEFAULT_CACHE_NAME, "second"); waitForClusterToForm(CacheContainer.DEFAULT_CACHE_NAME, "second"); cache(0).put("k","v"); cache(0,"second").put("k","v"); assert cache(1).get("k").equals("v"); assert cache(1, "second").get("k").equals("v"); k0 = new MagicKey(cache(0)); }
@Override public void start(DirectoryBasedIndexManager indexManager) { log.debug("Starting InfinispanDirectory"); deletesExecutor = getDeleteOperationsExecutor(); validateCacheManagerConfiguration(); cacheManager.startCaches(metadataCacheName, dataCacheName, lockingCacheName); Cache<?, ?> metadataCache = cacheManager.getCache(metadataCacheName); Cache<?, ?> dataCache = cacheManager.getCache(dataCacheName); Cache<?, ?> lockingCache = cacheManager.getCache(lockingCacheName); org.infinispan.lucene.directory.BuildContext directoryBuildContext = DirectoryBuilder .newDirectoryInstance(metadataCache, dataCache, lockingCache, directoryProviderName) .writeFileListAsynchronously(writeFileListAsync) .deleteOperationsExecutor(isAsync ? new WithinThreadExecutor() : deletesExecutor.getExecutor()); if (chunkSize != null) { directoryBuildContext.chunkSize(chunkSize); } if (indexWriterLockFactory != null) { directoryBuildContext.overrideWriteLocker(indexWriterLockFactory); } if (affinityId >= 0) { directoryBuildContext.affinityLocationIntoSegment(affinityId); } directory = directoryBuildContext.create(); DirectoryHelper.initializeIndexIfNeeded(directory); log.debugf("Initialized Infinispan index: '%s'", directoryProviderName); }
@Test(expectedExceptions = CacheException.class) public void testStartCachesFailed() { EmbeddedCacheManager cacheManager = null; try { cacheManager = createCacheManager(); cacheManager.defineConfiguration("correct-cache-1", cacheManager.getDefaultCacheConfiguration()); cacheManager.defineConfiguration("correct-cache-2", cacheManager.getDefaultCacheConfiguration()); cacheManager.defineConfiguration("correct-cache-3", cacheManager.getDefaultCacheConfiguration()); ConfigurationBuilder incorrectBuilder = new ConfigurationBuilder(); incorrectBuilder.customInterceptors().addInterceptor().position(InterceptorConfiguration.Position.FIRST) .interceptor(new BaseCustomAsyncInterceptor() { @Override protected void start() { throw new IllegalStateException(); } }); cacheManager.defineConfiguration("incorrect", incorrectBuilder.build()); cacheManager.startCaches("correct-cache-1", "correct-cache-2", "correct-cache-3", "incorrect"); } finally { if (cacheManager != null) { killCacheManagers(cacheManager); } } }
protected void createCacheManagers() throws Throwable { ConfigurationBuilder c = new ConfigurationBuilder(); c.clustering().cacheMode(CacheMode.REPL_SYNC) .remoteTimeout(30000) .transaction().transactionMode(TransactionMode.TRANSACTIONAL) .invocationBatching().enable() .locking().lockAcquisitionTimeout(60000).useLockStriping(false); EmbeddedCacheManager container = TestCacheManagerFactory.createClusteredCacheManager(c); container.start(); registerCacheManager(container); container.defineConfiguration(TEST_CACHE, c.build()); container.startCaches(TEST_CACHE); Cache cache1 = container.getCache(TEST_CACHE); assert cache1.getCacheConfiguration().clustering().cacheMode().equals(CacheMode.REPL_SYNC); cache1.start(); container = TestCacheManagerFactory.createClusteredCacheManager(c); container.start(); registerCacheManager(container); container.defineConfiguration(TEST_CACHE, c.build()); container.startCaches(TEST_CACHE); Cache cache2 = container.getCache(TEST_CACHE); assert cache2.getCacheConfiguration().clustering().cacheMode().equals(CacheMode.REPL_SYNC); }