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;
}
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 Committed(ParticipantEnlistment participant)
{
if (DebugTrace.Info)
{
DebugTrace.TxTrace(TraceLevel.Info, participant.EnlistmentId, "Replying Committed to transaction manager");
}
participant.DeliverCallback(Status.Committed);
}
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);
}
public TimerParticipantEvent(ParticipantEnlistment participant, TimerProfile profile) : base(participant)
{
this.profile = profile;
}
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);
}
}
private void OnSendComplete(IAsyncResult ar, ParticipantEnlistment participant)
{
Exception exception = null;
try
{
participant.ParticipantProxy.EndSendMessage(ar);
}
catch (WsatSendFailureException exception2)
{
Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception2, TraceEventType.Warning);
DebugTrace.TraceSendFailure(participant.EnlistmentId, exception2);
this.state.Perf.MessageSendFailureCountPerInterval.Increment();
exception = exception2;
}
if (exception != null)
{
participant.StateMachine.Enqueue(new MsgParticipantSendFailureEvent(participant));
}
}
protected ParticipantCallbackEvent(ParticipantEnlistment participant, ProtocolProviderCallback callback, object state) : base(participant)
{
this.callback = callback;
this.callbackState = state;
}
public DurableStateMachine(ParticipantEnlistment participant) : base(participant)
{
}
protected ParticipantFaultEvent(ParticipantEnlistment participant, MessageFault fault) : base(participant)
{
this.fault = fault;
}
public ParticipantStateMachine(ParticipantEnlistment participant) : base(participant)
{
this.participant = participant;
}
public void ReadOnly(ParticipantEnlistment participant)
{
if (DebugTrace.Info)
{
DebugTrace.TxTrace(TraceLevel.Info, participant.EnlistmentId, "Replying Readonly to transaction manager");
}
participant.DeliverCallback(Status.Readonly);
}
public MsgPreparedEvent(ParticipantEnlistment participant) : base(participant)
{
}
protected ParticipantStatusEvent(ParticipantEnlistment participant, Microsoft.Transactions.Bridge.Status status) : base(participant)
{
this.status = status;
}
public InternalEnlistSubordinateTransactionEvent(ParticipantEnlistment participant, MsgEnlistTransactionEvent source) : base(participant)
{
this.source = source;
}
protected ParticipantEvent(ParticipantEnlistment participant) : base(participant)
{
this.participant = participant;
}
public MsgReadOnlyEvent(ParticipantEnlistment participant) : base(participant)
{
}
public TmRegisterResponseEvent(ParticipantEnlistment participant, Status status, MsgRegisterEvent source) : base(participant, status)
{
this.source = source;
}
private void InvalidParticipantFaultEvent(SynchronizationEvent e, ParticipantEnlistment participant)
{
this.TraceInvalidEvent(e, false);
this.TryToAbortTransaction(e, participant);
}
public TmCommitEvent(ParticipantEnlistment participant, ProtocolProviderCallback callback, object state) : base(participant, callback, state)
{
}
public MsgRegisterEvent(ParticipantEnlistment participant, ref Register register, RequestAsyncResult result) : base(participant)
{
this.register = register;
this.result = result;
}
public MsgParticipantSendFailureEvent(ParticipantEnlistment participant) : base(participant)
{
}
public MsgAbortedEvent(ParticipantEnlistment participant) : base(participant)
{
}
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 Register(Message message, Microsoft.Transactions.Wsat.Messaging.RequestAsyncResult result)
{
Microsoft.Transactions.Wsat.Messaging.Register register = new Microsoft.Transactions.Wsat.Messaging.Register(message, this.state.ProtocolVersion);
EndpointAddress participantProtocolService = register.ParticipantProtocolService;
WsatRegistrationHeader header = WsatRegistrationHeader.ReadFrom(message);
if (header == null)
{
if (DebugTrace.Warning)
{
DebugTrace.Trace(TraceLevel.Warning, "Rejecting Register message with no registration header");
}
this.SendFault(result, this.state.Faults.InvalidParameters);
return;
}
switch (register.Protocol)
{
case ControlProtocol.Completion:
{
CompletionEnlistment completion = this.state.Lookup.FindEnlistment(header.TransactionId) as CompletionEnlistment;
if (completion != null)
{
CompletionParticipantProxy proxy = this.state.TryCreateCompletionParticipantProxy(participantProtocolService);
if (proxy == null)
{
if (DebugTrace.Warning)
{
DebugTrace.Trace(TraceLevel.Warning, "Rejecting Register message for completion on no completion enlistment");
}
this.SendFault(result, this.state.Faults.InvalidParameters);
return;
}
try
{
completion.StateMachine.Enqueue(new MsgRegisterCompletionEvent(completion, ref register, result, proxy));
return;
}
finally
{
proxy.Release();
}
break;
}
if (DebugTrace.Warning)
{
DebugTrace.Trace(TraceLevel.Warning, "Rejecting uncorrelated Register message for completion");
}
this.SendFault(result, this.state.Faults.UnknownCompletionEnlistment);
return;
}
case ControlProtocol.Volatile2PC:
case ControlProtocol.Durable2PC:
break;
default:
goto Label_0222;
}
if (!this.state.TransactionManager.Settings.NetworkOutboundAccess)
{
if (DebugTrace.Warning)
{
DebugTrace.Trace(TraceLevel.Warning, "Rejecting Register message because outbound transactions are disabled");
}
this.SendFault(result, this.state.Faults.ParticipantRegistrationNetAccessDisabled);
return;
}
if (register.Loopback == this.state.ProcessId)
{
if (DebugTrace.Warning)
{
DebugTrace.Trace(TraceLevel.Warning, "Rejecting recursive Register message from self");
}
this.SendFault(result, this.state.Faults.ParticipantRegistrationLoopback);
return;
}
TwoPhaseCommitParticipantProxy proxy2 = this.state.TryCreateTwoPhaseCommitParticipantProxy(participantProtocolService);
if (proxy2 == null)
{
if (DebugTrace.Warning)
{
DebugTrace.Trace(TraceLevel.Warning, "Rejecting Register message because 2PC proxy could not be created");
}
this.SendFault(result, this.state.Faults.InvalidParameters);
return;
}
try
{
ParticipantEnlistment participant = new ParticipantEnlistment(this.state, header, register.Protocol, proxy2);
this.state.TransactionManagerSend.Register(participant, new MsgRegisterEvent(participant, ref register, result));
return;
}
finally
{
proxy2.Release();
}
Label_0222:
Microsoft.Transactions.Bridge.DiagnosticUtility.FailFast("Registration protocol should have been validated");
}
public VolatileStateMachine(ParticipantEnlistment participant) : base(participant)
{
}
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 MsgCommittedEvent(ParticipantEnlistment participant) : base(participant)
{
}
public TmSubordinateRegisterResponseEvent(ParticipantEnlistment participant, Status status, InternalEnlistSubordinateTransactionEvent source) : base(participant, status)
{
this.source = source;
}
