Revert "Merge branch 'issue-2494-daggy' into issue-2494-daggy-integrate"

This reverts commit 5fc4dd8, reversing
changes made to cafa5bf.

Author: chrisdennis

ehcache-107/src/main/java/org/ehcache/jsr107/Eh107CacheManager.java

@@ -35,7 +35,10 @@
 import java.io.IOException;
 import java.lang.management.ManagementFactory;
 import java.net.URI;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Map;
+import java.util.Properties;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 
@@ -61,7 +64,7 @@ class Eh107CacheManager implements CacheManager {
   private static final MBeanServer MBEAN_SERVER = ManagementFactory.getPlatformMBeanServer();
 
   private final Object cachesLock = new Object();
-  private final ConcurrentMap<String, Eh107Cache<?, ?>> lazilyLoadedCaches = new ConcurrentHashMap<>();
+  private final ConcurrentMap<String, Eh107Cache<?, ?>> caches = new ConcurrentHashMap<>();
   private final org.ehcache.CacheManager ehCacheManager;
   private final EhcacheCachingProvider cachingProvider;
   private final ClassLoader classLoader;
@@ -80,26 +83,32 @@ class Eh107CacheManager implements CacheManager {
     this.configurationMerger = configurationMerger;
     this.statisticsService = jsr107Service.getStatistics();
 
+    refreshAllCaches();
   }
 
-
-  private void loadCache(String cacheName) {
-    Map<String, CacheConfiguration<?, ?>> 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);
+  private void refreshAllCaches() {
+    for (Map.Entry<String, CacheConfiguration<?, ?>> 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);
+          }
         }
       }
     }
+
+    for (Eh107Cache<?, ?> wrappedCache : caches.values()) {
+      wrappedCache.isClosed();
+    }
   }
 
   private <K, V> Eh107Cache<K, V> wrapEhcacheCache(String alias, CacheConfiguration<K, V> ehConfig) {
@@ -175,7 +184,7 @@ public <K, V, C extends Configuration<K, V>> Cache<K, V> createCache(String cach
         }
         Eh107Cache<K, V> cache = wrapEhcacheCache(cacheName, (InternalCache<K, V>)ehcache);
         assert safeCacheRetrieval(cacheName) == null;
-        lazilyLoadedCaches.put(cacheName, cache);
+        caches.put(cacheName, cache);
 
         @SuppressWarnings("unchecked")
         Eh107Configuration<?, ?> configuration = cache.getConfiguration(Eh107Configuration.class);
@@ -212,7 +221,7 @@ public <K, V, C extends Configuration<K, V>> Cache<K, V> createCache(String cach
         cache = new Eh107Cache<>(cacheName, new Eh107CompleteConfiguration<>(configHolder.jsr107Configuration, ehCache
           .getRuntimeConfiguration()), cacheResources, ehCache, statisticsService, this);
 
-        lazilyLoadedCaches.put(cacheName, cache);
+        caches.put(cacheName, cache);
 
         if (configHolder.jsr107Configuration.isManagementEnabled()) {
           enableManagement(cacheName, true);
@@ -248,7 +257,6 @@ public String toString() {
   @Override
   public <K, V> Cache<K, V> getCache(String cacheName, Class<K> keyType, Class<V> valueType) {
     checkClosed();
-    loadCache(cacheName);
 
     if (cacheName == null || keyType == null || valueType == null) {
       throw new NullPointerException();
@@ -279,7 +287,6 @@ public <K, V> Cache<K, V> getCache(String cacheName, Class<K> keyType, Class<V>
   @Override
   public <K, V> Cache<K, V> getCache(String cacheName) {
     checkClosed();
-    loadCache(cacheName);
 
     if (cacheName == null) {
       throw new NullPointerException();
@@ -290,7 +297,7 @@ public <K, V> Cache<K, V> getCache(String cacheName) {
 
   @SuppressWarnings("unchecked")
   private <K, V> Eh107Cache<K, V> safeCacheRetrieval(final String cacheName) {
-    final Eh107Cache<?, ?> eh107Cache = lazilyLoadedCaches.get(cacheName);
+    final Eh107Cache<?, ?> eh107Cache = caches.get(cacheName);
     if(eh107Cache != null && eh107Cache.isClosed()) {
       return null;
     }
@@ -300,7 +307,8 @@ private <K, V> Eh107Cache<K, V> safeCacheRetrieval(final String cacheName) {
   @Override
   public Iterable<String> getCacheNames() {
     checkClosed();
-    return Collections.unmodifiableList(new ArrayList<>(lazilyLoadedCaches.keySet()));
+    refreshAllCaches();
+    return Collections.unmodifiableList(new ArrayList<>(caches.keySet()));
   }
 
   @Override
@@ -312,7 +320,7 @@ public void destroyCache(String cacheName) {
     synchronized (cachesLock) {
       checkClosed();
 
-      Eh107Cache<?, ?> cache = lazilyLoadedCaches.remove(cacheName);
+      Eh107Cache<?, ?> cache = caches.remove(cacheName);
       if (cache == null) {
         // TCK expects this method to return w/o exception if named cache does
         // not exist
@@ -440,15 +448,15 @@ public void close() {
   void closeInternal() {
     synchronized (cachesLock) {
       try {
-        closeAll(lazilyLoadedCaches.values(), (Closeable) lazilyLoadedCaches::clear, ehCacheManager);
+        closeAll(caches.values(), (Closeable) caches::clear, ehCacheManager);
       } catch (IOException e) {
         throw new CacheException(e);
       }
     }
   }
 
   void close(Eh107Cache<?, ?> cache) {
-    if (lazilyLoadedCaches.remove(cache.getName(), cache)) {
+    if (caches.remove(cache.getName(), cache)) {
       try {
         chain(
           () -> unregisterObject(cache.getManagementMBean()),

ehcache-107/src/test/java/org/ehcache/jsr107/UnwrapTest.java

@@ -16,7 +16,6 @@
  */
 package org.ehcache.jsr107;
 
-import org.ehcache.config.builders.CacheConfigurationBuilder;
 import org.ehcache.core.EhcacheManager;
 import org.ehcache.event.CacheEvent;
 import org.junit.After;
@@ -30,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.*;
+import static org.hamcrest.Matchers.instanceOf;
+import static org.hamcrest.Matchers.is;
 
 /**
  * @author rism
@@ -79,31 +78,6 @@ 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<Integer, String> cacheConfigurationBuilder = CacheConfigurationBuilder.newCacheConfigurationBuilder(Integer.class, String.class, heap(5));
-    cacheManager.createCache("jcache", cacheConfigurationBuilder);
-
-    Cache<Integer, String> javaxCache = javaxCacheManager.getCache("jcache", Integer.class, String.class);
-    assertThat(javaxCache, is(notNullValue()));
-
-    CacheManager javaxCacheManager1 = javaxCacheManager.unwrap(javax.cache.CacheManager.class);
-    Cache<Integer, String> javaxCache1 = javaxCacheManager1.getCache("jcache", Integer.class, String.class);
-    assertThat(javaxCache1, is(notNullValue()));
-
-    org.ehcache.Cache<Integer, String> 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<String,String> {
     @Override
     public org.ehcache.event.EventType getType() {