case ENABLED: if (Boolean.parseBoolean(value)) { storeBuilder.async().enable(); } else { storeBuilder.async().disable();
case ENABLED: if (Boolean.parseBoolean(value)) { storeBuilder.async().enable(); } else { storeBuilder.async().disable();
public void testAsyncStoreDisabling() { ConfigurationBuilder builder = TestCacheManagerFactory.getDefaultCacheConfiguration(false); builder.persistence().addStore(DummyInMemoryStoreConfigurationBuilder.class).async().enable(); disableWithConfiguration(builder); }
if (async) { ModelNode writeBehind = store.get(ModelKeys.WRITE_BEHIND, ModelKeys.WRITE_BEHIND_NAME); storeConfigurationBuilder.async().enable() .modificationQueueSize(StoreWriteBehindResource.MODIFICATION_QUEUE_SIZE.resolveModelAttribute(context, writeBehind).asInt()) .threadPoolSize(StoreWriteBehindResource.THREAD_POOL_SIZE.resolveModelAttribute(context, writeBehind).asInt())
@Override protected void createCacheManagers() throws Throwable { ConfigurationBuilder cfg = getDefaultClusteredCacheConfig(CacheMode.REPL_SYNC, true); cfg.persistence() .addStore(DummyInMemoryStoreConfigurationBuilder.class) .slow(true) .storeName(shared ? ReplAsyncStoreTest.class.getName() : null) .shared(shared) .async().enable(); createClusteredCaches(3, CACHE_NAME, cfg); waitForClusterToForm(CACHE_NAME); }
@Override protected EmbeddedCacheManager createCacheManager() throws Exception { ConfigurationBuilder config = getDefaultStandaloneCacheConfig(false); config .persistence() .addStore(DummyInMemoryStoreConfigurationBuilder.class) .storeName(this.getClass().getName()) .slow(true) .async().enable().threadPoolSize(1) .build(); EmbeddedCacheManager cacheManager = TestCacheManagerFactory.createCacheManager(config); cacheManager.defineConfiguration(CACHE_NAME, config.build()); return cacheManager; }
private static ConfigurationBuilder config(boolean passivation) { ConfigurationBuilder config = new ConfigurationBuilder(); config.memory().size(1).persistence().passivation(passivation).addStore(LockableStoreConfigurationBuilder.class).async().enable(); return config; }
private void enableTestJdbcStorage(ConfigurationBuilder configuration) throws Exception { configuration .persistence() .passivation(false) .addSingleFileStore() .preload(false) .shared(false) .location(tmpDirectory) .async() .enable() .threadPoolSize(1); }
public void testChainingStoreDisabling() { ConfigurationBuilder builder = TestCacheManagerFactory.getDefaultCacheConfiguration(false); builder.persistence().addStore(DummyInMemoryStoreConfigurationBuilder.class).persistence().addStore(DummyInMemoryStoreConfigurationBuilder.class).async().enable(); EmbeddedCacheManager cm = TestCacheManagerFactory.createCacheManager(builder); try { checkAndDisableStore(cm, 2); } finally { TestingUtil.killCacheManagers(cm); } }
public void testBdbjeCacheStoreConfigurationAdaptor() { ConfigurationBuilder b = new ConfigurationBuilder(); b.loaders().addStore(BdbjeCacheStoreConfigurationBuilder.class).location("/tmp/bdbje").cacheDbNamePrefix("myprefix").catalogDbName("mycatalog").fetchPersistentState(true).async().enable(); Configuration configuration = b.build(); BdbjeCacheStoreConfiguration store = (BdbjeCacheStoreConfiguration) configuration.loaders().cacheLoaders().get(0); assert store.location().equals("/tmp/bdbje"); assert store.cacheDbNamePrefix().equals("myprefix"); assert store.catalogDbName().equals("mycatalog"); assert store.fetchPersistentState(); assert store.async().enabled(); b = new ConfigurationBuilder(); b.loaders().addStore(BdbjeCacheStoreConfigurationBuilder.class).read(store); Configuration configuration2 = b.build(); BdbjeCacheStoreConfiguration store2 = (BdbjeCacheStoreConfiguration) configuration2.loaders().cacheLoaders().get(0); assert store2.location().equals("/tmp/bdbje"); assert store2.cacheDbNamePrefix().equals("myprefix"); assert store2.catalogDbName().equals("mycatalog"); assert store2.fetchPersistentState(); assert store2.async().enabled(); BdbjeCacheStoreConfig legacy = store.adapt(); assert legacy.getLocation().equals("/tmp/bdbje"); assert legacy.getCacheDbNamePrefix().equals("myprefix"); assert legacy.getCatalogDbName().equals("mycatalog"); assert legacy.isFetchPersistentState(); assert legacy.getAsyncStoreConfig().isEnabled(); } }
private void createStore(boolean slow) throws PersistenceException { ConfigurationBuilder builder = TestCacheManagerFactory.getDefaultCacheConfiguration(false); DummyInMemoryStoreConfigurationBuilder dummyCfg = builder .persistence() .addStore(DummyInMemoryStoreConfigurationBuilder.class) .storeName(AsyncStoreTest.class.getName()); dummyCfg .async() .enable() .threadPoolSize(10); dummyCfg.slow(slow); InitializationContext ctx = PersistenceMockUtil.createContext(getClass().getSimpleName(), builder.build(), marshaller); DummyInMemoryStore underlying = new DummyInMemoryStore(); underlying.init(ctx); underlying.start(); writer = new SlowAdvancedAsyncCacheWriter(underlying); writer.init(ctx); writer.start(); loader = new AdvancedAsyncCacheLoader(underlying, writer.getState()); loader.init(ctx); loader.start(); eventually(writer::isAvailable); }
@Override protected EmbeddedCacheManager createCacheManager() throws Exception { EmbeddedCacheManager cm = TestCacheManagerFactory.createClusteredCacheManager(); for (CacheType cacheType : CacheType.values()) { ConfigurationBuilder builder = new ConfigurationBuilder(); builder.persistence() .addStore(DummyInMemoryStoreConfigurationBuilder.class) .preload(true) .storeName(this.getClass().getName()).async().enable(); builder.transaction().transactionMode(cacheType.transactionMode).useSynchronization(cacheType.useSynchronization) .recovery().enabled(cacheType.useRecovery); builder.customInterceptors().addInterceptor().index(0).interceptor(new ExceptionTrackerInterceptor()); cm.defineConfiguration(cacheType.cacheName, builder.build()); } return cm; }
.dataColumnName("datum").dataColumnType("BINARY") .timestampColumnName("version").timestampColumnType("BIGINT") .async().enable(); Configuration configuration = b.build(); JdbcStringBasedStoreConfiguration store = (JdbcStringBasedStoreConfiguration) configuration.persistence().stores().get(0);
private Cache<Object, Object> createManagerAndGetCache(boolean failSilently, int queueSize) { GlobalConfiguration globalConfiguration = new GlobalConfigurationBuilder().globalJmxStatistics().allowDuplicateDomains(true).build(); ConfigurationBuilder cb = TestCacheManagerFactory.getDefaultCacheConfiguration(false); Configuration config = cb.persistence().availabilityInterval(AVAILABILITY_INTERVAL) .addStore(DummyInMemoryStoreConfigurationBuilder.class) .async().enable().modificationQueueSize(queueSize).failSilently(failSilently) .build(); return new DefaultCacheManager(globalConfiguration, config).getCache(); }
/** * @param async set to true means the cache store instance is placed under an DelegatingCacheWriter */ private void test(boolean async) { ConfigurationBuilder dcc = TestCacheManagerFactory.getDefaultCacheConfiguration(true); DummyInMemoryStoreConfigurationBuilder builder = dcc.persistence().addStore(DummyInMemoryStoreConfigurationBuilder.class); if (async) { builder.async().enable(); } EmbeddedCacheManager cacheManager = TestCacheManagerFactory.createCacheManager(dcc); Cache<Object,Object> cache = cacheManager.getCache(); try { CacheLoader firstLoader = TestingUtil.getFirstLoader(cache); CacheLoader undelegatedLoader = firstLoader instanceof DelegatingCacheLoader ? ((DelegatingCacheLoader) firstLoader).undelegate() : firstLoader; CacheWriter firstWriter = TestingUtil.getFirstWriter(cache); CacheWriter undelegatedWriter = firstWriter instanceof DelegatingCacheWriter ? ((DelegatingCacheWriter) firstWriter).undelegate() : firstWriter; assertEquals(1, ((DummyInMemoryStore)undelegatedLoader).getInitCount()); assertEquals(1, ((DummyInMemoryStore)undelegatedWriter).getInitCount()); } finally { TestingUtil.killCacheManagers(cacheManager); } }