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 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();
}
}
}
public void ReleaseConnection(UnixConnection entry)
{
lock (_pool)
{
entry.ControlTime = DateTime.Now; // Initialize timeout
_pool.Add(entry);
Monitor.Pulse(_pool);
}
}
private void CancelConnection(UnixConnection entry)
{
try
{
entry.Stream.Close();
_activeConnections--;
}
catch
{
}
}
public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg,
ITransportHeaders headers, Stream requestStream)
{
UnixConnection connection = null;
bool isOneWay = RemotingServices.IsOneWay(((IMethodMessage)msg).MethodBase);
try
{
if (headers == null)
{
headers = new TransportHeaders();
}
headers ["__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 = UnixConnectionPool.GetConnection(_path);
UnixMessageIO.SendMessageStream(connection.Stream, requestStream, headers, connection.Buffer);
connection.Stream.Flush();
if (!isOneWay)
{
sinkStack.Push(this, connection);
ThreadPool.QueueUserWorkItem(new WaitCallback(data =>
{
try {
ReadAsyncUnixMessage(data);
}
catch {}
}), sinkStack);
}
else
{
connection.Release();
}
}
catch
{
if (connection != null)
{
connection.Release();
}
if (!isOneWay)
{
throw;
}
}
}
private UnixConnection CreateConnection()
{
try
{
ReusableUnixClient client = new ReusableUnixClient(_path);
UnixConnection entry = new UnixConnection(this, client);
_activeConnections++;
return(entry);
}
catch (Exception ex)
{
throw new RemotingException(ex.Message);
}
}
public UnixConnection GetConnection()
{
UnixConnection connection = null;
lock (_pool)
{
do
{
if (_pool.Count > 0)
{
// There are available connections
connection = (UnixConnection)_pool[_pool.Count - 1];
_pool.RemoveAt(_pool.Count - 1);
if (!connection.IsAlive)
{
CancelConnection(connection);
connection = null;
continue;
}
}
if (connection == null && _activeConnections < UnixConnectionPool.MaxOpenConnections)
{
// No connections available, but the max connections
// has not been reached yet, so a new one can be created
// Create the connection outside the lock
break;
}
// No available connections in the pool
// Wait for somewone to release one.
if (connection == null)
{
Monitor.Wait(_pool);
}
}while (connection == null);
}
if (connection == null)
{
return(CreateConnection());
}
else
{
return(connection);
}
}
private UnixConnection CreateConnection()
{
UnixConnection unixConnection;
try
{
UnixConnection unixConnection1 = new UnixConnection(this, new ReusableUnixClient(this._path));
this._activeConnections++;
unixConnection = unixConnection1;
}
catch (Exception exception)
{
throw new RemotingException(exception.Message);
}
return(unixConnection);
}
public void PurgeConnections()
{
lock (_pool)
{
for (int n = 0; n < _pool.Count; n++)
{
UnixConnection entry = (UnixConnection)_pool[n];
if ((DateTime.Now - entry.ControlTime).TotalSeconds > UnixConnectionPool.KeepAliveSeconds)
{
CancelConnection(entry);
_pool.RemoveAt(n);
n--;
}
}
}
}
public void ReleaseConnection(UnixConnection entry)
{
ArrayList arrayLists = this._pool;
Monitor.Enter(arrayLists);
try
{
entry.ControlTime = DateTime.Now;
this._pool.Add(entry);
Monitor.Pulse(this._pool);
}
finally
{
Monitor.Exit(arrayLists);
}
}
public UnixConnection GetConnection()
{
UnixConnection item = null;
ArrayList arrayLists = this._pool;
Monitor.Enter(arrayLists);
try
{
do
{
if (this._pool.Count > 0)
{
item = (UnixConnection)this._pool[this._pool.Count - 1];
this._pool.RemoveAt(this._pool.Count - 1);
if (!item.IsAlive)
{
this.CancelConnection(item);
item = null;
continue;
}
}
if (item != null || this._activeConnections >= UnixConnectionPool.MaxOpenConnections)
{
if (item != null)
{
continue;
}
Monitor.Wait(this._pool);
}
else
{
break;
}
}while (item == null);
}
finally
{
Monitor.Exit(arrayLists);
}
if (item != null)
{
return(item);
}
return(this.CreateConnection());
}
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 PurgeConnections()
{
ArrayList arrayLists = this._pool;
Monitor.Enter(arrayLists);
try
{
for (int i = 0; i < this._pool.Count; i++)
{
UnixConnection item = (UnixConnection)this._pool[i];
if ((DateTime.Now - item.ControlTime).TotalSeconds > (double)UnixConnectionPool.KeepAliveSeconds)
{
this.CancelConnection(item);
this._pool.RemoveAt(i);
i--;
}
}
}
finally
{
Monitor.Exit(arrayLists);
}
}
public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream requestStream)
{
UnixConnection connection = null;
bool flag = RemotingServices.IsOneWay(((IMethodMessage)msg).MethodBase);
try
{
if (headers == null)
{
headers = new TransportHeaders();
}
headers["__RequestUri"] = ((IMethodMessage)msg).Uri;
connection = UnixConnectionPool.GetConnection(this._path);
UnixMessageIO.SendMessageStream(connection.Stream, requestStream, headers, connection.Buffer);
connection.Stream.Flush();
if (flag)
{
connection.Release();
}
else
{
sinkStack.Push(this, connection);
ThreadPool.QueueUserWorkItem(new WaitCallback(this.ReadAsyncUnixMessage), sinkStack);
}
}
catch
{
if (connection != null)
{
connection.Release();
}
if (!flag)
{
throw;
}
}
}
private void CancelConnection(UnixConnection entry)
{
try
{
entry.Stream.Close();
_activeConnections--;
}
catch
{
}
}
public void ReleaseConnection (UnixConnection entry)
{
lock (_pool)
{
entry.ControlTime = DateTime.Now; // Initialize timeout
_pool.Add (entry);
Monitor.Pulse (_pool);
}
}
private UnixConnection CreateConnection()
{
try
{
ReusableUnixClient client = new ReusableUnixClient (_path);
UnixConnection entry = new UnixConnection(this, client);
_activeConnections++;
return entry;
}
catch (Exception ex)
{
throw new RemotingException (ex.Message);
}
}
