add PoolConnection which inherits from Connection and implements all the pool-spesific Connection behavior

Author: tellnes

lib/Connection.js

@@ -1,6 +1,5 @@
 var Net              = require('net');
 var ConnectionConfig = require('./ConnectionConfig');
-var Pool             = require('./Pool');
 var Protocol         = require('./protocol/Protocol');
 var SqlString        = require('./protocol/SqlString');
 var Query            = require('./protocol/sequences/Query');

lib/Pool.js

@@ -2,6 +2,7 @@ var mysql        = require('../');
 var Connection   = require('./Connection');
 var EventEmitter = require('events').EventEmitter;
 var Util         = require('util');
+var PoolConnection = require('./PoolConnection');
 
 module.exports = Pool;
 
@@ -35,7 +36,7 @@ Pool.prototype.getConnection = function (cb) {
   }
 
   if (this.config.connectionLimit === 0 || this._allConnections.length < this.config.connectionLimit) {
-    connection = this._createConnection();
+    connection = new PoolConnection(this, { config: this.config.connectionConfig });
 
     this._allConnections.push(connection);
 
@@ -68,7 +69,7 @@ Pool.prototype.getConnection = function (cb) {
 Pool.prototype.releaseConnection = function (connection) {
   var cb;
 
-  if (connection._poolRemoved) {
+  if (!connection._pool) {
     // The connection has been removed from the pool and is no longer good.
     if (this._connectionQueue.length) {
       cb = this._connectionQueue.shift();
@@ -115,11 +116,7 @@ Pool.prototype.end = function (cb) {
 
   for (var i = 0; i < this._allConnections.length; i++) {
     connection = this._allConnections[i];
-
-    delete connection.release;
-    connection.destroy = connection._realDestroy;
-    connection.end     = connection._realEnd;
-    connection.end(endCB);
+    connection._realEnd(endCB);
   }
 };
 
@@ -139,61 +136,9 @@ Pool.prototype.query = function (sql, values, cb) {
   });
 };
 
-Pool.prototype._createConnection = function() {
-  var self = this;
-  var connection = (this.config.createConnection)
-    ? this.config.createConnection(this.config.connectionConfig)
-    : mysql.createConnection(this.config.connectionConfig);
-
-  connection._realEnd = connection.end;
-  connection.end      = function(cb) {
-    console.warn( 'Calling conn.end() to release a pooled connection is '
-                + 'deprecated. In next version calling conn.end() will be '
-                + 'restored to default conn.end() behavior. Use '
-                + 'conn.release() instead.'
-                );
-    this.release();
-    if (cb) cb();
-  };
-
-  connection.release = function () {
-    self.releaseConnection(connection);
-  };
-
-  connection._realDestroy = connection.destroy;
-  connection.destroy      = function() {
-    self._removeConnection(connection);
-    connection.destroy();
-  };
-
-  // 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.
-  connection.on('end', this._handleConnectionEnd.bind(this, connection));
-  connection.on('error', this._handleConnectionError.bind(this, connection));
-
-  return connection;
-};
-
-Pool.prototype._handleConnectionEnd = function(connection) {
-  if (this._closed || connection._poolRemoved) {
-    return;
-  }
-  this._removeConnection(connection);
-};
-
-Pool.prototype._handleConnectionError = function(connection) {
-  if (this._closed || connection._poolRemoved) {
-    return;
-  }
-  this._removeConnection(connection);
-};
-
 Pool.prototype._removeConnection = function(connection) {
   var i;
 
-  connection._poolRemoved = true;
-
   for (i = 0; i < this._allConnections.length; i++) {
     if (this._allConnections[i] === connection) {
       this._allConnections.splice(i, 1);
@@ -208,9 +153,5 @@ Pool.prototype._removeConnection = function(connection) {
     }
   }
 
-  delete connection.release;
-  connection.end     = connection._realEnd;
-  connection.destroy = connection._realDestroy;
-
   this.releaseConnection(connection);
 };

lib/PoolConfig.js

@@ -4,7 +4,6 @@ var ConnectionConfig = require('./ConnectionConfig');
 module.exports = PoolConfig;
 function PoolConfig(options) {
   this.connectionConfig   = new ConnectionConfig(options);
-  this.createConnection   = options.createConnection || undefined;
   this.waitForConnections = (options.waitForConnections === undefined)
     ? true
     : Boolean(options.waitForConnections);

lib/PoolConnection.js

@@ -0,0 +1,48 @@
+var inherits = require('util').inherits
+  , Connection = require('./Connection')
+
+module.exports = PoolConnection;
+inherits(PoolConnection, Connection);
+
+function PoolConnection(pool, options) {
+  Connection.call(this, options);
+  this._pool = pool;
+
+  // 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.
+  this.on('end', this._removeFromPool);
+  this.on('error', this._removeFromPool);
+}
+
+PoolConnection.prototype.release = function () {
+  return this._pool.releaseConnection(this);
+};
+
+// TODO: Remove this when we are removing PoolConnection#end
+PoolConnection.prototype._realEnd = Connection.prototype.end;
+
+PoolConnection.prototype.end = function () {
+  console.warn( 'Calling conn.end() to release a pooled connection is '
+              + 'deprecated. In next version calling conn.end() will be '
+              + 'restored to default conn.end() behavior. Use '
+              + 'conn.release() instead.'
+              );
+  this.release();
+};
+
+PoolConnection.prototype.destroy = function () {
+  this._removeFromPool(this);
+  return Connection.prototype.destroy.apply(this, arguments);
+};
+
+PoolConnection.prototype._removeFromPool = function(connection) {
+  if (!this._pool || this._pool._closed) {
+    return;
+  }
+
+  var pool = this._pool;
+  this._pool = null;
+
+  pool._removeConnection(this);
+};

test/common.js

@@ -31,7 +31,7 @@ common.createConnection = function(config) {
 
 common.createPool = function(config) {
   config = mergeTestConfig(config);
-  config.createConnection = common.createConnection;
+  config.connectionConfig = mergeTestConfig(config.connectionConfig);
   return Mysql.createPool(config);
 };
 

test/integration/pool/test-destroy-connection.js

@@ -9,10 +9,7 @@ pool.getConnection(function(err, connection) {
   connection.destroy();
 
   assert.ok(pool._allConnections.length == 0);
-  assert.ok(connection._poolRemoved);
-  assert.strictEqual(connection.end,     Connection.prototype.end);
-  assert.strictEqual(connection.end,     Connection.prototype.end);
-  assert.ok(!('release' in connection))
+  assert.ok(!connection._pool);
 
   pool.end();
 });

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

@@ -0,0 +1,16 @@
+var common     = require('../../common');
+var assert     = require('assert');
+var Connection = require(common.lib + '/Connection');
+var PoolConnection = require(common.lib + '/PoolConnection');
+var EventEmitter = require('events').EventEmitter;
+var pool       = common.createPool();
+
+pool.getConnection(function (err, conn) {
+  if (err) throw err;
+
+  assert(conn instanceof PoolConnection);
+  assert(conn instanceof Connection);
+  assert(conn instanceof EventEmitter);
+
+  pool.end();
+});