@Override public GlobalConfiguration get() { org.infinispan.configuration.global.GlobalConfigurationBuilder builder = new org.infinispan.configuration.global.GlobalConfigurationBuilder(); if (this.defaultCache != null) { builder.defaultCacheName(this.defaultCache); builder.transport().transport(transport.transport()) .distributedSyncTimeout(transport.distributedSyncTimeout()) .clusterName(transport.clusterName()) .machineId(transport.machineId()) .rackId(transport.rackId()) .siteId(transport.siteId()) builder.transport().transportThreadPool().read(this.pools.get(ThreadPoolResourceDefinition.TRANSPORT).get()); builder.transport().remoteCommandThreadPool().read(this.pools.get(ThreadPoolResourceDefinition.REMOTE_COMMAND).get()); builder.asyncThreadPool().read(this.pools.get(ThreadPoolResourceDefinition.ASYNC_OPERATIONS).get()); builder.shutdown().hookBehavior(ShutdownHookBehavior.DONT_REGISTER); builder.globalJmxStatistics() .enabled(this.statisticsEnabled) .cacheManagerName(this.name) .mBeanServerLookup(new MBeanServerProvider((this.server != null) ? this.server.get() : null)) .jmxDomain("org.wildfly.clustering.infinispan") .allowDuplicateDomains(true);
@Override public void start() { GlobalConfigurationBuilder builder = new GlobalConfigurationBuilder(); // WFLY-6685 Prevent Infinispan from registering channel mbeans // The JGroups subsystem already does this builder.globalJmxStatistics().read(this.configuration.globalJmxStatistics()).disable(); // ISPN-4755 workaround TransportConfiguration transport = this.configuration.transport(); builder.transport() .clusterName(transport.clusterName()) .distributedSyncTimeout(transport.distributedSyncTimeout()) .initialClusterSize(transport.initialClusterSize()) .initialClusterTimeout(transport.initialClusterTimeout(), TimeUnit.MILLISECONDS) .machineId(transport.machineId()) .nodeName(transport.nodeName()) .rackId(transport.rackId()) .siteId(transport.siteId()) .transport(transport.transport()) .withProperties(transport.properties()) ; this.configuration = builder.build(); super.start(); }
@Override public TransportConfiguration get() { return new GlobalConfigurationBuilder().transport().transport(null).create(); } }
@Override public TransportConfiguration get() { ChannelFactory factory = this.factory.get(); ProtocolStackConfiguration stack = factory.getProtocolStackConfiguration(); org.wildfly.clustering.jgroups.spi.TransportConfiguration.Topology topology = stack.getTransport().getTopology(); TransportConfigurationBuilder builder = new GlobalConfigurationBuilder().transport() .clusterName(this.cluster.get()) .distributedSyncTimeout(this.lockTimeout) .transport(new ChannelFactoryTransport(factory)) ; if (topology != null) { builder.siteId(topology.getSite()).rackId(topology.getRack()).machineId(topology.getMachine()); } return builder.create(); }
public void testConfigurationProperties() throws Exception { GlobalConfigurationBuilder globalConfiguration = GlobalConfigurationBuilder.defaultClusteredBuilder(); globalConfiguration.transport().siteId("TESTVALUE1"); globalConfiguration.transport().rackId("TESTVALUE2"); globalConfiguration.transport().machineId("TESTVALUE3"); globalConfiguration.globalJmxStatistics().enable().mBeanServerLookup(new PerThreadMBeanServerLookup()); cm = TestCacheManagerFactory.createClusteredCacheManager(globalConfiguration, new ConfigurationBuilder()); String jmxDomain = cm.getCacheManagerConfiguration().globalJmxStatistics().domain(); ConfigurationBuilder localCache = config(); localCache.memory().storageType(StorageType.BINARY); cm.defineConfiguration("local_cache1", localCache.build()); localCache.memory().storageType(StorageType.OBJECT); cm.defineConfiguration("local_cache2", localCache.build()); cm.getCache("local_cache1"); cm.getCache("local_cache2"); MBeanServer mBeanServer = PerThreadMBeanServerLookup.getThreadMBeanServer(); Properties props1 = (Properties) mBeanServer.getAttribute(getCacheObjectName(jmxDomain, "local_cache1(local)", "Cache"), "configurationAsProperties"); Properties props2 = (Properties) mBeanServer.getAttribute(getCacheObjectName(jmxDomain, "local_cache2(local)", "Cache"), "configurationAsProperties"); Properties propsGlobal = (Properties) mBeanServer.getAttribute(getCacheManagerObjectName(jmxDomain), "globalConfigurationAsProperties"); assert "BINARY".equals(props1.getProperty("memory.storageType")); assert "OBJECT".equals(props2.getProperty("memory.storageType")); log.tracef("propsGlobal=%s", propsGlobal); assert "TESTVALUE1".equals(propsGlobal.getProperty("transport.siteId")); assert "TESTVALUE2".equals(propsGlobal.getProperty("transport.rackId")); assert "TESTVALUE3".equals(propsGlobal.getProperty("transport.machineId")); }
globalConfiguration = new GlobalConfigurationBuilder() .classLoader(LDCachingInfinispanBackend.class.getClassLoader()) .transport() .defaultTransport() .clusterName(clusterName) .machineId(machineName) .addProperty("configurationXml", jgroupsXml) .globalJmxStatistics() .jmxDomain("org.apache.marmotta.ldcache") .allowDuplicateDomains(true) .serialization() .addAdvancedExternalizer(new ModelExternalizer()) .addAdvancedExternalizer(new ValueExternalizer()) .classLoader(LDCachingInfinispanBackend.class.getClassLoader()) .transport() .defaultTransport() .clusterName(clusterName) .machineId(machineName) .addProperty("configurationFile", "jgroups-ldcache.xml") .globalJmxStatistics() .jmxDomain("org.apache.marmotta.ldcache") .allowDuplicateDomains(true) defaultConfiguration = new ConfigurationBuilder() .clustering() .cacheMode(CacheMode.DIST_ASYNC) .async()
manager = new DefaultCacheManager(configXml); } else { GlobalConfigurationBuilder globalConfigurationBuilder = new GlobalConfigurationBuilder(); ConfigurationBuilder configurationBuilder = new ConfigurationBuilder(); globalConfigurationBuilder.read(infinispanGlobalConfigurer.getGlobalConfiguration()); } else { globalConfigurationBuilder.globalJmxStatistics().jmxDomain(DEFAULT_JMX_DOMAIN).enable(); globalConfigurationBuilder.transport().clusterName(infinispanProperties.getClusterName()); configurationCustomizers.forEach(customizer -> customizer.customize(configurationBuilder)); manager = new DefaultCacheManager(globalConfigurationBuilder.build(), configurationBuilder.build());
private void createEmbeddedCache() { GlobalConfigurationBuilder globalBuilder; if (cacheMode.isClustered()) { globalBuilder = new GlobalConfigurationBuilder(); globalBuilder.transport().defaultTransport(); } else { globalBuilder = new GlobalConfigurationBuilder().nonClusteredDefault(); } globalBuilder.addModule(PrivateGlobalConfigurationBuilder.class).serverMode(true); org.infinispan.configuration.cache.ConfigurationBuilder builder = new org.infinispan.configuration.cache.ConfigurationBuilder(); builder.clustering().cacheMode(cacheMode) .compatibility().enable().marshaller(marshaller); if (cacheMode.isDistributed() && numOwners != DEFAULT_NUM_OWNERS) { builder.clustering().hash().numOwners(numOwners); } if (cacheMode.isDistributed() && l1Enable) { builder.clustering().l1().enable(); } cacheManager = cacheMode.isClustered() ? TestCacheManagerFactory.createClusteredCacheManager(globalBuilder, builder) : TestCacheManagerFactory.createCacheManager(globalBuilder, builder); if (!cacheName.isEmpty()) cacheManager.defineConfiguration(cacheName, builder.build()); embeddedCache = cacheName.isEmpty() ? cacheManager.getCache() : cacheManager.getCache(cacheName); }
private EmbeddedCacheManager infinispanCacheManager() { // Embedded Cluster Setting! GlobalConfigurationBuilder global = GlobalConfigurationBuilder.defaultClusteredBuilder(); global.clusteredDefault() .globalJmxStatistics() .allowDuplicateDomains(true) .transport() .addProperty("configurationFile", configFile) .clusterName("metatron-discovery-v20"); ConfigurationBuilder config = new ConfigurationBuilder(); config.expiration().lifespan(5, TimeUnit.SECONDS); config.clustering().cacheMode(CacheMode.DIST_SYNC); DefaultCacheManager cacheManager = new DefaultCacheManager(global.build(), config.build()); cacheManager.addListener(new InfinispanClusterListener(2)); return cacheManager; } }
/** * Creates the embedded cache manager. * * @return the embedded cache manager. */ public static EmbeddedCacheManager createManager() { final GlobalConfigurationBuilder globalBuilder = new GlobalConfigurationBuilder(); globalBuilder.nonClusteredDefault().globalJmxStatistics() .allowDuplicateDomains(true).transport() .clusterName(CLUSTER_NAME); final GlobalConfiguration globalCfg = globalBuilder.build(); final ConfigurationBuilder builder = new ConfigurationBuilder(); builder.clustering().cacheMode(CacheMode.LOCAL).indexing().disable(); final Configuration cfg = builder.build(); final EmbeddedCacheManager manager = new DefaultCacheManager(globalCfg, cfg); return manager; }
private EmbeddedCacheManager createCacheManager(String name1, JChannel ch1) { GlobalConfigurationBuilder gcb1 = new GlobalConfigurationBuilder(); gcb1.transport().nodeName(ch1.getName()).distributedSyncTimeout(10, SECONDS); CustomChannelLookup.registerChannel(gcb1, ch1, name1, false); ConfigurationBuilder replCfg = new ConfigurationBuilder(); replCfg.clustering().cacheMode(CacheMode.REPL_SYNC); replCfg.clustering().stateTransfer().timeout(10, SECONDS); EmbeddedCacheManager cm1 = new DefaultCacheManager(gcb1.build(), replCfg.build(), false); registerCacheManager(cm1); cm1.defineConfiguration(CACHE_NAME, replCfg.build()); return cm1; }
public void testConfigBuilder() { GlobalConfiguration globalConfig = new GlobalConfigurationBuilder() .transport().defaultTransport() .build(); Configuration cacheConfig = new ConfigurationBuilder().persistence().addStore(LevelDBStoreConfigurationBuilder.class).location(tmpDataDirectory) .expiredLocation(tmpExpiredDirectory).implementationType(LevelDBStoreConfiguration.ImplementationType.AUTO).build(); StoreConfiguration cacheLoaderConfig = cacheConfig.persistence().stores().get(0); assertTrue(cacheLoaderConfig instanceof LevelDBStoreConfiguration); LevelDBStoreConfiguration leveldbConfig = (LevelDBStoreConfiguration) cacheLoaderConfig; assertEquals(tmpDataDirectory, leveldbConfig.location()); assertEquals(tmpExpiredDirectory, leveldbConfig.expiredLocation()); EmbeddedCacheManager cacheManager = new DefaultCacheManager(globalConfig); cacheManager.defineConfiguration("testCache", cacheConfig); cacheManager.start(); Cache<String, String> cache = cacheManager.getCache("testCache"); cache.put("hello", "there"); cache.stop(); cacheManager.stop(); }
GlobalConfigurationBuilder gbuilder = GlobalConfigurationBuilder.defaultClusteredBuilder(); Transport transport = gbuilder.transport().getTransport(); gbuilder.transport().transport(transport); gbuilder.transport().clusterName("test"); startHotRodServer(gbuilder, defaultBuilder, j + 1); builder.indexing() .enable() .index(Index.LOCAL) .addProperty("hibernate.search.default.indexwriter.ram_buffer_size","128") .addProperty("lucene_version", "LUCENE_CURRENT"); builder.clustering().hash().numOwners(1); builder.jmxStatistics().enable(); builder.transaction().transactionMode(TransactionMode.TRANSACTIONAL); Configuration configuration = builder.build(); for (int j = 0; j < nnodes; j++) { for (String name : cacheNames) { manager(j).defineConfiguration(name,configuration); manager(j).getCache(name, true); assert manager(j).getCache() != null;
@Override public Object call() throws Exception { GlobalConfigurationBuilder gcb = new GlobalConfigurationBuilder(); gcb.transport().defaultTransport().nodeName(nodeName); // gcb.transport().machineId(machineId); BlockingThreadPoolExecutorFactory remoteExecutorFactory = new BlockingThreadPoolExecutorFactory( 10, 1, 0, 60000); gcb.transport().remoteCommandThreadPool().threadPoolFactory(remoteExecutorFactory); BlockingThreadPoolExecutorFactory stateTransferExecutorFactory = new BlockingThreadPoolExecutorFactory( 4, 1, 0, 60000); gcb.transport().stateTransferThreadPool().threadPoolFactory(stateTransferExecutorFactory); EmbeddedCacheManager cm = new DefaultCacheManager(gcb.build()); try { for (int j = 0; j < NUM_CACHES/2; j++) { cm.defineConfiguration("repl-cache-" + j, replConfig); cm.defineConfiguration("dist-cache-" + j, distConfig); } for (int j = 0; j < NUM_CACHES/2; j++) { Cache<Object, Object> replCache = cm.getCache("repl-cache-" + j); replCache.put(cm.getAddress(), "bla"); Cache<Object, Object> distCache = cm.getCache("dist-cache-" + j); distCache.put(cm.getAddress(), "bla"); } } finally { registerCacheManager(cm); } log.infof("Started cache manager %s", cm.getAddress()); return null; } });
@Override protected void createCacheManagers() throws Throwable { Configuration distConfig = getDefaultClusteredCacheConfig(cacheMode, false).build(); for (int i = 0; i < NUM_NODES; i++) { GlobalConfigurationBuilder gcb = new GlobalConfigurationBuilder(); gcb.transport().defaultTransport().nodeName(TestResourceTracker.getNameForIndex(i)); BlockingThreadPoolExecutorFactory remoteExecutorFactory = new BlockingThreadPoolExecutorFactory( 10, 1, 0, 60000); gcb.transport().remoteCommandThreadPool().threadPoolFactory(remoteExecutorFactory); EmbeddedCacheManager cm = new DefaultCacheManager(gcb.build()); registerCacheManager(cm); cm.defineConfiguration(CACHE_NAME, distConfig); log.infof("Started cache manager %s", cm.getAddress()); } waitForClusterToForm(CACHE_NAME); }
builder.indexing().index(indexLocalOnly ? Index.PRIMARY_OWNER : Index.ALL); builder.indexing() .addProperty("default.directory_provider", "local-heap") .addProperty("lucene_version", "LUCENE_CURRENT") .addProperty("error_handler", "org.infinispan.query.helper.StaticTestingErrorHandler"); } else { builder.indexing() .addProperty("default.indexmanager", "org.infinispan.query.indexmanager.InfinispanIndexManager") .addProperty("lucene_version", "LUCENE_CURRENT") GlobalConfigurationBuilder globalConfigurationBuilder = holder.getGlobalConfigurationBuilder().clusteredDefault(); globalConfigurationBuilder.transport().machineId("a" + i).rackId("b" + i).siteId("test" + i).defaultCacheName(defaultCacheName); caches.add(cm1.getCache());
protected <K, V> List<Cache<K, V>> createClusteredCaches(int numMembersInCluster, GlobalConfigurationBuilder globalConfigurationBuilder, ConfigurationBuilder defaultConfigBuilder, boolean serverMode, String... cacheNames) { List<Cache<K, V>> caches = new ArrayList<>(numMembersInCluster); for (int i = 0; i < numMembersInCluster; i++) { EmbeddedCacheManager cm; if (serverMode) { globalConfigurationBuilder.addModule(PrivateGlobalConfigurationBuilder.class).serverMode(true); globalConfigurationBuilder.transport().defaultTransport(); cm = addClusterEnabledCacheManager(globalConfigurationBuilder, defaultConfigBuilder); } else { cm = addClusterEnabledCacheManager(defaultConfigBuilder); } if (cacheNames.length == 0) { Cache<K, V> cache = cm.getCache(); caches.add(cache); } else { for (String cacheName : cacheNames) { cm.defineConfiguration(cacheName, defaultConfigBuilder.build()); caches.add(cm.getCache(cacheName)); } } } waitForClusterToForm(cacheNames); return caches; }
private EmbeddedCacheManager createCacheManager(int index) { GlobalConfigurationBuilder gcb = new GlobalConfigurationBuilder(); gcb.transport().defaultTransport(); TestCacheManagerFactory.amendGlobalConfiguration(gcb, new TransportFlags().withPortRange(index)); ConfigurationBuilder defaultCacheConfig = new ConfigurationBuilder(); EmbeddedCacheManager cm = TestCacheManagerFactory.newDefaultCacheManager(false, gcb, defaultCacheConfig, false); registerCacheManager(cm); Configuration replCfg = new ConfigurationBuilder().clustering().cacheMode(CacheMode.REPL_SYNC).build(); cm.defineConfiguration(REPL_CACHE_NAME, replCfg); Configuration distCfg = new ConfigurationBuilder().clustering().cacheMode(CacheMode.DIST_SYNC).build(); cm.defineConfiguration(DIST_CACHE_NAME, distCfg); Configuration scatteredCfg = new ConfigurationBuilder().clustering().cacheMode(CacheMode.SCATTERED_SYNC).build(); cm.defineConfiguration(SCATTERED_CACHE_NAME, scatteredCfg); return cm; }
GlobalConfigurationBuilder gc = GlobalConfigurationBuilder.defaultClusteredBuilder(); gc.transport().rackId(rack).machineId(machine); EmbeddedCacheManager cm = TestCacheManagerFactory.createClusteredCacheManager(gc, new ConfigurationBuilder()); cacheManagers.add(cm); return cm;
GlobalConfiguration gc = configBuilder.build(); ExoContainer container = ExoContainerContext.getCurrentContainer(); configBuilder.transport().clusterName(gc.transport().clusterName() + "_" + container.getContext().getName()) .globalJmxStatistics() .cacheManagerName(gc.globalJmxStatistics().cacheManagerName() + "_" + container.getContext().getName()). mBeanServerLookup(MBEAN_SERVER_LOOKUP); EmbeddedCacheManager manager; gc = configBuilder.build(); String clusterName = gc.transport().clusterName(); if (CACHE_MANAGERS.containsKey(clusterName)) confBuilder.transaction().transactionManagerLookup(tml); Configuration conf = holder.getDefaultConfigurationBuilder().build(); manager.defineConfiguration(regionId, conf); if (LOG.isInfoEnabled())