public IAsyncResult BeginCreateCoordinationContext(Message message, AsyncCallback callback, object state)
{
if (DebugTrace.Verbose)
{
DebugTrace.Trace(TraceLevel.Verbose, "Dispatching CreateCoordinationContext request");
if (DebugTrace.Pii)
{
DebugTrace.TracePii(TraceLevel.Verbose, "Sender is {0}", CoordinationServiceSecurity.GetSenderName(message));
}
}
Microsoft.Transactions.Wsat.Messaging.RequestAsyncResult result = new Microsoft.Transactions.Wsat.Messaging.RequestAsyncResult(message, callback, state);
try
{
this.dispatch.CreateCoordinationContext(message, result);
}
catch (InvalidMessageException exception)
{
Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Warning);
base.OnMessageException(result, message, exception, Faults.Version(this.service.ProtocolVersion).InvalidParameters);
}
catch (CommunicationException exception2)
{
Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception2, TraceEventType.Warning);
base.OnMessageException(result, message, exception2, Faults.Version(this.service.ProtocolVersion).CreateContextDispatchFailed);
}
catch (Exception exception3)
{
DebugTrace.Trace(TraceLevel.Error, "Unhandled exception {0} dispatching CreateCoordinationContext message: {1}", exception3.GetType().Name, exception3);
Microsoft.Transactions.Bridge.DiagnosticUtility.InvokeFinalHandler(exception3);
}
return(result);
}
protected void OnReceive(Message message)
{
DebugTrace.TraceEnter(this, "OnReceive");
if ((message != null) && !this.tokenResolver.FaultInSupportingToken(message))
{
if (DebugTrace.Verbose)
{
DebugTrace.Trace(TraceLevel.Verbose, "Failed to fault in SCT for supporting token signature");
}
Fault invalidParameters = Faults.Version(this.protocolVersion).InvalidParameters;
if (message.Headers.MessageId != null)
{
if (DebugTrace.Verbose)
{
DebugTrace.Trace(TraceLevel.Verbose, "Attempting to send {0} fault", invalidParameters.Code.Name);
}
Message reply = Library.CreateFaultMessage(message.Headers.MessageId, message.Version, invalidParameters);
RequestReplyCorrelator.AddressReply(reply, new RequestReplyCorrelator.ReplyToInfo(message));
SendSecurityHeader header = SupportingTokenChannel <TChannel> .SecurityStandardsManager.CreateSendSecurityHeader(reply, string.Empty, true, false, SecurityAlgorithmSuite.Default, MessageDirection.Output);
header.RequireMessageProtection = false;
header.AddTimestamp(SecurityProtocolFactory.defaultTimestampValidityDuration);
reply = header.SetupExecution();
this.TrySendFaultReply(reply);
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(Microsoft.Transactions.SR.GetString("SupportingTokenSignatureExpected")));
}
DebugTrace.TraceLeave(this, "OnReceive");
}
protected void OnMessageException(Message message, CommunicationException exception)
{
DebugTrace.Trace(TraceLevel.Warning, "{0} - {1} reading datagram with action {2}: {3}", base.GetType().Name, exception.GetType().Name, message.Headers.Action, exception.Message);
EndpointAddress faultToHeader = Library.GetFaultToHeader(message.Headers, this.protocolVersion);
if (faultToHeader == null)
{
DebugTrace.Trace(TraceLevel.Warning, "Ignoring invalid datagram - a fault-to header could not be obtained");
}
else
{
DatagramProxy proxy = null;
try
{
proxy = this.CreateFaultProxy(faultToHeader);
}
catch (CreateChannelFailureException exception2)
{
Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception2, TraceEventType.Warning);
DebugTrace.Trace(TraceLevel.Warning, "Ignoring invalid datagram: {0}", exception2.Message);
}
if (proxy != null)
{
try
{
IAsyncResult ar = proxy.BeginSendFault(message.Headers.MessageId, Faults.Version(this.protocolVersion).InvalidParameters, null, null);
proxy.EndSendMessage(ar);
if (DebugTrace.Warning)
{
DebugTrace.Trace(TraceLevel.Warning, "Sent InvalidParameters fault to {0}", proxy.To.Uri);
}
}
catch (WsatSendFailureException exception3)
{
Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception3, TraceEventType.Warning);
if (DebugTrace.Warning)
{
DebugTrace.Trace(TraceLevel.Warning, "{0} sending InvalidParameters fault to {1}: {2}", exception3.GetType().Name, proxy.To.Uri, exception3.Message);
}
}
finally
{
proxy.Release();
}
}
}
}
