new ConfigurationBuilder().persistence(); persistConfig.passivation(false); final SingleFileStoreConfigurationBuilder fileStore = final Configuration config = persistConfig.addStore(fileStore).build(); config.compatibility().enabled(); manager.getManager().defineConfiguration(namedCache, config); final Cache<String, String> cache = manager.getManager().getCache(namedCache); treeCache = f.createTreeCache(cache); cache.start();
@Override public EmbeddedCacheManager get() { GlobalConfiguration config = this.configuration.get(); String defaultCacheName = config.defaultCacheName().orElse(null); // We need to create a dummy default configuration if cache has a default cache Configuration defaultConfiguration = (defaultCacheName != null) ? new ConfigurationBuilder().build() : null; EmbeddedCacheManager manager = new DefaultCacheManager(config, defaultConfiguration, false); // Undefine the default cache, if we defined one if (defaultCacheName != null) { manager.undefineConfiguration(defaultCacheName); } // Override GlobalConfigurationManager with a local implementation @SuppressWarnings("deprecation") BasicComponentRegistry registry = manager.getGlobalComponentRegistry().getComponent(BasicComponentRegistry.class); registry.replaceComponent(GlobalConfigurationManager.class.getName(), new LocalGlobalConfigurationManager(), false); registry.rewire(); manager.start(); manager.addListener(this); InfinispanLogger.ROOT_LOGGER.debugf("%s cache container started", this.name); return manager; }
@SuppressWarnings("deprecation") @Override public void accept(ConfigurationBuilder builder) { ClusteringConfigurationBuilder clustering = builder.clustering(); CacheMode mode = clustering.cacheMode(); clustering.cacheMode(mode.needsStateTransfer() ? CacheMode.REPL_SYNC : CacheMode.LOCAL); // don't use DefaultConsistentHashFactory for REPL caches (WFLY-9276) clustering.hash().consistentHashFactory(null); clustering.l1().disable(); // Workaround for ISPN-8722 AttributeSet attributes = TemplateConfigurationServiceConfigurator.getAttributes(clustering); attributes.attribute(ClusteringConfiguration.BIAS_ACQUISITION).reset(); attributes.attribute(ClusteringConfiguration.BIAS_LIFESPAN).reset(); attributes.attribute(ClusteringConfiguration.INVALIDATION_BATCH_SIZE).reset(); // Ensure we use the default data container builder.dataContainer().dataContainer(null); // Disable expiration builder.expiration().lifespan(-1).maxIdle(-1); // Disable eviction builder.memory().size(-1).evictionStrategy(EvictionStrategy.MANUAL); builder.persistence().clearStores(); StateTransferConfigurationBuilder stateTransfer = clustering.stateTransfer().fetchInMemoryState(mode.needsStateTransfer()); attributes = TemplateConfigurationServiceConfigurator.getAttributes(stateTransfer); attributes.attribute(StateTransferConfiguration.AWAIT_INITIAL_TRANSFER).reset(); attributes.attribute(StateTransferConfiguration.TIMEOUT).reset(); } }
@Override public Configuration get() { ConfigurationBuilder builder = new ConfigurationBuilder(); this.consumer.accept(builder); Configuration configuration = builder.build(); this.container.get().defineConfiguration(this.cacheName, configuration); return configuration; }
@Override public PersistenceConfiguration get() { return new ConfigurationBuilder().persistence().passivation(false).create(); } }
@Override public PartitionHandlingConfiguration get() { return new ConfigurationBuilder().clustering().partitionHandling() .whenSplit(this.enabled ? PartitionHandling.DENY_READ_WRITES : PartitionHandling.ALLOW_READ_WRITES) .mergePolicy(MergePolicy.NONE) .create(); }
@Override public void call() { ConfigurationBuilder builder = new ConfigurationBuilder(); CacheMode cacheMode = CacheMode.DIST_ASYNC; // DIST_ASYNC isn't default so it should stay applied builder.clustering().cacheMode(cacheMode); String distCacheName = "dist-cache"; cm.defineConfiguration(distCacheName, builder.build()); String templateName = "template"; cm.defineConfiguration(templateName, new ConfigurationBuilder().template(true).build()); Cache cache = cm.getCache(distCacheName, templateName); assertEquals(cacheMode, cache.getCacheConfiguration().clustering().cacheMode()); } });
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 testPutAllBatch() throws Exception { int numberOfEntries = 100; String cacheName = "testPutAllBatch"; ConfigurationBuilder cb = new ConfigurationBuilder(); cb.read(cacheManager.getDefaultCacheConfiguration()); createCacheStoreConfig(cb.persistence(), false); cacheManager.defineConfiguration(cacheName, cb.build()); Cache<String, Object> cache = cacheManager.getCache(cacheName); Map<String, Object> entriesMap = IntStream.range(0, numberOfEntries).boxed() .collect(Collectors.toMap(Object::toString, i -> wrap(i.toString(), "Val"+i))); cache.putAll(entriesMap); assertEquals(numberOfEntries, cache.size()); CacheLoader cl = TestingUtil.getCacheLoader(cache); if (cl != null) IntStream.range(0, numberOfEntries).forEach(i -> assertNotNull(cl.load(Integer.toString(i)))); }
public void testDefaultCache() { EmbeddedCacheManager cm = createCacheManager(false); try { assertEquals(ComponentStatus.RUNNING, cm.getCache().getStatus()); assertTrue(cm.getCache().getName().equals(CacheContainer.DEFAULT_CACHE_NAME)); expectException(IllegalArgumentException.class, () -> cm.defineConfiguration(CacheContainer.DEFAULT_CACHE_NAME, new ConfigurationBuilder().build())); } finally { TestingUtil.killCacheManagers(cm); } }
public void testStoreAsBinaryOnBoth() { ConfigurationBuilder c = new ConfigurationBuilder(); c.memory().storageType(StorageType.BINARY).build(); ecm = TestCacheManagerFactory.createCacheManager(c); ecm.getCache().put(key, value); DataConversion keyDataConversion = ecm.getCache().getAdvancedCache().getKeyDataConversion(); DataConversion valueDataConversion = ecm.getCache().getAdvancedCache().getValueDataConversion(); DataContainer<?, ?> dc = ecm.getCache().getAdvancedCache().getDataContainer(); InternalCacheEntry entry = dc.iterator().next(); Object key = entry.getKey(); Object value = entry.getValue(); assertTrue(key instanceof WrappedBytes); assertEquals(keyDataConversion.fromStorage(key), this.key); assertTrue(value instanceof WrappedBytes); assertEquals(valueDataConversion.fromStorage(value), this.value); } }
@Override public void call() { ConfigurationBuilder customConfiguration = TestCacheManagerFactory.getDefaultCacheConfiguration(true); customConfiguration.transaction().transactionManagerLookup(new TxManagerLookupA()); Configuration definedConfiguration = cm.defineConfiguration("aCache", customConfiguration.build()); // verify the setting was not lost: assertTrue(definedConfiguration.transaction().transactionManagerLookup() instanceof TxManagerLookupA); // verify it's actually being used: TransactionManager activeTransactionManager = cm.getCache("aCache").getAdvancedCache().getTransactionManager(); assertNotNull(activeTransactionManager); assertTrue(activeTransactionManager instanceof TmA); } });
public void testDifferentDomain() throws Exception { GlobalConfigurationBuilder globalConfiguration = GlobalConfigurationBuilder.defaultClusteredBuilder(); globalConfiguration.globalJmxStatistics().enable().mBeanServerLookup(new PerThreadMBeanServerLookup()); cm = TestCacheManagerFactory.createClusteredCacheManager(globalConfiguration, new ConfigurationBuilder()); String jmxDomain = cm.getCacheManagerConfiguration().globalJmxStatistics().domain(); ConfigurationBuilder localCache = config();//local by default cm.defineConfiguration("local_cache", localCache.build()); cm.getCache("local_cache"); assert existsObject(getCacheObjectName(jmxDomain, "local_cache(local)", "Statistics")); }
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()); }
public void testStatistics() { Configuration cfg = new ConfigurationBuilder().simpleCache(true).jmxStatistics().enabled(true).build(); String name = "statsCache"; cacheManager.defineConfiguration(name, cfg); Cache<Object, Object> cache = cacheManager.getCache(name); assertEquals(0L, cache.getAdvancedCache().getStats().getStores()); cache.put("key", "value"); assertEquals(1L, cache.getAdvancedCache().getStats().getStores()); } }
/** * 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); }
public void testAllocatedAmountEqualWithVersion() { ConfigurationBuilder builder = new ConfigurationBuilder(); builder.memory() .size(MemoryUnit.MEGABYTES.toBytes(20)) .evictionType(EvictionType.MEMORY) .storageType(StorageType.OFF_HEAP); EmbeddedCacheManager manager = TestCacheManagerFactory.createCacheManager(builder); AdvancedCache<Object, Object> cache = manager.getCache().getAdvancedCache(); cache.put(1, 2, new EmbeddedMetadata.Builder().version(new NumericVersion(23)).build()); OffHeapMemoryAllocator allocator = cache.getComponentRegistry().getComponent( OffHeapMemoryAllocator.class); BoundedOffHeapDataContainer container = (BoundedOffHeapDataContainer) getContainer(cache); assertEquals(allocator.getAllocatedAmount(), container.currentSize); cache.clear(); assertEquals(allocator.getAllocatedAmount(), container.currentSize); }
@Test public void testRestoreTransactionalAtomicMap(final Method m) throws Exception { cacheManager.defineConfiguration(m.getName(), configureCacheLoader(null, false).build()); Cache<String, Object> cache = cacheManager.getCache(m.getName()); TransactionManager tm = cache.getAdvancedCache().getTransactionManager(); tm.begin(); final AtomicMap<String, String> map = AtomicMapLookup.getAtomicMap(cache, m.getName()); map.put("a", "b"); tm.commit(); //evict from memory cache.evict(m.getName()); // now re-retrieve the map and make sure we see the diffs assertEquals("b", AtomicMapLookup.getAtomicMap(cache, m.getName()).get("a")); }
@Override protected void createCacheManagers() throws Throwable { builderUsed = new ConfigurationBuilder(); builderUsed.clustering().cacheMode(cacheMode); if (tx) { builderUsed.transaction().transactionMode(TransactionMode.TRANSACTIONAL); builderUsed.locking().isolationLevel(IsolationLevel.READ_COMMITTED); } builderUsed.expiration().disableReaper(); createClusteredCaches(3, CACHE_NAME, builderUsed); injectTimeServices(); }
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()); }