Exemplo n.º 1
0
 internal override void ReleaseAndDisposeAll()
 {
     lock (padLock)
     {
         foreach (LinkedManagedSocket socket in sockets)
         {
             try
             {
                 if (socket.Connected)
                 {
                     socket.Shutdown(SocketShutdown.Both);
                 }
                 socket.Close();
                 Interlocked.Decrement(ref activeSocketCount);
                 Interlocked.Decrement(ref socketCount);
             }
             catch (SocketException)
             {
             }
             catch (ObjectDisposedException)
             {
             }
         }
         nextSocket = null;
     }
 }
Exemplo n.º 2
0
 private void PullSocketFromRotation(LinkedManagedSocket socket)
 {
     lock (padLock)
     {
         if (nextSocket != null)
         {
             if (socket == nextSocket)
             {
                 nextSocket = nextSocket.Next;
                 spareSockets--;
             }
             else
             {
                 LinkedManagedSocket pointer     = nextSocket.Next;
                 LinkedManagedSocket prevPointer = null;
                 while (pointer != null && pointer != socket)
                 {
                     prevPointer = pointer;
                     pointer     = pointer.Next;
                 }
                 if (pointer == socket && prevPointer != null && pointer != null)
                 {
                     prevPointer.Next = pointer.Next; //skip over it!
                     spareSockets--;
                 }
             }
         }
     }
 }
Exemplo n.º 3
0
        private LinkedManagedSocket BuildSocket()
        {
            LinkedManagedSocket socket = new LinkedManagedSocket(this.Settings, this);

            socket.Connect(this.destination, this.Settings.ConnectTimeout);
            Interlocked.Increment(ref socketCount);
            return(socket);
        }
Exemplo n.º 4
0
 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);
         }
     }
 }
Exemplo n.º 5
0
 public void PoolFiller()
 {
     do
     {
         Thread.Sleep(10000);
         try
         {
             List <LinkedManagedSocket> disposeList = null;
             lock (padLock)
             {
                 LinkedManagedSocket socketPointer = nextSocket;
                 while (socketPointer != null)
                 {
                     if (SocketAgedOut(socketPointer))
                     {
                         LinkedManagedSocket expiredSocket = socketPointer;
                         socketPointer = socketPointer.Next;
                         PullSocketFromRotation(expiredSocket);
                         spareSockets--;
                         if (disposeList == null)
                         {
                             disposeList = new List <LinkedManagedSocket>();
                         }
                         disposeList.Add(expiredSocket);
                     }
                     else
                     {
                         socketPointer = socketPointer.Next;
                     }
                 }
             }
             if (disposeList != null)
             {
                 disposeList.ForEach(expiredSocket => DisposeSocket(expiredSocket, false));
             }
         }
         catch (Exception ex)
         {
             log.InfoFormat("poolfiller exception {0}", ex.Message);
         }
     } while (true);
 }
Exemplo n.º 6
0
        internal override ManagedSocket GetSocket()
        {
            if (!EnterLimiter())
            {
                throw new SocketException((int)SocketError.TooManyOpenSockets);
            }

            List <LinkedManagedSocket> disposeList = null;

            try
            {
                lock (padLock)
                {
                    while (nextSocket != null)
                    {
                        // async receive could set an error at any time.
                        if (nextSocket.LastError == SocketError.Success)
                        {
                            var foundSocket = nextSocket;

                            // here we the first non-errored socket off of the linked list.
                            foundSocket.Idle = false;
                            nextSocket       = foundSocket.Next;
                            spareSockets--;
                            foundSocket.Next = null;
                            Interlocked.Increment(ref activeSocketCount);
                            return(foundSocket);
                        }
                        else
                        {
                            // not null, has error
                            LinkedManagedSocket badSocket = nextSocket;
                            log.DebugFormat("Socket not used in state {0}", badSocket.LastError);

                            nextSocket = nextSocket.Next; // look at the next one
                            spareSockets--;
                            badSocket.Next = null;
                            if (disposeList == null)
                            {
                                disposeList = new List <LinkedManagedSocket>();
                            }
                            disposeList.Add(badSocket);
                        }
                    }
                }
                if (disposeList != null)
                {
                    try
                    {
                        disposeList.ForEach(badSocket => DisposeSocket(badSocket, false));
                    }
                    catch (Exception ex)
                    {
                        log.InfoFormat("exception disposing sockets {0}", ex.Message);
                    }
                    disposeList = null;
                }

                // else, make a new one. which.. probably should not be able to happen.
                var socket = BuildSocket();
                lock (setLock)
                {
                    sockets.Add(socket);
                }
                Interlocked.Increment(ref activeSocketCount);
                return(socket);
            }
            catch
            {
                ExitLimiter();
                throw;
            }
            finally
            {
                if (disposeList != null)
                {
                    disposeList.ForEach(badSocket => DisposeSocket(badSocket, false));
                }
            }
        }
        internal override ManagedSocket GetSocket()
        {
            LinkedManagedSocket socket = null;

            if (EnterLimiter())
            {
                try
                {
                    lock (padLock)
                    {
                        LinkedManagedSocket foundSocket = null;
                        if (nextSocket != null)
                        {
                            while (foundSocket == null)
                            {
                                if (nextSocket == null)                                 //might be upon second iteration of this loop
                                {
                                    foundSocket = BuildSocket();
                                    lock (setLock)
                                    {
                                        sockets.Add(foundSocket);
                                    }
                                    Interlocked.Increment(ref activeSocketCount);
                                    break;
                                    //return socket;
                                }

                                if (nextSocket.LastError == SocketError.Success)                                 //async receive could set an error at any time.
                                {
                                    foundSocket = nextSocket;
                                }
                                else                                 //not null, has error
                                {
                                    LinkedManagedSocket badSocket = nextSocket;
                                    nextSocket     = nextSocket.Next;                                 //look at the next one
                                    badSocket.Next = null;
                                    DisposeSocket(badSocket, false);
                                }
                            }
                            //here we would've grabbed the first non-errored socket off of the linked list.
                            foundSocket.Idle = false;
                            nextSocket       = foundSocket.Next;
                            foundSocket.Next = null;
                            Interlocked.Increment(ref activeSocketCount);
                            socket = foundSocket;
                            //return socket;
                        }
                    }                    //next socket was null. we no longer need a lock
                    if (socket != null)  //found a good one on the list or built one in the loop
                    {
                        return(socket);
                    }

                    //else, make a new one. which.. probably should not be able to happen.
                    socket = BuildSocket();
                    lock (setLock)
                    {
                        sockets.Add(socket);
                    }
                    Interlocked.Increment(ref activeSocketCount);
                    return(socket);
                }
                catch
                {
                    ExitLimiter();
                    throw;
                }
            }

            throw new SocketException((int)SocketError.TooManyOpenSockets);
        }