Author: jeff.yuchang Date: 2010-04-16 01:39:03 -0400 (Fri, 16 Apr 2010) New Revision: 623 Added: branches/ODE/ODE-1.x-fixes/dao-hibernate/src/main/java/org/apache/ode/daohib/JotmTransaction.java branches/ODE/ODE-1.x-fixes/dao-hibernate/src/main/java/org/apache/ode/daohib/JotmTransactionFactory.java Modified: branches/ODE/ODE-1.x-fixes/bpel-store/src/main/java/org/apache/ode/store/hib/DbConfStoreConnectionFactory.java branches/ODE/ODE-1.x-fixes/bpel-test/pom.xml branches/ODE/ODE-1.x-fixes/dao-hibernate/pom.xml branches/ODE/ODE-1.x-fixes/dao-hibernate/src/main/java/org/apache/ode/daohib/bpel/BpelDAOConnectionFactoryImpl.java Log: * fix the hibernate upgrading issue. * now have 2 test case failed in bpel-tests module. Modified: branches/ODE/ODE-1.x-fixes/bpel-store/src/main/java/org/apache/ode/store/hib/DbConfStoreConnectionFactory.java =================================================================== --- branches/ODE/ODE-1.x-fixes/bpel-store/src/main/java/org/apache/ode/store/hib/DbConfStoreConnectionFactory.java 2010-04-15 11:57:12 UTC (rev 622) +++ branches/ODE/ODE-1.x-fixes/bpel-store/src/main/java/org/apache/ode/store/hib/DbConfStoreConnectionFactory.java 2010-04-16 05:39:03 UTC (rev 623) @@ -101,7 +101,13 @@ properties.put(SessionManager.PROP_GUID, _guid); properties.put(Environment.CONNECTION_PROVIDER, DataSourceConnectionProvider.class.getName()); properties.put(Environment.TRANSACTION_MANAGER_STRATEGY, HibernateTransactionManagerLookup.class.getName()); - properties.put(Environment.TRANSACTION_STRATEGY, "org.hibernate.transaction.JTATransactionFactory"); + /* + * Since Hibernate 3.2.6, Hibernate JTATransaction requires User Transaction bound on JNDI. Let's work around + * by implementing Hibernate JTATransactionFactory that hooks up to the JTATransactionManager(ODE uses geronimo + * by default). + */ + //properties.put(Environment.TRANSACTION_STRATEGY, "org.hibernate.transaction.JTATransactionFactory"); + properties.put(Environment.TRANSACTION_STRATEGY, "org.apache.ode.daohib.JotmTransactionFactory"); properties.put(Environment.CURRENT_SESSION_CONTEXT_CLASS, "jta"); if(__log.isDebugEnabled()) __log.debug("Store connection properties: " + properties ); Modified: branches/ODE/ODE-1.x-fixes/bpel-test/pom.xml =================================================================== --- branches/ODE/ODE-1.x-fixes/bpel-test/pom.xml 2010-04-15 11:57:12 UTC (rev 622) +++ branches/ODE/ODE-1.x-fixes/bpel-test/pom.xml 2010-04-16 05:39:03 UTC (rev 623) @@ -155,11 +155,9 @@ <configuration> <!-- FIXME: temporary skip it, 3 failed test cases (2 in JDK6, 3 in JDK5): testIMA, testRetireOld, testIsolated**--> <excludes> - <!-- - <exclude>**/MessageRouting20Test.java</exclude> + <exclude>**/MessageRouting20Test.java</exclude> <exclude>**/VersionedRedeployTest.java</exclude> - <exclude>**/StructuredActivities20Test.java</exclude> - --> + <!--exclude>**/StructuredActivities20Test.java</exclude--> </excludes> </configuration> </plugin> Modified: branches/ODE/ODE-1.x-fixes/dao-hibernate/pom.xml =================================================================== --- branches/ODE/ODE-1.x-fixes/dao-hibernate/pom.xml 2010-04-15 11:57:12 UTC (rev 622) +++ branches/ODE/ODE-1.x-fixes/dao-hibernate/pom.xml 2010-04-16 05:39:03 UTC (rev 623) @@ -64,7 +64,6 @@ <groupId>org.slf4j</groupId> <artifactId>slf4j-log4j12</artifactId> <version>${slf4j.version}</version> - <scope>test</scope> </dependency> <dependency> <groupId>junit</groupId> Added: branches/ODE/ODE-1.x-fixes/dao-hibernate/src/main/java/org/apache/ode/daohib/JotmTransaction.java =================================================================== --- branches/ODE/ODE-1.x-fixes/dao-hibernate/src/main/java/org/apache/ode/daohib/JotmTransaction.java (rev 0) +++ branches/ODE/ODE-1.x-fixes/dao-hibernate/src/main/java/org/apache/ode/daohib/JotmTransaction.java 2010-04-16 05:39:03 UTC (rev 623) @@ -0,0 +1,360 @@ +/* + * Hibernate, Relational Persistence for Idiomatic Java + * + * Copyright (c) 2008, 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.apache.ode.daohib; + +import javax.transaction.Status; +import javax.transaction.Synchronization; +import javax.transaction.SystemException; +import javax.transaction.TransactionManager; +import javax.transaction.UserTransaction; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.hibernate.HibernateException; +import org.hibernate.Transaction; +import org.hibernate.TransactionException; +import org.hibernate.jdbc.JDBCContext; +import org.hibernate.transaction.TransactionFactory; +import org.hibernate.util.JTAHelper; + +/** + * {@link Transaction} implementation based on transaction management through + * a JTA {@link UserTransaction}. Similar to {@link CMTTransaction}, except + * here we are actually managing the transactions through the Hibernate + * transaction mechanism. + * + * @author Gavin King + * @author Steve Ebersole + * @author Les Hazlewood + * + * Scraped from org.hibernate + */ +public class JotmTransaction implements Transaction { + private static final Log log = LogFactory.getLog( JotmTransaction.class ); + + private final JDBCContext jdbcContext; + private final TransactionFactory.Context transactionContext; + + private UserTransaction userTransaction; + private boolean newTransaction; + private boolean begun; + private boolean commitFailed; + private boolean commitSucceeded; + private boolean callback; + + public JotmTransaction( + UserTransaction userTransaction, + JDBCContext jdbcContext, + TransactionFactory.Context transactionContext) { + this.jdbcContext = jdbcContext; + this.transactionContext = transactionContext; + this.userTransaction = userTransaction; + } + + /** + * {@inheritDoc} + */ + public void begin() throws HibernateException { + if ( begun ) { + return; + } + if ( commitFailed ) { + throw new TransactionException( "cannot re-start transaction after failed commit" ); + } + + log.debug( "begin" ); + + try { + newTransaction = userTransaction.getStatus() == Status.STATUS_NO_TRANSACTION; + if ( newTransaction ) { + userTransaction.begin(); + log.debug( "Began a new JTA transaction" ); + } + } + catch ( Exception e ) { + log.error( "JTA transaction begin failed", e ); + throw new TransactionException( "JTA transaction begin failed", e ); + } + + /*if (newTransaction) { + // don't need a synchronization since we are committing + // or rolling back the transaction ourselves - assuming + // that we do no work in beforeTransactionCompletion() + synchronization = false; + }*/ + + boolean synchronization = jdbcContext.registerSynchronizationIfPossible(); + + if ( !newTransaction && !synchronization ) { + log.warn( "You should set hibernate.transaction.manager_lookup_class if cache is enabled" ); + } + + if ( !synchronization ) { + //if we could not register a synchronization, + //do the before/after completion callbacks + //ourself (but we need to let jdbcContext + //know that this is what we are going to + //do, so it doesn't keep trying to register + //synchronizations) + callback = jdbcContext.registerCallbackIfNecessary(); + } + + begun = true; + commitSucceeded = false; + + jdbcContext.afterTransactionBegin( this ); + } + + /** + * {@inheritDoc} + */ + public void commit() throws HibernateException { + if ( !begun ) { + throw new TransactionException( "Transaction not successfully started" ); + } + + log.debug( "commit" ); + + boolean flush = !transactionContext.isFlushModeNever() + && ( callback || !transactionContext.isFlushBeforeCompletionEnabled() ); + + if ( flush ) { + transactionContext.managedFlush(); //if an exception occurs during flush, user must call rollback() + } + + if ( callback && newTransaction ) { + jdbcContext.beforeTransactionCompletion( this ); + } + + closeIfRequired(); + + if ( newTransaction ) { + try { + userTransaction.commit(); + commitSucceeded = true; + log.debug( "Committed JTA UserTransaction" ); + } + catch ( Exception e ) { + commitFailed = true; // so the transaction is already rolled back, by JTA spec + log.error( "JTA commit failed", e ); + throw new TransactionException( "JTA commit failed: ", e ); + } + finally { + afterCommitRollback(); + } + } + else { + // this one only really needed for badly-behaved applications! + // (if the TransactionManager has a Sychronization registered, + // its a noop) + // (actually we do need it for downgrading locks) + afterCommitRollback(); + } + + } + + /** + * {@inheritDoc} + */ + public void rollback() throws HibernateException { + if ( !begun && !commitFailed ) { + throw new TransactionException( "Transaction not successfully started" ); + } + + log.debug( "rollback" ); + + try { + closeIfRequired(); + } + catch ( Exception e ) { + // swallow it, and continue to roll back JTA transaction + log.error( "could not close session during rollback", e ); + } + + try { + if ( newTransaction ) { + if ( !commitFailed ) { + userTransaction.rollback(); + log.debug( "Rolled back JTA UserTransaction" ); + } + } + else { + userTransaction.setRollbackOnly(); + log.debug( "set JTA UserTransaction to rollback only" ); + } + } + catch ( Exception e ) { + log.error( "JTA rollback failed", e ); + throw new TransactionException( "JTA rollback failed", e ); + } + finally { + afterCommitRollback(); + } + } + + private static final int NULL = Integer.MIN_VALUE; + + private void afterCommitRollback() throws TransactionException { + + begun = false; + // this method is a noop if there is a Synchronization! + if ( callback ) { + if ( !newTransaction ) { + log.warn( "You should set hibernate.transaction.manager_lookup_class if cache is enabled" ); + } + int status = NULL; + try { + status = userTransaction.getStatus(); + } + catch ( Exception e ) { + log.error( "Could not determine transaction status after commit", e ); + throw new TransactionException( "Could not determine transaction status after commit", e ); + } + finally { + jdbcContext.afterTransactionCompletion( status == Status.STATUS_COMMITTED, this ); + } + } + } + + /** + * {@inheritDoc} + */ + public boolean wasRolledBack() throws TransactionException { + final int status; + try { + status = userTransaction.getStatus(); + } + catch ( SystemException se ) { + log.error( "Could not determine transaction status", se ); + throw new TransactionException( "Could not determine transaction status", se ); + } + if ( status == Status.STATUS_UNKNOWN ) { + throw new TransactionException( "Could not determine transaction status" ); + } + else { + return JTAHelper.isRollback( status ); + } + } + + /** + * {@inheritDoc} + */ + public boolean wasCommitted() throws TransactionException { + final int status; + try { + status = userTransaction.getStatus(); + } + catch ( SystemException se ) { + log.error( "Could not determine transaction status", se ); + throw new TransactionException( "Could not determine transaction status: ", se ); + } + if ( status == Status.STATUS_UNKNOWN ) { + throw new TransactionException( "Could not determine transaction status" ); + } + else { + return status == Status.STATUS_COMMITTED; + } + } + + /** + * {@inheritDoc} + */ + public boolean isActive() throws TransactionException { + if ( !begun || commitFailed || commitSucceeded ) { + return false; + } + + final int status; + try { + status = userTransaction.getStatus(); + } + catch ( SystemException se ) { + log.error( "Could not determine transaction status", se ); + throw new TransactionException( "Could not determine transaction status: ", se ); + } + if ( status == Status.STATUS_UNKNOWN ) { + throw new TransactionException( "Could not determine transaction status" ); + } + else { + return status == Status.STATUS_ACTIVE; + } + } + + /** + * {@inheritDoc} + */ + public void registerSynchronization(Synchronization sync) throws HibernateException { + if ( getTransactionManager() == null ) { + throw new IllegalStateException( "JTA TransactionManager not available" ); + } + else { + try { + getTransactionManager().getTransaction().registerSynchronization( sync ); + } + catch ( Exception e ) { + throw new TransactionException( "could not register synchronization", e ); + } + } + } + + /** + * Getter for property 'transactionManager'. + * + * @return Value for property 'transactionManager'. + */ + private TransactionManager getTransactionManager() { + return transactionContext.getFactory().getTransactionManager(); + } + + private void closeIfRequired() throws HibernateException { + boolean close = callback && + transactionContext.shouldAutoClose() && + !transactionContext.isClosed(); + if ( close ) { + transactionContext.managedClose(); + } + } + + /** + * {@inheritDoc} + */ + public void setTimeout(int seconds) { + try { + userTransaction.setTransactionTimeout( seconds ); + } + catch ( SystemException se ) { + throw new TransactionException( "could not set transaction timeout", se ); + } + } + + /** + * Getter for property 'userTransaction'. + * + * @return Value for property 'userTransaction'. + */ + protected UserTransaction getUserTransaction() { + return userTransaction; + } +} Added: branches/ODE/ODE-1.x-fixes/dao-hibernate/src/main/java/org/apache/ode/daohib/JotmTransactionFactory.java =================================================================== --- branches/ODE/ODE-1.x-fixes/dao-hibernate/src/main/java/org/apache/ode/daohib/JotmTransactionFactory.java (rev 0) +++ branches/ODE/ODE-1.x-fixes/dao-hibernate/src/main/java/org/apache/ode/daohib/JotmTransactionFactory.java 2010-04-16 05:39:03 UTC (rev 623) @@ -0,0 +1,309 @@ +/* + * Hibernate, Relational Persistence for Idiomatic Java + * + * Copyright (c) 2008, 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.apache.ode.daohib; + +import java.util.Properties; + +import javax.naming.InitialContext; +import javax.naming.NamingException; +import javax.transaction.HeuristicMixedException; +import javax.transaction.HeuristicRollbackException; +import javax.transaction.NotSupportedException; +import javax.transaction.RollbackException; +import javax.transaction.SystemException; +import javax.transaction.TransactionManager; +import javax.transaction.UserTransaction; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.hibernate.ConnectionReleaseMode; +import org.hibernate.HibernateException; +import org.hibernate.Transaction; +import org.hibernate.TransactionException; +import org.hibernate.jdbc.JDBCContext; +import org.hibernate.cfg.Environment; +import org.hibernate.transaction.TransactionFactory; +import org.hibernate.transaction.TransactionManagerLookup; +import org.hibernate.transaction.TransactionManagerLookupFactory; +import org.hibernate.util.NamingHelper; +import org.hibernate.util.JTAHelper; + +/** + * Factory for {@link JotmTransaction} instances. + * <p/> + * To be completely accurate to the JTA spec, JTA implementations should + * publish their contextual {@link UserTransaction} reference into JNDI. + * However, in practice there are quite a few <tt>stand-alone</tt> + * implementations intended for use outside of J2EE/JEE containers and + * which therefore do not publish their {@link UserTransaction} references + * into JNDI but which otherwise follow the aspects of the JTA specification. + * This {@link TransactionFactory} implementation can support both models. + * <p/> + * For complete JTA implementations (including dependence on JNDI), the + * {@link UserTransaction} reference is obtained by a call to + * {@link #resolveInitialContext}. Hibernate will then attempt to locate the + * {@link UserTransaction} within this resolved + * {@link InitialContext} based on the namespace returned by + * {@link #resolveUserTransactionName}. + * <p/> + * For the so-called <tt>stand-alone</tt> implementations, we do not care at + * all about the JNDI aspects just described. Here, the implementation would + * have a specific manner to obtain a reference to its contextual + * {@link UserTransaction}; usually this would be a static code reference, but + * again it varies. Anyway, for each implementation the integration would need + * to override the {@link #getUserTransaction} method and return the appropriate + * thing. + * + * @author Gavin King + * @author Steve Ebersole + * @author Les Hazlewood + * + * Scraped from org.hibernate + */ +public class JotmTransactionFactory implements TransactionFactory { + public static final String DEFAULT_USER_TRANSACTION_NAME = "java:comp/UserTransaction"; + private static final Log log = LogFactory.getLog( JotmTransactionFactory.class ); + + protected InitialContext initialContext; + protected String userTransactionName; + + private TransactionManager txManager; + + /** + * Configure this transaction factory. Specifically here we are attempting to + * resolve both an {@link #getInitialContext InitialContext} as well as the + * {@link #getUserTransactionName() JNDI namespace} for the {@link UserTransaction}. + * + * @param props The configuration properties + * + * @exception HibernateException + */ + public void configure(Properties props) throws HibernateException { + this.initialContext = resolveInitialContext( props ); + this.userTransactionName = resolveUserTransactionName( props ); + log.debug( "Configured JTATransactionFactory to use [" + userTransactionName + "] for UserTransaction JDNI namespace" ); + txManager = new HibernateTransactionManagerLookup().getTransactionManager(props); + } + + /** + * Given the lot of Hibernate configuration properties, resolve appropriate + * reference to JNDI {@link InitialContext}. + * <p/> + * In general, the properties in which we are interested here all begin with + * <tt>hibernate.jndi</tt>. Especially important depending on your + * environment are {@link Environment#JNDI_URL hibernate.jndi.url} and + * {@link Environment#JNDI_CLASS hibernate.jndi.class} + * + * @param properties The Hibernate config properties. + * @return The resolved InitialContext. + */ + protected final InitialContext resolveInitialContext(Properties properties) { + try { + return NamingHelper.getInitialContext( properties ); + } + catch ( NamingException ne ) { + throw new HibernateException( "Could not obtain initial context", ne ); + } + } + + /** + * Given the lot of Hibernate configuration properties, resolve appropriate + * JNDI namespace to use for {@link UserTransaction} resolution. + * <p/> + * We determine the namespace to use by<ol> + * <li>Any specified {@link Environment#USER_TRANSACTION jta.UserTransaction} config property</li> + * <li>If a {@link TransactionManagerLookup} was indicated, use its + * {@link TransactionManagerLookup#getUserTransactionName}</li> + * <li>finally, as a last resort, we use {@link #DEFAULT_USER_TRANSACTION_NAME}</li> + * </ol> + * + * @param properties The Hibernate config properties. + * @return The resolved {@link UserTransaction} namespace + */ + protected final String resolveUserTransactionName(Properties properties) { + String utName = properties.getProperty( Environment.USER_TRANSACTION ); + if ( utName == null ) { + TransactionManagerLookup lookup = TransactionManagerLookupFactory.getTransactionManagerLookup( properties ); + if ( lookup != null ) { + utName = lookup.getUserTransactionName(); + } + } + return utName == null ? DEFAULT_USER_TRANSACTION_NAME : utName; + } + + /** + * {@inheritDoc} + */ + public Transaction createTransaction(JDBCContext jdbcContext, Context transactionContext) + throws HibernateException { + /* + * JTA TransactionManager returns a JTA transaction. We need a user transaction to use + * hibernate's JTATransactionFactory. + */ + // UserTransaction ut = getUserTransaction(); + UserTransaction ut; + try { + ut = new UserTransaction() { + javax.transaction.Transaction transaction = txManager.getTransaction(); + public void begin() throws NotSupportedException, SystemException { + // TODO Auto-generated method stub + } + + public void commit() throws HeuristicMixedException, + HeuristicRollbackException, IllegalStateException, + RollbackException, SecurityException, SystemException { + transaction.commit(); + } + + public int getStatus() throws SystemException { + // TODO Auto-generated method stub + return transaction.getStatus(); + } + + public void rollback() throws IllegalStateException, + SecurityException, SystemException { + // TODO Auto-generated method stub + transaction.rollback(); + } + + public void setRollbackOnly() throws IllegalStateException, + SystemException { + // TODO Auto-generated method stub + transaction.setRollbackOnly(); + } + + public void setTransactionTimeout(int i) throws SystemException { + // TODO Auto-generated method stub + } + }; + } catch (SystemException e) { + throw new HibernateException(e); + } + + return new JotmTransaction( ut, jdbcContext, transactionContext ); + } + + /** + * Get the {@link UserTransaction} reference. + * + * @return The appropriate {@link UserTransaction} reference. + */ + protected UserTransaction getUserTransaction() { + final String utName = getUserTransactionName(); + log.debug( "Attempting to locate UserTransaction via JNDI [" + utName + "]"); + + try { + UserTransaction ut = ( UserTransaction ) getInitialContext().lookup( utName ); + if ( ut == null ) { + throw new TransactionException( "Naming service lookup for UserTransaction returned null [" + utName +"]" ); + } + + log.trace( "Obtained UserTransaction" ); + + return ut; + } + catch ( NamingException ne ) { + throw new TransactionException( "Could not find UserTransaction in JNDI [" + utName + "]", ne ); + } + } + + /** + * Getter for property 'initialContext'. + * + * @return Value for property 'initialContext'. + */ + protected InitialContext getInitialContext() { + return initialContext; + } + + /** + * Getter for property 'userTransactionName'. + * The algorithm here is + * + * @return Value for property 'userTransactionName'. + */ + protected String getUserTransactionName() { + return userTransactionName; + } + + /** + * {@inheritDoc} + */ + public ConnectionReleaseMode getDefaultReleaseMode() { + return ConnectionReleaseMode.AFTER_STATEMENT; + } + + /** + * {@inheritDoc} + */ + public boolean isTransactionManagerRequired() { + return false; + } + + /** + * {@inheritDoc} + */ + public boolean areCallbacksLocalToHibernateTransactions() { + return false; + } + + /** + * {@inheritDoc} + */ + public boolean isTransactionInProgress( + JDBCContext jdbcContext, + Context transactionContext, + Transaction transaction) { + try { + // Essentially: + // 1) If we have a local (Hibernate) transaction in progress + // and it already has the UserTransaction cached, use that + // UserTransaction to determine the status. + // 2) If a transaction manager has been located, use + // that transaction manager to determine the status. + // 3) Finally, as the last resort, try to lookup the + // UserTransaction via JNDI and use that to determine the + // status. + if ( transaction != null ) { + UserTransaction ut = ( ( JotmTransaction ) transaction ).getUserTransaction(); + if ( ut != null ) { + return JTAHelper.isInProgress( ut.getStatus() ); + } + } + + if ( jdbcContext.getFactory().getTransactionManager() != null ) { + return JTAHelper.isInProgress( jdbcContext.getFactory().getTransactionManager().getStatus() ); + } + else { + UserTransaction ut = getUserTransaction(); + return ut != null && JTAHelper.isInProgress( ut.getStatus() ); + } + } + catch ( SystemException se ) { + throw new TransactionException( "Unable to check transaction status", se ); + } + } + +} Modified: branches/ODE/ODE-1.x-fixes/dao-hibernate/src/main/java/org/apache/ode/daohib/bpel/BpelDAOConnectionFactoryImpl.java =================================================================== --- branches/ODE/ODE-1.x-fixes/dao-hibernate/src/main/java/org/apache/ode/daohib/bpel/BpelDAOConnectionFactoryImpl.java 2010-04-15 11:57:12 UTC (rev 622) +++ branches/ODE/ODE-1.x-fixes/dao-hibernate/src/main/java/org/apache/ode/daohib/bpel/BpelDAOConnectionFactoryImpl.java 2010-04-16 05:39:03 UTC (rev 623) @@ -28,8 +28,8 @@ import org.hibernate.HibernateException; import org.hibernate.cfg.Environment; import org.hibernate.dialect.Dialect; -import org.hibernate.dialect.resolver.DialectFactory; -import org.hibernate.dialect.resolver.StandardDialectResolver; +//import org.hibernate.dialect.resolver.DialectFactory; +//import org.hibernate.dialect.resolver.StandardDialectResolver; import javax.sql.DataSource; import javax.transaction.TransactionManager; @@ -102,7 +102,13 @@ properties.put(Environment.CONNECTION_PROVIDER, DataSourceConnectionProvider.class.getName()); properties.put(Environment.TRANSACTION_MANAGER_STRATEGY, HibernateTransactionManagerLookup.class.getName()); - properties.put(Environment.TRANSACTION_STRATEGY, "org.hibernate.transaction.JTATransactionFactory"); + /* + * Since Hibernate 3.2.6, Hibernate JTATransaction requires User Transaction bound on JNDI. Let's work around + * by implementing Hibernate JTATransactionFactory that hooks up to the JTATransactionManager(ODE uses geronimo + * by default). + */ + //properties.put(Environment.TRANSACTION_STRATEGY, "org.hibernate.transaction.JTATransactionFactory"); + properties.put(Environment.TRANSACTION_STRATEGY, "org.apache.ode.daohib.JotmTransactionFactory"); properties.put(Environment.CURRENT_SESSION_CONTEXT_CLASS, "jta"); // Guess Hibernate dialect if not specified in hibernate.properties @@ -149,7 +155,7 @@ // Open a connection and use that connection to figure out database // product name/version number in order to decide which Hibernate // dialect to use. - Connection conn = dataSource.getConnection(); +/* Connection conn = dataSource.getConnection(); try { DatabaseMetaData metaData = conn.getMetaData(); if (metaData != null) { @@ -159,7 +165,7 @@ } } finally { conn.close(); - } + }*/ if (dialect == null) { __log.info("Cannot determine hibernate dialect for this database: using the default one.");