Improve release of broken connection when pool is full

Release operation discards the connection if it is broken. It also tries
to resolve a pending acquisition request, if any. In order to this it
tries to execute a promise-free internal acquire that immediately
returns an available resource or creates a new one, if possible. New
resource can only be created if pool is not at its maximum capacity.

Previously, release operation only decremented the active connection
counter at the end. This made it impossible to create a new connection
when broken one is returned.

This commit fixes the problem by making `Pool#_release()` decrement
the active counter after connection has been either added to the list
of idle connections or discarded because it turned out to be broken.

Author: lutovich

src/v1/internal/pool.js

@@ -154,6 +154,7 @@ class Pool {
       // key has been purged, don't put it back, just destroy the resource
       this._destroy(resource);
     }
+    resourceReleased(key, this._activeResourceCounts);
 
     // check if there are any pending requests
     const requests = this._acquireRequests[key];
@@ -164,18 +165,14 @@ class Pool {
         const resource = this._acquire(key);
         if (resource) {
           // managed to acquire a valid resource from the pool to satisfy the pending acquire request
+          resourceAcquired(key, this._activeResourceCounts); // increment the active counter
           requests.shift(); // forget the pending request
           pending.resolve(resource); // resolve the pending request with the acquired resource
-
-          // return early to not decrement the number of released resources
-          return;
         }
       } else {
         delete this._acquireRequests[key];
       }
     }
-
-    resourceReleased(key, this._activeResourceCounts);
   }
 }
 

test/internal/pool.test.js

@@ -522,6 +522,40 @@ describe('Pool', () => {
     });
   });
 
+  it('should resolve pending acquisition request when single invalid resource returned', done => {
+    const key = 'bolt://localhost:7687';
+    const acquisitionTimeout = 1000;
+    let counter = 0;
+
+    const pool = new Pool(
+      (url, release) => new Resource(url, counter++, release),
+      resource => {
+      },
+      resourceValidOnlyOnceValidationFunction,
+      new PoolConfig(1, acquisitionTimeout)
+    );
+
+    pool.acquire(key).then(resource1 => {
+      expect(resource1.id).toEqual(0);
+      expect(pool.activeResourceCount(key)).toEqual(1);
+
+      // release the resource before the acquisition timeout, it should be treated as invalid
+      setTimeout(() => {
+        expectNumberOfAcquisitionRequests(pool, key, 1);
+        resource1.close();
+      }, acquisitionTimeout / 2);
+
+      pool.acquire(key).then(resource2 => {
+        expect(resource2.id).toEqual(1);
+        expectNoPendingAcquisitionRequests(pool);
+        expect(pool.activeResourceCount(key)).toEqual(1);
+        done();
+      }).catch(error => {
+        done.fail(error);
+      });
+    });
+  });
+
   it('should work fine when invalid resources released and acquisition attempt pending', done => {
     const key = 'bolt://localhost:7687';
     const acquisitionTimeout = 1000;