/*
* JBoss, Home of Professional Open Source
* Copyright 2005, JBoss Inc., and individual contributors as indicated
* by the @authors tag. See the copyright.txt in the distribution for a
* full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software 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 software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.jbpm.persistence.db;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.IdentityHashMap;
import java.util.Map;
import javax.sql.DataSource;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.ConnectionReleaseMode;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.StaleStateException;
import org.hibernate.Transaction;
import org.hibernate.engine.SessionFactoryImplementor;
import org.hibernate.exception.LockAcquisitionException;
import org.jbpm.JbpmContext;
import org.jbpm.JbpmException;
import org.jbpm.db.ContextSession;
import org.jbpm.db.GraphSession;
import org.jbpm.db.JobSession;
import org.jbpm.db.LoggingSession;
import org.jbpm.db.TaskMgmtSession;
import org.jbpm.persistence.JbpmPersistenceException;
import org.jbpm.persistence.PersistenceService;
import org.jbpm.svc.Services;
import org.jbpm.tx.TxService;
public class DbPersistenceService implements PersistenceService {
private static final long serialVersionUID = 1L;
protected final DbPersistenceServiceFactory persistenceServiceFactory;
protected Connection connection;
protected boolean mustConnectionBeClosed;
protected Transaction transaction;
protected boolean isTransactionEnabled;
protected boolean isCurrentSessionEnabled;
protected Session session;
protected boolean mustSessionBeFlushed;
protected boolean mustSessionBeClosed;
protected GraphSession graphSession;
protected TaskMgmtSession taskMgmtSession;
protected JobSession jobSession;
protected ContextSession contextSession;
protected LoggingSession loggingSession;
private Map customSessions;
/**
* @deprecated for access to other services, invoke {@link JbpmContext#getServices()}
*/
protected Services services;
public DbPersistenceService(DbPersistenceServiceFactory persistenceServiceFactory) {
this.persistenceServiceFactory = persistenceServiceFactory;
this.isTransactionEnabled = persistenceServiceFactory.isTransactionEnabled();
this.isCurrentSessionEnabled = persistenceServiceFactory.isCurrentSessionEnabled();
}
public SessionFactory getSessionFactory() {
return session != null ? session.getSessionFactory()
: persistenceServiceFactory.getSessionFactory();
}
public Session getSession() {
if (session == null) {
SessionFactory sessionFactory = persistenceServiceFactory.getSessionFactory();
if (isCurrentSessionEnabled) {
session = sessionFactory.getCurrentSession();
mustSessionBeFlushed = false;
mustSessionBeClosed = false;
}
else {
Connection connection = getConnection(false);
session = connection != null ? sessionFactory.openSession(connection)
: sessionFactory.openSession();
mustSessionBeFlushed = true;
mustSessionBeClosed = true;
}
if (isTransactionEnabled) beginTransaction();
}
return session;
}
public void beginTransaction() {
transaction = session.beginTransaction();
// commit does a flush anyway
mustSessionBeFlushed = false;
}
public void endTransaction() {
if (!isTransactionRollbackOnly()) {
Exception commitException = commit();
if (commitException != null) {
rollback();
closeSession();
closeConnection();
throw new JbpmPersistenceException("transaction commit failed", commitException);
}
}
else {
Exception rollbackException = rollback();
if (rollbackException != null) {
closeSession();
closeConnection();
throw new JbpmPersistenceException("transaction rollback failed", rollbackException);
}
}
}
public Connection getConnection() {
return getConnection(true);
}
public Connection getConnection(boolean resolveSession) {
if (connection == null) {
DataSource dataSource = persistenceServiceFactory.getDataSource();
if (dataSource != null) {
try {
connection = dataSource.getConnection();
mustConnectionBeClosed = true;
}
catch (SQLException e) {
// NOTE that Errors are not caught because that might halt the JVM
// and mask the original Error
throw new JbpmPersistenceException("connection to data source failed", e);
}
}
else {
// resolve session or return
Session session = this.session;
if (session != null || resolveSession && (session = getSession()) != null) {
// get connection from session
connection = session.connection();
/*
* If the session is using aggressive connection release (as in a CMT environment),
* the application is responsible for closing the returned connection. Otherwise, the
* application should not close the connection.
*/
SessionFactoryImplementor sessionFactory = (SessionFactoryImplementor) session.getSessionFactory();
ConnectionReleaseMode releaseMode = sessionFactory.getSettings()
.getConnectionReleaseMode();
mustConnectionBeClosed = releaseMode == ConnectionReleaseMode.AFTER_STATEMENT;
}
}
}
return connection;
}
public boolean isTransactionActive() {
return transaction != null && transaction.isActive();
}
protected boolean isTransactionManagedExternally() {
return !isTransactionEnabled;
}
protected boolean isTransactionRollbackOnly() {
TxService txService = getTxService();
return txService != null ? txService.isRollbackOnly() : false;
}
public void close() {
// flush session
Exception flushException = flushSession();
if (flushException != null) {
// JBPM-1465: if transaction is enabled, flush is disabled, see beginTransaction()
// otherwise, transaction is managed externally
// in either case, rolling back is unnecessary and possibly disastrous
closeSession();
closeConnection();
throw new JbpmPersistenceException("failed to flush hibernate session", flushException);
}
// commit or roll back transaction
endTransaction();
// close session
Exception closeSessionException = closeSession();
if (closeSessionException != null) {
closeConnection();
throw new JbpmPersistenceException("failed to close hibernate session",
closeSessionException);
}
// close jdbc connection
Exception closeConnectionException = closeConnection();
if (closeConnectionException != null) {
throw new JbpmPersistenceException("failed to close hibernate connection",
closeConnectionException);
}
}
protected Exception commit() {
if (!isTransactionManagedExternally() && transaction != null) {
try {
transaction.commit();
}
catch (RuntimeException e) {
return e;
}
}
return null;
}
protected Exception rollback() {
// if there is an external transaction manager, throw an exception at it
if (isTransactionManagedExternally()) {
throw new JbpmPersistenceException("cannot honor rollback request under external transaction manager");
}
if (transaction != null) {
try {
transaction.rollback();
}
catch (RuntimeException e) {
return e;
}
}
return null;
}
private Exception flushSession() {
if (mustSessionBeFlushed) {
if (session != null) {
try {
session.flush();
}
catch (RuntimeException e) {
return e;
}
}
else {
log.warn("no hibernate session to flush");
}
}
return null;
}
private Exception closeSession() {
if (mustSessionBeClosed) {
if (session != null) {
try {
session.close();
}
catch (RuntimeException e) {
return e;
}
}
else {
log.warn("no hibernate session to close");
}
}
return null;
}
private Exception closeConnection() {
if (mustConnectionBeClosed) {
if (connection != null) {
try {
connection.close();
}
catch (RuntimeException e) {
return e;
}
catch (SQLException e) {
return e;
}
}
else {
log.warn("no jdbc connection to close");
}
}
return null;
}
public void assignId(Object object) {
Session session = getSession();
if (session != null) {
try {
session.save(object);
}
catch (HibernateException e) {
// NOTE that Errors are not caught because that might halt the JVM
// and mask the original Error.
throw new JbpmPersistenceException("could not assign id to " + object, e);
}
}
}
// getters and setters //////////////////////////////////////////////////////
public GraphSession getGraphSession() {
if (graphSession == null) {
Session session = getSession();
if (session != null) graphSession = new GraphSession(session);
}
return graphSession;
}
public LoggingSession getLoggingSession() {
if (loggingSession == null) {
Session session = getSession();
if (session != null) loggingSession = new LoggingSession(session);
}
return loggingSession;
}
public JobSession getJobSession() {
if (jobSession == null) {
Session session = getSession();
if (session != null) jobSession = new JobSession(session);
}
return jobSession;
}
public ContextSession getContextSession() {
if (contextSession == null) {
Session session = getSession();
if (session != null) contextSession = new ContextSession(session);
}
return contextSession;
}
public TaskMgmtSession getTaskMgmtSession() {
if (taskMgmtSession == null) {
Session session = getSession();
if (session != null) taskMgmtSession = new TaskMgmtSession(session);
}
return taskMgmtSession;
}
public Object getCustomSession(Class sessionClass) {
if (customSessions == null) {
customSessions = new IdentityHashMap();
}
else {
Object customSession = customSessions.get(sessionClass);
if (customSession != null) return customSession;
}
try {
Constructor constructor = sessionClass.getConstructor(new Class[] {
Session.class
});
try {
Object customSession = constructor.newInstance(new Object[] {
session
});
customSessions.put(sessionClass, customSession);
return customSession;
}
catch (InstantiationException e) {
throw new JbpmException(sessionClass + " is not instantiable", e);
}
catch (IllegalAccessException e) {
throw new JbpmException(getClass() + " has no access to " + constructor, e);
}
catch (InvocationTargetException e) {
throw new JbpmException(constructor + " threw exception", e.getCause());
}
}
catch (NoSuchMethodException e) {
throw new JbpmException("constructor not found: " + sessionClass.getName() + '('
+ Session.class.getName() + ')', e);
}
}
public DataSource getDataSource() {
return persistenceServiceFactory.getDataSource();
}
/**
* @deprecated use {@link TxService#isRollbackOnly()} instead
*/
public boolean isRollbackOnly() {
return isTransactionRollbackOnly();
}
/**
* @deprecated use {@link TxService#setRollbackOnly()} instead
*/
public void setRollbackOnly() {
TxService txService = getTxService();
if (txService != null) txService.setRollbackOnly();
}
/**
* @deprecated use {@link TxService#setRollbackOnly()} instead
* @throws IllegalArgumentException if <code>rollbackOnly</code> is <code>false</code>
*/
public void setRollbackOnly(boolean rollbackOnly) {
if (!rollbackOnly) {
throw new IllegalArgumentException("cannot unmark transaction for rollback");
}
setRollbackOnly();
}
private static TxService getTxService() {
return (TxService) Services.getCurrentService(Services.SERVICENAME_TX, false);
}
/**
* Injects an external Hibernate session, disabling transaction management.
*/
public void setSession(Session session) {
setSession(session, false);
}
/**
* Injects an external Hibernate session without affecting transaction management.
*
* @deprecated call {@link #setSession(Session, boolean) setSession(session, true)} instead
*/
public void setSessionWithoutDisablingTx(Session session) {
setSession(session, true);
}
/**
* Injects an external Hibernate session. Injecting a session normally disables transaction
* management. The <code>keepTransactionEnabled</code> parameter can be used to prevent
* transaction management from being disabled, according to the following table.
* <table border="1">
* <tr>
* <th>is currently enabled?</th>
* <th>keep enabled?</th>
* <th>enabled onward</th>
* </tr>
* <tr>
* <td>true</td>
* <td>true</td>
* <td>true (no change)</td>
* </tr>
* <tr>
* <td>true</td>
* <td>false</td>
* <td>false</td>
* </tr>
* <tr>
* <td>false</td>
* <td>any</td>
* <td>false (no change)</td>
* </tr>
* </table>
*/
public void setSession(Session session, boolean keepTransactionEnabled) {
this.session = session;
if (isTransactionEnabled && !keepTransactionEnabled) isTransactionEnabled = false;
}
public void setConnection(Connection connection) {
this.connection = connection;
}
public void setContextSession(ContextSession contextSession) {
this.contextSession = contextSession;
}
public void setDataSource(DataSource dataSource) {
persistenceServiceFactory.setDataSource(dataSource);
}
public void setGraphSession(GraphSession graphSession) {
this.graphSession = graphSession;
}
public void setLoggingSession(LoggingSession loggingSession) {
this.loggingSession = loggingSession;
}
public void setJobSession(JobSession jobSession) {
this.jobSession = jobSession;
}
public void setTaskMgmtSession(TaskMgmtSession taskMgmtSession) {
this.taskMgmtSession = taskMgmtSession;
}
public void setSessionFactory(SessionFactory sessionFactory) {
persistenceServiceFactory.setSessionFactory(sessionFactory);
}
public Transaction getTransaction() {
return transaction;
}
public void setTransaction(Transaction transaction) {
this.transaction = transaction;
}
public boolean isTransactionEnabled() {
return isTransactionEnabled;
}
public void setTransactionEnabled(boolean isTransactionEnabled) {
this.isTransactionEnabled = isTransactionEnabled;
}
/**
* Tells whether the given exception or any of its causes is a persistence exception.
* Currently a <em>persistence exception</em> is an instance of {@link HibernateException}.
*/
public static boolean isPersistenceException(Exception exception) {
for (Throwable t = exception; t != null; t = t.getCause()) {
if (t instanceof HibernateException) return true;
}
return false;
}
/**
* Tells whether the given exception or any of its causes is a locking exception. Currently a
* <em>locking exception</em> is an instance of {@link StaleStateException} or
* {@link LockAcquisitionException}. Note that Hibernate dialects have limited ability to map
* native locking error codes to {@link LockAcquisitionException}s.
*/
public static boolean isLockingException(Exception exception) {
for (Throwable t = exception; t != null; t = t.getCause()) {
if (t instanceof StaleStateException || t instanceof LockAcquisitionException) {
return true;
}
}
return false;
}
private static final Log log = LogFactory.getLog(DbPersistenceService.class);
}