internal ISingletonChannelListener OnGetSingletonMessageHandler(ServerSingletonPreambleConnectionReader serverSingletonPreambleReader) { Uri via = serverSingletonPreambleReader.Via; TChannelListener channelListener = GetChannelListener(via); if (channelListener != null) { if (channelListener is IChannelListener <IReplyChannel> ) { channelListener.RaiseMessageReceived(); return((ISingletonChannelListener)channelListener); } else { serverSingletonPreambleReader.SendFault(FramingEncodingString.UnsupportedModeFault); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( new ProtocolException(SR.Format(SR.FramingModeNotSupported, FramingMode.Singleton))); } } else { serverSingletonPreambleReader.SendFault(FramingEncodingString.EndpointNotFoundFault); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( new EndpointNotFoundException(SR.Format(SR.EndpointNotFound, via))); } }
void OnSingletonConnection(IConnection connection, Action connectionDequeuedCallback, long streamPosition, int offset, int size, TimeSpan timeout) { if (onSingletonPreambleKnown == null) { onSingletonPreambleKnown = OnSingletonPreambleKnown; } ServerSingletonPreambleConnectionReader singletonPreambleReader = new ServerSingletonPreambleConnectionReader(connection, connectionDequeuedCallback, streamPosition, offset, size, transportSettingsCallback, onConnectionClosed, onSingletonPreambleKnown); lock (ThisLock) { if (isDisposed) { singletonPreambleReader.Dispose(); return; } connectionReaders.Add(singletonPreambleReader); } //TODO: This might block a thread. Work out if it's safe to make this method async void // or make the caller async. singletonPreambleReader.StartReadingAsync(viaDelegate, timeout).GetAwaiter().GetResult(); }
public ServerSingletonConnectionReader(ServerSingletonPreambleConnectionReader preambleReader, IConnection upgradedConnection, ConnectionDemuxer connectionDemuxer) : base(upgradedConnection, preambleReader.BufferOffset, preambleReader.BufferSize, preambleReader.Security, preambleReader.TransportSettings, preambleReader.Via) { decoder = preambleReader.Decoder; contentType = decoder.ContentType; this.connectionDemuxer = connectionDemuxer; rawConnection = preambleReader.RawConnection; channelBindingToken = preambleReader.ChannelBinding; }
async Task CompleteSingletonPreambleAsync(ServerSingletonPreambleConnectionReader serverSingletonPreambleReader, ISingletonChannelListener singletonChannelListener) { var timeoutHelper = new TimeoutHelper(singletonChannelListener.ReceiveTimeout); IConnection upgradedConnection = await serverSingletonPreambleReader.CompletePreambleAsync(singletonChannelListener.ReceiveTimeout); ServerSingletonConnectionReader singletonReader = new ServerSingletonConnectionReader(serverSingletonPreambleReader, upgradedConnection, this); //singletonReader doesn't have async version of ReceiveRequest, so just call the sync method for now. RequestContext requestContext = await singletonReader.ReceiveRequestAsync(timeoutHelper.GetCancellationToken()); singletonChannelListener.ReceiveRequest(requestContext, serverSingletonPreambleReader.ConnectionDequeuedCallback, true); }
void OnSingletonPreambleKnown(ServerSingletonPreambleConnectionReader serverSingletonPreambleReader) { lock (ThisLock) { if (isDisposed) { return; } connectionReaders.Remove(serverSingletonPreambleReader); } ISingletonChannelListener singletonChannelListener = singletonPreambleCallback(serverSingletonPreambleReader); Fx.Assert(singletonChannelListener != null, "singletonPreambleCallback must return a listener or send a Fault/throw"); // transfer ownership of the connection from the preamble reader to the message handler #pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed CompleteSingletonPreambleAsync(serverSingletonPreambleReader, singletonChannelListener); #pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed }