.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); }
/** * 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 DuplicateDomainAwareCacheManager() { super(new GlobalConfigurationBuilder().globalJmxStatistics().allowDuplicateDomains(true).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; } };
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); } }
public InfinispanEventsDeliveredCache(String subscribeProxyIdentifier) { super(EventCloudProperties.getDefaultTemporaryPath() + "infinispan" + File.separatorChar + subscribeProxyIdentifier); GlobalConfigurationBuilder config = new GlobalConfigurationBuilder(); config.globalJmxStatistics().disable().allowDuplicateDomains(true); config.serialization().addAdvancedExternalizer( NotificationId.SERIALIZER).addAdvancedExternalizer( SubscriptionId.SERIALIZER); this.cacheManager = new DefaultCacheManager(config.build()); this.cache = this.createCache(); }
/** * Produces the default embedded cache manager. * * @param defaultConfiguration the default configuration produced by the {@link DefaultTestEmbeddedCacheManagerProducer}. * @return the default embedded cache manager used by the application. */ @Produces @ApplicationScoped public EmbeddedCacheManager getDefaultEmbeddedCacheManager(Configuration defaultConfiguration) { // Sometimes we're called from a remote thread that doesn't have the test name set // We don't have the test name here, either, but we can use a dummy one TestResourceTracker.setThreadTestNameIfMissing("DefaultTestEmbeddedCacheManagerProducer"); ConfigurationBuilder builder = new ConfigurationBuilder(); GlobalConfigurationBuilder globalConfigurationBuilder = new GlobalConfigurationBuilder(); globalConfigurationBuilder.globalJmxStatistics().allowDuplicateDomains(true); builder.read(defaultConfiguration); return TestCacheManagerFactory.createClusteredCacheManager(globalConfigurationBuilder, builder); }
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()); } }
/** * 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; }
/** * 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 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; } }
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); }
@Test public void testIfSpringEmbeddedCacheManagerFactoryBeanAllowesOverridingGlobalConfiguration() throws Exception { GlobalConfigurationBuilder overriddenConfiguration = new GlobalConfigurationBuilder(); overriddenConfiguration.transport().rackId("r2"); overriddenConfiguration.globalJmxStatistics().allowDuplicateDomains(true); objectUnderTest = SpringEmbeddedCacheManagerFactoryBeanBuilder .defaultBuilder().fromFile(NAMED_ASYNC_CACHE_CONFIG_LOCATION, getClass()) .withGlobalConfiguration(overriddenConfiguration).build(); final SpringEmbeddedCacheManager springEmbeddedCacheManager = objectUnderTest.getObject(); assertEquals( "Transport for cache configured in" + CACHE_NAME_FROM_CONFIGURATION_FILE + "is assigned to r1 rack. But later Global Configuration overrides " + "this setting to r2. Obviously created SpringEmbeddedCacheManagerFactoryBean does not support this kind " + "of overriding.", "r2", springEmbeddedCacheManager.getNativeCacheManager().getCacheManagerConfiguration().transport().rackId()); }
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(); }
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); }
private Cache<Object, Object> createManagerAndGetCache(boolean failSilently, int queueSize) { GlobalConfiguration globalConfiguration = new GlobalConfigurationBuilder().globalJmxStatistics().allowDuplicateDomains(true).build(); ConfigurationBuilder cb = TestCacheManagerFactory.getDefaultCacheConfiguration(false); Configuration config = cb.persistence().availabilityInterval(AVAILABILITY_INTERVAL) .addStore(DummyInMemoryStoreConfigurationBuilder.class) .async().enable().modificationQueueSize(queueSize).failSilently(failSilently) .build(); return new DefaultCacheManager(globalConfiguration, config).getCache(); }
/** * @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); }
@Test public void testIfSpringEmbeddedCacheManagerFactoryBeanAllowesOverridingConfigurationWithEmptyInputStream() throws Exception { objectUnderTest = SpringEmbeddedCacheManagerFactoryBeanBuilder .defaultBuilder().build(); // 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().getNativeCacheManager(); assertEquals(infinispanEmbeddedCacheManager.getCacheManagerConfiguration().globalJmxStatistics() .allowDuplicateDomains(), true); assertEquals(infinispanEmbeddedCacheManager.getDefaultCacheConfiguration().transaction().transactionMode().isTransactional(), false); } }
@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()); } }