@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 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; }
@BeforeMethod public void setUp() { n = new CacheNotifierImpl(); mockCache = mock(EncoderCache.class, RETURNS_DEEP_STUBS); when(mockCache.getAdvancedCache()).thenReturn(mockCache); when(mockCache.getKeyDataConversion()).thenReturn(DataConversion.DEFAULT_KEY); when(mockCache.getValueDataConversion()).thenReturn(DataConversion.DEFAULT_VALUE); Configuration config = mock(Configuration.class, RETURNS_DEEP_STUBS); when(config.memory().storageType()).thenReturn(StorageType.OBJECT); when(mockCache.getStatus()).thenReturn(ComponentStatus.INITIALIZING); MockBasicComponentRegistry mockRegistry = new MockBasicComponentRegistry(); when(mockCache.getComponentRegistry().getComponent(BasicComponentRegistry.class)).thenReturn(mockRegistry); mockRegistry.registerMocks(RpcManager.class, StreamingMarshaller.class, CancellationService.class, CommandsFactory.class, Encoder.class); TestingUtil.inject(n, mockCache, cdl, config, mockRegistry, mock(InternalEntryFactory.class), mock(ClusterEventManager.class), mock(KeyPartitioner.class)); cl = new PrimaryOwnerCacheListener(); n.start(); n.addListener(cl); ctx = new NonTxInvocationContext(null); }
@Override public void setEnvironment(Cache<Object, Object> cache, Set<Object> inputKeys) { AdvancedCache<Object, Object> unwrapped = SecurityActions.getUnwrappedCache(cache).getAdvancedCache(); if (unwrapped.getCacheConfiguration().memory().storageType() == StorageType.OBJECT) { this.cache = unwrapped.withWrapping(ByteArrayWrapper.class, IdentityWrapper.class); } else { this.cache = cache; //todo [anistor] why not `unwrapped` instead ? do we need security for mass indexing ? } SearchIntegrator searchIntegrator = ComponentRegistryUtils.getSearchIntegrator(unwrapped); KeyTransformationHandler keyTransformationHandler = ComponentRegistryUtils.getKeyTransformationHandler(unwrapped); TimeService timeService = ComponentRegistryUtils.getTimeService(unwrapped); this.indexUpdater = new IndexUpdater(searchIntegrator, keyTransformationHandler, timeService); this.clusteringDependentLogic = SecurityActions.getClusteringDependentLogic(unwrapped); if (everywhereKeys != null) keys.addAll(everywhereKeys); if (inputKeys != null) keys.addAll(inputKeys); keyDataConversion = unwrapped.getKeyDataConversion(); valueDataConversion = unwrapped.getValueDataConversion(); }
@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 Cache<?, ?> checkValidConfiguration(final Cache<?, ?> cache, String indexName) { Configuration configuration = cache.getCacheConfiguration(); if (configuration.expiration().maxIdle() != -1) { throw log.luceneStorageHavingIdleTimeSet(indexName, cache.getName()); } if (configuration.expiration().lifespan() != -1) { throw log.luceneStorageHavingLifespanSet(indexName, cache.getName()); } if (configuration.memory().storageType() == StorageType.BINARY) { throw log.luceneStorageAsBinaryEnabled(indexName, cache.getName()); } if (!Configurations.noDataLossOnJoiner(configuration)) { throw log.luceneStorageNoStateTransferEnabled(indexName, cache.getName()); } return cache; }
public void testBackwardCompatibility() { ConfigurationBuilder c = new ConfigurationBuilder(); c.memory().storageType(StorageType.BINARY); ecm = TestCacheManagerFactory.createCacheManager(c); assertEquals(StorageType.BINARY, ecm.getCache().getCacheConfiguration().memory().storageType()); }
private static Cache<?, ?> checkValidConfiguration(final Cache<?, ?> cache, String indexName) { Configuration configuration = cache.getCacheConfiguration(); if (configuration.expiration().maxIdle() != -1) { throw log.luceneStorageHavingIdleTimeSet(indexName, cache.getName()); } if (configuration.expiration().lifespan() != -1) { throw log.luceneStorageHavingLifespanSet(indexName, cache.getName()); } if (configuration.memory().storageType() == StorageType.BINARY) { throw log.luceneStorageAsBinaryEnabled(indexName, cache.getName()); } if (!Configurations.noDataLossOnJoiner(configuration)) { throw log.luceneStorageNoStateTransferEnabled(indexName, cache.getName()); } return cache; }
@Override public void call() { Configuration cfg = cm.getDefaultCacheConfiguration(); assertTrue(cfg.dataContainer().<byte[]>keyEquivalence() instanceof AnyEquivalence); assertTrue(cfg.dataContainer().<byte[]>valueEquivalence() instanceof AnyEquivalence); assertEquals(StorageType.OBJECT, cfg.memory().storageType()); } });
public void testConfigCloning() { ConfigurationBuilder c = new ConfigurationBuilder(); c.memory().storageType(StorageType.BINARY); ConfigurationBuilder builder = new ConfigurationBuilder().read(c.build()); Configuration clone = builder.build(); assertEquals(StorageType.BINARY, clone.memory().storageType()); }
@Override public void call() { Configuration cfg = cm.getDefaultCacheConfiguration(); assertTrue(cfg.dataContainer().<byte[]>keyEquivalence() instanceof AnyEquivalence); assertTrue(cfg.dataContainer().<byte[]>valueEquivalence() instanceof AnyEquivalence); assertEquals(StorageType.BINARY, cfg.memory().storageType()); } });
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()); }
@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()); } },
@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()); } });
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 testConfigOverriding() { ConfigurationBuilder c = new ConfigurationBuilder(); c.memory().storageType(StorageType.BINARY); ecm = TestCacheManagerFactory.createCacheManager(c); ecm.defineConfiguration("newCache", new ConfigurationBuilder().read(c.build()).memory().storageType(StorageType.OBJECT).build()); assertEquals(StorageType.OBJECT, ecm.getCache("newCache").getCacheConfiguration().memory().storageType()); }
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()); }
@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 testBuildDiffCacheNameTimestampsRegion() { final String timestamps = "org.hibernate.cache.spi.UpdateTimestampsCache"; final String unrecommendedTimestamps = "unrecommended-timestamps"; Properties p = createProperties(); p.setProperty( TIMESTAMPS_CACHE_RESOURCE_PROP, unrecommendedTimestamps); TestRegionFactory factory = createRegionFactory(p, m -> { ConfigurationBuilder builder = new ConfigurationBuilder(); builder.clustering().stateTransfer().fetchInMemoryState(true); builder.clustering().cacheMode( CacheMode.REPL_SYNC ); m.defineConfiguration(unrecommendedTimestamps, builder.build() ); }); try { assertEquals(unrecommendedTimestamps, factory.getBaseConfiguration(InfinispanProperties.TIMESTAMPS)); InfinispanBaseRegion region = factory.buildTimestampsRegion(timestamps); AdvancedCache cache = region.getCache(); Configuration cacheCfg = cache.getCacheConfiguration(); assertEquals(CacheMode.REPL_SYNC, cacheCfg.clustering().cacheMode()); assertTrue(cacheCfg.memory().storageType() != StorageType.BINARY); assertFalse(cacheCfg.jmxStatistics().enabled()); } finally { factory.stop(); } }
public void testPreloadStoredAsBinary() { ConfigurationBuilder cb = TestCacheManagerFactory.getDefaultCacheConfiguration(false); createCacheStoreConfig(cb.persistence(), true).memory().storageType(StorageType.BINARY); cacheManager.defineConfiguration("testPreloadStoredAsBinary", cb.build()); Cache<String, Pojo> cache = cacheManager.getCache("testPreloadStoredAsBinary"); cache.start(); assert cache.getCacheConfiguration().persistence().preload(); assertEquals(StorageType.BINARY, cache.getCacheConfiguration().memory().storageType()); cache.put("k1", new Pojo(1)); cache.put("k2", new Pojo(2), 111111, TimeUnit.MILLISECONDS); cache.put("k3", new Pojo(3), -1, TimeUnit.MILLISECONDS, 222222, TimeUnit.MILLISECONDS); cache.put("k4", new Pojo(4), 333333, TimeUnit.MILLISECONDS, 444444, TimeUnit.MILLISECONDS); cache.stop(); cache.start(); assertEquals(4, cache.entrySet().size()); assertEquals(new Pojo(1), cache.get("k1")); assertEquals(new Pojo(2), cache.get("k2")); assertEquals(new Pojo(3), cache.get("k3")); assertEquals(new Pojo(4), cache.get("k4")); }