Handles a rollback request from a client.
967421
void rollbackTransaction(HotRodHeader header, Subject subject, XidImpl xid) {
      RollbackTransactionOperation operation = new RollbackTransactionOperation(header, server, subject, xid,
            this::writeTransactionResponse);
      executor.execute(operation);
   }
245934
public void rollback() throws DBException
    {
        super.rollback(); // Will throw an error if something is not set up right.
        try   {
            if (m_JDBCConnection != null)
                m_JDBCConnection.rollback();
        } catch (SQLException ex) {
            throw this.convertError(ex);
        }
    }
805136
def rollback(self, release):
        """"""
        r = self._h._http_resource(
            method='POST',
            resource=('apps', self.name, 'releases'),
            data={'rollback': release}
        )
        return self.releases[-1]
1295395
public static void rollback()
   {
      try {
         if (userTransaction.getStatus() != Status.STATUS_NO_TRANSACTION) {
            userTransaction.rollback();
         }
         else {
            LOGGER.warn("Request to rollback transaction when none was in started.");
         }
      }
      catch (Exception e) {
         LOGGER.warn("Transaction rollback failed.", e);
      }
   }
270587
function rollback() {
    var parsed = ensureConfig();
    var name = parsed.name;
    // check if is an index number.
    // if yes try to lookup the id
    // by its index.
    try {
        var idx = void 0;
        if (/^[0-9]+$/.test(name)) {
            idx = parseInt(parsed.name) - 1;
            if (idx >= 0) {
                var keys = Object.keys(mu.rollbacks);
                var key = keys[idx];
                if (key)
                    name = key;
            }
        }
    }
    catch (ex) { }
    mu.rollback(parsed.name, parsed.output);
}
208097
public void rollback() throws SQLException {

    cmdPrologue();

    lock.lock();
    try {

      if (inTransaction()) {
        executeQuery("ROLLBACK");
      }

    } catch (Exception e) {
      /* eat exception */
    } finally {
      lock.unlock();
    }
  }
1283708
@Override
    public void rollback() throws DataCorruptedException, IOException, IllegalStateException
    {
        try {
            this.txContext.abort();
        } catch (final Exception e) {
            throw new DataCorruptedException("Error trying to rollback a Transaction.", e);
        }
    }
1139702
protected <T> T executeIgnoreRollback(TransactionCallback<T> action, T rollbackValue) {
        try {
            // Try to create the mutex in a new TX
            return this.newTransactionTemplate.execute(action);
        } catch (TransactionSystemException e) {
            if (e.getCause() instanceof RollbackException) {
                // Ignore rollbacks
                return rollbackValue;
            }

            // re-throw exception with unhandled cause
            throw e;
        }
    }
622349
public void rollback() throws SystemException {
        Transaction transaction = currentTransaction();
        if (transaction == null) {
            throw new IllegalStateException("No active transaction");
        }
        transaction.rollback();     
    }
421530
def rollback(self, date):
        """"""
        if self.onOffset(date):
            return date
        else:
            return date - YearBegin(month=self.month)
1296981
private void fireOnRollbackTransaction(ChannelEvent e) {
        List<EventListener> listeners = changes.getListenerList(AMQP);
        for (EventListener listener : listeners) {
            ChannelListener amqpListener = (ChannelListener)listener;
            amqpListener.onRollback(e);
        }
    }
115131
public function rollback() {
        if ($this->txUrl) {
            $this->client->post($this->txUrl . '/fcr:tx/fcr:rollback');
            $this->txUrl = null;
            $this->killKeepTransactionAlive();
        }
    }
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());
        }
    }
752112
def rollback(self, date):
        """"""
        if self.onOffset(date):
            return date
        else:
            return date - QuarterBegin(month=self.month)
1149052
def rollback(self):
		
		try:
			if self.connection is not None:
				self.connection.rollback()
				self._updateCheckTime()
				self.release()
		except Exception, e:
			pass
722415
static void rcvRollbackTransaction(CommsByteBuffer request, Conversation conversation,
                                      int requestNumber, boolean allocatedFromBufferPool,
                                      boolean partOfExchange)
   {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "rcvRollbackTransaction",
                                           new Object[]
                                           {
                                              request,
                                              conversation,
                                              ""+requestNumber,
                                              ""+allocatedFromBufferPool
                                            });

      short connectionObjectId = request.getShort();  // BIT16 ConnectionObjectId
      int clientTransactionId = request.getInt();     // BIT32 Client transaction Id

      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
      {
         SibTr.debug(tc, "SICoreConnection Id:", connectionObjectId);
         SibTr.debug(tc, "Client transaction Id:", clientTransactionId);
      }

      try
      {
         // Get the transaction out of the table
         ServerLinkLevelState linkState = (ServerLinkLevelState) conversation.getLinkLevelAttachment();
         SITransaction tran = linkState.getTransactionTable().get(clientTransactionId);

         if (tran == IdToTransactionTable.INVALID_TRANSACTION)
         {
            Throwable e = linkState.getTransactionTable().getExceptionForRollbackOnlyLocalTransaction(clientTransactionId);

            //Remove transaction from the table
            linkState.getTransactionTable().removeLocalTransaction(clientTransactionId);

            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Looks like the transaction failed to create", e);
         }
         else
         {
            // At this point here the transaction will only be rolled back.
            // Therefore, any subsequent operations will be invalid and will be thrown out
            // by the client. As such, remove it from the table.
            linkState.getTransactionTable().removeLocalTransaction(clientTransactionId);

            SIUncoordinatedTransaction siTran = (SIUncoordinatedTransaction)tran;
            siTran.rollback();
         }

         try
         {
            conversation.send(poolManager.allocate(),
                              JFapChannelConstants.SEG_ROLLBACK_TRANSACTION_R,
                              requestNumber,
                              JFapChannelConstants.PRIORITY_MEDIUM,
                              true,
                              ThrottlingPolicy.BLOCK_THREAD,
                              null);
         }
         catch (SIException e)
         {
            FFDCFilter.processException(e,
                                        CLASS_NAME + ".rcvRollbackTransaction",
                                        CommsConstants.STATICCATTRANSACTION_ROLLBACK_01);

            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, e.getMessage(), e);

            SibTr.error(tc, "COMMUNICATION_ERROR_SICO2026", e);
         }
      }
      catch (SIException e)
      {
         //No FFDC code needed
         //Only FFDC if we haven't received a meTerminated event.
         if(!((ConversationState)conversation.getAttachment()).hasMETerminated())
         {
            FFDCFilter.processException(e,
                                       CLASS_NAME + ".rcvRollbackTransaction",
                                       CommsConstants.STATICCATTRANSACTION_ROLLBACK_02);
         }

         if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, e.getMessage(), e);

         StaticCATHelper.sendExceptionToClient(e,
                                               CommsConstants.STATICCATTRANSACTION_ROLLBACK_02,
                                               conversation, requestNumber);
      }

      request.release(allocatedFromBufferPool);

      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "rcvRollbackTransaction");
   }
1034233
def rollback(self):
        """"""
        if not self._in_transaction:
            raise NotInTransaction
        self._init_cache()
        self._in_transaction = False