Inform all associated consumers that a rollback has occurred.

No-op if strict redelivery ordering is disabled.
438956
public void informConsumersOfRollback() {
     if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
       SibTr.entry(this, tc, "informConsumersOfRollback", new Object[]{Boolean.valueOf(strictRedeliveryOrdering)});
     
     if (strictRedeliveryOrdering) {
       // Take a copy of the set of consumers, to avoid additional locking
       // when we call into the consumers to inform them of a rollback.
       ConsumerSessionProxy[] consumersToNotify;
       synchronized(associatedConsumersLock) {
         consumersToNotify = 
           new ConsumerSessionProxy[associatedConsumers.size()];
         consumersToNotify = (ConsumerSessionProxy[])
           associatedConsumers.toArray(consumersToNotify);
       }
       
       // Callback each consumer to inform them of the rollback
       for (int i = 0; i < consumersToNotify.length; i++) {
         try {
           consumersToNotify[i].rollbackOccurred();
         }
         catch (SIException e) {
           // FFDC for the error, but do not re-throw.
           // Most likely the connection to the ME is unavailable, or the
           // consumer has been closed and cleaned up.
           // In these cases the consumer will not be able to consume any
           // more messages - so redelivery ordering is not an issue.
           FFDCFilter.processException(e, CLASS_NAME + ".informConsumersOfRollback",
               CommsConstants.TRANSACTION_INFORMCONSUMERSOFROLLBACK_01, this);
           if (tc.isDebugEnabled()) SibTr.debug(tc, "Encountered error informing consumer of rollback: " + consumersToNotify[i]);
           if (tc.isEventEnabled()) SibTr.exception(tc, e);
         }
       }
     }
     
     if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
       SibTr.exit(this, tc, "informConsumersOfRollback");     
   }
918914
def rollback(self, sql=None):
        """"""
        self._transaction = False
        try:
            rollback = self._con.rollback
        except AttributeError:
            return self._con.query(sql or 'rollback')
        else:
            if sql:
                return rollback(sql=sql)
            else:
                return rollback()
13323
public function rollBack()
    {
        --$this->currentTransactionLevel;
        if ($this->currentTransactionLevel == 0 || !$this->nestable()) {
            parent::rollBack();
        } else {
            $this->exec("ROLLBACK TO SAVEPOINT LEVEL{$this->currentTransactionLevel}");
        }
    }
1166078
def rollback(self, cb=None):
        '''
        
        '''
        # Could call select() but spec 1.9.2.5 says to raise an exception
        if not self.enabled:
            raise self.TransactionsNotEnabled()

        self.send_frame(MethodFrame(self.channel_id, 90, 30))
        self._rollback_cb.append(cb)
        self.channel.add_synchronous_cb(self._recv_rollback_ok)
74580
@Override
    public void rollback() throws IllegalStateException, SystemException {
        if (tc.isEntryEnabled())
            Tr.entry(tc, "rollback (SPI)");

        final int state = _status.getState();

        //
        // We are only called in this method for superiors.
        //
        if (state == TransactionState.STATE_ACTIVE) {
            //
            // Cancel timeout prior to completion phase
            //
            cancelAlarms();

            try {
                _status.setState(TransactionState.STATE_ROLLING_BACK);
            } catch (SystemException se) {
                FFDCFilter.processException(se, "com.ibm.tx.jta.TransactionImpl.rollback", "1587", this);
                if (tc.isDebugEnabled())
                    Tr.debug(tc, "Exception caught setting state to ROLLING_BACK!", se);
                if (tc.isEntryEnabled())
                    Tr.exit(tc, "rollback (SPI)");
                throw se;
            }

            try {
                internalRollback();
            } catch (HeuristicMixedException hme) {
                if (tc.isDebugEnabled())
                    Tr.debug(tc, "HeuristicMixedException caught rollback processing", hme);
                // state change handled by notifyCompletion

                // Add to list of heuristically completed transactions
                addHeuristic();
            } catch (HeuristicHazardException hhe) {
                if (tc.isDebugEnabled())
                    Tr.debug(tc, "HeuristicHazardException caught rollback processing", hhe);
                // state change handled by notifyCompletion

                // Add to list of heuristically completed transactions
                addHeuristic();
            } catch (HeuristicCommitException hce) {
                if (tc.isDebugEnabled())
                    Tr.debug(tc, "HeuristicHazardException caught rollback processing", hce);
                // state change handled by notifyCompletion

                // Add to list of heuristically completed transactions
                addHeuristic();
            } catch (SystemException se) {
                FFDCFilter.processException(se, "com.ibm.tx.jta.TransactionImpl.rollback", "1626", this);
                if (tc.isEventEnabled())
                    Tr.event(tc, "SystemException caught during rollback", se);
                if (tc.isEntryEnabled())
                    Tr.exit(tc, "rollback (SPI)");
                throw se;
            } catch (Throwable ex) {
                FFDCFilter.processException(ex, "com.ibm.tx.jta.TransactionImpl.rollback", "1633", this);
                if (tc.isEventEnabled())
                    Tr.event(tc, "Exception caught during rollback", ex);
                if (tc.isEntryEnabled())
                    Tr.exit(tc, "rollback (SPI)");
                throw new SystemException(ex.getLocalizedMessage());
            } finally {
                notifyCompletion();
            }
        }
        //
        // Defect 1440
        //
        // We are not in ACTIVE state so we need to
        // throw the appropriate exception.
        //
        else if (state == TransactionState.STATE_NONE) {
            if (tc.isEventEnabled())
                Tr.event(tc, "No transaction available!");
            if (tc.isEntryEnabled())
                Tr.exit(tc, "rollback (SPI)");
            throw new IllegalStateException();
        } else {
            if (tc.isEventEnabled())
                Tr.event(tc, "Invalid transaction state:" + state);
            if (tc.isEntryEnabled())
                Tr.exit(tc, "rollback (SPI)");
            throw new SystemException();
        }

        if (tc.isEntryEnabled())
            Tr.exit(tc, "rollback (SPI)");
    }
