holder.getGlobalConfigurationBuilder() .transport() .defaultTransport() .addProperty("configurationFile", jgroupsConfig);
holder.getGlobalConfigurationBuilder() .transport() .defaultTransport() .addProperty("configurationFile", jgroupsConfig);
public static void registerChannel(GlobalConfigurationBuilder gcb, JChannel channel, String nodeName, boolean connect) { TransportConfigurationBuilder tcb = gcb.transport(); tcb.defaultTransport(); tcb.addProperty(JGroupsTransport.CHANNEL_LOOKUP, CustomChannelLookup.class.getName()); tcb.addProperty("customNodeName", nodeName); tcb.addProperty("customConnect", Boolean.toString(connect)); channelMap.put(nodeName, channel); }
protected void configureTransport(GlobalConfigurationBuilder gcb, String nodeName, String siteName, String jgroupsUdpMcastAddr) { if (nodeName == null) { gcb.transport().defaultTransport(); } else { FileLookup fileLookup = FileLookupFactory.newInstance();
public static void main(String[] args) throws UnknownHostException { .defaultTransport() .addProperty("configurationFile", "default-configs/default-jgroups-kubernetes.xml") .build();
@Override protected GlobalConfigurationBuilder createGlobalConfigurationBuilder() { GlobalConfigurationBuilder global = new GlobalConfigurationBuilder(); global.globalJmxStatistics().enable().allowDuplicateDomains(true); global.transport().defaultTransport().clusterName(repoName); global.transport().addProperty("configurationFile", "openl-jgroups-mosh-config.xml"); return global; } };
public void channelLookupTest() { when(mockChannel.getAddress()).thenReturn(a); when(mockChannel.down(isA(Event.class))).thenReturn(a); when(mockChannel.getView()).thenReturn(v); when(mockChannel.getProtocolStack()).thenReturn(ps); when(ps.getTransport()).thenReturn(new UDP()); EmbeddedCacheManager cm = null; try { GlobalConfigurationBuilder gc = GlobalConfigurationBuilder.defaultClusteredBuilder(); gc.transport().defaultTransport().addProperty("channelLookup", DummyLookup.class.getName()); cm = TestCacheManagerFactory.createClusteredCacheManager(gc, new ConfigurationBuilder()); cm.start(); cm.getCache(); GlobalComponentRegistry gcr = TestingUtil.extractGlobalComponentRegistry(cm); Transport t = gcr.getComponent(Transport.class); assertNotNull(t); assertTrue(t instanceof JGroupsTransport); assertNotSame(JChannel.class, ((JGroupsTransport) t).getChannel().getClass()); } finally { TestingUtil.killCacheManagers(cm); } }
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; }
.classLoader(InfinispanEmbeddedCacheManager.class.getClassLoader()) .transport() .defaultTransport() .clusterName(config.getClusterName()) .machineId("instance-" + config.getDatacenterId())
.classLoader(InfinispanEmbeddedCacheManager.class.getClassLoader()) .transport() .defaultTransport() .clusterName(config.getClusterName()) .machineId("instance-" + config.getDatacenterId())
.classLoader(LDCachingInfinispanBackend.class.getClassLoader()) .transport() .defaultTransport() .clusterName(clusterName) .machineId(machineName) .classLoader(LDCachingInfinispanBackend.class.getClassLoader()) .transport() .defaultTransport() .clusterName(clusterName) .machineId(machineName)
public TestCluster build() { List<HotRodServer> hotRodServers = new ArrayList<>(); List<EmbeddedCacheManager> embeddedCacheManagers = new ArrayList<>(); for (int i = 0; i < numMembers; i++) { GlobalConfigurationBuilder gcb = new GlobalConfigurationBuilder(); gcb.transport().defaultTransport().clusterName(name); EmbeddedCacheManager clusteredCacheManager = createClusteredCacheManager(gcb, getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC)); caches.entrySet().forEach(entry -> clusteredCacheManager.defineConfiguration(entry.getKey(), entry.getValue().build())); embeddedCacheManagers.add(clusteredCacheManager); hotRodServers.add(HotRodClientTestingUtil.startHotRodServer(clusteredCacheManager, hotRodBuilder)); } int port = hotRodServers.get(0).getPort(); org.infinispan.client.hotrod.configuration.ConfigurationBuilder build = new org.infinispan.client.hotrod.configuration.ConfigurationBuilder(); build.addServer().port(port).host("localhost"); if (trustStoreFileName != null) { build.security().ssl().enable().trustStoreFileName(trustStoreFileName).trustStorePassword(trustStorePassword); } if (keyStoreFileName != null) { build.security().ssl().keyStoreFileName(keyStoreFileName).keyStorePassword(keyStorePassword); } return new TestCluster(hotRodServers, embeddedCacheManagers, new RemoteCacheManager(build.build())); }
@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); }
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); }
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(); }
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; }
@Override public Void call() throws Exception { GlobalConfigurationBuilder gcb = new GlobalConfigurationBuilder(); gcb.transport().defaultTransport().nodeName(nodeName) .addProperty(JGroupsTransport.CONFIGURATION_STRING, configurator.getProtocolStackString()); BlockingThreadPoolExecutorFactory transportExecutorFactory = new BlockingThreadPoolExecutorFactory(
builder.transport().defaultTransport();
@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; } });