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()) .machineId(transport.machineId()) .rackId(transport.rackId()) 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); builder.site().read(this.site.get());
/** * This bean is optional but it shows how to inject {@link org.infinispan.configuration.global.GlobalConfiguration}. */ @Bean public InfinispanGlobalConfigurer globalConfiguration() { logger.info("Defining Global Configuration"); return () -> GlobalConfigurationBuilder .defaultClusteredBuilder() .globalJmxStatistics().allowDuplicateDomains(true) .build(); }
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")); }
GlobalConfigurationBuilder gcb = new GlobalConfigurationBuilder(); String jgroupsUdpMcastAddr = config.get("jgroupsUdpMcastAddr", System.getProperty(InfinispanConnectionProvider.JGROUPS_UDP_MCAST_ADDR)); configureTransport(gcb, topologyInfo.getMyNodeName(), topologyInfo.getMySiteName(), jgroupsUdpMcastAddr); gcb.globalJmxStatistics() .jmxDomain(InfinispanConnectionProvider.JMX_DOMAIN + "-" + topologyInfo.getMyNodeName()); gcb.globalJmxStatistics() .allowDuplicateDomains(allowDuplicateJMXDomains) .enable(); cacheManager = new DefaultCacheManager(gcb.build()); containerManaged = false; ConfigurationBuilder modelCacheConfigBuilder = new ConfigurationBuilder(); Configuration modelCacheConfiguration = modelCacheConfigBuilder.build(); cacheManager.defineConfiguration(InfinispanConnectionProvider.REALM_CACHE_NAME, modelCacheConfiguration); cacheManager.defineConfiguration(InfinispanConnectionProvider.AUTHORIZATION_CACHE_NAME, modelCacheConfiguration); cacheManager.defineConfiguration(InfinispanConnectionProvider.USER_CACHE_NAME, modelCacheConfiguration); ConfigurationBuilder sessionConfigBuilder = new ConfigurationBuilder(); if (clustered) { String sessionsMode = config.get("sessionsMode", "distributed");
GlobalConfiguration globalConfiguration = new GlobalConfigurationBuilder() .classLoader(InfinispanEmbeddedCacheManager.class.getClassLoader()) .transport() .defaultTransport() .clusterName(config.getClusterName()) .machineId("instance-" + config.getDatacenterId()) .addProperty("configurationXml", jgroupsXml) .distributedSyncTimeout(config.getClusterTimeout()) .globalJmxStatistics() .jmxDomain("org.apache.marmotta.kiwi") .allowDuplicateDomains(true) .serialization() .addAdvancedExternalizer(externalizers) .build(); defaultConfiguration = new ConfigurationBuilder() .clustering() .cacheMode(CacheMode.REPL_ASYNC) .async() .maxIdle(10, TimeUnit.MINUTES) .build(); cacheManager = new DefaultCacheManager(globalConfiguration, defaultConfiguration, true); log.info("initialised Infinispan replicated cache manager (cluster name: {})", globalConfiguration.transport().clusterName());
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); }
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 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; }
@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()); } }
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")); }
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); } }
@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()); }
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()); } }
/** * 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"); }
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)) manager = new DefaultCacheManager(gc); CacheManagerInstance cacheManagerInstance = new CacheManagerInstance(manager); cacheManagerInstance.acquire(); confBuilder.transaction().transactionManagerLookup(tml); Configuration conf = holder.getDefaultConfigurationBuilder().build(); manager.defineConfiguration(regionId, conf); if (LOG.isInfoEnabled())
@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(); } }
@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(); }