protected ServerCache getDefaultCache() { GlobalConfiguration gconfig = new GlobalConfigurationBuilder() .globalJmxStatistics() .allowDuplicateDomains(true) .enable() .jmxDomain("custom-cache") .build(); Configuration configuration = new ConfigurationBuilder() .eviction() .strategy(EvictionStrategy.LIRS) .maxEntries(100) .jmxStatistics().enable() .build(); EmbeddedCacheManager manager = new DefaultCacheManager(gconfig, configuration); Cache<Object, Object> c = manager.getCache("custom-cache"); return new InfinispanCache(c); }
@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()) builder.serialization().classResolver(ModularClassResolver.getInstance(this.loader.get())); builder.classLoader(module.getClassLoader()); int id = Ids.MAX_ID; SerializationConfigurationBuilder serialization = builder.serialization(); for (Externalizer<?> externalizer : EnumSet.allOf(DefaultExternalizer.class)) { serialization.addAdvancedExternalizer(new AdvancedExternalizerAdapter<>(id++, externalizer)); 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.expirationThreadPool().read(this.schedulers.get(ScheduledThreadPoolResourceDefinition.EXPIRATION).get()); builder.listenerThreadPool().read(this.pools.get(ThreadPoolResourceDefinition.LISTENER).get()); builder.stateTransferThreadPool().read(this.pools.get(ThreadPoolResourceDefinition.STATE_TRANSFER).get()); builder.persistenceThreadPool().read(this.pools.get(ThreadPoolResourceDefinition.PERSISTENCE).get()); builder.shutdown().hookBehavior(ShutdownHookBehavior.DONT_REGISTER); builder.globalJmxStatistics() .enabled(this.statisticsEnabled) .cacheManagerName(this.name)
@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(); }
@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(); }
public void testDifferentDomain() throws Exception { GlobalConfigurationBuilder globalConfiguration = GlobalConfigurationBuilder.defaultClusteredBuilder(); globalConfiguration.globalJmxStatistics().enable().mBeanServerLookup(new PerThreadMBeanServerLookup()); cm = TestCacheManagerFactory.createClusteredCacheManager(globalConfiguration, new ConfigurationBuilder()); String jmxDomain = cm.getCacheManagerConfiguration().globalJmxStatistics().domain(); ConfigurationBuilder localCache = config();//local by default cm.defineConfiguration("local_cache", localCache.build()); cm.getCache("local_cache"); assert existsObject(getCacheObjectName(jmxDomain, "local_cache(local)", "Statistics")); }
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; }
@Override protected EmbeddedCacheManager createCacheManager() throws Exception { GlobalConfigurationBuilder gcb = new GlobalConfigurationBuilder(); gcb.globalJmxStatistics().jmxDomain(JMX_DOMAIN).mBeanServerLookup(new PerThreadMBeanServerLookup()).enable(); ConfigurationBuilder dcc = TestCacheManagerFactory.getDefaultCacheConfiguration(true); dcc.transaction().autoCommit(false); dcc.memory().size(1000); dcc.jmxStatistics().enable(); server = PerThreadMBeanServerLookup.getThreadMBeanServer(); return new DefaultCacheManager(gcb.build(), dcc.build()); }
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; } }
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(); }
/** * 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; }
public void testRegisterReplicatedCache() throws Exception { GlobalConfigurationBuilder globalConfiguration = GlobalConfigurationBuilder.defaultClusteredBuilder(); globalConfiguration.globalJmxStatistics().enable(); EmbeddedCacheManager cm = TestCacheManagerFactory.createClusteredCacheManager(globalConfiguration, new ConfigurationBuilder()); cacheContainers.add(cm); cm.start(); ConfigurationBuilder configurationOverride = config(); configurationOverride.clustering().cacheMode(CacheMode.REPL_SYNC); cm.defineConfiguration("first", configurationOverride.build()); Cache first = cm.getCache("first"); ComponentMetadataRepo metadataRepo = cm.getGlobalComponentRegistry().getComponentMetadataRepo(); ComponentMetadata metadata = metadataRepo.getComponentMetadata(first.getClass()); ResourceDMBean mbean = new ResourceDMBean(first, metadata.toManageableComponentMetadata()); Collection<ResourceDMBean> mbeans = singleton(mbean); ComponentsJmxRegistration regComponents = buildRegistrator(first); regComponents.registerMBeans(mbeans); String name = regComponents.getObjectName("Cache").toString(); ObjectName name1 = new ObjectName(name); assertCorrectJmxName(name1, first); assert mBeanServer.isRegistered(name1); regComponents.unregisterMBeans(mbeans); assert !mBeanServer.isRegistered(name1); }
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")); }
protected EmbeddedCacheManager createBackingEmbeddedCacheManager() throws IOException { if (configurationFileLocation != null) { ConfigurationBuilderHolder configurationBuilderHolder = new ParserRegistry(Thread.currentThread().getContextClassLoader()) .parse(configurationFileLocation.getInputStream()); if(gcb != null) { configurationBuilderHolder.getGlobalConfigurationBuilder().read(gcb.build()); } if (builder != null) { configurationBuilderHolder.getDefaultConfigurationBuilder().read(builder.build()); } return new DefaultCacheManager(configurationBuilderHolder, true); } else { if (gcb == null) { if (logger.isDebugEnabled()) logger.debug("GlobalConfigurationBuilder is null. Using default new " + "instance."); gcb = new GlobalConfigurationBuilder(); gcb.globalJmxStatistics().allowDuplicateDomains(true); } if (builder == null) { if (logger.isDebugEnabled()) logger.debug("ConfigurationBuilder is null. Using default new instance."); builder = new ConfigurationBuilder(); } return new DefaultCacheManager(gcb.build(), builder.build()); } }
private Cache getCache() { GlobalConfigurationBuilder gc = GlobalConfigurationBuilder.defaultClusteredBuilder(); ConfigurationBuilder c = new ConfigurationBuilder(); c.clustering().cacheMode(CacheMode.REPL_SYNC) .remoteTimeout(30000) .transaction().invocationBatching().enable() .locking().lockAcquisitionTimeout(60000).useLockStriping(false); EmbeddedCacheManager container = TestCacheManagerFactory.createClusteredCacheManager(gc, c); cacheContainers.add(container); container.defineConfiguration("TestCache", c.build()); return container.getCache("TestCache"); } }
@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 EmbeddedCacheManager embeddedCacheManager() throws IOException { if(configurationFile == null) { GlobalConfigurationBuilder global = new GlobalConfigurationBuilder(); global.globalJmxStatistics().allowDuplicateDomains(true); return new DefaultCacheManager(global.build(), new ConfigurationBuilder().build()); } else { return new DefaultCacheManager(configurationFile); } }
@Test public final void testAddConfigurations() throws Exception { final InfinispanEmbeddedCacheManagerFactoryBean objectUnderTest = new InfinispanEmbeddedCacheManagerFactoryBean(); // Allow duplicate domains. A good little configuration modification to make. If this isn't enabled, // JMXDomainConflicts occur which break the testsuite. This way we can also have a non-default configuration to // check. GlobalConfigurationBuilder gcb = new GlobalConfigurationBuilder(); gcb.globalJmxStatistics().allowDuplicateDomains(true); // Now prepare a cache configuration. ConfigurationBuilder builder = new ConfigurationBuilder(); builder.transaction().transactionMode(TransactionMode.NON_TRANSACTIONAL); // Now add them to the object that we are testing. objectUnderTest.addCustomGlobalConfiguration(gcb); objectUnderTest.addCustomCacheConfiguration(builder); objectUnderTest.afterPropertiesSet(); // Get the cache manager and make assertions. final EmbeddedCacheManager infinispanEmbeddedCacheManager = objectUnderTest.getObject(); assertEquals(infinispanEmbeddedCacheManager.getCacheManagerConfiguration().globalJmxStatistics() .allowDuplicateDomains(), gcb.build().globalJmxStatistics().allowDuplicateDomains()); assertEquals(infinispanEmbeddedCacheManager.getDefaultCacheConfiguration().transaction() .transactionMode().isTransactional(), builder.build().transaction().transactionMode().isTransactional()); } }
@Produces @ApplicationScoped public EmbeddedCacheManager create() { GlobalConfiguration global = new GlobalConfigurationBuilder() .globalJmxStatistics().cacheManagerName("geekseek") .build(); Configuration local = new ConfigurationBuilder() .clustering() .cacheMode(CacheMode.LOCAL) .transaction() .transactionMode(TransactionMode.TRANSACTIONAL) .transactionManagerLookup(new GenericTransactionManagerLookup()) .autoCommit(false) .build(); return new DefaultCacheManager(global, local); }
private Cache<Object, Object> createManagerAndGetCache(int startFailures) { GlobalConfiguration globalConfiguration = new GlobalConfigurationBuilder().globalJmxStatistics().allowDuplicateDomains(true).build(); ConfigurationBuilder cb = TestCacheManagerFactory.getDefaultCacheConfiguration(false); Configuration config = cb.persistence() .addStore(DummyInMemoryStoreConfigurationBuilder.class) .startFailures(startFailures) .build(); return new DefaultCacheManager(globalConfiguration, config).getCache(); }