public void AsyncProcessResponse(IServerResponseChannelSinkStack sinkStack, object state,
IMessage msg, ITransportHeaders headers, Stream responseStream)
{
ClientConnection connection = (ClientConnection)state;
NetworkStream ns = new NetworkStream(connection.Socket);
TcpMessageIO.SendMessageStream(ns, responseStream, headers, connection.Buffer);
ns.Flush();
ns.Close();
}
public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg,
ITransportHeaders headers, Stream requestStream)
{
TcpConnection connection = null;
bool isOneWay = RemotingServices.IsOneWay(((IMethodMessage)msg).MethodBase);
try
{
if (headers == null)
{
headers = new TransportHeaders();
}
headers [CommonTransportKeys.RequestUri] = ((IMethodMessage)msg).Uri;
// Sends the stream using a connection from the pool
// and creates a WorkItem that will wait for the
// response of the server
connection = TcpConnectionPool.GetConnection(_host, _port);
TcpMessageIO.SendMessageStream(connection.Stream, requestStream, headers, connection.Buffer, isOneWay);
connection.Stream.Flush();
if (!isOneWay)
{
sinkStack.Push(this, connection);
ThreadPool.QueueUserWorkItem(new WaitCallback(data =>
{
try {
ReadAsyncTcpMessage(data);
}
catch {}
}), sinkStack);
}
else
{
connection.Release();
}
}
catch
{
if (connection != null)
{
connection.Release();
}
if (!isOneWay)
{
throw;
}
}
}
internal void InternalProcessMessage(ClientConnection connection, Stream stream)
{
// Reads the headers and the request stream
Stream requestStream;
ITransportHeaders requestHeaders;
requestStream = TcpMessageIO.ReceiveMessageStream(stream, out requestHeaders, connection.Buffer);
requestHeaders [CommonTransportKeys.IPAddress] = connection.ClientAddress;
requestHeaders [CommonTransportKeys.ConnectionId] = connection.Id;
string uri = (string)requestHeaders [CommonTransportKeys.RequestUri];
TcpChannel.ParseChannelUrl(uri, out uri);
if (uri != null)
{
requestHeaders [CommonTransportKeys.RequestUri] = uri;
}
// Pushes the connection object together with the sink. This information
// will be used for sending the response in an async call.
ServerChannelSinkStack sinkStack = new ServerChannelSinkStack();
sinkStack.Push(this, connection);
ITransportHeaders responseHeaders;
Stream responseStream;
IMessage responseMsg;
ServerProcessing proc = next_sink.ProcessMessage(sinkStack, null, requestHeaders, requestStream, out responseMsg, out responseHeaders, out responseStream);
switch (proc)
{
case ServerProcessing.Complete:
TcpMessageIO.SendMessageStream(stream, responseStream, responseHeaders, connection.Buffer);
stream.Flush();
break;
case ServerProcessing.Async:
case ServerProcessing.OneWay:
break;
}
}
public void ProcessMessages()
{
byte[] buffer = new byte[256];
NetworkStream ns = new NetworkStream(_socket);
_stream = new BufferedStream(ns);
try
{
bool end = false;
while (!end)
{
MessageStatus type = TcpMessageIO.ReceiveMessageStatus(_stream, buffer);
switch (type)
{
case MessageStatus.MethodMessage:
_sink.InternalProcessMessage(this, _stream);
break;
case MessageStatus.Unknown:
case MessageStatus.CancelSignal:
_stream.Flush();
end = true;
break;
}
}
}
catch (Exception ex)
{
#if DEBUG
Console.WriteLine("The exception was caught during TcpServerChannel.ProcessMessages: {0}, {1}", ex.GetType(), ex.Message);
#endif
}
finally
{
try
{
_stream.Close();
_socket.Close();
}
catch { }
}
}
private void ReadAsyncTcpMessage(object data)
{
// This method is called by a new thread to asynchronously
// read the response to a request
// The stack was provided as state data in QueueUserWorkItem
IClientChannelSinkStack stack = (IClientChannelSinkStack)data;
// The first sink in the stack is this sink. Pop it and
// get the status data, which is the TcpConnection used to send
// the request
TcpConnection connection = (TcpConnection)stack.Pop(this);
try
{
ITransportHeaders responseHeaders;
// Read the response, blocking if necessary
MessageStatus status = TcpMessageIO.ReceiveMessageStatus(connection.Stream, connection.Buffer);
if (status != MessageStatus.MethodMessage)
{
throw new RemotingException("Unknown response message from server");
}
Stream responseStream = TcpMessageIO.ReceiveMessageStream(connection.Stream, out responseHeaders, connection.Buffer);
// Free the connection, so it can be reused
connection.Release();
connection = null;
// Ok, proceed with the other sinks
stack.AsyncProcessResponse(responseHeaders, responseStream);
}
catch
{
if (connection != null)
{
connection.Release();
}
throw;
}
}
public void ProcessMessage(IMessage msg,
ITransportHeaders requestHeaders,
Stream requestStream,
out ITransportHeaders responseHeaders,
out Stream responseStream)
{
TcpConnection connection = null;
try
{
if (requestHeaders == null)
{
requestHeaders = new TransportHeaders();
}
requestHeaders [CommonTransportKeys.RequestUri] = ((IMethodMessage)msg).Uri;
// Sends the message
connection = TcpConnectionPool.GetConnection(_host, _port);
TcpMessageIO.SendMessageStream(connection.Stream, requestStream, requestHeaders, connection.Buffer);
connection.Stream.Flush();
// Reads the response
MessageStatus status = TcpMessageIO.ReceiveMessageStatus(connection.Stream, connection.Buffer);
if (status != MessageStatus.MethodMessage)
{
throw new RemotingException("Unknown response message from server");
}
responseStream = TcpMessageIO.ReceiveMessageStream(connection.Stream, out responseHeaders, connection.Buffer);
}
finally
{
if (connection != null)
{
connection.Release();
}
}
}