} // IServerChannelSink internal void ServiceRequest(Object state) { HttpServerSocketHandler streamManager = (HttpServerSocketHandler)state; ITransportHeaders headers = streamManager.ReadHeaders(); Stream requestStream = streamManager.GetRequestStream(); // process request ServerChannelSinkStack sinkStack = new ServerChannelSinkStack(); sinkStack.Push(this, streamManager); IMessage responseMessage; ITransportHeaders responseHeaders; Stream responseStream; ServerProcessing processing = _nextSink.ProcessMessage(sinkStack, null, headers, requestStream, out responseMessage, out responseHeaders, out responseStream); // handle response switch (processing) { case ServerProcessing.Complete: { // Send the response. Call completed synchronously. sinkStack.Pop(this); streamManager.SendResponse(responseStream, "200", "OK", responseHeaders); break; } // case ServerProcessing.Complete case ServerProcessing.OneWay: { // Just send back a 200 OK streamManager.SendResponse(null, "202", "Accepted", responseHeaders); break; } // case ServerProcessing.OneWay case ServerProcessing.Async: { sinkStack.StoreAndDispatch(this, streamManager); break; } // case ServerProcessing.Async } // switch (processing) // async processing will take care if handling this later if (processing != ServerProcessing.Async) { if (streamManager.CanServiceAnotherRequest()) { streamManager.BeginReadMessage(); } else { streamManager.Close(); } } } // ServiceRequest
public Stream GetResponseStream(IServerResponseChannelSinkStack sinkStack, object state, IMessage msg, ITransportHeaders headers) { HttpServerSocketHandler handler = (HttpServerSocketHandler)state; if (handler.AllowChunkedResponse) { return(handler.GetResponseStream("200", "OK", headers)); } return(null); }
public void AsyncProcessResponse(IServerResponseChannelSinkStack sinkStack, object state, IMessage msg, ITransportHeaders headers, Stream stream) { HttpServerSocketHandler handler = null; handler = (HttpServerSocketHandler)state; handler.SendResponse(stream, "200", "OK", headers); if (handler.CanServiceAnotherRequest()) { handler.BeginReadMessage(); } else { handler.Close(); } }
internal void ServiceRequest(object state) { IMessage message; ITransportHeaders headers2; Stream stream2; HttpServerSocketHandler handler = (HttpServerSocketHandler)state; ITransportHeaders requestHeaders = handler.ReadHeaders(); Stream requestStream = handler.GetRequestStream(); requestHeaders["__CustomErrorsEnabled"] = handler.CustomErrorsEnabled(); ServerChannelSinkStack sinkStack = new ServerChannelSinkStack(); sinkStack.Push(this, handler); ServerProcessing processing = this._nextSink.ProcessMessage(sinkStack, null, requestHeaders, requestStream, out message, out headers2, out stream2); switch (processing) { case ServerProcessing.Complete: sinkStack.Pop(this); handler.SendResponse(stream2, "200", "OK", headers2); break; case ServerProcessing.OneWay: handler.SendResponse(null, "202", "Accepted", headers2); break; case ServerProcessing.Async: sinkStack.StoreAndDispatch(this, handler); break; } if (processing != ServerProcessing.Async) { if (handler.CanServiceAnotherRequest()) { handler.BeginReadMessage(); } else { handler.Close(); } } }
} // AddHookChannelUri // // end of IChannelReceiverHook implementation // // // Server helpers // // Thread for listening void Listen() { bool bOkToListen = false; try { _tcpListener.Start(_bExclusiveAddressUse); bOkToListen = true; } catch (Exception e) { _startListeningException = e; } _waitForStartListening.Set(); // allow main thread to continue now that we have tried to start the socket InternalRemotingServices.RemotingTrace("Waiting to Accept the Socket on Port: " + _port); // // Wait for an incoming socket // Socket socket; while (bOkToListen) { InternalRemotingServices.RemotingTrace("TCPChannel::Listen - tcpListen.Pending() == true"); try { socket = _tcpListener.AcceptSocket(); if (socket == null) { throw new RemotingException( String.Format( CoreChannel.GetResourceString("Remoting_Socket_Accept"), Marshal.GetLastWin32Error().ToString())); } else { // disable nagle delay socket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.NoDelay, 1); // set linger option LingerOption lingerOption = new LingerOption(true, 3); socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger, lingerOption); HttpServerSocketHandler streamManager = new HttpServerSocketHandler(socket, CoreChannel.RequestQueue); streamManager.DataArrivedCallback = new WaitCallback(_transportSink.ServiceRequest); streamManager.BeginReadMessage(); } } catch (Exception e) { if (!_bListening) { // We called Stop() on the tcp listener, so gracefully exit. bOkToListen = false; } else { // we want the exception to show up as unhandled since this // is an unexpected failure. if (!(e is SocketException)) { // FUTURE: Add an internal exception reporting system, so // that failures won't be masked. For release builds, we // really don't want to let the listener thread die. //throw; } } } } // while (bOkToListen) }
} // AddHookChannelUri // // end of IChannelReceiverHook implementation // // Thread for listening void Listen() { bool bOkToListen = false; try { _tcpListener.Start(_bExclusiveAddressUse); bOkToListen = true; } catch (Exception e) { _startListeningException = e; } _waitForStartListening.Set(); // allow main thread to continue now that we have tried to start the socket InternalRemotingServices.RemotingTrace( "Waiting to Accept the Socket on Port: " + _port); // // Wait for an incoming socket // Socket socket; while (bOkToListen) { InternalRemotingServices.RemotingTrace("TCPChannel::Listen - tcpListen.Pending() == true"); try { socket = _tcpListener.AcceptSocket(); if (socket == null) { throw new RemotingException( String.Format( CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Socket_Accept"), Marshal.GetLastWin32Error().ToString(CultureInfo.InvariantCulture))); } else { // disable nagle delay socket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.NoDelay, 1); // Set keepalive flag, so that inactive sockets can be cleaned up socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, 1); // set linger option LingerOption lingerOption = new LingerOption(true, 3); socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger, lingerOption); Stream netStream = new SocketStream(socket); HttpServerSocketHandler streamManager = null; //Create the socket Handler streamManager = new HttpServerSocketHandler(socket, CoreChannel.RequestQueue, netStream); // @ streamManager.DataArrivedCallback = new WaitCallback(_transportSink.ServiceRequest); streamManager.BeginReadMessage(); } } catch (Exception e) { if (!_bListening) { // We called Stop() on the tcp listener, so gracefully exit. bOkToListen = false; } else { // we want the exception to show up as unhandled since this // is an unexpected failure. if (!(e is SocketException)) { // < } } } } // while (bOkToListen) }
} // AddHookChannelUri // // end of IChannelReceiverHook implementation // // Thread for listening void Listen() { bool bOkToListen = false; try { _tcpListener.Start(_bExclusiveAddressUse); bOkToListen = true; } catch (Exception e) { _startListeningException = e; } _waitForStartListening.Set(); // allow main thread to continue now that we have tried to start the socket InternalRemotingServices.RemotingTrace("Waiting to Accept the Socket on Port: " + _port); // // Wait for an incoming socket // Socket socket; while (bOkToListen) { InternalRemotingServices.RemotingTrace("TCPChannel::Listen - tcpListen.Pending() == true"); try { socket = _tcpListener.AcceptSocket(); if (socket == null) { throw new RemotingException( String.Format( CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Socket_Accept"), Marshal.GetLastWin32Error().ToString(CultureInfo.InvariantCulture))); } else { // disable nagle delay socket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.NoDelay, 1); // Set keepalive flag, so that inactive sockets can be cleaned up socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, 1); // set linger option LingerOption lingerOption = new LingerOption(true, 3); socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger, lingerOption); Stream netStream = new SocketStream(socket); HttpServerSocketHandler streamManager = null; //Create the socket Handler streamManager = new HttpServerSocketHandler(socket, CoreChannel.RequestQueue, netStream); // @ streamManager.DataArrivedCallback = new WaitCallback(_transportSink.ServiceRequest); streamManager.BeginReadMessage(); } } catch (Exception e) { if (!_bListening) { // We called Stop() on the tcp listener, so gracefully exit. bOkToListen = false; } else { // we want the exception to show up as unhandled since this // is an unexpected failure. if (!(e is SocketException)) { // < } } } } // while (bOkToListen) }