private void SendOneWay(SocketPool pool, int commandID, MemoryStream messageStream)
{
ManagedSocket socket = null;
ResourcePoolItem <MemoryStream> rebufferedStreamItem = CreateOneWayMessage(commandID, messageStream, pool);
try
{
MemoryStream rebufferedStream = rebufferedStreamItem.Item;
socket = pool.GetSocket();
// GetBuffer() should be used in preference to ToArray() where possible
// as it does not allocate a new byte[] like ToArray does().
byte[] messageBuffer = rebufferedStream.GetBuffer();
socket.Send(messageBuffer, (int)rebufferedStream.Length, SocketFlags.None);
}
catch (SocketException sex)
{
if (socket != null)
{
socket.LastError = sex.SocketErrorCode;
}
throw;
}
finally
{
if (socket != null)
{
socket.Release();
}
rebufferedStreamItem.Release();
}
}
private static void SendOneWay(SocketPool pool, int commandID, MemoryStream messageStream)
{
ManagedSocket socket = null;
ResourcePoolItem <MemoryStream> rebufferedStreamItem = CreateOneWayMessage(commandID, messageStream, pool);
try
{
MemoryStream rebufferedStream = rebufferedStreamItem.Item;
socket = pool.GetSocket();
// GetBuffer() should be used in preference to ToArray() where possible
// as it does not allocate a new byte[] like ToArray does().
byte[] messageBuffer = rebufferedStream.GetBuffer();
socket.Send(messageBuffer, (int)rebufferedStream.Length, SocketFlags.None);
if (socket.ServerSupportsAck && pool.Settings.RequestOneWayAck)
{
try
{
socket.GetReply(); //make sure we got the ack
}
catch (SocketException sex)
{
log.ErrorFormat("Failed to receive ack from {0} with error {1}", pool.Destination, sex.SocketErrorCode);
throw;
}
}
catch (Exception ex)
{
log.ErrorFormat("Failed to receive ack from {0} with error {1}", pool.Destination, ex.Message);
throw;
}
}
internal void ReleaseAndDisposeSocket(ManagedSocket socket)
{
if (socket != null)
{
try
{
socket.Idle = false;
Interlocked.Decrement(ref activeSocketCount);
Interlocked.Decrement(ref socketCount);
socket.Shutdown(SocketShutdown.Both);
socket.Close();
if (growing)
{
lock (growlock)
{
sockets[((ArrayManagedSocket)socket).Index] = null;
}
}
else
{
sockets[((ArrayManagedSocket)socket).Index] = null;
}
socket = null;
}
catch (SocketException)
{ }
catch (ObjectDisposedException)
{ }
}
}
internal override ManagedSocket GetSocket()
{
ManagedSocket socket = new ManagedSocket(Settings, this);
socket.Connect(destination);
Interlocked.Increment(ref activeSocketCount);
Interlocked.Increment(ref socketCount);
return socket;
}
internal override ManagedSocket GetSocket()
{
ManagedSocket socket = new ManagedSocket(Settings, this);
socket.Connect(destination);
Interlocked.Increment(ref activeSocketCount);
Interlocked.Increment(ref socketCount);
return(socket);
}
internal override void ReleaseSocket(ManagedSocket socket)
{
if (socket.LastError != SocketError.Success || SocketAgedOut(socket))
{
ReleaseAndDisposeSocket(socket);
}
else
{
Interlocked.Decrement(ref activeSocketCount);
socket.Idle = true;
}
}
private void DisposeSocket(ManagedSocket socket, bool pullFromRotation)
{
bool exitLimiter = false;
if (socket != null)
{
try
{
if (!socket.Idle)
{
exitLimiter = true;
Interlocked.Decrement(ref activeSocketCount);
}
if (pullFromRotation)
{
PullSocketFromRotation((LinkedManagedSocket)socket);
}
socket.Idle = false;
Interlocked.Decrement(ref socketCount);
lock (setLock)
{
sockets.Remove((LinkedManagedSocket)socket);
}
if (socket.Connected)
{
socket.Shutdown(SocketShutdown.Both);
}
socket.Close();
}
catch (SocketException)
{ }
catch (ObjectDisposedException)
{
exitLimiter = false;
if (log.IsErrorEnabled)
{
log.ErrorFormat("Attempt to release and dispose disposed socket by pool for {0}, socket {1}", destination, socket.Handle);
}
}
finally
{
if (exitLimiter)
{
ExitLimiter();
}
}
}
}
internal void ReleaseAndDisposeSocket(ManagedSocket socket)
{
try
{
socket.Shutdown(SocketShutdown.Both);
socket.Close();
Interlocked.Decrement(ref activeSocketCount);
Interlocked.Decrement(ref socketCount);
}
catch (SocketException)
{ }
catch (ObjectDisposedException)
{ }
}
internal void ReleaseAndDisposeSocket(ManagedSocket socket)
{
try
{
socket.Shutdown(SocketShutdown.Both);
socket.Close();
Interlocked.Decrement(ref activeSocketCount);
Interlocked.Decrement(ref socketCount);
}
catch (SocketException)
{ }
catch (ObjectDisposedException)
{ }
}
private MemoryStream SendSync(SocketPool pool, int commandID, MemoryStream messageStream)
{
short messageId = (short)1; //new async scheme doesn't currently need these.
ResourcePoolItem <MemoryStream> rebufferedStreamItem = CreateSyncMessage((short)commandID, messageId, messageStream, pool);
MemoryStream rebufferedStream = rebufferedStreamItem.Item;
ManagedSocket socket = null;
MemoryStream replyStream = null;
try
{
socket = pool.GetSocket();
// GetBuffer() should be used in preference to ToArray() where possible
// as it does not allocate a new byte[] like ToArray does().
socket.Send(rebufferedStream.GetBuffer(), (int)rebufferedStream.Length, SocketFlags.None);
replyStream = socket.GetReply();
}
catch (ThreadAbortException)
{
if (socket != null)
{
socket.LastError = SocketError.TimedOut;
}
log.Warn("Thread aborted on SocketClient.");
throw;
}
catch (SocketException ex)
{
if (socket != null)
{
socket.LastError = ex.SocketErrorCode;
}
throw;
}
finally
{
rebufferedStreamItem.Release();
if (socket != null) //getting the socket can throw a timedout exception due to limiting, in which case the socket will be null
{
socket.Release();
}
}
return(replyStream);
}
internal override void ReleaseSocket(ManagedSocket socket)
{
try
{
if (socket.LastError != SocketError.Success || SocketAgedOut(socket))
{
//log.InfoFormat("releasing socket to {0} with status {1}", destination, socket.LastError);
DisposeSocket(socket);
}
else
{
if (!socket.Idle)
{
lock (padLock)
{
socket.Idle = true;
if (nextSocket == null)
{
nextSocket = (LinkedManagedSocket)socket;
spareSockets++;
}
else
{
LinkedManagedSocket newNextSocket = (LinkedManagedSocket)socket;
LinkedManagedSocket currentNextSocket = nextSocket;
newNextSocket.Next = currentNextSocket;
nextSocket = newNextSocket;
spareSockets++;
}
ExitLimiter();
}
Interlocked.Decrement(ref activeSocketCount);
}
}
}
catch (Exception ex)
{
if (log.IsErrorEnabled)
{
log.ErrorFormat("Exception releasing socket: {0}", ex);
}
}
}
internal override void ReleaseSocket(ManagedSocket socket)
{
ReleaseAndDisposeSocket(socket);
}
protected bool SocketAgedOut(ManagedSocket socket)
{
long ageTicks = DateTime.UtcNow.Ticks - socket.CreatedTicks;
return(ageTicks > socketLifetimeTicks);
}
internal abstract void ReleaseSocket(ManagedSocket socket);
internal override void ReleaseSocket(ManagedSocket socket)
{
ReleaseAndDisposeSocket(socket);
}
protected bool SocketAgedOut(ManagedSocket socket)
{
long ageTicks = DateTime.UtcNow.Ticks - socket.CreatedTicks;
return ageTicks > socketLifetimeTicks;
}
internal override void ReleaseSocket(ManagedSocket socket)
{
if (socket.LastError != SocketError.Success || SocketAgedOut(socket))
{
ReleaseAndDisposeSocket(socket);
}
else
{
Interlocked.Decrement(ref activeSocketCount);
socket.Idle = true;
}
}
private void DisposeSocket(ManagedSocket socket)
{
DisposeSocket(socket, true);
}
internal void ReleaseAndDisposeSocket(ManagedSocket socket)
{
if (socket != null)
{
try
{
socket.Idle = false;
Interlocked.Decrement(ref activeSocketCount);
Interlocked.Decrement(ref socketCount);
socket.Shutdown(SocketShutdown.Both);
socket.Close();
if (growing)
{
lock (growlock)
{
sockets[((ArrayManagedSocket)socket).Index] = null;
}
}
else
{
sockets[((ArrayManagedSocket)socket).Index] = null;
}
socket = null;
}
catch (SocketException)
{ }
catch (ObjectDisposedException)
{ }
}
}
internal abstract void ReleaseSocket(ManagedSocket socket);
