Merge pull request #1791 from qingyang-id/release-idle-connection

Release idle connection

Author: sidorares

README.md

@@ -132,6 +132,8 @@ const pool = mysql.createPool({
   database: 'test',
   waitForConnections: true,
   connectionLimit: 10,
+  maxIdle: 10, // max idle connections, the default value is the same as `connectionLimit`
+  idleTimeout: 60000, // idle connections timeout, in milliseconds, the default value 60000
   queueLimit: 0
 });
 ```

index.d.ts

@@ -180,6 +180,8 @@ export interface ConnectionOptions extends mysql.ConnectionOptions {
   stream?: any;
   uri?: string;
   connectionLimit?: number;
+  maxIdle?: number;
+  idleTimeout?: number;
   Promise?: any;
   queueLimit?: number;
   waitForConnections?: boolean;

lib/connection_config.js

@@ -59,6 +59,8 @@ const validOptions = {
   user: 1,
   // These options are used for Pool
   connectionLimit: 1,
+  maxIdle: 1,
+  idleTimeout: 1,
   Promise: 1,
   queueLimit: 1,
   waitForConnections: 1

lib/pool.js

@@ -27,6 +27,10 @@ class Pool extends EventEmitter {
     this._freeConnections = new Queue();
     this._connectionQueue = new Queue();
     this._closed = false;
+    if (this.config.maxIdle < this.config.connectionLimit) {
+      // create idle connection timeout automatically release job
+      this._removeIdleTimeoutConnections();
+    }
   }
 
   promise(promiseImpl) {
@@ -40,7 +44,7 @@ class Pool extends EventEmitter {
     }
     let connection;
     if (this._freeConnections.length > 0) {
-      connection = this._freeConnections.shift();
+      connection = this._freeConnections.pop();
       this.emit('acquire', connection);
       return process.nextTick(() => cb(null, connection));
     }
@@ -187,6 +191,26 @@ class Pool extends EventEmitter {
     this.releaseConnection(connection);
   }
 
+  _removeIdleTimeoutConnections() {
+    if (this._removeIdleTimeoutConnectionsTimer) {
+      clearTimeout(this._removeIdleTimeoutConnectionsTimer);
+    }
+
+    this._removeIdleTimeoutConnectionsTimer = setTimeout(() => {
+      try {
+        while (
+          this._freeConnections.length > this.config.maxIdle &&
+          Date.now() - this._freeConnections.get(0).lastActiveTime >
+            this.config.idleTimeout
+        ) {
+          this._freeConnections.get(0).destroy();
+        }
+      } finally {
+        this._removeIdleTimeoutConnections();
+      }
+    }, 1000);
+  }
+
   format(sql, values) {
     return mysql.format(
       sql,

lib/pool_config.js

@@ -15,6 +15,12 @@ class PoolConfig {
     this.connectionLimit = isNaN(options.connectionLimit)
       ? 10
       : Number(options.connectionLimit);
+    this.maxIdle = isNaN(options.maxIdle)
+      ? this.connectionLimit
+      : Number(options.maxIdle);
+    this.idleTimeout = isNaN(options.idleTimeout)
+      ? 60000
+      : Number(options.idleTimeout);
     this.queueLimit = isNaN(options.queueLimit)
       ? 0
       : Number(options.queueLimit);

lib/pool_connection.js

@@ -6,6 +6,8 @@ class PoolConnection extends Connection {
   constructor(pool, options) {
     super(options);
     this._pool = pool;
+    // The last active time of this connection
+    this.lastActiveTime = Date.now();
     // When a fatal error occurs the connection's protocol ends, which will cause
     // the connection to end as well, thus we only need to watch for the end event
     // and we will be notified of disconnects.
@@ -22,6 +24,8 @@ class PoolConnection extends Connection {
     if (!this._pool || this._pool._closed) {
       return;
     }
+    // update last active time
+    this.lastActiveTime = Date.now();
     this._pool.releaseConnection(this);
   }
 

test/common.js

@@ -105,7 +105,10 @@ exports.getConfig = function(input) {
     timezone: args && args.timezone,
     dateStrings: args && args.dateStrings,
     authSwitchHandler: args && args.authSwitchHandler,
-    typeCast: args && args.typeCast
+    typeCast: args && args.typeCast,
+    connectionLimit: args && args.connectionLimit,
+    maxIdle: args && args.maxIdle,
+    idleTimeout: args && args.idleTimeout,
   };
   return params;
 };

test/integration/test-pool-release-idle-connection.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const createPool = require('../common.js').createPool;
+const assert = require('assert');
+
+const pool = new createPool({
+  connectionLimit: 5, // 5 connections
+  maxIdle: 1, // 1 idle connection
+  idleTimeout: 5000, // 5 seconds
+});
+
+pool.getConnection((err1, connection1) => {
+  assert.ifError(err1);
+  assert.ok(connection1);
+  pool.getConnection((err2, connection2) => {
+    assert.ifError(err2);
+    assert.ok(connection2);
+    assert.notStrictEqual(connection1, connection2);
+    pool.getConnection((err3, connection3) => {
+      assert.ifError(err3);
+      assert.ok(connection3);
+      assert.notStrictEqual(connection1, connection3);
+      assert.notStrictEqual(connection2, connection3);
+      connection1.release();
+      connection2.release();
+      connection3.release();
+      assert(pool._allConnections.length === 3);
+      assert(pool._freeConnections.length === 3);
+      setTimeout(() => {
+        assert(pool._allConnections.length === 1);
+        assert(pool._freeConnections.length === 1);
+        pool.getConnection((err4, connection4) => {
+          assert.ifError(err4);
+          assert.ok(connection4);
+          assert.strictEqual(connection3, connection4);
+          assert(pool._allConnections.length === 1);
+          assert(pool._freeConnections.length === 0);
+          connection4.release();
+          connection4.destroy();
+          pool.end();
+          setTimeout(() => process.exit(0), 1000);
+        });
+      }, 7000);
+    });
+  });
+});

typings/mysql/lib/Pool.d.ts

@@ -26,6 +26,16 @@ declare namespace Pool {
          */
         connectionLimit?: number;
 
+        /**
+         * The minimum number of idle connections. (Default: 10)
+         */
+         maxIdle?: number;
+
+        /**
+         * The idle connections timeout, in milliseconds. (Default: 60000)
+         */
+         idleTimeout?: number;
+
         /**
          * The maximum number of connection requests the pool will queue before returning an error from getConnection. If set to 0, there
          * is no limit to the number of queued connection requests. (Default: 0)