Calls rollback on all {@link MigrationAwareService}.
184805
private void rollbackServices() {
        PartitionMigrationEvent event = getPartitionMigrationEvent();
        for (MigrationAwareService service : getMigrationAwareServices()) {
            try {
                service.rollbackMigration(event);
            } catch (Throwable e) {
                logger.warning("While promoting " + getPartitionMigrationEvent(), e);
            }
        }
    }
1294468
@Override
    public void rollback(final Xid _xid)
        throws XAException
    {
        ConnectionResource.LOG.trace("rollback (xid = {})", _xid);
        try  {
            if (this.connection != null && !this.connection.isClosed())  {
                this.connection.rollback();
            }
        } catch (final SQLException e)  {
            final XAException xa = new XAException(XAException.XA_RBCOMMFAIL);
            xa.initCause(e);
            throw xa;
        } finally  {
            try {
                if (this.connection != null && !this.connection.isClosed())  {
                    this.connection.close();
                }
                this.connection = null;
                setOpened(false);
            } catch (final SQLException e) {
                ConnectionResource.LOG.error("SQLException", e);
            }
        }
    }
555427
@Override
	public void rollback() {
		for (ResourceManager<Transaction> manager : managers.values()) {
			Transaction transaction = manager.transaction();
			
			if (transaction.isActive()) {
				try {
					transaction.rollback();
				} catch (Exception e) {
					logger.warning("Transaction [" + transaction.getId()
							+ "]: Rollback failed due to [" + e
							+ "]; Consistency will be ensured in read");
				}
			}
		}
	}
56383
@Override
    public void rollbackStatements() {
        if (log.isDebugEnabled()) {
            log.debug(String.format("Received transaction rollback: '%s':%n",
                    endpointConfiguration.getServerConfiguration().getDatabaseName()));
        }

        if(!endpointConfiguration.isAutoTransactionHandling()){
            handleMessageAndCheckResponse(JdbcMessage.rollbackTransaction());
        }
    }
50915
public function rollBack()
    {
        if ($this->transactionLevel === 0) {
            throw ConnectionException::noActiveTransaction();
        }

        if ($this->transactionLevel === 1) {
            $queryDebugger = $this->createQueryDebugger('ROLLBACK TRANSACTION');
            $this->getDriverConnection()->rollBack();
            $this->debugQuery($queryDebugger);
        } else {
            $this->exec($this->getPlatform()->getRollbackSavepointSQLQuery($this->generateSavepointName()));
        }

        $this->transactionLevel--;
    }
631397
public final void rollback() throws XAException
    {
        if (tc.isEntryEnabled()) Tr.entry(tc, "rollback", _resource);
        if (tcSummary.isDebugEnabled()) Tr.debug(tcSummary, "rollback", this);

        try
        {
            _resource.rollback(_xid);

			// Record the vote.
			// _completedCommit defaults to false.
			_vote = JTAResourceVote.rollback;
        }
        catch(XAException xae)
        {
			// Record the completion XA return code
			_completionXARC = xae.errorCode;

			throw xae;
        }
        finally
        {
            if (tc.isEntryEnabled()) Tr.exit(tc, "rollback");
            if (tcSummary.isDebugEnabled()) Tr.debug(tcSummary, "rollback result: " + 
                                                                XAReturnCodeHelper.convertXACode(_completionXARC));
        }
    }
868893
void rollbackResources()
    {
        final boolean traceOn = TraceComponent.isAnyTracingEnabled();

        if (traceOn && tc.isEntryEnabled())
            Tr.entry(tc, "rollbackResources", this);

        distributeEnd(XAResource.TMFAIL);
        _outcome = false;
        _retryRequired = distributeOutcome();

        if (traceOn && tc.isEntryEnabled())
            Tr.exit(tc, "rollbackResources", _retryRequired);
    }
789317
@Override
	public void rollback() {
		if (conn != null) {
			try {
				conn.rollback();
			} catch (SQLException e) {
				throw new UroborosqlSQLException(e);
			}
		}
	}
600873
public void rollback() {
        try {
            ldapOperations.rename(temporaryDn, originalDn);
        } catch (Exception e) {
            log.warn("Filed to rollback unbind operation, temporaryDn: "
                    + temporaryDn + "; originalDn: " + originalDn);
        }
    }
