@Test
  public void existingNonSpringTransaction() {
    MockUOWManager manager = new MockUOWManager();
    manager.setUOWStatus(UOWManager.UOW_STATUS_ACTIVE);
    WebSphereUowTransactionManager ptm = new WebSphereUowTransactionManager(manager);
    DefaultTransactionDefinition definition = new DefaultTransactionDefinition();

    assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
    assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
    assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());

    assertEquals(
        "result",
        ptm.execute(
            definition,
            new TransactionCallback<String>() {
              @Override
              public String doInTransaction(TransactionStatus status) {
                assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
                assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
                assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
                return "result";
              }
            }));

    assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
    assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
    assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());

    assertEquals(0, manager.getUOWTimeout());
    assertEquals(UOWManager.UOW_TYPE_GLOBAL_TRANSACTION, manager.getUOWType());
    assertTrue(manager.getJoined());
    assertFalse(manager.getRollbackOnly());
  }
  private void doTestExistingTransactionWithSuspension(final int propagationBehavior) {
    MockUOWManager manager = new MockUOWManager();
    final WebSphereUowTransactionManager ptm = new WebSphereUowTransactionManager(manager);
    DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
    final DefaultTransactionDefinition definition2 = new DefaultTransactionDefinition();
    definition2.setPropagationBehavior(propagationBehavior);
    definition2.setReadOnly(true);

    assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
    assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
    assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());

    assertEquals(
        "result",
        ptm.execute(
            definition,
            new TransactionCallback<String>() {
              @Override
              public String doInTransaction(TransactionStatus status) {
                assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
                assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
                assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
                assertEquals(
                    "result2",
                    ptm.execute(
                        definition2,
                        new TransactionCallback<String>() {
                          @Override
                          public String doInTransaction(TransactionStatus status) {
                            assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
                            assertEquals(
                                propagationBehavior
                                    == TransactionDefinition.PROPAGATION_REQUIRES_NEW,
                                TransactionSynchronizationManager.isActualTransactionActive());
                            assertTrue(
                                TransactionSynchronizationManager.isCurrentTransactionReadOnly());
                            return "result2";
                          }
                        }));
                return "result";
              }
            }));

    assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
    assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
    assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());

    assertEquals(0, manager.getUOWTimeout());
    if (propagationBehavior == TransactionDefinition.PROPAGATION_REQUIRES_NEW) {
      assertEquals(UOWManager.UOW_TYPE_GLOBAL_TRANSACTION, manager.getUOWType());
    } else {
      assertEquals(UOWManager.UOW_TYPE_LOCAL_TRANSACTION, manager.getUOWType());
    }
    assertFalse(manager.getJoined());
    assertFalse(manager.getRollbackOnly());
  }
 public Object invoke(MethodInvocation methodInvocation) throws Throwable {
   if (methodInvocation.getMethod().getName().equals("setSomething")) {
     assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
     assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
   } else {
     assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
     assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
   }
   return methodInvocation.proceed();
 }
  @Test
  public void existingTransactionUsingPropagationNotSupported() {
    MockUOWManager manager = new MockUOWManager();
    final WebSphereUowTransactionManager ptm = new WebSphereUowTransactionManager(manager);
    DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
    final DefaultTransactionDefinition definition2 = new DefaultTransactionDefinition();
    definition2.setPropagationBehavior(TransactionDefinition.PROPAGATION_NOT_SUPPORTED);
    definition2.setReadOnly(true);

    assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
    assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
    assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());

    assertEquals(
        "result",
        ptm.execute(
            definition,
            new TransactionCallback<String>() {
              @Override
              public String doInTransaction(TransactionStatus status) {
                assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
                assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
                assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
                assertEquals(
                    "result2",
                    ptm.execute(
                        definition2,
                        new TransactionCallback<String>() {
                          @Override
                          public String doInTransaction(TransactionStatus status) {
                            assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
                            assertFalse(
                                TransactionSynchronizationManager.isActualTransactionActive());
                            assertTrue(
                                TransactionSynchronizationManager.isCurrentTransactionReadOnly());
                            return "result2";
                          }
                        }));
                return "result";
              }
            }));

    assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
    assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
    assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());

    assertEquals(0, manager.getUOWTimeout());
    assertEquals(UOWManager.UOW_TYPE_LOCAL_TRANSACTION, manager.getUOWType());
    assertFalse(manager.getJoined());
    assertFalse(manager.getRollbackOnly());
  }
  @Test
  public void newTransactionWithCommitException() {
    final RollbackException rex = new RollbackException();
    MockUOWManager manager =
        new MockUOWManager() {
          @Override
          public void runUnderUOW(int type, boolean join, UOWAction action) throws UOWException {
            throw new UOWException(rex);
          }
        };
    WebSphereUowTransactionManager ptm = new WebSphereUowTransactionManager(manager);
    DefaultTransactionDefinition definition = new DefaultTransactionDefinition();

    assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
    assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
    assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());

    try {
      ptm.execute(
          definition,
          new TransactionCallback<String>() {
            @Override
            public String doInTransaction(TransactionStatus status) {
              assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
              assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
              assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
              return "result";
            }
          });
      fail("Should have thrown TransactionSystemException");
    } catch (TransactionSystemException ex) {
      // expected
      assertTrue(ex.getCause() instanceof UOWException);
      assertSame(rex, ex.getRootCause());
      assertSame(rex, ex.getMostSpecificCause());
    }

    assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
    assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
    assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());

    assertEquals(0, manager.getUOWTimeout());
  }
  @After
  public void tearDown() throws Exception {
    if (this.transactionStatus != null && !this.transactionStatus.isCompleted()) {
      endTransaction();
    }

    assertTrue(TransactionSynchronizationManager.getResourceMap().isEmpty());
    assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
    assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
    assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
  }
  private void doTestNewTransactionWithCommit(int propagationBehavior, final int synchMode) {
    MockUOWManager manager = new MockUOWManager();
    WebSphereUowTransactionManager ptm = new WebSphereUowTransactionManager(manager);
    ptm.setTransactionSynchronization(synchMode);
    DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
    definition.setPropagationBehavior(propagationBehavior);
    definition.setReadOnly(true);

    assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
    assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
    assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());

    assertEquals(
        "result",
        ptm.execute(
            definition,
            new TransactionCallback<String>() {
              @Override
              public String doInTransaction(TransactionStatus status) {
                if (synchMode != WebSphereUowTransactionManager.SYNCHRONIZATION_NEVER) {
                  assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
                  assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
                  assertTrue(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
                } else {
                  assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
                  assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
                  assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
                }
                return "result";
              }
            }));

    assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
    assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
    assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());

    assertEquals(0, manager.getUOWTimeout());
    assertEquals(UOWManager.UOW_TYPE_GLOBAL_TRANSACTION, manager.getUOWType());
    assertFalse(manager.getJoined());
    assertFalse(manager.getRollbackOnly());
  }
