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