final SingleFileStoreConfigurationBuilder fileStore = new SingleFileStoreConfigurationBuilder(persistConfig).location(location); fileStore.invocationBatching().enable(); fileStore.eviction().maxEntries(15); fileStore.eviction().strategy(EvictionStrategy.LRU);
@BeforeClass public void setUp() { // create cache configuration ConfigurationBuilder cb = new ConfigurationBuilder(); cb.clustering().invocationBatching().enable() .clustering().cacheMode(CacheMode.DIST_SYNC) .clustering().stateTransfer().timeout(10000) .locking().lockAcquisitionTimeout(TestingUtil.shortTimeoutMillis()) .locking().isolationLevel(IsolationLevel.REPEATABLE_READ); configuration = cb.build(); mockExecutorService = mock(ExecutorService.class); cache = mock(Cache.class); when(cache.getName()).thenReturn("testCache"); rpcManager = mock(RpcManager.class); commandsFactory = mock(CommandsFactory.class); cacheNotifier = mock(ClusterCacheNotifier.class); persistenceManager = mock(PersistenceManager.class); dataContainer = mock(InternalDataContainer.class); transactionTable = mock(TransactionTable.class); stateTransferLock = mock(StateTransferLock.class); distributionManager = mock(DistributionManager.class); ef = mock(InternalEntryFactory.class); when(distributionManager.getCacheTopology()).thenAnswer(invocation -> cacheTopology); }
@Override protected ConfigurationBuilder createConfigurationBuilder() { ConfigurationBuilder cb = new ConfigurationBuilder(); cb.invocationBatching().enable() .locking().lockAcquisitionTimeout(TestingUtil.shortTimeoutMillis()) .isolationLevel(IsolationLevel.REPEATABLE_READ) .transaction().lockingMode(LockingMode.PESSIMISTIC); return cb; }
private void parseInvocationBatching(final XMLExtendedStreamReader reader, final ConfigurationBuilderHolder holder) throws XMLStreamException { ConfigurationBuilder builder = holder.getCurrentConfigurationBuilder(); for (int i = 0; i < reader.getAttributeCount(); i++) { ParseUtils.requireNoNamespaceAttribute(reader, i); String value = replaceProperties(reader.getAttributeValue(i)); Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i)); switch (attribute) { case ENABLED: if (Boolean.parseBoolean(value)) { builder.invocationBatching().enable(); } else { builder.invocationBatching().disable(); } break; default: throw ParseUtils.unexpectedAttribute(reader, i); } } ParseUtils.requireNoContent(reader); }
@Override protected EmbeddedCacheManager createCacheManager() throws Exception { // start a single cache instance ConfigurationBuilder cb = getDefaultStandaloneCacheConfig(true); cb.invocationBatching().enable() .memory().storageType(StorageType.BINARY); return TestCacheManagerFactory.createCacheManager(cb); }
@Override protected EmbeddedCacheManager createCacheManager() throws Exception { ConfigurationBuilder cfg = getDefaultStandaloneCacheConfig(true); cfg .invocationBatching().enable() .persistence() .addStore(DummyInMemoryStoreConfigurationBuilder.class) .ignoreModifications(true); return TestCacheManagerFactory.createCacheManager(cfg); }
@Override public EmbeddedCacheManager createCacheManager() { final ConfigurationBuilder defaultConfiguration = getDefaultCacheConfiguration(true); defaultConfiguration.invocationBatching().enable().transaction().autoCommit(false); return TestCacheManagerFactory.createCacheManager(defaultConfiguration); }
/** * Clean the configuration template to prevent conflicts */ protected void resetConfiguration(ConfigurationBuilder confBuilder) { confBuilder.invocationBatching().enable().eviction().strategy(EvictionStrategy.NONE).maxEntries(-1).expiration() .lifespan(-1L).maxIdle(-1L).wakeUpInterval(60000L); } }
public void testAtomicMapWithoutBatchSet() { ConfigurationBuilder builder = buildConfiguration(); builder.invocationBatching().disable(); cacheManager.defineConfiguration("ahm_without_batch", builder.build()); Cache<String, String> ahmCache = cacheManager.getCache("ahm_without_batch"); AtomicMap<String, String> map = AtomicMapLookup.getAtomicMap(ahmCache, "key"); assert map.isEmpty(); map.put("a", "b"); assert map.get("a").equals("b"); // now re-retrieve the map and make sure we see the diffs assert AtomicMapLookup.getAtomicMap(ahmCache, "key").get("a").equals("b"); }
public static ConfigurationBuilder createLocalCacheConfiguration() { ConfigurationBuilder builder = TestCacheManagerFactory.getDefaultCacheConfiguration(true); builder .clustering() .cacheMode(CacheMode.LOCAL) .transaction() .transactionMode(TransactionMode.NON_TRANSACTIONAL) .locking() .lockAcquisitionTimeout(10000) .invocationBatching() .disable() .deadlockDetection() .disable() .jmxStatistics() .disable() ; return builder; }
@Override protected void createCacheManagers() throws Throwable { ConfigurationBuilder configurationBuilder = TestCacheManagerFactory.getDefaultCacheConfiguration(true); configurationBuilder .clustering() .cacheMode(CacheMode.DIST_SYNC) .remoteTimeout(10000) .stateTransfer() .fetchInMemoryState(true) .l1() .enable() .transaction() .transactionMode(TransactionMode.TRANSACTIONAL) .locking() .lockAcquisitionTimeout(10000) .invocationBatching() .disable() .jmxStatistics() .disable() .indexing() .index(Index.ALL) .addIndexedEntity(Person.class) .addProperty("hibernate.search.default.directory_provider", "local-heap") .addProperty("lucene_version", "LUCENE_CURRENT"); createClusteredCaches(2, "lucene", configurationBuilder); }
static AdvancedCache getTargetCache(EmbeddedCacheManager manager, Properties properties) { StoreProperties props = new StoreProperties(TARGET, properties); ConfigurationBuilder configBuilder = new ConfigurationBuilder(); String segmentCountString = props.get(SEGMENT_COUNT); // 0 means not enabled int segmentCount = 0; if (segmentCountString != null) { segmentCount = Integer.parseInt(segmentCountString); if (segmentCount < 0) { throw new IllegalArgumentException("Segment count must be > 0"); } } if (segmentCount > 0) { configBuilder.clustering().hash().numSegments(segmentCount); } configBuilder.persistence().addStore(getInitializedStoreBuilder(props)) .purgeOnStartup(true) .segmented(segmentCount > 0); configBuilder.invocationBatching().transaction() .transactionMode(TransactionMode.TRANSACTIONAL) .transactionManagerLookup(new EmbeddedTransactionManagerLookup()); String cacheName = props.cacheName(); manager.defineConfiguration(cacheName, configBuilder.build()); return manager.getCache(cacheName).getAdvancedCache().withFlags(Flag.SKIP_CACHE_LOAD); }
@BeforeMethod public void setUp() { ConfigurationBuilder cb = new ConfigurationBuilder(); cb.invocationBatching().enable() .clustering().cacheMode(CacheMode.LOCAL) .locking().concurrencyLevel(2000) .lockAcquisitionTimeout(120000) .isolationLevel(IsolationLevel.READ_COMMITTED); cacheContainer = TestCacheManagerFactory.createCacheManager(cb); Cache c = cacheContainer.getCache(); cache = new TreeCacheImpl<>(c); }
@Override protected ConfigurationBuilder createConfigurationBuilder() { ConfigurationBuilder cb = new ConfigurationBuilder(); cb.invocationBatching().enable() .locking().lockAcquisitionTimeout(TestingUtil.shortTimeoutMillis()) .isolationLevel(IsolationLevel.REPEATABLE_READ) .transaction().lockingMode(LockingMode.OPTIMISTIC); return cb; } }
private EmbeddedCacheManager getCacheManager(boolean batchingEnabled) throws Exception { ConfigurationBuilder builder = new ConfigurationBuilder(); builder .persistence() .passivation(false) .addSingleFileStore() .location(TMP_DIR + File.separator + "cacheStore") .preload(false) .fetchPersistentState(true) .purgeOnStartup(false) .indexing() .index(Index.PRIMARY_OWNER) .addIndexedEntity(SEntity.class) .addProperty("default.directory_provider", "filesystem") .addProperty("lucene_version", "LUCENE_CURRENT") .addProperty("default.indexBase", TMP_DIR + File.separator + "idx"); if (batchingEnabled) { builder.invocationBatching().enable(); } else { builder.invocationBatching().disable(); } return TestCacheManagerFactory.createCacheManager(builder); }
@Override protected EmbeddedCacheManager createCacheManager() throws Exception { ConfigurationBuilder c = getDefaultStandaloneCacheConfig(true); c.invocationBatching().enable().memory().storageType(StorageType.BINARY); EmbeddedCacheManager cm = TestCacheManagerFactory.createCacheManager(c); cache = cm.getCache(); return cm; }
@Override protected EmbeddedCacheManager createCacheManager() throws Exception { ConfigurationBuilder c = getDefaultStandaloneCacheConfig(true); c .invocationBatching().enable() .persistence() .passivation(true) .addStore(DummyInMemoryStoreConfigurationBuilder.class); EmbeddedCacheManager cm = TestCacheManagerFactory.createCacheManager(c); cache = cm.getCache(); loader = TestingUtil.getFirstLoader(cache); return cm; }
private Configuration getRevisionCacheConfig(long maxEntries) { ConfigurationBuilder cb = new ConfigurationBuilder(); cb.invocationBatching().enable().transaction().transactionMode(TransactionMode.TRANSACTIONAL); // Use Embedded manager even in managed ( wildfly/eap ) environment. We don't want infinispan to participate in global transaction cb.transaction().transactionManagerLookup(new EmbeddedTransactionManagerLookup()); cb.transaction().lockingMode(LockingMode.PESSIMISTIC); cb.memory() .evictionStrategy(EvictionStrategy.REMOVE) .evictionType(EvictionType.COUNT) .size(maxEntries); return cb.build(); }
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(); } }