.cacheManagerName(this.name) .mBeanServerLookup(new MBeanServerProvider((this.server != null) ? this.server.get() : null)) .jmxDomain("org.wildfly.clustering.infinispan") .allowDuplicateDomains(true);
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); }
/** * Note this method does not amend the global configuration to reduce overall resource footprint. It is therefore * suggested to use {@link org.infinispan.test.fwk.TestCacheManagerFactory#createClusteredCacheManager(org.infinispan.configuration.cache.ConfigurationBuilder, * TransportFlags)} instead when this is needed * * @param start Whether to start this cache container * @param gc The global configuration builder to use * @param c The default configuration to use * @param keepJmxDomain Whether or not the provided jmx domain should be used or if a unique one is generated * @return The resultant cache manager that is created */ public static EmbeddedCacheManager newDefaultCacheManager(boolean start, GlobalConfigurationBuilder gc, ConfigurationBuilder c, boolean keepJmxDomain) { if (!keepJmxDomain) { gc.globalJmxStatistics().jmxDomain("infinispan-" + UUID.randomUUID()); } return newDefaultCacheManager(start, gc, c); }
private static DefaultCacheManager newDefaultCacheManager(boolean start, ConfigurationBuilderHolder holder, boolean keepJmxDomain) { if (!keepJmxDomain) { holder.getGlobalConfigurationBuilder().globalJmxStatistics().jmxDomain( "infinispan-" + UUID.randomUUID()); } return newDefaultCacheManager(start, holder); }
globalConfigurationBuilder.read(infinispanGlobalConfigurer.getGlobalConfiguration()); } else { globalConfigurationBuilder.globalJmxStatistics().jmxDomain(DEFAULT_JMX_DOMAIN).enable(); globalConfigurationBuilder.transport().clusterName(infinispanProperties.getClusterName());
globalConfigurationBuilder.read(infinispanGlobalConfigurer.getGlobalConfiguration()); } else { globalConfigurationBuilder.globalJmxStatistics().jmxDomain(DEFAULT_JMX_DOMAIN).enable(); globalConfigurationBuilder.transport().clusterName(infinispanProperties.getClusterName());
@Test(expectedExceptions = CacheConfigurationException.class, expectedExceptionsMessageRegExp = "ISPN000436:.*") public void testMissingDefaultConfiguration() { GlobalConfigurationBuilder gcb = new GlobalConfigurationBuilder(); gcb.globalJmxStatistics().jmxDomain("infinispan-" + UUID.randomUUID()); EmbeddedCacheManager cm = new DefaultCacheManager(gcb.build()); try { cm.getCache("someCache"); } finally { cm.stop(); } }
@Bean(destroyMethod = "stop") public DefaultCacheManager defaultCacheManager() throws IOException { final String configXml = infinispanProperties.getEmbedded().getConfigXml(); final GlobalConfiguration defaultGlobalConfiguration = new GlobalConfigurationBuilder() .globalJmxStatistics().jmxDomain(DEFAULT_JMX_DOMAIN).enable() .transport().clusterName(infinispanProperties.getEmbedded().getClusterName()) .build(); final GlobalConfiguration globalConfiguration = infinispanGlobalConfigurer == null? defaultGlobalConfiguration : infinispanGlobalConfigurer.getGlobalConfiguration(); final DefaultCacheManager manager = configXml.isEmpty()? new DefaultCacheManager(globalConfiguration) : new DefaultCacheManager(configXml); configureCaches(manager); return manager; }
private GlobalConfigurationBuilder createGlobalConfigurationBuilder() { GlobalConfigurationBuilder globalConfiguration = GlobalConfigurationBuilder.defaultClusteredBuilder(); globalConfiguration.globalJmxStatistics().enable() .mBeanServerLookup(new PerThreadMBeanServerLookup()) .jmxDomain(JMX_DOMAIN); return globalConfiguration; }
/** * Build a local cache configuration. * <p/> * In local cache mode, the cache is not shared among the servers in a cluster. Each machine keeps a local cache. * This allows quick startups and eliminates network traffic in the cluster, but subsequent requests to different * cluster members cannot benefit from the cached data. */ protected void buildLocalConfiguration() { GlobalConfiguration globalConfiguration = new GlobalConfigurationBuilder() .classLoader(InfinispanEmbeddedCacheManager.class.getClassLoader()) .globalJmxStatistics() .jmxDomain("org.apache.marmotta.kiwi") .allowDuplicateDomains(true) .build(); defaultConfiguration = new ConfigurationBuilder() .clustering() .cacheMode(CacheMode.LOCAL) .eviction() .strategy(EvictionStrategy.LIRS) .maxEntries(100000) .expiration() .lifespan(5, TimeUnit.MINUTES) .maxIdle(1, TimeUnit.MINUTES) .build(); cacheManager = new DefaultCacheManager(globalConfiguration, defaultConfiguration, true); log.info("initialised Infinispan local cache manager"); }
@Override protected void createCacheManagers() throws Throwable { server = PerThreadMBeanServerLookup.getThreadMBeanServer(); for (int i = 0; i < NUM_NODES; i++) { InputStream is = FileLookupFactory.newInstance().lookupFileStrict( "dynamic-indexing-distribution.xml", Thread.currentThread().getContextClassLoader()); ParserRegistry parserRegistry = new ParserRegistry( Thread.currentThread().getContextClassLoader()); ConfigurationBuilderHolder holder = parserRegistry.parse(is); // Each cache manager should use a different jmx domain and // a parallel-testsuite friendly mbean server holder.getGlobalConfigurationBuilder().globalJmxStatistics() .jmxDomain(BASE_JMX_DOMAIN + i) .mBeanServerLookup(new PerThreadMBeanServerLookup()); EmbeddedCacheManager cm = TestCacheManagerFactory .createClusteredCacheManager(holder, true); registerCacheManager(cm); Cache cache = cm.getCache(); caches.add(cache); } waitForClusterToForm(neededCacheNames); }
/** * Create a non-clustered instance of the infinispan cache. */ public LDCachingInfinispanBackend() { globalConfiguration = new GlobalConfigurationBuilder() .classLoader(LDCachingInfinispanBackend.class.getClassLoader()) .globalJmxStatistics() .jmxDomain("org.apache.marmotta.ldcache") .allowDuplicateDomains(true) .build(); defaultConfiguration = new ConfigurationBuilder() .clustering() .cacheMode(CacheMode.LOCAL) .eviction() .strategy(EvictionStrategy.LIRS) .maxEntries(100000) .expiration() .lifespan(7, TimeUnit.DAYS) .maxIdle(1, TimeUnit.DAYS) .build(); clustered = false; }
private CacheContainer createManager(ConfigurationBuilder builder) { GlobalConfigurationBuilder gcb1 = GlobalConfigurationBuilder.defaultClusteredBuilder(); gcb1.globalJmxStatistics().enable().jmxDomain(jmxDomain) .mBeanServerLookup(new PerThreadMBeanServerLookup()); CacheContainer cacheManager = TestCacheManagerFactory.createClusteredCacheManager(gcb1, builder, new TransportFlags(), true); cacheManager.start(); return cacheManager; }
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); }
public static EmbeddedCacheManager createClusteredCacheManagerEnforceJmxDomain( String cacheManagerName, String jmxDomain, boolean exposeGlobalJmx, boolean allowDuplicateDomains, ConfigurationBuilder builder, MBeanServerLookup mBeanServerLookup) { GlobalConfigurationBuilder globalBuilder = GlobalConfigurationBuilder.defaultClusteredBuilder(); amendGlobalConfiguration(globalBuilder, new TransportFlags()); globalBuilder.globalJmxStatistics() .jmxDomain(jmxDomain) .mBeanServerLookup(mBeanServerLookup) .allowDuplicateDomains(allowDuplicateDomains) .enabled(exposeGlobalJmx); if (cacheManagerName != null) { globalBuilder.globalJmxStatistics().cacheManagerName(cacheManagerName); } return createClusteredCacheManager(globalBuilder, builder, new TransportFlags(), true); }
/** * @see #createCacheManagerEnforceJmxDomain(String) */ public static EmbeddedCacheManager createCacheManagerEnforceJmxDomain(String jmxDomain, String cacheManagerName, boolean exposeGlobalJmx, boolean exposeCacheJmx, boolean allowDuplicates) { GlobalConfigurationBuilder globalConfiguration = new GlobalConfigurationBuilder(); globalConfiguration .globalJmxStatistics() .allowDuplicateDomains(allowDuplicates) .jmxDomain(jmxDomain) .mBeanServerLookup(new PerThreadMBeanServerLookup()) .enabled(exposeGlobalJmx); if (cacheManagerName != null) globalConfiguration.globalJmxStatistics().cacheManagerName(cacheManagerName); ConfigurationBuilder configuration = new ConfigurationBuilder(); configuration.jmxStatistics().enabled(exposeCacheJmx); return createCacheManager(globalConfiguration, configuration, true); }
@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()); }
@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()); }
@Override protected void createCacheManagers() throws Throwable { ConfigurationBuilder defaultConfig = new ConfigurationBuilder(); GlobalConfigurationBuilder gcb1 = GlobalConfigurationBuilder.defaultClusteredBuilder(); gcb1.globalJmxStatistics().enable().jmxDomain(JMX_DOMAIN) .mBeanServerLookup(new PerThreadMBeanServerLookup()); CacheContainer cacheManager1 = TestCacheManagerFactory.createClusteredCacheManager(gcb1, defaultConfig, new TransportFlags(), true); cacheManager1.start(); GlobalConfigurationBuilder gcb2 = GlobalConfigurationBuilder.defaultClusteredBuilder(); gcb2.globalJmxStatistics().enable().jmxDomain(JMX_DOMAIN) .mBeanServerLookup(new PerThreadMBeanServerLookup()); CacheContainer cacheManager2 = TestCacheManagerFactory.createClusteredCacheManager(gcb2, defaultConfig, new TransportFlags(), true); cacheManager2.start(); registerCacheManager(cacheManager1, cacheManager2); ConfigurationBuilder cb = new ConfigurationBuilder(); cb.clustering().cacheMode(CacheMode.REPL_SYNC).jmxStatistics().enable(); defineConfigurationOnAllManagers(cachename, cb); defineConfigurationOnAllManagers(cachename2, cb); waitForClusterToForm(cachename); }
protected EmbeddedCacheManager createCacheManager() throws Exception { GlobalConfigurationBuilder globalBuilder = new GlobalConfigurationBuilder(); globalBuilder.globalJmxStatistics() .mBeanServerLookup(new PerThreadMBeanServerLookup()) .jmxDomain(JMX_DOMAIN) .enable(); ConfigurationBuilder builder = new ConfigurationBuilder(); builder.memory().size(1) .jmxStatistics().enable() .persistence() .passivation(true) .addStore(DummyInMemoryStoreConfigurationBuilder.class); // Do not initialize this in instance declaration since a different // thread will be used when running from maven, breaking the thread local threadMBeanServer = PerThreadMBeanServerLookup.getThreadMBeanServer(); return TestCacheManagerFactory.createCacheManager(globalBuilder, builder, true); }