@Override public boolean equals(Object object) { if ((object == null) || !(object instanceof InfinispanXAResourceRecovery)) return false; InfinispanXAResourceRecovery recovery = (InfinispanXAResourceRecovery) object; return this.cache.getCacheManager().getCacheManagerConfiguration().globalJmxStatistics().cacheManagerName().equals(recovery.cache.getCacheManager().getCacheManagerConfiguration().globalJmxStatistics().cacheManagerName()) && this.cache.getName().equals(recovery.cache.getName()); }
@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(); }
@Override public EmbeddedCacheManager get() { GlobalConfiguration config = this.configuration.get(); String defaultCacheName = config.defaultCacheName().orElse(null); // We need to create a dummy default configuration if cache has a default cache Configuration defaultConfiguration = (defaultCacheName != null) ? new ConfigurationBuilder().build() : null; EmbeddedCacheManager manager = new DefaultCacheManager(config, defaultConfiguration, false); // Undefine the default cache, if we defined one if (defaultCacheName != null) { manager.undefineConfiguration(defaultCacheName); } // Override GlobalConfigurationManager with a local implementation @SuppressWarnings("deprecation") BasicComponentRegistry registry = manager.getGlobalComponentRegistry().getComponent(BasicComponentRegistry.class); registry.replaceComponent(GlobalConfigurationManager.class.getName(), new LocalGlobalConfigurationManager(), false); registry.rewire(); manager.start(); manager.addListener(this); InfinispanLogger.ROOT_LOGGER.debugf("%s cache container started", this.name); return manager; }
@Override public String getName() { GlobalConfiguration global = this.cache.getCacheManager().getCacheManagerConfiguration(); TransportConfiguration transport = global.transport(); return transport.transport() != null ? transport.clusterName() : global.globalJmxStatistics().cacheManagerName(); }
@Test public final void testAddConfigurations() throws Exception { final InfinispanEmbeddedCacheManagerFactoryBean objectUnderTest = new InfinispanEmbeddedCacheManagerFactoryBean(); GlobalConfigurationBuilder gcb = new GlobalConfigurationBuilder(); // 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 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")); }
gc.listenerThreadPool().threadPoolFactory(); assertEquals(5, listenerThreadPool.maxThreads()); assertEquals(10000, listenerThreadPool.queueLength()); DefaultThreadFactory listenerThreadFactory = gc.listenerThreadPool().threadFactory(); assertEquals("AsyncListenerThread", listenerThreadFactory.threadNamePattern()); gc.persistenceThreadPool().threadPoolFactory(); DefaultThreadFactory persistenceThreadFactory = gc.persistenceThreadPool().threadFactory(); gc.asyncThreadPool().threadPoolFactory(); DefaultThreadFactory asyncThreadFactory = gc.asyncThreadPool().threadFactory(); gc.transport().transportThreadPool().threadPoolFactory(); gc.transport().remoteCommandThreadPool().threadPoolFactory(); gc.stateTransferThreadPool().threadPoolFactory(); gc.expirationThreadPool().threadFactory(); assertTrue(gc.transport().transport() instanceof JGroupsTransport); assertEquals("infinispan-cluster", gc.transport().clusterName()); assertEquals("Jalapeno", gc.transport().nodeName()); assertEquals(50000, gc.transport().distributedSyncTimeout());
public void check(ConfigurationBuilderHolder holder) { GlobalConfiguration g = getGlobalConfiguration(holder); assertEquals("maximal", g.globalJmxStatistics().cacheManagerName()); assertTrue(g.globalJmxStatistics().enabled()); assertEquals("my-domain", g.globalJmxStatistics().domain()); assertTrue(g.globalJmxStatistics().mbeanServerLookup() instanceof CustomMBeanServerPropertiesTest.TestLookup); assertEquals(1, g.globalJmxStatistics().properties().size()); assertEquals("value", g.globalJmxStatistics().properties().getProperty("key")); assertEquals("maximal-cluster", g.transport().clusterName()); assertEquals(120000, g.transport().distributedSyncTimeout()); assertEquals("udp", g.transport().properties().getProperty("stack-udp")); assertEquals("tcp", g.transport().properties().getProperty("stack-tcp")); assertEquals("jgroups-udp.xml", g.transport().properties().getProperty("stackFilePath-udp")); assertEquals("jgroups-tcp.xml", g.transport().properties().getProperty("stackFilePath-tcp")); assertEquals("tcp", g.transport().properties().getProperty("stack")); threadFactory = getGlobalConfiguration(holder).listenerThreadPool().threadFactory(); threadPool = getGlobalConfiguration(holder).listenerThreadPool().threadPoolFactory(); assertTrue(getGlobalConfiguration(holder).expirationThreadPool().threadPoolFactory() instanceof ScheduledThreadPoolExecutorFactory); threadFactory = getGlobalConfiguration(holder).expirationThreadPool().threadFactory(); ThreadPoolExecutorFactory threadPoolExecutorFactory = getGlobalConfiguration(holder).replicationQueueThreadPool().threadPoolFactory(); threadFactory = getGlobalConfiguration(holder).replicationQueueThreadPool().threadFactory(); threadFactory = getGlobalConfiguration(holder).transport().remoteCommandThreadPool().threadFactory();
public void testNamedCacheXML() throws IOException { cm = TestCacheManagerFactory.fromXml("configs/named-cache-test.xml"); assertEquals("s1", cm.getCacheManagerConfiguration().transport().siteId()); assertEquals("r1", cm.getCacheManagerConfiguration().transport().rackId()); assertEquals("m1", cm.getCacheManagerConfiguration().transport().machineId()); Cache c = cm.getCache(); assertEquals(100, c.getCacheConfiguration().locking().concurrencyLevel()); assertEquals(1000, c.getCacheConfiguration().locking().lockAcquisitionTimeout()); assertFalse(c.getCacheConfiguration().transaction().transactionMode().isTransactional()); assertEquals(TransactionMode.NON_TRANSACTIONAL, c.getCacheConfiguration().transaction().transactionMode()); assertNotNull("This should not be null, since a shared transport should be present", TestingUtil.extractComponent(c, Transport.class));
Map<String, Configuration> configurations = new HashMap<>(); for(Map.Entry<String, ConfigurationBuilder> configuration : holderBefore.getNamedConfigurationBuilders().entrySet()) { configurations.put(configuration.getKey(), configuration.getValue().build()); registry.serialize(baos, holderBefore.getGlobalConfigurationBuilder().build(), configurations); GlobalConfiguration globalConfigurationBefore = holderBefore.getGlobalConfigurationBuilder().build(); GlobalConfiguration globalConfigurationAfter = holderAfter.getGlobalConfigurationBuilder().build(); assertEquals(globalConfigurationBefore.sites().localSite(), globalConfigurationAfter.sites().localSite()); assertEquals(globalConfigurationBefore.security().securityCacheTimeout(), globalConfigurationAfter.security().securityCacheTimeout()); compareAttributeSets("Global", globalConfigurationBefore.globalState().attributes(), globalConfigurationAfter.globalState().attributes(), "localConfigurationStorage"); compareAttributeSets("Global", globalConfigurationBefore.globalJmxStatistics().attributes(), globalConfigurationAfter.globalJmxStatistics().attributes(), "mBeanServerLookup"); compareAttributeSets("Global", globalConfigurationBefore.security().authorization().attributes(), globalConfigurationAfter.security().authorization().attributes()); compareAttributeSets("Global", globalConfigurationBefore.serialization().attributes(), globalConfigurationAfter.serialization().attributes(), "marshaller", "classResolver"); compareAttributeSets("Global", globalConfigurationBefore.transport().attributes(), globalConfigurationAfter.transport().attributes(), "transport"); compareExtraGlobalConfiguration(globalConfigurationBefore, globalConfigurationAfter); Configuration configurationBefore = holderBefore.getNamedConfigurationBuilders().get(name).build(); Configuration configurationAfter = holderAfter.getNamedConfigurationBuilders().get(name).build(); compareAttributeSets(name, configurationBefore.clustering().attributes(), configurationAfter.clustering().attributes()); compareAttributeSets(name, configurationBefore.compatibility().attributes(), configurationAfter.compatibility().attributes(), "marshaller"); compareAttributeSets(name, configurationBefore.memory().attributes(), configurationAfter.memory().attributes()); compareAttributeSets(name, configurationBefore.expiration().attributes(), configurationAfter.expiration().attributes());
@Override public void call() { GlobalConfiguration globalCfg = cm.getCacheManagerConfiguration(); assertFalse(globalCfg.defaultCacheName().isPresent()); assertNull(cm.getDefaultCacheConfiguration()); assertEquals(CacheMode.REPL_SYNC, cm.getCacheConfiguration("default").clustering().cacheMode()); }
private Configuration getInternalCacheConfig() { ConfigurationBuilder configurationBuilder = new ConfigurationBuilder(); // allow the registry to work for local caches as well as clustered caches CacheMode cacheMode = cacheManager.getGlobalComponentRegistry().getGlobalConfiguration().isClustered() ? CacheMode.REPL_SYNC : CacheMode.LOCAL; configurationBuilder.clustering().cacheMode(cacheMode); // use invocation batching (cache-only transactions) for high consistency as writes are expected to be rare in this cache configurationBuilder.transaction().transactionMode(TransactionMode.TRANSACTIONAL) .transactionManagerLookup(null).invocationBatching().enable(); configurationBuilder.security().authorization().disable(); return configurationBuilder.build(); }
@Override public void call() { GlobalConfiguration globalCfg = cm.getCacheManagerConfiguration(); assertTrue(globalCfg.transport().transport() instanceof JGroupsTransport); assertEquals("demoCluster", globalCfg.transport().clusterName()); Configuration cfg = cm.getDefaultCacheConfiguration(); assertEquals(CacheMode.REPL_SYNC, cfg.clustering().cacheMode()); }
@Test public void testIfSpringEmbeddedCacheManagerFactoryBeanAllowesOverridingGlobalConfiguration() throws Exception { GlobalConfigurationBuilder overriddenConfiguration = new GlobalConfigurationBuilder(); overriddenConfiguration.transport().rackId("r2"); 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 void validateCacheManagerConfiguration() { if (cacheManager.getCacheConfiguration(metadataCacheName) == null) { if (cacheManager.getCacheConfiguration(metadataCacheName) == null) { log.missingIndexCacheConfiguration(metadataCacheName); ConfigurationBuilder builder = new ConfigurationBuilder(); if (cacheManager.getCacheManagerConfiguration().isClustered()) { .clustering().cacheMode(CacheMode.REPL_SYNC).remoteTimeout(25000) .stateTransfer().awaitInitialTransfer(true).timeout(480000) .locking().useLockStriping(false).lockAcquisitionTimeout(10000).concurrencyLevel(500) builder.simpleCache(true); cacheManager.defineConfiguration(metadataCacheName, builder.build()); log.missingIndexCacheConfiguration(dataCacheName); ConfigurationBuilder builder = new ConfigurationBuilder(); if (cacheManager.getCacheManagerConfiguration().isClustered()) { log.missingIndexCacheConfiguration(lockingCacheName); ConfigurationBuilder builder = new ConfigurationBuilder(); if (cacheManager.getCacheManagerConfiguration().isClustered()) {
@Override protected ConfigurationBuilder getConfigurationBuilder() { ConfigurationBuilder builder = new ConfigurationBuilder(); Configuration templateConfiguration = this.dependencies.getTemplateConfiguration(); if (templateConfiguration != null) { builder.read(templateConfiguration); } Configuration configuration = this.builder.build(); builder.read(configuration); builder.template(configuration.isTemplate()); builder.jmxStatistics().enabled(this.dependencies.getCacheContainer().getCacheManagerConfiguration().globalJmxStatistics().enabled()); TransactionManager tm = this.dependencies.getTransactionManager(); if (tm != null) { builder.transaction().transactionManagerLookup(new TransactionManagerProvider(tm)); } TransactionSynchronizationRegistry tsr = this.dependencies.getTransactionSynchronizationRegistry(); if (tsr != null) { builder.transaction().transactionSynchronizationRegistryLookup(new TransactionSynchronizationRegistryProvider(tsr)); } return builder; } }
@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()); }
/** * Carry out any initialization tasks that might be necessary */ @Override public void initialize() { cacheManager = new DefaultCacheManager(globalConfiguration, defaultConfiguration, true); if(entryCache == null) { cacheManager.defineConfiguration(LDCACHE_ENTRY_CACHE, defaultConfiguration); entryCache = cacheManager.<String,CacheEntry>getCache(LDCACHE_ENTRY_CACHE).getAdvancedCache().withFlags(Flag.SKIP_LOCKING, Flag.SKIP_CACHE_LOAD, Flag.SKIP_REMOTE_LOOKUP); } log.info("initialised cache manager ({})", globalConfiguration.isClustered() ? "cluster name: "+globalConfiguration.transport().clusterName() : "single host"); }
public void testGlobalConfig() throws Exception { ConfigurationBuilderHolder holder = parse(); GlobalConfiguration gc = holder.getGlobalConfigurationBuilder().build(); BlockingThreadPoolExecutorFactory listenerThreadPool = gc.listenerThreadPool().threadPoolFactory(); assertEquals(2, listenerThreadPool.maxThreads()); BlockingThreadPoolExecutorFactory persistenceThreadPool = gc.persistenceThreadPool().threadPoolFactory(); assertEquals(4, persistenceThreadPool.maxThreads()); Properties transportProps = gc.transport().properties(); assertEquals("jgroups-tcp.xml", transportProps.get("configurationFile")); Configuration configuration = holder.getDefaultConfigurationBuilder().build(); assertEquals(IsolationLevel.READ_COMMITTED, configuration.locking().isolationLevel()); } }
private void defineDataTypeCacheConfigurations(ServiceRegistry serviceRegistry) { String defaultResource = manager.getCacheManagerConfiguration().isClustered() ? DEF_INFINISPAN_CONFIG_RESOURCE : INFINISPAN_CONFIG_LOCAL_RESOURCE; ConfigurationBuilderHolder defaultConfiguration = DefaultCacheManagerProvider.loadConfiguration(serviceRegistry, defaultResource); for ( DataType type : DataType.values() ) { cacheName = type.defaultCacheName; Configuration configuration = manager.getCacheConfiguration(cacheName); ConfigurationBuilder builder; if (configuration == null) { builder = new ConfigurationBuilder().read(configuration); builder.read(override.build(false)); builder.template(true);