@Override
public void begin() {
	try {
		if ( getStatus() == TransactionStatus.NOT_ACTIVE ) {
			log.trace( "Calling TransactionManager#begin" );
			transactionManager.begin();
			initiator = true;
			log.trace( "Called TransactionManager#begin" );
		}
		else {
			log.trace( "Skipping TransactionManager#begin due to already active transaction" );
		}
	}
	catch (Exception e) {
		throw new TransactionException( "JTA TransactionManager#begin failed", e );
	}
}
 

@Override
public void begin() {
	try {
		if ( getStatus() == TransactionStatus.NOT_ACTIVE ) {
			log.trace( "Calling UserTransaction#begin" );
			userTransaction.begin();
			initiator = true;
			log.trace( "Called UserTransaction#begin" );
		}
		else {
			log.trace( "Skipping TransactionManager#begin due to already active transaction" );
		}
	}
	catch (Exception e) {
		throw new TransactionException( "JTA UserTransaction#begin failed", e );
	}
}
 

protected void exce(ChannelHandlerContext ctx, ClientPacket packet) throws Exception {
	session = Session.getSession(ctx);
	if(null == session){
		logger.debug("new session for {}",ctx);
		session = Session.create(ctx);
	}
	DB.getSession().getTransaction().begin();
	try{
		onPacket(packet);
		if(DB.getSession().getTransaction().getStatus().isOneOf(TransactionStatus.ACTIVE))
			DB.getSession().getTransaction().commit();
	}catch(Exception e){
		logger.error("onPacket error, {}", packet.protocol , e);
		if(DB.getSession().isOpen())
			DB.getSession().getTransaction().rollback();
	}

}
 

/** {@inheritDoc} */
@Override public void onSessionEnd(CacheStoreSession ses, boolean commit) {
    Session hibSes = ses.attach(null);

    if (hibSes != null) {
        try {
            Transaction tx = hibSes.getTransaction();

            if (commit) {
                if (hibSes.isDirty())
                    hibSes.flush();

                if (tx.getStatus() == TransactionStatus.ACTIVE)
                    tx.commit();
            }
            else if (tx.getStatus().canRollback())
                tx.rollback();
        }
        catch (HibernateException e) {
            throw new CacheWriterException("Failed to end store session [tx=" + ses.transaction() + ']', e);
        }
        finally {
            hibSes.close();
        }
    }
}
 

/** {@inheritDoc} */
@Override protected void afterTest() throws Exception {
    super.afterTest();

    Session s = store.session(null);

    if (s == null)
        return;

    try {
        s.createQuery("delete from " + CacheHibernateBlobStoreEntry.class.getSimpleName())
                .setFlushMode(FlushMode.ALWAYS).executeUpdate();

        Transaction hTx = s.getTransaction();

        if (hTx != null && hTx.getStatus() == TransactionStatus.ACTIVE)
            hTx.commit();
    }
    finally {
        s.close();
    }
}
 

/** {@inheritDoc} */
@Override public void onSessionEnd(CacheStoreSession ses, boolean commit) {
    Session hibSes = ses.attach(null);

    if (hibSes != null) {
        try {
            Transaction tx = hibSes.getTransaction();

            if (commit) {
                if (hibSes.isDirty())
                    hibSes.flush();

                if (tx.getStatus() == TransactionStatus.ACTIVE)
                    tx.commit();
            }
            else if (tx.getStatus().canRollback())
                tx.rollback();
        }
        catch (HibernateException e) {
            throw new CacheWriterException("Failed to end store session [tx=" + ses.transaction() + ']', e);
        }
        finally {
            hibSes.close();
        }
    }
}
 

/** {@inheritDoc} */
@Override protected void afterTest() throws Exception {
    super.afterTest();

    Session s = store.session(null);

    if (s == null)
        return;

    try {
        s.createQuery("delete from " + CacheHibernateBlobStoreEntry.class.getSimpleName())
                .setFlushMode(FlushMode.ALWAYS).executeUpdate();

        Transaction hTx = s.getTransaction();

        if (hTx != null && hTx.getStatus() == TransactionStatus.ACTIVE)
            hTx.commit();
    }
    finally {
        s.close();
    }
}
 

@Before
public void setup() {
    exchange = mock(Exchange.class);
    BindingOperationInfo boi = mock(BindingOperationInfo.class);
    when(exchange.getBindingOperationInfo()).thenReturn(boi);
    OperationInfo oi = mock(OperationInfo.class);
    when(boi.getOperationInfo()).thenReturn(oi);
    invokerBuilder = new UnitOfWorkInvokerFactory();
    fooService = new FooService();
    sessionFactory = mock(SessionFactory.class);
    session = mock(Session.class);
    when(sessionFactory.openSession()).thenReturn(session);
    transaction = mock(Transaction.class);
    when(session.getTransaction()).thenReturn(transaction);
    when(transaction.getStatus()).thenReturn(TransactionStatus.ACTIVE);
}
 

