Author: steve.ebersole(a)jboss.com Date: 2007-07-24 16:34:07 -0400 (Tue, 24 Jul 2007) New Revision: 12811 Added: core/trunk/cache-jbosscache2/src/main/java/org/ core/trunk/cache-jbosscache2/src/main/java/org/hibernate/ core/trunk/cache-jbosscache2/src/main/java/org/hibernate/cache/ core/trunk/cache-jbosscache2/src/main/java/org/hibernate/cache/jbc2/ core/trunk/cache-jbosscache2/src/main/java/org/hibernate/cache/jbc2/BasicRegionAdapter.java core/trunk/cache-jbosscache2/src/main/java/org/hibernate/cache/jbc2/CacheInstanceManager.java core/trunk/cache-jbosscache2/src/main/java/org/hibernate/cache/jbc2/JBossCacheRegionFactory.java core/trunk/cache-jbosscache2/src/main/java/org/hibernate/cache/jbc2/builder/ core/trunk/cache-jbosscache2/src/main/java/org/hibernate/cache/jbc2/builder/InvalidationCacheInstanceManager.java core/trunk/cache-jbosscache2/src/main/java/org/hibernate/cache/jbc2/builder/MultiplexingCacheInstanceManager.java core/trunk/cache-jbosscache2/src/main/java/org/hibernate/cache/jbc2/entity/ core/trunk/cache-jbosscache2/src/main/java/org/hibernate/cache/jbc2/entity/EntityRegionImpl.java core/trunk/cache-jbosscache2/src/main/java/org/hibernate/cache/jbc2/entity/ReadOnlyAccess.java Log: partial jbosscache2.x support Added: core/trunk/cache-jbosscache2/src/main/java/org/hibernate/cache/jbc2/BasicRegionAdapter.java =================================================================== --- core/trunk/cache-jbosscache2/src/main/java/org/hibernate/cache/jbc2/BasicRegionAdapter.java (rev 0) +++ core/trunk/cache-jbosscache2/src/main/java/org/hibernate/cache/jbc2/BasicRegionAdapter.java 2007-07-24 20:34:07 UTC (rev 12811) @@ -0,0 +1,138 @@ +/* + * Copyright (c) 2007, Red Hat Middleware, LLC. All rights reserved. + * + * This copyrighted material is made available to anyone wishing to use, modify, + * copy, or redistribute it subject to the terms and conditions of the GNU + * Lesser General Public License, v. 2.1. This program is distributed in the + * hope that it will be useful, but WITHOUT A WARRANTY; without even the implied + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. You should have received a + * copy of the GNU Lesser General Public License, v.2.1 along with this + * distribution; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * Red Hat Author(s): Steve Ebersole + */ +package org.hibernate.cache.jbc2; + +import java.util.HashMap; +import java.util.Map; +import java.util.Set; + +import org.jboss.cache.Cache; +import org.jboss.cache.Fqn; +import org.jboss.cache.config.Option; + +import org.hibernate.cache.CacheException; +import org.hibernate.cache.Region; + +/** + * General support for writing {@link Region} implementations for + * + * + * @author Steve Ebersole + */ +public abstract class BasicRegionAdapter implements Region { + public static final String ITEM = "item"; + + protected final Cache jbcCache; + protected final String regionName; + protected final Fqn regionFqn; + + public BasicRegionAdapter(Cache jbcCache, String regionName) { + this.jbcCache = jbcCache; + this.regionName = regionName; + this.regionFqn = Fqn.fromString( regionName.replace( '.', '/' ) ); + activateLocalClusterNode(); + } + + private void activateLocalClusterNode() { + org.jboss.cache.Region jbcRegion = jbcCache.getRegion( regionFqn, true ); + if ( jbcRegion.isActive() ) { + return; + } + ClassLoader classLoader = Thread.currentThread().getContextClassLoader(); + if ( classLoader == null ) { + classLoader = getClass().getClassLoader(); + } + jbcRegion.registerContextClassLoader( classLoader ); + jbcRegion.activate(); + } + + public String getName() { + return regionName; + } + + public void destroy() throws CacheException { + try { + // NOTE : this is being used from the process of shutting down a + // SessionFactory. Specific things to consider: + // (1) this clearing of the region should not propogate to + // other nodes on the cluster (if any); this is the + // cache-mode-local option bit... + // (2) really just trying a best effort to cleanup after + // ourselves; lock failures, etc are not critical here; + // this is the fail-silently option bit... + Option option = new Option(); + option.setCacheModeLocal( true ); + option.setFailSilently( true ); + jbcCache.getInvocationContext().setOptionOverrides( option ); + jbcCache.removeNode( regionFqn ); + deactivateLocalNode(); + } + catch( Exception e ) { + throw new CacheException( e ); + } + } + + private void deactivateLocalNode() { + org.jboss.cache.Region jbcRegion = jbcCache.getRegion( regionFqn, false ); + if ( jbcRegion != null && jbcRegion.isActive() ) { + jbcRegion.deactivate(); + jbcRegion.unregisterContextClassLoader(); + } + } + + public long getSizeInMemory() { + // not supported + return -1; + } + + public long getElementCountInMemory() { + try { + Set children = jbcCache.getRoot().getChild( regionFqn ).getChildrenNames(); + return children == null ? 0 : children.size(); + } + catch ( Exception e ) { + throw new CacheException( e ); + } + } + + public long getElementCountOnDisk() { + return -1; + } + + public Map toMap() { + try { + Map result = new HashMap(); + Set childrenNames = jbcCache.getRoot().getChild( regionFqn ).getChildrenNames(); + if (childrenNames != null) { + for ( Object childName : childrenNames ) { + result.put( childName, jbcCache.get( new Fqn( regionFqn, childName ), ITEM ) ); + } + } + return result; + } + catch (Exception e) { + throw new CacheException(e); + } + } + + public long nextTimestamp() { + return System.currentTimeMillis() / 100; + } + + public int getTimeout() { + return 600; //60 seconds + } +} Added: core/trunk/cache-jbosscache2/src/main/java/org/hibernate/cache/jbc2/CacheInstanceManager.java =================================================================== --- core/trunk/cache-jbosscache2/src/main/java/org/hibernate/cache/jbc2/CacheInstanceManager.java (rev 0) +++ core/trunk/cache-jbosscache2/src/main/java/org/hibernate/cache/jbc2/CacheInstanceManager.java 2007-07-24 20:34:07 UTC (rev 12811) @@ -0,0 +1,62 @@ +/* + * Copyright (c) 2007, Red Hat Middleware, LLC. All rights reserved. + * + * This copyrighted material is made available to anyone wishing to use, modify, + * copy, or redistribute it subject to the terms and conditions of the GNU + * Lesser General Public License, v. 2.1. This program is distributed in the + * hope that it will be useful, but WITHOUT A WARRANTY; without even the implied + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. You should have received a + * copy of the GNU Lesser General Public License, v.2.1 along with this + * distribution; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * Red Hat Author(s): Steve Ebersole + */ +package org.hibernate.cache.jbc2; + +import org.jboss.cache.Cache; + +/** + * Acts as a buffer from how instances of {@link Cache} are built/obtained. + * + * @author Steve Ebersole + */ +public interface CacheInstanceManager { + /** + * Retrieve a handle to the {@link Cache} instance to be used for storing + * entity data. + * + * @return The entity data cache instance. + */ + public Cache getEntityCacheInstance(); + + /** + * Retrieve a handle to the {@link Cache} instance to be used for storing + * collection data. + * + * @return The collection data cache instance. + */ + public Cache getCollectionCacheInstance(); + + /** + * Retrieve a handle to the {@link Cache} instance to be used for storing + * query results. + * + * @return The query result cache instance. + */ + public Cache getQueryCacheInstance(); + + /** + * Retrieve a handle to the {@link Cache} instance to be used for storing + * timestamps. + * + * @return The timestamps cache instance. + */ + public Cache getTimestampsCacheInstance(); + + /** + * Release any held resources. + */ + public void release(); +} Added: core/trunk/cache-jbosscache2/src/main/java/org/hibernate/cache/jbc2/JBossCacheRegionFactory.java =================================================================== --- core/trunk/cache-jbosscache2/src/main/java/org/hibernate/cache/jbc2/JBossCacheRegionFactory.java (rev 0) +++ core/trunk/cache-jbosscache2/src/main/java/org/hibernate/cache/jbc2/JBossCacheRegionFactory.java 2007-07-24 20:34:07 UTC (rev 12811) @@ -0,0 +1,88 @@ +/* + * Copyright (c) 2007, Red Hat Middleware, LLC. All rights reserved. + * + * This copyrighted material is made available to anyone wishing to use, modify, + * copy, or redistribute it subject to the terms and conditions of the GNU + * Lesser General Public License, v. 2.1. This program is distributed in the + * hope that it will be useful, but WITHOUT A WARRANTY; without even the implied + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. You should have received a + * copy of the GNU Lesser General Public License, v.2.1 along with this + * distribution; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * Red Hat Author(s): Steve Ebersole + */ +package org.hibernate.cache.jbc2; + +import java.util.Properties; + +import org.hibernate.cache.CacheDataDescription; +import org.hibernate.cache.CacheException; +import org.hibernate.cache.CollectionRegion; +import org.hibernate.cache.EntityRegion; +import org.hibernate.cache.QueryResultsRegion; +import org.hibernate.cache.RegionFactory; +import org.hibernate.cache.TimestampsRegion; +import org.hibernate.cache.jbc2.builder.InvalidationCacheInstanceManager; +import org.hibernate.cache.jbc2.entity.EntityRegionImpl; +import org.hibernate.cfg.Settings; + +/** + * {@inheritDoc} + * + * @author Steve Ebersole + */ +public class JBossCacheRegionFactory implements RegionFactory { + private CacheInstanceManager cacheInstanceManager; + + public JBossCacheRegionFactory() { + } + + public JBossCacheRegionFactory(CacheInstanceManager cacheInstanceManager) { + this.cacheInstanceManager = cacheInstanceManager; + } + + public void start(Settings settings, Properties properties) throws CacheException { + if ( cacheInstanceManager == null ) { + cacheInstanceManager = new InvalidationCacheInstanceManager( settings, properties ); + } + } + + public void stop() { + if ( cacheInstanceManager != null ) { + cacheInstanceManager.release(); + } + } + + public boolean isMinimalPutsEnabledByDefault() { + return true; + } + + public long nextTimestamp() { + return System.currentTimeMillis() / 100; + } + + public EntityRegion buildEntityRegion( + String regionName, + Properties properties, + CacheDataDescription metadata) throws CacheException { + return new EntityRegionImpl( cacheInstanceManager.getEntityCacheInstance(), regionName, metadata ); + } + + public CollectionRegion buildCollectionRegion( + String regionName, + Properties properties, + CacheDataDescription metadata) throws CacheException { + return null; + } + + public QueryResultsRegion buildQueryResultsRegion(String regionName, Properties properties) throws CacheException { + return null; + } + + public TimestampsRegion buildTimestampsRegion(String regionName, Properties properties) throws CacheException { + return null; + } + +} Added: core/trunk/cache-jbosscache2/src/main/java/org/hibernate/cache/jbc2/builder/InvalidationCacheInstanceManager.java =================================================================== --- core/trunk/cache-jbosscache2/src/main/java/org/hibernate/cache/jbc2/builder/InvalidationCacheInstanceManager.java (rev 0) +++ core/trunk/cache-jbosscache2/src/main/java/org/hibernate/cache/jbc2/builder/InvalidationCacheInstanceManager.java 2007-07-24 20:34:07 UTC (rev 12811) @@ -0,0 +1,103 @@ +/* + * Copyright (c) 2007, Red Hat Middleware, LLC. All rights reserved. + * + * This copyrighted material is made available to anyone wishing to use, modify, + * copy, or redistribute it subject to the terms and conditions of the GNU + * Lesser General Public License, v. 2.1. This program is distributed in the + * hope that it will be useful, but WITHOUT A WARRANTY; without even the implied + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. You should have received a + * copy of the GNU Lesser General Public License, v.2.1 along with this + * distribution; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * Red Hat Author(s): Steve Ebersole + */ +package org.hibernate.cache.jbc2.builder; + +import java.util.Properties; + +import javax.transaction.TransactionManager; + +import org.jboss.cache.Cache; +import org.jboss.cache.DefaultCacheFactory; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +import org.hibernate.util.PropertiesHelper; +import org.hibernate.cache.jbc2.CacheInstanceManager; +import org.hibernate.cfg.Settings; + +/** + * A {@link org.hibernate.cache.jbc2.CacheInstanceManager} implementation where we use a single cache instance + * we assume to be configured for invalidation if operating on a cluster. Under that + * assumption, we can store all data into the same {@link Cache} instance. + * + * @author Steve Ebersole + */ +public class InvalidationCacheInstanceManager implements CacheInstanceManager { + public static final String CACHE_RESOURCE_PROP = "hibernate.cache.region.jbc2.cfg.invalidation"; + public static final String DEFAULT_CACHE_RESOURCE = "treecache.xml"; + + private static final Log log = LogFactory.getLog( InvalidationCacheInstanceManager.class ); + + private final Cache cache; + + public InvalidationCacheInstanceManager(Settings settings, Properties properties) { + String configResource = PropertiesHelper.getString( CACHE_RESOURCE_PROP, properties, DEFAULT_CACHE_RESOURCE ); + cache = DefaultCacheFactory.getInstance().createCache( configResource, false ); + if ( settings.getTransactionManagerLookup() != null ) { + TransactionManager tm = settings.getTransactionManagerLookup().getTransactionManager( properties ); + if ( tm != null ) { + cache.getConfiguration().getRuntimeConfig().setTransactionManager( tm ); + } + } + cache.start(); + } + + public InvalidationCacheInstanceManager(Cache cache) { + this.cache = cache; + } + + /** + * {@inheritDoc} + */ + public Cache getEntityCacheInstance() { + return cache; + } + + /** + * {@inheritDoc} + */ + public Cache getCollectionCacheInstance() { + return cache; + } + + /** + * {@inheritDoc} + */ + public Cache getQueryCacheInstance() { + return cache; + } + + /** + * {@inheritDoc} + */ + public Cache getTimestampsCacheInstance() { + return cache; + } + + /** + * {@inheritDoc} + */ + public void release() { + if ( cache != null ) { + try { + cache.stop(); + } + catch( Throwable t ) { + log.warn( "Unable to stop cache instance", t ); + } + } + } +} Added: core/trunk/cache-jbosscache2/src/main/java/org/hibernate/cache/jbc2/builder/MultiplexingCacheInstanceManager.java =================================================================== --- core/trunk/cache-jbosscache2/src/main/java/org/hibernate/cache/jbc2/builder/MultiplexingCacheInstanceManager.java (rev 0) +++ core/trunk/cache-jbosscache2/src/main/java/org/hibernate/cache/jbc2/builder/MultiplexingCacheInstanceManager.java 2007-07-24 20:34:07 UTC (rev 12811) @@ -0,0 +1,204 @@ +/* + * Copyright (c) 2007, Red Hat Middleware, LLC. All rights reserved. + * + * This copyrighted material is made available to anyone wishing to use, modify, + * copy, or redistribute it subject to the terms and conditions of the GNU + * Lesser General Public License, v. 2.1. This program is distributed in the + * hope that it will be useful, but WITHOUT A WARRANTY; without even the implied + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. You should have received a + * copy of the GNU Lesser General Public License, v.2.1 along with this + * distribution; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * Red Hat Author(s): Steve Ebersole + */ +package org.hibernate.cache.jbc2.builder; + +import java.util.Properties; +import javax.transaction.TransactionManager; + +import org.jboss.cache.Cache; +import org.jboss.cache.DefaultCacheFactory; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +import org.hibernate.cache.CacheException; +import org.hibernate.cache.jbc2.CacheInstanceManager; +import org.hibernate.cfg.Settings; +import org.hibernate.util.PropertiesHelper; + +/** + * Here we build separate {@link Cache} instances for each type of region, but + * using the jgroups multiplexer under the covers to re-use the same group comm + * stack. + * + * @author Steve Ebersole + */ +public class MultiplexingCacheInstanceManager implements CacheInstanceManager { + public static final String ENTITY_CACHE_RESOURCE_PROP = "hibernate.cache.region.jbc2.cfg.entity"; + public static final String COLL_CACHE_RESOURCE_PROP = "hibernate.cache.region.jbc2.cfg.collection"; + public static final String TS_CACHE_RESOURCE_PROP = "hibernate.cache.region.jbc2.cfg.ts"; + public static final String QUERY_CACHE_RESOURCE_PROP = "hibernate.cache.region.jbc2.cfg.query"; + + public static final String DEF_ENTITY_RESOURCE = "entity-cache.xml"; + public static final String DEF_COLL_RESOURCE = "collection-cache.xml"; + public static final String DEF_TS_RESOURCE = "ts-cache.xml"; + public static final String DEF_QUERY_RESOURCE = "query-cache.xml"; + + public static final String OPTIMISTIC_LOCKING_SCHEME = "OPTIMISTIC"; + + private static final Log log = LogFactory.getLog( MultiplexingCacheInstanceManager.class ); + + private final Cache jbcEntityCache; + private final Cache jbcCollectionCache; + private final Cache jbcTsCache; + private final Cache jbcQueryCache; + + public MultiplexingCacheInstanceManager(Settings settings, Properties properties) { + try { + TransactionManager tm = settings.getTransactionManagerLookup() == null + ? null + : settings.getTransactionManagerLookup().getTransactionManager( properties ); + if ( settings.isSecondLevelCacheEnabled() ) { + jbcEntityCache = buildEntityRegionCacheInstance( properties ); + jbcCollectionCache = buildCollectionRegionCacheInstance( properties ); + if ( tm != null ) { + jbcEntityCache.getConfiguration().getRuntimeConfig().setTransactionManager( tm ); + jbcCollectionCache.getConfiguration().getRuntimeConfig().setTransactionManager( tm ); + } + } + else { + jbcEntityCache = null; + jbcCollectionCache = null; + } + if ( settings.isQueryCacheEnabled() ) { + jbcTsCache = buildTsRegionCacheInstance( properties ); + jbcQueryCache = buildQueryRegionCacheInstance( properties ); + } + else { + jbcTsCache = null; + jbcQueryCache = null; + } + } + catch( CacheException ce ) { + throw ce; + } + catch( Throwable t ) { + throw new CacheException( "Unable to start region factory", t ); + } + } + + public MultiplexingCacheInstanceManager(Cache jbcEntityCache, Cache jbcCollectionCache, Cache jbcTsCache, Cache jbcQueryCache) { + this.jbcEntityCache = jbcEntityCache; + this.jbcCollectionCache = jbcCollectionCache; + this.jbcTsCache = jbcTsCache; + this.jbcQueryCache = jbcQueryCache; + } + + protected Cache buildEntityRegionCacheInstance(Properties properties) { + try { + String configResource = PropertiesHelper.getString( ENTITY_CACHE_RESOURCE_PROP, properties, DEF_ENTITY_RESOURCE ); + return DefaultCacheFactory.getInstance().createCache( configResource ); + } + catch( Throwable t ) { + throw new CacheException( "unable to build entity region cache instance", t ); + } + } + + protected Cache buildCollectionRegionCacheInstance(Properties properties) { + try { + String configResource = PropertiesHelper.getString( COLL_CACHE_RESOURCE_PROP, properties, DEF_COLL_RESOURCE ); + return DefaultCacheFactory.getInstance().createCache( configResource ); + } + catch( Throwable t ) { + throw new CacheException( "unable to build collection region cache instance", t ); + } + } + + protected Cache buildTsRegionCacheInstance(Properties properties) { + try { + String configResource = PropertiesHelper.getString( TS_CACHE_RESOURCE_PROP, properties, DEF_TS_RESOURCE ); + return DefaultCacheFactory.getInstance().createCache( configResource ); + } + catch( Throwable t ) { + throw new CacheException( "unable to build timestamps region cache instance", t ); + } + } + + protected Cache buildQueryRegionCacheInstance(Properties properties) { + try { + String configResource = PropertiesHelper.getString( QUERY_CACHE_RESOURCE_PROP, properties, DEF_QUERY_RESOURCE ); + return DefaultCacheFactory.getInstance().createCache( configResource ); + } + catch( Throwable t ) { + throw new CacheException( "unable to build query region cache instance", t ); + } + } + + /** + * {@inheritDoc} + */ + public Cache getEntityCacheInstance() { + return jbcEntityCache; + } + + /** + * {@inheritDoc} + */ + public Cache getCollectionCacheInstance() { + return jbcCollectionCache; + } + + /** + * {@inheritDoc} + */ + public Cache getQueryCacheInstance() { + return jbcQueryCache; + } + + /** + * {@inheritDoc} + */ + public Cache getTimestampsCacheInstance() { + return jbcTsCache; + } + + /** + * {@inheritDoc} + */ + public void release() { + if ( jbcEntityCache != null ) { + try { + jbcEntityCache.stop(); + } + catch( Throwable t ) { + log.info( "Unable to stop entity cache instance", t ); + } + } + if ( jbcCollectionCache != null ) { + try { + jbcCollectionCache.stop(); + } + catch( Throwable t ) { + log.info( "Unable to stop collection cache instance", t ); + } + } + if ( jbcTsCache != null ) { + try { + jbcTsCache.stop(); + } + catch( Throwable t ) { + log.info( "Unable to stop timestamp cache instance", t ); + } + } + if ( jbcQueryCache != null ) { + try { + jbcQueryCache.stop(); + } + catch( Throwable t ) { + log.info( "Unable to stop query cache instance", t ); + } + } + } +} Added: core/trunk/cache-jbosscache2/src/main/java/org/hibernate/cache/jbc2/entity/EntityRegionImpl.java =================================================================== --- core/trunk/cache-jbosscache2/src/main/java/org/hibernate/cache/jbc2/entity/EntityRegionImpl.java (rev 0) +++ core/trunk/cache-jbosscache2/src/main/java/org/hibernate/cache/jbc2/entity/EntityRegionImpl.java 2007-07-24 20:34:07 UTC (rev 12811) @@ -0,0 +1,78 @@ +/* + * Copyright (c) 2007, Red Hat Middleware, LLC. All rights reserved. + * + * This copyrighted material is made available to anyone wishing to use, modify, + * copy, or redistribute it subject to the terms and conditions of the GNU + * Lesser General Public License, v. 2.1. This program is distributed in the + * hope that it will be useful, but WITHOUT A WARRANTY; without even the implied + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. You should have received a + * copy of the GNU Lesser General Public License, v.2.1 along with this + * distribution; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * Red Hat Author(s): Steve Ebersole + */ +package org.hibernate.cache.jbc2.entity; + +import org.jboss.cache.Cache; +import org.jboss.cache.Fqn; + +import org.hibernate.cache.CacheDataDescription; +import org.hibernate.cache.CacheException; +import org.hibernate.cache.EntityRegion; +import org.hibernate.cache.access.AccessType; +import org.hibernate.cache.access.EntityRegionAccessStrategy; +import org.hibernate.cache.jbc2.BasicRegionAdapter; + + +/** + * Defines the behavior of the entity cache regions for JBossCache. + * + * @author Steve Ebersole + */ +public class EntityRegionImpl extends BasicRegionAdapter implements EntityRegion { + private final CacheDataDescription metadata; + + public EntityRegionImpl(Cache jbcCache, String regionName, CacheDataDescription metadata) { + super( jbcCache, regionName ); + this.metadata = metadata; + } + + /** + * {@inheritDoc} + */ + public EntityRegionAccessStrategy buildAccessStrategy(AccessType accessType) throws CacheException { + // todo : allow the other strategies, which will require a non-transactional cache instance + if ( ! ( AccessType.READ_ONLY.equals( accessType ) || AccessType.TRANSACTIONAL.equals( accessType ) ) ) { + throw new CacheException( + "TreeCacheRegionFactory only supports " + AccessType.READ_ONLY.getName() + " or " + + AccessType.TRANSACTIONAL + " access strategies [" + accessType.getName() + "]" + ); + } + return null; + } + + /** + * Here, for JBossCache, we consider the cache to be transaction aware if the underlying + * cache instance has a refernece to the transaction manager. + */ + public boolean isTransactionAware() { + return jbcCache.getConfiguration().getRuntimeConfig().getTransactionManager() != null; + } + + /** + * {@inheritDoc} + */ + public CacheDataDescription getCacheDataDescription() { + return metadata; + } + + Cache getCacheInstance() { + return jbcCache; + } + + Fqn getRegionFqn() { + return regionFqn; + } +} Added: core/trunk/cache-jbosscache2/src/main/java/org/hibernate/cache/jbc2/entity/ReadOnlyAccess.java =================================================================== --- core/trunk/cache-jbosscache2/src/main/java/org/hibernate/cache/jbc2/entity/ReadOnlyAccess.java (rev 0) +++ core/trunk/cache-jbosscache2/src/main/java/org/hibernate/cache/jbc2/entity/ReadOnlyAccess.java 2007-07-24 20:34:07 UTC (rev 12811) @@ -0,0 +1,157 @@ +/* + * Copyright (c) 2007, Red Hat Middleware, LLC. All rights reserved. + * + * This copyrighted material is made available to anyone wishing to use, modify, + * copy, or redistribute it subject to the terms and conditions of the GNU + * Lesser General Public License, v. 2.1. This program is distributed in the + * hope that it will be useful, but WITHOUT A WARRANTY; without even the implied + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. You should have received a + * copy of the GNU Lesser General Public License, v.2.1 along with this + * distribution; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * Red Hat Author(s): Steve Ebersole + */ +package org.hibernate.cache.jbc2.entity; + +import org.jboss.cache.Fqn; +import org.jboss.cache.lock.TimeoutException; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +import org.hibernate.cache.access.EntityRegionAccessStrategy; +import org.hibernate.cache.access.SoftLock; +import org.hibernate.cache.EntityRegion; +import org.hibernate.cache.CacheException; + +/** + * {@inheritDoc} + * + * @author Steve Ebersole + */ +public class ReadOnlyAccess implements EntityRegionAccessStrategy { + private static final Log log = LogFactory.getLog( ReadOnlyAccess.class ); + + private final EntityRegionImpl region; + + public ReadOnlyAccess(EntityRegionImpl region) { + this.region = region; + } + + public EntityRegion getRegion() { + return region; + } + + public Object get(Object key, long txTimestamp) throws CacheException { + try { + return region.getCacheInstance().get( region.getRegionFqn(), EntityRegionImpl.ITEM ); + } + catch ( Exception e ) { + throw new CacheException( e ); + } + } + + public boolean putFromLoad( + Object key, + Object value, + long txTimestamp, + Object version) throws CacheException { + try { + region.getCacheInstance().putForExternalRead( region.getRegionFqn(), key, value ); + return true; + } + catch ( TimeoutException te) { + //ignore! + log.debug( "ignoring write lock acquisition failure" ); + return false; + } + catch ( Throwable t ) { + throw new CacheException( t ); + } + } + + public boolean putFromLoad( + Object key, + Object value, + long txTimestamp, + Object version, + boolean minimalPutOverride) throws CacheException { + return putFromLoad( key, value, txTimestamp, version ); + } + + public SoftLock lockItem(Object key, Object version) throws CacheException { + throw new UnsupportedOperationException( "Illegal attempt to lock (edit) read only item" ); + } + + public SoftLock lockRegion() throws CacheException { + throw new UnsupportedOperationException( "Illegal attempt to lock (edit) read only region" ); + } + + public void unlockItem(Object key, SoftLock lock) throws CacheException { + log.error( "Illegal attempt to lock (edit) read only item" ); + } + + public void unlockRegion(SoftLock lock) throws CacheException { + log.error( "Illegal attempt to lock (edit) read only region" ); + } + + public boolean insert(Object key, Object value, Object version) throws CacheException { + try { + region.getCacheInstance().put( new Fqn( region.getRegionFqn(), key ), EntityRegionImpl.ITEM, value ); + } + catch (Exception e) { + throw new CacheException(e); + } + return true; + } + + public boolean afterInsert(Object key, Object value, Object version) throws CacheException { + return false; + } + + public boolean update( + Object key, + Object value, + Object currentVersion, + Object previousVersion) throws CacheException { + throw new UnsupportedOperationException( "Illegal attempt to lock (edit) read only item" ); + } + + public boolean afterUpdate( + Object key, + Object value, + Object currentVersion, + Object previousVersion, + SoftLock lock) throws CacheException { + throw new UnsupportedOperationException( "Illegal attempt to lock (edit) read only item" ); + } + + public void remove(Object key) throws CacheException { + try { + region.getCacheInstance().remove( region.getRegionFqn(), key ); + } + catch ( Exception e ) { + throw new CacheException( e ); + } + } + + public void removeAll() throws CacheException { + try { + region.getCacheInstance().removeNode( region.getRegionFqn() ); + } + catch ( Exception e ) { + throw new CacheException( e ); + } + } + + public void evict(Object key) throws CacheException { + } + + public void evictAll() throws CacheException { + } + + public void destroy() { + region.destroy(); + } +}