org.infinispan.configuration.global.GlobalConfigurationBuilder builder = new org.infinispan.configuration.global.GlobalConfigurationBuilder(); if (this.defaultCache != null) { builder.defaultCacheName(this.defaultCache);
@Override protected EmbeddedCacheManager createCacheManager() throws Exception { return TestCacheManagerFactory.createCacheManager(new GlobalConfigurationBuilder().defaultCacheName(cacheName), new ConfigurationBuilder()); } }
@Override protected EmbeddedCacheManager createCacheManager() throws Exception { return TestCacheManagerFactory.createCacheManager( new GlobalConfigurationBuilder().defaultCacheName(CACHE_NAME), new ConfigurationBuilder() ); }
@Override protected EmbeddedCacheManager createCacheManager() throws Exception { return TestCacheManagerFactory.createCacheManager( new GlobalConfigurationBuilder().defaultCacheName(CACHE_NAME), new ConfigurationBuilder() ); }
protected EmbeddedCacheManager createTestCacheManager() { return TestCacheManagerFactory.createCacheManager( new GlobalConfigurationBuilder().nonClusteredDefault().defaultCacheName(cacheName), hotRodCacheConfiguration()); }
static EmbeddedCacheManager getCacheManager(Properties properties) { StoreProperties props = new StoreProperties(TARGET, properties); GlobalConfigurationBuilder globalBuilder = new GlobalConfigurationBuilder(); globalBuilder.defaultCacheName(DEFAULT_CACHE_NAME); SerializationConfigUtil.configureSerialization(props, globalBuilder.serialization()); GlobalConfiguration globalConfig = globalBuilder.build(); return new DefaultCacheManager(globalConfig, new ConfigurationBuilder().build()); }
public static StreamingMarshaller getMarshaller(StoreProperties props) { switch (getMarshallerType(props)) { case CURRENT: if (props.isTargetStore()) return null; GlobalConfigurationBuilder globalConfig = new GlobalConfigurationBuilder() .defaultCacheName(props.cacheName()); configureExternalizers(props, globalConfig.serialization()); EmbeddedCacheManager manager = new DefaultCacheManager(globalConfig.build(), new ConfigurationBuilder().build()); return manager.getCache().getAdvancedCache().getComponentRegistry().getComponent(StreamingMarshaller.class); case CUSTOM: String marshallerClass = props.get(MARSHALLER, CLASS); if (marshallerClass == null) throw new CacheConfigurationException( String.format("The property %s.%s must be set if a custom marshaller type is specified", MARSHALLER, CLASS)); try { return (StreamingMarshaller) Util.loadClass(marshallerClass, SerializationConfigUtil.class.getClassLoader()).newInstance(); } catch (IllegalAccessException | InstantiationException e) { throw new CacheConfigurationException(String.format("Unable to load StreamingMarshaller '%s' for %s store", marshallerClass, SOURCE), e); } case LEGACY: if (props.isTargetStore()) throw new CacheConfigurationException("The legacy marshaller can only be specified for source stores."); return new LegacyVersionAwareMarshaller(getExternalizersFromProps(props)); default: throw new IllegalStateException("Unexpected marshaller type"); } }
@Override public EmbeddedCacheManager createCacheManager() { ConfigurationBuilder builder = new ConfigurationBuilder(); builder.persistence() .addStore(DummyInMemoryStoreConfigurationBuilder.class) .storeName(getClass().getName()); EmbeddedCacheManager cacheManager = TestCacheManagerFactory.createCacheManager( new GlobalConfigurationBuilder().nonClusteredDefault().defaultCacheName(cacheName), builder); advancedCache = cacheManager.<byte[], byte[]>getCache(cacheName).getAdvancedCache(); return cacheManager; }
public MockClient(String cacheName, MockChannel mockChannel) { this.cacheName = cacheName; this.ctx = new MockChannelHandlerContext(mockChannel); cacheContainer = TestCacheManagerFactory.createCacheManager(new GlobalConfigurationBuilder().defaultCacheName(cacheName), new ConfigurationBuilder()); cache = cacheContainer.getCache(cacheName); }
@Test public void testIfSpringEmbeddedCacheManagerFactoryBeanStopsTheCreatedEmbeddedCacheManagerWhenBeingDestroyed() throws Exception { GlobalConfigurationBuilder builder = new GlobalConfigurationBuilder(); builder.defaultCacheName("default"); objectUnderTest = SpringEmbeddedCacheManagerFactoryBeanBuilder .defaultBuilder().withGlobalConfiguration(builder).build(); final SpringEmbeddedCacheManager springEmbeddedCacheManager = objectUnderTest.getObject(); springEmbeddedCacheManager.getCache("default"); // Implicitly starts // SpringEmbeddedCacheManager objectUnderTest.destroy(); assertEquals( "SpringEmbeddedCacheManagerFactoryBean should stop the created SpringEmbeddedCacheManager when being destroyed. " + "However, the created SpringEmbeddedCacheManager is still not terminated.", ComponentStatus.TERMINATED, springEmbeddedCacheManager.getNativeCacheManager() .getStatus()); }
@Test public void testIfSpringEmbeddedCacheManagerFactoryBeanStopsTheCreatedEmbeddedCacheManagerWhenBeingDestroyed() throws Exception { GlobalConfigurationBuilder builder = new GlobalConfigurationBuilder(); builder.defaultCacheName("default"); objectUnderTest = SpringEmbeddedCacheManagerFactoryBeanBuilder .defaultBuilder().withGlobalConfiguration(builder).build(); final SpringEmbeddedCacheManager springEmbeddedCacheManager = objectUnderTest.getObject(); springEmbeddedCacheManager.getCache("default"); // Implicitly starts // SpringEmbeddedCacheManager objectUnderTest.destroy(); assertEquals( "SpringEmbeddedCacheManagerFactoryBean should stop the created SpringEmbeddedCacheManager when being destroyed. " + "However, the created SpringEmbeddedCacheManager is still not terminated.", ComponentStatus.TERMINATED, springEmbeddedCacheManager.getNativeCacheManager() .getStatus()); }
@BeforeMethod public void beforeClass() { ConfigurationBuilder cc = TestCacheManagerFactory.getDefaultCacheConfiguration(true); JdbcStringBasedStoreConfigurationBuilder storeBuilder = cc .persistence() .addStore(JdbcStringBasedStoreConfigurationBuilder.class) .shared(true) .transactional(true); UnitTestDatabaseManager.configureUniqueConnectionFactory(storeBuilder); UnitTestDatabaseManager.setDialect(storeBuilder); UnitTestDatabaseManager.buildTableManipulation(storeBuilder.table()); cacheManager = TestCacheManagerFactory.createCacheManager(new GlobalConfigurationBuilder().defaultCacheName("Test"), cc); cache = cacheManager.getCache("Test"); store = TestingUtil.getFirstTxWriter(cache); }
@Override protected EmbeddedCacheManager createCacheManager() throws Exception { GlobalConfigurationBuilder gcb = new GlobalConfigurationBuilder(); gcb.defaultCacheName("default"); ConfigurationBuilder c = getDefaultStandaloneCacheConfig(true); c.jmxStatistics().enable().dataContainer().invocationBatching().enable().locking().isolationLevel(IsolationLevel.READ_COMMITTED); EmbeddedCacheManager cm = TestCacheManagerFactory.createCacheManager(gcb, c); return cm; }
org.infinispan.configuration.global.GlobalConfigurationBuilder builder = new org.infinispan.configuration.global.GlobalConfigurationBuilder(); if (this.defaultCache != null) { builder.defaultCacheName(this.defaultCache);
public void testAddRemoveListenerWhileNotRunning() throws Exception { GetCacheManagerCheckListener listener = new GetCacheManagerCheckListener(); ConfigurationBuilderHolder holder = new ConfigurationBuilderHolder(); holder.getGlobalConfigurationBuilder().clusteredDefault().defaultCacheName("default"); holder.newConfigurationBuilder("default").clustering().cacheMode(CacheMode.DIST_SYNC); EmbeddedCacheManager cmA = TestCacheManagerFactory.createClusteredCacheManager(false, holder, false); EmbeddedCacheManager cmB = null; try { cmA.addListener(listener); cmA.getCache(); cmB = TestCacheManagerFactory.createClusteredCacheManager(); cmB.getCache(); assertNotNull(listener.firstEvent.get(10, TimeUnit.SECONDS)); } finally { TestingUtil.killCacheManagers(cmA, cmB); } // Should not throw an exception? cmA.removeListener(listener); }
new GlobalConfigurationBuilder().defaultCacheName(REMOTE_CACHE), hotRodCacheConfiguration(localBuilder));
@Override protected void createCacheManagers() throws Throwable { createCluster(holder -> { String defaultName = "default"; holder.getGlobalConfigurationBuilder().defaultCacheName(defaultName); ConfigurationBuilder cacheCfg = getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC, false); cacheCfg.indexing() .index(Index.PRIMARY_OWNER) .addIndexedEntity(Car.class) .addProperty("default.indexmanager", InfinispanIndexManager.class.getName()) .addProperty("error_handler", StaticTestingErrorHandler.class.getName()) .addProperty("lucene_version", "LUCENE_CURRENT"); cacheCfg.clustering().stateTransfer().fetchInMemoryState(true); holder.newConfigurationBuilder(defaultName).read(cacheCfg.build()); Configuration cacheCfg1 = getDefaultClusteredCacheConfig(CacheMode.REPL_SYNC, false) .clustering().stateTransfer().fetchInMemoryState(true).build(); holder.newConfigurationBuilder(InfinispanIntegration.DEFAULT_INDEXESDATA_CACHENAME).read(cacheCfg1); holder.newConfigurationBuilder(InfinispanIntegration.DEFAULT_LOCKING_CACHENAME).read(cacheCfg1); }, NUM_NODES); caches.addAll(caches()); }
@Override protected void createCacheManagers() throws Throwable { createCluster(holder -> { String defaultName = "default"; holder.getGlobalConfigurationBuilder().defaultCacheName(defaultName); ConfigurationBuilder cacheCfg = getDefaultClusteredCacheConfig(CacheMode.REPL_SYNC, transactionsEnabled()); cacheCfg.indexing() .index(Index.PRIMARY_OWNER) .addIndexedEntity(Person.class) .addProperty("default.indexmanager", "org.infinispan.query.indexmanager.InfinispanIndexManager") .addProperty("error_handler", "org.infinispan.query.helper.StaticTestingErrorHandler") .addProperty("lucene_version", "LUCENE_CURRENT"); cacheCfg.clustering().stateTransfer().fetchInMemoryState(true); enhanceConfig(cacheCfg); holder.newConfigurationBuilder(defaultName).read(cacheCfg.build()); Configuration cacheCfg1 = getDefaultClusteredCacheConfig(CacheMode.REPL_SYNC, false) .clustering().stateTransfer().fetchInMemoryState(true).build(); holder.newConfigurationBuilder(InfinispanIntegration.DEFAULT_INDEXESDATA_CACHENAME).read(cacheCfg1); holder.newConfigurationBuilder(InfinispanIntegration.DEFAULT_LOCKING_CACHENAME).read(cacheCfg1); }, 2); cache1 = cache(0); cache2 = cache(1); }
@Override protected AdvancedLoadWriteStore createStore() throws Exception { ConfigurationBuilder localBuilder = TestCacheManagerFactory.getDefaultCacheConfiguration(false); localBuilder.memory().evictionType(EvictionType.COUNT).size(WRITE_DELETE_BATCH_MAX_ENTRIES) .expiration().wakeUpInterval(10L); localCacheManager = TestCacheManagerFactory.createCacheManager( new GlobalConfigurationBuilder().defaultCacheName(REMOTE_CACHE), hotRodCacheConfiguration(localBuilder)); localCacheManager.getCache(REMOTE_CACHE); TestingUtil.replaceComponent(localCacheManager, TimeService.class, timeService, true); localCacheManager.getCache(REMOTE_CACHE).getAdvancedCache().getComponentRegistry().rewire(); hrServer = HotRodClientTestingUtil.startHotRodServer(localCacheManager); ConfigurationBuilder builder = TestCacheManagerFactory.getDefaultCacheConfiguration(false); RemoteStoreConfigurationBuilder storeConfigurationBuilder = builder .persistence() .addStore(RemoteStoreConfigurationBuilder.class) .rawValues(true) .remoteCacheName(REMOTE_CACHE); storeConfigurationBuilder .addServer() .host(hrServer.getHost()) .port(hrServer.getPort()); RemoteStore remoteStore = new RemoteStore(); remoteStore.init(createContext(builder.build())); return remoteStore; }