public void Commit(Enlistment enlistment)
 {
     try
     {
         assertNotDisposed();
         logger.DebugFormat("Committing enlistment with id: {0}", Id);
         queueStorage.Global(actions =>
         {
             actions.RemoveReversalsMoveCompletedMessagesAndFinishSubQueueMove(Id);
             actions.MarkAsReadyToSend(Id);
             actions.DeleteRecoveryInformation(Id);
             actions.Commit();
         });
         enlistment.Done();
         logger.DebugFormat("Commited enlistment with id: {0}", Id);
     }
     catch (Exception e)
     {
         logger.Warn("Failed to commit enlistment " + Id, e);
         throw;
     }
     finally
     {
         onCompelete();
     }
 }

 public void Rollback(Enlistment enlistment)
 {
     container.Rollback();
     container.Ext().Refresh(oldItem, int.MaxValue);
     oldItem = null;
     container = null;
 }

			public void Commit(Enlistment enlistment)
			{
				if (_ThrowIt)
					Assert.Fail("commit is never called if prepare failed");

				enlistment.Done();
			}

 public void InDoubt(Enlistment enlistment)
 {
     log.Warn("transaction in doubt {0}, messages {1}", TransactionId, this.Messages.Count);
     if (_onrollback != null) _onrollback(this);
     enlistment.Done();
     TransactionOpen = false;
 }

		public void Commit(Enlistment enlistment)
		{
			if (_transaction != null && !_transaction.IsUpdated)
			{
				_transaction.Commit();
				_transaction = null;

				if (Completed != null)
				{
					Completed(this, new EventArgs());
				}

				if (_connection != null)
				{
					if (!_connection.Options.Pooling && (_connection.OwningConnection == null || _connection.OwningConnection.IsClosed))
					{
						_connection.Disconnect();
					}
				}
				_connection = null;
				_systemTransaction = null;

				// Declare done on the enlistment
				enlistment.Done();
			}
		}

 void IEnlistmentNotification.Commit(Enlistment enlistment)
 {
     this.m_Value = new StringBuilder(this.m_TemporaryValue.ToString());
     this.m_TemporaryValue = null;
     this.enlistedTransaction = null;
     enlistment.Done();
 }

 /// <summary>
 /// Performs necessary commit actions, clearing the current <see cref="TransactionContext"/>
 /// </summary>
 public void Commit(Enlistment enlistment)
 {
     BeforeCommit();
     DoCommit();
     TransactionContext.Clear();
     enlistment.Done();
 }

        public void Commit(Enlistment enlistment)
        {
            if (this.transaction != null && !this.transaction.IsUpdated)
            {
                this.transaction.Commit();
                this.transaction = null;

                if (this.Completed != null)
                {
                    this.Completed(this, new EventArgs());
                }

                if (this.connection != null)
                {
                    if (!this.connection.Pooled && (this.connection.OwningConnection == null || this.connection.OwningConnection.IsClosed))
                    {
                        this.connection.Disconnect();
                    }
                }
                this.connection         = null;
                this.systemTransaction  = null;

                // Declare done on the enlistment
                enlistment.Done();
            }
        }

		public override void Commit(Enlistment enlistment)
		{
			if (_ThrowOnCommit)
				throw new Exception("Simulated commit error");

			base.Commit(enlistment);
		}

 public void Commit(Enlistment enlistment)
 {
     log.Debug("Commit {0}, Messages: {1}", TransactionId, Messages.Count);
     if (_oncommit != null) _oncommit(this);
     enlistment.Done();
     TransactionOpen = false;
 }

 public void Rollback(Enlistment enlistment)
 {
     enlistment.Done();
     this.notification.Aborted(0, false, 0, 0);
     Marshal.ReleaseComObject(this.notification);
     this.notification = null;
 }

 /// <summary>
 /// Make the transacted changes permanent.
 /// </summary>
 void IEnlistmentNotification.Commit(Enlistment enlistment)
 {
     _value = new StringBuilder(_temporaryValue.ToString());
     _temporaryValue = null;
     _enlistedTransaction = null;
     enlistment.Done();
 }

 public void InDoubt(Enlistment enlistment)
 {
     enlistment.Done();
     this.notification.InDoubt();
     Marshal.ReleaseComObject(this.notification);
     this.notification = null;
 }

 public void Commit(Enlistment enlistment)
 {
     enlistment.Done();
     this.notification.Committed(false, 0, 0);
     Marshal.ReleaseComObject(this.notification);
     this.notification = null;
 }

		void IEnlistmentNotification.Commit(Enlistment enlistment)
		{
			if (_ThrowIt && ++_ErrorCount < 2)
				throw new ApplicationException("simulating resource failure");

			enlistment.Done();
		}

		public override void Rollback(Enlistment enlistment)
		{
			if (_ThrowOnRollback)
				throw new Exception("Simulated rollback error");

			base.Rollback(enlistment);
		}

 public void Rollback(Enlistment enlistment)
 {
     foreach (var x in _rollbackCommands)
     {
         x();
     }
     enlistment.Done();
 }

        public void InDoubt( Enlistment enlistment )
        {
            Status = TxfmStatus.InInDoubt;

            enlistment.Done();

            Status = TxfmStatus.InTransaction;
        }

 public void InDoubt(Enlistment enlistment)
 {
     lock (_sharedLock)
     {
         if (InDoubtAction != null) InDoubtAction();
     }
     enlistment.Done();
 }

 public void Commit(Enlistment enlistment)
 {
     #if DEBUG
     System.Diagnostics.Trace.WriteLine("NuoDbTransaction::IEnlistmentNotification::Commit()");
     #endif
     Commit();
     enlistment.Done();
 }