private static Cache[] allCaches(CacheManager cacheManager) {
int i = 0;
Cache[] caches = new Cache[cacheManager.getCacheNames().length];
for (String name : cacheManager.getCacheNames()) {
caches[i++] = cacheManager.getCache(name);
}
return caches;
}
/** @see com.dianping.cache.core.CacheClient#clear() */
@Override
public void clear() {
defaultBlockingCache.removeAll();
for (String cacheName : manager.getCacheNames()) {
manager.getCache(cacheName).removeAll();
}
}
@Bean
public net.sf.ehcache.CacheManager customEhCacheCacheManager() {
net.sf.ehcache.CacheManager cacheManager = mock(net.sf.ehcache.CacheManager.class);
given(cacheManager.getStatus()).willReturn(Status.STATUS_ALIVE);
given(cacheManager.getCacheNames()).willReturn(new String[0]);
return cacheManager;
}
/**
* {@inheritDoc} Sets up two caches: cache1 is local. cache2 is to be receive updates
*
* @throws Exception
*/
@Before
public void setUp() throws Exception {
failFastInsufficientMemory();
MulticastKeepaliveHeartbeatSender.setHeartBeatInterval(1000);
CountingCacheEventListener.resetCounters();
manager1 =
new CacheManager(
AbstractCacheTest.TEST_CONFIG_DIR
+ "distribution/ehcache-distributed-big-payload-1.xml");
manager2 =
new CacheManager(
AbstractCacheTest.TEST_CONFIG_DIR
+ "distribution/ehcache-distributed-big-payload-2.xml");
manager3 =
new CacheManager(
AbstractCacheTest.TEST_CONFIG_DIR
+ "distribution/ehcache-distributed-big-payload-3.xml");
// allow cluster to be established
waitForClusterMembership(
10,
TimeUnit.SECONDS,
Arrays.asList(manager1.getCacheNames()),
manager1,
manager2,
manager3);
}
@Test
public void testCacheDecoratorFactoryProperties() {
CacheManager cacheManager =
new CacheManager(getClass().getResourceAsStream(EHCACHE_DEFAULT_DECORATOR_TEST_XML));
List<String> cacheNames = Arrays.asList(cacheManager.getCacheNames());
assertEquals(7, cacheNames.size());
MockDecoratorFactoryCache cache =
(MockDecoratorFactoryCache) cacheManager.getEhcache("noDecoratorCache-defaultDecoratorOne");
assertEquals("defaultDecoratorOne", cache.getProperties().getProperty("someKey"));
cache =
(MockDecoratorFactoryCache) cacheManager.getEhcache("noDecoratorCache-defaultDecoratorTwo");
assertEquals("defaultDecoratorTwo", cache.getProperties().getProperty("someKey"));
cache =
(MockDecoratorFactoryCache)
cacheManager.getEhcache("oneDecoratorCache-defaultDecoratorOne");
assertEquals("defaultDecoratorOne", cache.getProperties().getProperty("someKey"));
cache =
(MockDecoratorFactoryCache)
cacheManager.getEhcache("oneDecoratorCache-defaultDecoratorTwo");
assertEquals("defaultDecoratorTwo", cache.getProperties().getProperty("someKey"));
cache = (MockDecoratorFactoryCache) cacheManager.getEhcache("oneDecoratorCacheFirst");
assertEquals("oneFirst", cache.getProperties().getProperty("someKey"));
}
/** Does a down cache manager in the cluster get removed? */
@Test
public void testRemoteCachePeersDetectsDownCacheManager() throws InterruptedException {
// Drop a CacheManager from the cluster
manager3.shutdown();
// Allow change detection to occur. Heartbeat 1 second and is not stale until 5000
waitForClusterMembership(
11020, TimeUnit.MILLISECONDS, Arrays.asList(manager1.getCacheNames()), manager1, manager2);
}
@Override
public Iterable<String> getCacheNames() {
if (this.cacheManager != null) {
String[] names = cacheManager.getCacheNames();
return Arrays.asList(names);
} else {
return new ArrayList<String>(0);
}
}
/**
* Return all caches from the CacheManager
*
* @param sorted Should the caches be sorted by name?
* @return
*/
private List<Ehcache> getAllCaches(boolean sorted) {
M_log.debug("getAllCaches()");
final String[] cacheNames = cacheManager.getCacheNames();
if (sorted) Arrays.sort(cacheNames);
final List<Ehcache> caches = new ArrayList<Ehcache>(cacheNames.length);
for (String cacheName : cacheNames) {
caches.add(cacheManager.getEhcache(cacheName));
}
return caches;
}
private String createReferenceString() {
String[] names = manager.getCacheNames();
String urlBase = "//localhost.localdomain:12000/";
StringBuilder buffer = new StringBuilder();
for (String name : names) {
buffer.append(urlBase);
buffer.append(name);
buffer.append("|");
}
String payload = buffer.toString();
return payload;
}
public SamplerRepoEntry(CacheManager cacheManager) {
if (cacheManager == null) throw new IllegalArgumentException("cacheManager == null");
this.cacheManagerSampler = new CacheManagerSamplerImpl(cacheManager);
this.cacheManager = cacheManager;
String[] cNames = cacheManager.getCacheNames();
this.cacheSamplersByName = new HashMap<String, CacheSampler>(cNames.length);
for (String cName : cNames) {
cacheSamplersByName.put(cName, new CacheSamplerImpl(cacheManager.getEhcache(cName)));
}
}
/** Service INIT */
public void init() {
if (cacheManager == null) {
throw new IllegalStateException("init(): Ehcache CacheManager is null!");
}
log.info(
"INIT: "
+ cacheManager.getStatus()
+ ", caches: "
+ Arrays.asList(cacheManager.getCacheNames()));
if (serverConfigurationService.getBoolean("memory.ehcache.jmx", true)) {
EhCacheJmxRegistration registration = new EhCacheJmxRegistration();
registration.register(cacheManager);
}
}
@Override
public void evictExpiredMembers() {
if (!getSecurityService().isSuperUser()) {
throw new SecurityException(
"Only super admin can evict caches, current user not super admin");
}
if (this.cacheManager != null) {
String[] allCacheNames = cacheManager.getCacheNames();
for (String cacheName : allCacheNames) {
Ehcache cache = cacheManager.getCache(cacheName);
cache.evictExpiredElements();
}
}
}
public void logStats() {
for (String name : manager.getCacheNames()) {
StatisticsGateway s = manager.getCache(name).getStatistics();
log.debug(
String.format(
"Cache %s: hit/miss = %d/%d (%f), heap = %d (%d bytes), disk = %d (%d bytes)",
name,
s.cacheHitCount(),
s.cacheMissCount(),
s.cacheHitRatio(),
s.getLocalHeapSize(),
s.getLocalHeapSizeInBytes(),
s.getLocalDiskSize(),
s.getLocalDiskSizeInBytes()));
}
}
@Test
public void testCacheDecoratorFactory() {
CacheManager cacheManager =
new CacheManager(getClass().getResourceAsStream(EHCACHE_DEFAULT_DECORATOR_TEST_XML));
List<String> cacheNames = Arrays.asList(cacheManager.getCacheNames());
System.out.println(cacheNames);
assertEquals(7, cacheNames.size());
assertTrue(cacheNames.contains("noDecoratorCache"));
assertTrue(cacheNames.contains("noDecoratorCache-defaultDecoratorOne"));
assertTrue(cacheNames.contains("noDecoratorCache-defaultDecoratorTwo"));
assertTrue(cacheNames.contains("oneDecoratorCache"));
assertTrue(cacheNames.contains("oneDecoratorCacheFirst"));
assertTrue(cacheNames.contains("oneDecoratorCache-defaultDecoratorOne"));
assertTrue(cacheNames.contains("oneDecoratorCache-defaultDecoratorTwo"));
}
/** Does a down cache manager in the cluster get removed? */
@Test
public void testRemoteCachePeersDetectsDownCacheManagerSlow() throws InterruptedException {
MulticastKeepaliveHeartbeatSender.setHeartBeatInterval(2000);
try {
Thread.sleep(2000);
// Drop a CacheManager from the cluster
manager3.shutdown();
// Insufficient time, should be alive till now
CacheManagerPeerProvider provider = manager1.getCacheManagerPeerProvider("RMI");
for (String cacheName : manager1.getCacheNames()) {
List remotePeersOfCache1 = provider.listRemoteCachePeers(manager1.getCache(cacheName));
assertEquals(2, remotePeersOfCache1.size());
}
} finally {
MulticastKeepaliveHeartbeatSender.setHeartBeatInterval(1000);
Thread.sleep(2000);
}
}
/** Does a new cache manager in the cluster get detected? */
@Test
public void testRemoteCachePeersDetectsNewCacheManager() throws InterruptedException {
// Add new CacheManager to cluster
CacheManager manager4 =
new CacheManager(
AbstractCacheTest.TEST_CONFIG_DIR
+ "distribution/ehcache-distributed-big-payload-4.xml");
try {
// Allow detection to occur
waitForClusterMembership(
10020,
TimeUnit.MILLISECONDS,
Arrays.asList(manager1.getCacheNames()),
manager1,
manager2,
manager3,
manager4);
} finally {
manager4.shutdown();
}
}
/**
* Tests put and remove initiated from cache1 in a cluster
*
* <p>This test goes into an infinite loop if the chain of notifications is not somehow broken.
*/
@Test
public void testPutProgagatesFromAndToEveryCacheManagerAndCache()
throws CacheException, InterruptedException {
// Put
final String[] cacheNames = manager1.getCacheNames();
Arrays.sort(cacheNames);
for (int i = 0; i < cacheNames.length; i++) {
String name = cacheNames[i];
manager1.getCache(name).put(new Element(Integer.toString(i), Integer.valueOf(i)));
// Add some non serializable elements that should not get propagated
manager1.getCache(name).put(new Element("nonSerializable" + i, new Object()));
}
assertBy(
10,
TimeUnit.SECONDS,
new Callable<Boolean>() {
public Boolean call() throws Exception {
for (int i = 0; i < cacheNames.length; i++) {
String name = cacheNames[i];
for (CacheManager manager : new CacheManager[] {manager2, manager3}) {
Element element = manager.getCache(name).get(Integer.toString(i));
assertNotNull("Cache : " + name, element);
assertEquals(Integer.toString(i), element.getKey());
assertEquals(Integer.valueOf(i), element.getValue());
assertNull(manager.getCache(name).get("nonSerializable" + i));
}
}
return Boolean.TRUE;
}
},
is(Boolean.TRUE));
}
@Override
public String getStatus() {
// MIRRORS the OLD status report
final StringBuilder buf = new StringBuilder();
buf.append("** Memory report\n");
buf.append("freeMemory: ").append(Runtime.getRuntime().freeMemory());
buf.append(" totalMemory: ");
buf.append(Runtime.getRuntime().totalMemory());
buf.append(" maxMemory: ");
buf.append(Runtime.getRuntime().maxMemory());
buf.append("\n\n");
String[] allCacheNames = cacheManager.getCacheNames();
Arrays.sort(allCacheNames);
ArrayList<Ehcache> caches = new ArrayList<Ehcache>(allCacheNames.length);
for (String cacheName : allCacheNames) {
Ehcache cache = cacheManager.getCache(cacheName);
caches.add(cache);
}
// summary (cache descriptions)
for (Ehcache cache : caches) {
Cache c = new EhcacheCache(cache);
buf.append(c.getDescription()).append("\n");
}
// extended report
// TODO probably should remove this
buf.append("\n** Extended Cache Report\n");
for (Ehcache cache : caches) {
buf.append(cache.toString());
buf.append("\n");
}
// config report
buf.append("\n** Current Cache Configurations\n");
// determine whether to use old or new form keys
boolean legacyKeys = true; // set true for a 2.9/BasicMemoryService compatible set of keys
String maxKey = "maxEntries";
String ttlKey = "timeToLive";
String ttiKey = "timeToIdle";
String eteKey = "eternal";
//noinspection ConstantConditions
if (legacyKeys) {
maxKey = "maxElementsInMemory";
ttlKey = "timeToLiveSeconds";
ttiKey = "timeToIdleSeconds";
}
// DEFAULT cache config
CacheConfiguration defaults = cacheManager.getConfiguration().getDefaultCacheConfiguration();
long maxEntriesDefault = defaults.getMaxEntriesLocalHeap();
long ttlSecsDefault = defaults.getTimeToLiveSeconds();
long ttiSecsDefault = defaults.getTimeToIdleSeconds();
boolean eternalDefault = defaults.isEternal();
buf.append("# DEFAULTS: ")
.append(maxKey)
.append("=")
.append(maxEntriesDefault)
.append(",")
.append(ttlKey)
.append("=")
.append(ttlSecsDefault)
.append(",")
.append(ttiKey)
.append("=")
.append(ttiSecsDefault)
.append(",")
.append(eteKey)
.append("=")
.append(eternalDefault)
.append("\n");
// new: timeToLive=600,timeToIdle=360,maxEntries=5000,eternal=false
// old: timeToLiveSeconds=3600,timeToIdleSeconds=900,maxElementsInMemory=20000,eternal=false
for (Ehcache cache : caches) {
long maxEntries = cache.getCacheConfiguration().getMaxEntriesLocalHeap();
long ttlSecs = cache.getCacheConfiguration().getTimeToLiveSeconds();
long ttiSecs = cache.getCacheConfiguration().getTimeToIdleSeconds();
boolean eternal = cache.getCacheConfiguration().isEternal();
if (maxEntries == maxEntriesDefault
&& ttlSecs == ttlSecsDefault
&& ttiSecs == ttiSecsDefault
&& eternal == eternalDefault) {
// Cache ONLY uses the defaults
buf.append("# memory.").append(cache.getName()).append(" *ALL DEFAULTS*\n");
} else {
// NOT only defaults cache, show the settings that differ from the defaults
buf.append("memory.").append(cache.getName()).append("=");
boolean first = true;
if (maxEntries != maxEntriesDefault) {
//noinspection ConstantConditions
first = addKeyValueToConfig(buf, maxKey, maxEntries, first);
}
if (ttlSecs != ttlSecsDefault) {
first = addKeyValueToConfig(buf, ttlKey, ttlSecs, first);
}
if (ttiSecs != ttiSecsDefault) {
first = addKeyValueToConfig(buf, ttiKey, ttiSecs, first);
}
if (eternal != eternalDefault) {
addKeyValueToConfig(buf, eteKey, eternal, first);
}
buf.append("\n");
// TODO remove the overflow to disk check
//noinspection deprecation
if (cache.getCacheConfiguration().isOverflowToDisk()) {
// overflowToDisk. maxEntriesLocalDisk
buf.append("# NOTE: ")
.append(cache.getName())
.append(" is configured for Overflow(disk), ")
.append(cache.getCacheConfiguration().getMaxEntriesLocalDisk())
.append(" entries\n");
}
}
}
final String rv = buf.toString();
log.info(rv);
return rv;
}
