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()));
 }
Esempio n. 4
0
 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);
    }
  }