/*
|
* 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.pvm.internal.tx;
|
|
import java.io.Serializable;
|
import java.util.ArrayList;
|
import java.util.List;
|
|
import javax.transaction.Synchronization;
|
|
import org.jbpm.internal.log.Log;
|
|
|
/** simple 2 phase commit transaction.
|
* no logging or recovery.
|
* non thread safe (which is ok).
|
* @author Tom Baeyens
|
*/
|
public class StandardTransaction extends AbstractTransaction implements Transaction, Serializable {
|
|
private static final long serialVersionUID = 1L;
|
private static Log log = Log.getLog(StandardTransaction.class.getName());
|
|
enum State {
|
CREATED,
|
ACTIVE,
|
ROLLBACKONLY,
|
COMMITTED,
|
ROLLEDBACK
|
}
|
|
protected List<StandardResource> resources;
|
protected List<StandardSynchronization> synchronizations;
|
protected State state = State.CREATED;
|
|
// methods for interceptor //////////////////////////////////////////////////
|
|
public void begin() {
|
if (log.isTraceEnabled()) log.trace("beginning "+this);
|
state = State.ACTIVE;
|
}
|
|
public void complete() {
|
if (state==State.ACTIVE) {
|
commit();
|
} else if (state==State.ROLLBACKONLY){
|
rollback();
|
} else {
|
throw new TransactionException("complete on transaction in state "+state);
|
}
|
}
|
|
// public tx methods ////////////////////////////////////////////////////////
|
|
public void setRollbackOnly() {
|
if (state!=State.ACTIVE) {
|
throw new TransactionException("transaction was not active: "+state);
|
}
|
state = State.ROLLBACKONLY;
|
}
|
|
public boolean isRollbackOnly() {
|
return ( (state==State.ROLLBACKONLY)
|
|| (state==State.ROLLEDBACK)
|
);
|
}
|
|
// commit ///////////////////////////////////////////////////////////////////
|
|
/** implements simplest two phase commit. */
|
public void commit() {
|
flushDeserializedObjects();
|
|
if (state!=State.ACTIVE) {
|
throw new TransactionException("commit on transaction in state "+state);
|
}
|
|
log.trace("committing "+this);
|
|
try {
|
beforeCompletion();
|
|
if (resources!=null) {
|
// prepare //////////////////////////////////////////////////////////////
|
// the prepare loop will be skipped at the first exception
|
for (StandardResource standardResource: resources) {
|
if (log.isTraceEnabled()) log.trace("preparing resource "+standardResource);
|
standardResource.prepare();
|
}
|
}
|
|
// for any exception in the prepare phase, we'll rollback
|
} catch (Exception exception) {
|
try {
|
if (log.isTraceEnabled()) log.trace("resource threw exception in prepare. rolling back.");
|
rollbackResources();
|
} catch (Exception rollbackException) {
|
log.error("rollback failed as well", rollbackException);
|
}
|
|
// rethrow
|
if (exception instanceof RuntimeException) {
|
throw (RuntimeException) exception;
|
}
|
throw new TransactionException("prepare failed", exception);
|
}
|
|
// here is the point of no return :-)
|
|
// commit ///////////////////////////////////////////////////////////////
|
Throwable commitException = null;
|
if (resources!=null) {
|
// The commit loop will try to send the commit to every resource,
|
// No matter what it takes. If exceptions come out of resource.commit's
|
// they will be suppressed and the first exception will be rethrown after
|
// all the resources are commited
|
for (StandardResource standardResource: resources) {
|
try {
|
if (log.isTraceEnabled()) log.trace("committing resource "+standardResource);
|
standardResource.commit();
|
|
// Exceptions in the commit phase will not lead to rollback, since some resources
|
// might have committed and can't go back.
|
} catch (Throwable t) {
|
// TODO this should go to a special log for sys admin recovery
|
log.error("commit failed for resource "+standardResource, t);
|
if (commitException==null) {
|
commitException = t;
|
}
|
}
|
}
|
}
|
|
state = State.COMMITTED;
|
afterCompletion();
|
if (log.isTraceEnabled()) log.trace("committed "+this);
|
|
if (commitException!=null) {
|
if (commitException instanceof RuntimeException) {
|
throw (RuntimeException) commitException;
|
} else if (commitException instanceof Error) {
|
throw (Error) commitException;
|
}
|
throw new TransactionException("resource failed to commit", commitException);
|
}
|
}
|
|
// rollback /////////////////////////////////////////////////////////////////
|
|
public void rollback() {
|
if ( (state!=State.ACTIVE)
|
&& (state!=State.ROLLBACKONLY)
|
) {
|
throw new TransactionException("rollback on transaction in state "+state);
|
}
|
|
if (log.isTraceEnabled()) log.trace("rolling back "+this);
|
|
beforeCompletion();
|
rollbackResources();
|
}
|
|
|
void rollbackResources() {
|
if (resources!=null) {
|
for (StandardResource resource: resources) {
|
try {
|
if (log.isTraceEnabled()) log.trace("rolling back resource "+resource);
|
resource.rollback();
|
} catch (Exception e) {
|
log.error("rollback failed for resource "+resource);
|
}
|
}
|
}
|
|
state = State.ROLLEDBACK;
|
|
afterCompletion();
|
|
if (log.isTraceEnabled()) log.trace("rolled back");
|
}
|
|
// synchronizations /////////////////////////////////////////////////////////
|
|
public void registerSynchronization(Synchronization synchronization) {
|
if (synchronizations==null) {
|
synchronizations = new ArrayList<StandardSynchronization>();
|
}
|
synchronizations.add(new StandardSynchronization(synchronization));
|
}
|
|
public void afterCompletion() {
|
if (synchronizations!=null) {
|
for (StandardSynchronization synchronization: synchronizations) {
|
synchronization.afterCompletion(state);
|
}
|
}
|
}
|
|
public void beforeCompletion() {
|
if (synchronizations!=null) {
|
for (StandardSynchronization synchronization: synchronizations) {
|
synchronization.beforeCompletion();
|
}
|
}
|
}
|
|
// resource enlisting ///////////////////////////////////////////////////////
|
|
public void enlistResource(StandardResource standardResource) {
|
if (resources==null) {
|
resources = new ArrayList<StandardResource>();
|
}
|
log.trace("enlisting resource "+standardResource+" to standard transaction");
|
resources.add(standardResource);
|
}
|
|
List<StandardResource> getResources() {
|
return resources;
|
}
|
|
// general methods //////////////////////////////////////////////////////////
|
|
public String toString() {
|
return "StandardTransaction["+System.identityHashCode(this)+"]";
|
}
|
}
|
