Hibernate
/
hibernate-orm
mirror of https://github.com/hibernate/hibernate-orm
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[HHH-5552] (Infinispan listener implementations need to load entities and keys using application classloader) A wrapper class now puts the right classloader for listener calls. 

[HHH-5563] (JndiInfinispanRegionFactory creates region with a stopped cache, if region previously existed) A check was added to start the cache if no invocations are allowed any more.


git-svn-id: https://svn.jboss.org/repos/hibernate/core/trunk@20653 1b8cb986-b30d-0410-93ca-fae66ebed9b2
This commit is contained in:
Galder Zamarreno 2010-09-16 17:26:33 +00:00
parent 0088c9f213
commit d587904e98
10 changed files with 564 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
cache-infinispan/src/main/java/org/hibernate/cache/infinispan/InfinispanRegionFactory.java vendored
View File

@ -21,6 +21,7 @@ import org.hibernate.cache.TimestampsRegion;
import org.hibernate.cache.access.AccessType;
import org.hibernate.cache.infinispan.collection.CollectionRegionImpl;
import org.hibernate.cache.infinispan.entity.EntityRegionImpl;
import org.hibernate.cache.infinispan.impl.ClassLoaderAwareCache;
import org.hibernate.cache.infinispan.query.QueryResultsRegionImpl;
import org.hibernate.cache.infinispan.timestamp.TimestampsRegionImpl;
import org.hibernate.cache.infinispan.timestamp.TimestampTypeOverrides;
@ -29,6 +30,7 @@ import org.hibernate.cache.infinispan.util.CacheAdapter;
import org.hibernate.cache.infinispan.util.CacheAdapterImpl;
import org.hibernate.cfg.Settings;
import org.hibernate.util.PropertiesHelper;
import org.infinispan.AdvancedCache;
import org.infinispan.Cache;
import org.infinispan.config.Configuration;
import org.infinispan.manager.DefaultCacheManager;
@ -203,11 +205,19 @@ public class InfinispanRegionFactory implements RegionFactory {
if (log.isDebugEnabled()) log.debug("Building timestamps cache region [" + regionName + "]");
Cache cache = getCache(regionName, TIMESTAMPS_KEY, properties);
CacheAdapter cacheAdapter = CacheAdapterImpl.newInstance(cache);
TimestampsRegionImpl region = new TimestampsRegionImpl(cacheAdapter, regionName, transactionManager, this);
TimestampsRegionImpl region = createTimestampsRegion(cacheAdapter, regionName);
region.start();
return region;
}
protected TimestampsRegionImpl createTimestampsRegion(CacheAdapter cacheAdapter, String regionName) {
return new TimestampsRegionImpl(cacheAdapter, regionName, transactionManager, this);
}
protected TransactionManager getTransactionManager() {
return transactionManager;
}
/**
* {@inheritDoc}
*/
@ -393,7 +403,15 @@ public class InfinispanRegionFactory implements RegionFactory {
manager.defineConfiguration(regionName, templateCacheName, regionCacheCfg);
definedConfigurations.add(regionName);
}
return manager.getCache(regionName);
Cache cache = manager.getCache(regionName);
if (!cache.getStatus().allowInvocations()) {
cache.start();
}
return createCacheWrapper(cache.getAdvancedCache());
}
protected ClassLoaderAwareCache createCacheWrapper(AdvancedCache cache) {
return new ClassLoaderAwareCache(cache, Thread.currentThread().getContextClassLoader());
}
private Configuration configureTransactionManager(Configuration regionOverrides, String templateCacheName, Properties properties) {

170
cache-infinispan/src/main/java/org/hibernate/cache/infinispan/impl/ClassLoaderAwareCache.java vendored Normal file
View File

@ -0,0 +1,170 @@
package org.hibernate.cache.infinispan.impl;
import java.lang.annotation.Annotation;
import java.lang.ref.WeakReference;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.EnumMap;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import org.infinispan.AbstractDelegatingAdvancedCache;
import org.infinispan.AdvancedCache;
import org.infinispan.commands.VisitableCommand;
import org.infinispan.context.InvocationContext;
import org.infinispan.interceptors.base.CommandInterceptor;
import org.infinispan.notifications.Listener;
import org.infinispan.notifications.cachelistener.annotation.CacheEntryActivated;
import org.infinispan.notifications.cachelistener.annotation.CacheEntryCreated;
import org.infinispan.notifications.cachelistener.annotation.CacheEntryEvicted;
import org.infinispan.notifications.cachelistener.annotation.CacheEntryInvalidated;
import org.infinispan.notifications.cachelistener.annotation.CacheEntryLoaded;
import org.infinispan.notifications.cachelistener.annotation.CacheEntryModified;
import org.infinispan.notifications.cachelistener.annotation.CacheEntryPassivated;
import org.infinispan.notifications.cachelistener.annotation.CacheEntryRemoved;
import org.infinispan.notifications.cachelistener.annotation.CacheEntryVisited;
import org.infinispan.notifications.cachelistener.event.Event;
import org.infinispan.stats.Stats;
/**
* @author Paul Ferraro
*/
public class ClassLoaderAwareCache<K, V> extends AbstractDelegatingAdvancedCache<K, V> {
final WeakReference<ClassLoader> classLoaderRef;
public ClassLoaderAwareCache(AdvancedCache<K, V> cache, ClassLoader classLoader) {
super(cache);
this.classLoaderRef = new WeakReference<ClassLoader>(classLoader);
cache.removeInterceptor(ClassLoaderAwareCommandInterceptor.class);
cache.addInterceptor(new ClassLoaderAwareCommandInterceptor(), 0);
}
@Override
public Stats getStats() {
return this.getAdvancedCache().getStats();
}
@Override
public void stop() {
super.stop();
this.classLoaderRef.clear();
}
@Override
public void addListener(Object listener) {
super.addListener(new ClassLoaderAwareListener(listener, this));
}
void setContextClassLoader(final ClassLoader classLoader) {
PrivilegedAction<Void> action = new PrivilegedAction<Void>() {
@Override
public Void run() {
Thread.currentThread().setContextClassLoader(classLoader);
return null;
}
};
AccessController.doPrivileged(action);
}
private class ClassLoaderAwareCommandInterceptor extends CommandInterceptor {
@Override
protected Object handleDefault(InvocationContext ctx, VisitableCommand command) throws Throwable {
ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
ClassLoaderAwareCache.this.setContextClassLoader(ClassLoaderAwareCache.this.classLoaderRef.get());
try {
return super.handleDefault(ctx, command);
}
finally {
ClassLoaderAwareCache.this.setContextClassLoader(classLoader);
}
}
}
static final Map<Class<? extends Annotation>, Event.Type> events = new HashMap<Class<? extends Annotation>, Event.Type>();
static {
events.put(CacheEntryActivated.class, Event.Type.CACHE_ENTRY_ACTIVATED);
events.put(CacheEntryCreated.class, Event.Type.CACHE_ENTRY_CREATED);
events.put(CacheEntryEvicted.class, Event.Type.CACHE_ENTRY_EVICTED);
events.put(CacheEntryInvalidated.class, Event.Type.CACHE_ENTRY_INVALIDATED);
events.put(CacheEntryLoaded.class, Event.Type.CACHE_ENTRY_LOADED);
events.put(CacheEntryModified.class, Event.Type.CACHE_ENTRY_MODIFIED);
events.put(CacheEntryPassivated.class, Event.Type.CACHE_ENTRY_PASSIVATED);
events.put(CacheEntryRemoved.class, Event.Type.CACHE_ENTRY_REMOVED);
events.put(CacheEntryVisited.class, Event.Type.CACHE_ENTRY_VISITED);
}
@Listener
public static class ClassLoaderAwareListener {
private final Object listener;
private final Map<Event.Type, List<Method>> methods = new EnumMap<Event.Type, List<Method>>(Event.Type.class);
private final ClassLoaderAwareCache cache;
public ClassLoaderAwareListener(Object listener, ClassLoaderAwareCache cache) {
this.listener = listener;
this.cache = cache;
for (Method method : listener.getClass().getMethods()) {
for (Map.Entry<Class<? extends Annotation>, Event.Type> entry : events.entrySet()) {
Class<? extends Annotation> annotation = entry.getKey();
if (method.isAnnotationPresent(annotation)) {
List<Method> methods = this.methods.get(entry.getValue());
if (methods == null) {
methods = new LinkedList<Method>();
this.methods.put(entry.getValue(), methods);
}
methods.add(method);
}
}
}
}
@CacheEntryActivated
@CacheEntryCreated
@CacheEntryEvicted
@CacheEntryInvalidated
@CacheEntryLoaded
@CacheEntryModified
@CacheEntryPassivated
@CacheEntryRemoved
@CacheEntryVisited
public void event(Event event) throws Throwable {
List<Method> methods = this.methods.get(event.getType());
if (methods != null) {
ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
ClassLoader visible = (ClassLoader) cache.classLoaderRef.get();
cache.setContextClassLoader(visible);
try {
for (Method method : this.methods.get(event.getType())) {
try {
method.invoke(this.listener, event);
}
catch (InvocationTargetException e) {
throw e.getCause();
}
}
}
finally {
cache.setContextClassLoader(classLoader);
}
}
}
public int hashCode() {
return this.listener.hashCode();
}
public boolean equals(Object object) {
if (object == null) return false;
if (object instanceof ClassLoaderAwareCache.ClassLoaderAwareListener) {
@SuppressWarnings("unchecked")
ClassLoaderAwareListener listener = (ClassLoaderAwareListener) object;
return this.listener.equals(listener.listener);
}
return this.listener.equals(object);
}
}
}

5
cache-infinispan/src/main/java/org/hibernate/cache/infinispan/util/FlagAdapter.java vendored
View File

@ -34,7 +34,8 @@ import org.infinispan.context.Flag;
public enum FlagAdapter {
ZERO_LOCK_ACQUISITION_TIMEOUT,
CACHE_MODE_LOCAL,
FORCE_ASYNCHRONOUS;
FORCE_ASYNCHRONOUS,
FORCE_SYNCHRONOUS;
Flag toFlag() {
switch(this) {
@ -44,6 +45,8 @@ public enum FlagAdapter {
return Flag.CACHE_MODE_LOCAL;
case FORCE_ASYNCHRONOUS:
return Flag.FORCE_ASYNCHRONOUS;
case FORCE_SYNCHRONOUS:
return Flag.FORCE_SYNCHRONOUS;
default:
throw new CacheException("Unmatched Infinispan flag " + this);
}

2
cache-infinispan/src/test/java/org/hibernate/test/cache/infinispan/JndiInfinispanRegionFactoryTestCase.java vendored
View File

@ -9,7 +9,7 @@ import java.util.Properties;
* // TODO: Document this
*
* @author Galder Zamarreño
* @since // TODO
* @since 3.5
*/
public class JndiInfinispanRegionFactoryTestCase extends TestCase {

10
cache-infinispan/src/test/java/org/hibernate/test/cache/infinispan/functional/BasicJdbcTransactionalTestCase.java vendored
View File

@ -107,4 +107,14 @@ public class BasicJdbcTransactionalTestCase extends SingleNodeTestCase {
s.close();
}
}
public void testEmptySecondLevelCacheEntry() throws Exception {
getSessions().getCache().evictEntityRegion(Item.class.getName());
Statistics stats = getSessions().getStatistics();
stats.clear();
SecondLevelCacheStatistics statistics = stats.getSecondLevelCacheStatistics(Item.class.getName() + ".items");
Map cacheEntries = statistics.getEntries();
assertEquals(0, cacheEntries.size());
}
}

14
cache-infinispan/src/test/java/org/hibernate/test/cache/infinispan/functional/BasicReadOnlyTestCase.java vendored
View File

@ -1,5 +1,10 @@
package org.hibernate.test.cache.infinispan.functional;
import org.hibernate.stat.SecondLevelCacheStatistics;
import org.hibernate.stat.Statistics;
import java.util.Map;
/**
* @author Galder Zamarreño
* @since 3.5
@ -15,4 +20,13 @@ public class BasicReadOnlyTestCase extends SingleNodeTestCase {
return "read-only";
}
public void testEmptySecondLevelCacheEntry() throws Exception {
getSessions().getCache().evictEntityRegion(Item.class.getName());
Statistics stats = getSessions().getStatistics();
stats.clear();
SecondLevelCacheStatistics statistics = stats.getSecondLevelCacheStatistics(Item.class.getName() + ".items");
Map cacheEntries = statistics.getEntries();
assertEquals(0, cacheEntries.size());
}
}

10
cache-infinispan/src/test/java/org/hibernate/test/cache/infinispan/functional/BasicTransactionalTestCase.java vendored
View File

@ -340,4 +340,14 @@ public class BasicTransactionalTestCase extends SingleNodeTestCase {
commitOrRollbackTx();
}
}
public void testEmptySecondLevelCacheEntry() throws Exception {
getSessions().getCache().evictEntityRegion(Item.class.getName());
Statistics stats = getSessions().getStatistics();
stats.clear();
SecondLevelCacheStatistics statistics = stats.getSecondLevelCacheStatistics(Item.class.getName() + ".items");
Map cacheEntries = statistics.getEntries();
assertEquals(0, cacheEntries.size());
}
}

180
cache-infinispan/src/test/java/org/hibernate/test/cache/infinispan/functional/JndiRegionFactoryTestCase.java vendored Normal file
View File

@ -0,0 +1,180 @@
package org.hibernate.test.cache.infinispan.functional;
import org.hibernate.Session;
import org.hibernate.cache.RegionFactory;
import org.hibernate.cache.infinispan.InfinispanRegionFactory;
import org.hibernate.cache.infinispan.JndiInfinispanRegionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.cfg.Environment;
import org.hibernate.cfg.Mappings;
import org.hibernate.dialect.Dialect;
import org.hibernate.engine.SessionFactoryImplementor;
import org.hibernate.junit.functional.ExecutionEnvironment;
import org.hibernate.stat.Statistics;
import org.infinispan.Cache;
import org.infinispan.lifecycle.ComponentStatus;
import org.infinispan.manager.DefaultCacheManager;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.util.logging.Log;
import org.infinispan.util.logging.LogFactory;
import org.jboss.util.naming.NonSerializableFactory;
import org.jnp.server.Main;
import org.jnp.server.SingletonNamingServer;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.Name;
import javax.naming.NameNotFoundException;
import javax.naming.Reference;
import javax.naming.StringRefAddr;
import java.util.Properties;
/**
* // TODO: Document this
*
* @author Galder Zamarreño
* @since // TODO
*/
public class JndiRegionFactoryTestCase extends SingleNodeTestCase {
private static final Log log = LogFactory.getLog(JndiRegionFactoryTestCase.class);
private static final String JNDI_NAME = "java:CacheManager";
private Main namingMain;
private SingletonNamingServer namingServer;
private Properties props;
private boolean bindToJndi = true;
private EmbeddedCacheManager manager;
public JndiRegionFactoryTestCase(String string) {
super(string);
}
@Override
protected void cleanupTest() throws Exception {
Context ctx = new InitialContext(props);
unbind(JNDI_NAME, ctx);
namingServer.destroy();
namingMain.stop();
manager.stop(); // Need to stop cos JNDI region factory does not stop it.
}
@Override
protected Class<? extends RegionFactory> getCacheRegionFactory() {
return JndiInfinispanRegionFactory.class;
}
@Override
public void afterConfigurationBuilt(Mappings mappings, Dialect dialect) {
if (bindToJndi) {
try {
// Create an in-memory jndi
namingServer = new SingletonNamingServer();
namingMain = new Main();
namingMain.setInstallGlobalService(true);
namingMain.setPort(-1);
namingMain.start();
props = new Properties();
props.put("java.naming.factory.initial", "org.jnp.interfaces.NamingContextFactory");
props.put("java.naming.factory.url.pkgs", "org.jboss.naming:org.jnp.interfaces");
manager = new DefaultCacheManager(InfinispanRegionFactory.DEF_INFINISPAN_CONFIG_RESOURCE, false);
Context ctx = new InitialContext(props);
bind(JNDI_NAME, manager, EmbeddedCacheManager.class, ctx);
} catch(Exception e) {
throw new RuntimeException("Failure to set up JNDI", e);
}
}
}
@Override
public void configure(Configuration cfg) {
super.configure(cfg);
cfg.setProperty(JndiInfinispanRegionFactory.CACHE_MANAGER_RESOURCE_PROP, JNDI_NAME);
cfg.setProperty(Environment.JNDI_CLASS, "org.jnp.interfaces.NamingContextFactory");
cfg.setProperty("java.naming.factory.url.pkgs", "org.jboss.naming:org.jnp.interfaces");
}
public void testRedeployment() throws Exception {
addEntityCheckCache();
getEnvironment().getSessionFactory().close();
bindToJndi = false;
ExecutionEnvironment environment = new ExecutionEnvironment( this );
environment.initialize();
setEnvironment(environment);
addEntityCheckCache();
JndiInfinispanRegionFactory regionFactory = (JndiInfinispanRegionFactory) ((SessionFactoryImplementor)
environment.getSessionFactory()).getSettings().getRegionFactory();
Cache cache = regionFactory.getCacheManager().getCache("org.hibernate.test.cache.infinispan.functional.Item");
assertEquals(ComponentStatus.RUNNING, cache.getStatus());
}
private void addEntityCheckCache() throws Exception {
Item item = new Item("chris", "Chris's Item");
beginTx();
try {
Session s = openSession();
s.getTransaction().begin();
s.persist(item);
s.getTransaction().commit();
s.close();
} catch (Exception e) {
setRollbackOnlyTx(e);
} finally {
commitOrRollbackTx();
}
beginTx();
try {
Session s = openSession();
Item found = (Item) s.load(Item.class, item.getId());
Statistics stats = s.getSessionFactory().getStatistics();
log.info(stats.toString());
assertEquals(item.getDescription(), found.getDescription());
assertEquals(0, stats.getSecondLevelCacheMissCount());
assertEquals(1, stats.getSecondLevelCacheHitCount());
s.delete(found);
s.close();
} catch (Exception e) {
setRollbackOnlyTx(e);
} finally {
commitOrRollbackTx();
}
}
/**
* Helper method that binds the a non serializable object to the JNDI tree.
*
* @param jndiName Name under which the object must be bound
* @param who Object to bind in JNDI
* @param classType Class type under which should appear the bound object
* @param ctx Naming context under which we bind the object
* @throws Exception Thrown if a naming exception occurs during binding
*/
private void bind(String jndiName, Object who, Class<?> classType, Context ctx) throws Exception {
// Ah ! This service isn't serializable, so we use a helper class
NonSerializableFactory.bind(jndiName, who);
Name n = ctx.getNameParser("").parse(jndiName);
while (n.size() > 1) {
String ctxName = n.get(0);
try {
ctx = (Context) ctx.lookup(ctxName);
} catch (NameNotFoundException e) {
log.debug("creating Subcontext " + ctxName);
ctx = ctx.createSubcontext(ctxName);
}
n = n.getSuffix(1);
}
// The helper class NonSerializableFactory uses address type nns, we go on to
// use the helper class to bind the service object in JNDI
StringRefAddr addr = new StringRefAddr("nns", jndiName);
Reference ref = new Reference(classType.getName(), addr, NonSerializableFactory.class.getName(), null);
ctx.rebind(n.get(0), ref);
}
private void unbind(String jndiName, Context ctx) throws Exception {
NonSerializableFactory.unbind(jndiName);
// ctx.unbind(jndiName);
}
}

9
cache-infinispan/src/test/java/org/hibernate/test/cache/infinispan/functional/SingleNodeTestCase.java vendored
View File

@ -90,15 +90,6 @@ public abstract class SingleNodeTestCase extends FunctionalTestCase {
cfg.setProperty(Environment.TRANSACTION_STRATEGY, getTransactionFactoryClass().getName());
}
public void testEmptySecondLevelCacheEntry() throws Exception {
getSessions().getCache().evictEntityRegion(Item.class.getName());
Statistics stats = getSessions().getStatistics();
stats.clear();
SecondLevelCacheStatistics statistics = stats.getSecondLevelCacheStatistics(Item.class.getName() + ".items");
Map cacheEntries = statistics.getEntries();
assertEquals(0, cacheEntries.size());
}
protected void beginTx() throws Exception {
tm.begin();
}

147
cache-infinispan/src/test/java/org/hibernate/test/cache/infinispan/timestamp/TimestampsRegionImplTestCase.java vendored
View File

@ -27,11 +27,35 @@ import java.util.Properties;
import org.hibernate.cache.CacheDataDescription;
import org.hibernate.cache.Region;
import org.hibernate.cache.RegionFactory;
import org.hibernate.cache.UpdateTimestampsCache;
import org.hibernate.cache.infinispan.InfinispanRegionFactory;
import org.hibernate.cache.infinispan.impl.ClassLoaderAwareCache;
import org.hibernate.cache.infinispan.timestamp.TimestampsRegionImpl;
import org.hibernate.cache.infinispan.util.CacheAdapter;
import org.hibernate.cache.infinispan.util.CacheAdapterImpl;
import org.hibernate.cache.infinispan.util.FlagAdapter;
import org.hibernate.cfg.Configuration;
import org.hibernate.test.cache.infinispan.AbstractGeneralDataRegionTestCase;
import org.hibernate.test.cache.infinispan.functional.classloader.Account;
import org.hibernate.test.cache.infinispan.functional.classloader.AccountHolder;
import org.hibernate.test.cache.infinispan.functional.classloader.SelectedClassnameClassLoader;
import org.hibernate.test.cache.infinispan.util.CacheTestUtil;
import org.infinispan.AdvancedCache;
import org.infinispan.notifications.Listener;
import org.infinispan.notifications.cachelistener.annotation.CacheEntryActivated;
import org.infinispan.notifications.cachelistener.annotation.CacheEntryCreated;
import org.infinispan.notifications.cachelistener.annotation.CacheEntryEvicted;
import org.infinispan.notifications.cachelistener.annotation.CacheEntryInvalidated;
import org.infinispan.notifications.cachelistener.annotation.CacheEntryLoaded;
import org.infinispan.notifications.cachelistener.annotation.CacheEntryModified;
import org.infinispan.notifications.cachelistener.annotation.CacheEntryPassivated;
import org.infinispan.notifications.cachelistener.annotation.CacheEntryRemoved;
import org.infinispan.notifications.cachelistener.annotation.CacheEntryVisited;
import org.infinispan.notifications.cachelistener.event.CacheEntryModifiedEvent;
import org.infinispan.notifications.cachelistener.event.Event;
import javax.transaction.TransactionManager;
/**
* Tests of TimestampsRegionImpl.
@ -60,4 +84,127 @@ public class TimestampsRegionImplTestCase extends AbstractGeneralDataRegionTestC
return CacheAdapterImpl.newInstance(regionFactory.getCacheManager().getCache("timestamps"));
}
public void testClearTimestampsRegionInIsolated() throws Exception {
Configuration cfg = createConfiguration();
InfinispanRegionFactory regionFactory = CacheTestUtil.startRegionFactory(cfg, getCacheTestSupport());
// Sleep a bit to avoid concurrent FLUSH problem
avoidConcurrentFlush();
Configuration cfg2 = createConfiguration();
InfinispanRegionFactory regionFactory2 = CacheTestUtil.startRegionFactory(cfg2, getCacheTestSupport());
// Sleep a bit to avoid concurrent FLUSH problem
avoidConcurrentFlush();
TimestampsRegionImpl region = (TimestampsRegionImpl) regionFactory.buildTimestampsRegion(getStandardRegionName(REGION_PREFIX), cfg.getProperties());
TimestampsRegionImpl region2 = (TimestampsRegionImpl) regionFactory2.buildTimestampsRegion(getStandardRegionName(REGION_PREFIX), cfg2.getProperties());
// QueryResultsRegion region2 = regionFactory2.buildQueryResultsRegion(getStandardRegionName(REGION_PREFIX), cfg2.getProperties());
// ClassLoader cl = Thread.currentThread().getContextClassLoader();
// Thread.currentThread().setContextClassLoader(cl.getParent());
// log.info("TCCL is " + cl.getParent());
Account acct = new Account();
acct.setAccountHolder(new AccountHolder());
region.getCacheAdapter().withFlags(FlagAdapter.FORCE_SYNCHRONOUS).put(acct, "boo");
// region.put(acct, "boo");
//
// region.evictAll();
// Account acct = new Account();
// acct.setAccountHolder(new AccountHolder());
}
@Override
protected Configuration createConfiguration() {
Configuration cfg = CacheTestUtil.buildConfiguration("test", MockInfinispanRegionFactory.class, false, true);
return cfg;
}
public static class MockInfinispanRegionFactory extends InfinispanRegionFactory {
public MockInfinispanRegionFactory() {
}
public MockInfinispanRegionFactory(Properties props) {
super(props);
}
// @Override
// protected TimestampsRegionImpl createTimestampsRegion(CacheAdapter cacheAdapter, String regionName) {
// return new MockTimestampsRegionImpl(cacheAdapter, regionName, getTransactionManager(), this);
// }
@Override
protected ClassLoaderAwareCache createCacheWrapper(AdvancedCache cache) {
return new ClassLoaderAwareCache(cache, Thread.currentThread().getContextClassLoader()) {
@Override
public void addListener(Object listener) {
super.addListener(new MockClassLoaderAwareListener(listener, this));
}
};
}
// @Override
// protected EmbeddedCacheManager createCacheManager(Properties properties) throws CacheException {
// try {
// EmbeddedCacheManager manager = new DefaultCacheManager(InfinispanRegionFactory.DEF_INFINISPAN_CONFIG_RESOURCE);
// org.infinispan.config.Configuration ispnCfg = new org.infinispan.config.Configuration();
// ispnCfg.setCacheMode(org.infinispan.config.Configuration.CacheMode.REPL_SYNC);
// manager.defineConfiguration("timestamps", ispnCfg);
// return manager;
// } catch (IOException e) {
// throw new CacheException("Unable to create default cache manager", e);
// }
// }
@Listener
public static class MockClassLoaderAwareListener extends ClassLoaderAwareCache.ClassLoaderAwareListener {
MockClassLoaderAwareListener(Object listener, ClassLoaderAwareCache cache) {
super(listener, cache);
}
@CacheEntryActivated
@CacheEntryCreated
@CacheEntryEvicted
@CacheEntryInvalidated
@CacheEntryLoaded
@CacheEntryModified
@CacheEntryPassivated
@CacheEntryRemoved
@CacheEntryVisited
public void event(Event event) throws Throwable {
ClassLoader cl = Thread.currentThread().getContextClassLoader();
String notFoundPackage = "org.hibernate.test.cache.infinispan.functional.classloader";
String[] notFoundClasses = { notFoundPackage + ".Account", notFoundPackage + ".AccountHolder" };
SelectedClassnameClassLoader visible = new SelectedClassnameClassLoader(null, null, notFoundClasses, cl);
Thread.currentThread().setContextClassLoader(visible);
super.event(event);
Thread.currentThread().setContextClassLoader(cl);
}
}
}
// @Listener
// public static class MockTimestampsRegionImpl extends TimestampsRegionImpl {
//
// public MockTimestampsRegionImpl(CacheAdapter cacheAdapter, String name, TransactionManager transactionManager, RegionFactory factory) {
// super(cacheAdapter, name, transactionManager, factory);
// }
//
// @CacheEntryModified
// public void nodeModified(CacheEntryModifiedEvent event) {
//// ClassLoader cl = Thread.currentThread().getContextClassLoader();
//// String notFoundPackage = "org.hibernate.test.cache.infinispan.functional.classloader";
//// String[] notFoundClasses = { notFoundPackage + ".Account", notFoundPackage + ".AccountHolder" };
//// SelectedClassnameClassLoader visible = new SelectedClassnameClassLoader(null, null, notFoundClasses, cl);
//// Thread.currentThread().setContextClassLoader(visible);
// super.nodeModified(event);
//// Thread.currentThread().setContextClassLoader(cl);
// }
// }
}