debian/0000755000000000000000000000000011731744270007174 5ustar debian/copyright0000644000000000000000000000105011731466624011127 0ustar The sources where downloaded from https://repository.jboss.org/nexus/content/groups/public-jboss/org/hibernate/hibernate-jbosscache/3.6.8.Final/ Files: * Copyright: © 2007 Red Hat Middleware LLC License: LGPL The full text of the GNU Lesser General Public License is distributed in /usr/share/common-licenses/LGPL-2 on Debian systems. Files: debian/* Copyright: © 2010 Miguel Landaeta License: LGPL The full text of the GNU Lesser General Public License is distributed in /usr/share/common-licenses/LGPL-2 on Debian systems. debian/orig-tar.sh0000755000000000000000000000064611731466624011271 0ustar #!/bin/sh set -e # called by uscan with '--upstream-version' package=`dpkg-parsechangelog | sed -n 's/^Source: //p'` version=$2 tarball=$3 unzip $tarball rm -rf META-INF TAR=../${package}_${version}.orig.tar.gz DIR=${package}-${version}.orig mkdir -p $DIR/src/main/java mv org/* $DIR/src/main/java rmdir org GZIP=--best tar --numeric --group 0 --owner 0 -c -v -z -f $TAR $DIR rm -rf $tarball $DIR debian/classpath0000644000000000000000000000044011731702067011075 0ustar hibernate-jbosscache.jar /usr/share/java/hibernate3.jar /usr/share/java/slf4j-api.jar /usr/share/java/geronimo-jta-1.0.1b-spec.jar /usr/share/java/jboss-cache3.jar /usr/share/java/jboss-system.jar /usr/share/java/jboss-jmx.jar /usr/share/java/jgroups.jar /usr/share/java/jboss-cache1.jar debian/watch0000644000000000000000000000036711731466624010237 0ustar version=3 # This watch file is not perfect. Better ideas are welcome. https://repository.jboss.org/nexus/content/groups/public-jboss/org/hibernate/hibernate-jbosscache/3.6.8.Final/ \ hibernate-jbosscache-(.+)-sources.jar debian debian/orig-tar.sh debian/patches/0000755000000000000000000000000011731703266010623 5ustar debian/patches/series0000644000000000000000000000006511731702354012036 0ustar create-pom-file.patch compatibility-with-3.3.2.patch debian/patches/create-pom-file.patch0000644000000000000000000001771411731466624014633 0ustar Description: Create POM file for project --- /dev/null +++ libhibernate-jbosscache-java-3.6.8.Final/pom.xml @@ -0,0 +1,185 @@ + + + + + 4.0.0 + + + org.hibernate + hibernate-parent + 3.6.8.Final + ../hibernate-parent/pom.xml + + + org.hibernate + hibernate-jbosscache + jar + + Hibernate JBossCache Integration + Integration of Hibernate with JBossCache 3.x (though 2.x sould work as well) + + + + ${project.groupId} + hibernate-core + ${project.version} + + + org.jboss.cache + jbosscache-core + 3.2.1.GA + + + + + ${project.groupId} + hibernate-testing + ${project.version} + test + + + hsqldb + hsqldb + 1.8.0.2 + test + + + + cglib + cglib + test + + + javassist + javassist + test + + + + + + + false + src/test/java + + **/*.xml + + + + true + src/test/resources + + + + + + org.apache.maven.plugins + maven-compiler-plugin + + 1.5 + 1.5 + + + + org.apache.maven.plugins + maven-surefire-plugin + + + + **/ClusteredConcurrentTimestampRegionTestCase.java + + + + hibernate.test.validatefailureexpected + true + + + jgroups.bind_addr + ${jgroups.bind_addr} + + + + java.net.preferIPv4Stack + true + + + + jgroups.ping.timeout + 500 + + + + jgroups.ping.num_initial_members + 1 + + + + jgroups.udp.enable_bundling + false + + + ${skipUnitTests} + + + + + + + true + + 127.0.0.1 + + + + + test + + false + + + false + + + + debian/patches/compatibility-with-3.3.2.patch0000644000000000000000000002571511731703266016141 0ustar Description: Compatibility with 3.3.2.GA jbossas4 package needs these classes to be built. If that package gets removed from the archive, this patch can be dropped. Author: Miguel Landaeta Bug-Debian: http://bugs.debian.org/655775 Forwarded: no Last-Update: 2012-04-19 --- /dev/null +++ libhibernate-jbosscache-java-3.6.8/src/main/java/hibernate/cache/TreeCacheProvider.java @@ -0,0 +1,131 @@ +/* + * Hibernate, Relational Persistence for Idiomatic Java + * + * Copyright (c) 2007, Red Hat Middleware LLC or third-party contributors as + * indicated by the @author tags or express copyright attribution + * statements applied by the authors.  All third-party contributions are + * distributed under license by Red Hat Middleware LLC. + * + * 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, as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY 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 + * along with this distribution; if not, write to: + * Free Software Foundation, Inc. + * 51 Franklin Street, Fifth Floor + * Boston, MA 02110-1301 USA + */ +package org.hibernate.cache; + +import java.util.Properties; +import javax.transaction.TransactionManager; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.hibernate.transaction.TransactionManagerLookup; +import org.hibernate.transaction.TransactionManagerLookupFactory; +import org.hibernate.cfg.Environment; +import org.jboss.cache.PropertyConfigurator; + +/** + * Support for a standalone JBossCache (TreeCache) instance. The JBossCache is configured + * via a local config resource. + * + * @author Gavin King + */ +public class TreeCacheProvider implements CacheProvider { + + /** + * @deprecated use {@link org.hibernate.cfg.Environment#CACHE_PROVIDER_CONFIG} + */ + public static final String CONFIG_RESOURCE = "hibernate.cache.tree_cache.config"; + public static final String DEFAULT_CONFIG = "treecache-optimistic.xml"; + + private static final Logger log = LoggerFactory.getLogger( TreeCacheProvider.class ); + + private org.jboss.cache.TreeCache cache; + private TransactionManager transactionManager; + + /** + * Construct and configure the Cache representation of a named cache region. + * + * @param regionName the name of the cache region + * @param properties configuration settings + * @return The Cache representation of the named cache region. + * @throws CacheException Indicates an error building the cache region. + */ + public Cache buildCache(String regionName, Properties properties) throws CacheException { + return new TreeCache(cache, regionName, transactionManager); + } + + public long nextTimestamp() { + return System.currentTimeMillis() / 100; + } + + /** + * Prepare the underlying JBossCache TreeCache instance. + * + * @param properties All current config settings. + * + * @throws CacheException Indicates a problem preparing cache for use. + */ + public void start(Properties properties) { + String resource = properties.getProperty( Environment.CACHE_PROVIDER_CONFIG ); + + if ( resource == null ) { + resource = properties.getProperty( CONFIG_RESOURCE ); + } + if ( resource == null ) { + resource = DEFAULT_CONFIG; + } + log.debug( "Configuring TreeCache from resource [" + resource + "]" ); + try { + cache = new org.jboss.cache.TreeCache(); + PropertyConfigurator config = new PropertyConfigurator(); + config.configure( cache, resource ); + TransactionManagerLookup transactionManagerLookup = TransactionManagerLookupFactory.getTransactionManagerLookup(properties); + if (transactionManagerLookup!=null) { + cache.setTransactionManagerLookup( new TransactionManagerLookupAdaptor(transactionManagerLookup, properties) ); + transactionManager = transactionManagerLookup.getTransactionManager(properties); + } + cache.start(); + } + catch (Exception e) { + throw new CacheException(e); + } + } + + public void stop() { + if (cache!=null) { + cache.stop(); + cache.destroy(); + cache=null; + } + } + + public boolean isMinimalPutsEnabledByDefault() { + return true; + } + + static final class TransactionManagerLookupAdaptor implements org.jboss.cache.TransactionManagerLookup { + private final TransactionManagerLookup tml; + private final Properties props; + TransactionManagerLookupAdaptor(TransactionManagerLookup tml, Properties props) { + this.tml=tml; + this.props=props; + } + public TransactionManager getTransactionManager() throws Exception { + return tml.getTransactionManager(props); + } + } + + public org.jboss.cache.TreeCache getUnderlyingCache() { + return cache; + } +} --- /dev/null +++ libhibernate-jbosscache-java-3.6.8/src/main/java/hibernate/cache/TreeCache.java @@ -0,0 +1,227 @@ +/* + * Hibernate, Relational Persistence for Idiomatic Java + * + * Copyright (c) 2007, Red Hat Middleware LLC or third-party contributors as + * indicated by the @author tags or express copyright attribution + * statements applied by the authors.  All third-party contributions are + * distributed under license by Red Hat Middleware LLC. + * + * 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, as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY 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 + * along with this distribution; if not, write to: + * Free Software Foundation, Inc. + * 51 Franklin Street, Fifth Floor + * Boston, MA 02110-1301 USA + */ +package org.hibernate.cache; + +import java.util.HashMap; +import java.util.Iterator; +import java.util.Map; +import java.util.Set; + +import javax.transaction.SystemException; +import javax.transaction.Transaction; +import javax.transaction.TransactionManager; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.jboss.cache.Fqn; +import org.jboss.cache.lock.TimeoutException; + +/** + * Represents a particular region within the given JBossCache TreeCache. + * + * @author Gavin King + */ +public class TreeCache implements Cache, TransactionAwareCache { + + private static final Logger log = LoggerFactory.getLogger(TreeCache.class); + + private static final String ITEM = "item"; + + private org.jboss.cache.TreeCache cache; + private final String regionName; + private final Fqn regionFqn; + private final TransactionManager transactionManager; + + public TreeCache(org.jboss.cache.TreeCache cache, String regionName, TransactionManager transactionManager) + throws CacheException { + this.cache = cache; + this.regionName = regionName; + this.regionFqn = Fqn.fromString( regionName.replace( '.', '/' ) ); + this.transactionManager = transactionManager; + } + + public Object get(Object key) throws CacheException { + Transaction tx = suspend(); + try { + return read(key); + } + finally { + resume( tx ); + } + } + + public Object read(Object key) throws CacheException { + try { + return cache.get( new Fqn( regionFqn, key ), ITEM ); + } + catch (Exception e) { + throw new CacheException(e); + } + } + + public void update(Object key, Object value) throws CacheException { + try { + cache.put( new Fqn( regionFqn, key ), ITEM, value ); + } + catch (Exception e) { + throw new CacheException(e); + } + } + + public void put(Object key, Object value) throws CacheException { + Transaction tx = suspend(); + try { + //do the failfast put outside the scope of the JTA txn + cache.putFailFast( new Fqn( regionFqn, key ), ITEM, value, 0 ); + } + catch (TimeoutException te) { + //ignore! + log.debug("ignoring write lock acquisition failure"); + } + catch (Exception e) { + throw new CacheException(e); + } + finally { + resume( tx ); + } + } + + private void resume(Transaction tx) { + try { + if (tx!=null) transactionManager.resume(tx); + } + catch (Exception e) { + throw new CacheException("Could not resume transaction", e); + } + } + + private Transaction suspend() { + Transaction tx = null; + try { + if ( transactionManager!=null ) { + tx = transactionManager.suspend(); + } + } + catch (SystemException se) { + throw new CacheException("Could not suspend transaction", se); + } + return tx; + } + + public void remove(Object key) throws CacheException { + try { + cache.remove( new Fqn( regionFqn, key ) ); + } + catch (Exception e) { + throw new CacheException(e); + } + } + + public void clear() throws CacheException { + try { + cache.remove( regionFqn ); + } + catch (Exception e) { + throw new CacheException(e); + } + } + + public void destroy() throws CacheException { + try { + // NOTE : evict() operates locally only (i.e., does not propogate + // to any other nodes in the potential cluster). This is + // exactly what is needed when we destroy() here; destroy() is used + // as part of the process of shutting down a SessionFactory; thus + // these removals should not be propogated + cache.evict( regionFqn ); + } + catch( Exception e ) { + throw new CacheException( e ); + } + } + + public void lock(Object key) throws CacheException { + throw new UnsupportedOperationException( "TreeCache is a fully transactional cache" + regionName ); + } + + public void unlock(Object key) throws CacheException { + throw new UnsupportedOperationException( "TreeCache is a fully transactional cache: " + regionName ); + } + + public long nextTimestamp() { + return System.currentTimeMillis() / 100; + } + + public int getTimeout() { + return 600; //60 seconds + } + + public String getRegionName() { + return regionName; + } + + public long getSizeInMemory() { + return -1; + } + + public long getElementCountInMemory() { + try { + Set children = cache.getChildrenNames( regionFqn ); + return children == null ? 0 : children.size(); + } + catch (Exception e) { + throw new CacheException(e); + } + } + + public long getElementCountOnDisk() { + return 0; + } + + public Map toMap() { + try { + Map result = new HashMap(); + Set childrenNames = cache.getChildrenNames( regionFqn ); + if (childrenNames != null) { + Iterator iter = childrenNames.iterator(); + while ( iter.hasNext() ) { + Object key = iter.next(); + result.put( + key, + cache.get( new Fqn( regionFqn, key ), ITEM ) + ); + } + } + return result; + } + catch (Exception e) { + throw new CacheException(e); + } + } + + public String toString() { + return "TreeCache(" + regionName + ')'; + } + +} debian/clean0000644000000000000000000000003111731466473010201 0ustar hibernate-jbosscache.jar debian/changelog0000644000000000000000000000301311731706433011042 0ustar libhibernate-jbosscache-java (3.6.8-2) unstable; urgency=low * Add a patch with some classes that were provided by 3.3.2.GA. These classes are reintroduced for compatibility reasons. (Closes: #655775, #661694). * Add Build-Depends on libjboss-cache1-java. * Bump Standards-Version to 3.9.3. No changes were required. -- Miguel Landaeta Mon, 19 Mar 2012 19:51:48 -0430 libhibernate-jbosscache-java (3.6.8-1) unstable; urgency=low * First upload to Debian. [ by sponsor Steffen Moeller ] * Added Brian to uploaders and set DMUA flag * Merged changes from 3.3.2.GA-1 to 3.3.2.GA-2 with Brian's work * Omitted ".Final" from version. -- Brian Thomason Mon, 26 Dec 2011 00:23:47 +0100 libhibernate-jbosscache-java (3.6.8.Final-0ubuntu1) precise; urgency=low * New upstream release -- Brian Thomason Tue, 06 Dec 2011 22:12:12 +0000 libhibernate-jbosscache-java (3.3.2.GA-2) UNRELEASED; urgency=low [ Miguel Landaeta ] * Bump Standards-Version to 3.9.2. No changes were required. [ James Page ] * Fix FTBFS with OpenJDK7 (LP: #888961) (Closes: #652042): - d/rules: Specify source/target as 1.5 when calling jh_build to work around Java 7 encoding errors. -- Miguel Landaeta Tue, 20 Dec 2011 19:10:24 -0430 libhibernate-jbosscache-java (3.3.2.GA-1) unstable; urgency=low * Initial release. (Closes: #589598). -- Miguel Landaeta Sun, 18 Jul 2010 21:19:04 -0430 debian/control0000644000000000000000000000237511731702055010601 0ustar Source: libhibernate-jbosscache-java Maintainer: Debian Java Maintainers Uploaders: Miguel Landaeta , Brian Thomason Section: java Priority: optional Build-Depends: debhelper (>= 7.0.50~), default-jdk, javahelper, libhibernate3-java, libslf4j-java, libgeronimo-jta-1.0.1b-spec-java, libjboss-cache3-java, libjboss-system-java, libjboss-jmx-java, libjgroups-java, libjboss-cache1-java Standards-Version: 3.9.3 Vcs-Git: git://git.debian.org/git/pkg-java/libhibernate-jbosscache-java.git Vcs-Browser: http://git.debian.org/?p=pkg-java/libhibernate-jbosscache-java.git DM-Upload-Allowed: yes Package: libhibernate-jbosscache-java Architecture: all Depends: libhibernate3-java, libslf4j-java, libgeronimo-jta-1.0.1b-spec-java, libjboss-cache1-java, libjboss-system-java, libjboss-jmx-java, ${misc:Depends}, libjgroups-java Description: Java library for integration of Hibernate with JBossCache This Java library provides support in Hibernate for JBossCache 1.x APIs. . Hibernate is an object-relational mapping (ORM) Java library and JBossCache is a replicated cache for frequently accessed Java objects in a cluster, in order to improve the performance of applications. debian/rules0000755000000000000000000000125711731466624010265 0ustar #!/usr/bin/make -f export JAVA_HOME=/usr/lib/jvm/default-java export CLASSPATH=$(shell for jar in `cat debian/classpath`; do echo -n "$${jar}:"; done) export DEB_UPSTREAM_VERSION=$(shell dpkg-parsechangelog |grep Version|awk -F": " '{print $$2}'|sed -e 's/-.*//') %: dh --with javahelper $@ override_jh_build: jh_build --javacopts="-source 1.5 -target 1.5" --javadoc-opts="-source 1.5" \ hibernate-jbosscache.jar src/main get-orig-source: cd $(dir $(firstword $(MAKEFILE_LIST)))../ && \ uscan \ --verbose \ --no-symlink \ --destdir $(CURDIR) \ --watchfile debian/watch \ --force-download \ --debug \ --download-version $(DEB_UPSTREAM_VERSION) \ --rename debian/compat0000644000000000000000000000000211731466473010400 0ustar 7 debian/source/0000755000000000000000000000000011731466473010502 5ustar debian/source/format0000644000000000000000000000001411731466473011710 0ustar 3.0 (quilt) debian/jlibs0000644000000000000000000000003111731466473010222 0ustar hibernate-jbosscache.jar