You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@marmotta.apache.org by ss...@apache.org on 2013/12/17 15:47:35 UTC
[2/7] git commit: towards MARMOTTA-388: triplestore now working with
infinispan, configurable cluster mode
towards MARMOTTA-388: triplestore now working with infinispan, configurable cluster mode
Project: http://git-wip-us.apache.org/repos/asf/marmotta/repo
Commit: http://git-wip-us.apache.org/repos/asf/marmotta/commit/0d79835c
Tree: http://git-wip-us.apache.org/repos/asf/marmotta/tree/0d79835c
Diff: http://git-wip-us.apache.org/repos/asf/marmotta/diff/0d79835c
Branch: refs/heads/develop
Commit: 0d79835c1e27333ba72229391a8303ba94b4c996
Parents: c0c795b
Author: Sebastian Schaffert <ss...@apache.org>
Authored: Mon Dec 16 19:48:58 2013 +0100
Committer: Sebastian Schaffert <ss...@apache.org>
Committed: Mon Dec 16 19:48:58 2013 +0100
----------------------------------------------------------------------
.../kiwi/loader/generic/KiWiHandler.java | 46 +-
.../marmotta/kiwi/caching/KiWiCacheManager.java | 110 ++-
.../marmotta/kiwi/config/KiWiConfiguration.java | 41 +
.../marmotta/kiwi/config/RegistryStrategy.java | 39 +
.../registry/CacheTripleRegistry.java | 49 +-
.../marmotta/kiwi/sail/KiWiValueFactory.java | 16 +-
.../src/main/resources/ehcache-kiwi.xml | 770 -------------------
.../src/test/resources/logback.xml | 2 +-
8 files changed, 225 insertions(+), 848 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0d79835c/libraries/kiwi/kiwi-loader/src/main/java/org/apache/marmotta/kiwi/loader/generic/KiWiHandler.java
----------------------------------------------------------------------
diff --git a/libraries/kiwi/kiwi-loader/src/main/java/org/apache/marmotta/kiwi/loader/generic/KiWiHandler.java b/libraries/kiwi/kiwi-loader/src/main/java/org/apache/marmotta/kiwi/loader/generic/KiWiHandler.java
index 244d660..b9ee1f1 100644
--- a/libraries/kiwi/kiwi-loader/src/main/java/org/apache/marmotta/kiwi/loader/generic/KiWiHandler.java
+++ b/libraries/kiwi/kiwi-loader/src/main/java/org/apache/marmotta/kiwi/loader/generic/KiWiHandler.java
@@ -3,9 +3,6 @@ package org.apache.marmotta.kiwi.loader.generic;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
-import net.sf.ehcache.Element;
-import net.sf.ehcache.constructs.blocking.CacheEntryFactory;
-import net.sf.ehcache.constructs.blocking.SelfPopulatingCache;
import org.apache.marmotta.commons.sesame.model.Namespaces;
import org.apache.marmotta.commons.sesame.tripletable.IntArray;
import org.apache.marmotta.commons.util.DateUtils;
@@ -53,9 +50,6 @@ public class KiWiHandler implements RDFHandler {
protected KiWiLoaderConfiguration config;
- protected SelfPopulatingCache literalCache;
- protected SelfPopulatingCache uriCache;
- protected SelfPopulatingCache bnodeCache;
protected LoadingCache<String,Locale> localeCache;
// if non-null, all imported statements will have this context (regardless whether they specified a different context)
@@ -75,27 +69,6 @@ public class KiWiHandler implements RDFHandler {
this.config = config;
this.store = store;
- this.literalCache = new SelfPopulatingCache(store.getPersistence().getCacheManager().getLoaderCache(), new CacheEntryFactory() {
- @Override
- public Object createEntry(Object key) throws Exception {
- return createLiteral((Literal)key);
- }
- });
-
- this.uriCache = new SelfPopulatingCache(store.getPersistence().getCacheManager().getLoaderCache(), new CacheEntryFactory() {
- @Override
- public Object createEntry(Object key) throws Exception {
- return createURI(((URI)key).stringValue());
- }
- });
-
- this.bnodeCache = new SelfPopulatingCache(store.getPersistence().getCacheManager().getLoaderCache(), new CacheEntryFactory() {
- @Override
- public Object createEntry(Object key) throws Exception {
- return createBNode(((BNode)key).stringValue());
- }
- });
-
this.localeCache = CacheBuilder.newBuilder()
.maximumSize(100)
.build(new CacheLoader<String, Locale>() {
@@ -295,27 +268,14 @@ public class KiWiHandler implements RDFHandler {
} else if(value instanceof KiWiNode) {
return (KiWiNode)value;
} else if(value instanceof URI) {
- Element e = uriCache.get((URI) value);
- if(e != null) {
- return (KiWiNode) e.getObjectValue();
- }
+ return createURI(((URI)value).stringValue());
} else if(value instanceof BNode) {
- Element e = bnodeCache.get(((BNode)value));
- if(e != null) {
- return (KiWiNode) e.getObjectValue();
- }
+ return createBNode(((BNode)value).stringValue());
} else if(value instanceof Literal) {
- Literal l = (Literal)value;
- Element e = literalCache.get(l);
- if(e != null) {
- return (KiWiNode) e.getObjectValue();
- }
-
+ return createLiteral((Literal)value);
} else {
throw new IllegalArgumentException("the value passed as argument does not have the correct type");
}
- throw new IllegalStateException("could not construct or load node");
-
}
protected KiWiLiteral createLiteral(Literal l) throws ExecutionException {
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0d79835c/libraries/kiwi/kiwi-triplestore/src/main/java/org/apache/marmotta/kiwi/caching/KiWiCacheManager.java
----------------------------------------------------------------------
diff --git a/libraries/kiwi/kiwi-triplestore/src/main/java/org/apache/marmotta/kiwi/caching/KiWiCacheManager.java b/libraries/kiwi/kiwi-triplestore/src/main/java/org/apache/marmotta/kiwi/caching/KiWiCacheManager.java
index 1c444a4..7be150c 100644
--- a/libraries/kiwi/kiwi-triplestore/src/main/java/org/apache/marmotta/kiwi/caching/KiWiCacheManager.java
+++ b/libraries/kiwi/kiwi-triplestore/src/main/java/org/apache/marmotta/kiwi/caching/KiWiCacheManager.java
@@ -49,6 +49,8 @@ public class KiWiCacheManager {
public static final String NAMESPACE_URI_CACHE = "namespace-uri-cache";
public static final String NAMESPACE_PREFIX_CACHE = "namespace-prefix-cache";
public static final String LOADER_CACHE = "loader-cache";
+ public static final String REGISTRY_CACHE = "registry-cache";
+
private EmbeddedCacheManager cacheManager;
private GlobalConfiguration globalConfiguration;
@@ -56,33 +58,58 @@ public class KiWiCacheManager {
// default configuration: distributed cache, 100000 entries, 300 seconds expiration, 60 seconds idle
private Configuration defaultConfiguration;
+ private boolean clustered;
+
public KiWiCacheManager(KiWiConfiguration config) {
- globalConfiguration = new GlobalConfigurationBuilder()
- .transport()
- .defaultTransport()
- .clusterName(config.getName())
- .machineId("instance-" + config.getDatacenterId())
- .addProperty("configurationFile", "jgroups-udp.xml")
- .build();
-
-
- defaultConfiguration = new ConfigurationBuilder()
- .clustering()
- .cacheMode(CacheMode.DIST_SYNC)
- .sync()
- .l1()
- .lifespan(25, TimeUnit.SECONDS)
- .hash()
- .numOwners(2)
- .numSegments(100)
- .consistentHashFactory(new SyncConsistentHashFactory())
- .eviction()
- .strategy(EvictionStrategy.LIRS)
- .maxEntries(100000)
- .expiration()
- .lifespan(5, TimeUnit.MINUTES)
- .maxIdle(1, TimeUnit.MINUTES)
- .build();
+
+ this.clustered = config.isClustered();
+
+ if(clustered) {
+ globalConfiguration = new GlobalConfigurationBuilder()
+ .transport()
+ .defaultTransport()
+ .clusterName(config.getName())
+ .machineId("instance-" + config.getDatacenterId())
+ .addProperty("configurationFile", "jgroups-udp.xml")
+ .globalJmxStatistics()
+ .build();
+
+
+ defaultConfiguration = new ConfigurationBuilder()
+ .clustering()
+ .cacheMode(CacheMode.DIST_ASYNC)
+ .async()
+ .l1()
+ .lifespan(25, TimeUnit.SECONDS)
+ .hash()
+ .numOwners(2)
+ .numSegments(100)
+ .consistentHashFactory(new SyncConsistentHashFactory())
+ .eviction()
+ .strategy(EvictionStrategy.LIRS)
+ .maxEntries(100000)
+ .expiration()
+ .lifespan(5, TimeUnit.MINUTES)
+ .maxIdle(1, TimeUnit.MINUTES)
+ .build();
+ } else {
+ globalConfiguration = new GlobalConfigurationBuilder()
+ .globalJmxStatistics()
+ .build();
+
+ defaultConfiguration = new ConfigurationBuilder()
+ .clustering()
+ .cacheMode(CacheMode.LOCAL)
+ .eviction()
+ .strategy(EvictionStrategy.LIRS)
+ .maxEntries(100000)
+ .expiration()
+ .lifespan(5, TimeUnit.MINUTES)
+ .maxIdle(1, TimeUnit.MINUTES)
+ .build();
+
+ }
+
cacheManager = new DefaultCacheManager(globalConfiguration, defaultConfiguration, true);
}
@@ -233,6 +260,37 @@ public class KiWiCacheManager {
/**
+ * Create and return the cache used by the CacheTripleRegistry. This is an unlimited synchronous replicated
+ * cache and should be used with care.
+ * @return
+ */
+ public Cache getRegistryCache() {
+ if(!cacheManager.cacheExists(LOADER_CACHE)) {
+ if(clustered) {
+ Configuration registryConfiguration = new ConfigurationBuilder()
+ .clustering()
+ .cacheMode(CacheMode.REPL_SYNC)
+ .sync()
+ .l1()
+ .lifespan(25, TimeUnit.SECONDS)
+ .eviction()
+ .strategy(EvictionStrategy.NONE)
+ .build();
+ cacheManager.defineConfiguration(REGISTRY_CACHE, registryConfiguration);
+ } else {
+ Configuration registryConfiguration = new ConfigurationBuilder()
+ .clustering()
+ .cacheMode(CacheMode.LOCAL)
+ .eviction()
+ .strategy(EvictionStrategy.NONE)
+ .build();
+ cacheManager.defineConfiguration(REGISTRY_CACHE, registryConfiguration);
+ }
+ }
+ return cacheManager.getCache(REGISTRY_CACHE);
+ }
+
+ /**
* Get the cache with the given name from the cache manager. Can be used to request additional
* caches from the cache manager that are not covered by explicit methods.
*
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0d79835c/libraries/kiwi/kiwi-triplestore/src/main/java/org/apache/marmotta/kiwi/config/KiWiConfiguration.java
----------------------------------------------------------------------
diff --git a/libraries/kiwi/kiwi-triplestore/src/main/java/org/apache/marmotta/kiwi/config/KiWiConfiguration.java b/libraries/kiwi/kiwi-triplestore/src/main/java/org/apache/marmotta/kiwi/config/KiWiConfiguration.java
index 65019ba..0a06aa0 100644
--- a/libraries/kiwi/kiwi-triplestore/src/main/java/org/apache/marmotta/kiwi/config/KiWiConfiguration.java
+++ b/libraries/kiwi/kiwi-triplestore/src/main/java/org/apache/marmotta/kiwi/config/KiWiConfiguration.java
@@ -100,6 +100,14 @@ public class KiWiConfiguration {
private int datacenterId = 0;
+ private RegistryStrategy registryStrategy = RegistryStrategy.CACHE;
+
+ /**
+ * Enable to turn on cluster mode (e.g. for cache replication)
+ */
+ private boolean clustered = false;
+
+
public KiWiConfiguration(String name, String jdbcUrl, String dbUser, String dbPassword, KiWiDialect dialect) {
this(name, jdbcUrl, dbUser, dbPassword, dialect, null, null);
}
@@ -321,4 +329,37 @@ public class KiWiConfiguration {
public void setDatacenterId(int datacenterId) {
this.datacenterId = datacenterId;
}
+
+
+ /**
+ * Return the strategy to use for synchronizing between transactions. Currently either "database" or "cache".
+ * @return
+ */
+ public RegistryStrategy getRegistryStrategy() {
+ return registryStrategy;
+ }
+
+ /**
+ * Change the strategy to use for synchronizing between transactions. Currently either "database" or "cache".
+ * @return
+ */
+ public void setRegistryStrategy(RegistryStrategy registryStrategy) {
+ this.registryStrategy = registryStrategy;
+ }
+
+ /**
+ * If true, support for special cluster features is enabled (e.g. replicated caches).
+ *
+ * @return
+ */
+ public boolean isClustered() {
+ return clustered;
+ }
+
+ /**
+ * If true, support for special cluster features is enabled (e.g. replicated caches).
+ */
+ public void setClustered(boolean clustered) {
+ this.clustered = clustered;
+ }
}
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0d79835c/libraries/kiwi/kiwi-triplestore/src/main/java/org/apache/marmotta/kiwi/config/RegistryStrategy.java
----------------------------------------------------------------------
diff --git a/libraries/kiwi/kiwi-triplestore/src/main/java/org/apache/marmotta/kiwi/config/RegistryStrategy.java b/libraries/kiwi/kiwi-triplestore/src/main/java/org/apache/marmotta/kiwi/config/RegistryStrategy.java
new file mode 100644
index 0000000..841d1cf
--- /dev/null
+++ b/libraries/kiwi/kiwi-triplestore/src/main/java/org/apache/marmotta/kiwi/config/RegistryStrategy.java
@@ -0,0 +1,39 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.marmotta.kiwi.config;
+
+/**
+ * The strategy to use for transactional triple registry. This is needed to avoid two parallel transactions creating
+ * the same triple with different IDs.
+ *
+ * @author Sebastian Schaffert (sschaffert@apache.org)
+ */
+public enum RegistryStrategy {
+
+ /**
+ * Use the database to synchronize between several parallel instances. Slow but requires less memory.
+ */
+ DATABASE,
+
+ /**
+ * Use a synchronized replicated infinispan cache to synchronize between parallel instances. Faster but requires
+ * more memory.
+ */
+ CACHE
+
+}
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0d79835c/libraries/kiwi/kiwi-triplestore/src/main/java/org/apache/marmotta/kiwi/persistence/registry/CacheTripleRegistry.java
----------------------------------------------------------------------
diff --git a/libraries/kiwi/kiwi-triplestore/src/main/java/org/apache/marmotta/kiwi/persistence/registry/CacheTripleRegistry.java b/libraries/kiwi/kiwi-triplestore/src/main/java/org/apache/marmotta/kiwi/persistence/registry/CacheTripleRegistry.java
index cb1896c..e35744e 100644
--- a/libraries/kiwi/kiwi-triplestore/src/main/java/org/apache/marmotta/kiwi/persistence/registry/CacheTripleRegistry.java
+++ b/libraries/kiwi/kiwi-triplestore/src/main/java/org/apache/marmotta/kiwi/persistence/registry/CacheTripleRegistry.java
@@ -18,19 +18,37 @@
package org.apache.marmotta.kiwi.persistence.registry;
import org.apache.marmotta.commons.sesame.tripletable.IntArray;
-import org.infinispan.AdvancedCache;
+import org.apache.marmotta.kiwi.caching.KiWiCacheManager;
+import org.infinispan.Cache;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
import java.util.Map;
/**
- * A triple registry implementation based on the Infinispan cache.
+ * A triple registry implementation based on the Infinispan cache. Registry entries are stored in a replicated,
+ * synchronized Infinispan cache. Transaction information is kept locally.
*
* @author Sebastian Schaffert (sschaffert@apache.org)
*/
public class CacheTripleRegistry implements KiWiTripleRegistry {
+ private static Logger log = LoggerFactory.getLogger(CacheTripleRegistry.class);
- AdvancedCache<IntArray,Map<Long,Long>> cache;
+ private Cache<Long,Long> cache;
+
+
+ private Map<Long,List<Long>> transactions;
+
+
+ public CacheTripleRegistry(KiWiCacheManager cacheManager) {
+ cache = cacheManager.getRegistryCache();
+ transactions = new HashMap<>();
+
+ }
/**
@@ -42,7 +60,17 @@ public class CacheTripleRegistry implements KiWiTripleRegistry {
*/
@Override
public void registerKey(IntArray key, long transactionId, long tripleId) {
+ List<Long> transaction = transactions.get(transactionId);
+ if(transaction == null) {
+ transaction = new ArrayList<>();
+ transactions.put(transactionId, transaction);
+ }
+ Long old = cache.put(key.longHashCode(),tripleId);
+ transaction.add(key.longHashCode());
+ if(old != null && old != tripleId) {
+ log.warn("registered a new triple ID for an already existing triple");
+ }
}
/**
@@ -54,7 +82,12 @@ public class CacheTripleRegistry implements KiWiTripleRegistry {
*/
@Override
public long lookupKey(IntArray key) {
- return 0;
+ Long value = cache.get(key.longHashCode());
+ if(value != null) {
+ return value;
+ } else {
+ return -1;
+ }
}
/**
@@ -65,7 +98,11 @@ public class CacheTripleRegistry implements KiWiTripleRegistry {
*/
@Override
public void releaseTransaction(long transactionId) {
-
+ if(transactions.containsKey(transactionId)) {
+ for(long key : transactions.remove(transactionId)) {
+ cache.removeAsync(key);
+ }
+ }
}
/**
@@ -75,6 +112,6 @@ public class CacheTripleRegistry implements KiWiTripleRegistry {
*/
@Override
public void deleteKey(IntArray key) {
-
+ cache.remove(key.longHashCode());
}
}
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0d79835c/libraries/kiwi/kiwi-triplestore/src/main/java/org/apache/marmotta/kiwi/sail/KiWiValueFactory.java
----------------------------------------------------------------------
diff --git a/libraries/kiwi/kiwi-triplestore/src/main/java/org/apache/marmotta/kiwi/sail/KiWiValueFactory.java b/libraries/kiwi/kiwi-triplestore/src/main/java/org/apache/marmotta/kiwi/sail/KiWiValueFactory.java
index 444af01..f248dfb 100644
--- a/libraries/kiwi/kiwi-triplestore/src/main/java/org/apache/marmotta/kiwi/sail/KiWiValueFactory.java
+++ b/libraries/kiwi/kiwi-triplestore/src/main/java/org/apache/marmotta/kiwi/sail/KiWiValueFactory.java
@@ -23,7 +23,9 @@ import org.apache.marmotta.commons.sesame.tripletable.IntArray;
import org.apache.marmotta.commons.util.DateUtils;
import org.apache.marmotta.kiwi.model.rdf.*;
import org.apache.marmotta.kiwi.persistence.KiWiConnection;
+import org.apache.marmotta.kiwi.persistence.registry.CacheTripleRegistry;
import org.apache.marmotta.kiwi.persistence.registry.DBTripleRegistry;
+import org.apache.marmotta.kiwi.persistence.registry.KiWiTripleRegistry;
import org.openrdf.model.*;
import org.openrdf.model.impl.ContextStatementImpl;
import org.slf4j.Logger;
@@ -50,13 +52,23 @@ public class KiWiValueFactory implements ValueFactory {
private KiWiStore store;
- private DBTripleRegistry registry;
+ private KiWiTripleRegistry registry;
private String defaultContext;
public KiWiValueFactory(KiWiStore store, String defaultContext) {
anonIdGenerator = new Random();
- registry = new DBTripleRegistry(store);
+
+ switch (store.getPersistence().getConfiguration().getRegistryStrategy()) {
+ case DATABASE:
+ registry = new DBTripleRegistry(store);
+ break;
+ case CACHE:
+ registry = new CacheTripleRegistry(store.getPersistence().getCacheManager());
+ break;
+ default:
+ registry = new CacheTripleRegistry(store.getPersistence().getCacheManager());
+ }
this.store = store;
this.defaultContext = defaultContext;
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0d79835c/libraries/kiwi/kiwi-triplestore/src/main/resources/ehcache-kiwi.xml
----------------------------------------------------------------------
diff --git a/libraries/kiwi/kiwi-triplestore/src/main/resources/ehcache-kiwi.xml b/libraries/kiwi/kiwi-triplestore/src/main/resources/ehcache-kiwi.xml
deleted file mode 100644
index ccbd3fe..0000000
--- a/libraries/kiwi/kiwi-triplestore/src/main/resources/ehcache-kiwi.xml
+++ /dev/null
@@ -1,770 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-
- Licensed to the Apache Software Foundation (ASF) under one
- or more contributor license agreements. See the NOTICE file
- distributed with this work for additional information
- regarding copyright ownership. The ASF licenses this file
- to you under the Apache License, Version 2.0 (the
- "License"); you may not use this file except in compliance
- with the License. You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- See the License for the specific language governing permissions and
- limitations under the License.
-
--->
-<!--
-CacheManager Configuration
-==========================
-An ehcache.xml corresponds to a single CacheManager.
-
-See instructions below or the ehcache schema (ehcache.xsd) on how to configure.
-
-System property tokens can be specified in this file which are replaced when the configuration
-is loaded. For example multicastGroupPort=${multicastGroupPort} can be replaced with the
-System property either from an environment variable or a system property specified with a
-command line switch such as -DmulticastGroupPort=4446. Another example, useful for Terracotta
-server based deployments is <terracottaConfig url="${serverAndPort}"/ and specify a command line
-switch of -Dserver36:9510
-
-The attributes of <ehcache> are:
-* name - an optional name for the CacheManager. The name is optional and primarily used
-for documentation or to distinguish Terracotta clustered cache state. With Terracotta
-clustered caches, a combination of CacheManager name and cache name uniquely identify a
-particular cache store in the Terracotta clustered memory.
-* updateCheck - an optional boolean flag specifying whether this CacheManager should check
-for new versions of Ehcache over the Internet. If not specified, updateCheck="true".
-* dynamicConfig - an optional setting that can be used to disable dynamic configuration of caches
-associated with this CacheManager. By default this is set to true - i.e. dynamic configuration
-is enabled. Dynamically configurable caches can have their TTI, TTL and maximum disk and
-in-memory capacity changed at runtime through the cache's configuration object.
-* monitoring - an optional setting that determines whether the CacheManager should
-automatically register the SampledCacheMBean with the system MBean server.
-
-Currently, this monitoring is only useful when using Terracotta clustering and using the
-Terracotta Developer Console. With the "autodetect" value, the presence of Terracotta clustering
-will be detected and monitoring, via the Developer Console, will be enabled. Other allowed values
-are "on" and "off". The default is "autodetect". This setting does not perform any function when
-used with JMX monitors.
-
-* maxBytesLocalHeap - optional setting that constraints the memory usage of the Caches managed by the CacheManager
-to use at most the specified number of bytes of the local VM's heap.
-* maxBytesLocalOffHeap - optional setting that constraints the offHeap usage of the Caches managed by the CacheManager
-to use at most the specified number of bytes of the local VM's offHeap memory.
-* maxBytesLocalDisk - optional setting that constraints the disk usage of the Caches managed by the CacheManager
-to use at most the specified number of bytes of the local disk.
-
-These settings let you define "resource pools", caches will share. For instance setting maxBytesLocalHeap to 100M, will result in
-all caches sharing 100 MegaBytes of ram. The CacheManager will balance these 100 MB across all caches based on their respective usage
-patterns. You can allocate a precise amount of bytes to a particular cache by setting the appropriate maxBytes* attribute for that cache.
-That amount will be subtracted from the CacheManager pools, so that if a cache a specified 30M requirement, the other caches will share
-the remaining 70M.
-
-Also, specifying a maxBytesLocalOffHeap at the CacheManager level will result in overflowToOffHeap to be true by default. If you don't want
-a specific cache to overflow to off heap, you'll have to set overflowToOffHeap="false" explicitly
-
-Here is an example of CacheManager level resource tuning, which will use up to 400M of heap and 2G of offHeap:
-
-<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
- xsi:noNamespaceSchemaLocation="ehcache.xsd"
- updateCheck="true" monitoring="autodetect"
- dynamicConfig="true" maxBytesLocalHeap="400M" maxBytesLocalOffHeap="2G">
-
--->
-<ehcache name="kiwi"
- xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
- updateCheck="false"
- maxBytesLocalHeap="60%"
- dynamicConfig="false"
- xsi:noNamespaceSchemaLocation="http://ehcache.sf.net/ehcache.xsd">
-
- <!--
- DiskStore configuration
- =======================
-
- The diskStore element is optional. To turn off disk store path creation, comment out the diskStore
- element below.
-
- Configure it if you have overflowToDisk or diskPersistent enabled for any cache.
-
- If it is not configured, and a cache is created which requires a disk store, a warning will be
- issued and java.io.tmpdir will automatically be used.
-
- diskStore has only one attribute - "path". It is the path to the directory where
- .data and .index files will be created.
-
- If the path is one of the following Java System Property it is replaced by its value in the
- running VM. For backward compatibility these are not specified without being enclosed in the ${token}
- replacement syntax.
-
- The following properties are translated:
- * user.home - KiWiUser's home directory
- * user.dir - KiWiUser's current working directory
- * java.io.tmpdir - Default temp file path
- * ehcache.disk.store.dir - A system property you would normally specify on the command line
- e.g. java -Dehcache.disk.store.dir=/u01/myapp/diskdir ...
-
- Subdirectories can be specified below the property e.g. java.io.tmpdir/one
-
- -->
- <diskStore path="java.io.tmpdir/kiwi-cache"/>
-
-
- <!--
- Cache configuration
- ===================
-
- The following attributes are required.
-
- name:
- Sets the name of the cache. This is used to identify the cache. It must be unique.
-
- maxEntriesLocalHeap:
- Sets the maximum number of objects that will be held on heap memory. 0 = no limit.
-
- maxEntriesLocalDisk:
- Sets the maximum number of objects that will be maintained in the DiskStore
- The default value is zero, meaning unlimited.
-
- eternal:
- Sets whether elements are eternal. If eternal, timeouts are ignored and the
- element is never expired.
-
- The following attributes and elements are optional.
-
- maxEntriesInCache:
- This feature is applicable only to Terracotta distributed caches.
- Sets the maximum number of entries that can be stored in the cluster. 0 = no limit.
- Note that clustered cache will still perform eviction if resource usage requires it.
- This property can be modified dynamically while the cache is operating.
-
- overflowToOffHeap:
- (boolean) This feature is available only in enterprise versions of Ehcache.
- When set to true, enables the cache to utilize off-heap memory
- storage to improve performance. Off-heap memory is not subject to Java
- GC. The default value is false.
-
- maxBytesLocalHeap:
- Defines how many bytes the cache may use from the VM's heap. If a CacheManager
- maxBytesLocalHeap has been defined, this Cache's specified amount will be
- subtracted from the CacheManager. Other caches will share the remainder.
- This attribute's values are given as <number>k|K|m|M|g|G for
- kilobytes (k|K), megabytes (m|M), or gigabytes (g|G).
- For example, maxBytesLocalHeap="2g" allots 2 gigabytes of heap memory.
- If you specify a maxBytesLocalHeap, you can't use the maxEntriesLocalHeap attribute.
- maxEntriesLocalHeap can't be used if a CacheManager maxBytesLocalHeap is set.
-
- Elements put into the cache will be measured in size using net.sf.ehcache.pool.sizeof.SizeOf
- If you wish to ignore some part of the object graph, see net.sf.ehcache.pool.sizeof.annotations.IgnoreSizeOf
-
- maxBytesLocalOffHeap:
- This feature is available only in enterprise versions of Ehcache.
- Sets the amount of off-heap memory this cache can use, and will reserve.
-
- This setting will set overflowToOffHeap to true. Set explicitly to false to disable overflow behavior.
-
- Note that it is recommended to set maxEntriesLocalHeap to at least 100 elements
- when using an off-heap store, otherwise performance will be seriously degraded,
- and a warning will be logged.
-
- The minimum amount that can be allocated is 128MB. There is no maximum.
-
- maxBytesLocalDisk:
- As for maxBytesLocalHeap, but specifies the limit of disk storage this cache will ever use.
-
- timeToIdleSeconds:
- Sets the time to idle for an element before it expires.
- i.e. The maximum amount of time between accesses before an element expires
- Is only used if the element is not eternal.
- Optional attribute. A value of 0 means that an Element can idle for infinity.
- The default value is 0.
-
- timeToLiveSeconds:
- Sets the time to live for an element before it expires.
- i.e. The maximum time between creation time and when an element expires.
- Is only used if the element is not eternal.
- Optional attribute. A value of 0 means that and Element can live for infinity.
- The default value is 0.
-
- diskExpiryThreadIntervalSeconds:
- The number of seconds between runs of the disk expiry thread. The default value
- is 120 seconds.
-
- diskSpoolBufferSizeMB:
- This is the size to allocate the DiskStore for a spool buffer. Writes are made
- to this area and then asynchronously written to disk. The default size is 30MB.
- Each spool buffer is used only by its cache. If you get OutOfMemory errors consider
- lowering this value. To improve DiskStore performance consider increasing it. Trace level
- logging in the DiskStore will show if put back ups are occurring.
-
- clearOnFlush:
- whether the MemoryStore should be cleared when flush() is called on the cache.
- By default, this is true i.e. the MemoryStore is cleared.
-
- memoryStoreEvictionPolicy:
- Policy would be enforced upon reaching the maxEntriesLocalHeap limit. Default
- policy is Least Recently Used (specified as LRU). Other policies available -
- First In First Out (specified as FIFO) and Less Frequently Used
- (specified as LFU)
-
- copyOnRead:
- Whether an Element is copied when being read from a cache.
- By default this is false.
-
- copyOnWrite:
- Whether an Element is copied when being added to the cache.
- By default this is false.
-
- Cache persistence is configured through the persistence sub-element. The attributes of the
- persistence element are:
-
- strategy:
- Configures the type of persistence provided by the configured cache. This must be one of the
- following values:
-
- * localRestartable - Enables the RestartStore and copies all cache entries (on-heap and/or off-heap)
- to disk. This option provides fast restartability with fault tolerant cache persistence on disk.
- It is available for Enterprise Ehcache users only.
-
- * localTempSwap - Swaps cache entries (on-heap and/or off-heap) to disk when the cache is full.
- "localTempSwap" is not persistent.
-
- * none - Does not persist cache entries.
-
- * distributed - Defers to the <terracotta> configuration for persistence settings. This option
- is not applicable for standalone.
-
- synchronousWrites:
- When set to true write operations on the cache do not return until after the operations data has been
- successfully flushed to the disk storage. This option is only valid when used with the "localRestartable"
- strategy, and defaults to false.
-
- The following example configuration shows a cache configured for localTempSwap restartability.
-
- <cache name="persistentCache" maxEntriesLocalHeap="1000">
- <persistence strategy="localTempSwap"/>
- </cache>
-
- Cache elements can also contain sub elements which take the same format of a factory class
- and properties. Defined sub-elements are:
-
- * cacheEventListenerFactory - Enables registration of listeners for cache events, such as
- put, remove, update, and expire.
-
- * bootstrapCacheLoaderFactory - Specifies a BootstrapCacheLoader, which is called by a
- cache on initialisation to prepopulate itself.
-
- * cacheExtensionFactory - Specifies a CacheExtension, a generic mechanism to tie a class
- which holds a reference to a cache to the cache lifecycle.
-
- * cacheExceptionHandlerFactory - Specifies a CacheExceptionHandler, which is called when
- cache exceptions occur.
-
- * cacheLoaderFactory - Specifies a CacheLoader, which can be used both asynchronously and
- synchronously to load objects into a cache. More than one cacheLoaderFactory element
- can be added, in which case the loaders form a chain which are executed in order. If a
- loader returns null, the next in chain is called.
-
- * copyStrategy - Specifies a fully qualified class which implements
- net.sf.ehcache.store.compound.CopyStrategy. This strategy will be used for copyOnRead
- and copyOnWrite in place of the default which is serialization.
-
- Example of cache level resource tuning:
- <cache name="memBound" maxBytesLocalHeap="100m" maxBytesLocalOffHeap="4g" maxBytesLocalDisk="200g" />
-
-
- Cache Event Listeners
- +++++++++++++++++++++
-
- All cacheEventListenerFactory elements can take an optional property listenFor that describes
- which events will be delivered in a clustered environment. The listenFor attribute has the
- following allowed values:
-
- * all - the default is to deliver all local and remote events
- * local - deliver only events originating in the current node
- * remote - deliver only events originating in other nodes
-
- Example of setting up a logging listener for local cache events:
-
- <cacheEventListenerFactory class="my.company.log.CacheLogger"
- listenFor="local" />
-
-
- Search
- ++++++
-
- A <cache> can be made searchable by adding a <searchable/> sub-element. By default the keys
- and value objects of elements put into the cache will be attributes against which
- queries can be expressed.
-
- <cache>
- <searchable/>
- </cache>
-
-
- An "attribute" of the cache elements can also be defined to be searchable. In the example below
- an attribute with the name "age" will be available for use in queries. The value for the "age"
- attribute will be computed by calling the method "getAge()" on the value object of each element
- in the cache. See net.sf.ehcache.search.attribute.ReflectionAttributeExtractor for the format of
- attribute expressions. Attribute values must also conform to the set of types documented in the
- net.sf.ehcache.search.attribute.AttributeExtractor interface
-
- <cache>
- <searchable>
- <searchAttribute name="age" expression="value.getAge()"/>
- </searchable>
- </cache>
-
-
- Attributes may also be defined using a JavaBean style. With the following attribute declaration
- a public method getAge() will be expected to be found on either the key or value for cache elements
-
- <cache>
- <searchable>
- <searchAttribute name="age"/>
- </searchable>
- </cache>
-
- In more complex situations you can create your own attribute extractor by implementing the
- AttributeExtractor interface. Providing your extractor class is shown in the following example:
-
- <cache>
- <searchable>
- <searchAttribute name="age" class="com.example.MyAttributeExtractor"/>
- </searchable>
- </cache>
-
- Use properties to pass state to your attribute extractor if needed. Your implementation must provide
- a public constructor that takes a single java.util.Properties instance
-
- <cache>
- <searchable>
- <searchAttribute name="age" class="com.example.MyAttributeExtractor" properties="foo=1,bar=2"/>
- </searchable>
- </cache>
-
-
- RMI Cache Replication
- +++++++++++++++++++++
-
- Each cache that will be distributed needs to set a cache event listener which replicates
- messages to the other CacheManager peers. For the built-in RMI implementation this is done
- by adding a cacheEventListenerFactory element of type RMICacheReplicatorFactory to each
- distributed cache's configuration as per the following example:
-
- <cacheEventListenerFactory class="net.sf.ehcache.distribution.RMICacheReplicatorFactory"
- properties="replicateAsynchronously=true,
- replicatePuts=true,
- replicatePutsViaCopy=false,
- replicateUpdates=true,
- replicateUpdatesViaCopy=true,
- replicateRemovals=true,
- asynchronousReplicationIntervalMillis=<number of milliseconds>,
- asynchronousReplicationMaximumBatchSize=<number of operations>"
- propertySeparator="," />
-
- The RMICacheReplicatorFactory recognises the following properties:
-
- * replicatePuts=true|false - whether new elements placed in a cache are
- replicated to others. Defaults to true.
-
- * replicatePutsViaCopy=true|false - whether the new elements are
- copied to other caches (true), or whether a remove message is sent. Defaults to true.
-
- * replicateUpdates=true|false - whether new elements which override an
- element already existing with the same key are replicated. Defaults to true.
-
- * replicateRemovals=true - whether element removals are replicated. Defaults to true.
-
- * replicateAsynchronously=true | false - whether replications are
- asynchronous (true) or synchronous (false). Defaults to true.
-
- * replicateUpdatesViaCopy=true | false - whether the new elements are
- copied to other caches (true), or whether a remove message is sent. Defaults to true.
-
- * asynchronousReplicationIntervalMillis=<number of milliseconds> - The asynchronous
- replicator runs at a set interval of milliseconds. The default is 1000. The minimum
- is 10. This property is only applicable if replicateAsynchronously=true
-
- * asynchronousReplicationMaximumBatchSize=<number of operations> - The maximum
- number of operations that will be batch within a single RMI message. The default
- is 1000. This property is only applicable if replicateAsynchronously=true
-
- JGroups Replication
- +++++++++++++++++++
-
- For the Jgroups replication this is done with:
- <cacheEventListenerFactory class="net.sf.ehcache.distribution.jgroups.JGroupsCacheReplicatorFactory"
- properties="replicateAsynchronously=true, replicatePuts=true,
- replicateUpdates=true, replicateUpdatesViaCopy=false,
- replicateRemovals=true,asynchronousReplicationIntervalMillis=1000"/>
- This listener supports the same properties as the RMICacheReplicationFactory.
-
-
- JMS Replication
- +++++++++++++++
-
- For JMS-based replication this is done with:
- <cacheEventListenerFactory
- class="net.sf.ehcache.distribution.jms.JMSCacheReplicatorFactory"
- properties="replicateAsynchronously=true,
- replicatePuts=true,
- replicateUpdates=true,
- replicateUpdatesViaCopy=true,
- replicateRemovals=true,
- asynchronousReplicationIntervalMillis=1000"
- propertySeparator=","/>
-
- This listener supports the same properties as the RMICacheReplicationFactory.
-
- Cluster Bootstrapping
- +++++++++++++++++++++
-
- Bootstrapping a cluster may use a different mechanism to replication. e.g you can mix
- JMS replication with bootstrap via RMI - just make sure you have the cacheManagerPeerProviderFactory
- and cacheManagerPeerListenerFactory configured.
-
- There are two bootstrapping mechanisms: RMI and JGroups.
-
- RMI Bootstrap
-
- The RMIBootstrapCacheLoader bootstraps caches in clusters where RMICacheReplicators are
- used. It is configured as per the following example:
-
- <bootstrapCacheLoaderFactory
- class="net.sf.ehcache.distribution.RMIBootstrapCacheLoaderFactory"
- properties="bootstrapAsynchronously=true, maximumChunkSizeBytes=5000000"
- propertySeparator="," />
-
- The RMIBootstrapCacheLoaderFactory recognises the following optional properties:
-
- * bootstrapAsynchronously=true|false - whether the bootstrap happens in the background
- after the cache has started. If false, bootstrapping must complete before the cache is
- made available. The default value is true.
-
- * maximumChunkSizeBytes=<integer> - Caches can potentially be very large, larger than the
- memory limits of the VM. This property allows the bootstraper to fetched elements in
- chunks. The default chunk size is 5000000 (5MB).
-
- JGroups Bootstrap
-
- Here is an example of bootstrap configuration using JGroups boostrap:
-
- <bootstrapCacheLoaderFactory class="net.sf.ehcache.distribution.jgroups.JGroupsBootstrapCacheLoaderFactory"
- properties="bootstrapAsynchronously=true"/>
-
- The configuration properties are the same as for RMI above. Note that JGroups bootstrap only supports
- asynchronous bootstrap mode.
-
-
- Cache Exception Handling
- ++++++++++++++++++++++++
-
- By default, most cache operations will propagate a runtime CacheException on failure. An
- interceptor, using a dynamic proxy, may be configured so that a CacheExceptionHandler can
- be configured to intercept Exceptions. Errors are not intercepted.
-
- It is configured as per the following example:
-
- <cacheExceptionHandlerFactory class="com.example.ExampleExceptionHandlerFactory"
- properties="logLevel=FINE"/>
-
- Caches with ExceptionHandling configured are not of type Cache, but are of type Ehcache only,
- and are not available using CacheManager.getCache(), but using CacheManager.getEhcache().
-
-
- Cache Loader
- ++++++++++++
-
- A default CacheLoader may be set which loads objects into the cache through asynchronous and
- synchronous methods on Cache. This is different to the bootstrap cache loader, which is used
- only in distributed caching.
-
- It is configured as per the following example:
-
- <cacheLoaderFactory class="com.example.ExampleCacheLoaderFactory"
- properties="type=int,startCounter=10"/>
-
- Element value comparator
- ++++++++++++++++++++++++
-
- These two cache atomic methods:
- removeElement(Element e)
- replace(Element old, Element element)
-
- rely on comparison of cached elements value. The default implementation relies on Object.equals()
- but that can be changed in case you want to use a different way to compute equality of two elements.
-
- This is configured as per the following example:
-
- <elementValueComparator class="com.company.xyz.MyElementComparator"/>
-
- The MyElementComparator class must implement the is net.sf.ehcache.store.ElementValueComparator
- interface. The default implementation is net.sf.ehcache.store.DefaultElementValueComparator.
-
-
- SizeOf Policy
- +++++++++++++
-
- Control how deep the SizeOf engine can go when sizing on-heap elements.
-
- This is configured as per the following example:
-
- <sizeOfPolicy maxDepth="100" maxDepthExceededBehavior="abort"/>
-
- maxDepth controls how many linked objects can be visited before the SizeOf engine takes any action.
- maxDepthExceededBehavior specifies what happens when the max depth is exceeded while sizing an object graph.
- "continue" makes the SizeOf engine log a warning and continue the sizing. This is the default.
- "abort" makes the SizeOf engine abort the sizing, log a warning and mark the cache as not correctly tracking
- memory usage. This makes Ehcache.hasAbortedSizeOf() return true when this happens.
-
- The SizeOf policy can be configured at the cache manager level (directly under <ehcache>) and at
- the cache level (under <cache> or <defaultCache>). The cache policy always overrides the cache manager
- one if both are set. This element has no effect on distributed caches.
-
- Transactions
- ++++++++++++
-
- To enable an ehcache as transactions, set the transactionalMode
-
- transactionalMode="xa" - high performance JTA/XA implementation
- transactionalMode="xa_strict" - canonically correct JTA/XA implementation
- transactionMode="local" - high performance local transactions involving caches only
- transactionalMode="off" - the default, no transactions
-
- If set, all cache operations will need to be done through transactions.
-
- To prevent users keeping references on stored elements and modifying them outside of any transaction's control,
- transactions also require the cache to be configured copyOnRead and copyOnWrite.
-
- CacheWriter
- ++++++++++++
-
- A CacheWriter can be set to write to an underlying resource. Only one CacheWriter can be
- configured per cache.
-
- The following is an example of how to configure CacheWriter for write-through:
-
- <cacheWriter writeMode="write-through" notifyListenersOnException="true">
- <cacheWriterFactory class="net.sf.ehcache.writer.TestCacheWriterFactory"
- properties="type=int,startCounter=10"/>
- </cacheWriter>
-
- The following is an example of how to configure CacheWriter for write-behind:
-
- <cacheWriter writeMode="write-behind" minWriteDelay="1" maxWriteDelay="5"
- rateLimitPerSecond="5" writeCoalescing="true" writeBatching="true" writeBatchSize="1"
- retryAttempts="2" retryAttemptDelaySeconds="1">
- <cacheWriterFactory class="net.sf.ehcache.writer.TestCacheWriterFactory"
- properties="type=int,startCounter=10"/>
- </cacheWriter>
-
- The cacheWriter element has the following attributes:
- * writeMode: the write mode, write-through or write-behind
-
- These attributes only apply to write-through mode:
- * notifyListenersOnException: Sets whether to notify listeners when an exception occurs on a writer operation.
-
- These attributes only apply to write-behind mode:
- * minWriteDelay: Set the minimum number of seconds to wait before writing behind. If set to a value greater than 0,
- it permits operations to build up in the queue. This is different from the maximum write delay in that by waiting
- a minimum amount of time, work is always being built up. If the minimum write delay is set to zero and the
- CacheWriter performs its work very quickly, the overhead of processing the write behind queue items becomes very
- noticeable in a cluster since all the operations might be done for individual items instead of for a collection
- of them.
- * maxWriteDelay: Set the maximum number of seconds to wait before writing behind. If set to a value greater than 0,
- it permits operations to build up in the queue to enable effective coalescing and batching optimisations.
- * writeBatching: Sets whether to batch write operations. If set to true, writeAll and deleteAll will be called on
- the CacheWriter rather than write and delete being called for each key. Resources such as databases can perform
- more efficiently if updates are batched, thus reducing load.
- * writeBatchSize: Sets the number of operations to include in each batch when writeBatching is enabled. If there are
- less entries in the write-behind queue than the batch size, the queue length size is used.
- * rateLimitPerSecond: Sets the maximum number of write operations to allow per second when writeBatching is enabled.
- * writeCoalescing: Sets whether to use write coalescing. If set to true and multiple operations on the same key are
- present in the write-behind queue, only the latest write is done, as the others are redundant.
- * retryAttempts: Sets the number of times the operation is retried in the CacheWriter, this happens after the
- original operation.
- * retryAttemptDelaySeconds: Sets the number of seconds to wait before retrying an failed operation.
-
- Cache Extension
- +++++++++++++++
-
- CacheExtensions are a general purpose mechanism to allow generic extensions to a Cache.
- CacheExtensions are tied into the Cache lifecycle.
-
- CacheExtensions are created using the CacheExtensionFactory which has a
- <code>createCacheCacheExtension()</code> method which takes as a parameter a
- Cache and properties. It can thus call back into any public method on Cache, including, of
- course, the load methods.
-
- Extensions are added as per the following example:
-
- <cacheExtensionFactory class="com.example.FileWatchingCacheRefresherExtensionFactory"
- properties="refreshIntervalMillis=18000, loaderTimeout=3000,
- flushPeriod=whatever, someOtherProperty=someValue ..."/>
-
- Cache Decorator Factory
- +++++++++++++++++++++++
-
- Cache decorators can be configured directly in ehcache.xml. The decorators will be created and added to the CacheManager.
- It accepts the name of a concrete class that extends net.sf.ehcache.constructs.CacheDecoratorFactory
- The properties will be parsed according to the delimiter (default is comma ',') and passed to the concrete factory's
- <code>createDecoratedEhcache(Ehcache cache, Properties properties)</code> method along with the reference to the owning cache.
-
- It is configured as per the following example:
-
- <cacheDecoratorFactory
- class="com.company.DecoratedCacheFactory"
- properties="property1=true ..." />
-
- Distributed Caching with Terracotta
- +++++++++++++++++++++++++++++++++++
-
- Distributed Caches connect to a Terracotta Server Array. They are configured with the <terracotta> sub-element.
-
- The <terracotta> sub-element has the following attributes:
-
- * clustered=true|false - indicates whether this cache should be clustered (distributed) with Terracotta. By
- default, if the <terracotta> element is included, clustered=true.
-
- * copyOnRead=true|false - indicates whether cache values are deserialized on every read or if the
- materialized cache value can be re-used between get() calls. This setting is useful if a cache
- is being shared by callers with disparate classloaders or to prevent local drift if keys/values
- are mutated locally without being put back in the cache.
-
- The default is false.
-
- * consistency=strong|eventual - Indicates whether this cache should have strong consistency or eventual
- consistency. The default is eventual. See the documentation for the meaning of these terms.
-
- * synchronousWrites=true|false
-
- Synchronous writes (synchronousWrites="true") maximize data safety by blocking the client thread until
- the write has been written to the Terracotta Server Array.
-
- This option is only available with consistency=strong. The default is false.
-
- * concurrency - the number of segments that will be used by the map underneath the Terracotta Store.
- Its optional and has default value of 0, which means will use default values based on the internal
- Map being used underneath the store.
-
- This value cannot be changed programmatically once a cache is initialized.
-
- The <terracotta> sub-element also has a <nonstop> sub-element to allow configuration of cache behaviour if a distributed
- cache operation cannot be completed within a set time or in the event of a clusterOffline message. If this element does not appear, nonstop behavior is off.
-
- <nonstop> has the following attributes:
-
- * enabled="true" - defaults to true.
-
- * timeoutMillis - An SLA setting, so that if a cache operation takes longer than the allowed ms, it will timeout.
-
- * searchTimeoutMillis - If a cache search operation in the nonstop mode takes longer than the allowed ms, it will timeout.
-
- * immediateTimeout="true|false" - What to do on receipt of a ClusterOffline event indicating that communications
- with the Terracotta Server Array were interrupted.
-
- <nonstop> has one sub-element, <timeoutBehavior> which has the following attribute:
-
- * type="noop|exception|localReads|localReadsAndExceptionOnWrite" - What to do when a timeout has occurred. Exception is the default.
-
- Simplest example to indicate clustering:
- <terracotta/>
-
- To indicate the cache should not be clustered (or remove the <terracotta> element altogether):
- <terracotta clustered="false"/>
-
- To indicate the cache should be clustered using "eventual" consistency mode for better performance :
- <terracotta clustered="true" consistency="eventual"/>
-
- To indicate the cache should be clustered using synchronous-write locking level:
- <terracotta clustered="true" synchronousWrites="true"/>
- -->
-
- <!--
- Mandatory Default Cache configuration. These settings will be applied to caches
- created programmtically using CacheManager.add(String cacheName)
- -->
- <defaultCache
- eternal="true"
- overflowToDisk="false"
- memoryStoreEvictionPolicy="LRU"
- />
-
- <!--
- a cache from database ID to KiWiNode; should be very large since this kind of lookup is a very frequent operation
- -->
- <cache name="node-cache"
- maxBytesLocalHeap="30%"
- timeToLiveSeconds="3600"
- overflowToDisk="false"
- memoryStoreEvictionPolicy="LFU"/>
-
- <!--
- a cache from database ID to KiWiTriple; should be fairly large since it can speed up loading query results
- from the database by avoiding reconstructing each triple from the database result
- -->
- <cache name="triple-cache"
- maxBytesLocalHeap="10%"
- overflowToDisk="false"
- timeToLiveSeconds="3600"
- memoryStoreEvictionPolicy="LFU"/>
-
-
- <!-- a cache from URI to KiWiUriResource -->
- <cache name="uri-cache"
- maxBytesLocalHeap="10%"
- overflowToDisk="false"
- timeToLiveSeconds="3600"
- memoryStoreEvictionPolicy="LRU"/>
-
- <!-- a cache from anonymous ID to KiWiAnonResource -->
- <cache name="bnode-cache"
- maxBytesLocalHeap="5%"
- overflowToDisk="false"
- timeToLiveSeconds="3600"
- memoryStoreEvictionPolicy="LRU"/>
-
-
- <!-- a cache from literal cache key to KiWiLiteral -->
- <cache name="literal-cache"
- maxBytesLocalHeap="10%"
- overflowToDisk="false"
- timeToLiveSeconds="3600"
- memoryStoreEvictionPolicy="LFU"/>
-
-
- <cache name="namespace-prefix-cache"
- maxBytesLocalHeap="5%"
- eternal="true"
- overflowToDisk="false"
- memoryStoreEvictionPolicy="LFU"/>
-
- <cache name="namespace-uri-cache"
- maxBytesLocalHeap="5%"
- eternal="true"
- overflowToDisk="false"
- memoryStoreEvictionPolicy="LFU"/>
-
-
- <cache name="loader-cache"
- statistics="true"
- maxBytesLocalHeap="15%"
- timeToIdleSeconds="120"
- overflowToDisk="false"
- memoryStoreEvictionPolicy="LRU"/>
-
-
- <!-- uncomment to enable cache debugging -->
-<!--
- <cacheManagerPeerListenerFactory
- class="org.terracotta.ehcachedx.monitor.probe.ProbePeerListenerFactory"
- properties="monitorAddress=localhost, monitorPort=9889" />
--->
-
-</ehcache>
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0d79835c/libraries/kiwi/kiwi-triplestore/src/test/resources/logback.xml
----------------------------------------------------------------------
diff --git a/libraries/kiwi/kiwi-triplestore/src/test/resources/logback.xml b/libraries/kiwi/kiwi-triplestore/src/test/resources/logback.xml
index 9678d31..42350aa 100644
--- a/libraries/kiwi/kiwi-triplestore/src/test/resources/logback.xml
+++ b/libraries/kiwi/kiwi-triplestore/src/test/resources/logback.xml
@@ -22,7 +22,7 @@
</encoder>
</appender>
- <logger name="net.sf.ehcache.pool.impl" level="WARN" />
+ <logger name="org.infinispan.jmx" level="WARN" />
<root level="${root-level:-INFO}">
<appender-ref ref="CONSOLE"/>