public Message EndReceive(IAsyncResult result)
{
Message message = innerDuplexSessionChannel.EndReceive(result);
ReadAndAddContextIdToMessage(message);
return(message);
}
private void OnReceive(IAsyncResult result)
{
IDuplexSessionChannel asyncState = (IDuplexSessionChannel)result.AsyncState;
bool flag = false;
try
{
Message message = asyncState.EndReceive(result);
if (message == null)
{
asyncState.Close(this.channelPool.IdleTimeout);
flag = true;
}
else
{
message.Close();
}
}
catch (CommunicationException exception)
{
if (DiagnosticUtility.ShouldTraceInformation)
{
DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Information);
}
}
catch (TimeoutException exception2)
{
if (DiagnosticUtility.ShouldTraceInformation)
{
DiagnosticUtility.ExceptionUtility.TraceHandledException(exception2, TraceEventType.Information);
}
}
finally
{
if (!flag)
{
asyncState.Abort();
}
}
}
void OnReceive(IAsyncResult result)
{
IDuplexSessionChannel channel = (IDuplexSessionChannel)result.AsyncState;
bool success = false;
try
{
Message message = channel.EndReceive(result);
if (message == null)
{
channel.Close(this.channelPool.IdleTimeout);
success = true;
}
else
{
message.Close();
}
}
catch (CommunicationException e)
{
DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
}
catch (TimeoutException e)
{
if (TD.CloseTimeoutIsEnabled())
{
TD.CloseTimeout(e.Message);
}
DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
}
finally
{
if (!success)
{
channel.Abort();
}
}
}
/// <summary>
/// AsyncCallback for ReceiveRequest
/// </summary>
/// <param name="ar">async result</param>
private void ReceiveRequest(IAsyncResult ar)
{
ChannelClientState state = (ChannelClientState)ar.AsyncState;
IDuplexSessionChannel channel = (IDuplexSessionChannel)state.Channel;
BrokerClient client = state.Client;
Message requestMessage;
try
{
requestMessage = channel.EndReceive(ar);
}
catch (Exception ce)
{
BrokerTracing.TraceEvent(TraceEventType.Warning, 0, "[DuplexFrontEnd] Exception while receiving requests: {0}", ce);
this.FrontendDisconnect(channel, client);
lock (channel)
{
if (channel.State == CommunicationState.Faulted)
{
BrokerTracing.TraceEvent(TraceEventType.Warning, 0, "[DuplexFrontEnd] Abort faulted channel.");
channel.Abort();
return;
}
}
// Retry receiving requests
if (!ar.CompletedSynchronously)
{
this.TryToBeginReceiveMessagesWithThrottling(state);
}
return;
}
#region Debug Failure Test
SimulateFailure.FailOperation(1);
#endregion
// After channel timeout, the request will be null if you call channel.Receive()
// Need to end the channel at this time
if (requestMessage == null)
{
// Indicate that the channel should be closed
// Close the channel
lock (channel)
{
if (channel.State == CommunicationState.Opened)
{
this.FrontendDisconnect(channel, client);
try
{
channel.Close();
BrokerTracing.TraceEvent(TraceEventType.Information, 0, "[DuplexFrontEnd] Channel closed");
}
catch (Exception ce)
{
BrokerTracing.TraceEvent(TraceEventType.Warning, 0, "[DuplexFrontEnd] Exception throwed while close the channel: {0}", ce);
channel.Abort();
}
}
}
return;
}
// Try to get the client id
string callerSID;
string userName = this.GetUserName(requestMessage, out callerSID);
string clientId = GetClientId(requestMessage, callerSID);
try
{
ParamCheckUtility.ThrowIfTooLong(clientId.Length, "clientId", Constant.MaxClientIdLength, SR.ClientIdTooLong);
ParamCheckUtility.ThrowIfNotMatchRegex(ParamCheckUtility.ClientIdValid, clientId, "clientId", SR.InvalidClientId);
}
catch (ArgumentException)
{
BrokerTracing.EtwTrace.LogFrontEndRequestRejectedClientIdInvalid(this.SessionId, clientId, Utility.GetMessageIdFromMessage(requestMessage));
RequestContextBase requestContextToReject = new DuplexRequestContext(requestMessage, this.binding, channel, this.Observer);
requestContextToReject.BeginReply(FrontEndFaultMessage.GenerateFaultMessage(requestMessage, requestMessage.Headers.MessageVersion, SOAFaultCode.Broker_InvalidClientIdOrTooLong, SR.InvalidClientIdOrTooLong), this.ReplySentCallback, requestContextToReject);
return;
}
if (client == null)
{
if (!this.TryGetClientByChannel(channel, clientId, userName, requestMessage, out client))
{
return;
}
state.Client = client;
}
// Receive new requests
if (!ar.CompletedSynchronously)
{
this.TryToBeginReceiveMessagesWithThrottling(state);
}
// Reject if client id does not match
if (String.Compare(clientId, client.ClientId, StringComparison.OrdinalIgnoreCase) != 0)
{
BrokerTracing.EtwTrace.LogFrontEndRequestRejectedClientIdNotMatch(this.SessionId, clientId, Utility.GetMessageIdFromMessage(requestMessage));
RequestContextBase requestContextToReject = new DuplexRequestContext(requestMessage, this.binding, channel, this.Observer);
requestContextToReject.BeginReply(FrontEndFaultMessage.GenerateFaultMessage(requestMessage, requestMessage.Headers.MessageVersion, SOAFaultCode.Broker_ClientIdNotMatch, SR.ClientIdNotMatch), this.ReplySentCallback, requestContextToReject);
return;
}
// Try to get the user info header
bool userDataFlag = GetUserInfoHeader(requestMessage);
// Create request context
RequestContextBase requestContext;
if (userDataFlag)
{
// Message that needs not to reply
requestContext = DummyRequestContext.GetInstance(requestMessage.Version);
}
else
{
requestContext = new DuplexRequestContext(requestMessage, this.binding, channel, this.Observer, client);
}
// Check auth
if (!this.CheckAuth(requestContext, requestMessage))
{
return;
}
// remove security header for websocket
TryRemoveSecurityHeaderForHttps(requestMessage);
// Send the request to the broker client
Task.Run(() => client.RequestReceived(requestContext, requestMessage, null));
}