@Override
public void rollback() {
	try {
		TransactionStatus status = jdbcResourceTransaction.getStatus();
		if ( ( rollbackOnly && status != TransactionStatus.NOT_ACTIVE ) || status == TransactionStatus.ACTIVE ) {
			jdbcResourceTransaction.rollback();
			JdbcResourceLocalTransactionCoordinatorImpl.this.afterCompletionCallback( false );
		}
	}
	finally {
		rollbackOnly = false;
	}

	// no-op otherwise.
}
 

@Override
public void markRollbackOnly() {
	if ( getStatus() != TransactionStatus.ROLLED_BACK ) {
		if ( log.isDebugEnabled() ) {
			log.debug(
					"JDBC transaction marked for rollback-only (exception provided for stack trace)",
					new Exception( "exception just for purpose of providing stack trace" )
			);
		}

		rollbackOnly = true;
	}
}
 

@Override
public TransactionStatus getStatus() {
	try {
		return StatusTranslator.translate( transactionManager.getStatus() );
	}
	catch (SystemException e) {
		throw new TransactionException( "JTA TransactionManager#getStatus failed", e );
	}
}
 

@Override
public TransactionStatus getStatus() {
	try {
		return StatusTranslator.translate( userTransaction.getStatus() );
	}
	catch (SystemException e) {
		throw new TransactionException( "JTA TransactionManager#getStatus failed", e );
	}
}
 

public static TransactionStatus translate(int status) {
	TransactionStatus transactionStatus = null;
	switch ( status ) {
		case Status.STATUS_ACTIVE:
			transactionStatus = TransactionStatus.ACTIVE;
			break;
		case Status.STATUS_PREPARED:
			transactionStatus = TransactionStatus.ACTIVE;
			break;
		case Status.STATUS_PREPARING:
			transactionStatus = TransactionStatus.ACTIVE;
			break;
		case Status.STATUS_COMMITTING:
			transactionStatus = TransactionStatus.COMMITTING;
			break;
		case Status.STATUS_ROLLING_BACK:
			transactionStatus = TransactionStatus.ROLLING_BACK;
			break;
		case Status.STATUS_NO_TRANSACTION:
			transactionStatus = TransactionStatus.NOT_ACTIVE;
			break;
		case Status.STATUS_COMMITTED:
			transactionStatus = TransactionStatus.COMMITTED;
			break;
		case Status.STATUS_ROLLEDBACK:
			transactionStatus = TransactionStatus.ROLLED_BACK;
			break;
		case Status.STATUS_MARKED_ROLLBACK:
			transactionStatus = TransactionStatus.MARKED_ROLLBACK;
			break;
		default:
			break;
	}
	if ( transactionStatus == null ) {
		throw new TransactionException( "TransactionManager reported transaction status as unknwon" );
	}
	return transactionStatus;
}
 

@Override
public void explicitJoin() {
	if ( synchronizationRegistered ) {
		log.debug( "JTA transaction was already joined (RegisteredSynchronization already registered)" );
		return;
	}

	if ( getTransactionDriverControl().getStatus() != TransactionStatus.ACTIVE ) {
		throw new TransactionRequiredForJoinException(
				"Explicitly joining a JTA transaction requires a JTA transaction be currently active"
		);
	}

	joinJtaTransaction();
}
 

@Override
public void begin() {
	try {
		if ( !doConnectionsFromProviderHaveAutoCommitDisabled() ) {
			log.trace( "Preparing to begin transaction via JDBC Connection.setAutoCommit(false)" );
			getConnectionForTransactionManagement().setAutoCommit( false );
			log.trace( "Transaction begun via JDBC Connection.setAutoCommit(false)" );
		}
		status = TransactionStatus.ACTIVE;
	}
	catch( SQLException e ) {
		throw new TransactionException( "JDBC begin transaction failed: ", e );
	}
}
 

@Override
public void commit() {
	try {
		log.trace( "Preparing to commit transaction via JDBC Connection.commit()" );
		getConnectionForTransactionManagement().commit();
		status = TransactionStatus.COMMITTED;
		log.trace( "Transaction committed via JDBC Connection.commit()" );
	}
	catch( SQLException e ) {
		status = TransactionStatus.FAILED_COMMIT;
		throw new TransactionException( "Unable to commit against JDBC Connection", e );
	}

	afterCompletion();
}
 

protected void resetConnection(boolean initiallyAutoCommit) {
	try {
		if ( initiallyAutoCommit ) {
			log.trace( "re-enabling auto-commit on JDBC Connection after completion of JDBC-based transaction" );
			getConnectionForTransactionManagement().setAutoCommit( true );
			status = TransactionStatus.NOT_ACTIVE;
		}
	}
	catch ( Exception e ) {
		log.debug(
				"Could not re-enable auto-commit on JDBC Connection after completion of JDBC-based transaction : " + e
		);
	}
}
 

@Override
public void rollback() {
	try {
		log.trace( "Preparing to rollback transaction via JDBC Connection.rollback()" );
		getConnectionForTransactionManagement().rollback();
		status = TransactionStatus.ROLLED_BACK;
		log.trace( "Transaction rolled-back via JDBC Connection.rollback()" );
	}
	catch( SQLException e ) {
		status = TransactionStatus.FAILED_ROLLBACK;
		throw new TransactionException( "Unable to rollback against JDBC Connection", e );
	}

	afterCompletion();
}
 

