public static void RegisterResponse(Enlistment enlistment, Status status, object obj)
{
MsgRegisterEvent source = (MsgRegisterEvent)obj;
ParticipantEnlistment protocolProviderContext = (ParticipantEnlistment)enlistment.ProtocolProviderContext;
protocolProviderContext.StateMachine.Enqueue(new TmRegisterResponseEvent(protocolProviderContext, status, source));
}
public void Rejoin(Enlistment enlistment, ProtocolProviderCallback callback, object obj)
{
DebugTrace.TraceEnter(this, "Rejoin");
ParticipantEnlistment participant = null;
try
{
participant = this.state.LogEntrySerialization.DeserializeParticipant(enlistment);
}
catch (SerializationException exception)
{
DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Critical);
if (DebugTrace.Error)
{
DebugTrace.Trace(TraceLevel.Error, "Failed to deserialize log entry for participant: {0}", exception);
}
ParticipantRecoveryLogEntryCorruptRecord.TraceAndLog(enlistment.LocalTransactionId, enlistment.RemoteTransactionId, enlistment.GetRecoveryData(), exception);
DiagnosticUtility.FailFast("A participant recovery log entry could not be deserialized. This is a fatal condition.");
}
if (ParticipantRecoveredRecord.ShouldTrace)
{
ParticipantRecoveredRecord.Trace(participant.EnlistmentId, participant.Enlistment.RemoteTransactionId, (participant.ParticipantProxy != null) ? participant.ParticipantProxy.To : null, this.state.ProtocolVersion);
}
participant.StateMachine.Enqueue(new TmRejoinEvent(participant, callback, obj));
DebugTrace.TraceLeave(this, "Rejoin");
}
public override void OnEvent(TmRollbackEvent e)
{
ParticipantEnlistment participant = e.Participant;
participant.SetCallback(e.Callback, e.CallbackState);
base.state.TransactionManagerSend.Aborted(participant);
}
public byte[] Serialize(ParticipantEnlistment participant)
{
Enlistment enlistment = participant.Enlistment;
LogEntry logEntry = new LogEntry(enlistment.RemoteTransactionId, enlistment.LocalTransactionId, participant.EnlistmentId, participant.ParticipantProxy.To);
return(this.SerializeLogEntry(logEntry));
}
public override void OnEvent(InternalEnlistSubordinateTransactionEvent e)
{
ParticipantEnlistment participant = e.Participant;
base.state.TransactionManagerSend.Register(participant, e);
participant.StateMachine.ChangeState(base.state.States.SubordinateRegistering);
}
public override void OnEvent(MsgPreparedEvent e)
{
ParticipantEnlistment participant = e.Participant;
Exception exception = null;
try
{
byte[] data = base.state.LogEntrySerialization.Serialize(participant);
participant.Enlistment.SetRecoveryData(data);
base.state.TransactionManagerSend.Prepared(participant);
e.StateMachine.ChangeState(base.state.States.DurablePrepared);
}
catch (SerializationException exception2)
{
DiagnosticUtility.ExceptionUtility.TraceHandledException(exception2, TraceEventType.Error);
exception = exception2;
}
if (exception != null)
{
if (DebugTrace.Error)
{
DebugTrace.Trace(TraceLevel.Verbose, "Failed to serialize log entry for participant: {0}", exception);
}
ParticipantRecoveryLogEntryCreationFailureRecord.TraceAndLog(participant.EnlistmentId, participant.Enlistment.RemoteTransactionId, exception.Message, exception);
base.state.TwoPhaseCommitCoordinator.SendRollback(participant);
base.state.TransactionManagerSend.Aborted(participant);
e.StateMachine.ChangeState(base.state.States.DurableAborted);
}
}
public override void OnEvent(TmParticipantForgetEvent e)
{
ParticipantEnlistment participant = e.Participant;
participant.SetCallback(e.Callback, e.CallbackState);
base.state.TransactionManagerSend.ForgetResponse(participant, Status.Success);
}
public static void SubordinateRegisterResponse(Enlistment enlistment, Status status, object obj)
{
InternalEnlistSubordinateTransactionEvent source = (InternalEnlistSubordinateTransactionEvent)obj;
ParticipantEnlistment protocolProviderContext = (ParticipantEnlistment)enlistment.ProtocolProviderContext;
protocolProviderContext.StateMachine.Enqueue(new TmSubordinateRegisterResponseEvent(protocolProviderContext, status, source));
}
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 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 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);
}
public override void Enter(StateMachine stateMachine)
{
ParticipantEnlistment participant = (ParticipantEnlistment)stateMachine.Enlistment;
participant.CreateCoordinatorService();
base.state.TwoPhaseCommitCoordinator.SendCommit(participant);
stateMachine.ChangeState(base.state.States.DurableCommitting);
}
public override void OnEvent(TmPrepareEvent e)
{
ParticipantEnlistment participant = e.Participant;
participant.SetCallback(e.Callback, e.CallbackState);
base.state.TransactionManagerSend.ReadOnly(participant);
e.StateMachine.ChangeState(base.state.States.DurableInDoubt);
}
public TwoPhaseCommitParticipantEvent(ParticipantEnlistment participant) : base(participant)
{
MessageHeaders incomingMessageHeaders = OperationContext.Current.IncomingMessageHeaders;
this.faultTo = Library.GetFaultToHeader(incomingMessageHeaders, base.state.ProtocolVersion);
this.replyTo = Library.GetReplyToHeader(incomingMessageHeaders);
this.messageID = incomingMessageHeaders.MessageId;
}
public override void OnEvent(TmPrePrepareEvent e)
{
ParticipantEnlistment participant = e.Participant;
participant.SetCallback(e.Callback, e.CallbackState);
base.state.TwoPhaseCommitCoordinator.SendPrepare(participant);
e.StateMachine.ChangeState(base.state.States.VolatilePrePreparing);
}
public override void OnEvent(TmCommitEvent e)
{
ParticipantEnlistment participant = e.Participant;
base.state.TwoPhaseCommitCoordinator.SendCommit(participant);
participant.SetCallback(e.Callback, e.CallbackState);
e.StateMachine.ChangeState(base.state.States.DurableCommitting);
}
public override void OnEvent(TmPrepareEvent e)
{
ParticipantEnlistment participant = e.Participant;
participant.SetCallback(e.Callback, e.CallbackState);
base.state.TransactionManagerSend.Prepared(participant);
e.StateMachine.ChangeState(base.state.States.VolatilePrepared);
}
public override void OnEvent(TmRollbackEvent e)
{
ParticipantEnlistment participant = e.Participant;
participant.SetCallback(e.Callback, e.CallbackState);
base.state.TransactionManagerSend.Aborted(participant);
participant.StateMachine.ChangeState(base.state.States.SubordinateFinished);
}
public override void OnEvent(TmParticipantForgetEvent e)
{
ParticipantEnlistment participant = e.Participant;
participant.SetCallback(e.Callback, e.CallbackState);
base.state.TransactionManagerSend.ForgetResponse(participant, Status.Success);
e.StateMachine.ChangeState(base.state.States.DurableInDoubt);
}
public override void OnEvent(TmRollbackEvent e)
{
ParticipantEnlistment participant = e.Participant;
base.state.TwoPhaseCommitCoordinator.SendRollback(participant);
participant.SetCallback(e.Callback, e.CallbackState);
base.state.TransactionManagerSend.Aborted(participant);
e.StateMachine.ChangeState(base.state.States.VolatileAborting);
}
public override void Enter(StateMachine stateMachine)
{
ParticipantEnlistment participant = (ParticipantEnlistment)stateMachine.Enlistment;
participant.CreateCoordinatorService();
base.state.TwoPhaseCommitCoordinator.SendRollback(participant);
base.state.TransactionManagerSend.Aborted(participant);
stateMachine.ChangeState(base.state.States.DurableAborted);
}
public override void OnEvent(MsgReplayEvent e)
{
ProtocolVersionHelper.AssertProtocolVersion10(base.state.ProtocolVersion, typeof(DurableActive), "OnEvent(replay)");
ParticipantEnlistment participant = e.Participant;
base.state.TwoPhaseCommitCoordinator.SendRollback(participant);
base.state.TransactionManagerSend.Rollback(participant);
e.StateMachine.ChangeState(base.state.States.DurableAborted);
}
public void Aborted(Message message)
{
ParticipantEnlistment participant = this.CheckMessage(message, true, false);
if (participant != null)
{
participant.StateMachine.Enqueue(new MsgAbortedEvent(participant));
}
}
protected void ForwardEnlistmentEventToSubordinate(MsgEnlistTransactionEvent e)
{
CoordinatorEnlistment coordinator = e.Coordinator;
TransactionContextManager contextManager = coordinator.ContextManager;
coordinator.ContextManager = null;
ParticipantEnlistment participant = new ParticipantEnlistment(this.state, coordinator.Enlistment, contextManager);
participant.StateMachine.Enqueue(new InternalEnlistSubordinateTransactionEvent(participant, e));
}
public void Fault(Message message, MessageFault fault)
{
ParticipantEnlistment participant = this.CheckMessage(message, false, false);
if (participant != null)
{
this.state.Perf.FaultsReceivedCountPerInterval.Increment();
participant.StateMachine.Enqueue(new MsgParticipantFaultEvent(participant, fault));
}
}
public void Replay(Message message)
{
ProtocolVersionHelper.AssertProtocolVersion10(this.state.ProtocolVersion, base.GetType(), "Replay");
ParticipantEnlistment participant = this.CheckMessage(message, true, true);
if (participant != null)
{
participant.StateMachine.Enqueue(new MsgReplayEvent(participant));
}
}
public override void Leave(StateMachine stateMachine)
{
base.Leave(stateMachine);
ParticipantEnlistment enlistment = (ParticipantEnlistment)stateMachine.Enlistment;
long num = Microsoft.Transactions.Wsat.StateMachines.State.QueryStopTime() - enlistment.LastMessageTime;
base.state.Perf.AverageParticipantPrepareResponseTimeBase.Increment();
base.state.Perf.AverageParticipantPrepareResponseTime.IncrementBy(num);
enlistment.Retries = 0;
stateMachine.CancelTimer();
}
public override void OnEvent(TimerParticipantEvent e)
{
ParticipantEnlistment participant = e.Participant;
participant.Retries++;
if (PrepareMessageRetryRecord.ShouldTrace)
{
PrepareMessageRetryRecord.Trace(participant.EnlistmentId, participant.Enlistment.RemoteTransactionId, participant.Retries);
}
base.state.Perf.PrepareRetryCountPerInterval.Increment();
base.state.TwoPhaseCommitCoordinator.SendPrepare(participant);
}
public override void OnEvent(TmRejoinEvent e)
{
if (!base.state.Recovering)
{
DiagnosticUtility.FailFast("Rejoin events should only be delivered during recovery");
}
ParticipantEnlistment participant = e.Participant;
participant.SetCallback(e.Callback, e.CallbackState);
base.state.TransactionManagerSend.Rejoined(participant);
e.StateMachine.ChangeState(base.state.States.DurableRejoined);
}
