Class XATransactionState

All Implemented Interfaces:
Context

final class XATransactionState extends ContextImpl
  • Field Details

    • TRO_TIMEOUT

      static final int TRO_TIMEOUT
      Rollback-only due to timeout
      See Also:
    • TRO_DEADLOCK

      static final int TRO_DEADLOCK
      Rollback-only due to deadlock
      See Also:
    • TRO_FAIL

      static final int TRO_FAIL
      Rollback-only due to end(TMFAIL)
      See Also:
    • T0_NOT_ASSOCIATED

      static final int T0_NOT_ASSOCIATED
      See Also:
    • T1_ASSOCIATED

      static final int T1_ASSOCIATED
      See Also:
    • TC_COMPLETED

      static final int TC_COMPLETED
      See Also:
    • conn

      final EmbedConnection conn
    • creatingResource

      final EmbedXAResource creatingResource
    • associatedResource

      private EmbedXAResource associatedResource
    • xid

      final XAXactId xid
    • cleanupOrCancelMonitor

    • suspendedList

      When an XAResource suspends a transaction (end(TMSUSPEND)) it must be resumed using the same XAConnection. This has been the traditional Cloudscape/Derby behaviour, though there does not seem to be a specific reference to this behaviour in the JTA spec. Note that while the transaction is suspended by this XAResource, another XAResource may join the transaction and suspend it after the join.
    • associationState

      int associationState
      Association state of the transaction.
    • rollbackOnlyCode

      int rollbackOnlyCode
    • isPrepared

      boolean isPrepared
      has this transaction been prepared.
    • performTimeoutRollback

      boolean performTimeoutRollback
      Indicates whether this transaction is supposed to be rolled back by timeout.
    • timeoutTask

      A timer task scheduled for the time when the transaction will timeout.
  • Constructor Details

  • Method Details

    • getTimerFactory

      private static TimerFactory getTimerFactory()
    • cleanupOnError

      public void cleanupOnError(Throwable t)
      Description copied from interface: Context
      Contexts will be passed errors that are caught by the outer system when they are serious enough to require corrective action. They will be told what the error is, so that they can react appropriately. Most of the time, the contexts will react by either doing nothing or by removing themselves from the context manager. If there are no other references to the context, removing itself from the manager equates to freeing it.
      On an exception that is session severity or greater the Context must push itself off the stack. This is to ensure that after a session has been closed there are no Contexts on the stack that potentially hold references to objects, thus delaying their garbage collection.

      Contexts must release all their resources before removing themselves from their context manager.

      The context manager will "unwind" the contexts during cleanup in the reverse order they were placed on its global stack.

      If error is an instance of StandardException then an implementation of this method may throw a new exception if and only if the new exception is an instance of StandardException that is more severe than the original error or the new exception is a not an instance of StandardException (e.g java.lang.NullPointerException).

    • start

      void start(EmbedXAResource resource, int flags) throws XAException
      Throws:
      XAException
    • end

      boolean end(EmbedXAResource resource, int flags, boolean endingCurrentXid) throws XAException
      Throws:
      XAException
    • scheduleTimeoutTask

      void scheduleTimeoutTask(long timeoutMillis)
      Schedule a timeout task which will rollback the global transaction after the specified time will elapse.
      Parameters:
      timeoutMillis - The number of milliseconds to be elapsed before the transaction will be rolled back.
    • xa_rollback

      void xa_rollback() throws SQLException
      Rollback the global transaction and cancel the timeout task.
      Throws:
      SQLException
    • xa_commit

      void xa_commit(boolean onePhase) throws SQLException
      Commit the global transaction and cancel the timeout task.
      Parameters:
      onePhase - Indicates whether to use one phase commit protocol. Otherwise two phase commit protocol will be used.
      Throws:
      SQLException
    • xa_prepare

      int xa_prepare() throws SQLException
      Prepare the global transaction for commit.
      Throws:
      SQLException
    • xa_finalize

      private void xa_finalize()
      This method cancels timeoutTask and assigns 'performTimeoutRollback = false'.
    • cancel

      void cancel(String messageId) throws XAException
      This function is called from the timer task when the transaction times out.
      Throws:
      XAException
      See Also:
    • getMonitor

      private static ModuleFactory getMonitor()
      Privileged Monitor lookup. Must be private so that user code can't call this entry point.