Rollback all resources, but do not drive state changes.
Used when transaction HAS TIMED OUT.
329202
public void rollbackResources() {
        final boolean traceOn = TraceComponent.isAnyTracingEnabled();

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

        try {
            final Transaction t = ((EmbeddableTranManagerSet) TransactionManagerFactory.getTransactionManager()).suspend();
            getResources().rollbackResources();
            if (t != null)
                ((EmbeddableTranManagerSet) TransactionManagerFactory.getTransactionManager()).resume(t);
        } catch (Exception ex) {
            FFDCFilter.processException(ex, "com.ibm.tx.jta.impl.EmbeddableTransactionImpl.rollbackResources", "104", this);
            if (traceOn && tc.isDebugEnabled())
                Tr.debug(tc, "Exception caught from rollbackResources()", ex);
        }

        if (traceOn && tc.isEntryEnabled())
            Tr.exit(tc, "rollbackResources");
    }
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);
      }
   }
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);
      }
   }
771121
def rollback(self):
        
        try:
            if self._autocommit:
                return

            if not self._conn or not self._conn.is_connected():
                return

            if not self._conn.tds72_transaction:
                return

            self._main_cursor._rollback(cont=True,
                                        isolation_level=self._isolation_level)
        except socket.error as e:
            if e.errno in (errno.ENETRESET, errno.ECONNRESET, errno.EPIPE):
                return
            self._conn.close()
            raise
        except ClosedConnectionError:
            pass
1332150
public void rollback() {
        log.debug("Performing rollback");
        while (!operationExecutors.isEmpty()) {
            CompensatingTransactionOperationExecutor rollbackOperation = operationExecutors.pop();
            try {
                rollbackOperation.rollback();
            } catch (Exception e) {
                throw new TransactionSystemException(
                        "Error occurred during rollback", e);
            }
        }
    }
14655
def rollback(self):
        """"""
        for p in self._moves:
            logging.info("Moving to %s\n from %s", *p)

        for new_path, path in self._moves:
            try:
                logger.debug('Replacing %s from %s', new_path, path)
                if os.path.isfile(new_path):
                    os.unlink(new_path)
                elif os.path.isdir(new_path):
                    rmtree(new_path)
                renames(path, new_path)
            except OSError as ex:
                logger.error("Failed to restore %s", new_path)
                logger.debug("Exception: %s", ex)

        self.commit()
866882
def rollback(self):
        """"""
        if not self._moved_paths.can_rollback:
            logger.error(
                "Can't roll back %s; was not uninstalled",
                self.dist.project_name,
            )
            return False
        logger.info('Rolling back uninstall of %s', self.dist.project_name)
        self._moved_paths.rollback()
        for pth in self.pth.values():
            pth.rollback()
438983
@Override
    public void rollback() throws IllegalStateException, SecurityException, SystemException
    {

        try
        {
            Transaction tx = threadLocal.get();
            if (tx == null)
            {
                throw new IllegalStateException("Cannot locate a Transaction for rollback.");
            }

            if (log.isDebugEnabled())
                log.info("Rollback transaction:" + tx);

            tx.rollback();

        }
        finally
        {
            if (log.isDebugEnabled())
                log.info("Resetting after rollback.");
            threadLocal.set(null);
            timerThead.set(null);
        }
    }
447770
public void rollback() throws HandlerException {
        if (_isInitiator) {
            try {
                _userTx.rollback();
            } catch (SystemException se) {
                throw CommonKnowledgeMessages.MESSAGES.userTransactionRollbackFailed(se);
            }
        } else if (_userTx != null) {
            try {
                _userTx.setRollbackOnly();
            } catch (SystemException se) {
                throw CommonKnowledgeMessages.MESSAGES.userTransactionSetRollbackOnlyFailed(se);
            }
        }
    }
971201
def rollback
        super
        each {|transition| transition.machine.write(object, :event, transition.event) unless transition.transient?}
      end
449757
public function rollBack()
	{
		if ($this->transactions == 1)
		{
			$this->transactions = 0;

			$this->pdo->rollBack();
		}
		else
		{
			--$this->transactions;
		}
	}
696611
def rollback(self):
        

        try:
            self.check_connection()
        except NullDatabaseConnectionError:
            return

        logger.debug("rollback: path='{}'".format(self.database_path))

        self.connection.rollback()
1028702
def rollback(gandi, resource, background):
    
    result = gandi.disk.rollback(resource, background)

    if background:
        gandi.pretty_echo(result)
    return result
360903
def rollback(self):
        """"""
        self._check_state()
        database = self._session._database
        api = database.spanner_api
        metadata = _metadata_with_prefix(database.name)
        api.rollback(self._session.name, self._transaction_id, metadata=metadata)
        self._rolled_back = True
        del self._session._transaction
510339
def rolledback!(force_restore_state = false) #:nodoc:
      run_callbacks :rollback
    ensure
      IdentityMap.remove(self) if IdentityMap.enabled?
      restore_transaction_record_state(force_restore_state)
    end
538544
def rollback(using=None, sid=None):
    
    if sid:
        django.db.transaction.savepoint_rollback(sid)
    else:
        try:
             django.db.transaction.rollback(using)
        except django.db.transaction.TransactionManagementError:
             django.db.transaction.set_rollback(True, using)
925521
public function rollBack () {
        $this->transaction_level--;

        if(!$this->nestable() || $this->transaction_level == 0) {
            parent::rollBack();
        } else {
            $this->exec("ROLLBACK TO SAVEPOINT LEVEL{$this->transaction_level}");
        }
    }