/// <summary> /// Notifies an enlisted object that a transaction is being prepared for commitment. /// </summary> /// <param name="preparingEnlistment">A <see cref="T:System.Transactions.PreparingEnlistment"/> object used to send a response to the transaction manager.</param> public void Prepare(PreparingEnlistment preparingEnlistment) { onTxComplete(); try { using (var machineStoreForApplication = IsolatedStorageFile.GetMachineStoreForDomain()) { var name = TransactionRecoveryInformationFileName; using (var file = machineStoreForApplication.CreateFile(name + ".temp")) using (var writer = new BinaryWriter(file)) { writer.Write(session.ResourceManagerId.ToString()); writer.Write(PromotableRavenClientEnlistment.GetLocalOrDistributedTransactionId(transaction).ToString()); writer.Write(session.DatabaseName ?? ""); writer.Write(preparingEnlistment.RecoveryInformation()); file.Flush(true); } machineStoreForApplication.MoveFile(name + ".temp", name); } } catch (Exception e) { logger.ErrorException("Could not prepare distributed transaction", e); preparingEnlistment.ForceRollback(e); return; } preparingEnlistment.Prepared(); }
static void HandleEndPrepare(IAsyncResult result) { PreparingEnlistment preparingEnlistment = (PreparingEnlistment)result.AsyncState; bool success = false; try { if (!result.CompletedSynchronously) { PrepareAsyncResult.End(result); preparingEnlistment.Prepared(); } success = true; } //we need to swollow the TransactionException as it could because another party aborting it catch (TransactionException) { } finally { if (!success) { preparingEnlistment.ForceRollback(); } } }
void IEnlistmentNotification.Prepare(PreparingEnlistment preparingEnlistment) { bool success = false; try { IAsyncResult result = new PrepareAsyncResult(this, TransactionContext.handleEndPrepare, preparingEnlistment); if (result.CompletedSynchronously) { PrepareAsyncResult.End(result); preparingEnlistment.Prepared(); } success = true; } //we need to swollow the TransactionException as it could because another party aborting it catch (TransactionException) { } finally { if (!success) { preparingEnlistment.ForceRollback(); } } }
void IEnlistmentNotification.Prepare(PreparingEnlistment preparingEnlistment) { using (new SessionIdLoggingContext(sessionImplementor.SessionId)) { try { using (var tx = new TransactionScope(AmbientTransation)) { if (sessionImplementor.ConnectionManager.IsConnected) { using (sessionImplementor.ConnectionManager.FlushingFromDtcTransaction) { sessionImplementor.BeforeTransactionCompletion(null); foreach (var dependentSession in sessionImplementor.ConnectionManager.DependentSessions) { dependentSession.BeforeTransactionCompletion(null); } logger.Debug("prepared for DTC transaction"); tx.Complete(); } } } preparingEnlistment.Prepared(); } catch (Exception exception) { logger.Error("DTC transaction prepare phase failed", exception); preparingEnlistment.ForceRollback(exception); } } }
public void Prepare(PreparingEnlistment preparingEnlistment) { CheckDisposed(); Log.Debug($"Two-phase transaction prepare (localid={_txId})", _connector.Id); // The PostgreSQL prepared transaction name is the distributed GUID + our connection's process ID, for uniqueness _preparedTxName = $"{_transaction.TransactionInformation.DistributedIdentifier}/{_connector.BackendProcessId}"; try { using (_connector.StartUserAction()) _connector.ExecuteInternalCommand($"PREPARE TRANSACTION '{_preparedTxName}'"); // The MSDTC, which manages escalated distributed transactions, performs the 2nd phase // asynchronously - this means that TransactionScope.Dispose() will return before all // resource managers have actually commit. // If the same connection tries to enlist to a new TransactionScope immediately after // disposing an old TransactionScope, its EnlistedTransaction must have been cleared // (or we'll throw a double enlistment exception). This must be done here at the 1st phase // (which is sync). if (_connector.Connection != null) { _connector.Connection.EnlistedTransaction = null; } preparingEnlistment.Prepared(); } catch (Exception e) { Dispose(); preparingEnlistment.ForceRollback(e); } }
void IEnlistmentNotification.Prepare(PreparingEnlistment preparingEnlistment) { using (new SessionIdLoggingContext(sessionImplementor.SessionId)) { try { using (var tx = new TransactionScope(AmbientTransation)) { sessionImplementor.BeforeTransactionCompletion(null); if (sessionImplementor.FlushMode != FlushMode.Never && sessionImplementor.ConnectionManager.IsConnected) { using (sessionImplementor.ConnectionManager.FlushingFromDtcTransaction) { logger.Debug(string.Format("[session-id={0}] Flushing from Dtc Transaction", sessionImplementor.SessionId)); sessionImplementor.Flush(); } } logger.Debug("prepared for DTC transaction"); tx.Complete(); } preparingEnlistment.Prepared(); } catch (Exception exception) { logger.Error("DTC transaction prepre phase failed", exception); preparingEnlistment.ForceRollback(exception); } } }
/// <summary> /// Notifies an enlisted object that a transaction is being prepared /// for commitment. /// </summary> /// <param name="preparingEnlistment"> /// A <see cref="T:System.Transactions.PreparingEnlistment" /> object /// used to send a response to the transaction manager. /// </param> public void Prepare(PreparingEnlistment preparingEnlistment) { try { #if DEBUG Console.WriteLine( "{0}.Prepare(...) (try) - {1}", this.GetType(), this.managedPath); #endif this.ManagedFileStream = this.OnPrepareFileStream(this.managedPath); preparingEnlistment.Prepared(); } catch (Exception e) { #if DEBUG Console.WriteLine( "{0}.Prepare(...) (catch) - {1}", this.GetType(), this.managedPath); #endif // Rollback() is not called on a resource manager // if its Prepare() method votes for rollback. if (!this.disposed) { this.OnRollback(); } preparingEnlistment.ForceRollback(e); } }
public virtual void Prepare(PreparingEnlistment preparingEnlistment) { try { if (this.dataAccessObjectDataContext != null) { this.dataAccessObjectDataContext.Commit(this, false); } preparingEnlistment.Prepared(); } catch (TransactionAbortedException) { throw; } catch (Exception e) { foreach (var persistenceTransactionContext in this.persistenceTransactionContextsBySqlDatabaseContexts.Values) { persistenceTransactionContext.sqlDatabaseCommandsContext.Rollback(); } preparingEnlistment.ForceRollback(e); Dispose(); } }
public void Prepare(PreparingEnlistment preparingEnlistment) { if (_transaction != null && !_transaction.HasMutations) { // In the case where our resource manager doesn't have any mutations, it was a read, // which we will no-op and allow through even if it was a two phase commit. // This allows cases such as nested transactions where the inner transaction is a readonly // timestamp bound read and doesn't have anything to commit. Logger.Debug(() => "Received a PREPARE for a two phase commit but without changes. This is allowed."); preparingEnlistment.Prepared(); return; } Logger.Warn(() => "Received a call to Prepare, which indicates two phase commit inside a transaction scope. This is currently not supported in Spanner."); try { preparingEnlistment.ForceRollback(new NotSupportedException( "Spanner only supports single phase commit (Prepare not supported)." + " This error can happen when attempting to use multiple transaction resources but may also happen for" + " other reasons that cause a Transaction to use two-phase commit.")); } finally { // We've forced a rollback, but the expectation is that *this* resource // manager won't have done anything yet, given that we've "failed" to prepare. // Therefore we need to clean ourselves up. The other resource managers that have already // been prepared will be cleaned up by the transaction manager. Dispose(); } }
public void Prepare(PreparingEnlistment preparingEnlistment) { uint method = 0x528; this.TrEntry(method, new object[] { preparingEnlistment }); preparingEnlistment.ForceRollback(); base.TrExit(method); }
/// <summary> /// Prepare the session for the transaction commit. Run /// <see cref="ISessionImplementor.BeforeTransactionCompletion(ITransaction)"/> for the session and for /// <see cref="ConnectionManager.DependentSessions"/> if any. <see cref="Lock"/> the context /// before signaling it is done, or before rollback in case of failure. /// </summary> /// <param name="preparingEnlistment">The object for notifying the prepare phase outcome.</param> public virtual void Prepare(PreparingEnlistment preparingEnlistment) { _preparing = true; using (_session.BeginContext()) { try { using (_session.ConnectionManager.BeginProcessingFromSystemTransaction(_useConnectionOnSystemTransactionPrepare)) { if (_useConnectionOnSystemTransactionPrepare) { // Ensure any newly acquired connection gets enlisted in the transaction. When distributed, // this code runs from another thread and we cannot rely on Transaction.Current. using (var tx = new TransactionScope(EnlistedTransaction)) { // Required when both connection auto-enlistment and session auto-enlistment are disabled. _session.JoinTransaction(); _session.BeforeTransactionCompletion(null); foreach (var dependentSession in _session.ConnectionManager.DependentSessions) { dependentSession.BeforeTransactionCompletion(null); } tx.Complete(); } } else { _session.BeforeTransactionCompletion(null); foreach (var dependentSession in _session.ConnectionManager.DependentSessions) { dependentSession.BeforeTransactionCompletion(null); } } } // Lock the session to ensure second phase gets done before the session is used by code following // the transaction scope disposal. Lock(); _logger.Debug("Prepared for system transaction"); _preparing = false; preparingEnlistment.Prepared(); } catch (Exception exception) { _preparing = false; _logger.Error(exception, "System transaction prepare phase failed"); try { CompleteTransaction(false); } finally { preparingEnlistment.ForceRollback(exception); } } } }
public void Prepare ( PreparingEnlistment preparingEnlistment ) { resource.NumPrepare++; if ( resource.IgnorePrepare ) return; if ( resource.FailPrepare ) { if (resource.FailWithException) preparingEnlistment.ForceRollback ( new NotSupportedException () ); else preparingEnlistment.ForceRollback (); } else { preparingEnlistment.Prepared (); } }
public void Prepare(PreparingEnlistment preparingEnlistment) { Console.WriteLine("PREPARE - VolatileResource"); if (throwIt && ++errorCount < 2) { throw new ApplicationException("simulating resource failure"); } preparingEnlistment.ForceRollback(); }
public void Prepare(PreparingEnlistment preparingEnlistment) { this.CheckDisposed(); if (!this._transaction.IsValid(false)) { preparingEnlistment.ForceRollback(); return; } preparingEnlistment.Prepared(); }
public void Prepare(PreparingEnlistment preparingEnlistment) { try { preparingEnlistment.Prepared(); } catch (Exception ex) { preparingEnlistment.ForceRollback(ex); } }
public void Prepare(PreparingEnlistment preparingEnlistment) { if (_unitOfWork.KeepAlive()) { preparingEnlistment.Prepared(); } else { preparingEnlistment.ForceRollback(); } }
void IEnlistmentNotification.Prepare(PreparingEnlistment preparingEnlistment) { if (!_transaction.NotifyPrepare()) { preparingEnlistment.ForceRollback(); } else { preparingEnlistment.Prepared(); } }
public void Prepare(PreparingEnlistment preparingEnlistment) { if (RandomRollback && rand.Next(0, 10) > 7) { preparingEnlistment.ForceRollback(); } else { preparingEnlistment.Prepared(); } }
public void Prepare(PreparingEnlistment preparingEnlistment) { if (_transaction.IsValid(false) == false) { preparingEnlistment.ForceRollback(); } else { preparingEnlistment.Prepared(); } }
public void Prepare(PreparingEnlistment preparingEnlistment) { if (_ThrowIt) { preparingEnlistment.ForceRollback(new ApplicationException("this one went astray")); } else { preparingEnlistment.Prepared(); } }
public void Prepare(PreparingEnlistment preparingEnlistment) { Console.WriteLine("Prepare notification received"); //Perform transactional work //If work finished correctly, reply prepared preparingEnlistment.Prepared(); // otherwise, do a ForceRollback preparingEnlistment.ForceRollback(); }
/// <summary> /// Notifies an enlisted object that a transaction is being prepared for /// commitment. /// </summary> /// <param name="preparingEnlistment"> /// A <see cref="T:System.Transactions.PreparingEnlistment"></see> object /// used to send a response to the transaction manager.</param> void IEnlistmentNotification.Prepare(PreparingEnlistment preparingEnlistment) { if (m_dbTransaction.m_valid) { m_dbTransaction.Connection.Session.PrepareCommit(); preparingEnlistment.Prepared(); } else { preparingEnlistment.ForceRollback(); } }
public void Prepare(PreparingEnlistment preparingEnlistment) { try { PrepareAction(); preparingEnlistment.Prepared(); } catch { preparingEnlistment.ForceRollback(); } }
//Don't throw an exception here. Instead call ForceRollback() public void Prepare(PreparingEnlistment preparingEnlistment) { try { Execute(); preparingEnlistment.Prepared(); } catch (Exception e) { preparingEnlistment.ForceRollback(e); } }
public void Prepare(PreparingEnlistment preparingEnlistment) { try { // Nothing to do preparingEnlistment.Prepared(); } catch (Exception e) { preparingEnlistment.ForceRollback(e); } }
public void Prepare(PreparingEnlistment preparingEnlistment) { try { Neo4jRestTransaction.DoKeepAlive(transactionExecutionEnvironment); preparingEnlistment.Prepared(); } catch (Exception e) { preparingEnlistment.ForceRollback(e); } }
public void Prepare(PreparingEnlistment preparingEnlistment) { if ((this.channel.State == CommunicationState.Opened) && (this.channel.InternalPendingItems > 0)) { Exception e = DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("MsmqSessionChannelsMustBeClosed"))); preparingEnlistment.ForceRollback(e); this.channel.Fault(); } else { preparingEnlistment.Done(); } }
public void Prepare(PreparingEnlistment preparingEnlistment) { Assert.AreNotEqual(thread, Thread.CurrentThread.ManagedThreadId); if (shouldRollBack) { log.Debug(">>>>Force Rollback<<<<<"); preparingEnlistment.ForceRollback(); } else { preparingEnlistment.Prepared(); } }
public void Prepare(PreparingEnlistment preparingEnlistment) { try { _transaction.IsValid(); } catch (Exception e) { preparingEnlistment.ForceRollback(e); return; } preparingEnlistment.Prepared(); }
public void Prepare(PreparingEnlistment preparingEnlistment) { if (this.channel.State != CommunicationState.Closed) { this.channel.Fault(); Exception e = DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("MsmqSessionChannelsMustBeClosed"))); preparingEnlistment.ForceRollback(e); } else { preparingEnlistment.Prepared(); } }
public void Prepare(PreparingEnlistment preparingEnlistment) { switch (_phase1Vote) { case Phase1Vote.Prepared: { preparingEnlistment.Prepared(); break; } case Phase1Vote.ForceRollback: { preparingEnlistment.ForceRollback(); break; } case Phase1Vote.Done: { preparingEnlistment.Done(); break; } } }
public void Prepare(PreparingEnlistment preparingEnlistment) { switch (_phase1Vote) { case Phase1Vote.Prepared: { if (_volatileEnlistDuringPrepare) { TestEnlistment newVol = new TestEnlistment(_phase1Vote, _expectedOutcome); try { _txToEnlist.EnlistVolatile(newVol, EnlistmentOptions.None); Assert.Equal(_expectEnlistToSucceed, true); } catch (Exception) { Assert.Equal(_expectEnlistToSucceed, false); } } preparingEnlistment.Prepared(); break; } case Phase1Vote.ForceRollback: { if (_outcomeReceived != null) { _outcomeReceived.Set(); } preparingEnlistment.ForceRollback(); break; } case Phase1Vote.Done: { if (_outcomeReceived != null) { _outcomeReceived.Set(); } preparingEnlistment.Done(); break; } } }
public void Prepare(PreparingEnlistment preparingEnlistment) { if (_enlistDuringPrepare) { Trace(string.Format("MyEnlistment.Prepare - attempting another enlistment with options {0}", _enlistOptions.ToString())); try { MyEnlistment enlist2 = new MyEnlistment( _secondEnlistmentCompleted, /*votePrepared=*/ true, /*enlistDuringPrepare=*/ false, _enlistOptions); this.TransactionToEnlist.EnlistVolatile(enlist2, _enlistOptions); if (!_expectSuccessfulEnlist) { // Force rollback of the transaction because the second enlistment was unsuccessful. Trace("MyEnlistment.Prepare - Force Rollback because second enlistment succeeded unexpectedly"); _aborted = true; _outcomeReceived.Set(); preparingEnlistment.ForceRollback(new Exception("MyEnlistment voted ForceRollback")); return; } } catch (Exception ex) { if (_expectSuccessfulEnlist) { Trace(string.Format("MyEnlistment.Prepare - Force Rollback because second enlistment failed unexpectedly - {0}; {1}", ex.GetType().ToString(), ex.ToString())); // Force rollback of the transaction because the second enlistment was unsuccessful. _aborted = true; _outcomeReceived.Set(); preparingEnlistment.ForceRollback(new Exception("MyEnlistment voted ForceRollback")); return; } } } if (_votePrepared) { Trace("MyEnlistment.Prepare voting Prepared"); preparingEnlistment.Prepared(); } else { Trace("MyEnlistment.Prepare - Force Rollback"); _aborted = true; _outcomeReceived.Set(); preparingEnlistment.ForceRollback(new Exception("MyEnlistment voted ForceRollback")); } }
public void Prepare(PreparingEnlistment preparingEnlistment) { resource.NumPrepare++; if (resource.IgnorePrepare) return; if (resource.FailPrepare) { if (resource.FailWithException) preparingEnlistment.ForceRollback(resource.ThrowThisException ?? new NotSupportedException()); else preparingEnlistment.ForceRollback(); } else { preparingEnlistment.Prepared(); } }
public void Prepare(PreparingEnlistment preparingEnlistment) { try { dtcControlEvent.Reset(); Tracer.Debug("Prepare notification received for TX id: " + this.transactionId); BeforeEnd(); // Before sending the request to the broker, log the recovery bits, if // this fails we can't prepare and the TX should be rolled back. RecoveryLogger.LogRecoveryInfo(this.transactionId as XATransactionId, preparingEnlistment.RecoveryInformation()); // Inform the broker that work on the XA'sh TX Branch is complete. TransactionInfo info = new TransactionInfo(); info.ConnectionId = this.connection.ConnectionId; info.TransactionId = this.transactionId; info.Type = (int) TransactionType.End; this.connection.CheckConnected(); this.connection.SyncRequest(info); // Prepare the Transaction for commit. info.Type = (int) TransactionType.Prepare; IntegerResponse response = (IntegerResponse) this.connection.SyncRequest(info); if(response.Result == XA_READONLY) { Tracer.Debug("Transaction Prepare done and doesn't need a commit, TX id: " + this.transactionId); this.transactionId = null; this.currentEnlistment = null; // Read Only means there's nothing to recover because there was no // change on the broker. RecoveryLogger.LogRecovered(this.transactionId as XATransactionId); // if server responds that nothing needs to be done, then reply prepared // but clear the current state data so we appear done to the commit method. preparingEnlistment.Prepared(); // Done so commit won't be called. AfterCommit(); } else { Tracer.Debug("Transaction Prepare succeeded TX id: " + this.transactionId); // If work finished correctly, reply prepared preparingEnlistment.Prepared(); } } catch(Exception ex) { Tracer.DebugFormat("Transaction[{0}] Prepare failed with error: {1}", this.transactionId, ex.Message); AfterRollback(); preparingEnlistment.ForceRollback(); try { this.connection.OnException(ex); } catch (Exception error) { Tracer.Error(error.ToString()); } this.currentEnlistment = null; this.transactionId = null; } finally { this.dtcControlEvent.Set(); } }