787248
@Override
    public void rollback(Xid xid) throws XAException {

        final boolean isTracingEnabled = TraceComponent.isAnyTracingEnabled();

        if (isTracingEnabled && tc.isEntryEnabled())
            Tr.entry(this, tc, "rollback");

        if (getMcWrapper().isMCAborted()) {
            Tr.exit(tc, "Connection was aborted. Exiting rollback.");
            return;
        }

        this.hasRollbackOccured = true;

        try {
            xaResource.rollback(xid);
        } catch (XAException e) {
            processXAException(e);
            com.ibm.ws.ffdc.FFDCFilter.processException(
                                                        e,
                                                        "com.ibm.ejs.j2c.XATransactionWrapper.rollback",
                                                        "755",
                                                        this);
            if (!mcWrapper.isStale()) {
                Tr.error(tc, "XA_RESOURCE_ADAPTER_OPERATION_ID_EXCP_J2CA0027", "rollback", xid, e, mcWrapper.gConfigProps.cfName);
            }
            if (isTracingEnabled && tc.isEntryEnabled())
                Tr.exit(this, tc, "rollback", e);
            throw e;
        } catch (Exception e) {
            com.ibm.ws.ffdc.FFDCFilter.processException(
                                                        e,
                                                        "com.ibm.ejs.j2c.XATransactionWrapper.rollback",
                                                        "761",
                                                        this);
            if (!mcWrapper.shouldBeDestroyed()) {
                mcWrapper.markTransactionError();
                Tr.error(tc, "XA_RESOURCE_ADAPTER_OPERATION_ID_EXCP_J2CA0027", "rollback", xid, e, mcWrapper.gConfigProps.cfName);
            }
            XAException x = new XAException("Exception:" + e.toString());
            x.initCause(e);
            if (isTracingEnabled && tc.isEntryEnabled())
                Tr.exit(this, tc, "rollback", x);
            throw x;
        }

        if (isTracingEnabled && tc.isEntryEnabled())
            Tr.exit(this, tc, "rollback");
    }
126382
@Override
    public void rollback() throws IllegalStateException, SystemException
    {
        for (ResourceManager implementor : implementors)
        {
            if (implementor != null)
            {
                implementor.doRollback();
                status = Status.STATUS_ROLLEDBACK;
            }
        }
    }
906338
public void rollback_only()
    {
        if (tc.isEntryEnabled())
            Tr.entry(tc, "rollback_only");

        try
        {
            _transaction.setRollbackOnly();
            _transaction.subRollback();
        } catch (Throwable exc)
        {
            FFDCFilter.processException(exc, "com.ibm.tx.remote.TransactionWrapper.rollback_only", "813", this);
            if (tc.isEventEnabled())
                Tr.event(tc, "rollback_only caught exception setting coordinator rollback_only", exc);
        }

        if (tc.isEntryEnabled())
            Tr.exit(tc, "rollback_only");
    }
311649
public void rollback(Xid xid) throws XAException {

        JDBCXAResource resource = xaDataSource.getResource(xid);

        if (resource == null) {
            throw new XAException(
                "The XADataSource has no such Xid in prepared state:  " + xid);
        }

        resource.rollbackThis();
    }
146010
@Override
    public void rollback(String globalId) throws HeuristicHazardException, HeuristicCommitException, HeuristicMixedException, SystemException {

        final TransactionWrapper t = TransactionWrapper.getTransactionWrapper(globalId);

        if (t != null) {
            t.rollback();
        } else {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                Tr.debug(tc, "No matching TransactionWrapper: " + globalId);
            throw new SystemException();
        }
    }
1154968
public void rollback(PersistenceDelegator delegator)
    {
        if (eventLogQueue != null)
        {
            onRollBack(delegator, eventLogQueue.getInsertEvents());
            onRollBack(delegator, eventLogQueue.getUpdateEvents());
            onRollBack(delegator, eventLogQueue.getDeleteEvents());

            rollbackJoinTableData(delegator);
        }
    }
21585
protected boolean rollback()
    {
        if (currentOut != null) {
            currentOut.rollback();
            currentOut = null;
            moreOut = false;
        }
        return true;
    }
1367035
protected function rollbackTransaction()
    {
        $this->entityManager->rollback();

        $connection = $this->entityManager->getConnection();
        if (!$connection->isTransactionActive() || $connection->isRollbackOnly()) {
            $this->entityManager->close();
        }
    }