Merge pull request #1429 from sequelize/hotfix/transaction_timeout

Fix transaction timeouts for postgres

lib/dialects/postgres/connector-manager.js

-
-var Query   = require("./query")
-  , Utils   = require("../../utils")
+var Query                = require("./query")
+  , Utils                = require("../../utils")
+  , ConnectionParameters = require('pg/lib/connection-parameters')
 
 
 module.exports = (function() {
 module.exports = (function() {
   var ConnectorManager = function(sequelize, config) {
   var ConnectorManager = function(sequelize, config) {
@@ -16,13 +16,6 @@ module.exports = (function() {
     // https://github.com/brianc/node-postgres/issues/166#issuecomment-9514935
     // https://github.com/brianc/node-postgres/issues/166#issuecomment-9514935
     this.pg.types.setTypeParser(20, String);
     this.pg.types.setTypeParser(20, String);
 
 
-    // set pooling parameters if specified
-    if (this.pooling) {
-      this.pg.defaults.poolSize           = this.config.pool.maxConnections || 10
-      this.pg.defaults.poolIdleTimeout    = this.config.pool.maxIdleTime    || 30000
-      this.pg.defaults.reapIntervalMillis = this.config.pool.reapInterval   || 1000
-    }
-
     this.disconnectTimeoutId = null
     this.disconnectTimeoutId = null
     this.pendingQueries = 0
     this.pendingQueries = 0
     this.clientDrained = true
     this.clientDrained = true
@@ -31,7 +24,7 @@ module.exports = (function() {
     this.onProcessExit = function () {
     this.onProcessExit = function () {
       this.disconnect()
       this.disconnect()
     }.bind(this);
     }.bind(this);
-    
+
     process.on('exit', this.onProcessExit)
     process.on('exit', this.onProcessExit)
   }
   }
   Utils._.extend(ConnectorManager.prototype, require("../connector-manager").prototype)
   Utils._.extend(ConnectorManager.prototype, require("../connector-manager").prototype)
@@ -89,7 +82,16 @@ module.exports = (function() {
     this.isConnecting = true
     this.isConnecting = true
     this.isConnected  = false
     this.isConnected  = false
 
 
-    var uri = this.sequelize.getQueryInterface().QueryGenerator.databaseConnectionUri(this.config)
+    var uri    = this.sequelize.getQueryInterface().QueryGenerator.databaseConnectionUri(this.config)
+      , config = new ConnectionParameters(uri)
+
+    // set pooling parameters if specified
+    if (this.pooling) {
+      config.poolSize           = this.config.pool.maxConnections || 10
+      config.poolIdleTimeout    = this.config.pool.maxIdleTime    || 30000
+      config.reapIntervalMillis = this.config.pool.reapInterval   || 1000
+      config.uuid               = this.config.uuid
+    }
 
 
     var connectCallback = function(err, client, done) {
     var connectCallback = function(err, client, done) {
       self.isConnecting = false
       self.isConnecting = false
@@ -142,7 +144,7 @@ module.exports = (function() {
 
 
     if (this.pooling) {
     if (this.pooling) {
       // acquire client from pool
       // acquire client from pool
-      this.pg.connect(uri, connectCallback)
+      this.pg.connect(config, connectCallback)
     } else {
     } else {
       if (!!this.client) {
       if (!!this.client) {
         connectCallback(null, this.client)
         connectCallback(null, this.client)
@@ -151,13 +153,13 @@ module.exports = (function() {
 
 
         var responded = false
         var responded = false
 
 
-        this.client = new this.pg.Client(uri)
+        this.client = new this.pg.Client(config)
         this.client.connect(function(err, client, done) {
         this.client.connect(function(err, client, done) {
           responded = true
           responded = true
           connectCallback(err, client || self.client, done)
           connectCallback(err, client || self.client, done)
         })
         })
 
 
-        // If we didn't ever hear from the client.connect() callback the connection timedout, node-postgres does not treat this as an error since no active query was ever emitted
+        // If we didn't ever hear from the client.connect() callback the connection timeout, node-postgres does not treat this as an error since no active query was ever emitted
         this.client.on('end', function () {
         this.client.on('end', function () {
           if (!responded) {
           if (!responded) {
             connectCallback(new Error('Connection timed out'))
             connectCallback(new Error('Connection timed out'))

lib/transaction-manager.js

@@ -22,8 +22,9 @@ TransactionManager.prototype.getConnectorManager = function(uuid) {
         {},
         {},
         Utils._.clone(config.pool || {}),
         Utils._.clone(config.pool || {}),
         {
         {
-          maxConnections: 0,
-          useReplicaton: false
+          minConnections: 1,
+          maxConnections: 1,
+          useReplicaton:  false
         }
         }
       )
       )
       config.keepDefaultTimezone = true
       config.keepDefaultTimezone = true

lib/transaction.js

@@ -86,4 +86,4 @@ Transaction.prototype.cleanup = function() {
 
 
 var onError = function(err) {
 var onError = function(err) {
   this.emit('error', err)
   this.emit('error', err)
-}
+}
\ No newline at end of file

test/sequelize.transaction.test.js

@@ -116,4 +116,35 @@ describe(Support.getTestDialectTeaser("Sequelize#transaction"), function () {
       }).done(done)
       }).done(done)
     })
     })
   })
   })
+
+  describe('complex long running example', function() {
+    it("works with promise syntax", function(done) {
+      Support.prepareTransactionTest(this.sequelize, function(sequelize) {
+        var Test = sequelize.define('Test', {
+          id:   { type: Support.Sequelize.INTEGER, primaryKey: true, autoIncrement: true},
+          name: { type: Support.Sequelize.STRING }
+        })
+
+        sequelize
+          .sync({ force: true })
+          .then(function() {
+            sequelize.transaction(function(transaction) {
+              Test
+                .create({ name: 'Peter' }, { transaction: transaction })
+                .then(function() {
+                  setTimeout(function() {
+                    transaction
+                      .commit()
+                      .then(function() { return Test.count() })
+                      .then(function(count) {
+                        expect(count).to.equal(1)
+                        done()
+                      })
+                  }, 1000)
+                })
+            })
+          })
+      })
+    })
+  })
 })
 })

test/transaction-manager.test.js

@@ -60,12 +60,13 @@ describe(Support.getTestDialectTeaser("TransactionManager"), function () {
         }
         }
 
 
         Object.keys(this.sequelize.config.pool || {}).forEach(function(key) {
         Object.keys(this.sequelize.config.pool || {}).forEach(function(key) {
-          if (key !== 'maxConnections') {
+          if (['minConnections', 'maxConnections'].indexOf(key) === -1) {
             expect(connectorManager.config.pool[key]).to.equal(self.sequelize.config.pool[key])
             expect(connectorManager.config.pool[key]).to.equal(self.sequelize.config.pool[key])
           }
           }
         })
         })
 
 
-        expect(connectorManager.config.pool.maxConnections).to.equal(0)
+        expect(connectorManager.config.pool.minConnections).to.equal(1)
+        expect(connectorManager.config.pool.maxConnections).to.equal(1)
       })
       })
     })
     })
   })
   })