public void SinglePhaseCommit(SinglePhaseEnlistment en) { if (en == null) { throw new ArgumentNullException("en"); } try { this.handle.WaitOne(); } catch (ObjectDisposedException) { } lock (this.syncRoot) { try { this.transaction.Commit(); en.Committed(); } catch (Exception exception) { en.Aborted(exception); } finally { if ((this.connection != null) && (this.connection.State != ConnectionState.Closed)) { this.connection.Close(); this.connection = null; } } } }
public void Rollback(SinglePhaseEnlistment en) { if (en == null) { throw new ArgumentNullException("en"); } try { this.handle.WaitOne(); } catch (ObjectDisposedException) { } lock (this.syncRoot) { if (this.transaction != null) { this.transaction.Dispose(); } if ((this.connection != null) && (this.connection.State != ConnectionState.Closed)) { this.connection.Close(); this.connection = null; } en.Aborted(); } }
/// <summary> /// Notifies an enlisted object that the transaction is being committed. /// </summary> /// <param name="singlePhaseEnlistment">A <see cref="T:System.Transactions.SinglePhaseEnlistment"/> interface used to send a response to the transaction manager.</param> public void SinglePhaseCommit(SinglePhaseEnlistment singlePhaseEnlistment) { onTxComplete(); session.Commit(GetLocalOrDistributedTransactionId(transaction)); singlePhaseEnlistment.Committed(); }
void IPromotableSinglePhaseNotification.SinglePhaseCommit( SinglePhaseEnlistment singlePhaseEnlistment ) { this.simpleTransaction.Commit(); singlePhaseEnlistment.Committed(); DriverTransactionManager.RemoveDriverInTransaction( this.baseTransaction ); this.connection.driver.CurrentTransaction = null; if( this.connection.State == ConnectionState.Closed ) { this.connection.CloseFully(); } }
public void SinglePhaseCommit(SinglePhaseEnlistment singlePhaseEnlistment) { simpleTransaction.Commit(); singlePhaseEnlistment.Committed(); DriverTransactionManager.RemoveDriverInTransaction(baseTransaction); if (connection.State == ConnectionState.Closed) connection.CloseFully(); }
void IPromotableSinglePhaseNotification.Rollback(SinglePhaseEnlistment singlePhaseEnlistment) { simpleTransaction.Rollback(); singlePhaseEnlistment.Aborted(); DriverTransactionManager.RemoveDriverInTransaction(baseTransaction); connection.driver.CurrentTransaction = null; if (connection.State == ConnectionState.Closed) connection.CloseFully(); }
public void SinglePhaseCommit(SinglePhaseEnlistment singlePhaseEnlistment) { try { Neo4jTransaction.DoCommit(_transactionExecutionEnvironment); singlePhaseEnlistment.Committed(); } finally { singlePhaseEnlistment.Aborted(); } }
public void SinglePhaseCommit(SinglePhaseEnlistment singlePhaseEnlistment) { try { Commit(); singlePhaseEnlistment.Done(); } catch (Exception) { //on a callback thread, can't throw } }
public void SinglePhaseCommit(SinglePhaseEnlistment en) { if (en == null) throw new ArgumentNullException("en"); // // Wait until IPendingWork members have completed (WinOE bugs 17580 and 13395) try { handle.WaitOne(); } catch (ObjectDisposedException) { // If an ObjectDisposedException is thrown because // the WaitHandle has already closed, nothing to worry // about. Move on. } lock (syncRoot) { try { this.transaction.Commit(); en.Committed(); } catch (Exception e) { en.Aborted(e); } finally { if ((null != connection) && (ConnectionState.Closed != connection.State)) { connection.Close(); connection = null; } } } }
public void Rollback(SinglePhaseEnlistment singlePhaseEnlistment) { // prevent commands in main thread to run concurrently Driver driver = connection.driver; lock (driver) { rollbackThreadId = Thread.CurrentThread.ManagedThreadId; while (connection.Reader != null) { // wait for reader to finish. Maybe we should not wait // forever and cancel it after some time? System.Threading.Thread.Sleep(100); } simpleTransaction.Rollback(); singlePhaseEnlistment.Aborted(); DriverTransactionManager.RemoveDriverInTransaction(baseTransaction); if (connection.State == ConnectionState.Closed) connection.CloseFully(); rollbackThreadId = 0; } }
public void Rollback(SinglePhaseEnlistment singlePhaseEnlistment) {}
public void SinglePhaseCommit(SinglePhaseEnlistment singlePhaseEnlistment) {}
public void SinglePhaseCommit(SinglePhaseEnlistment singlePhaseEnlistment) { _log.Debug("Single Phase Commit"); if (_npgsqlTx != null) { _npgsqlTx.Commit(); _npgsqlTx.Dispose(); _npgsqlTx = null; singlePhaseEnlistment.Committed(); _connection.PromotableLocalTransactionEnded(); } else if (_callbacks != null) { if (_rm != null) { _rm.CommitWork(_callbacks.GetName()); singlePhaseEnlistment.Committed(); } else { _callbacks.CommitTransaction(); singlePhaseEnlistment.Committed(); } _callbacks = null; } _inTransaction = false; }
public void Rollback(SinglePhaseEnlistment singlePhaseEnlistment) { NpgsqlEventLog.LogMethodEnter(LogLevel.Debug, CLASSNAME, "Rollback"); // try to rollback the transaction with either the // ADO.NET transaction or the callbacks that managed the // two phase commit transaction. if (_npgsqlTx != null) { _npgsqlTx.Rollback(); _npgsqlTx.Dispose(); _npgsqlTx = null; singlePhaseEnlistment.Aborted(); _connection.PromotableLocalTransactionEnded(); } else if (_callbacks != null) { if (_rm != null) { _rm.RollbackWork(_callbacks.GetName()); singlePhaseEnlistment.Aborted(); } else { _callbacks.RollbackTransaction(); singlePhaseEnlistment.Aborted(); } _callbacks = null; } _inTransaction = false; }
/// <summary> /// Rollbacks the specified single phase enlistment. /// </summary> /// <param name="singlePhaseEnlistment">The single phase enlistment.</param> public void Rollback(SinglePhaseEnlistment singlePhaseEnlistment) { onTxComplete(); try { session.Rollback(PromotableRavenClientEnlistment.GetLocalOrDistributedTransactionId(transaction)); using (var machineStoreForApplication = IsolatedStorageFile.GetMachineStoreForDomain()) { machineStoreForApplication.DeleteFile(TransactionRecoveryInformationFileName); } } catch (Exception e) { logger.ErrorException("Could not rollback distributed transaction", e); singlePhaseEnlistment.InDoubt(e); return; } singlePhaseEnlistment.Aborted(); }
public void Rollback(SinglePhaseEnlistment singlePhaseEnlistment) { singlePhaseEnlistment.Done(); }
public void SinglePhaseCommit(SinglePhaseEnlistment singlePhaseEnlistment) { _callbacks.CommitTransaction(); singlePhaseEnlistment.Committed(); _callbacks.Dispose(); }
///<summary> /// Attempt to rollback the internal transaction. ///</summary> void IPromotableSinglePhaseNotification.Rollback(SinglePhaseEnlistment singlePhaseEnlistment) { try { // attempt to rollback the transaction this.dbTransaction.Rollback(); singlePhaseEnlistment.Done(); } finally { // clean-up our resources Dispose(); } }
/// <summary> /// Rollbacks the specified single phase enlistment. /// </summary> /// <param name="singlePhaseEnlistment">The single phase enlistment.</param> public void Rollback(SinglePhaseEnlistment singlePhaseEnlistment) { onTxComplete(); try { session.Rollback(transaction.LocalIdentifier); DeleteFile(); } catch (Exception e) { logger.ErrorException("Could not rollback distributed transaction", e); singlePhaseEnlistment.InDoubt(e); return; } singlePhaseEnlistment.Aborted(); ctx.Dispose(); }
///<summary> /// Attempt to commit the internal transaction. ///</summary> void IPromotableSinglePhaseNotification.SinglePhaseCommit(SinglePhaseEnlistment singlePhaseEnlistment) { try { // attempt to commit the enlistment this.dbTransaction.Commit(); singlePhaseEnlistment.Committed(); } catch (Exception e) { // something went wrong, make sure the transaction aborts singlePhaseEnlistment.Aborted(e); throw; } finally { // clean-up our resources Dispose(); } }
void IPromotableSinglePhaseNotification.SinglePhaseCommit(SinglePhaseEnlistment singlePhaseEnlistment) { lock (this.syncRoot) { if (this.txnid != null) { this.controller.DischargeAsync(this.txnid, false).ContinueWith( (t, o) => { var spe = (SinglePhaseEnlistment)o; if (t.IsFaulted) { spe.Aborted(t.Exception.InnerException); } else { spe.Done(); } }, singlePhaseEnlistment); } } }
void DoSingleCommit (ISinglePhaseNotification single) { if (single == null) return; SinglePhaseEnlistment enlistment = new SinglePhaseEnlistment (this, single); single.SinglePhaseCommit (enlistment); CheckAborted (); }
// Called by transaction to initiate abort sequence public void Rollback(SysTx.SinglePhaseEnlistment enlistment) { Debug.Assert(null != enlistment, "null enlistment?"); SqlInternalConnection connection = GetValidConnection(); SqlConnection usersConnection = connection.Connection; Bid.Trace("<sc.SqlDelegatedTransaction.Rollback|RES|CPOOL> %d#, Connection %d#, aborting transaction.\n", ObjectID, connection.ObjectID); RuntimeHelpers.PrepareConstrainedRegions(); try { #if DEBUG TdsParser.ReliabilitySection tdsReliabilitySection = new TdsParser.ReliabilitySection(); RuntimeHelpers.PrepareConstrainedRegions(); try { tdsReliabilitySection.Start(); #else { #endif //DEBUG lock (connection) { try { // Now that we've acquired the lock, make sure we still have valid state for this operation. ValidateActiveOnConnection(connection); _active = false; // set to inactive first, doesn't matter how the execute completes, this transaction is done. _connection = null; // Set prior to ExecuteTransaction call in case this initiates a TransactionEnd event // If we haven't already rolled back (or aborted) then tell the SQL Server to roll back if (!_internalTransaction.IsAborted) { connection.ExecuteTransaction(SqlInternalConnection.TransactionRequest.Rollback, null, IsolationLevel.Unspecified, _internalTransaction, true); } } catch (SqlException e) { ADP.TraceExceptionWithoutRethrow(e); // Doom the connection, to make sure that the transaction is // eventually rolled back. // VSTS 144562: doom the connection while having the lock on it to prevent race condition with "Transaction Ended" Event connection.DoomThisConnection(); // Unlike SinglePhaseCommit, a rollback is a rollback, regardless // of how it happens, so SysTx won't throw an exception, and we // don't want to throw an exception either, because SysTx isn't // handling it and it may create a fail fast scenario. In the end, // there is no way for us to communicate to the consumer that this // failed for more serious reasons than usual. // // This is a bit like "should you throw if Close fails", however, // it only matters when you really need to know. In that case, // we have the tracing that we're doing to fallback on for the // investigation. } catch (InvalidOperationException e) { ADP.TraceExceptionWithoutRethrow(e); connection.DoomThisConnection(); } } // it doesn't matter whether the rollback succeeded or not, we presume // that the transaction is aborted, because it will be eventually. connection.CleanupConnectionOnTransactionCompletion(_atomicTransaction); enlistment.Aborted(); } #if DEBUG finally { tdsReliabilitySection.Stop(); } #endif //DEBUG } catch (System.OutOfMemoryException e) { usersConnection.Abort(e); throw; } catch (System.StackOverflowException e) { usersConnection.Abort(e); throw; } catch (System.Threading.ThreadAbortException e) { usersConnection.Abort(e); throw; } }
/// <summary> /// Rollbacks the specified single phase enlistment. /// </summary> /// <param name="singlePhaseEnlistment">The single phase enlistment.</param> public void Rollback(SinglePhaseEnlistment singlePhaseEnlistment) { onTxComplete(); try { session.Rollback(PromotableRavenClientEnlistment.GetLocalOrDistributedTransactionId(transaction)); DeleteFile(); } catch (Exception e) { logger.ErrorException("Could not rollback distributed transaction", e); singlePhaseEnlistment.InDoubt(e); return; } singlePhaseEnlistment.Aborted(); }
// Called by the transaction to initiate commit sequence public void SinglePhaseCommit(SysTx.SinglePhaseEnlistment enlistment) { Debug.Assert(null != enlistment, "null enlistment?"); SqlInternalConnection connection = GetValidConnection(); SqlConnection usersConnection = connection.Connection; Bid.Trace("<sc.SqlDelegatedTransaction.SinglePhaseCommit|RES|CPOOL> %d#, Connection %d#, committing transaction.\n", ObjectID, connection.ObjectID); RuntimeHelpers.PrepareConstrainedRegions(); try { #if DEBUG TdsParser.ReliabilitySection tdsReliabilitySection = new TdsParser.ReliabilitySection(); RuntimeHelpers.PrepareConstrainedRegions(); try { tdsReliabilitySection.Start(); #else { #endif //DEBUG // If the connection is dooomed, we can be certain that the // transaction will eventually be rolled back, and we shouldn't // attempt to commit it. if (connection.IsConnectionDoomed) { lock (connection) { _active = false; // set to inactive first, doesn't matter how the rest completes, this transaction is done. _connection = null; } enlistment.Aborted(SQL.ConnectionDoomed()); } else { Exception commitException; lock (connection) { try { // Now that we've acquired the lock, make sure we still have valid state for this operation. ValidateActiveOnConnection(connection); _active = false; // set to inactive first, doesn't matter how the rest completes, this transaction is done. _connection = null; // Set prior to ExecuteTransaction call in case this initiates a TransactionEnd event connection.ExecuteTransaction(SqlInternalConnection.TransactionRequest.Commit, null, IsolationLevel.Unspecified, _internalTransaction, true); commitException = null; } catch (SqlException e) { commitException = e; ADP.TraceExceptionWithoutRethrow(e); // Doom the connection, to make sure that the transaction is // eventually rolled back. // VSTS 144562: doom the connection while having the lock on it to prevent race condition with "Transaction Ended" Event connection.DoomThisConnection(); } catch (InvalidOperationException e) { commitException = e; ADP.TraceExceptionWithoutRethrow(e); connection.DoomThisConnection(); } } if (commitException != null) { // connection.ExecuteTransaction failed with exception if (_internalTransaction.IsCommitted) { // Even though we got an exception, the transaction // was committed by the server. enlistment.Committed(); } else if (_internalTransaction.IsAborted) { // The transaction was aborted, report that to // SysTx. enlistment.Aborted(commitException); } else { // The transaction is still active, we cannot // know the state of the transaction. enlistment.InDoubt(commitException); } // We eat the exception. This is called on the SysTx // thread, not the applications thread. If we don't // eat the exception an UnhandledException will occur, // causing the process to FailFast. } connection.CleanupConnectionOnTransactionCompletion(_atomicTransaction); if (commitException == null) { // connection.ExecuteTransaction succeeded enlistment.Committed(); } } } #if DEBUG finally { tdsReliabilitySection.Stop(); } #endif //DEBUG } catch (System.OutOfMemoryException e) { usersConnection.Abort(e); throw; } catch (System.StackOverflowException e) { usersConnection.Abort(e); throw; } catch (System.Threading.ThreadAbortException e) { usersConnection.Abort(e); throw; } }
void IPromotableSinglePhaseNotification.Rollback(SinglePhaseEnlistment singlePhaseEnlistment) { MySqlTransactionScope current = scopeStack.Peek(); current.Rollback(singlePhaseEnlistment); scopeStack.Pop(); }
public void SinglePhaseCommit(SinglePhaseEnlistment singlePhaseEnlistment) { NpgsqlEventLog.LogMethodEnter(LogLevel.Debug, CLASSNAME, "SinglePhaseCommit"); if (_npgsqlTx != null) { _npgsqlTx.Commit(); _npgsqlTx.Dispose(); _npgsqlTx = null; singlePhaseEnlistment.Committed(); _connection.PromotableLocalTransactionEnded(); } else if (_callbacks != null) { if (_rm != null) { _rm.CommitWork(_callbacks.GetName()); singlePhaseEnlistment.Committed(); } else { _callbacks.CommitTransaction(); singlePhaseEnlistment.Committed(); } _callbacks = null; } _inTransaction = false; }
void IPromotableSinglePhaseNotification.SinglePhaseCommit(SinglePhaseEnlistment singlePhaseEnlistment) { scopeStack.Pop().SinglePhaseCommit(singlePhaseEnlistment); }
public void SinglePhaseCommit(SinglePhaseEnlistment singlePhaseEnlistment) { singlePhaseEnlistment.Committed(); }
void ISinglePhaseNotification.SinglePhaseCommit(SinglePhaseEnlistment singlePhaseEnlistment) { }
internal void Rollback (Exception ex, object abortingEnlisted) { if (aborted) { FireCompleted (); return; } /* See test ExplicitTransaction7 */ if (info.Status == TransactionStatus.Committed) throw new TransactionException ("Transaction has already been committed. Cannot accept any new work."); // Save thrown exception as 'reason' of transaction's abort. innerException = ex; SinglePhaseEnlistment e = new SinglePhaseEnlistment(); foreach (IEnlistmentNotification prep in Volatiles) if (prep != abortingEnlisted) prep.Rollback (e); var durables = Durables; if (durables.Count > 0 && durables [0] != abortingEnlisted) durables [0].Rollback (e); if (pspe != null && pspe != abortingEnlisted) pspe.Rollback (e); Aborted = true; FireCompleted (); }
/// <summary> /// Notifies an enlisted object that the transaction is being rolled back. /// </summary> /// <param name="singlePhaseEnlistment">A <see cref="T:System.Transactions.SinglePhaseEnlistment"/> object used to send a response to the transaction manager.</param> public void Rollback(SinglePhaseEnlistment singlePhaseEnlistment) { onTxComplete(); session.Rollback(GetLocalOrDistributedTransactionId(transaction)); singlePhaseEnlistment.Aborted(); }