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);
}
private void OnSendFaultComplete(IAsyncResult ar, DatagramProxy proxy)
{
try
{
proxy.EndSendMessage(ar);
}
catch (WsatSendFailureException exception)
{
Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Warning);
DebugTrace.TraceSendFailure(exception);
this.state.Perf.MessageSendFailureCountPerInterval.Increment();
}
}
private void OnSendComplete(IAsyncResult ar, CompletionEnlistment completion, CompletionParticipantProxy proxy)
{
try
{
proxy.EndSendMessage(ar);
}
catch (WsatSendFailureException exception)
{
Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Warning);
this.state.Perf.MessageSendFailureCountPerInterval.Increment();
if (completion != null)
{
DebugTrace.TraceSendFailure(completion.EnlistmentId, exception);
}
else
{
DebugTrace.TraceSendFailure(exception);
}
}
}
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));
}
}
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));
}
}
