@Override public void accept(org.infinispan.configuration.cache.ConfigurationBuilder builder) { builder.read(this.template.get()); }
void read() { Configuration c = (Configuration) options.get(Caching.CreateOption.CONFIGURATION); if (c != null) { builder.read(c); } } void mode() {
@Override public void accept(org.infinispan.configuration.cache.ConfigurationBuilder builder) { builder.read(this.template.get()); }
@Override protected ConfigurationBuilder getConfigurationBuilder() { return new ConfigurationBuilder().read(this.configuration.getValue()); }
/** * Overrides the default embedded cache manager. */ @Produces @ApplicationScoped @SuppressWarnings("unused") public EmbeddedCacheManager defaultCacheManager() throws IOException { EmbeddedCacheManager externalCacheContainerManager = TestCacheManagerFactory.fromXml("infinispan.xml"); externalCacheContainerManager.defineConfiguration("quick-very-large", new ConfigurationBuilder() .read(externalCacheContainerManager.getDefaultCacheConfiguration()) .expiration().wakeUpInterval(1l) .build()); return externalCacheContainerManager; }
/** * Overrides the default embedded cache manager. */ @Produces @ApplicationScoped @SuppressWarnings("unused") public EmbeddedCacheManager defaultCacheManager() throws IOException { EmbeddedCacheManager externalCacheContainerManager = TestCacheManagerFactory.fromXml("infinispan.xml"); externalCacheContainerManager.defineConfiguration("quick-very-large", new ConfigurationBuilder() .read(externalCacheContainerManager.getDefaultCacheConfiguration()) .expiration().wakeUpInterval(1l) .build()); return externalCacheContainerManager; }
/** * Get the cache with the given name from the cache manager. Can be used to request additional * caches from the cache manager that are not covered by explicit methods. * * @param name * @return */ public synchronized Cache getCacheByName(String name) { if(!cacheManager.cacheExists(name)) { cacheManager.defineConfiguration(name, new ConfigurationBuilder().read(defaultConfiguration).build()); } return cacheManager.getCache(name).getAdvancedCache().withFlags(Flag.SKIP_LOCKING, Flag.SKIP_CACHE_LOAD, Flag.SKIP_REMOTE_LOOKUP).getAdvancedCache().withFlags(Flag.SKIP_LOCKING, Flag.SKIP_CACHE_LOAD, Flag.SKIP_REMOTE_LOOKUP).getAdvancedCache().withFlags(Flag.SKIP_LOCKING, Flag.SKIP_CACHE_LOAD, Flag.SKIP_REMOTE_LOOKUP); }
@Test(expectedExceptions = CacheConfigurationException.class) public void testRecoveryAndAsyncCaches() { //Note: this configuration uses Xa Enlistment (see configs/recovery-enabled-config.xml). Configuration defaultConfig = cacheManager.getDefaultCacheConfiguration(); ConfigurationBuilder builder = new ConfigurationBuilder().read(defaultConfig); builder.clustering().cacheMode(CacheMode.REPL_ASYNC); builder.transaction().recovery().enable(); //it should throw an exception when try to build this configuration. builder.build(); }
public void createCacheTest() { ConfigurationBuilder builder = new ConfigurationBuilder(); builder.read(cacheManager.getDefaultCacheConfiguration()); builder.template(false); cacheManager.defineConfiguration("newCache", builder.build()); cacheManager.getCache("newCache"); }
ConfigurationBuilder newPreloadConfiguration(Configuration configuration, String storeName) { ConfigurationBuilder preloadingCfg = new ConfigurationBuilder(); preloadingCfg.read(configuration); preloadingCfg.persistence() .clearStores() .addStore(DummyInMemoryStoreConfigurationBuilder.class) .segmented(segmented) .preload(true) .storeName(storeName); return preloadingCfg; }
public void testOverrideWithStore() { final ConfigurationBuilder builder1 = new ConfigurationBuilder(); builder1.persistence().addStore(DummyInMemoryStoreConfigurationBuilder.class); cm = TestCacheManagerFactory.createCacheManager(builder1); ConfigurationBuilder builder2 = new ConfigurationBuilder(); builder2.read(cm.getDefaultCacheConfiguration()); builder2.memory().size(1000); Configuration configuration = cm.defineConfiguration("named", builder2.build()); assertEquals(1, configuration.persistence().stores().size()); }
public void testConfigCloning() { ConfigurationBuilder c = new ConfigurationBuilder(); c.memory().storageType(StorageType.BINARY); ConfigurationBuilder builder = new ConfigurationBuilder().read(c.build()); Configuration clone = builder.build(); assertEquals(StorageType.BINARY, clone.memory().storageType()); }
@Override protected void startInternal(MemcachedServerConfiguration configuration, EmbeddedCacheManager cacheManager) { if (cacheManager.getCacheConfiguration(configuration.defaultCacheName()) == null) { // Define the Memcached cache as clone of the default one cacheManager.defineConfiguration(configuration.defaultCacheName(), new ConfigurationBuilder().read(cacheManager.getDefaultCacheConfiguration()).build()); } ExpirationConfiguration expConfig = cacheManager.getCacheConfiguration(configuration.defaultCacheName()).expiration(); if (expConfig.lifespan() >= 0 || expConfig.maxIdle() >= 0) throw log.invalidExpiration(configuration.defaultCacheName()); Cache<byte[], byte[]> cache = cacheManager.getCache(configuration.defaultCacheName()); memcachedCache = cache.getAdvancedCache(); super.startInternal(configuration, cacheManager); }
@Override protected Cache<Object, Object> getCache() { cm.defineConfiguration("simple", new ConfigurationBuilder().read(cm.getDefaultCacheConfiguration()) .clustering().simpleCache(true) .jmxStatistics().available(false) .build()); Cache cache = cm.getCache("simple"); // without any listeners the notifications are ignored cache.addListener(new DummyListener()); return cache; }
public void testModuleConfiguration() { ConfigurationBuilder builder = new ConfigurationBuilder(); builder.addModule(MyModuleConfigurationBuilder.class).attribute("testValue"); Configuration configuration = builder.build(); assertEquals(configuration.module(MyModuleConfiguration.class).attribute(), "testValue"); ConfigurationBuilder secondBuilder = new ConfigurationBuilder(); secondBuilder.read(configuration); Configuration secondConfiguration = secondBuilder.build(); assertEquals(secondConfiguration.module(MyModuleConfiguration.class).attribute(), "testValue"); } }
public void testConfigOverriding() { ConfigurationBuilder c = new ConfigurationBuilder(); c.memory().storageType(StorageType.BINARY); ecm = TestCacheManagerFactory.createCacheManager(c); ecm.defineConfiguration("newCache", new ConfigurationBuilder().read(c.build()).memory().storageType(StorageType.OBJECT).build()); assertEquals(StorageType.OBJECT, ecm.getCache("newCache").getCacheConfiguration().memory().storageType()); }
public void testConfigurationOverride() throws Exception { ConfigurationBuilder defaultCfgBuilder = new ConfigurationBuilder(); defaultCfgBuilder.memory().size(200).storageType(StorageType.BINARY); cm = TestCacheManagerFactory.createCacheManager(defaultCfgBuilder); final ConfigurationBuilder cacheCfgBuilder = new ConfigurationBuilder().read(defaultCfgBuilder.build()); cm.defineConfiguration("my-cache", cacheCfgBuilder.build()); Cache<?, ?> cache = cm.getCache("my-cache"); assertEquals(200, cache.getCacheConfiguration().memory().size()); assertEquals(StorageType.BINARY, cache.getCacheConfiguration().memory().storageType()); }
public void testDefiningConfigurationOverridingBooleans() { EmbeddedCacheManager cm = createCacheManager(false); ConfigurationBuilder c = new ConfigurationBuilder(); c.memory().storageType(StorageType.BINARY); Configuration lazy = cm.defineConfiguration("storeAsBinary", c.build()); assertEquals(StorageType.BINARY, lazy.memory().storageType()); c = new ConfigurationBuilder().read(lazy); c.memory().storageType(StorageType.OFF_HEAP).size(1); Configuration lazyOffHeap = cm.defineConfiguration("lazyDeserializationWithOffHeap", c.build()); assertEquals(StorageType.OFF_HEAP, lazyOffHeap.memory().storageType()); assertEquals(1, lazyOffHeap.memory().size()); }
public void testDefineConfigurationTwice() { EmbeddedCacheManager cm = createCacheManager(false); try { Configuration override = new ConfigurationBuilder().invocationBatching().enable().build(); assertTrue(override.invocationBatching().enabled()); assertTrue(cm.defineConfiguration("test1", override).invocationBatching().enabled()); ConfigurationBuilder cb = new ConfigurationBuilder(); cb.read(override); Configuration config = cb.build(); assertTrue(config.invocationBatching().enabled()); assertTrue(cm.defineConfiguration("test2", config).invocationBatching().enabled()); } finally { cm.stop(); } }
public void testPartialOverride() { ConfigurationBuilder baseBuilder = new ConfigurationBuilder(); baseBuilder.memory().size(200).storageType(StorageType.BINARY); Configuration base = baseBuilder.build(); ConfigurationBuilder overrideBuilder = new ConfigurationBuilder(); overrideBuilder.read(base).locking().concurrencyLevel(31); Configuration override = overrideBuilder.build(); assertEquals(200, base.memory().size()); assertEquals(200, override.memory().size()); assertEquals(StorageType.BINARY, base.memory().storageType()); assertEquals(StorageType.BINARY, override.memory().storageType()); assertEquals(32, base.locking().concurrencyLevel()); assertEquals(31, override.locking().concurrencyLevel()); }