persistConfig.passivation(false); final SingleFileStoreConfigurationBuilder fileStore = new SingleFileStoreConfigurationBuilder(persistConfig).location(location); fileStore.eviction().strategy(EvictionStrategy.LRU); fileStore.jmxStatistics().disable(); final Configuration config = persistConfig.addStore(fileStore).build(); config.compatibility().enabled(); manager.getManager().defineConfiguration(namedCache, config);
@Override public AsyncStoreConfiguration get() { return new ConfigurationBuilder().persistence().addSingleFileStore().async().disable().create(); } }
@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 PersistenceConfiguration get() { return new ConfigurationBuilder().persistence().passivation(false).create(); } }
@Override public PersistenceConfiguration get() { B builder = new ConfigurationBuilder().persistence() .passivation(this.passivation) .addStore(this.builderClass) .fetchPersistentState(this.fetchState) .maxBatchSize(this.maxBatchSize) .preload(this.preload) .purgeOnStartup(this.purge) .shared(this.shared) .withProperties(this.properties) ; this.accept(builder); return builder.async().read(this.async.get()).persistence().create(); } }
@Override public TableManipulationConfiguration get() { return new ConfigurationBuilder().persistence().addStore(JdbcStringBasedStoreConfigurationBuilder.class).table() .idColumnName(this.columns.get(ID).getKey()) .idColumnType(this.columns.get(ID).getValue()) .dataColumnName(this.columns.get(DATA).getKey()) .dataColumnType(this.columns.get(DATA).getValue()) .timestampColumnName(this.columns.get(TIMESTAMP).getKey()) .timestampColumnType(this.columns.get(TIMESTAMP).getValue()) .fetchSize(this.fetchSize) .tableNamePrefix(this.prefix) .create(); } }
private ConfigurationBuilder addDummyStore(ConfigurationBuilder config, boolean pushing) { config .persistence() .clearStores() .addStore(DummyInMemoryStoreConfigurationBuilder.class) .storeName("Store-" + storeCounter.getAndIncrement()) .singleton() .enable() .pushStateWhenCoordinator(pushing); return config; }
@Override protected EmbeddedCacheManager createCacheManager(String cacheName) { configurationBuilder.persistence().clearStores(); DummyInMemoryStoreConfigurationBuilder dimcs = new DummyInMemoryStoreConfigurationBuilder(configurationBuilder.persistence()); if (sharedCacheLoader.get()) { dimcs.storeName(getClass().getName()); } else { dimcs.storeName(getClass().getName() + id++); } dimcs.fetchPersistentState(false).purgeOnStartup(false).shared(sharedCacheLoader.get()).preload(true); configurationBuilder.persistence().passivation(false).addStore(dimcs).fetchPersistentState(fetchPersistentState.get()); // Want to enable eviction, but don't actually evict anything configurationBuilder.memory().size(INSERTION_COUNT * 10); EmbeddedCacheManager cm = addClusterEnabledCacheManager(configurationBuilder, new TransportFlags().withMerge(true)); cm.defineConfiguration(cacheName, configurationBuilder.build()); return cm; }
@Test public void testClearStores() { Configuration c = new ConfigurationBuilder() .persistence() .addStore(DummyInMemoryStoreConfigurationBuilder.class) .persistence() .clearStores() .build(); assertEquals(c.persistence().stores().size(), 0); }
@Override protected void createCacheManagers() throws Throwable { EmbeddedCacheManager cacheManager1 = TestCacheManagerFactory.createClusteredCacheManager(); EmbeddedCacheManager cacheManager2 = TestCacheManagerFactory.createClusteredCacheManager(); registerCacheManager(cacheManager1, cacheManager2); ConfigurationBuilder config1 = getDefaultClusteredCacheConfig(cacheMode, false); config1.persistence().addClusterLoader(); ConfigurationBuilder config2 = getDefaultClusteredCacheConfig(cacheMode, false); config2.persistence().addClusterLoader(); config2.persistence().addStore(DummyInMemoryStoreConfigurationBuilder.class); cacheManager1.defineConfiguration("clusteredCl", config1.build()); cacheManager2.defineConfiguration("clusteredCl", config2.build()); waitForClusterToForm("clusteredCl"); }
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(); }
private void enableTestJdbcStorage(ConfigurationBuilder configuration) throws Exception { configuration .persistence() .passivation(false) .addSingleFileStore() .preload(false) .shared(false) .location(tmpDirectory) .async() .enable() .threadPoolSize(1); }
public void testStateTransfer() throws Exception { final int numKeys = 300; for (int i = 0; i < numKeys; i++) { cache(0).put(i, i); } log.info("Finished putting keys"); for (int i = 0; i < numKeys; i++) { assertEquals(i, cache(0).get(i)); } log.info("Adding a new node .."); builder.persistence().clearStores().addSingleFileStore().location(new File(tmpDir, "store1").getAbsolutePath()) // make sure this node writes in a different location .fetchPersistentState(true) .ignoreModifications(false) .purgeOnStartup(false); addClusterEnabledCacheManager(builder); log.info("Added a new node"); for (int i = 0; i < numKeys; i++) { assertEquals(i, cache(1).get(i)); // some keys are lost in 5.2 } } }
private void enablePassivation(ConfigurationBuilder builder) { builder.persistence().passivation(true); builder.memory().size(1); }
private StoreConfigurationBuilder<?, ?> buildCacheLoader(PersistenceConfigurationBuilder persistenceBuilder, ModelNode loader, String loaderKey) throws OperationFailedException { if (loaderKey.equals(ModelKeys.CLUSTER_LOADER)) { final ClusterLoaderConfigurationBuilder builder = persistenceBuilder.addClusterLoader(); if (loader.hasDefined(ModelKeys.REMOTE_TIMEOUT)) { builder.remoteCallTimeout(loader.require(ModelKeys.REMOTE_TIMEOUT).asLong()); } return builder; } else if (loaderKey.equals(ModelKeys.LOADER)) { String className = loader.require(ModelKeys.CLASS).asString(); try { return handleStoreOrLoaderClass(className, persistenceBuilder); } catch (Exception e) { throw InfinispanMessages.MESSAGES.invalidCacheStore(e, className); } } else { throw new IllegalStateException(); } }
@Override protected PersistenceConfigurationBuilder createCacheStoreConfig(PersistenceConfigurationBuilder persistence, boolean preload) { persistence .addStore(DummyInMemoryStoreConfigurationBuilder.class) .storeName(getClass().getName()) .purgeOnStartup(false).preload(preload); return persistence; }
@Override public PersistenceConfiguration get() { PersistenceConfiguration persistence = super.get(); StoreConfiguration store = persistence.stores().get(0); try { @SuppressWarnings("unchecked") Class<StoreConfigurationBuilder<?, ?>> storeClass = (Class<StoreConfigurationBuilder<?, ?>>) this.module.get().getClassLoader().loadClass(this.className).asSubclass(StoreConfigurationBuilder.class); return new ConfigurationBuilder().persistence().passivation(persistence.passivation()).addStore(storeClass) .async().read(store.async()) .fetchPersistentState(store.fetchPersistentState()) .preload(store.preload()) .purgeOnStartup(store.purgeOnStartup()) .shared(store.shared()) .withProperties(store.properties()) .persistence().create(); } catch (ClassNotFoundException | ClassCastException e) { throw InfinispanLogger.ROOT_LOGGER.invalidCacheStore(e, this.className); } }
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; }
@Override protected void createCacheManagers() { ConfigurationBuilder builder = getDefaultClusteredCacheConfig(CacheMode.REPL_SYNC, true, true); builder.transaction() .transactionMode(TransactionMode.TRANSACTIONAL).lockingMode(LockingMode.PESSIMISTIC) .transactionManagerLookup(new JBossStandaloneJTAManagerLookup()) .memory().size(1) .clustering().hash().groups().enabled() .persistence().passivation(true) .addStore(DummyInMemoryStoreConfigurationBuilder.class) .fetchPersistentState(false); addClusterEnabledCacheManager(builder); builder.persistence().clearStores() .addStore(DummyInMemoryStoreConfigurationBuilder.class).fetchPersistentState(false); addClusterEnabledCacheManager(builder); waitForClusterToForm(); }
protected EmbeddedCacheManager createCacheManager(int maxEntries) throws Exception { return new DefaultCacheManager( new GlobalConfigurationBuilder().build(), new ConfigurationBuilder() .memory().evictionType(EvictionType.COUNT).size(maxEntries) .persistence().passivation(true) .addSingleFileStore().location(storeDir.getAbsolutePath()).preload(true) .indexing().index(Index.ALL) .addIndexedEntity(Person.class) .addIndexedEntity(Car.class) .addProperty("default.directory_provider", "filesystem") .addProperty("default.indexBase", indexDir.getAbsolutePath()) .addProperty("lucene_version", "LUCENE_CURRENT") .build() ); }