protected GlobalConfigurationBuilder createForeignExternalizerGlobalConfig() { //Needed Externalizers should be picked up automatically via the Module system return new GlobalConfigurationBuilder().clusteredDefault(); }
/** * Allows multiple configurations to be defined for a cache manager before it is started, using the supplied * {@link ConfigurationBuilderHolder}. These cannot be shared per node so this method doesn't allow the user to make * the mistake and instead will give you one instance per node. * <p> * This method will wait until all nodes are up before returning * @param consumer consumer to configure the caches * @param count how many nodes to bring up */ protected void createCluster(Consumer<ConfigurationBuilderHolder> consumer, int count) { for (int i = 0; i < count; ++i) { ConfigurationBuilderHolder holder = new ConfigurationBuilderHolder(); holder.getGlobalConfigurationBuilder().clusteredDefault(); consumer.accept(holder); addClusterEnabledCacheManager(holder); } waitForClusterToForm(); }
if (clustered) { serviceProperties.put(CacheFactoryConstants.CLUSTERED, Boolean.TRUE); builder.clusteredDefault(); builderHelper.applyConfigOnBuilderValue(CacheFactoryConstants.TRANSPORT__CLUSTER_NAME, String.class, false);
for (int machineNumber = 0; machineNumber < machines; ++machineNumber) { ConfigurationBuilderHolder holder = new ConfigurationBuilderHolder(); GlobalConfigurationBuilder globalConfigurationBuilder = holder.getGlobalConfigurationBuilder().clusteredDefault();
protected EmbeddedCacheManager createCacheManager(String persistentStateLocation) throws Exception { GlobalConfigurationBuilder global = new GlobalConfigurationBuilder().clusteredDefault(); global.globalState().enable().persistentLocation(persistentStateLocation); EmbeddedCacheManager cacheManager = TestCacheManagerFactory.createClusteredCacheManager(global, new ConfigurationBuilder()); return cacheManager; }
protected EmbeddedCacheManager createCacheManager(String persistentStateLocation) throws Exception { GlobalConfigurationBuilder global = new GlobalConfigurationBuilder().clusteredDefault(); global.globalState().enable().persistentLocation(persistentStateLocation); EmbeddedCacheManager cacheManager = TestCacheManagerFactory.createClusteredCacheManager(global, new ConfigurationBuilder()); cacheManager.getCache(); return cacheManager; } }
protected EmbeddedCacheManager createCacheManager(String persistentStateLocation) throws Exception { GlobalConfigurationBuilder global = new GlobalConfigurationBuilder().clusteredDefault(); global.globalState().enable().persistentLocation(persistentStateLocation); EmbeddedCacheManager cacheManager = TestCacheManagerFactory.createClusteredCacheManager(global, new ConfigurationBuilder()); cacheManager.getCache(); return cacheManager; }
private EmbeddedCacheManager getManagerWithStore(Method m, boolean isClustered, boolean isStoreShared, String storePrefix) { String storeName = storePrefix + m.getName(); ConfigurationBuilder c = new ConfigurationBuilder(); c .persistence() .addStore(DummyInMemoryStoreConfigurationBuilder.class).storeName(storeName).shared(isStoreShared) .clustering() .cacheMode(isClustered ? CacheMode.REPL_SYNC : CacheMode.LOCAL); GlobalConfigurationBuilder gcb = new GlobalConfigurationBuilder().clusteredDefault(); EmbeddedCacheManager cm = TestCacheManagerFactory.createClusteredCacheManager(gcb, c); cm.defineConfiguration("cache", c.build()); return cm; }
@Override protected void createCacheManagers() { for (int i = 0; i < nodeCount(); i++) { char id = 'A'; id += i; GlobalConfigurationBuilder builder = new GlobalConfigurationBuilder().clusteredDefault(); builder.globalState().enable() .persistentLocation(PERSISTENT_LOCATION + File.separator + id) .temporaryLocation(TMP_LOCATION) .sharedPersistentLocation(SHARED_LOCATION); EmbeddedCacheManager cm = createClusteredCacheManager(builder, hotRodCacheConfiguration()); cacheManagers.add(cm); } waitForClusterToForm(CounterModuleLifecycle.COUNTER_CACHE_NAME); }
protected GlobalConfigurationBuilder createForeignExternalizerGlobalConfig() { GlobalConfigurationBuilder builder = new GlobalConfigurationBuilder().clusteredDefault(); builder.serialization() .addAdvancedExternalizer(1234, new IdViaConfigObj.Externalizer()) .addAdvancedExternalizer(new IdViaAnnotationObj.Externalizer()) .addAdvancedExternalizer(3456, new IdViaBothObj.Externalizer()); return builder; }
@Override protected GlobalConfigurationBuilder createForeignExternalizerGlobalConfig() { GlobalConfigurationBuilder builder = new GlobalConfigurationBuilder().clusteredDefault(); builder.serialization() .addAdvancedExternalizer(1234, new IdViaConfigObj.Externalizer()) .addAdvancedExternalizer(new IdViaAnnotationObj.Externalizer()) .addAdvancedExternalizer(3456, new IdViaBothObj.Externalizer()); return builder; }
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; } }
@Override protected void createCacheManagers() throws Throwable { cfgBuilder = getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC, true); cfgBuilder.transaction().transactionManagerLookup(new EmbeddedTransactionManagerLookup()); cfgBuilder.clustering().hash().numOwners(2); cfgBuilder.clustering().stateTransfer().fetchInMemoryState(true); cfgBuilder.clustering().stateTransfer().timeout(20000); GlobalConfigurationBuilder gcb0 = new GlobalConfigurationBuilder().clusteredDefault(); addClusterEnabledCacheManager(gcb0, cfgBuilder, new TransportFlags().withFD(true)); GlobalConfigurationBuilder gcb1 = new GlobalConfigurationBuilder().clusteredDefault(); addClusterEnabledCacheManager(gcb1, cfgBuilder, new TransportFlags().withFD(true)); }
@Override protected void createCacheManagers() throws Exception { GlobalConfigurationBuilder globalBuilder = new GlobalConfigurationBuilder(); globalBuilder.addModule(PrivateGlobalConfigurationBuilder.class).serverMode(true); GlobalConfigurationBuilder globalConfiguration = globalBuilder.clusteredDefault(); createCluster(globalConfiguration, getDefaultCacheBuilder(), NUM_SERVERS); for (EmbeddedCacheManager cm : cacheManagers) { this.defineCaches(cm); String[] cacheNames = cm.getCacheNames().toArray(new String[0]); cm.startCaches(cacheNames); cm.getClassWhiteList().addClasses(TestClass.class); waitForClusterToForm(cacheNames); RestServerHelper restServerHelper = new RestServerHelper(cm); restServerHelper.start(TestResourceTracker.getCurrentTestShortName()); restServers.add(restServerHelper); } client = new HttpClient(); client.start(); }
public void testAddRemoveListenerWhileNotRunning() throws Exception { GetCacheManagerCheckListener listener = new GetCacheManagerCheckListener(); ConfigurationBuilderHolder holder = new ConfigurationBuilderHolder(); holder.getGlobalConfigurationBuilder().clusteredDefault().defaultCacheName("default"); holder.newConfigurationBuilder("default").clustering().cacheMode(CacheMode.DIST_SYNC); EmbeddedCacheManager cmA = TestCacheManagerFactory.createClusteredCacheManager(false, holder, false); EmbeddedCacheManager cmB = null; try { cmA.addListener(listener); cmA.getCache(); cmB = TestCacheManagerFactory.createClusteredCacheManager(); cmB.getCache(); assertNotNull(listener.firstEvent.get(10, TimeUnit.SECONDS)); } finally { TestingUtil.killCacheManagers(cmA, cmB); } // Should not throw an exception? cmA.removeListener(listener); }
GlobalConfigurationBuilder globalConfigurationBuilder = holder.getGlobalConfigurationBuilder().clusteredDefault(); globalConfigurationBuilder.transport().machineId("a" + i).rackId("b" + i).siteId("test" + i).defaultCacheName(defaultCacheName);
@Override protected AdvancedLoadWriteStore createStore() throws Exception { ConfigurationBuilder localBuilder = TestCacheManagerFactory.getDefaultCacheConfiguration(false); localBuilder.memory().evictionType(EvictionType.COUNT).size(WRITE_DELETE_BATCH_MAX_ENTRIES).expiration().wakeUpInterval(10L); // Set it to dist so it has segments localBuilder.clustering().cacheMode(CacheMode.DIST_SYNC); GlobalConfigurationBuilder globalConfig = new GlobalConfigurationBuilder().clusteredDefault(); globalConfig.globalJmxStatistics().defaultCacheName(REMOTE_CACHE); localCacheManager = TestCacheManagerFactory.createClusteredCacheManager( globalConfig, hotRodCacheConfiguration(localBuilder)); localCacheManager.getCache(REMOTE_CACHE); TestingUtil.replaceComponent(localCacheManager, TimeService.class, timeService, true); localCacheManager.getCache(REMOTE_CACHE).getAdvancedCache().getComponentRegistry().rewire(); hrServer = HotRodClientTestingUtil.startHotRodServer(localCacheManager); // In case if the server has to unmarshall the value, make sure to use the same marshaller hrServer.setMarshaller(getMarshaller()); ConfigurationBuilder builder = TestCacheManagerFactory .getDefaultCacheConfiguration(false); RemoteStoreConfigurationBuilder storeConfigurationBuilder = builder .persistence() .addStore(RemoteStoreConfigurationBuilder.class) .remoteCacheName(REMOTE_CACHE); storeConfigurationBuilder .addServer() .host(hrServer.getHost()) .port(hrServer.getPort()); RemoteStore remoteStore = new RemoteStore(); remoteStore.init(createContext(builder.build())); return remoteStore; }