public void testGetTimeout() {
Properties p = new Properties();
p.setProperty(TransactionCoordinator.TXN_TIMEOUT_PROPERTY, "5000");
p.setProperty(TransactionCoordinator.TXN_UNBOUNDED_TIMEOUT_PROPERTY, "100000");
TransactionCoordinator coordinator = new TransactionCoordinatorImpl(p, null);
Transaction txn = coordinator.createTransaction(false).getTransaction();
assertTrue(
"Incorrect bounded Transaction timeout: " + txn.getTimeout(), txn.getTimeout() == 5000);
txn = coordinator.createTransaction(true).getTransaction();
assertTrue(
"Incorrect unbounded Transaction timeout: " + txn.getTimeout(), txn.getTimeout() == 100000);
}
public void testGetCreationTime() throws Exception {
long now = System.currentTimeMillis();
Thread.sleep(50);
Transaction txn1 = coordinator.createTransaction(false).getTransaction();
Thread.sleep(50);
Transaction txn2 = coordinator.createTransaction(false).getTransaction();
assertTrue(
"Transaction creation time is too early: " + txn1.getCreationTime(),
now < txn1.getCreationTime());
assertTrue(
"Transaction creation times out-of-order: "
+ txn1.getCreationTime()
+ " vs "
+ txn2.getCreationTime(),
txn1.getCreationTime() < txn2.getCreationTime());
}
public void testGetId() {
txn.abort(abortXcp);
Transaction txn2 = coordinator.createTransaction(false).getTransaction();
assertNotNull(txn.getId());
assertNotNull(txn2.getId());
assertFalse(Arrays.equals(txn.getId(), txn2.getId()));
}
public TransactionHandle createTransaction(boolean unbounded) {
if (txnCoordinator != null) {
return txnCoordinator.createTransaction(unbounded);
}
DummyTransaction txn = new DummyTransaction();
proxy.setCurrentTransaction(txn);
return new TestTransactionHandle(txn);
}
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);
}
}
/** 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 testEquals() throws Exception {
Transaction txn2 = coordinator.createTransaction(false).getTransaction();
assertFalse(txn.equals(null));
assertTrue(txn.equals(txn));
assertFalse(txn.equals(txn2));
}
/**
* 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);
}
}