/*
* 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.db;
import java.sql.Connection;
import java.util.LinkedList;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.jbpm.JbpmException;
/**
* represents the connection to the jbpm database.
*
* You can obtain a JbpmSession with
* <pre>
* JbpmSession jbpmSession = jbpmSessionFactory.openJbpmSession();
* </pre>
* or
* <pre>
* Connection jdbcConnection = ...;
* JbpmSession jbpmSession = jbpmSessionFactory.openJbpmSession(jdbcConnection);
* </pre>
* The actual database operations are defined in the module sessions :
* <ul>
* <li>{@link org.jbpm.db.GraphSession}</li>
* <li>{@link org.jbpm.db.TaskMgmtSession}</li>
* <li>{@link org.jbpm.db.LoggingSession}</li>
* <li>{@link org.jbpm.db.ContextSession}</li>
* </ul>
* The easiest way to obtain the operations is like this :
* <ul>
* <li><pre>jbpmSession.getGraphSession().someGraphDbMethod(...)</pre></li>
* <li><pre>jbpmSession.getTaskMgmtSession().someTaskDbMethod(...)</pre></li>
* <li><pre>jbpmSession.getLoggingSession().someLoggingDbMethod(...)</pre></li>
* <li><pre>jbpmSession.getContextSession().someContextDbMethod(...)</pre></li>
* </ul>
*
* @deprecated use {@link org.jbpm.JbpmContext} and {@link org.jbpm.JbpmConfiguration} instead.
*/
public class JbpmSession {
static ThreadLocal currentJbpmSessionStack = new ThreadLocal();
JbpmSessionFactory jbpmSessionFactory = null;
Session session = null;
Transaction transaction = null;
GraphSession graphSession = null;
ContextSession contextSession = null;
TaskMgmtSession taskMgmtSession = null;
LoggingSession loggingSession = null;
JobSession jobSession = null;
public JbpmSession( JbpmSessionFactory jbpmSessionFactory, Session session ) {
this.jbpmSessionFactory = jbpmSessionFactory;
this.session = session;
this.graphSession = new GraphSession(this);
this.contextSession = new ContextSession(this);
this.taskMgmtSession = new TaskMgmtSession(this);
this.loggingSession = new LoggingSession(this);
pushCurrentSession();
}
public JbpmSession(Session session) {
this.session = session;
this.graphSession = new GraphSession(this);
this.contextSession = new ContextSession(this);
this.taskMgmtSession = new TaskMgmtSession(this);
this.loggingSession = new LoggingSession(this);
}
public JbpmSessionFactory getJbpmSessionFactory() {
return jbpmSessionFactory;
}
public Connection getConnection() {
try {
return session.connection();
} catch (Exception e) {
log.error(e);
handleException();
throw new JbpmException( "couldn't get the jdbc connection from hibernate", e );
}
}
public Session getSession() {
return session;
}
public Transaction getTransaction() {
return transaction;
}
public void beginTransaction() {
try {
transaction = session.beginTransaction();
} catch (Exception e) {
log.error(e);
handleException();
throw new JbpmException( "couldn't begin a transaction", e );
}
}
public void commitTransaction() {
if ( transaction == null ) {
throw new JbpmException("can't commit : no transaction started" );
}
try {
session.flush();
transaction.commit();
} catch (Exception e) {
log.error(e);
handleException();
throw new JbpmException( "couldn't commit transaction", e );
} finally {
transaction = null;
}
}
public void rollbackTransaction() {
if ( transaction == null ) {
throw new JbpmException("can't rollback : no transaction started" );
}
try {
transaction.rollback();
} catch (Exception e) {
log.error(e);
handleException();
throw new JbpmException( "couldn't rollback transaction", e );
} finally {
transaction = null;
}
}
public void commitTransactionAndClose() {
commitTransaction();
close();
}
public void rollbackTransactionAndClose() {
rollbackTransaction();
close();
}
public GraphSession getGraphSession() {
return graphSession;
}
public ContextSession getContextSession() {
return contextSession;
}
public TaskMgmtSession getTaskMgmtSession() {
return taskMgmtSession;
}
public LoggingSession getLoggingSession() {
return loggingSession;
}
public JobSession getJobSession() {
return jobSession;
}
public void close() {
try {
if ( (session!=null)
&& (session.isOpen())
) {
session.close();
}
} catch (Exception e) {
log.error(e);
throw new JbpmException( "couldn't close the hibernate connection", e );
} finally {
popCurrentSession();
session = null;
}
}
/**
* handles an exception that is thrown by hibernate.
*/
void handleException() {
// if hibernate throws an exception,
if (transaction!=null) {
try {
// the transaction should be rolled back
transaction.rollback();
} catch (HibernateException e) {
log.error("couldn't rollback hibernate transaction", e);
}
// and the hibernate session should be closed.
close();
}
}
public void pushCurrentSession() {
LinkedList stack = (LinkedList) currentJbpmSessionStack.get();
if (stack==null) {
stack = new LinkedList();
currentJbpmSessionStack.set(stack);
}
stack.addFirst(this);
}
/**
* @deprecated use {@link org.jbpm.JbpmConfiguration#getCurrentJbpmContext()} instead.
*/
public static JbpmSession getCurrentJbpmSession() {
JbpmSession jbpmSession = null;
LinkedList stack = (LinkedList) currentJbpmSessionStack.get();
if ( (stack!=null)
&& (! stack.isEmpty())
) {
jbpmSession = (JbpmSession) stack.getFirst();
}
return jbpmSession;
}
public void popCurrentSession() {
LinkedList stack = (LinkedList) currentJbpmSessionStack.get();
if ( (stack==null)
|| (stack.isEmpty())
|| (stack.getFirst()!=this)
) {
log.warn("can't pop current session: are you calling JbpmSession.close() multiple times ?");
} else {
stack.removeFirst();
}
}
private static final Log log = LogFactory.getLog(JbpmSession.class);
}