@Override public void accept(ConfigurationBuilder builder) { super.accept(builder); builder.clustering().cacheMode(CacheMode.LOCAL); // Auto-enable simple cache optimization if cache is non-transactional and non-persistent builder.simpleCache((this.memory().storageType() == StorageType.OBJECT) && !this.transaction().transactionMode().isTransactional() && !this.persistence().usingStores()); } }
private static void verifyCacheHasNoEviction(AdvancedCache<?, ?> cache) { if (cache.getCacheConfiguration().memory().isEvictionEnabled()) throw new IllegalArgumentException("DistributedSegmentReadLocker is not reliable when using a cache with eviction enabled, disable eviction on this cache instance"); }
public void testDefiningConfigurationOverridingBooleans() { EmbeddedCacheManager cm = createCacheManager(false); ConfigurationBuilder c = new ConfigurationBuilder(); c.memory().storageType(StorageType.BINARY); Configuration lazy = cm.defineConfiguration("storeAsBinary", c.build()); assertEquals(StorageType.BINARY, lazy.memory().storageType()); c = new ConfigurationBuilder().read(lazy); c.memory().storageType(StorageType.OFF_HEAP).size(1); Configuration lazyOffHeap = cm.defineConfiguration("lazyDeserializationWithOffHeap", c.build()); assertEquals(StorageType.OFF_HEAP, lazyOffHeap.memory().storageType()); assertEquals(1, lazyOffHeap.memory().size()); }
public void testSmallCache() { // Check that we have the correctly configured cache assertEquals(smallCache.getCacheConfiguration().memory().size(), 10); } }
@Override public void check(ConfigurationBuilderHolder holder) { GlobalConfiguration globalConfiguration = getGlobalConfiguration(holder); assertEquals(4, globalConfiguration.transport().initialClusterSize()); assertEquals(30000, globalConfiguration.transport().initialClusterTimeout()); MemoryConfiguration mc = getConfiguration(holder, "off-heap-memory").memory(); assertEquals(StorageType.OFF_HEAP, mc.storageType()); assertEquals(10000000, mc.size()); assertEquals(4, mc.addressCount()); assertEquals(EvictionType.MEMORY, mc.evictionType()); mc = getConfiguration(holder, "binary-memory").memory(); assertEquals(StorageType.BINARY, mc.storageType()); assertEquals(1, mc.size()); mc = getConfiguration(holder, "object-memory").memory(); assertEquals(StorageType.OBJECT, mc.storageType()); } },
assertEquals(1000, c.locking().concurrencyLevel()); assertEquals(IsolationLevel.REPEATABLE_READ, c.locking().isolationLevel()); assertEquals(StorageType.OBJECT, c.memory().storageType()); assertEquals(StorageType.BINARY, c.memory().storageType()); assertEquals(5000, c.memory().size()); assertEquals(EvictionStrategy.REMOVE, c.memory().evictionStrategy()); assertEquals(EvictionType.COUNT, c.memory().evictionType()); assertEquals(StorageType.OBJECT, c.memory().storageType()); assertEquals(60000, c.expiration().lifespan()); assertEquals(1000, c.expiration().maxIdle()); assertEquals(5000, c.memory().size()); assertEquals(EvictionStrategy.EXCEPTION, c.memory().evictionStrategy()); assertEquals(EvictionType.MEMORY, c.memory().evictionType()); assertEquals(StorageType.BINARY, c.memory().storageType()); assertEquals(StorageType.BINARY, c.memory().storageType());
assertEquals("person-cache", factory.getBaseConfiguration(person)); Configuration personOverride = factory.getConfigurationOverride(person); assertEquals(EvictionType.COUNT, personOverride.memory().evictionType()); assertEquals(5000, personOverride.memory().size()); assertEquals(2000, personOverride.expiration().wakeUpInterval()); assertEquals(60000, personOverride.expiration().lifespan()); assertEquals(EvictionType.COUNT, queryOverride.memory().evictionType()); assertEquals(10000, queryOverride.memory().size()); assertEquals(3000, queryOverride.expiration().wakeUpInterval()); } finally {
@Override public void call() { Configuration cfg = cm.getDefaultCacheConfiguration(); assertTrue(cfg.dataContainer().<byte[]>keyEquivalence() instanceof AnyEquivalence); assertTrue(cfg.dataContainer().valueEquivalence() instanceof AnyEquivalence); assertEquals(StorageType.OFF_HEAP, cfg.memory().storageType()); assertEquals(EvictionStrategy.MANUAL, cfg.memory().evictionStrategy()); } });
protected void doPreloadingTestWithEviction(Configuration preloadingCfg, String cacheName) throws Exception { assertTrue("Preload not enabled for preload with eviction test", preloadingCfg.persistence().preload()); assertTrue("Eviction not enabled for preload with eviction test", preloadingCfg.memory().isEvictionEnabled()); final long expectedEntriesInContainer = Math.min(4L, preloadingCfg.memory().size()); AdvancedCacheLoader preloadingCacheLoader = (AdvancedCacheLoader) TestingUtil.getCacheLoader(preloadingCache);
private void memory(MeterRegistry registry) { Gauge.builder("cache.memory.size", cache, cache -> cache.getAdvancedCache().getStats().getCurrentNumberOfEntriesInMemory()) .tags(getTagsWithCacheName()) .description("Number of entries currently in the cache, excluding passivated entries") .register(registry); if (cache.getCacheConfiguration().memory().evictionStrategy().isEnabled()) { Gauge.builder("cache.memory.used", cache, cache -> cache.getAdvancedCache().getStats().getDataMemoryUsed()) .tags(getTagsWithCacheName()) .description("Provides how much memory the current eviction algorithm estimates is in use for data") .register(registry); } Gauge.builder("cache.memory.offHeap", cache, cache -> cache.getAdvancedCache().getStats().getOffHeapMemoryUsed()) .tags(getTagsWithCacheName()) .description("The amount of off-heap memory used by this cache") .register(registry); }
@Override public void check(ConfigurationBuilderHolder holder) { Configuration c = holder.getDefaultConfigurationBuilder().build(); assertFalse(c.memory().evictionType() == EvictionType.MEMORY); c = getConfiguration(holder, "invalid"); assertTrue(c.memory().evictionType() == EvictionType.COUNT);
public void testPartialOverride() { ConfigurationBuilder baseBuilder = new ConfigurationBuilder(); baseBuilder.memory().size(200).storageType(StorageType.BINARY); Configuration base = baseBuilder.build(); ConfigurationBuilder overrideBuilder = new ConfigurationBuilder(); overrideBuilder.read(base).locking().concurrencyLevel(31); Configuration override = overrideBuilder.build(); assertEquals(200, base.memory().size()); assertEquals(200, override.memory().size()); assertEquals(StorageType.BINARY, base.memory().storageType()); assertEquals(StorageType.BINARY, override.memory().storageType()); assertEquals(32, base.locking().concurrencyLevel()); assertEquals(31, override.locking().concurrencyLevel()); }
public void testSuperLargeCache() { assertEquals(superLargeCache.getCacheConfiguration().memory().size(), 20); } }
@Override public void check(ConfigurationBuilderHolder holder) { GlobalStateConfiguration gs = getGlobalConfiguration(holder).globalState(); assertEquals(ConfigurationStorage.OVERLAY, gs.configurationStorage()); assertEquals("sharedPath", gs.sharedPersistentLocation()); EncodingConfiguration encoding = getConfiguration(holder, "local").encoding(); assertEquals(MediaType.APPLICATION_OBJECT, encoding.keyDataType().mediaType()); assertEquals(MediaType.APPLICATION_OBJECT, encoding.valueDataType().mediaType()); PartitionHandlingConfiguration ph = getConfiguration(holder, "dist").clustering().partitionHandling(); assertTrue(ph.enabled()); assertEquals(PartitionHandling.ALLOW_READS, ph.whenSplit()); assertEquals(MergePolicy.PREFERRED_NON_NULL, ph.mergePolicy()); ph = getConfiguration(holder, "repl").clustering().partitionHandling(); assertFalse(ph.enabled()); assertEquals(PartitionHandling.ALLOW_READ_WRITES, ph.whenSplit()); assertEquals(MergePolicy.NONE, ph.mergePolicy()); MemoryConfiguration mc = getConfiguration(holder, "off-heap-memory").memory(); assertEquals(StorageType.OFF_HEAP, mc.storageType()); assertEquals(10000000, mc.size()); assertEquals(4, mc.addressCount()); assertEquals(EvictionType.MEMORY, mc.evictionType()); mc = getConfiguration(holder, "binary-memory").memory(); assertEquals(StorageType.BINARY, mc.storageType()); assertEquals(1, mc.size()); mc = getConfiguration(holder, "object-memory").memory(); assertEquals(StorageType.OBJECT, mc.storageType()); } },
@Test public void testBuildQueryRegionWithCustomRegionName() { final String queryRegionName = "myquery"; Properties p = createProperties(); p.setProperty("hibernate.cache.infinispan.myquery.cfg", "timestamps-none-eviction"); p.setProperty("hibernate.cache.infinispan.myquery.memory.eviction.type", "MEMORY"); p.setProperty("hibernate.cache.infinispan.myquery.expiration.wake_up_interval", "2222"); p.setProperty("hibernate.cache.infinispan.myquery.memory.size", "11111"); TestRegionFactory factory = createRegionFactory(p); try { assertTrue(isDefinedCache(factory, "local-query")); InfinispanBaseRegion region = factory.buildQueryResultsRegion(queryRegionName); assertNotNull(factory.getBaseConfiguration(queryRegionName)); assertTrue(isDefinedCache(factory, queryRegionName)); AdvancedCache cache = region.getCache(); Configuration cacheCfg = cache.getCacheConfiguration(); assertEquals(EvictionType.COUNT, cacheCfg.memory().evictionType()); assertEquals(2222, cacheCfg.expiration().wakeUpInterval()); assertEquals( 11111, cacheCfg.memory().size() ); } finally { factory.stop(); } }
private void memory(MeterRegistry registry) { Gauge.builder("cache.memory.size", cache, cache -> cache.getAdvancedCache().getStats().getCurrentNumberOfEntriesInMemory()) .tags(getTagsWithCacheName()) .description("Number of entries currently in the cache, excluding passivated entries") .register(registry); if (cache.getCacheConfiguration().memory().evictionStrategy().isEnabled()) { Gauge.builder("cache.memory.used", cache, cache -> cache.getAdvancedCache().getStats().getDataMemoryUsed()) .tags(getTagsWithCacheName()) .description("Provides how much memory the current eviction algorithm estimates is in use for data") .register(registry); } Gauge.builder("cache.memory.offHeap", cache, cache -> cache.getAdvancedCache().getStats().getOffHeapMemoryUsed()) .tags(getTagsWithCacheName()) .description("The amount of off-heap memory used by this cache") .register(registry); }
private CacheNotifierImpl newNotifier() { CacheNotifierImpl notifier = new CacheNotifierImpl(); AdvancedCache mockCache = mock(AdvancedCache.class, RETURNS_DEEP_STUBS); ComponentRegistry registry = mock(ComponentRegistry.class); Configuration config = mock(Configuration.class, RETURNS_DEEP_STUBS); when(config.clustering().cacheMode()).thenReturn(CacheMode.LOCAL); when(config.memory().storageType()).thenReturn(StorageType.OBJECT); TestingUtil.inject(notifier, mockCache, new ClusteringDependentLogic.LocalLogic(), config, new InternalEntryFactoryImpl(), mock(ClusterEventManager.class), mock(BasicComponentRegistry.class)); return notifier; }
public void testConfigurationOverride() throws Exception { ConfigurationBuilder defaultCfgBuilder = new ConfigurationBuilder(); defaultCfgBuilder.memory().size(200).storageType(StorageType.BINARY); cm = TestCacheManagerFactory.createCacheManager(defaultCfgBuilder); final ConfigurationBuilder cacheCfgBuilder = new ConfigurationBuilder().read(defaultCfgBuilder.build()); cm.defineConfiguration("my-cache", cacheCfgBuilder.build()); Cache<?, ?> cache = cm.getCache("my-cache"); assertEquals(200, cache.getCacheConfiguration().memory().size()); assertEquals(StorageType.BINARY, cache.getCacheConfiguration().memory().storageType()); }
public void testTinyCache() { // Check that we have the correctly configured cache assertEquals(tinyCache.getCacheConfiguration().memory().size(), 1); }
@Test public void testBuildEntityRegionPersonPlusEntityOverridesWithoutCfg() { final String person = "com.acme.Person"; Properties p = createProperties(); // Third option, no cache defined for entity and overrides for generic entity data type and entity itself. p.setProperty("hibernate.cache.infinispan.com.acme.Person.memory.eviction.type", "MEMORY"); p.setProperty("hibernate.cache.infinispan.com.acme.Person.expiration.lifespan", "60000"); p.setProperty("hibernate.cache.infinispan.com.acme.Person.expiration.max_idle", "30000"); p.setProperty("hibernate.cache.infinispan.entity.cfg", "myentity-cache"); p.setProperty("hibernate.cache.infinispan.entity.memory.eviction.type", "FIFO"); p.setProperty("hibernate.cache.infinispan.entity.memory.size", "10000"); p.setProperty("hibernate.cache.infinispan.entity.expiration.wake_up_interval", "3000"); TestRegionFactory factory = createRegionFactory(p); try { factory.getCacheManager(); assertFalse( isDefinedCache(factory, person ) ); InfinispanBaseRegion region = factory.buildEntityRegion(person, AccessType.TRANSACTIONAL); assertTrue( isDefinedCache(factory, person ) ); AdvancedCache cache = region.getCache(); Configuration cacheCfg = cache.getCacheConfiguration(); assertEquals(EvictionType.COUNT, cacheCfg.memory().evictionType()); assertEquals(3000, cacheCfg.expiration().wakeUpInterval()); assertEquals(10000, cacheCfg.memory().size()); assertEquals(60000, cacheCfg.expiration().lifespan()); assertEquals(30000, cacheCfg.expiration().maxIdle()); } finally { factory.stop(); } }