public void ProcessMessage(IMessage msg, ITransportHeaders requestHeaders, Stream requestStream, out ITransportHeaders responseHeaders, out Stream responseStream)
{
UnixConnection connection = null;
try
{
if (requestHeaders == null)
{
requestHeaders = new TransportHeaders();
}
requestHeaders["__RequestUri"] = ((IMethodMessage)msg).Uri;
connection = UnixConnectionPool.GetConnection(this._path);
UnixMessageIO.SendMessageStream(connection.Stream, requestStream, requestHeaders, connection.Buffer);
connection.Stream.Flush();
if (UnixMessageIO.ReceiveMessageStatus(connection.Stream, connection.Buffer) != MessageStatus.MethodMessage)
{
throw new RemotingException("Unknown response message from server");
}
responseStream = UnixMessageIO.ReceiveMessageStream(connection.Stream, out responseHeaders, connection.Buffer);
}
finally
{
if (connection != null)
{
connection.Release();
}
}
}
private void ReadAsyncUnixMessage(object data)
{
ITransportHeaders transportHeader;
IClientChannelSinkStack clientChannelSinkStack = (IClientChannelSinkStack)data;
UnixConnection unixConnection = (UnixConnection)clientChannelSinkStack.Pop(this);
try
{
if (UnixMessageIO.ReceiveMessageStatus(unixConnection.Stream, unixConnection.Buffer) != MessageStatus.MethodMessage)
{
throw new RemotingException("Unknown response message from server");
}
Stream stream = UnixMessageIO.ReceiveMessageStream(unixConnection.Stream, out transportHeader, unixConnection.Buffer);
unixConnection.Release();
unixConnection = null;
clientChannelSinkStack.AsyncProcessResponse(transportHeader, stream);
}
catch
{
if (unixConnection != null)
{
unixConnection.Release();
}
throw;
}
}
public void ProcessMessages()
{
byte[] numArray = new byte[256];
this._stream = new BufferedStream(new NetworkStream(this._client));
try
{
try
{
bool flag = false;
while (!flag)
{
MessageStatus messageStatu = UnixMessageIO.ReceiveMessageStatus(this._stream, numArray);
if (messageStatu == MessageStatus.MethodMessage)
{
this._sink.InternalProcessMessage(this, this._stream);
}
else if (messageStatu == MessageStatus.CancelSignal || messageStatu == MessageStatus.Unknown)
{
flag = true;
}
}
}
catch (Exception exception)
{
}
}
finally
{
this._stream.Close();
this._client.Close();
this._serverChannel.ReleaseConnection(Thread.CurrentThread);
}
}
private void ReadAsyncUnixMessage(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 UnixConnection used to send
// the request
UnixConnection connection = (UnixConnection)stack.Pop(this);
try
{
ITransportHeaders responseHeaders;
// Read the response, blocking if necessary
MessageStatus status = UnixMessageIO.ReceiveMessageStatus(connection.Stream, connection.Buffer);
if (status != MessageStatus.MethodMessage)
{
throw new RemotingException("Unknown response message from server");
}
Stream responseStream = UnixMessageIO.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 ProcessMessages()
{
byte[] buffer = new byte[256];
_stream = new BufferedStream(new NetworkStream(_client));
try
{
bool end = false;
while (!end)
{
MessageStatus type = UnixMessageIO.ReceiveMessageStatus(_stream, buffer);
switch (type)
{
case MessageStatus.MethodMessage:
_sink.InternalProcessMessage(this, _stream);
break;
case MessageStatus.Unknown:
case MessageStatus.CancelSignal:
end = true;
break;
}
}
}
catch (Exception)
{
// Console.WriteLine (ex);
}
finally
{
try
{
_serverChannel.ReleaseConnection(Thread.CurrentThread);
_stream.Close();
_client.Close();
}
catch
{
}
}
}