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);
final EmbeddedCacheManager manager = new DefaultCacheManager(); final PersistenceConfigurationBuilder persistConfig = new ConfigurationBuilder().persistence(); final SingleFileStoreConfigurationBuilder fileStore = new SingleFileStoreConfigurationBuilder(persistConfig).location("cache"); final Configuration config = persistConfig.addStore(fileStore).compatibility().enable().build(); manager.defineConfiguration("records", config);
@BeforeClass public void prepare() { Configuration config = new ConfigurationBuilder().build(); cacheManager.defineConfiguration("cache1", config); cacheManager.defineConfiguration("cache2", config); }
@Test(expectedExceptions=IllegalStateException.class) public void testConfigurationUndefineWhileInUse() { cm = TestCacheManagerFactory.createCacheManager(); cm.defineConfiguration("testConfig", new ConfigurationBuilder().build()); cm.getCache("testConfig"); cm.undefineConfiguration("testConfig"); }
protected <K, V> List<Cache<K, V>> createClusteredCaches( int numMembersInCluster, String cacheName, ConfigurationBuilder builder, TransportFlags flags) { List<Cache<K, V>> caches = new ArrayList<>(numMembersInCluster); for (int i = 0; i < numMembersInCluster; i++) { EmbeddedCacheManager cm = addClusterEnabledCacheManager(flags); cm.defineConfiguration(cacheName, builder.build()); Cache<K, V> cache = cm.getCache(cacheName); caches.add(cache); } waitForClusterToForm(cacheName); return caches; }
@Override public Cache findOrCreate(String name, Map<CreateOption,Object> options) { Cache result = find(name); if (result == null) { manager().defineConfiguration(name, Config.uration(validate(options))); log.info("Creating cache: "+name); result = manager().getCache(name); } return result; }
@BeforeMethod protected void setup() throws Exception { EmbeddedCacheManager manager = TestCacheManagerFactory.createCacheManager(); for (int i = 0; i < NUM_CACHES; i++) { manager.defineConfiguration("cache" + i, TestCacheManagerFactory.getDefaultCacheConfiguration(false).build()); } cacheManager = manager; }
@Test public void testExplicitStop() { cacheManager.defineConfiguration("A", new ConfigurationBuilder().build()); cacheManager.defineConfiguration("B", new ConfigurationBuilder().build()); Cache<?, ?> cacheA = cacheManager.getCache("A"); Cache<?, ?> cacheB = cacheManager.getCache("B"); cacheManager.addCacheDependency("A", "B"); cacheB.stop(); cacheA.stop(); assertAllTerminated(cacheA, cacheB); }
void performRehashEvent(boolean offline) { joinerManager = addClusterEnabledCacheManager(new TransportFlags()); joinerManager.defineConfiguration(cacheName, configuration.build()); joiner = joinerManager.getCache(cacheName); }
@Override public void call() { cm.defineConfiguration("foo", new ConfigurationBuilder().build()); } });
protected Cache getDefaultCache() { EmbeddedCacheManager manager = new DefaultCacheManager(); manager.defineConfiguration("custom-cache", new ConfigurationBuilder() .eviction().strategy(EvictionStrategy.NONE).maxEntries(1000) .build()); return manager.getCache("custom-cache"); }
@Test(expectedExceptions = IllegalLifecycleStateException.class) public void testCacheStopFollowedByCacheOp() { cacheManager.defineConfiguration("big", cacheManager.getDefaultCacheConfiguration()); Cache cache = cacheManager.getCache("big"); cache.put("k", "v"); cache.stop(); cache.put("k", "v2"); }
@Override protected void createCacheManagers() throws Throwable { addClusterEnabledCacheManager(getGlobalConfigurationBuilder("r1"), getConfigurationBuilder()) .defineConfiguration("test", getConfigurationBuilder().build()); }
@Test public void testCyclicDependencies() { cacheManager.defineConfiguration("A", new ConfigurationBuilder().build()); cacheManager.defineConfiguration("B", new ConfigurationBuilder().build()); Cache<?, ?> cacheA = cacheManager.getCache("A"); Cache<?, ?> cacheB = cacheManager.getCache("B"); cacheManager.addCacheDependency("A", "B"); cacheManager.addCacheDependency("B", "A"); // Order will not be enforced cacheManager.stop(); assertAllTerminated(cacheA, cacheB); }
@Override public void call() { cm.defineConfiguration("custom", cfg.build()); Cache c = cm.getCache("custom"); DummyInterceptor i = TestingUtil.findInterceptor(c, DummyInterceptor.class); assertNotNull(i); } });
protected void postConfigure(List<EmbeddedCacheManager> cacheManagers) { ConfigurationBuilder builder = new ConfigurationBuilder(); builder.indexing().index(Index.NONE); Configuration configuration = builder.build(); cacheManagers.forEach(cm -> { cm.defineConfiguration(DEFAULT_LOCKING_CACHENAME, configuration); cm.defineConfiguration(DEFAULT_INDEXESDATA_CACHENAME, configuration); cm.defineConfiguration(DEFAULT_INDEXESMETADATA_CACHENAME, configuration); }); }
public static void main(String args[]) throws Exception { EmbeddedCacheManager manager = new DefaultCacheManager(); manager.defineConfiguration("custom-cache", new ConfigurationBuilder() .eviction().strategy(LIRS).maxEntries(10) .build()); Cache<Object, Object> c = manager.getCache("custom-cache"); }
@Override public void call() { assert !cm.getCache().getCacheConfiguration().transaction().transactionMode().isTransactional(); cm.defineConfiguration("a", c); final Cache<Object, Object> a = cm.getCache("a"); assert a.getCacheConfiguration().invocationBatching().enabled(); assert a.getCacheConfiguration().transaction().transactionMode().isTransactional(); } });
private <K, V> Cache<K, V> createCache(boolean enableBatch, String name) { ConfigurationBuilder c = new ConfigurationBuilder(); c.invocationBatching().enable(enableBatch); cacheManager.defineConfiguration(name, c.build()); return cacheManager.getCache(name); } }
protected <K, V> List<Cache<K, V>> createClusteredCaches(int numMembersInCluster, String cacheName, GlobalConfigurationBuilder gcb, ConfigurationBuilder builder) { List<Cache<K, V>> caches = new ArrayList<>(numMembersInCluster); final TransportFlags flags = transportFlags(); for (int i = 0; i < numMembersInCluster; i++) { EmbeddedCacheManager cm = addClusterEnabledCacheManager(flags, gcb, builder); if (cacheName != null) cm.defineConfiguration(cacheName, builder.build()); Cache<K, V> cache = cacheName == null ? cm.getCache() : cm.getCache(cacheName); caches.add(cache); } waitForClusterToForm(cacheName); return caches; }