Push pooling logic into connection providers

Author: ali-ince

gulpfile.babel.js

@@ -38,6 +38,7 @@ const ts = require('gulp-typescript')
 const JasmineReporter = require('jasmine-spec-reporter').SpecReporter
 const karma = require('karma')
 const log = require('fancy-log')
+const JasmineExec = require('jasmine')
 
 /**
  * Useful to investigate resource leaks in tests. Enable to see active sockets and file handles after the 'test' task.
@@ -112,6 +113,18 @@ gulp.task(
   })
 )
 
+gulp.task('test-nodejs-unit', () => {
+  return runJasmineTests('#unit*')
+})
+
+gulp.task('test-nodejs-stub', () => {
+  return runJasmineTests('#stub*')
+})
+
+gulp.task('test-nodejs-integration', () => {
+  return runJasmineTests('#integration*')
+})
+
 gulp.task('run-browser-test-chrome', function (cb) {
   runKarma('chrome', cb)
 })
@@ -248,3 +261,24 @@ function runKarma (browser, cb) {
     }
   ).start()
 }
+
+function runJasmineTests (filterString) {
+  return new Promise((resolve, reject) => {
+    const jasmine = new JasmineExec()
+    jasmine.loadConfigFile('./spec/support/jasmine.json')
+    jasmine.loadHelpers()
+    jasmine.loadSpecs()
+    jasmine.configureDefaultReporter({
+      print: () => {}
+    })
+    jasmine.addReporter(newJasmineConsoleReporter())
+    jasmine.onComplete(passed => {
+      if (passed) {
+        resolve()
+      } else {
+        reject(new Error('tests failed'))
+      }
+    })
+    jasmine.execute(null, filterString)
+  })
+}

package-lock.json

@@ -0,0 +1,7 @@
+{
+  "spec_dir": "test",
+  "spec_files": ["**/*.test.js", "!**/browser/*.js"],
+  "helpers": ["../node_modules/@babel/register/lib/node.js"],
+  "stopSpecOnExpectationFailure": false,
+  "random": true
+}

spec/support/jasmine.json

@@ -19,7 +19,7 @@
 
 import Session from './session'
 import Pool from './internal/pool'
-import Connection from './internal/connection'
+import ChannelConnection from './internal/connection-channel'
 import { newError, SERVICE_UNAVAILABLE } from './error'
 import DirectConnectionProvider from './internal/connection-provider-direct'
 import Bookmark from './internal/bookmark'
@@ -76,19 +76,9 @@ class Driver {
     this._id = idGenerator++
     this._address = address
     this._userAgent = userAgent
-    this._openConnections = {}
     this._authToken = authToken
     this._config = config
     this._log = Logger.create(config)
-    this._pool = new Pool({
-      create: this._createConnection.bind(this),
-      destroy: this._destroyConnection.bind(this),
-      validate: this._validateConnection.bind(this),
-      installIdleObserver: this._installIdleObserverOnConnection.bind(this),
-      removeIdleObserver: this._removeIdleObserverOnConnection.bind(this),
-      config: PoolConfig.fromDriverConfig(config),
-      log: this._log
-    })
 
     /**
      * Reference to the connection provider. Initialized lazily by {@link _getOrCreateConnectionProvider}.
@@ -120,66 +110,6 @@ class Driver {
     return connectivityVerifier.verify({ database })
   }
 
-  /**
-   * Create a new connection and initialize it.
-   * @return {Promise<Connection>} promise resolved with a new connection or rejected when failed to connect.
-   * @access private
-   */
-  _createConnection (address, release) {
-    const connection = Connection.create(
-      address,
-      this._config,
-      this._createConnectionErrorHandler(),
-      this._log
-    )
-    connection._release = () => release(address, connection)
-    this._openConnections[connection.id] = connection
-
-    return connection.connect(this._userAgent, this._authToken).catch(error => {
-      if (this.onError) {
-        // notify Driver.onError callback about connection initialization errors
-        this.onError(error)
-      }
-      // let's destroy this connection
-      this._destroyConnection(connection)
-      // propagate the error because connection failed to connect / initialize
-      throw error
-    })
-  }
-
-  /**
-   * Check that a connection is usable
-   * @return {boolean} true if the connection is open
-   * @access private
-   **/
-  _validateConnection (conn) {
-    if (!conn.isOpen()) {
-      return false
-    }
-
-    const maxConnectionLifetime = this._config.maxConnectionLifetime
-    const lifetime = Date.now() - conn.creationTimestamp
-    return lifetime <= maxConnectionLifetime
-  }
-
-  _installIdleObserverOnConnection (conn, observer) {
-    conn._queueObserver(observer)
-  }
-
-  _removeIdleObserverOnConnection (conn) {
-    conn._updateCurrentObserver()
-  }
-
-  /**
-   * Dispose of a connection.
-   * @return {Connection} the connection to dispose.
-   * @access private
-   */
-  _destroyConnection (conn) {
-    delete this._openConnections[conn.id]
-    conn.close()
-  }
-
   /**
    * Acquire a session to communicate with the database. The session will
    * borrow connections from the underlying connection pool as required and
@@ -225,38 +155,27 @@ class Driver {
   }
 
   // Extension point
-  _createConnectionProvider (address, connectionPool, driverOnErrorCallback) {
-    return new DirectConnectionProvider(
-      address,
-      connectionPool,
-      driverOnErrorCallback
-    )
-  }
-
-  // Extension point
-  _createConnectionErrorHandler () {
-    return new ConnectionErrorHandler(SERVICE_UNAVAILABLE)
+  _createConnectionProvider (address, userAgent, authToken) {
+    return new DirectConnectionProvider({
+      id: this._id,
+      config: this._config,
+      log: this._log,
+      address: address,
+      userAgent: userAgent,
+      authToken: authToken
+    })
   }
 
   _getOrCreateConnectionProvider () {
     if (!this._connectionProvider) {
-      const driverOnErrorCallback = this._driverOnErrorCallback.bind(this)
       this._connectionProvider = this._createConnectionProvider(
         this._address,
-        this._pool,
-        driverOnErrorCallback
+        this._userAgent,
+        this._authToken
       )
     }
-    return this._connectionProvider
-  }
 
-  _driverOnErrorCallback (error) {
-    const userDefinedOnErrorCallback = this.onError
-    if (userDefinedOnErrorCallback && error.code === SERVICE_UNAVAILABLE) {
-      userDefinedOnErrorCallback(error)
-    } else {
-      // we don't need to tell the driver about this error
-    }
+    return this._connectionProvider
   }
 
   /**
@@ -266,18 +185,8 @@ class Driver {
    */
   close () {
     this._log.info(`Driver ${this._id} closing`)
-
-    try {
-      // purge all idle connections in the connection pool
-      this._pool.purgeAll()
-    } finally {
-      // then close all connections driver has ever created
-      // it is needed to close connections that are active right now and are acquired from the pool
-      for (let connectionId in this._openConnections) {
-        if (this._openConnections.hasOwnProperty(connectionId)) {
-          this._openConnections[connectionId].close()
-        }
-      }
+    if (this._connectionProvider) {
+      this._connectionProvider.close()
     }
   }
 }