Commit a transaction.
        :param transaction_id: ID of transaction to be committed.
        :param **kwargs: Further parameters for the transport layer.
325215
def transaction_commit(self, transaction_id, **kwargs):
        
        if transaction_id not in self.__transactions:
            raise workflows.Error("Attempting to commit unknown transaction")
        self.log.debug("Committing transaction %s", transaction_id)
        self.__transactions.remove(transaction_id)
        self._transaction_commit(transaction_id, **kwargs)
813465
public void commitTransaction() throws SystemException
   {
      Long key = Long.valueOf(Thread.currentThread().getId());
      TransactionImpl tx = txs.get(key);
      if (tx != null)
      {
         try
         {
            tx.commit();
         }
         catch (Throwable t)
         {
            SystemException se = new SystemException("Error during commit");
            se.initCause(t);
            throw se;
         }
      }
      else
      {
         throw new IllegalStateException("No transaction to commit");
      }
   }
1063275
def _update(self, metadata, tx_id, resource_id):
        
        try:
            if not tx_id:
                sent_tx = self.write(metadata, resource_id)
                self.logger.debug('bdb::put::{}'.format(sent_tx['id']))
                return sent_tx
            else:
                txs = self.driver.instance.transactions.get(asset_id=self.get_asset_id(tx_id))
                unspent = txs[-1]
                sent_tx = self._put(metadata, unspent, resource_id)
                self.logger.debug('bdb::put::{}'.format(sent_tx))
                return sent_tx

        except BadRequest as e:
            logging.error(e)
632667
def commit(self) -> ResponseCommit:
        """"""
        hash = struct.pack('>Q', self.txCount)
        return ResponseCommit(data=hash)
1017737
def transaction_id=(transaction_id)
      if transaction_id.nil?
        fail ArgumentError, "transaction_id cannot be nil"
      end

      if transaction_id.to_s.length < 1
        fail ArgumentError, "invalid value for 'transaction_id', the character length must be great than or equal to 1."
      end

      @transaction_id = transaction_id
    end
580707
public void commit(DBTransaction dbTran) {
        try {
            applyUpdates(dbTran);
        } catch (Exception e) {
            // All retries, if needed, failed.
            m_logger.error("Commit failed", e);
            throw e;
        } finally {
            dbTran.clear();
        }
    }
79389
public static void putTransactionId(final String transactionId) {
		if ((transactionId != null) && (0 < transactionId.length())) {
			MDC.put(TRANSACTION_ID, transactionId);
		}
	}
297138
def commit_finished( self, block_id ):
        

        self.db.commit()

        # NOTE: tokens vest for the *next* block in order to make the immediately usable
        assert block_id+1 in self.vesting, 'BUG: failed to vest at {}'.format(block_id)

        self.clear_collisions( block_id )
        self.clear_vesting(block_id+1)
579688
protected void performTransaction(Fragment frag, int flags, FragmentTransaction ft, int containerId) {
        configureAdditionMode(frag, flags, ft, containerId);
        ft.commitAllowingStateLoss();
    }
930786
def create_transaction(options = {})
      agent.create_transaction(self['id'], options) do |data, resp|
        yield(data, resp) if block_given?
      end
    end
642135
def commit(self):
        

        if not self._parent._is_active:
            raise exc.InvalidRequestError("This transaction is inactive")
        yield from self._do_commit()
        self._is_active = False
284961
def commit(self) -> None:
        
        if len(self._transactions) == 0:
            raise RuntimeError("commit called outside transaction")

        # If we have nested transactions, we don't actually commit, but push
        # rollbacks up to previous transaction.
        if len(self._transactions) > 1:
            for on_rollback in reversed(self._transactions[-1]):
                self._transactions[-2].insert(0, on_rollback)

        _debug("commit")
        self.reset()
729806
def create_transaction(self, *args: Any, **kwargs: Any) -> BaseTransaction:
        
        return self.get_transaction_class()(*args, **kwargs)
883471
public static void commit()
   {
      try {
         if (!isDone()) {
            userTransaction.commit();
         }
         else {
            LOGGER.warn("commit() called with no current transaction.");
         }
      }
      catch (Exception e) {
         throw new RuntimeException("Transaction commit failed.", e);
      }
   }
945899
def add_transaction(self, transaction):
        
        for item in transaction:
            if item not in self.__transaction_index_map:
                self.__items.append(item)
                self.__transaction_index_map[item] = set()
            self.__transaction_index_map[item].add(self.__num_transaction)
        self.__num_transaction += 1
58440
def do_transaction(self, function, *args, **kwargs):
        """"""
        with self.config.db_transaction() as trans:
            function(trans, *args, **kwargs)
36414
public void commitTransaction() throws HibernateException
    {
        Transaction tx = threadTransaction.get();
        threadTransaction.set(null);
        if (tx != null && !tx.wasCommitted() && !tx.wasRolledBack())
        {
            tx.commit();
        }
    }