@Override public Configuration get() { ConfigurationBuilder builder = new ConfigurationBuilder(); this.consumer.accept(builder); Configuration configuration = builder.build(); this.container.get().defineConfiguration(this.cacheName, configuration); return configuration; }
@Override public PartitionHandlingConfiguration get() { return new ConfigurationBuilder().clustering().partitionHandling() .whenSplit(this.enabled ? PartitionHandling.DENY_READ_WRITES : PartitionHandling.ALLOW_READ_WRITES) .mergePolicy(MergePolicy.NONE) .create(); }
new ConfigurationBuilder().persistence(); persistConfig.passivation(false); final SingleFileStoreConfigurationBuilder fileStore = final Configuration config = persistConfig.addStore(fileStore).build(); config.compatibility().enabled(); manager.getManager().defineConfiguration(namedCache, config);
private EmbeddedCacheManager createTestCacheManager() { ConfigurationBuilder config = new ConfigurationBuilder(); config.clustering().cacheMode(CacheMode.REPL_ASYNC); EmbeddedCacheManager cm = TestCacheManagerFactory.createClusteredCacheManager(config); config = new ConfigurationBuilder(); cm.defineConfiguration("local", config.build()); return cm; }
@Test(expectedExceptions = CacheConfigurationException.class) public void testClashingNames() { EmbeddedCacheManager cm = createCacheManager(false); try { ConfigurationBuilder c = new ConfigurationBuilder(); cm.defineConfiguration("aCache", c.build()); cm.defineConfiguration("aCache", c.build()); } finally { TestingUtil.killCacheManagers(cm); } }
@Override public void call() { cm.defineConfiguration("foo", new ConfigurationBuilder().build()); } });
@Override protected void createCacheManagers() throws Throwable { ConfigurationBuilder builderUsed = new ConfigurationBuilder(); builderUsed.clustering().cacheMode(CacheMode.DIST_SYNC); createClusteredCaches(3, CACHE_NAME, builderUsed); }
@Override protected EmbeddedCacheManager createCacheManager() throws Exception { ConfigurationBuilder builder = new ConfigurationBuilder(); return TestCacheManagerFactory.createCacheManager(builder); }
@BeforeMethod public void setUp() throws Exception { ConfigurationBuilder c = new ConfigurationBuilder(); c .transaction().transactionMode(TransactionMode.NON_TRANSACTIONAL) .clustering().cacheMode(CacheMode.LOCAL) .locking().isolationLevel(IsolationLevel.REPEATABLE_READ); cm = TestCacheManagerFactory.createCacheManager(c); cache = getCache(); CacheNotifier mockNotifier = mock(CacheNotifier.class); TestingUtil.replaceComponent(cache, CacheNotifier.class, mockNotifier, true); }
@Test(expectedExceptions = CacheConfigurationException.class) public void testWrongCacheModeConfiguration() throws Exception { ConfigurationBuilder config = new ConfigurationBuilder(); config.clustering().cacheMode(CacheMode.REPL_ASYNC); TestCacheManagerFactory.createCacheManager(config); }
public void testInvocationBatchingAndInducedTm() { final ConfigurationBuilder cb = new ConfigurationBuilder(); cb.invocationBatching().enable(); assert cb.build().transaction().transactionMode().isTransactional(); withCacheManager(new CacheManagerCallable(TestCacheManagerFactory.createCacheManager(cb)){ @Override public void call() { assert cm.getCache().getAdvancedCache().getTransactionManager() != null; } }); }
@Override protected Cache<Object, Object> getCache() { cm.defineConfiguration("simple", new ConfigurationBuilder().read(cm.getDefaultCacheConfiguration()) .clustering().simpleCache(true) .jmxStatistics().available(false) .build()); Cache cache = cm.getCache("simple"); // without any listeners the notifications are ignored cache.addListener(new DummyListener()); return cache; }
@BeforeMethod private void configureBeforeMethod() { mockedCacheManager = mock(DefaultCacheManager.class); // We return the real global component registry to avoid to mock all the dependencies in the world when(mockedCacheManager.getGlobalComponentRegistry()).thenReturn(cacheManager.getGlobalComponentRegistry()); internalCacheRegistry.registerInternalCache(INTERNAL_CACHE_NAME, new ConfigurationBuilder().clustering().cacheMode(CacheMode.DIST_ASYNC).build(), EnumSet.of(InternalCacheRegistry.Flag.EXCLUSIVE)); cacheManager.defineConfiguration(CACHE_NAME, new ConfigurationBuilder().build()); }
@Test(expectedExceptions=IllegalStateException.class) public void testConfigurationUndefineWhileInUse() { cm = TestCacheManagerFactory.createCacheManager(); cm.defineConfiguration("testConfig", new ConfigurationBuilder().build()); cm.getCache("testConfig"); cm.undefineConfiguration("testConfig"); }
protected void postConfigure(List<EmbeddedCacheManager> cacheManagers) { ConfigurationBuilder builder = new ConfigurationBuilder(); builder.indexing().index(Index.NONE); Configuration configuration = builder.build(); cacheManagers.forEach(cm -> { cm.defineConfiguration(DEFAULT_LOCKING_CACHENAME, configuration); cm.defineConfiguration(DEFAULT_INDEXESDATA_CACHENAME, configuration); cm.defineConfiguration(DEFAULT_INDEXESMETADATA_CACHENAME, configuration); }); }
@Override protected void createCacheManagers() throws Throwable { builderUsed = new ConfigurationBuilder(); builderUsed.clustering().cacheMode(CacheMode.INVALIDATION_SYNC); createClusteredCaches(3, CACHE_NAME, builderUsed); }
@Test(expectedExceptions=CacheException.class) public void testForeignExternalizerIdNegative() { GlobalConfigurationBuilder global = createForeignExternalizerGlobalConfig(-1); TestCacheManagerFactory.createCacheManager(global, new ConfigurationBuilder()); }
@Override public EmbeddedCacheManager get() { GlobalConfiguration config = this.configuration.get(); String defaultCacheName = config.defaultCacheName().orElse(null); // We need to create a dummy default configuration if cache has a default cache Configuration defaultConfiguration = (defaultCacheName != null) ? new ConfigurationBuilder().build() : null; EmbeddedCacheManager manager = new DefaultCacheManager(config, defaultConfiguration, false); // Undefine the default cache, if we defined one if (defaultCacheName != null) { manager.undefineConfiguration(defaultCacheName); } // Override GlobalConfigurationManager with a local implementation @SuppressWarnings("deprecation") BasicComponentRegistry registry = manager.getGlobalComponentRegistry().getComponent(BasicComponentRegistry.class); registry.replaceComponent(GlobalConfigurationManager.class.getName(), new LocalGlobalConfigurationManager(), false); registry.rewire(); manager.start(); manager.addListener(this); InfinispanLogger.ROOT_LOGGER.debugf("%s cache container started", this.name); return manager; }
@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 public StateTransferConfiguration get() { boolean timeoutEnabled = this.timeout > 0; return new ConfigurationBuilder().clustering().stateTransfer() .chunkSize(this.chunkSize) .fetchInMemoryState(true) .awaitInitialTransfer(timeoutEnabled) .timeout(timeoutEnabled ? this.timeout : Long.MAX_VALUE) .create(); }