ISPN-9174 Qualify region names in v53.InfinispanRegionFactory

hibernate/cache-commons/src/main/java/org/infinispan/hibernate/cache/commons/util/CacheCommandFactory.java

@@ -27,18 +27,18 @@
 public class CacheCommandFactory implements ModuleCommandFactory {
 
    /**
-    * Keeps track of regions to which second-level cache specific
-    * commands have been plugged.
+    * Keeps track of regions to which second-level cache specific commands have been plugged.
+    * The regions are keyed by cache name (which is qualified), not by region name that is unqualified in Hibernate 5.3+
     */
-	private ConcurrentMap<String, InfinispanBaseRegion> allRegions = new ConcurrentHashMap<>();
+   private ConcurrentMap<ByteString, InfinispanBaseRegion> allRegions = new ConcurrentHashMap<>();
 
    /**
     * Add region so that commands can be cleared on shutdown.
     *
     * @param region instance to keep track of
     */
 	public void addRegion(InfinispanBaseRegion region) {
-		allRegions.put( region.getName(), region );
+		allRegions.put(ByteString.fromString(region.getCache().getName()), region);
 	}
 
    /**
@@ -47,7 +47,7 @@ public void addRegion(InfinispanBaseRegion region) {
     * @param regions collection of regions to clear
     */
 	public void clearRegions(Collection<? extends InfinispanBaseRegion> regions) {
-		regions.forEach( region -> allRegions.remove( region.getName() ) );
+		regions.forEach(region -> allRegions.remove(ByteString.fromString(region.getCache().getName())));
 	}
 
 	@Override
@@ -64,7 +64,7 @@ public CacheRpcCommand fromStream(byte commandId, ByteString cacheName) {
 		CacheRpcCommand c;
 		switch ( commandId ) {
 			case CacheCommandIds.EVICT_ALL:
-				c = new EvictAllCommand( cacheName, allRegions.get( cacheName.toString() ) );
+				c = new EvictAllCommand(cacheName, allRegions.get(cacheName));
 				break;
 			case CacheCommandIds.END_INVALIDATION:
 				c = new EndInvalidationCommand(cacheName);

hibernate/cache-commons/src/main/java/org/infinispan/hibernate/cache/commons/util/Caches.java

@@ -217,8 +217,8 @@ public static AdvancedCache failSilentReadCache(AdvancedCache cache) {
 
 	/**
 	 * Broadcast an evict-all command with the given cache instance.
-	 *
 	 * @param cache instance used to broadcast command
+	 *
 	 */
 	public static void broadcastEvictAll(AdvancedCache cache) {
 		final RpcManager rpcManager = cache.getRpcManager();

hibernate/cache-commons/src/test/java/org/infinispan/test/hibernate/cache/commons/AbstractRegionAccessStrategyTest.java

@@ -60,7 +60,7 @@ public abstract class AbstractRegionAccessStrategyTest<S>
 		extends AbstractNonFunctionalTest {
 	protected final Logger log = Logger.getLogger(getClass());
 
-	public static final String REGION_NAME = "test/com.foo.test";
+	public static final String REGION_NAME = "com.foo.test";
 	public static final String KEY_BASE = "KEY";
 	public static final TestCacheEntry VALUE1 = new TestCacheEntry("VALUE1", 1);
 	public static final TestCacheEntry VALUE2 = new TestCacheEntry("VALUE2", 2);
@@ -127,6 +127,7 @@ public void cleanup() {
 		if (remoteRegion != null) remoteRegion.getCache().clear();
 		node1Exception = node2Exception = null;
 		node1Failure = node2Failure = null;
+		TIME_SERVICE.advance(1); // There might be invalidation from the previous test
 	}
 
 	@AfterClassOnce

hibernate/cache-commons/src/test/java/org/infinispan/test/hibernate/cache/commons/functional/QualifierTest.java

@@ -0,0 +1,46 @@
+package org.infinispan.test.hibernate.cache.commons.functional;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+import org.hibernate.cfg.AvailableSettings;
+import org.infinispan.hibernate.cache.commons.InfinispanBaseRegion;
+import org.infinispan.manager.EmbeddedCacheManager;
+import org.infinispan.test.hibernate.cache.commons.util.TestRegionFactory;
+import org.infinispan.test.hibernate.cache.commons.util.TestRegionFactoryProvider;
+import org.infinispan.test.hibernate.cache.commons.util.TestSessionAccess;
+import org.junit.Test;
+
+public class QualifierTest extends AbstractFunctionalTest {
+   public static final String FOO_BAR = "foo.bar";
+
+   @Override
+   public List<Object[]> getParameters() {
+      return Collections.singletonList(READ_WRITE_DISTRIBUTED);
+   }
+
+   @Override
+   protected void addSettings(Map settings) {
+      super.addSettings(settings);
+      settings.put(AvailableSettings.CACHE_REGION_PREFIX, FOO_BAR);
+   }
+
+   @Test
+   public void testRegionNamesQualified() {
+      TestRegionFactory factory = TestRegionFactoryProvider.INSTANCE.findRegionFactory(sessionFactory().getCache());
+      EmbeddedCacheManager cacheManager = factory.getCacheManager();
+      for (String cacheName : cacheManager.getCacheNames()) {
+         assertTrue(cacheName.startsWith(FOO_BAR));
+      }
+      // In Hibernate < 5.3 the region factory got qualified names and couldn't use any unqualified form
+      if (!TestRegionFactoryProvider.INSTANCE.getRegionFactoryClass().getName().contains(".v51.")) {
+         for (InfinispanBaseRegion region : TestSessionAccess.findTestSessionAccess().getAllRegions(sessionFactory())) {
+            assertFalse(region.getName().startsWith(FOO_BAR));
+         }
+      }
+   }
+}

hibernate/cache-commons/src/test/java/org/infinispan/test/hibernate/cache/commons/util/TestSessionAccess.java

@@ -9,6 +9,7 @@
 import org.infinispan.hibernate.cache.commons.InfinispanBaseRegion;
 import org.infinispan.util.ControlledTimeService;
 
+import java.util.Collection;
 import java.util.List;
 import java.util.ServiceLoader;
 
@@ -45,6 +46,8 @@ static TestSessionAccess findTestSessionAccess() {
 
    InfinispanBaseRegion getRegion(SessionFactoryImplementor sessionFactory, String regionName);
 
+   Collection<InfinispanBaseRegion> getAllRegions(SessionFactoryImplementor sessionFactory);
+
    interface TestRegionAccessStrategy {
 
       SoftLock lockItem(Object session, Object key, Object version) throws CacheException;

hibernate/cache-v51/src/main/java/org/infinispan/hibernate/cache/v51/InfinispanRegionFactory.java

@@ -462,4 +462,8 @@ else if ( ispnTmLookupClassName != null && !ispnTmLookupClassName.equals( hbTmLo
 			builder.transaction().useSynchronization( DEF_USE_SYNCHRONIZATION );
 		}
 	}
+
+	public SessionFactoryOptions getSettings() {
+		return settings;
+	}
 }

hibernate/cache-v51/src/main/java/org/infinispan/hibernate/cache/v51/query/QueryResultsRegionImpl.java

@@ -85,9 +85,8 @@ public void evictAll() throws CacheException {
       try {
          // Invalidate the local region and then go remote
          invalidateRegion();
-         Caches.broadcastEvictAll( cache );
-      }
-      finally {
+         Caches.broadcastEvictAll(cache);
+      } finally {
          resume( tx );
       }
    }

hibernate/cache-v51/src/test/java/org/infinispan/test/hibernate/cache/v51/util/TestRegionFactoryImpl.java

@@ -74,21 +74,29 @@ public Configuration getPendingPutsCacheConfiguration() {
 
    @Override
    public InfinispanBaseRegion buildCollectionRegion(String regionName, AccessType accessType) {
+      String prefix = delegate.getSettings().getCacheRegionPrefix();
+      if (prefix != null && !prefix.isEmpty()) regionName = prefix + '.' + regionName;
       return (InfinispanBaseRegion) delegate.buildCollectionRegion(regionName, null, MUTABLE_VERSIONED);
    }
 
    @Override
    public InfinispanBaseRegion buildEntityRegion(String regionName, AccessType accessType) {
+      String prefix = delegate.getSettings().getCacheRegionPrefix();
+      if (prefix != null && !prefix.isEmpty()) regionName = prefix + '.' + regionName;
       return (InfinispanBaseRegion) delegate.buildEntityRegion(regionName, null, MUTABLE_VERSIONED);
    }
 
    @Override
    public InfinispanBaseRegion buildTimestampsRegion(String regionName) {
+      String prefix = delegate.getSettings().getCacheRegionPrefix();
+      if (prefix != null && !prefix.isEmpty()) regionName = prefix + '.' + regionName;
       return (InfinispanBaseRegion) delegate.buildTimestampsRegion(regionName, null);
    }
 
    @Override
    public InfinispanBaseRegion buildQueryResultsRegion(String regionName) {
+      String prefix = delegate.getSettings().getCacheRegionPrefix();
+      if (prefix != null && !prefix.isEmpty()) regionName = prefix + '.' + regionName;
       return (InfinispanBaseRegion) delegate.buildQueryResultsRegion(regionName, null);
    }
 

hibernate/cache-v51/src/test/java/org/infinispan/test/hibernate/cache/v51/util/TestSessionAccessImpl.java

@@ -36,6 +36,7 @@
 
 import java.sql.Connection;
 import java.sql.SQLException;
+import java.util.Collection;
 import java.util.List;
 
 import static org.mockito.Mockito.mock;
@@ -167,6 +168,11 @@ public InfinispanBaseRegion getRegion(SessionFactoryImplementor sessionFactory,
       return (InfinispanBaseRegion) sessionFactory.getSecondLevelCacheRegion(regionName);
    }
 
+   @Override
+   public Collection<InfinispanBaseRegion> getAllRegions(SessionFactoryImplementor sessionFactory) {
+      return sessionFactory.getAllSecondLevelCacheRegions().values();
+   }
+
    private static SessionImplementor unwrap(Object session) {
       return (SessionImplementor) session;
    }

hibernate/cache-v53/src/main/java/org/infinispan/hibernate/cache/v53/InfinispanRegionFactory.java

@@ -111,15 +111,12 @@ public InfinispanRegionFactory(Properties props) {
 
    @Override
    public DomainDataRegion buildDomainDataRegion(DomainDataRegionConfig regionConfig, DomainDataRegionBuildingContext buildingContext) {
-      if ( log.isDebugEnabled() ) {
-         log.debugf(
-               "Building domain data region [%s] entities=%s collections=%s naturalIds=%s",
-               regionConfig.getRegionName(),
-               regionConfig.getEntityCaching(),
-               regionConfig.getCollectionCaching(),
-               regionConfig.getNaturalIdCaching()
-         );
-      }
+      log.debugf("Building domain data region [%s] entities=%s collections=%s naturalIds=%s",
+            regionConfig.getRegionName(),
+            regionConfig.getEntityCaching(),
+            regionConfig.getCollectionCaching(),
+            regionConfig.getNaturalIdCaching()
+      );
       // TODO: data type is probably deprecated, but we need it for backwards-compatible configuration
       DataType dataType;
       int entities = regionConfig.getEntityCaching().size();
@@ -137,31 +134,28 @@ public DomainDataRegion buildDomainDataRegion(DomainDataRegionConfig regionConfi
          dataType = DataType.ENTITY;
       }
 
-      AdvancedCache cache = getCache(regionConfig.getRegionName(), dataType);
+      AdvancedCache cache = getCache(qualify(regionConfig.getRegionName()), dataType);
       DomainDataRegionImpl region = new DomainDataRegionImpl(cache, regionConfig, this, getCacheKeysFactory());
       startRegion(region);
       return region;
    }
 
    @Override
    public QueryResultsRegion buildQueryResultsRegion(String regionName, SessionFactoryImplementor sessionFactory) {
-      if ( log.isDebugEnabled() ) {
-         log.debug( "Building query results cache region [" + regionName + "]" );
-      }
+      log.debugf("Building query results cache region [%s]", regionName);
 
-       AdvancedCache cache = getCache(regionName, DataType.QUERY);
+      AdvancedCache cache = getCache(qualify(regionName), DataType.QUERY);
       QueryResultsRegionImpl region = new QueryResultsRegionImpl(cache, regionName, this);
       startRegion(region);
       return region;
    }
 
    @Override
    public TimestampsRegion buildTimestampsRegion(String regionName, SessionFactoryImplementor sessionFactory) {
-      if ( log.isDebugEnabled() ) {
-         log.debug( "Building timestamps cache region [" + regionName + "]" );
-      }
-      final AdvancedCache cache = getCache(regionName, DataType.TIMESTAMPS);
-      TimestampsRegionImpl region = createTimestampsRegion( cache, regionName );
+      log.debugf("Building timestamps cache region [%s]", regionName);
+
+      final AdvancedCache cache = getCache(qualify(regionName), DataType.TIMESTAMPS);
+      TimestampsRegionImpl region = createTimestampsRegion(cache, regionName);
       startRegion(region);
       return region;
    }
@@ -427,17 +421,17 @@ private void defineDataTypeCacheConfigurations(ServiceRegistry serviceRegistry)
       }
    }
 
-   protected AdvancedCache getCache(String regionName, DataType type) {
-      if (!manager.cacheExists(regionName)) {
-         String templateCacheName = baseConfigurations.get(regionName);
+   protected AdvancedCache getCache(String cacheName, DataType type) {
+      if (!manager.cacheExists(cacheName)) {
+         String templateCacheName = baseConfigurations.get(cacheName);
          Configuration configuration = null;
          ConfigurationBuilder builder = new ConfigurationBuilder();
          if (templateCacheName != null) {
             configuration = manager.getCacheConfiguration(templateCacheName);
             if (configuration == null) {
-               log.customConfigForRegionNotFound(templateCacheName, regionName, type.key);
+               log.customConfigForRegionNotFound(templateCacheName, cacheName, type.key);
             } else {
-               log.debugf("Region '%s' will use cache template '%s'", regionName, templateCacheName);
+               log.debugf("Region '%s' will use cache template '%s'", cacheName, templateCacheName);
                builder.read(configuration);
                unsetTransactions(builder);
                // do not apply data type overrides to regions that set special cache configuration
@@ -451,19 +445,19 @@ protected AdvancedCache getCache(String regionName, DataType type) {
             builder.read(configuration);
             // overrides for data types are already applied, but we should check custom ones
          }
-         ConfigurationBuilder override = configOverrides.get(regionName);
+         ConfigurationBuilder override = configOverrides.get(cacheName);
          if (override != null) {
-            log.debugf("Region '%s' has additional configuration set through properties.", regionName);
+            log.debugf("Region '%s' has additional configuration set through properties.", cacheName);
             builder.read(override.build(false));
          }
          if (globalStats != null) {
             builder.jmxStatistics().enabled(globalStats).available(globalStats);
          }
          configuration = builder.build();
          type.validate(configuration);
-         manager.defineConfiguration(regionName, configuration);
+         manager.defineConfiguration(cacheName, configuration);
       }
-      final AdvancedCache cache = manager.getCache( regionName ).getAdvancedCache();
+      final AdvancedCache cache = manager.getCache( cacheName ).getAdvancedCache();
       // TODO: not sure if this is needed in recent Infinispan
       if ( !cache.getStatus().allowInvocations() ) {
          cache.start();

hibernate/cache-v53/src/main/java/org/infinispan/hibernate/cache/v53/impl/DomainDataRegionImpl.java

@@ -79,10 +79,9 @@ protected enum Strategy {
       NONE, VALIDATION, TOMBSTONES, VERSIONED_ENTRIES
    }
 
-   public DomainDataRegionImpl(
-         AdvancedCache cache, DomainDataRegionConfig config,
-         InfinispanRegionFactory factory, CacheKeysFactory cacheKeysFactory) {
-      super( cache, config.getRegionName(), factory);
+   public DomainDataRegionImpl(AdvancedCache cache, DomainDataRegionConfig config,
+                               InfinispanRegionFactory factory, CacheKeysFactory cacheKeysFactory) {
+      super(cache, config.getRegionName(), factory);
       this.config = config;
       this.cacheKeysFactory = cacheKeysFactory;
 

hibernate/cache-v53/src/main/java/org/infinispan/hibernate/cache/v53/impl/QueryResultsRegionImpl.java

@@ -61,7 +61,7 @@ public void clear() throws CacheException {
       transactionContext.clear();
       // Invalidate the local region and then go remote
       invalidateRegion();
-      Caches.broadcastEvictAll( cache );
+      Caches.broadcastEvictAll(cache);
    }
 
    @Override

hibernate/cache-v53/src/test/java/org/infinispan/test/hibernate/cache/v53/util/TestInfinispanRegionFactory.java

@@ -66,8 +66,8 @@ protected EmbeddedCacheManager createCacheManager(Properties properties, Service
    }
 
    @Override
-   protected AdvancedCache getCache(String regionName, DataType type) {
-      AdvancedCache cache = super.getCache(regionName, type);
+   protected AdvancedCache getCache(String cacheName, DataType type) {
+      AdvancedCache cache = super.getCache(cacheName, type);
       return wrapCache == null ? cache : wrapCache.apply(cache);
    }
 

hibernate/cache-v53/src/test/java/org/infinispan/test/hibernate/cache/v53/util/TestSessionAccessImpl.java

@@ -6,6 +6,7 @@
 import org.hibernate.boot.spi.SessionFactoryOptions;
 import org.hibernate.cache.CacheException;
 import org.hibernate.cache.cfg.spi.DomainDataCachingConfig;
+import org.hibernate.cache.spi.CacheImplementor;
 import org.hibernate.cache.spi.DirectAccessRegion;
 import org.hibernate.cache.spi.access.AccessType;
 import org.hibernate.cache.spi.access.CachedDomainDataAccess;
@@ -42,7 +43,9 @@
 
 import java.sql.Connection;
 import java.sql.SQLException;
+import java.util.Collection;
 import java.util.List;
+import java.util.stream.Collectors;
 
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
@@ -193,6 +196,14 @@ public InfinispanBaseRegion getRegion(SessionFactoryImplementor sessionFactory,
       return (InfinispanBaseRegion) sessionFactory.getCache().getRegion(regionName);
    }
 
+   @Override
+   public Collection<InfinispanBaseRegion> getAllRegions(SessionFactoryImplementor sessionFactory) {
+      CacheImplementor cache = sessionFactory.getCache();
+      return cache.getCacheRegionNames().stream()
+            .map(regionName -> (InfinispanBaseRegion) cache.getRegion(regionName))
+            .collect(Collectors.toList());
+   }
+
    private static SharedSessionContractImplementor unwrap(Object session) {
       return (SharedSessionContractImplementor) session;
    }