@Override @SuppressWarnings("unchecked") protected void createCacheManagers() throws Throwable { // Car is split into 2 shards: one is going to Infinispan Directory with a shared index, the // other is // going to Ram with a local index ConfigurationBuilder cacheCfg = getDefaultClusteredCacheConfig(CacheMode.REPL_SYNC, false); cacheCfg .indexing() .index(Index.ALL) .addIndexedEntity(Car.class) .addProperty("hibernate.search.car.sharding_strategy.nbr_of_shards", "2") .addProperty("hibernate.search.car.1.directory_provider", "ram") .addProperty( "hibernate.search.car.0.indexmanager", "org.infinispan.query.indexmanager.InfinispanIndexManager") .addProperty("error_handler", "org.infinispan.query.helper.StaticTestingErrorHandler") .addProperty("lucene_version", "LUCENE_CURRENT"); List<Cache<Integer, Object>> cacheList = createClusteredCaches(NUM_NODES, cacheCfg); waitForClusterToForm(BasicCacheContainer.DEFAULT_CACHE_NAME); for (Cache cache : cacheList) { caches.add(cache); } }
@Override protected void createCacheManagers() throws Throwable { // todo [anistor] initializing the server-side context in this way is a hack. normally this // should use the protobuf metadata registry MarshallerRegistration.registerMarshallers( SerializationContextHolder.getSerializationContext()); // initialize client-side serialization context MarshallerRegistration.registerMarshallers(ProtoStreamMarshaller.getSerializationContext()); ConfigurationBuilder builder = hotRodCacheConfiguration(getDefaultClusteredCacheConfig(CacheMode.REPL_SYNC, false)); builder .transaction() .indexing() .enable() .indexLocalOnly(false) .addProperty( "default.directory_provider", "ram") // todo test with "infinispan" provider too .addProperty("lucene_version", "LUCENE_CURRENT"); builder.dataContainer().valueEquivalence(AnyEquivalence.getInstance()); // TODO [anistor] hacks! createHotRodServers(2, builder); }
/** * Implementation of abstract method processModelNode suitable for distributed cache * * @param cache * @param configuration * @param dependencies * @return */ @Override void processModelNode( String containerName, ModelNode cache, ConfigurationBuilder builder, List<Dependency<?>> dependencies) { // process the basic clustered configuration super.processModelNode(containerName, cache, builder, dependencies); // process the additional distributed attributes and elements if (cache.hasDefined(ModelKeys.OWNERS)) { builder.clustering().hash().numOwners(cache.get(ModelKeys.OWNERS).asInt()); } if (cache.hasDefined(ModelKeys.VIRTUAL_NODES)) { builder.clustering().hash().numVirtualNodes(cache.get(ModelKeys.VIRTUAL_NODES).asInt()); } if (cache.hasDefined(ModelKeys.L1_LIFESPAN)) { long lifespan = cache.get(ModelKeys.L1_LIFESPAN).asLong(); if (lifespan > 0) { builder.clustering().l1().lifespan(lifespan); } else { builder.clustering().l1().disable(); } } }
@Override protected EmbeddedCacheManager createCacheManager() throws Exception { cacheStoreDir = new File(TestingUtil.tmpDirectory(this.getClass())); TestingUtil.recursiveFileRemove(cacheStoreDir); ConfigurationBuilder builder = getDefaultClusteredCacheConfig(CacheMode.LOCAL, true, true); builder .transaction() .transactionMode(TransactionMode.TRANSACTIONAL) .lockingMode(LockingMode.PESSIMISTIC) .transactionManagerLookup(new DummyTransactionManagerLookup()) .eviction() .maxEntries(150) .strategy(EvictionStrategy.LIRS) .locking() .lockAcquisitionTimeout(20000) .concurrencyLevel(5000) .useLockStriping(false) .writeSkewCheck(false) .isolationLevel(IsolationLevel.READ_COMMITTED) .dataContainer() .storeAsBinary() .persistence() .passivation(passivationEnabled) .addSingleFileStore() .location(cacheStoreDir.getAbsolutePath()) .fetchPersistentState(true) .ignoreModifications(false) .preload(false) .purgeOnStartup(false); configureConfiguration(builder); return TestCacheManagerFactory.createCacheManager(builder); }
@Test public void testBuildDiffCacheNameTimestampsRegion() { final String timestamps = "org.hibernate.cache.spi.UpdateTimestampsCache"; Properties p = createProperties(); p.setProperty("hibernate.cache.infinispan.timestamps.cfg", "unrecommended-timestamps"); InfinispanRegionFactory factory = createRegionFactory(p); try { EmbeddedCacheManager manager = factory.getCacheManager(); assertFalse(factory.getDefinedConfigurations().contains("timestamp")); assertTrue(factory.getDefinedConfigurations().contains("unrecommended-timestamps")); assertTrue( factory .getTypeOverrides() .get("timestamps") .getCacheName() .equals("unrecommended-timestamps")); ConfigurationBuilder builder = new ConfigurationBuilder(); builder.clustering().stateTransfer().fetchInMemoryState(true); builder.clustering().cacheMode(CacheMode.REPL_SYNC); manager.defineConfiguration("unrecommended-timestamps", builder.build()); TimestampsRegionImpl region = (TimestampsRegionImpl) factory.buildTimestampsRegion(timestamps, p); AdvancedCache cache = region.getCache(); Configuration cacheCfg = cache.getCacheConfiguration(); assertEquals(EvictionStrategy.NONE, cacheCfg.eviction().strategy()); assertEquals(CacheMode.REPL_SYNC, cacheCfg.clustering().cacheMode()); assertFalse(cacheCfg.storeAsBinary().enabled()); assertFalse(cacheCfg.jmxStatistics().enabled()); } finally { factory.stop(); } }
private void stuConfigurationBuilder() { ConfigurationBuilder builder = new ConfigurationBuilder(); ClusteringConfigurationBuilder clusterBuilder = builder.clustering().cacheMode(CacheMode.REPL_SYNC); Configuration config = clusterBuilder.build(); }
public void testDisabledInterceptorStack() { ConfigurationBuilder cfg = new ConfigurationBuilder(); cfg.storeAsBinary().disable(); cm.defineConfiguration("a", cfg.build()); Cache<?, ?> c = cm.getCache("a"); assert TestingUtil.findInterceptor(c, MarshalledValueInterceptor.class) == null; }
private void createRemoteValueWrapperInterceptor(ComponentRegistry cr, Configuration cfg) { RemoteValueWrapperInterceptor wrapperInterceptor = cr.getComponent(RemoteValueWrapperInterceptor.class); if (wrapperInterceptor == null) { wrapperInterceptor = new RemoteValueWrapperInterceptor(); // Interceptor registration not needed, core configuration handling // already does it for all custom interceptors - UNLESS the InterceptorChain already exists in // the component registry! AsyncInterceptorChain ic = cr.getComponent(AsyncInterceptorChain.class); ConfigurationBuilder builder = new ConfigurationBuilder().read(cfg); InterceptorConfigurationBuilder interceptorBuilder = builder.customInterceptors().addInterceptor(); interceptorBuilder.interceptor(wrapperInterceptor); if (cfg.invocationBatching().enabled()) { if (ic != null) ic.addInterceptorAfter(wrapperInterceptor, BatchingInterceptor.class); interceptorBuilder.after(BatchingInterceptor.class); } else { if (ic != null) ic.addInterceptorAfter(wrapperInterceptor, InvocationContextInterceptor.class); interceptorBuilder.after(InvocationContextInterceptor.class); } if (ic != null) { cr.registerComponent(wrapperInterceptor, RemoteValueWrapperInterceptor.class); } cfg.customInterceptors().interceptors(builder.build().customInterceptors().interceptors()); } }
@Override protected EmbeddedCacheManager createCacheManager() throws Exception { ConfigurationBuilder configuration = getDefaultClusteredCacheConfig(CacheMode.LOCAL, true); configuration.transaction().lockingMode(LockingMode.PESSIMISTIC); configure(configuration); return TestCacheManagerFactory.createCacheManager(configuration); }
/** * Create the default configuration. * * @return the default cache configuration. */ protected ConfigurationBuilder createDefaultConfigurationBuilder() { ConfigurationBuilder configurationBuilder = new ConfigurationBuilder(); configurationBuilder.transaction().transactionMode(TransactionMode.TRANSACTIONAL); configurationBuilder.transaction().transactionManagerLookup(transactionManagerLookupInstance()); configurationBuilder.transaction().lockingMode(LockingMode.PESSIMISTIC); return configurationBuilder; }
@Override protected ConfigurationBuilder createCacheConfigBuilder() { ConfigurationBuilder c = getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC, true); c.clustering().hash().numOwners(100).numSegments(4).l1().disable(); c.transaction().transactionProtocol(TransactionProtocol.TOTAL_ORDER).recovery().disable(); return c; }
@Override protected void createCacheManagers() throws Throwable { ConfigurationBuilder defaultConfiguration = getDefaultClusteredCacheConfig(CacheMode.REPL_SYNC, false); defaultConfiguration.clustering().stateTransfer().fetchInMemoryState(true); createClusteredCaches(2, defaultConfiguration); ConfigurationBuilder cfg = initialCacheConfiguration(); cfg.clustering() .stateTransfer() .fetchInMemoryState(true) .indexing() .index(Index.LOCAL) .addIndexedEntity(getModelFactory().getUserImplClass()) .addIndexedEntity(getModelFactory().getAccountImplClass()) .addIndexedEntity(getModelFactory().getTransactionImplClass()) .addProperty( "default.indexmanager", "org.infinispan.query.indexmanager.InfinispanIndexManager") .addProperty("lucene_version", "LUCENE_CURRENT"); manager(0).defineConfiguration(TEST_CACHE_NAME, cfg.build()); manager(1).defineConfiguration(TEST_CACHE_NAME, cfg.build()); cache1 = manager(0).getCache(TEST_CACHE_NAME); cache2 = manager(1).getCache(TEST_CACHE_NAME); }
@Override protected ConfigurationBuilder getCacheConfig() { ConfigurationBuilder builder = hotRodCacheConfiguration(getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC, false)); builder.clustering().hash().numOwners(1); return builder; }
@Override protected void createCacheManagers() throws Throwable { ConfigurationBuilder cfgBuilder = hotRodCacheConfiguration(getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC, false)); cfgBuilder .indexing() .index(Index.ALL) .addProperty("default.directory_provider", "ram") .addProperty("lucene_version", "LUCENE_CURRENT"); createHotRodServers(NUM_NODES, cfgBuilder); waitForClusterToForm(); remoteCache = client(0).getCache(); // initialize server-side serialization context RemoteCache<String, String> metadataCache = client(0).getCache(ProtobufMetadataManagerConstants.PROTOBUF_METADATA_CACHE_NAME); metadataCache.put( "sample_bank_account/bank.proto", Util.read( Util.getResourceAsStream( "/sample_bank_account/bank.proto", getClass().getClassLoader()))); assertFalse(metadataCache.containsKey(ProtobufMetadataManagerConstants.ERRORS_KEY_SUFFIX)); // initialize client-side serialization context MarshallerRegistration.registerMarshallers( ProtoStreamMarshaller.getSerializationContext(client(0))); }
@Override protected EmbeddedCacheManager createCacheManager() throws Exception { final ConfigurationBuilder builder = getDefaultStandaloneCacheConfig(true); builder .indexing() .index(Index.LOCAL) .addIndexedEntity(TestEntity.class) .addProperty("default.directory_provider", "ram") .addProperty("lucene_version", "LUCENE_CURRENT") .security() .authorization() .enable() .role("admin") .role("query") .role("noquery"); return Subject.doAs( ADMIN, new PrivilegedAction<EmbeddedCacheManager>() { @Override public EmbeddedCacheManager run() { EmbeddedCacheManager ecm = TestCacheManagerFactory.createCacheManager(getSecureGlobalConfiguration(), builder); ecm.getCache(); return ecm; } }); }
public void testCorrectShutdown() { CacheContainer cc = null; try { ConfigurationBuilder cfg = new ConfigurationBuilder(); cfg.transaction() .transactionMode(TransactionMode.TRANSACTIONAL) .indexing() .index(Index.ALL) .addProperty("default.directory_provider", "ram") .addProperty("lucene_version", "LUCENE_CURRENT"); cc = TestCacheManagerFactory.createCacheManager(cfg); Cache<?, ?> cache = cc.getCache(); SearchFactoryIntegrator sfi = TestingUtil.extractComponent(cache, SearchFactoryIntegrator.class); assert !sfi.isStopped(); cc.stop(); assert sfi.isStopped(); } finally { // proper cleanup for exceptional execution TestingUtil.killCacheManagers(cc); } }
private ConfigurationBuilder getCB() { ConfigurationBuilder cb = new ConfigurationBuilder(); cb.clustering() .cacheMode(CacheMode.DIST_SYNC) .sync() .replTimeout(60000) .stateTransfer() .timeout(180000) .fetchInMemoryState(true) .hash() .numOwners(1); // transactions cb.transaction() .transactionMode(TransactionMode.TRANSACTIONAL) .lockingMode(LockingMode.PESSIMISTIC) .syncCommitPhase(true) .syncRollbackPhase(true); // cb.transaction().transactionMode(TransactionMode.NON_TRANSACTIONAL); cb.loaders().passivation(false).preload(true).shared(true); // Make it really shared by adding the test's name as store name cb.loaders() .addStore(DummyInMemoryCacheStoreConfigurationBuilder.class) .storeName(getClass().getSimpleName()) .async() .disable(); return cb; }
@Override protected void afterSitesCreated() { super.afterSitesCreated(); ConfigurationBuilder builder = newConfiguration(); builder.sites().addBackup().site(siteName(2)).strategy(BackupConfiguration.BackupStrategy.SYNC); defineInSite(site(0), CacheType.BACKUP_TO_SITE_2.name(), builder.build()); defineInSite(site(2), CacheType.BACKUP_TO_SITE_2.name(), newConfiguration().build()); builder = newConfiguration(); builder.sites().addBackup().site(siteName(1)).strategy(BackupConfiguration.BackupStrategy.SYNC); builder.sites().addBackup().site(siteName(2)).strategy(BackupConfiguration.BackupStrategy.SYNC); defineInSite(site(0), CacheType.BACKUP_TO_SITE_1_AND_2.name(), builder.build()); defineInSite(site(1), CacheType.BACKUP_TO_SITE_1_AND_2.name(), newConfiguration().build()); defineInSite(site(2), CacheType.BACKUP_TO_SITE_1_AND_2.name(), newConfiguration().build()); defineInSite(site(0), CacheType.NO_BACKUP.name(), newConfiguration().build()); // wait for caches in primary cluster site(0).waitForClusterToForm(null); site(0).waitForClusterToForm(CacheType.BACKUP_TO_SITE_1_AND_2.name()); site(0).waitForClusterToForm(CacheType.BACKUP_TO_SITE_1_AND_2.name()); site(0).waitForClusterToForm(CacheType.BACKUP_TO_SITE_2.name()); // wait for caches in backup site 1 site(1).waitForClusterToForm(null); site(1).waitForClusterToForm(CacheType.BACKUP_TO_SITE_1_AND_2.name()); // wait for caches in backup site 2 site(2).waitForClusterToForm(CacheType.BACKUP_TO_SITE_1_AND_2.name()); site(2).waitForClusterToForm(CacheType.BACKUP_TO_SITE_2.name()); }
protected ConfigurationBuilder getConfig() { ConfigurationBuilder dcc = getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC, true); dcc.transaction().locking().writeSkewCheck(true); dcc.transaction().locking().isolationLevel(IsolationLevel.REPEATABLE_READ); dcc.transaction().versioning().enable().scheme(VersioningScheme.SIMPLE); return dcc; }
private HotRodServer addHotRodServer() { EmbeddedCacheManager cm = addClusterEnabledCacheManager(defaultBuilder); cm.defineConfiguration(DIST_ONE_CACHE_NAME, distOneBuilder.build()); cm.defineConfiguration(DIST_TWO_CACHE_NAME, distTwoBuilder.build()); HotRodServer server = HotRodClientTestingUtil.startHotRodServer(cm); addr2hrServer.put(new InetSocketAddress(server.getHost(), server.getPort()), server); return server; }
protected EmbeddedCacheManager createCacheManager() throws Exception { ConfigurationBuilder c = getDefaultStandaloneCacheConfig(true); c.indexing() .enable() .addProperty("hibernate.search.default.directory_provider", "ram") .addProperty("hibernate.search.lucene_version", "LUCENE_CURRENT"); return TestCacheManagerFactory.createCacheManager(c); }
@Test public void testDummyTMGetCache() { ConfigurationBuilder cb = new ConfigurationBuilder(); cb.transaction() .use1PcForAutoCommitTransactions(true) .transactionManagerLookup(new DummyTransactionManagerLookup()); DefaultCacheManager cm = new DefaultCacheManager(cb.build()); cm.getCache(); }
@Override protected EmbeddedCacheManager createCacheManager() throws Exception { ConfigurationBuilder cfg = getDefaultStandaloneCacheConfig(false); cfg.indexing() .index(Index.ALL) .addProperty("default.directory_provider", "ram") .addProperty("error_handler", "org.infinispan.query.helper.StaticTestingErrorHandler"); return TestCacheManagerFactory.createCacheManager(cfg); }
@Override protected void createCacheManagers() throws Throwable { dccc = getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC, true, true); dccc.transaction().transactionManagerLookup(new DummyTransactionManagerLookup()); dccc.clustering().hash().l1().disable().locking().lockAcquisitionTimeout(1000l); dccc.clustering().stateTransfer().fetchInMemoryState(true); createCluster(dccc, 2); waitForClusterToForm(); }
protected EmbeddedCacheManager createCacheManager() throws Exception { ConfigurationBuilder cfg = getDefaultStandaloneCacheConfig(true); cfg.indexing() .index(Index.ALL) .addIndexedEntity(Car.class) .addProperty("default.directory_provider", "ram") .addProperty("lucene_version", "LUCENE_CURRENT"); return TestCacheManagerFactory.createCacheManager(cfg); }
private static ConfigurationBuilder createConfigurationBuilder() { ConfigurationBuilder builder = getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC, false); builder.clustering().stateTransfer().fetchInMemoryState(true); builder.clustering().hash().groups().enabled(true); builder.clustering().hash().numOwners(2); builder.clustering().hash().numSegments(1); builder.clustering().hash().consistentHashFactory(new CustomConsistentHashFactory()); return builder; }
private Configuration buildConfiguration(boolean tx) { ConfigurationBuilder cb = getDefaultClusteredCacheConfig(CacheMode.REPL_ASYNC, tx); cb.clustering().async().useReplQueue(true).replQueueInterval(100).replQueueMaxElements(3); // These are the default: // .asyncMarshalling(false) // .stateTransfer().fetchInMemoryState(true) // .locking().useLockStriping(false); return cb.build(); }
protected ConfigurationBuilder getConfigurationBuilder() { ConfigurationBuilder cfgBuilder = new ConfigurationBuilder(); cfgBuilder .indexing() .index(Index.ALL) .addProperty("default.directory_provider", "ram") .addProperty("lucene_version", "LUCENE_CURRENT"); return cfgBuilder; }
@Override protected EmbeddedCacheManager createCacheManager() throws Exception { ConfigurationBuilder cfg = getDefaultStandaloneCacheConfig(true); cfg.indexing() .index(Index.ALL) .addProperty("default.directory_provider", "filesystem") .addProperty("default.indexBase", indexDirectory) .addProperty("lucene_version", "LUCENE_CURRENT"); return TestCacheManagerFactory.createCacheManager(cfg); }
@Override protected EmbeddedCacheManager createCacheManager() throws Exception { // start a single cache instance ConfigurationBuilder c = getDefaultStandaloneCacheConfig(true); c.storeAsBinary().enable(); EmbeddedCacheManager cm = TestCacheManagerFactory.createCacheManager(false); cm.defineConfiguration("lazy-cache-test", c.build()); cache = cm.getCache("lazy-cache-test"); return cm; }