예제 #8
0
 public static void afterCommit(final Runnable action) {
   if (TransactionSynchronizationManager.isActualTransactionActive()) {
     TransactionSynchronizationManager.registerSynchronization(
         new TransactionSynchronizationAdapter() {
           @Override
           public void afterCommit() {
             action.run();
           }
         });
   } else {
     action.run();
   }
 }
 public static void doBeforeCommit(final InvokationCallback invokationCallback) {
   if (TransactionSynchronizationManager.isActualTransactionActive()) {
     TransactionSynchronizationManager.registerSynchronization(
         new TransactionSynchronizationAdapter() {
           public void beforeCommit(boolean readOnly) {
             invokationCallback.invoke();
           }
         });
   } else {
     // invoke now
     invokationCallback.invoke();
   }
 }
  @Test
  public void newTransactionWithRollback() {
    MockUOWManager manager = new MockUOWManager();
    WebSphereUowTransactionManager ptm = new WebSphereUowTransactionManager(manager);
    DefaultTransactionDefinition definition = new DefaultTransactionDefinition();

    assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
    assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
    assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());

    try {
      ptm.execute(
          definition,
          new TransactionCallback<String>() {
            @Override
            public String doInTransaction(TransactionStatus status) {
              assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
              assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
              assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
              throw new OptimisticLockingFailureException("");
            }
          });
      fail("Should have thrown OptimisticLockingFailureException");
    } catch (OptimisticLockingFailureException ex) {
      // expected
    }

    assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
    assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
    assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());

    assertEquals(0, manager.getUOWTimeout());
    assertEquals(UOWManager.UOW_TYPE_GLOBAL_TRANSACTION, manager.getUOWType());
    assertFalse(manager.getJoined());
    assertTrue(manager.getRollbackOnly());
  }
 /**
  * this method checks if there is a transaction active and registers an afterCommit invokation of
  * the InvokationCallback. if there is no transaction active it invokes the InvokationCallback
  * immediately.
  *
  * @param invokationCallback
  */
 public static void doAfterCommit(final InvokationCallback invokationCallback) {
   // currentlly supports spring synchronization
   if (TransactionSynchronizationManager.isActualTransactionActive()) {
     TransactionSynchronizationManager.registerSynchronization(
         new TransactionSynchronizationAdapter() {
           @Override
           public void afterCommit() {
             invokationCallback.invoke();
           }
         });
   } else {
     // invoke now
     invokationCallback.invoke();
   }
 }
 @EventListener
 public void blogAddedTransactionalOldSchool(final BlogAddedEvent blogAddedEvent) {
   // Note: *Old school* transaction handling before Spring 4.2
   if (TransactionSynchronizationManager
       .isActualTransactionActive()) { // To not fail with "java.lang.IllegalStateException:
                                       // Transaction synchronization is not active"
     TransactionSynchronizationManager.registerSynchronization(
         new TransactionSynchronizationAdapter() {
           @Override
           public void afterCommit() {
             internalSendBlogAddedNotification(blogAddedEvent);
           }
         });
   } else {
     log.warn("No active transaction found. Sending notification immediately.");
     internalSendBlogAddedNotification(blogAddedEvent);
   }
 }
  /** Borrowed from Seam */
  public int getStatus() {
    if (ptm == null) {
      return TransactionManager.STATUS_NO_TRANSACTION;
    }

    // logger.debug( "Current TX name (According to TransactionSynchronizationManager) : " +
    // TransactionSynchronizationManager.getCurrentTransactionName() );
    if (TransactionSynchronizationManager.isActualTransactionActive()) {
      TransactionStatus transaction = null;
      boolean commitNewTransaction = false;
      try {
        if (currentTransaction.size() == 0) {
          transaction = ptm.getTransaction(td);
          currentTransaction.push(transaction);
          commitNewTransaction = true;
          if (transaction.isNewTransaction()) {
            return TransactionManager.STATUS_COMMITTED;
          }
        } else {
          transaction = currentTransaction.peek();
        }
        logger.debug("Current TX: " + transaction);
        // If SynchronizationManager thinks it has an active transaction but
        // our transaction is a new one
        // then we must be in the middle of committing
        if (transaction.isCompleted()) {
          if (transaction.isRollbackOnly()) {
            return TransactionManager.STATUS_ROLLEDBACK;
          }
          return TransactionManager.STATUS_COMMITTED;
        } else {
          if (transaction.isRollbackOnly()) {
            return 5;
          }
          return TransactionManager.STATUS_ACTIVE;
        }
      } finally {
        if (commitNewTransaction) {
          ptm.commit(transaction);
        }
      }
    }
    return TransactionManager.STATUS_NO_TRANSACTION;
  }
 private void validateTransaction() {
   if (!TransactionSynchronizationManager.isActualTransactionActive()) {
     throw new TransactionRequiredException();
   }
 }
 private static boolean isActualNonReadonlyTransactionActive() {
   return TransactionSynchronizationManager.isActualTransactionActive()
       && !TransactionSynchronizationManager.isCurrentTransactionReadOnly();
 }