@Override
public void rollback() {
	if ( !isActive() ) {
		if ( jpaCompliance.isJpaTransactionComplianceEnabled() ) {

			throw new IllegalStateException(
					"JPA compliance dictates throwing IllegalStateException when #rollback " +
							"is called on non-active transaction"
			);
		}
	}

	TransactionStatus status = getStatus();
	if ( status == TransactionStatus.ROLLED_BACK || status == TransactionStatus.NOT_ACTIVE ) {
		// Allow rollback() calls on completed transactions, just no-op.
		LOG.debug( "rollback() called on an inactive transaction" );
		return;
	}

	if ( !status.canRollback() ) {
		throw new TransactionException( "Cannot rollback transaction in current status [" + status.name() + "]" );
	}

	LOG.debug( "rolling back" );

	if ( status != TransactionStatus.FAILED_COMMIT || allowFailedCommitToPhysicallyRollback() ) {
		internalGetTransactionDriverControl().rollback();
	}
}
 

@Override
public TransactionStatus getStatus() {
	if ( transactionDriverControl == null ) {
		if ( session.isOpen() ) {
			transactionDriverControl = transactionCoordinator.getTransactionDriverControl();
		}
		else {
			return TransactionStatus.NOT_ACTIVE;
		}
	}
	return transactionDriverControl.getStatus();
}
 

@Override
public boolean getRollbackOnly() {
	if ( !isActive() ) {
		if ( jpaCompliance.isJpaTransactionComplianceEnabled() ) {
			throw new IllegalStateException(
					"JPA compliance dictates throwing IllegalStateException when #getRollbackOnly " +
							"is called on non-active transaction"
			);
		}
	}

	return getStatus() == TransactionStatus.MARKED_ROLLBACK;
}
 

private boolean isTransactionFlushable() {
	if ( getCurrentTransaction() == null ) {
		// assume it is flushable - CMT, auto-commit, etc
		return true;
	}
	final TransactionStatus status = getCurrentTransaction().getStatus();
	return status == TransactionStatus.ACTIVE || status == TransactionStatus.COMMITTING;
}
 

private void rollbackIfNecessary() {
    if (transaction == null) {
        return;
    }
    if(transaction.getStatus() != TransactionStatus.COMMITTED){
        transaction.rollback();
    }
}
 

/**
 * Ends hibernate session.
 *
 * @param ses Hibernate session.
 * @param tx Cache ongoing transaction.
 */
private void end(Session ses, Transaction tx) {
    // Commit only if there is no cache transaction,
    // otherwise sessionEnd() will do all required work.
    if (tx == null) {
        org.hibernate.Transaction hTx = ses.getTransaction();

        if (hTx != null && hTx.getStatus() == TransactionStatus.ACTIVE)
            hTx.commit();

        ses.close();
    }
}
 

/**
 * Ends hibernate session.
 *
 * @param ses Hibernate session.
 * @param tx Cache ongoing transaction.
 */
private void end(Session ses, Transaction tx) {
    // Commit only if there is no cache transaction,
    // otherwise sessionEnd() will do all required work.
    if (tx == null) {
        org.hibernate.Transaction hTx = ses.getTransaction();

        if (hTx != null && hTx.getStatus() == TransactionStatus.ACTIVE)
            hTx.commit();

        ses.close();
    }
}
 

private void rollbackTransaction(Session session, UnitOfWork uow) {
    if (uow.transactional()) {
        Transaction txn = session.getTransaction();
        if (txn != null && session.getTransaction().getStatus() != TransactionStatus.ACTIVE) {
            txn.rollback();
        }
    }

}
 

private void commitTransaction(Session session, UnitOfWork uow) {
    if (uow.transactional()) {
        Transaction txn = session.getTransaction();
        if (txn != null && session.getTransaction().getStatus() != TransactionStatus.ACTIVE) {
            txn.commit();
        }
    }

}
 

/**
 * If transaction is present and active then commit.
 */
private void success() {
    org.hibernate.Transaction txn = session.getTransaction();
    if (txn != null && txn.getStatus().equals(TransactionStatus.ACTIVE)) {
        txn.commit();
    }
}
 

/**
 * If transaction is present and active then rollback.
 */
private void error() {
    org.hibernate.Transaction txn = session.getTransaction();
    if (txn != null && txn.getStatus().equals(TransactionStatus.ACTIVE)) {
        txn.rollback();
    }
}
 

/**
 * @see io.dropwizard.hibernate.UnitOfWorkAspect#rollbackTransaction()
 */
private void rollbackTransaction(Session session, UnitOfWork unitOfWork) {
    if (unitOfWork.transactional()) {
        final Transaction txn = session.getTransaction();
        if (txn != null && txn.getStatus().equals(TransactionStatus.ACTIVE)) {
            txn.rollback();
        }
    }
}