From be30a76370c242adcaa203112d7b1390569170c0 Mon Sep 17 00:00:00 2001 From: Nishchay Date: Tue, 10 Jan 2023 16:03:38 +0530 Subject: [PATCH] issue-2494 : fix cache visiblity for javaxCacheManager --- .../org/ehcache/jsr107/Eh107CacheManager.java | 68 ++++++++----------- .../java/org/ehcache/jsr107/UnwrapTest.java | 31 ++++++++- 2 files changed, 58 insertions(+), 41 deletions(-) diff --git a/ehcache-107/src/main/java/org/ehcache/jsr107/Eh107CacheManager.java b/ehcache-107/src/main/java/org/ehcache/jsr107/Eh107CacheManager.java index 11abf7e57c..0af2001399 100644 --- a/ehcache-107/src/main/java/org/ehcache/jsr107/Eh107CacheManager.java +++ b/ehcache-107/src/main/java/org/ehcache/jsr107/Eh107CacheManager.java @@ -34,10 +34,7 @@ import java.io.IOException; import java.lang.management.ManagementFactory; import java.net.URI; -import java.util.ArrayList; -import java.util.Collections; -import java.util.Map; -import java.util.Properties; +import java.util.*; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentMap; @@ -63,7 +60,7 @@ class Eh107CacheManager implements CacheManager { private static final MBeanServer MBEAN_SERVER = ManagementFactory.getPlatformMBeanServer(); private final Object cachesLock = new Object(); - private final ConcurrentMap> caches = new ConcurrentHashMap<>(); + private final ConcurrentMap> lazilyLoadedCaches = new ConcurrentHashMap<>(); private final org.ehcache.CacheManager ehCacheManager; private final EhcacheCachingProvider cachingProvider; private final ClassLoader classLoader; @@ -82,37 +79,31 @@ class Eh107CacheManager implements CacheManager { this.configurationMerger = configurationMerger; this.statisticsService = jsr107Service.getStatistics(); - refreshAllCaches(); } - private void refreshAllCaches() { - for (Map.Entry> entry : ehCacheManager.getRuntimeConfiguration().getCacheConfigurations().entrySet()) { - String name = entry.getKey(); - CacheConfiguration config = entry.getValue(); - - if (!caches.containsKey(name)) { - Eh107Cache wrappedCache = wrapEhcacheCache(name, config); - if (caches.putIfAbsent(name, wrappedCache) == null) { - @SuppressWarnings("unchecked") - Eh107Configuration configuration = wrappedCache.getConfiguration(Eh107Configuration.class); - if (configuration.isManagementEnabled()) { - enableManagement(wrappedCache, true); - } - if (configuration.isStatisticsEnabled()) { - enableStatistics(wrappedCache, true); - } + private Eh107Cache wrapEhcacheCache(String alias, CacheConfiguration ehConfig) { + org.ehcache.Cache cache = ehCacheManager.getCache(alias, ehConfig.getKeyType(), ehConfig.getValueType()); + return wrapEhcacheCache(alias, (InternalCache)cache); + } + + private void loadCache(String cacheName) { + Map> cacheConfigurations = ehCacheManager.getRuntimeConfiguration().getCacheConfigurations(); + CacheConfiguration cacheConfiguration; + + if (null != (cacheConfiguration = cacheConfigurations.get(cacheName))) { + Eh107Cache wrappedCache = wrapEhcacheCache(cacheName, cacheConfiguration); + if (lazilyLoadedCaches.putIfAbsent(cacheName, wrappedCache) == null) { + @SuppressWarnings("unchecked") + Eh107Configuration configuration = wrappedCache.getConfiguration(Eh107Configuration.class); + if (configuration.isManagementEnabled()) { + enableManagement(wrappedCache, true); + } + if (configuration.isStatisticsEnabled()) { + enableStatistics(wrappedCache, true); } } } - for (Eh107Cache wrappedCache : caches.values()) { - wrappedCache.isClosed(); - } - } - - private Eh107Cache wrapEhcacheCache(String alias, CacheConfiguration ehConfig) { - org.ehcache.Cache cache = ehCacheManager.getCache(alias, ehConfig.getKeyType(), ehConfig.getValueType()); - return wrapEhcacheCache(alias, (InternalCache)cache); } private Eh107Cache wrapEhcacheCache(String alias, InternalCache cache) { @@ -182,8 +173,7 @@ public > Cache createCache(String cach throw new CacheException("A Cache named [" + cacheName + "] already exists"); } Eh107Cache cache = wrapEhcacheCache(cacheName, (InternalCache)ehcache); - assert safeCacheRetrieval(cacheName) == null; - caches.put(cacheName, cache); + lazilyLoadedCaches.put(cacheName, cache); @SuppressWarnings("unchecked") Eh107Configuration configuration = cache.getConfiguration(Eh107Configuration.class); @@ -220,7 +210,7 @@ public > Cache createCache(String cach cache = new Eh107Cache<>(cacheName, new Eh107CompleteConfiguration<>(configHolder.jsr107Configuration, ehCache .getRuntimeConfiguration()), cacheResources, ehCache, statisticsService, this); - caches.put(cacheName, cache); + lazilyLoadedCaches.put(cacheName, cache); if (configHolder.jsr107Configuration.isManagementEnabled()) { enableManagement(cacheName, true); @@ -296,7 +286,8 @@ public Cache getCache(String cacheName) { @SuppressWarnings("unchecked") private Eh107Cache safeCacheRetrieval(final String cacheName) { - final Eh107Cache eh107Cache = caches.get(cacheName); + loadCache(cacheName); + final Eh107Cache eh107Cache = lazilyLoadedCaches.get(cacheName); if(eh107Cache != null && eh107Cache.isClosed()) { return null; } @@ -306,8 +297,7 @@ private Eh107Cache safeCacheRetrieval(final String cacheName) { @Override public Iterable getCacheNames() { checkClosed(); - refreshAllCaches(); - return Collections.unmodifiableList(new ArrayList<>(caches.keySet())); + return Collections.unmodifiableList(new ArrayList<>(lazilyLoadedCaches.keySet())); } @Override @@ -319,7 +309,7 @@ public void destroyCache(String cacheName) { synchronized (cachesLock) { checkClosed(); - Eh107Cache cache = caches.remove(cacheName); + Eh107Cache cache = lazilyLoadedCaches.remove(cacheName); if (cache == null) { // TCK expects this method to return w/o exception if named cache does // not exist @@ -447,7 +437,7 @@ public void close() { void closeInternal() { synchronized (cachesLock) { try { - closeAll(caches.values(), (Closeable) caches::clear, ehCacheManager); + closeAll(lazilyLoadedCaches.values(), (Closeable) lazilyLoadedCaches::clear, ehCacheManager); } catch (IOException e) { throw new CacheException(e); } @@ -455,7 +445,7 @@ void closeInternal() { } void close(Eh107Cache cache) { - if (caches.remove(cache.getName(), cache)) { + if (lazilyLoadedCaches.remove(cache.getName(), cache)) { try { chain( () -> unregisterObject(cache.getManagementMBean()), diff --git a/ehcache-107/src/test/java/org/ehcache/jsr107/UnwrapTest.java b/ehcache-107/src/test/java/org/ehcache/jsr107/UnwrapTest.java index 930238a967..99ac3a1cfa 100644 --- a/ehcache-107/src/test/java/org/ehcache/jsr107/UnwrapTest.java +++ b/ehcache-107/src/test/java/org/ehcache/jsr107/UnwrapTest.java @@ -15,6 +15,7 @@ */ package org.ehcache.jsr107; +import org.ehcache.config.builders.CacheConfigurationBuilder; import org.ehcache.core.EhcacheManager; import org.ehcache.event.CacheEvent; import org.junit.After; @@ -28,9 +29,9 @@ import javax.cache.event.EventType; import javax.cache.spi.CachingProvider; +import static org.ehcache.config.builders.ResourcePoolsBuilder.heap; import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.instanceOf; -import static org.hamcrest.Matchers.is; +import static org.hamcrest.Matchers.*; /** * @author rism @@ -77,6 +78,32 @@ public void testCacheEntryEventUnwrap() { assertThat(cacheEntryEvent.unwrap(cacheEntryEvent.getClass()), is(instanceOf(Eh107CacheEntryEvent.NormalEvent.class))); } + @Test + public void testCacheVisibilityPostUnwrap() { + + CacheManager javaxCacheManager = Caching.getCachingProvider().getCacheManager(); + + org.ehcache.CacheManager cacheManager = javaxCacheManager.unwrap(org.ehcache.CacheManager.class); + CacheConfigurationBuilder cacheConfigurationBuilder = CacheConfigurationBuilder.newCacheConfigurationBuilder(Integer.class, String.class, heap(5)); + cacheManager.createCache("jcache", cacheConfigurationBuilder); + + Cache javaxCache = javaxCacheManager.getCache("jcache", Integer.class, String.class); + assertThat(javaxCache, is(notNullValue())); + + CacheManager javaxCacheManager1 = javaxCacheManager.unwrap(javax.cache.CacheManager.class); + Cache javaxCache1 = javaxCacheManager1.getCache("jcache", Integer.class, String.class); + assertThat(javaxCache1, is(notNullValue())); + + org.ehcache.Cache cache = cacheManager.getCache("jcache", Integer.class, String.class); + assertThat(cache, is(notNullValue())); + + cache.put(1,"one"); + assertThat(javaxCache.get(1), is("one")); + assertThat(javaxCache1.get(1), is("one")); + + } + + private class EhEvent implements CacheEvent { @Override public org.ehcache.event.EventType getType() {