public void Dispose()
        {
            runCleanUpTask = false;

            try
            {
                @lock.Wait();

                foreach (var queue in cache.Select(x => x.Value).ToList())
                {
                    while (!queue.IsEmpty)
                    {
                        TcpServerConnection connection;
                        if (queue.TryDequeue(out connection))
                        {
                            disposalBag.Add(connection);
                        }
                    }
                }
                cache.Clear();
            }
            finally
            {
                @lock.Release();
            }

            while (!disposalBag.IsEmpty)
            {
                TcpServerConnection connection = null;
                if (disposalBag.TryTake(out connection))
                {
                    connection?.Dispose();
                }
            }
        }
Example #2
0
        /// <summary>
        /// Release connection back to cache.
        /// </summary>
        /// <param name="connection">The Tcp server connection to return.</param>
        /// <param name="close">Should we just close the connection instead of reusing?</param>
        internal void Release(TcpServerConnection connection, bool close = false)
        {
            if (close || connection.IsWinAuthenticated)
            {
                disposalBag.Add(connection);
                return;
            }

            connection.LastAccess = DateTime.Now;

            @lock.Wait();
            while (true)
            {
                if (cache.TryGetValue(connection.CacheKey, out var existingConnections))
                {
                    existingConnections.Enqueue(connection);
                    break;
                }

                if (cache.TryAdd(connection.CacheKey, new ConcurrentQueue <TcpServerConnection>(new[] { connection })))
                {
                    break;
                }
                ;
            }
            @lock.Release();
        }
        /// <summary>
        ///     Release connection back to cache.
        /// </summary>
        /// <param name="connection">The Tcp server connection to return.</param>
        /// <param name="close">Should we just close the connection instead of reusing?</param>
        internal async Task Release(TcpServerConnection connection, bool close = false)
        {
            if (connection == null)
            {
                return;
            }

            if (close || connection.IsWinAuthenticated || !server.EnableConnectionPool)
            {
                disposalBag.Add(connection);
                return;
            }

            connection.LastAccess = DateTime.Now;

            try
            {
                await @lock.WaitAsync();

                while (true)
                {
                    ConcurrentQueue <TcpServerConnection> existingConnections;
                    if (cache.TryGetValue(connection.CacheKey, out existingConnections))
                    {
                        while (existingConnections.Count >= server.MaxCachedConnections)
                        {
                            TcpServerConnection staleConnection;
                            if (existingConnections.TryDequeue(out staleConnection))
                            {
                                disposalBag.Add(staleConnection);
                            }
                        }

                        existingConnections.Enqueue(connection);
                        break;
                    }

                    if (cache.TryAdd(connection.CacheKey,
                                     new ConcurrentQueue <TcpServerConnection>(new[] { connection })))
                    {
                        break;
                    }
                }
            }
            finally
            {
                @lock.Release();
            }
        }
Example #4
0
 internal async Task Release(Task <TcpServerConnection> connectionCreateTask, bool closeServerConnection)
 {
     if (connectionCreateTask != null)
     {
         TcpServerConnection connection = null;
         try
         {
             connection = await connectionCreateTask;
         }
         catch { }
         finally
         {
             await Release(connection, closeServerConnection);
         }
     }
 }