@Override public ExpirationConfiguration get() { return new ConfigurationBuilder().expiration() .wakeUpInterval(this.interval) .lifespan(this.lifespan) .maxIdle(this.maxIdle) .create(); } }
@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; }
builder.expiration().lifespan(-1).maxIdle(-1); InfinispanWebLogger.ROOT_LOGGER.expirationDisabled(InfinispanCacheRequirement.CONFIGURATION.resolve(this.containerName, templateCacheName));
@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(); } }
@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(); } }
void expire() { builder.expiration() .maxIdle(options.getLong(Caching.CreateOption.IDLE)) .lifespan(options.getLong(Caching.CreateOption.TTL)); } void transact() {
@Override public ExpirationConfiguration get() { return new ConfigurationBuilder().expiration() .wakeUpInterval(this.interval) .lifespan(this.lifespan) .maxIdle(this.maxIdle) .create(); } }
@Override protected EmbeddedCacheManager createCacheManager() throws Exception { ConfigurationBuilder cfg = CacheTestSupport.createLocalCacheConfiguration(); cfg.expiration().lifespan(10l); return TestCacheManagerFactory.createCacheManager(cfg); }
/** * Creates a new ExoCache instance with the relevant parameters * @throws ExoCacheInitException If any exception occurs while creating the cache */ private ExoCache<Serializable, Object> create(ExoCacheConfig config, ConfigurationBuilder confBuilder, Callable<Cache<Serializable, Object>> cacheGetter, String strategy, int maxEntries, long lifespan, long maxIdle, long wakeUpInterval) throws ExoCacheInitException { EvictionStrategy es = strategy == null || strategy.length() == 0 ? null : EvictionStrategy.valueOf(strategy .toUpperCase(Locale.ENGLISH)); if (es == null) { es = EvictionStrategy.LRU; } confBuilder.eviction().strategy(EvictionStrategy.valueOf(strategy)).maxEntries(maxEntries).expiration() .lifespan(lifespan).maxIdle(maxIdle).wakeUpInterval(wakeUpInterval); try { return new GenericExoCache(config, cacheGetter.call()); } catch (Exception e)//NOSONAR { throw new ExoCacheInitException("Cannot create the cache '" + config.getName() + "'", e); } }
/** * Clean the configuration template to prevent conflicts */ protected void resetConfiguration(ConfigurationBuilder confBuilder) { confBuilder.invocationBatching().enable().eviction().strategy(EvictionStrategy.NONE).maxEntries(-1).expiration() .lifespan(-1L).maxIdle(-1L).wakeUpInterval(60000L); } }
@Override protected EmbeddedCacheManager createCacheManager() throws Exception { ConfigurationBuilder builder = new ConfigurationBuilder(); builder.expiration().lifespan(EXPIRATION_TIMEOUT); EmbeddedCacheManager manager = TestCacheManagerFactory.createCacheManager(builder); TestingUtil.replaceComponent(manager, TimeService.class, controlledTimeService, true); return manager; }
protected static org.infinispan.configuration.cache.ConfigurationBuilder getExpiryCacheConfig() { ConfigurationBuilder builder = getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC); builder.expiration().lifespan(EXPIRATION_TIMEOUT).wakeUpInterval(100, TimeUnit.MILLISECONDS); return hotRodCacheConfiguration(builder); }
@Override protected void createCacheManagers() throws Throwable { ConfigurationBuilder defaultClusteredCacheConfig2 = getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC, false); defaultClusteredCacheConfig2.expiration().lifespan(EXPIRATION_TIMEOUT).wakeUpInterval(100, TimeUnit.MILLISECONDS); createClusteredCaches(2, "expiry", defaultClusteredCacheConfig2); cacheManagers.forEach(cm -> replaceComponent(cm, TimeService.class, controlledTimeService, true)); waitForClusterToForm("expiry"); } }
protected EmbeddedCacheManager addClusterEnabledCacheManager(ConfigurationBuilder defaultConfig) { // We don't want anything to expire or evict in the base test - just making sure the generation of metadata // for entries doesn't cause issues switch (expirationType) { case MORTAL: defaultConfig.expiration().lifespan(10, TimeUnit.MINUTES); break; case TRANSIENT: defaultConfig.expiration().maxIdle(10, TimeUnit.MINUTES); break; case TRANSIENT_MORTAL: defaultConfig.expiration().lifespan(10, TimeUnit.MINUTES).maxIdle(10, TimeUnit.MINUTES); break; } if (eviction) { defaultConfig.memory().evictionType(EvictionType.COUNT).size(1000); } return super.addClusterEnabledCacheManager(defaultConfig); }
/** * 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; }
/** * 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; }
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; } }
/** * 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; }
protected ConfigurationBuilder createTopologyCacheConfig(long distSyncTimeout) { ConfigurationBuilder builder = new ConfigurationBuilder(); builder.clustering().cacheMode(CacheMode.REPL_SYNC).remoteTimeout(configuration.topologyReplTimeout()) .locking().lockAcquisitionTimeout(configuration.topologyLockTimeout()) .clustering().partitionHandling().mergePolicy(null) .expiration().lifespan(-1).maxIdle(-1); if (configuration.topologyStateTransfer()) { builder .clustering() .stateTransfer() .awaitInitialTransfer(configuration.topologyAwaitInitialTransfer()) .fetchInMemoryState(true) .timeout(distSyncTimeout + configuration.topologyReplTimeout()); } else { builder.persistence().addClusterLoader().remoteCallTimeout(configuration.topologyReplTimeout()); } return builder; }
@Override protected void createCacheManagers() throws Throwable { ControlledConsistentHashFactory chf = new ControlledConsistentHashFactory.Default(0, 1); ConfigurationBuilder builder = TestCacheManagerFactory.getDefaultCacheConfiguration(true); builder .clustering() .cacheMode(CacheMode.REPL_SYNC) .hash() .numSegments(1) .consistentHashFactory(chf) .expiration() .lifespan(10, TimeUnit.SECONDS) .transaction() .transactionMode(TransactionMode.TRANSACTIONAL) .lockingMode(LockingMode.OPTIMISTIC) .locking() .isolationLevel(IsolationLevel.REPEATABLE_READ) .writeSkewCheck(true) .versioning() .enable() .scheme(VersioningScheme.SIMPLE); createCluster(builder, 2); TestingUtil.replaceComponent(manager(0), TimeService.class, timeService, true); expirationManager1 = cache(0).getAdvancedCache().getExpirationManager(); TestingUtil.replaceComponent(manager(1), TimeService.class, timeService, true); expirationManager2 = cache(1).getAdvancedCache().getExpirationManager(); }