Exemple #1
0
            public async Task <IConnectionHandle> AcquireConnectionAsync(CancellationToken cancellationToken)
            {
                try
                {
                    StartCheckingOut();

                    var stopwatch = Stopwatch.StartNew();
                    _poolQueueWaitResult = await _pool._maxConnectionsQueue.WaitSignaledAsync(_timeout, cancellationToken).ConfigureAwait(false);

                    if (_poolQueueWaitResult == SemaphoreSlimSignalable.SemaphoreWaitResult.Entered)
                    {
                        PooledConnection pooledConnection = null;
                        var timeout = EnsureTimeout(stopwatch);

                        using (var connectionCreator = new ConnectionCreator(_pool, timeout))
                        {
                            pooledConnection = await connectionCreator.CreateOpenedOrReuseAsync(cancellationToken).ConfigureAwait(false);
                        }

                        return(EndCheckingOut(pooledConnection, stopwatch));
                    }

                    stopwatch.Stop();
                    throw CreateException(stopwatch);
                }
                catch (Exception ex)
                {
                    HandleException(ex);
                    throw;
                }
            }
Exemple #2
0
        private async Task EnsureMinSizeAsync(CancellationToken cancellationToken)
        {
            var minTimeout = TimeSpan.FromMilliseconds(20);

            while (CreatedCount < _settings.MinConnections && !cancellationToken.IsCancellationRequested)
            {
                using (var poolAwaiter = _maxConnectionsQueue.CreateAwaiter())
                {
                    var entered = await poolAwaiter.WaitSignaledAsync(minTimeout, cancellationToken).ConfigureAwait(false);

                    if (!entered)
                    {
                        return;
                    }

                    using (var connectionCreator = new ConnectionCreator(this, minTimeout))
                    {
                        var connection = await connectionCreator.CreateOpenedAsync(cancellationToken).ConfigureAwait(false);

                        _connectionHolder.Return(connection);
                    }
                }

                cancellationToken.ThrowIfCancellationRequested();
            }
        }
            public async Task <IConnectionHandle> EnteredPoolAsync(bool enteredPool, CancellationToken cancellationToken)
            {
                _enteredPool = enteredPool;
                PooledConnection connection = null;

                if (enteredPool)
                {
                    var timeSpentInWaitQueue = _stopwatch.Elapsed;
                    using (var connectionCreator = new ConnectionCreator(_pool, _pool._settings.WaitQueueTimeout - timeSpentInWaitQueue))
                    {
                        connection = await connectionCreator.CreateOpenedOrReuseAsync(cancellationToken).ConfigureAwait(false);
                    }
                }

                return(FinalizePoolEnterance(connection));
            }
            public IConnectionHandle EnteredPool(bool enteredPool, CancellationToken cancellationToken)
            {
                _enteredPool = enteredPool;
                PooledConnection connection = null;

                if (enteredPool)
                {
                    var timeSpentInWaitQueue = _stopwatch.Elapsed;
                    using (var connectionCreator = new ConnectionCreator(_pool, _pool._settings.WaitQueueTimeout - timeSpentInWaitQueue))
                    {
                        connection = connectionCreator.CreateOpenedOrReuse(cancellationToken);
                    }
                }

                return(FinalizePoolEnterance(connection));
            }
        private async Task EnsureMinSizeAsync(CancellationToken cancellationToken)
        {
            var minTimeout = TimeSpan.FromMilliseconds(20);

            while (CreatedCount < _settings.MinConnections)
            {
                bool enteredPool = false;
                try
                {
                    enteredPool = await _poolQueue.WaitAsync(minTimeout, cancellationToken).ConfigureAwait(false);

                    if (!enteredPool)
                    {
                        return;
                    }

                    using (var connectionCreator = new ConnectionCreator(this, minTimeout))
                    {
                        var connection = await connectionCreator.CreateOpenedAsync(cancellationToken).ConfigureAwait(false);

                        _connectionHolder.Return(connection);
                    }
                }
                finally
                {
                    if (enteredPool)
                    {
                        try
                        {
                            _poolQueue.Release();
                        }
                        catch
                        {
                            // log this... it's a bug
                        }
                    }
                }
            }
        }
        private void EnsureMinSize(CancellationToken cancellationToken)
        {
            var minTimeout = TimeSpan.FromMilliseconds(20);

            while (_connectionPool.CreatedCount < _connectionPool.Settings.MinConnections && !cancellationToken.IsCancellationRequested)
            {
                using (var poolAwaiter = _connectionPool.CreateMaxConnectionsAwaiter())
                {
                    var entered = poolAwaiter.WaitSignaled(minTimeout, cancellationToken);
                    if (!entered)
                    {
                        return;
                    }

                    using (var connectionCreator = new ConnectionCreator(_connectionPool, minTimeout))
                    {
                        var connection = connectionCreator.CreateOpened(cancellationToken);
                        _connectionPool.ConnectionHolder.Return(connection);
                    }
                }

                cancellationToken.ThrowIfCancellationRequested();
            }
        }