Package org.hibernate.transaction.synchronization

Examples of org.hibernate.transaction.synchronization.CallbackCoordinator


            throw new AssertionFailure( "Transaction MARKED_FOR_JOINED after isOpen() call" );
          }
          //flush before completion and
          //register clear on rollback
          log.trace( "Adding flush() and close() synchronization" );
          CallbackCoordinator callbackCoordinator = ( (SessionImplementor ) getSession() ).getJDBCContext().getJtaSynchronizationCallbackCoordinator();
          if ( callbackCoordinator == null ) {
            throw new AssertionFailure( "Expecting CallbackCoordinator to be non-null" );
          }
          callbackCoordinator.setBeforeCompletionManagedFlushChecker(
              new BeforeCompletionManagedFlushChecker() {
                public boolean shouldDoManagedFlush(TransactionFactory.Context ctx, javax.transaction.Transaction jtaTransaction)
                    throws SystemException {
                  if ( transaction == null ) {
                    log.warn( "Transaction not available on beforeCompletion: assuming valid" );
                  }
                  return !ctx.isFlushModeNever()
                      && ( jtaTransaction == null || !JTAHelper.isRollback( jtaTransaction.getStatus() ) );
                }
              }
          );
          callbackCoordinator.setAfterCompletionAction(
              new AfterCompletionAction() {
                public void doAction(TransactionFactory.Context ctx, int status) {
                  try {
                    if ( !ctx.isClosed() ) {
                      if ( Status.STATUS_ROLLEDBACK == status
                          && transactionType == PersistenceUnitTransactionType.JTA ) {
                        session.clear();
                      }
                      JoinableCMTTransaction joinable = ( JoinableCMTTransaction ) session.getTransaction();
                      joinable.resetStatus();
                    }
                  }
                  catch ( HibernateException e ) {
                    throw convert( e );
                  }
                }
              }
          );
          callbackCoordinator.setExceptionMapper(
              new ExceptionMapper() {
                public RuntimeException mapStatusCheckFailure(String message, SystemException systemException) {
                  throw new PersistenceException( message, systemException );
                }
View Full Code Here


  public CallbackCoordinator getJtaSynchronizationCallbackCoordinator() {
    return jtaSynchronizationCallbackCoordinator;
  }

  public CallbackCoordinator getJtaSynchronizationCallbackCoordinator(javax.transaction.Transaction jtaTransaction) {
    jtaSynchronizationCallbackCoordinator = new CallbackCoordinator( owner, this, jtaTransaction, hibernateTransaction );
    return jtaSynchronizationCallbackCoordinator;
  }
View Full Code Here

            throw new AssertionFailure( "Transaction MARKED_FOR_JOINED after isOpen() call" );
          }
          //flush before completion and
          //register clear on rollback
          log.trace( "Adding flush() and close() synchronization" );
          CallbackCoordinator callbackCoordinator = ( (SessionImplementor ) getSession() ).getJDBCContext().getJtaSynchronizationCallbackCoordinator();
          if ( callbackCoordinator == null ) {
            throw new AssertionFailure( "Expecting CallbackCoordinator to be non-null" );
          }
          callbackCoordinator.setBeforeCompletionManagedFlushChecker(
              new BeforeCompletionManagedFlushChecker() {
                public boolean shouldDoManagedFlush(TransactionFactory.Context ctx, javax.transaction.Transaction jtaTransaction)
                    throws SystemException {
                  if ( transaction == null ) {
                    log.warn( "Transaction not available on beforeCompletion: assuming valid" );
                  }
                  return !ctx.isFlushModeNever()
                      && ( jtaTransaction == null || !JTAHelper.isRollback( jtaTransaction.getStatus() ) );
                }
              }
          );
          callbackCoordinator.setAfterCompletionAction(
              new AfterCompletionAction() {
                public void doAction(TransactionFactory.Context ctx, int status) {
                  try {
                    if ( !ctx.isClosed() ) {
                      if ( Status.STATUS_ROLLEDBACK == status
                          && transactionType == PersistenceUnitTransactionType.JTA ) {
                        session.clear();
                      }
                      JoinableCMTTransaction joinable = ( JoinableCMTTransaction ) session.getTransaction();
                      joinable.resetStatus();
                    }
                  }
                  catch ( HibernateException e ) {
                    throw convert( e );
                  }
                }
              }
          );
          callbackCoordinator.setExceptionMapper(
              new ExceptionMapper() {
                public RuntimeException mapStatusCheckFailure(String message, SystemException systemException) {
                  throw new PersistenceException( message, systemException );
                }
View Full Code Here

            throw new AssertionFailure( "Transaction MARKED_FOR_JOINED after isOpen() call" );
          }
          //flush before completion and
          //register clear on rollback
          log.trace( "Adding flush() and close() synchronization" );
          CallbackCoordinator callbackCoordinator = ( (SessionImplementor ) getSession() ).getJDBCContext().getJtaSynchronizationCallbackCoordinator();
          if ( callbackCoordinator == null ) {
            throw new AssertionFailure( "Expecting CallbackCoordinator to be non-null" );
          }
          callbackCoordinator.setBeforeCompletionManagedFlushChecker(
              new BeforeCompletionManagedFlushChecker() {
                public boolean shouldDoManagedFlush(TransactionFactory.Context ctx, javax.transaction.Transaction jtaTransaction)
                    throws SystemException {
                  if ( transaction == null ) {
                    log.warn( "Transaction not available on beforeCompletion: assuming valid" );
                  }
                  return !ctx.isFlushModeNever()
                      && ( jtaTransaction == null || !JTAHelper.isRollback( jtaTransaction.getStatus() ) );
                }
              }
          );
          callbackCoordinator.setAfterCompletionAction(
              new AfterCompletionAction() {
                public void doAction(TransactionFactory.Context ctx, int status) {
                  try {
                    if ( !ctx.isClosed() ) {
                      if ( Status.STATUS_ROLLEDBACK == status
                          && transactionType == PersistenceUnitTransactionType.JTA ) {
                        session.clear();
                      }
                      JoinableCMTTransaction joinable = ( JoinableCMTTransaction ) session.getTransaction();
                      joinable.resetStatus();
                    }
                  }
                  catch ( HibernateException e ) {
                    throw convert( e );
                  }
                }
              }
          );
          callbackCoordinator.setExceptionMapper(
              new ExceptionMapper() {
                public RuntimeException mapStatusCheckFailure(String message, SystemException systemException) {
                  throw new PersistenceException( message, systemException );
                }
View Full Code Here

            throw new AssertionFailure( "Transaction MARKED_FOR_JOINED after isOpen() call" );
          }
          //flush before completion and
          //register clear on rollback
          log.trace( "Adding flush() and close() synchronization" );
          CallbackCoordinator callbackCoordinator = ( (SessionImplementor ) getSession() ).getJDBCContext().getJtaSynchronizationCallbackCoordinator();
          if ( callbackCoordinator == null ) {
            throw new AssertionFailure( "Expecting CallbackCoordinator to be non-null" );
          }
          callbackCoordinator.setBeforeCompletionManagedFlushChecker(
              new BeforeCompletionManagedFlushChecker() {
                public boolean shouldDoManagedFlush(TransactionFactory.Context ctx, javax.transaction.Transaction jtaTransaction)
                    throws SystemException {
                  if ( transaction == null ) {
                    log.warn( "Transaction not available on beforeCompletion: assuming valid" );
                  }
                  return !ctx.isFlushModeNever()
                      && ( jtaTransaction == null || !JTAHelper.isRollback( jtaTransaction.getStatus() ) );
                }
              }
          );
          callbackCoordinator.setAfterCompletionAction(
              new AfterCompletionAction() {
                public void doAction(TransactionFactory.Context ctx, int status) {
                  try {
                    if ( !ctx.isClosed() ) {
                      if ( Status.STATUS_ROLLEDBACK == status
                          && transactionType == PersistenceUnitTransactionType.JTA ) {
                        session.clear();
                      }
                      JoinableCMTTransaction joinable = ( JoinableCMTTransaction ) session.getTransaction();
                      joinable.resetStatus();
                    }
                  }
                  catch ( HibernateException e ) {
                    throw convert( e );
                  }
                }
              }
          );
          callbackCoordinator.setExceptionMapper(
              new ExceptionMapper() {
                public RuntimeException mapStatusCheckFailure(String message, SystemException systemException) {
                  throw new PersistenceException( message, systemException );
                }
View Full Code Here

            throw new AssertionFailure( "Transaction MARKED_FOR_JOINED after isOpen() call" );
          }
          //flush before completion and
          //register clear on rollback
          log.trace( "Adding flush() and close() synchronization" );
          CallbackCoordinator callbackCoordinator = ( (SessionImplementor ) getSession() ).getJDBCContext().getJtaSynchronizationCallbackCoordinator();
          if ( callbackCoordinator == null ) {
            throw new AssertionFailure( "Expecting CallbackCoordinator to be non-null" );
          }
          callbackCoordinator.setBeforeCompletionManagedFlushChecker(
              new BeforeCompletionManagedFlushChecker() {
                public boolean shouldDoManagedFlush(TransactionFactory.Context ctx, javax.transaction.Transaction jtaTransaction)
                    throws SystemException {
                  if ( transaction == null ) {
                    log.warn( "Transaction not available on beforeCompletion: assuming valid" );
                  }
                  return !ctx.isFlushModeNever()
                      && ( jtaTransaction == null || !JTAHelper.isRollback( jtaTransaction.getStatus() ) );
                }
              }
          );
          callbackCoordinator.setAfterCompletionAction(
              new AfterCompletionAction() {
                public void doAction(TransactionFactory.Context ctx, int status) {
                  try {
                    if ( !ctx.isClosed() ) {
                      if ( Status.STATUS_ROLLEDBACK == status
                          && transactionType == PersistenceUnitTransactionType.JTA ) {
                        session.clear();
                      }
                      JoinableCMTTransaction joinable = ( JoinableCMTTransaction ) session.getTransaction();
                      joinable.resetStatus();
                    }
                  }
                  catch ( HibernateException e ) {
                    throw convert( e );
                  }
                }
              }
          );
          callbackCoordinator.setExceptionMapper(
              new ExceptionMapper() {
                public RuntimeException mapStatusCheckFailure(String message, SystemException systemException) {
                  throw new PersistenceException( message, systemException );
                }
View Full Code Here

TOP

Related Classes of org.hibernate.transaction.synchronization.CallbackCoordinator

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.