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) { } }
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);
protected bool SocketAgedOut(ManagedSocket socket) { long ageTicks = DateTime.UtcNow.Ticks - socket.CreatedTicks; return ageTicks > socketLifetimeTicks; }
private void DisposeSocket(ManagedSocket socket) { DisposeSocket(socket, true); }