private void OnSendRegisterComplete(CoordinatorEnlistment coordinator, ControlProtocol protocol, IAsyncResult ar)
{
SynchronizationEvent event2;
EndpointAddress to = null;
try
{
RegisterResponse response = coordinator.RegistrationProxy.EndSendRegister(ar);
to = response.CoordinatorProtocolService;
TwoPhaseCommitCoordinatorProxy proxy = this.state.TryCreateTwoPhaseCommitCoordinatorProxy(to);
if (proxy == null)
{
if (RegistrationCoordinatorResponseInvalidMetadataRecord.ShouldTrace)
{
RegistrationCoordinatorResponseInvalidMetadataRecord.Trace(coordinator.EnlistmentId, coordinator.SuperiorContext, protocol, to, null, this.state.ProtocolVersion);
}
event2 = new MsgRegistrationCoordinatorSendFailureEvent(coordinator);
}
else
{
try
{
if (protocol == ControlProtocol.Durable2PC)
{
event2 = new MsgRegisterDurableResponseEvent(coordinator, response, proxy);
}
else
{
VolatileCoordinatorEnlistment asyncState = (VolatileCoordinatorEnlistment)ar.AsyncState;
event2 = new MsgRegisterVolatileResponseEvent(asyncState, response, proxy);
}
}
finally
{
proxy.Release();
}
}
}
catch (WsatFaultException exception)
{
Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Warning);
event2 = new MsgRegistrationCoordinatorFaultEvent(coordinator, protocol, exception.Fault);
if (RegistrationCoordinatorFaultedRecord.ShouldTrace)
{
RegistrationCoordinatorFaultedRecord.Trace(coordinator.EnlistmentId, coordinator.SuperiorContext, protocol, exception.Fault);
}
}
catch (WsatMessagingException exception2)
{
Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception2, TraceEventType.Warning);
this.state.Perf.MessageSendFailureCountPerInterval.Increment();
if (RegistrationCoordinatorFailedRecord.ShouldTrace)
{
RegistrationCoordinatorFailedRecord.Trace(coordinator.EnlistmentId, coordinator.SuperiorContext, protocol, exception2);
}
DebugTrace.TraceSendFailure(coordinator.EnlistmentId, exception2);
event2 = new MsgRegistrationCoordinatorSendFailureEvent(coordinator);
}
coordinator.StateMachine.Enqueue(event2);
}
protected void TrySendAborted(VolatileCoordinatorEnlistment coordinator)
{
if (coordinator.CoordinatorProxy != null)
{
this.state.TwoPhaseCommitParticipant.SendVolatileAborted(coordinator);
}
}
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 VolatileTwoPhaseCommitCoordinatorEvent(VolatileCoordinatorEnlistment coordinator) : base(coordinator)
{
MessageHeaders incomingMessageHeaders = OperationContext.Current.IncomingMessageHeaders;
this.faultTo = Library.GetFaultToHeader(incomingMessageHeaders, base.state.ProtocolVersion);
this.replyTo = Library.GetReplyToHeader(incomingMessageHeaders);
this.messageID = incomingMessageHeaders.MessageId;
}
private void OnSendVolatileRegisterComplete(IAsyncResult ar)
{
if (!ar.CompletedSynchronously)
{
VolatileCoordinatorEnlistment asyncState = (VolatileCoordinatorEnlistment)ar.AsyncState;
this.OnSendRegisterComplete(asyncState.Coordinator, ControlProtocol.Volatile2PC, ar);
}
}
public override void OnEvent(MsgVolatilePrepareEvent e)
{
VolatileCoordinatorEnlistment volatileCoordinator = e.VolatileCoordinator;
CoordinatorEnlistment coordinator = volatileCoordinator.Coordinator;
if (object.ReferenceEquals(volatileCoordinator, coordinator.RegisterVolatileCoordinator))
{
base.OnEvent(e);
}
}
public override void OnEvent(MsgVolatilePrepareEvent e)
{
VolatileCoordinatorEnlistment volatileCoordinator = e.VolatileCoordinator;
CoordinatorEnlistment coordinator = volatileCoordinator.Coordinator;
if (object.ReferenceEquals(volatileCoordinator, coordinator.LastCompletedVolatileCoordinator))
{
base.state.TwoPhaseCommitParticipant.SendVolatileReadOnly(volatileCoordinator);
}
}
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 override void OnEvent(MsgVolatileRollbackEvent e)
{
VolatileCoordinatorEnlistment volatileCoordinator = e.VolatileCoordinator;
CoordinatorEnlistment coordinator = volatileCoordinator.Coordinator;
if (object.ReferenceEquals(volatileCoordinator, coordinator.RegisterVolatileCoordinator) || object.ReferenceEquals(volatileCoordinator, coordinator.PreparingVolatileCoordinator))
{
base.state.TransactionManagerSend.Rollback(volatileCoordinator);
e.StateMachine.ChangeState(base.state.States.CoordinatorAborted);
}
else
{
base.OnEvent(e);
}
}
public override void OnEvent(MsgVolatileRollbackEvent e)
{
VolatileCoordinatorEnlistment volatileCoordinator = e.VolatileCoordinator;
CoordinatorEnlistment coordinator = volatileCoordinator.Coordinator;
if (object.ReferenceEquals(volatileCoordinator, coordinator.LastCompletedVolatileCoordinator))
{
base.state.TwoPhaseCommitParticipant.SendVolatileAborted(volatileCoordinator);
base.state.TransactionManagerSend.Rollback(volatileCoordinator);
e.StateMachine.ChangeState(base.state.States.CoordinatorAborted);
}
else
{
base.OnEvent(e);
}
}
public override void OnEvent(MsgVolatilePrepareEvent e)
{
VolatileCoordinatorEnlistment volatileCoordinator = e.VolatileCoordinator;
CoordinatorEnlistment coordinator = volatileCoordinator.Coordinator;
if (object.ReferenceEquals(volatileCoordinator, coordinator.LastCompletedVolatileCoordinator))
{
base.state.TwoPhaseCommitParticipant.SendVolatileReadOnly(volatileCoordinator);
}
else if (object.ReferenceEquals(volatileCoordinator, coordinator.RegisterVolatileCoordinator))
{
coordinator.PreparingVolatileCoordinator = volatileCoordinator;
coordinator.RegisterVolatileCoordinator = null;
base.state.TransactionManagerSend.PrePrepare(volatileCoordinator);
e.StateMachine.ChangeState(base.state.States.CoordinatorVolatilePreparing);
}
}
private void OnVolatileSendComplete(IAsyncResult ar, VolatileCoordinatorEnlistment volatileCoordinator)
{
Exception exception = null;
try
{
volatileCoordinator.CoordinatorProxy.EndSendMessage(ar);
}
catch (WsatSendFailureException exception2)
{
Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception2, TraceEventType.Warning);
DebugTrace.TraceSendFailure(volatileCoordinator.EnlistmentId, exception2);
this.state.Perf.MessageSendFailureCountPerInterval.Increment();
exception = exception2;
}
if (exception != null)
{
volatileCoordinator.StateMachine.Enqueue(new MsgVolatileCoordinatorSendFailureEvent(volatileCoordinator));
}
}
public static void PrePrepareResponse(Enlistment enlistment, Status status, object obj)
{
VolatileCoordinatorEnlistment coordinator = (VolatileCoordinatorEnlistment)obj;
coordinator.StateMachine.Enqueue(new TmPrePrepareResponseEvent(coordinator, status));
}
protected VolatileCoordinatorStatusEvent(VolatileCoordinatorEnlistment coordinator, Microsoft.Transactions.Bridge.Status status) : base(coordinator)
{
this.status = status;
}
protected VolatileCoordinatorEvent(VolatileCoordinatorEnlistment coordinator) : base(coordinator)
{
this.coordinator = coordinator;
}
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);
}
protected VolatileCoordinatorFaultEvent(VolatileCoordinatorEnlistment coordinator, MessageFault fault) : base(coordinator)
{
this.fault = fault;
}
public MsgVolatileCoordinatorFaultEvent(VolatileCoordinatorEnlistment coordinator, MessageFault fault) : base(coordinator, fault)
{
}
public MsgRegisterVolatileResponseEvent(VolatileCoordinatorEnlistment volatileCoordinator, RegisterResponse response, TwoPhaseCommitCoordinatorProxy proxy) : base(volatileCoordinator, response, proxy)
{
this.volatileCoordinator = volatileCoordinator;
}
public MsgVolatilePrepareEvent(VolatileCoordinatorEnlistment coordinator) : base(coordinator)
{
}
public MsgVolatileCoordinatorSendFailureEvent(VolatileCoordinatorEnlistment coordinator) : base(coordinator)
{
}
public TmPrePrepareResponseEvent(VolatileCoordinatorEnlistment coordinator, Status status) : base(coordinator, status)
{
}
public MsgVolatileCommitEvent(VolatileCoordinatorEnlistment coordinator) : base(coordinator)
{
}
public void SendVolatileRegister(VolatileCoordinatorEnlistment volatileCoordinator)
{
this.SendRegister(volatileCoordinator.Coordinator, ControlProtocol.Volatile2PC, volatileCoordinator.ParticipantService, this.sendVolatileRegisterComplete, volatileCoordinator);
}
public MsgVolatileRollbackEvent(VolatileCoordinatorEnlistment coordinator) : base(coordinator)
{
}
