public void testAbortSupplyCause() throws Exception {
Exception abortCause = new Exception("The cause");
txn.abort(abortCause);
assertAborted(abortCause);
try {
txn.abort(new IllegalArgumentException());
fail("Expected TransactionNotActiveException");
} catch (TransactionNotActiveException e) {
System.err.println(e);
assertEquals(abortCause, e.getCause());
}
assertAborted(abortCause);
try {
txn.abort(abortXcp);
fail("Expected TransactionNotActiveException");
} catch (TransactionNotActiveException e) {
System.err.println(e);
assertEquals(abortCause, e.getCause());
}
assertAborted(abortCause);
handle.getTransaction();
try {
handle.commit();
fail("Expected TransactionNotActiveException");
} catch (TransactionNotActiveException e) {
System.err.println(e);
assertEquals(abortCause, e.getCause());
}
assertAborted(abortCause);
}
public void testCommitCommitted() throws Exception {
txn.join(new DummyTransactionParticipant());
handle.commit();
try {
handle.commit();
fail("Expected IllegalStateException");
} catch (IllegalStateException e) {
System.err.println(e);
}
assertCommitted();
}
public void testCommitFails() throws Exception {
DummyTransactionParticipant[] participants = {
new DummyNonDurableTransactionParticipant(),
new DummyNonDurableTransactionParticipant() {
protected boolean prepareResult() {
return true;
}
},
new DummyNonDurableTransactionParticipant() {
public void commit(Transaction txn) {
throw new RuntimeException("Commit failed");
}
},
new DummyNonDurableTransactionParticipant() {
protected boolean prepareResult() {
return true;
}
},
new DummyTransactionParticipant() {}
};
for (TransactionParticipant participant : participants) {
txn.join(participant);
}
handle.commit();
for (DummyTransactionParticipant participant : participants) {
if (!participant.prepareReturnedTrue()) {
assertEquals(
(participant == participants[2] ? State.PREPARED : State.COMMITTED),
participant.getState());
}
}
assertCommitted();
}
public void testCheckTimeoutPreparingTimedOut() throws Exception {
final Exception[] checkTimeoutException = {null};
DummyTransactionParticipant[] participants = {
new DummyNonDurableTransactionParticipant() {
public boolean prepare(Transaction txn) throws Exception {
try {
txn.checkTimeout();
return super.prepare(txn);
} catch (RuntimeException e) {
checkTimeoutException[0] = e;
throw e;
}
}
},
new DummyTransactionParticipant()
};
for (DummyTransactionParticipant participant : participants) {
txn.join(participant);
}
Thread.sleep(TIMED_OUT);
try {
handle.commit();
fail("Expected TransactionTimeoutException");
} catch (TransactionTimeoutException e) {
System.err.println(e);
assertEquals(e, checkTimeoutException[0]);
}
}
public void testCommitPrepareAbortsAndFailsLast() throws Exception {
DummyTransactionParticipant[] participants = {
new DummyNonDurableTransactionParticipant(),
new DummyNonDurableTransactionParticipant() {
protected boolean prepareResult() {
return true;
}
},
new DummyTransactionParticipant() {
public void prepareAndCommit(Transaction txn) throws Exception {
try {
txn.abort(abortXcp);
} catch (RuntimeException e) {
fail("Unexpected exception: " + e);
}
throw new IOException("Prepare failed");
}
}
};
for (TransactionParticipant participant : participants) {
txn.join(participant);
}
try {
handle.commit();
fail("Expected IOException");
} catch (IOException e) {
System.err.println(e);
}
for (DummyTransactionParticipant participant : participants) {
if (!participant.prepareReturnedTrue()) {
assertEquals(State.ABORTED, participant.getState());
}
}
assertAborted(abortXcp);
}
public void testCommitAbortedWithNoCause() throws Exception {
txn.abort(abortXcp);
try {
handle.commit();
fail("Expected TransactionNotActiveException");
} catch (TransactionNotActiveException e) {
System.err.println(e);
assertFalse(retryable(e));
}
}
public void testCheckTimeoutCommitted() throws Exception {
handle.commit();
try {
txn.checkTimeout();
fail("Expected TransactionNotActiveException");
} catch (TransactionNotActiveException e) {
System.err.println(e);
}
handle = coordinator.createTransaction(false);
txn = handle.getTransaction();
Thread.sleep(TIMED_OUT);
handle.commit();
try {
txn.checkTimeout();
fail("Expected TransactionNotActiveException");
} catch (TransactionNotActiveException e) {
System.err.println(e);
}
}
public void testCommitAborted() throws Exception {
txn.join(new DummyTransactionParticipant());
txn.abort(abortXcp);
try {
handle.commit();
fail("Expected TransactionNotActiveException");
} catch (TransactionNotActiveException e) {
System.err.println(e);
}
assertAborted(abortXcp);
}
void assertCommitted() {
assertFalse(txn.isAborted());
assertEquals(null, txn.getAbortCause());
try {
handle.getTransaction().join(new DummyTransactionParticipant());
fail("Transaction was active");
} catch (IllegalStateException e) {
} catch (RuntimeException e) {
fail("Unexpected exception: " + e);
}
}
public void testGetTransactionCommitting() throws Exception {
TransactionParticipant participant =
new DummyTransactionParticipant() {
public void commit(Transaction txn) {
handle.getTransaction();
super.commit(txn);
}
};
txn.join(participant);
handle.commit();
}
public void testCommitAbortedWithNonRetryableCause() throws Exception {
Exception abortCause = new IllegalArgumentException();
txn.abort(abortCause);
try {
handle.commit();
fail("Expected TransactionNotActiveException");
} catch (TransactionNotActiveException e) {
System.err.println(e);
assertFalse(retryable(e));
assertEquals(abortCause, e.getCause());
}
assertAborted(abortCause);
}
public void testCheckTimeoutCommitting() throws Exception {
final Exception[] checkTimeoutException = {null};
DummyTransactionParticipant participant =
new DummyTransactionParticipant() {
public void commit(Transaction txn) {
try {
txn.checkTimeout();
} catch (RuntimeException e) {
checkTimeoutException[0] = e;
throw e;
}
}
};
txn.join(participant);
handle.commit();
assertNull(checkTimeoutException[0]);
}
public void testJoinPreparing() throws Exception {
final Exception[] abortCause = {null};
DummyTransactionParticipant[] participants = {
new DummyNonDurableTransactionParticipant(),
new DummyNonDurableTransactionParticipant() {
protected boolean prepareResult() {
return true;
}
},
new DummyNonDurableTransactionParticipant() {
public boolean prepare(Transaction txn) {
try {
txn.join(this);
fail("Expected IllegalStateException");
} catch (IllegalStateException e) {
System.err.println(e);
abortCause[0] = e;
throw e;
} catch (RuntimeException e) {
fail("Unexpected exception: " + e);
}
return false;
}
},
new DummyNonDurableTransactionParticipant() {
protected boolean prepareResult() {
return true;
}
}
};
for (TransactionParticipant participant : participants) {
txn.join(participant);
}
try {
handle.commit();
fail("Expected IllegalStateException");
} catch (IllegalStateException e) {
System.err.println(e);
}
for (DummyTransactionParticipant participant : participants) {
if (!participant.prepareReturnedTrue()) {
assertEquals(State.ABORTED, participant.getState());
}
}
assertAborted(abortCause[0]);
}
public void testAbortCommitting() throws Exception {
DummyTransactionParticipant[] participants = {
new DummyNonDurableTransactionParticipant(),
new DummyNonDurableTransactionParticipant() {
protected boolean prepareResult() {
return true;
}
},
new DummyNonDurableTransactionParticipant() {
public void commit(Transaction txn) {
assertNotAborted();
try {
txn.abort(abortXcp);
fail("Expected IllegalStateException");
} catch (IllegalStateException e) {
System.err.println(e);
throw e;
} catch (RuntimeException e) {
fail("Unexpected exception: " + e);
}
}
},
new DummyNonDurableTransactionParticipant() {
protected boolean prepareResult() {
return true;
}
}
};
for (TransactionParticipant participant : participants) {
txn.join(participant);
}
handle.commit();
for (DummyTransactionParticipant participant : participants) {
if (!participant.prepareReturnedTrue()) {
assertEquals(
participant == participants[2] ? State.PREPARED : State.COMMITTED,
participant.getState());
}
}
assertCommitted();
}
public void testCommitActive() throws Exception {
DummyTransactionParticipant[] participants = {
new DummyNonDurableTransactionParticipant(),
new DummyNonDurableTransactionParticipant() {
protected boolean prepareResult() {
return true;
}
},
new DummyTransactionParticipant()
};
for (TransactionParticipant participant : participants) {
txn.join(participant);
}
handle.commit();
for (DummyTransactionParticipant participant : participants) {
if (!participant.prepareReturnedTrue()) {
assertEquals(State.COMMITTED, participant.getState());
}
}
assertCommitted();
}
public void testCheckTimeoutPreparing() throws Exception {
final Exception[] checkTimeoutException = {null};
DummyTransactionParticipant[] participants = {
new DummyNonDurableTransactionParticipant() {
public boolean prepare(Transaction txn) throws Exception {
try {
txn.checkTimeout();
return super.prepare(txn);
} catch (RuntimeException e) {
checkTimeoutException[0] = e;
throw e;
}
}
},
new DummyTransactionParticipant()
};
for (DummyTransactionParticipant participant : participants) {
txn.join(participant);
}
handle.commit();
assertNull(checkTimeoutException[0]);
}
public void testCheckTimeoutPrepareAndCommittingTimedOut() throws Exception {
final Exception[] checkTimeoutException = {null};
DummyTransactionParticipant participant =
new DummyTransactionParticipant() {
public void prepareAndCommit(Transaction txn) {
try {
txn.checkTimeout();
} catch (RuntimeException e) {
checkTimeoutException[0] = e;
throw e;
}
}
};
txn.join(participant);
Thread.sleep(TIMED_OUT);
try {
handle.commit();
fail("Expected TransactionTimeoutException");
} catch (TransactionTimeoutException e) {
System.err.println(e);
assertEquals(e, checkTimeoutException[0]);
}
}
public void testCommitPrepareFailsMiddle() throws Exception {
final Exception abortCause = new IOException("Prepare failed");
DummyTransactionParticipant[] participants = {
new DummyNonDurableTransactionParticipant(),
new DummyNonDurableTransactionParticipant() {
protected boolean prepareResult() {
return true;
}
},
new DummyNonDurableTransactionParticipant() {
public boolean prepare(Transaction txn) throws Exception {
throw abortCause;
}
},
new DummyNonDurableTransactionParticipant() {
protected boolean prepareResult() {
return true;
}
},
new DummyTransactionParticipant()
};
for (TransactionParticipant participant : participants) {
txn.join(participant);
}
try {
handle.commit();
fail("Expected IOException");
} catch (IOException e) {
System.err.println(e);
}
for (DummyTransactionParticipant participant : participants) {
if (!participant.prepareReturnedTrue()) {
assertEquals(State.ABORTED, participant.getState());
}
}
assertAborted(abortCause);
}
public void testAbortPrepareAndCommitting() throws Exception {
final Exception abortCause = new IllegalArgumentException();
DummyTransactionParticipant[] participants = {
new DummyNonDurableTransactionParticipant(),
new DummyNonDurableTransactionParticipant() {
protected boolean prepareResult() {
return true;
}
},
new DummyTransactionParticipant() {
public void prepareAndCommit(Transaction txn) {
assertNotAborted();
try {
txn.abort(abortCause);
} catch (RuntimeException e) {
fail("Unexpected exception: " + e);
}
}
}
};
for (TransactionParticipant participant : participants) {
txn.join(participant);
}
try {
handle.commit();
fail("Expected TransactionAbortedException");
} catch (TransactionAbortedException e) {
System.err.println(e);
assertEquals(abortCause, e.getCause());
}
for (DummyTransactionParticipant participant : participants) {
if (!participant.prepareReturnedTrue()) {
assertEquals(State.ABORTED, participant.getState());
}
}
assertAborted(abortCause);
}
/**
* Private method that executes a single task, creating the transaction state and handling re-try
* as appropriate. If the thread calling this method is interrupted before the task can complete
* then this method attempts to re-schedule the task to run in another thread if {@code
* retryOnInterruption} is {@code true} and always re-throws the associated {@code
* InterruptedException}. Providing {@code true} for the {@code unbounded} parameter results in a
* transaction with timeout value as specified by the value of the {@code
* TransactionCoordinator.TXN_UNBOUNDED_TIMEOUT_PROPERTY} property.
*
* <p>This method returns {@code true} if the task was completed or failed permanently, and {@code
* false} otherwise. If {@code false} is returned then the task is scheduled to be re-tried at
* some point in the future, possibly by another thread, by this method. The caller may query the
* status of the task and wait for the task to complete or fail permanently through the {@code
* ScheduledTaskImpl} interface.
*/
private boolean executeTask(
ScheduledTaskImpl task, boolean unbounded, boolean retryOnInterruption)
throws InterruptedException {
logger.log(Level.FINEST, "starting a new transactional task");
// store the current owner, and then push the new thread detail
Identity parent = ContextResolver.getCurrentOwner();
ContextResolver.setTaskState(kernelContext, task.getOwner());
try {
// keep trying to run the task until we succeed, tracking how
// many tries it actually took
while (true) {
if (!task.setRunning(true)) {
// this task is already finished
return true;
}
// NOTE: We could report the two queue sizes separately,
// so we should figure out how we want to represent these
int waitSize = backingQueue.getReadyCount() + dependencyCount.get();
profileCollectorHandle.startTask(
task.getTask(), task.getOwner(), task.getStartTime(), waitSize);
task.incrementTryCount();
Transaction transaction = null;
try {
// setup the transaction state
TransactionHandle handle = transactionCoordinator.createTransaction(unbounded);
transaction = handle.getTransaction();
ContextResolver.setCurrentTransaction(transaction);
try {
// notify the profiler and access coordinator
profileCollectorHandle.noteTransactional(transaction.getId());
accessCoordinator.notifyNewTransaction(
transaction, task.getStartTime(), task.getTryCount());
// run the task in the new transactional context
task.getTask().run();
} finally {
// regardless of the outcome, always clear the current
// transaction state before proceeding...
ContextResolver.clearCurrentTransaction(transaction);
}
// try to commit the transaction...note that there's the
// chance that the application code masked the orginal
// cause of a failure, so we'll check for that first,
// re-throwing the root cause in that case
if (transaction.isAborted()) {
throw transaction.getAbortCause();
}
handle.commit();
// the task completed successfully, so we're done
profileCollectorHandle.finishTask(task.getTryCount());
task.setDone(null);
return true;
} catch (InterruptedException ie) {
// make sure the transaction was aborted
if (!transaction.isAborted()) {
transaction.abort(ie);
}
profileCollectorHandle.finishTask(task.getTryCount(), ie);
// if the task didn't finish because of the interruption
// then we want to note that and possibly re-queue the
// task to run in a usable thread
if (task.setInterrupted() && retryOnInterruption) {
if (!handoffRetry(task, ie)) {
// if the task couldn't be re-queued, then there's
// nothing left to do but drop it
task.setDone(ie);
if (logger.isLoggable(Level.WARNING)) {
logger.logThrow(Level.WARNING, ie, "dropping " + "an interrupted task: {0}" + task);
}
}
}
// always re-throw the interruption
throw ie;
} catch (Throwable t) {
// make sure the transaction was aborted
if ((transaction != null) && (!transaction.isAborted())) {
transaction.abort(t);
}
profileCollectorHandle.finishTask(task.getTryCount(), t);
// some error occurred, so see if we should re-try
if (!shouldRetry(task, t)) {
// the task is not being re-tried
task.setDone(t);
return true;
} else {
// see if the re-try should be handed-off
task.setRunning(false);
if (handoffRetry(task, t)) {
return false;
}
}
}
}
} finally {
// always restore the previous owner before leaving...
ContextResolver.setTaskState(kernelContext, parent);
}
}
public void testCommitActiveEmpty() throws Exception {
handle.commit();
assertCommitted();
}
/** Prints the test case, sets handle and txn */
protected void setUp() {
System.err.println("Testcase: " + getName());
handle = coordinator.createTransaction(false);
txn = handle.getTransaction();
}
public void testGetTransactionCommitted() throws Exception {
txn.join(new DummyTransactionParticipant());
handle.commit();
handle.getTransaction();
}
public void testGetTransactionActive() {
handle.getTransaction();
}
public void testGetTransactionAborted() {
txn.join(new DummyTransactionParticipant());
txn.abort(abortXcp);
handle.getTransaction();
}