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)); }