protected void VerifyAndTraceEnlistmentOptions()
{
Microsoft.Transactions.Bridge.EnlistmentOptions enlistmentOptions = this.enlistment.EnlistmentOptions;
if (enlistmentOptions == null)
{
DiagnosticUtility.FailFast("Need EnlistmentOptions for context");
}
if (enlistmentOptions.IsoLevel == IsolationLevel.Unspecified)
{
DiagnosticUtility.FailFast("Need IsolationLevel for context");
}
if (this.enlistment.LocalTransactionId == Guid.Empty)
{
DiagnosticUtility.FailFast("Need LocalTransactionId for context");
}
if (string.IsNullOrEmpty(this.enlistment.RemoteTransactionId))
{
DiagnosticUtility.FailFast("Need RemoteTransactionId for context");
}
if (DebugTrace.Info)
{
DebugTrace.TxTrace(TraceLevel.Info, this.enlistmentId, "Local transactionId is {0}", this.enlistment.LocalTransactionId);
DebugTrace.TxTrace(TraceLevel.Info, this.enlistmentId, "Remote transactionId is {0}", this.enlistment.RemoteTransactionId);
DebugTrace.TxTrace(TraceLevel.Info, this.enlistmentId, "Transaction timeout is {0} seconds", enlistmentOptions.Expires.TotalSeconds);
DebugTrace.TxTrace(TraceLevel.Info, this.enlistmentId, "Transaction isolation level is {0}", enlistmentOptions.IsoLevel);
}
}
public void Rejoined(ParticipantEnlistment participant)
{
if (DebugTrace.Info)
{
DebugTrace.TxTrace(TraceLevel.Info, participant.EnlistmentId, "Replying Success to transaction manager's Rejoin");
}
participant.DeliverCallback(Status.Success);
}
public void PrePrepare(VolatileCoordinatorEnlistment volatileCoordinator)
{
if (DebugTrace.Info)
{
DebugTrace.TxTrace(TraceLevel.Info, volatileCoordinator.EnlistmentId, "Sending PrePrepare to transaction manager");
}
this.coordination.PrePrepare(volatileCoordinator.Enlistment, this.prePrepareResponseCallback, volatileCoordinator);
}
public void ForgetResponse(TransactionEnlistment enlistment, Status status)
{
if (DebugTrace.Info)
{
DebugTrace.TxTrace(TraceLevel.Info, enlistment.EnlistmentId, "Replying {0} to transaction manager's Forget", status);
}
enlistment.DeliverCallback(status);
}
public void Replayed(CoordinatorEnlistment coordinator)
{
if (DebugTrace.Info)
{
DebugTrace.TxTrace(TraceLevel.Info, coordinator.EnlistmentId, "Replying Success to transaction manager's Replay");
}
coordinator.DeliverCallback(Status.Success);
}
public void Rollback(CompletionEnlistment completion)
{
if (DebugTrace.Info)
{
DebugTrace.TxTrace(TraceLevel.Info, completion.EnlistmentId, "Sending completion Rollback to transaction manager");
}
this.coordination.Rollback(completion.Enlistment, this.completionRollbackResponseCallback, completion);
}
public void Rollback(TransactionEnlistment enlistment)
{
if (DebugTrace.Info)
{
DebugTrace.TxTrace(TraceLevel.Info, enlistment.EnlistmentId, "Sending Rollback to transaction manager");
}
this.coordination.Rollback(enlistment.Enlistment, this.rollbackResponseCallback, enlistment);
}
public void Aborted(CoordinatorEnlistment coordinator)
{
if (DebugTrace.Info)
{
DebugTrace.TxTrace(TraceLevel.Info, coordinator.EnlistmentId, "Replying Aborted to transaction manager");
}
coordinator.DeliverCallback(Status.Aborted);
}
public void Commit(CoordinatorEnlistment coordinator)
{
if (DebugTrace.Info)
{
DebugTrace.TxTrace(TraceLevel.Info, coordinator.EnlistmentId, "Sending Commit to transaction manager");
}
this.coordination.Commit(coordinator.Enlistment, this.commitResponseCallback, coordinator);
}
public void Committed(ParticipantEnlistment participant)
{
if (DebugTrace.Info)
{
DebugTrace.TxTrace(TraceLevel.Info, participant.EnlistmentId, "Replying Committed to transaction manager");
}
participant.DeliverCallback(Status.Committed);
}
public void EnlistPrePrepareResponse(CoordinatorEnlistment coordinator, Status status)
{
if (DebugTrace.Info)
{
DebugTrace.TxTrace(TraceLevel.Info, coordinator.EnlistmentId, "Replying {0} to transaction manager's EnlistPrePrepare", status);
}
coordinator.DeliverCallback(status);
}
public void Register(ParticipantEnlistment participant, MsgRegisterEvent e)
{
if (DebugTrace.Info)
{
DebugTrace.TxTrace(TraceLevel.Info, participant.EnlistmentId, "Sending Register for {0} to transaction manager", participant.Enlistment.NotificationMask);
}
this.propagation.CreateSubordinateEnlistment(participant.Enlistment, this.registerResponseCallback, e);
}
public void ReadOnly(ParticipantEnlistment participant)
{
if (DebugTrace.Info)
{
DebugTrace.TxTrace(TraceLevel.Info, participant.EnlistmentId, "Replying Readonly to transaction manager");
}
participant.DeliverCallback(Status.Readonly);
}
private void Execute()
{
if (DebugTrace.Verbose)
{
DebugTrace.TxTrace(TraceLevel.Verbose, this.stateMachine.Enlistment.EnlistmentId, "Now processing events on {0}", this.stateMachine.GetType().Name);
}
while (true)
{
SynchronizationEvent e = this.queue.Peek();
if (e == null)
{
DiagnosticUtility.FailFast("Peek returned null synchronization event");
}
try
{
if (DebugTrace.Verbose)
{
DebugTrace.TxTrace(TraceLevel.Verbose, this.stateMachine.Enlistment.EnlistmentId, "Dispatching {0} event to {1} in {2}", e.GetType().Name, this.stateMachine.GetType().Name, this.stateMachine.State.GetType().Name);
}
using (Activity.CreateActivity(this.stateMachine.Enlistment.EnlistmentId))
{
this.stateMachine.Dispatch(e);
}
if (DebugTrace.Verbose)
{
DebugTrace.TxTrace(TraceLevel.Verbose, this.stateMachine.Enlistment.EnlistmentId, "Dispatched {0} event to {1} in {2}", e.GetType().Name, this.stateMachine.GetType().Name, this.stateMachine.State.GetType().Name);
}
}
catch (Exception exception)
{
DebugTrace.TxTrace(TraceLevel.Error, this.stateMachine.Enlistment.EnlistmentId, "REALLY BAD ERROR: Unhandled exception caught by synchronization manager: {0}", exception);
UnhandledStateMachineExceptionRecord.TraceAndLog(this.stateMachine.Enlistment.EnlistmentId, (this.stateMachine.Enlistment.Enlistment != null) ? this.stateMachine.Enlistment.Enlistment.RemoteTransactionId : string.Empty, this.stateMachine.ToString(), this.stateMachine.State.ToString(), this.stateMachine.History, exception);
DiagnosticUtility.FailFast(string.Format(CultureInfo.InvariantCulture, "Failfasting due to unhandled exception: {0}\r\n\r\n{1}", new object[] { exception.Message, exception }));
}
lock (this.mutex)
{
this.queue.Dequeue();
if (this.queue.Count == 0)
{
break;
}
}
if (DebugTrace.Verbose)
{
DebugTrace.TxTrace(TraceLevel.Verbose, this.stateMachine.Enlistment.EnlistmentId, "Continuing to process events on {0}", this.stateMachine.GetType().Name);
}
}
if (DebugTrace.Verbose)
{
DebugTrace.TxTrace(TraceLevel.Verbose, this.stateMachine.Enlistment.EnlistmentId, "Stopped processing events on {0}", this.stateMachine.GetType().Name);
}
}
public void SendRollback(ParticipantEnlistment participant)
{
if (DebugTrace.Info)
{
DebugTrace.TxTrace(TraceLevel.Info, participant.EnlistmentId, "Sending Rollback to {0} participant at {1}", participant.ControlProtocol, Ports.TryGetAddress(participant.ParticipantProxy));
}
IAsyncResult ar = participant.ParticipantProxy.BeginSendRollback(this.sendComplete, participant);
if (ar.CompletedSynchronously)
{
this.OnSendComplete(ar, participant);
}
}
public void EnqueueRecoveryReplay(TmReplayEvent e)
{
if (!this.recovering)
{
Microsoft.Transactions.Bridge.DiagnosticUtility.FailFast("Cannot enqueue recovery event outside of recovery");
}
if (DebugTrace.Info)
{
CoordinatorEnlistment coordinator = e.Coordinator;
DebugTrace.TxTrace(TraceLevel.Info, coordinator.EnlistmentId, "Enqueuing recovery replay for coordinator at {0}", Ports.TryGetAddress(coordinator.CoordinatorProxy));
}
this.recoveryQueue.Enqueue(e);
}
public void SendCommitted(CompletionEnlistment completion)
{
if (DebugTrace.Info)
{
DebugTrace.TxTrace(TraceLevel.Info, completion.EnlistmentId, "Sending Committed to completion participant at {0}", Ports.TryGetAddress(completion.ParticipantProxy));
}
IAsyncResult ar = completion.ParticipantProxy.BeginSendCommitted(this.sendComplete, completion);
if (ar.CompletedSynchronously)
{
this.OnSendComplete(ar, completion, completion.ParticipantProxy);
}
}
public void SendVolatileReadOnly(VolatileCoordinatorEnlistment coordinator)
{
if (DebugTrace.Info)
{
DebugTrace.TxTrace(TraceLevel.Info, coordinator.EnlistmentId, "Sending ReadOnly to volatile coordinator at {0}", Ports.TryGetAddress(coordinator.CoordinatorProxy));
}
IAsyncResult ar = coordinator.CoordinatorProxy.BeginSendReadOnly(this.volatileSendComplete, coordinator);
if (ar.CompletedSynchronously)
{
this.OnVolatileSendComplete(ar, coordinator);
}
}
public void SendRegisterResponse(Microsoft.Transactions.Wsat.Protocol.TransactionEnlistment enlistment, Microsoft.Transactions.Wsat.Messaging.RequestAsyncResult result, ControlProtocol protocol, EndpointAddress coordinatorService)
{
RegisterResponse response = new RegisterResponse(this.state.ProtocolVersion)
{
CoordinatorProtocolService = coordinatorService
};
if (DebugTrace.Info)
{
DebugTrace.TxTrace(TraceLevel.Info, enlistment.EnlistmentId, "Sending RegisterResponse for {0}", protocol);
}
RegistrationProxy.SendRegisterResponse(result, ref response);
}
public void SendRecoverMessage(CoordinatorEnlistment coordinator)
{
if (DebugTrace.Info)
{
DebugTrace.TxTrace(TraceLevel.Info, coordinator.EnlistmentId, "Sending Replay to durable coordinator at {0}", Ports.TryGetAddress(coordinator.CoordinatorProxy));
}
IAsyncResult ar = coordinator.CoordinatorProxy.BeginSendRecoverMessage(this.durableSendComplete, coordinator);
if (ar.CompletedSynchronously)
{
this.OnDurableSendComplete(ar, coordinator);
}
}
public void CancelTimer()
{
lock (this.timerLock)
{
if (this.timer.Active)
{
if (DebugTrace.Verbose)
{
DebugTrace.TxTrace(TraceLevel.Verbose, this.enlistment.EnlistmentId, "Removing active timer");
}
this.state.TimerManager.Remove(this);
this.timer.Instance = null;
this.timer.Active = false;
}
}
}
public bool TryEnqueueRecoveryOutcome(ParticipantCallbackEvent e)
{
lock (this.recoveryLock)
{
if (!this.recovering)
{
return(false);
}
if (DebugTrace.Info)
{
ParticipantEnlistment participant = e.Participant;
DebugTrace.TxTrace(TraceLevel.Info, participant.EnlistmentId, "Queuing recovery outcome {0} for participant at {1}", e, Ports.TryGetAddress(participant.ParticipantProxy));
}
this.recoveryQueue.Enqueue(e);
}
return(true);
}
private void SendRegister(CoordinatorEnlistment coordinator, ControlProtocol protocol, EndpointAddress protocolService, AsyncCallback callback, object callbackState)
{
Register register = new Register(this.state.ProtocolVersion)
{
Protocol = protocol,
Loopback = this.state.ProcessId,
ParticipantProtocolService = protocolService,
SupportingToken = coordinator.SuperiorIssuedToken
};
if (DebugTrace.Info)
{
DebugTrace.TxTrace(TraceLevel.Info, coordinator.EnlistmentId, "Sending Register for {0} to {1}", protocol, Ports.TryGetAddress(coordinator.RegistrationProxy));
}
IAsyncResult ar = coordinator.RegistrationProxy.BeginSendRegister(ref register, callback, callbackState);
if (ar.CompletedSynchronously)
{
this.OnSendRegisterComplete(coordinator, protocol, ar);
}
}
public void ChangeState(Microsoft.Transactions.Wsat.StateMachines.State newState)
{
if (this.history != null)
{
this.history.AddState(newState.ToString());
}
if (this.current != null)
{
if (DebugTrace.Info)
{
DebugTrace.TxTrace(TraceLevel.Info, this.enlistment.EnlistmentId, "Leaving [{0}]", this.current);
}
this.current.Leave(this);
}
if (DebugTrace.Info)
{
DebugTrace.TxTrace(TraceLevel.Info, this.enlistment.EnlistmentId, "Entering [{0}]", newState);
}
this.current = newState;
this.current.Enter(this);
}
public void TraceInvalidEvent(SynchronizationEvent e, bool fatal)
{
if (DebugTrace.Error)
{
if (this.history != null)
{
DebugTrace.TxTrace(TraceLevel.Error, e.Enlistment.EnlistmentId, "The {0} was not expected by the {1} state. The state machine history history follows:\n\n{2}", e, this.current, this.history.ToString());
}
else
{
DebugTrace.TxTrace(TraceLevel.Error, e.Enlistment.EnlistmentId, "The {0} was not expected by the {1} state", e, this.current);
}
}
if (fatal)
{
FatalUnexpectedStateMachineEventRecord.TraceAndLog(this.enlistment.EnlistmentId, this.enlistment.Enlistment.RemoteTransactionId, this.ToString(), this.current.ToString(), this.history, e.ToString(), null);
}
else
{
NonFatalUnexpectedStateMachineEventRecord.TraceAndLog(this.enlistment.EnlistmentId, this.enlistment.Enlistment.RemoteTransactionId, this.ToString(), this.current.ToString(), this.history, e.ToString(), null);
}
}
private bool CheckMessage(Message message, bool fault, out CoordinatorEnlistment durableCoordinator, out VolatileCoordinatorEnlistment volatileCoordinator)
{
Guid guid;
TwoPhaseCommitCoordinatorProxy coordinatorProxy;
durableCoordinator = null;
volatileCoordinator = null;
if (!Ports.TryGetEnlistment(message, out guid))
{
DebugTrace.Trace(TraceLevel.Warning, "Could not read enlistment header from message");
if (fault)
{
this.SendFault(message, this.state.Faults.InvalidParameters);
}
return(false);
}
Microsoft.Transactions.Wsat.Protocol.TransactionEnlistment enlistment = this.state.Lookup.FindEnlistment(guid);
if (enlistment == null)
{
DebugTrace.Trace(TraceLevel.Warning, "Could not find enlistment {0}", guid);
return(true);
}
durableCoordinator = enlistment as CoordinatorEnlistment;
if (durableCoordinator == null)
{
volatileCoordinator = enlistment as VolatileCoordinatorEnlistment;
if (volatileCoordinator == null)
{
DebugTrace.Trace(TraceLevel.Warning, "2PC message received for non-2PC enlistment {0}", guid);
if (fault)
{
this.SendFault(message, this.state.Faults.InvalidParameters);
}
return(false);
}
coordinatorProxy = volatileCoordinator.CoordinatorProxy;
}
else
{
coordinatorProxy = durableCoordinator.CoordinatorProxy;
}
if (coordinatorProxy == null)
{
if ((durableCoordinator != null) && object.ReferenceEquals(durableCoordinator.StateMachine.State, this.state.States.CoordinatorFailedRecovery))
{
DebugTrace.TxTrace(TraceLevel.Warning, enlistment.EnlistmentId, "Coordinator enlistment was not correctly recovered");
if (fault)
{
this.SendFault(message, this.state.Faults.InvalidPolicy);
}
return(false);
}
if (DebugTrace.Warning)
{
DebugTrace.TxTrace(TraceLevel.Warning, enlistment.EnlistmentId, "Received premature message with action {0}", message.Headers.Action);
}
if (fault)
{
this.SendFault(message, this.state.Faults.InvalidState);
}
return(false);
}
if (this.state.Service.Security.CheckIdentity(coordinatorProxy, message))
{
return(true);
}
if (EnlistmentIdentityCheckFailedRecord.ShouldTrace)
{
EnlistmentIdentityCheckFailedRecord.Trace(enlistment.EnlistmentId);
}
return(false);
}
private void TraceTmResponse(SynchronizationEvent e, Status status)
{
DebugTrace.TxTrace(TraceLevel.Info, e.Enlistment.EnlistmentId, "{0} {1}", e, status);
}
public void OnEvent(MsgCreateTransactionEvent e)
{
DebugTrace.TxTrace(TraceLevel.Info, e.Enlistment.EnlistmentId, "{0}", e);
}
public void OnEvent(MsgEnlistTransactionEvent e)
{
DebugTrace.TxTrace(TraceLevel.Info, e.Enlistment.EnlistmentId, "{0}{1}", e, (e.Body.IssuedToken != null) ? " with issued token" : string.Empty);
}
private ParticipantEnlistment CheckMessage(Message message, bool fault, bool preparedOrReplay)
{
Guid guid;
ControlProtocol protocol;
if (!Ports.TryGetEnlistment(message, out guid, out protocol))
{
DebugTrace.Trace(TraceLevel.Warning, "Could not read enlistment header from message");
if (fault)
{
this.SendFault(message, this.state.Faults.InvalidParameters);
}
return(null);
}
Microsoft.Transactions.Wsat.Protocol.TransactionEnlistment enlistment = this.state.Lookup.FindEnlistment(guid);
if (enlistment == null)
{
DebugTrace.Trace(TraceLevel.Verbose, "Enlistment {0} could not be found", guid);
if (preparedOrReplay)
{
if (protocol == ControlProtocol.Volatile2PC)
{
if (DebugTrace.Warning)
{
DebugTrace.Trace(TraceLevel.Warning, "Received Prepared or Replay from unrecognized volatile participant at {0}", Ports.TryGetFromAddress(message));
}
if (VolatileParticipantInDoubtRecord.ShouldTrace)
{
VolatileParticipantInDoubtRecord.Trace(guid, Library.GetReplyToHeader(message.Headers), this.state.ProtocolVersion);
}
this.SendFault(message, this.state.Faults.UnknownTransaction);
}
else if (protocol == ControlProtocol.Durable2PC)
{
this.SendRollback(message);
}
else
{
this.SendFault(message, this.state.Faults.InvalidParameters);
}
}
else if (DebugTrace.Info)
{
DebugTrace.Trace(TraceLevel.Info, "Ignoring message from unrecognized participant at {0}", Ports.TryGetFromAddress(message));
}
return(null);
}
ParticipantEnlistment enlistment2 = enlistment as ParticipantEnlistment;
if ((enlistment2 == null) || (protocol != enlistment2.ControlProtocol))
{
DebugTrace.Trace(TraceLevel.Warning, "Enlistment state does not match message for {0}", guid);
if (fault)
{
this.SendFault(message, this.state.Faults.InvalidParameters);
}
return(null);
}
if (enlistment2.ParticipantProxy == null)
{
DebugTrace.TxTrace(TraceLevel.Warning, enlistment2.EnlistmentId, "Participant enlistment was not correctly recovered");
if (fault)
{
this.SendFault(message, this.state.Faults.InvalidPolicy);
}
return(null);
}
if (this.state.Service.Security.CheckIdentity(enlistment2.ParticipantProxy, message))
{
return(enlistment2);
}
if (EnlistmentIdentityCheckFailedRecord.ShouldTrace)
{
EnlistmentIdentityCheckFailedRecord.Trace(enlistment2.EnlistmentId);
}
return(null);
}