286950
private void setRollbackOnly()
   {
      try
      {
         tm.getTransaction().setRollbackOnly();
      }
      catch (IllegalStateException e)
      {
         log.warn("Could not set the status of the tx to 'rollback-only'", e);
      }
      catch (SystemException e)
      {
         log.warn("Could not set the status of the tx to 'rollback-only'", e);
      }
   }
72814
static void rollbackIfActive(Transaction transaction) {
    try {
      if (transaction != null && transaction.isActive()) {
        transaction.rollback();
      }
    } catch (DatastoreException exp) {
      throw new EntityManagerException(exp);
    }
  }
1012145
public function force_transaction_rollback() {
        if ($this->transactions) {
            try {
                $this->rollback_transaction();
            } catch (dml_exception $e) {
                // ignore any sql errors here, the connection might be broken
            }
        }

        // now enable transactions again
        $this->transactions = array();
        $this->force_rollback = false;

        \core\event\manager::database_transaction_rolledback();
        \core\message\manager::database_transaction_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");
    }
622349
public void rollback() throws SystemException {
        Transaction transaction = currentTransaction();
        if (transaction == null) {
            throw new IllegalStateException("No active transaction");
        }
        transaction.rollback();     
    }
168292
protected function rollback()
    {
        if (!$this->isUpdate() || ($this->isUpdate() && $this->renamed)) {
            gplcart_file_delete_recursive($this->destination);
        }

        if (isset($this->tempname)) {
            rename($this->tempname, $this->destination);
        }
    }
297482
@Override
    public void afterCompletion(TransactionCommon tran, boolean committed)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "afterCompletion", new Object[] { tran, Boolean.valueOf(committed) });

        // We don't care if the transaction committed or rolled back, either way
        // this callback indicates that a message that this consumer had active
        // is no longer active and therefore we should decrement the active message
        // count (this callback is called once per active message).
        removeActiveMessages(1);

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "afterCompletion");
    }
1060908
def rollback(self):
        
        logger.info('Rolling back changes')

        config_text = self.compare_config(other=self.original_config)

        if len(config_text) > 0:
            return self._commit(config_text, force=True, reload_original_config=False)
649896
public function rollback()
    {
        $this->checkIfOpened();
        $response = $this->handleResponse($this->client->rollBackTransaction($this->transactionId));
        $this->active = false;

        return $response;
    }
877960
def rollback(self):
        """"""
        if self.session is not None:
            logger.info("rolling back transaction in %s" % self)
            self.session.close()
            self.session = None
            self.lock_update.release()
        else:
            logger.warning("rollback called but there's no open session in %s" % self)
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());
        }
    }
1149052
def rollback(self):
		
		try:
			if self.connection is not None:
				self.connection.rollback()
				self._updateCheckTime()
				self.release()
		except Exception, e:
			pass