@SuppressWarnings("deprecation") @Override public void accept(ConfigurationBuilder builder) { ClusteringConfigurationBuilder clustering = builder.clustering(); CacheMode mode = clustering.cacheMode(); clustering.cacheMode(mode.needsStateTransfer() ? CacheMode.REPL_SYNC : CacheMode.LOCAL); // don't use DefaultConsistentHashFactory for REPL caches (WFLY-9276) clustering.hash().consistentHashFactory(null); clustering.l1().disable(); // Workaround for ISPN-8722 AttributeSet attributes = TemplateConfigurationServiceConfigurator.getAttributes(clustering); attributes.attribute(ClusteringConfiguration.BIAS_ACQUISITION).reset(); attributes.attribute(ClusteringConfiguration.BIAS_LIFESPAN).reset(); attributes.attribute(ClusteringConfiguration.INVALIDATION_BATCH_SIZE).reset(); // Ensure we use the default data container builder.dataContainer().dataContainer(null); // Disable expiration builder.expiration().lifespan(-1).maxIdle(-1); // Disable eviction builder.memory().size(-1).evictionStrategy(EvictionStrategy.MANUAL); builder.persistence().clearStores(); StateTransferConfigurationBuilder stateTransfer = clustering.stateTransfer().fetchInMemoryState(mode.needsStateTransfer()); attributes = TemplateConfigurationServiceConfigurator.getAttributes(stateTransfer); attributes.attribute(StateTransferConfiguration.AWAIT_INITIAL_TRANSFER).reset(); attributes.attribute(StateTransferConfiguration.TIMEOUT).reset(); } }
@Override public ExpirationConfiguration get() { return new ConfigurationBuilder().expiration() .wakeUpInterval(this.interval) .lifespan(this.lifespan) .maxIdle(this.maxIdle) .create(); } }
/** * Create cache manager with custom idle time. * * @param idleTime idle time in seconds * @return cache manager */ public static EmbeddedCacheManager create(long idleTime) { Configuration configuration = new ConfigurationBuilder() .expiration().maxIdle(idleTime, TimeUnit.SECONDS) .build(); return new DefaultCacheManager(configuration); }
@Override public Collection<CapabilityServiceConfigurator> getDeploymentServiceConfigurators(final ServiceName name) { String cacheName = getCacheName(name, this.name); String containerName = this.config.getContainerName(); String templateCacheName = this.config.getCacheName(); // Ensure eviction and expiration are disabled @SuppressWarnings("deprecation") Consumer<ConfigurationBuilder> configurator = builder -> { // Ensure expiration is not enabled on cache ExpirationConfiguration expiration = builder.expiration().create(); if ((expiration.lifespan() >= 0) || (expiration.maxIdle() >= 0)) { builder.expiration().lifespan(-1).maxIdle(-1); InfinispanEjbLogger.ROOT_LOGGER.expirationDisabled(InfinispanCacheRequirement.CONFIGURATION.resolve(containerName, templateCacheName)); } int size = this.config.getMaxSize(); EvictionStrategy strategy = (size > 0) ? EvictionStrategy.REMOVE : EvictionStrategy.MANUAL; builder.memory().evictionStrategy(strategy).evictionType(EvictionType.COUNT).storageType(StorageType.OBJECT).size(size); if (strategy.isEnabled()) { // Only evict bean group entries // We will cascade eviction to the associated beans builder.dataContainer().dataContainer(EvictableDataContainer.createDataContainer(builder, size, BeanGroupKey.class::isInstance)); } }; List<CapabilityServiceConfigurator> builders = new ArrayList<>(3); builders.add(new TemplateConfigurationServiceConfigurator(ServiceName.parse(InfinispanCacheRequirement.CONFIGURATION.resolve(containerName, cacheName)), containerName, cacheName, templateCacheName, configurator)); builders.add(new CacheServiceConfigurator<>(ServiceName.parse(InfinispanCacheRequirement.CACHE.resolve(containerName, cacheName)), containerName, cacheName).require(new ServiceDependency(name.append("marshalling")))); builders.add(new ServiceConfiguratorAdapter(new RemoveOnCancelScheduledExecutorServiceConfigurator(name.append(this.name, "expiration"), EXPIRATION_THREAD_FACTORY))); return builders; }
/** * Return the triple id -> triple cache from the cache manager. This cache is used for speeding up the * construction of query results. * * @return */ public Map getTripleCache() { if(tripleCache == null) { Configuration tripleConfiguration = new ConfigurationBuilder().read(defaultConfiguration) .clustering() .cacheMode(CacheMode.LOCAL) .eviction() .maxEntries(config.getTripleCacheSize()) .expiration() .lifespan(60, TimeUnit.MINUTES) .maxIdle(30, TimeUnit.MINUTES) .build(); cacheManager.defineConfiguration(TRIPLE_CACHE, tripleConfiguration); tripleCache = new AsyncMap(cacheManager.getCache(TRIPLE_CACHE).getAdvancedCache().withFlags(Flag.SKIP_LOCKING, Flag.SKIP_CACHE_LOAD, Flag.SKIP_REMOTE_LOOKUP)); } return tripleCache; }
ConfigurationBuilder confBuilder = new ConfigurationBuilder(); confBuilder.read(defaultConf); confBuilder.locking().isolationLevel(IsolationLevel.READ_COMMITTED).concurrencyLevel(32).useLockStriping(false) .lockAcquisitionTimeout(10000); confBuilder.expiration().wakeUpInterval(-1); Configuration conf = confBuilder.build();
ConfigurationBuilder configurationBuilder = new ConfigurationBuilder(); configurationBuilder.jmxStatistics().enable(); configurationBuilder.eviction().maxEntries(123); configurationBuilder.expiration().maxIdle(180000); configurationBuilder.indexing() .index(Index.ALL) .addProperty("lucene_version", "LUCENE_CURRENT"); cm.defineConfiguration(MY_CUSTOM_CACHE, configurationBuilder.build()); Cache<String,String> cache = cm.getCache(MY_CUSTOM_CACHE);
.build(); defaultConfiguration = new ConfigurationBuilder() .clustering() .cacheMode(CacheMode.REPL_ASYNC) .async() .asyncMarshalling() .stateTransfer() .maxEntries(100000) .expiration() .lifespan(30, TimeUnit.MINUTES) .maxIdle(10, TimeUnit.MINUTES) .build(); cacheManager = new DefaultCacheManager(globalConfiguration, defaultConfiguration, true);
private Cache<String, Integer> configureAndBuildCache(int capacity) { ConfigurationBuilder config = new ConfigurationBuilder(); config .memory().size(capacity) .expiration().wakeUpInterval(5000L).maxIdle(120000L); String cacheName = "cache" + capacity; cacheManager.defineConfiguration(cacheName, config.build()); return cacheManager.getCache(cacheName); }
@Override protected EmbeddedCacheManager createCacheManager() throws Exception { ConfigurationBuilder cfg = new ConfigurationBuilder(); cfg.memory().size(CACHE_SIZE).evictionType(EvictionType.COUNT).storageType(StorageType.BINARY) .expiration().wakeUpInterval(100L) .locking().useLockStriping(false) // to minimise chances of deadlock in the unit test .build(); cacheManager = TestCacheManagerFactory.createCacheManager(cfg); cache = cacheManager.getCache(); return cacheManager; }
public void testDefineMultipleCachesWithExpiration() { for (int i = 0; i < 50; i++) { ConfigurationBuilder cfg = new ConfigurationBuilder(); cfg .expiration().wakeUpInterval(100L); String cacheName = Integer.toString(i); cacheManager.defineConfiguration(cacheName, cfg.build()); cacheManager.getCache(cacheName); } ThreadMXBean threadMBean = ManagementFactory.getThreadMXBean(); ThreadInfo[] threadInfos = threadMBean.dumpAllThreads(false, false); String pattern = EXPIRATION_THREAD_NAME_PREFIX; int evictionThreadCount = 0; for (ThreadInfo threadInfo : threadInfos) { if (threadInfo.getThreadName().startsWith(pattern)) evictionThreadCount++; } assert evictionThreadCount == 1 : "Thread should only be one expiration thread with pattern '" + pattern + "', instead there were " + evictionThreadCount; }
/** * Overrides the default embedded cache manager. */ @Produces @ApplicationScoped @SuppressWarnings("unused") public EmbeddedCacheManager defaultCacheManager() throws IOException { EmbeddedCacheManager externalCacheContainerManager = TestCacheManagerFactory.fromXml("infinispan.xml"); externalCacheContainerManager.defineConfiguration("quick-very-large", new ConfigurationBuilder() .read(externalCacheContainerManager.getDefaultCacheConfiguration()) .expiration().wakeUpInterval(1l) .build()); return externalCacheContainerManager; }
/** * Return the node id -> node cache from the cache manager. This cache is heavily used to lookup * nodes when querying or loading triples and should therefore have a decent size (default 500.000 elements). * * @return an EHCache Cache instance containing the node id -> node mappings */ public Map getNodeCache() { if(nodeCache == null) { Configuration nodeConfiguration = new ConfigurationBuilder().read(defaultConfiguration) .eviction() .maxEntries(1000000) .expiration() .lifespan(60, TimeUnit.MINUTES) .maxIdle(30, TimeUnit.MINUTES) .build(); cacheManager.defineConfiguration(NODE_CACHE, nodeConfiguration); nodeCache = new AsyncMap(cacheManager.getCache(NODE_CACHE).getAdvancedCache().withFlags(Flag.SKIP_LOCKING, Flag.SKIP_CACHE_LOAD, Flag.SKIP_REMOTE_LOOKUP)); } return nodeCache; }
@BeforeClass public void setup() throws Exception { ConfigurationBuilder serverBuilder = TestCacheManagerFactory.getDefaultCacheConfiguration(false); serverBuilder.memory().size(100) .expiration().wakeUpInterval(10L); serverCacheManager = TestCacheManagerFactory.createCacheManager( hotRodCacheConfiguration(serverBuilder)); serverCache = serverCacheManager.getCache(); hrServer = HotRodClientTestingUtil.startHotRodServer(serverCacheManager); ConfigurationBuilder clientBuilder = TestCacheManagerFactory.getDefaultCacheConfiguration(false); clientBuilder.persistence().addStore(RemoteStoreConfigurationBuilder.class) .rawValues(true) .addServer() .host(hrServer.getHost()) .port(hrServer.getPort()); clientCacheManager = TestCacheManagerFactory.createCacheManager(clientBuilder); clientCache = clientCacheManager.getCache(); org.infinispan.client.hotrod.configuration.ConfigurationBuilder rcmBuilder = new org.infinispan.client.hotrod.configuration.ConfigurationBuilder(); rcmBuilder.addServer() .host(hrServer.getHost()) .port(hrServer.getPort()); remoteCacheManager = new RemoteCacheManager(rcmBuilder.build()); remoteCacheManager.start(); remoteCache = remoteCacheManager.getCache(); }
if (cacheManager == null) { EmbeddedCacheManager cacheManager = new DefaultCacheManager(configStream, false); GlobalConfiguration globalConfigFromXml = cacheManager.getCacheManagerConfiguration(); Configuration configFromXml = cacheManager.getDefaultCacheConfiguration(); ConfigurationBuilder configBuilder = new ConfigurationBuilder().read(configFromXml); if (tmLookup == null) { tmLookup = getTransactionManagerLookup(); configBuilder.transaction().transactionManagerLookup(tmLookup); configBuilder.expiration().lifespan(-1); log.debug("Expiration of structure cache entries is disabled. Leaf nodes will use expiration " + cacheLifespanOfLeafNodes);
@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); localCacheManager = TestCacheManagerFactory.createServerModeCacheManager(localBuilder); localCacheManager.defineConfiguration(REMOTE_CACHE, localCacheManager.getDefaultCacheConfiguration()); localCacheManager.getCache(REMOTE_CACHE); TestingUtil.replaceComponent(localCacheManager, TimeService.class, timeService, true); localCacheManager.getCache(REMOTE_CACHE).getAdvancedCache().getComponentRegistry().rewire(); RestServerConfigurationBuilder restServerConfigurationBuilder = new RestServerConfigurationBuilder(); restServerConfigurationBuilder.port(0); restServer = new RestServer(); restServer.start(restServerConfigurationBuilder.build(), localCacheManager); ConfigurationBuilder builder = TestCacheManagerFactory.getDefaultCacheConfiguration(false); RestStoreConfigurationBuilder storeConfigurationBuilder = builder.persistence() .addStore(RestStoreConfigurationBuilder.class); storeConfigurationBuilder.host(restServer.getHost()).port(restServer.getPort()).path("/rest/" + REMOTE_CACHE); storeConfigurationBuilder.connectionPool().maxTotalConnections(10).maxConnectionsPerHost(10); storeConfigurationBuilder.validate(); RestStore restStore = new RestStore(); restStore.init(createContext(builder.build())); return restStore; }
@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; }
throws OperationFailedException { builder.jmxStatistics().enabled(CacheConfigurationResource.STATISTICS.resolveModelAttribute(context, cache).asBoolean()); builder.jmxStatistics().available(CacheConfigurationResource.STATISTICS_AVAILABLE.resolveModelAttribute(context, cache).asBoolean()); builder.simpleCache(CacheConfigurationResource.SIMPLE_CACHE.resolveModelAttribute(context, cache).asBoolean()); builder.clustering().cacheMode(this.mode); builder.expiration() .maxIdle(maxIdle) .lifespan(lifespan) .wakeUpInterval(interval) builder.expiration().enableReaper(); } else { builder.expiration().disableReaper();
/** * 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; }
@Test @TestForIssue(jiraKey = "HHH-9928") public void testGetForNullReleasePuts() { ConfigurationBuilder cb = new ConfigurationBuilder(); cb.simpleCache(true).expiration().maxIdle(500); Configuration ppCfg = cb.build(); String ppName = cm.getCache().getName() + "-" + InfinispanProperties.DEF_PENDING_PUTS_RESOURCE; Map ppCache = cm.getCache(ppName, false); assertNotNull(ppCache); Object pendingPutMap = ppCache.get(KEY1);