/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.felix.ipojo.transaction;
import java.lang.reflect.Member;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import javax.transaction.HeuristicMixedException;
import javax.transaction.HeuristicRollbackException;
import javax.transaction.InvalidTransactionException;
import javax.transaction.NotSupportedException;
import javax.transaction.RollbackException;
import javax.transaction.SystemException;
import javax.transaction.Transaction;
import javax.transaction.TransactionManager;
import org.apache.felix.ipojo.MethodInterceptor;
public class TransactionalMethod implements MethodInterceptor {
public static final int REQUIRES = 0;
public static final int REQUIRES_NEW = 1;
public static final int MANDATORY = 2;
public static final int SUPPORTED = 3;
public static final int NOT_SUPPORTED = 4;
public static final int NEVER = 5;
private String method;
private int propagation;
private int timeout;
private List<String> exceptions;
private TransactionManager manager;
private Map <Thread, Transaction> m_owned = new HashMap<Thread, Transaction>();
private boolean exceptionOnRollback;
private TransactionHandler handler;
private Transaction suspended;
public TransactionalMethod(String method, int propagation, int timeout, List<String> exception, boolean exceptionOnRollback, TransactionHandler handler) {
this.method = method;
this.propagation = propagation;
this.timeout = timeout;
this.exceptions = exception;
this.exceptionOnRollback = exceptionOnRollback;
this.handler = handler;
}
public synchronized void setTransactionManager(TransactionManager tm) {
manager = tm;
if (manager == null) {
// Clear stored transactions.
m_owned.clear();
}
}
public void onEntry() throws SystemException, NotSupportedException {
TransactionManager manager = null;
synchronized (this) {
if (this.manager != null) {
manager = this.manager; // Stack confinement
} else {
return; // Nothing can be done...
}
}
Transaction transaction = manager.getTransaction();
switch (propagation) {
case REQUIRES:
// Are we already in a transaction?
if (transaction == null) {
// No, create one
if (timeout > 0) {
manager.setTransactionTimeout(timeout);
}
manager.begin();
m_owned.put(Thread.currentThread(), manager.getTransaction());
} else {
// Add the transaction to the transaction list
handler.addTransaction(transaction);
}
break;
case MANDATORY:
if (transaction == null) {
// Error
throw new IllegalStateException("The method " + method + " must be called inside a transaction");
} else {
// Add the transaction to the transaction list
handler.addTransaction(transaction);
}
break;
case SUPPORTED:
// if transaction != null, register the callback, else do nothing
if (transaction != null) {
handler.addTransaction(transaction);
} // Else do nothing.
break;
case NOT_SUPPORTED:
// Do nothing.
break;
case NEVER:
if (transaction != null) {
throw new IllegalStateException("The method " + method + " must never be called inside a transaction");
}
break;
case REQUIRES_NEW:
if (transaction == null) {
// No current transaction, Just creates a new one
if (timeout > 0) {
manager.setTransactionTimeout(timeout);
}
manager.begin();
m_owned.put(Thread.currentThread(), manager.getTransaction());
} else {
if (suspended == null) {
suspended = manager.suspend();
if (timeout > 0) {
manager.setTransactionTimeout(timeout);
}
manager.begin();
m_owned.put(Thread.currentThread(), manager.getTransaction());
} else {
throw new IllegalStateException("The method " + method + " requires to suspend a second times a transaction");
}
}
break;
default:
throw new UnsupportedOperationException("Unknown or unsupported propagation policy for " + method + " :" + propagation);
}
}
public void onExit() throws SecurityException, HeuristicMixedException, HeuristicRollbackException, SystemException, InvalidTransactionException, IllegalStateException {
switch (propagation) {
case REQUIRES:
// Are we the owner of the transaction?
Transaction transaction = m_owned.get(Thread.currentThread());
if (transaction != null) { // Owner.
try {
transaction.commit(); // Commit the transaction
m_owned.remove(Thread.currentThread());
handler.transactionCommitted(transaction); // Manage potential notification.
} catch ( RollbackException e) {
m_owned.remove(Thread.currentThread());
// The transaction was rolledback
if (exceptionOnRollback) {
throw new IllegalStateException("The transaction was rolled back : " + e.getMessage());
}
handler.transactionRolledback(transaction); // Manage potential notification.
}
} // Else wait for commit.
break;
case MANDATORY:
// We are never the owner, so just exits the transaction.
break;
case SUPPORTED:
// Do nothing.
break;
case NOT_SUPPORTED:
// Do nothing.
break;
case NEVER:
// Do nothing.
break;
case REQUIRES_NEW:
// We're necessary the owner.
transaction = m_owned.get(Thread.currentThread());
if (transaction == null) {
throw new RuntimeException("Cannot apply the REQUIRES NEW propagation, we're not the transaction owner!");
}
try {
transaction.commit(); // Commit the transaction
m_owned.remove(Thread.currentThread());
handler.transactionCommitted(transaction); // Manage potential notification.
if (suspended != null) {
manager.suspend(); // suspend the completed transaction.
manager.resume(suspended);
suspended = null;
}
} catch ( RollbackException e) { // The transaction was rolledback rather than committed
m_owned.remove(Thread.currentThread());
if (suspended != null) {
manager.suspend(); // suspend the completed transaction.
manager.resume(suspended); // The resume transaction is not rolledback, they are independent.
suspended = null;
}
// The transaction was rolledback
if (exceptionOnRollback) {
throw new IllegalStateException("The transaction was rolled back : " + e.getMessage());
}
handler.transactionRolledback(transaction); // Manage potential notification.
}
break;
default:
throw new UnsupportedOperationException("Unknown or unsupported propagation policy for " + method + " :" + propagation);
}
}
public void onError(String exception) throws SystemException {
TransactionManager manager = null;
synchronized (this) {
if (this.manager != null) {
manager = this.manager; // Stack confinement
} else {
return; // Nothing can be done...
}
}
// is the error something to exclude, and are we inside the transaction (owner or participant)?
if (! exceptions.contains(exception)) {
Transaction tr = manager.getTransaction();
if (m_owned.containsValue(tr) || handler.getTransactions().contains(tr)) {
// Set the transaction to rollback only
manager.getTransaction().setRollbackOnly();
}
}
}
public void onEntry(Object o, Member member, Object[] objects) {
try {
onEntry();
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException("An issue occurs during transaction management of " + method + " : " + e.getMessage());
}
}
public void onError(Object o, Member member, Throwable throwable) {
try {
throwable.printStackTrace();
onError(throwable.getClass().getName());
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException("An issue occurs during transaction management of " + method + " : " + e.getMessage());
}
}
public void onExit(Object o, Member member, Object o1) {
// Wait for on finally.
}
public void onFinally(Object o, Member member) {
try {
onExit();
} catch (IllegalStateException e) {
throw e;
} catch (Exception e) {
throw new RuntimeException("An issue occurs during transaction management of " + method + " : " + e.getMessage());
}
}
public void rollbackOwnedTransactions() {
Iterator<Entry<Thread, Transaction>> entries = m_owned.entrySet().iterator();
while(entries.hasNext()) {
Entry<Thread, Transaction> entry = entries.next();
try {
entry.getValue().rollback();
} catch (IllegalStateException e) {
throw new RuntimeException("An issue occurs during transaction management of " + method + " : " + e.getMessage());
} catch (SystemException e) {
throw new RuntimeException("An issue occurs during transaction management of " + method + " : " + e.getMessage());
}
}
m_owned.clear();
}
}