Merge branch '1.7' into 2.0

Author: ali-ince

gulpfile.babel.js

@@ -17,30 +17,27 @@
  * limitations under the License.
  */
 
-var browserify = require('browserify')
-var source = require('vinyl-source-stream')
-var buffer = require('vinyl-buffer')
-var gulp = require('gulp')
-var through = require('through2')
-var uglify = require('gulp-uglify')
-var jasmine = require('gulp-jasmine')
-var babelify = require('babelify')
-var babel = require('gulp-babel')
-var watch = require('gulp-watch')
-var batch = require('gulp-batch')
-var replace = require('gulp-replace')
-var fs = require('fs-extra')
-var path = require('path')
-var minimist = require('minimist')
-var install = require('gulp-install')
-var file = require('gulp-file')
-var semver = require('semver')
-var sharedNeo4j = require('./test/internal/shared-neo4j').default
-var ts = require('gulp-typescript')
-var JasmineConsoleReporter = require('jasmine-console-reporter')
-var karma = require('karma')
-var transformTools = require('browserify-transform-tools')
-var log = require('fancy-log')
+const browserify = require('browserify')
+const source = require('vinyl-source-stream')
+const buffer = require('vinyl-buffer')
+const gulp = require('gulp')
+const uglify = require('gulp-uglify')
+const jasmine = require('gulp-jasmine')
+const babel = require('gulp-babel')
+const watch = require('gulp-watch')
+const batch = require('gulp-batch')
+const replace = require('gulp-replace')
+const fs = require('fs-extra')
+const path = require('path')
+const minimist = require('minimist')
+const install = require('gulp-install')
+const file = require('gulp-file')
+const semver = require('semver')
+const sharedNeo4j = require('./test/internal/shared-neo4j').default
+const ts = require('gulp-typescript')
+const JasmineConsoleReporter = require('jasmine-console-reporter')
+const karma = require('karma')
+const log = require('fancy-log')
 
 /**
  * Useful to investigate resource leaks in tests. Enable to see active sockets and file handles after the 'test' task.

src/driver.js

@@ -36,14 +36,14 @@ const DEFAULT_MAX_CONNECTION_LIFETIME = 60 * 60 * 1000 // 1 hour
 
 /**
  * Constant that represents read session access mode.
- * Should be used like this: `driver.session(neo4j.session.READ)`.
+ * Should be used like this: `driver.session({ defaultAccessMode: neo4j.session.READ })`.
  * @type {string}
  */
 const READ = ACCESS_MODE_READ
 
 /**
  * Constant that represents write session access mode.
- * Should be used like this: `driver.session(neo4j.session.WRITE)`.
+ * Should be used like this: `driver.session({ defaultAccessMode: neo4j.session.WRITE })`.
  * @type {string}
  */
 const WRITE = ACCESS_MODE_WRITE
@@ -64,17 +64,17 @@ class Driver {
   /**
    * You should not be calling this directly, instead use {@link driver}.
    * @constructor
-   * @param {string} hostPort
+   * @param {ServerAddress} address
    * @param {string} userAgent
    * @param {object} authToken
    * @param {object} config
    * @protected
    */
-  constructor (hostPort, userAgent, authToken = {}, config = {}) {
+  constructor (address, userAgent, authToken = {}, config = {}) {
     sanitizeConfig(config)
 
     this._id = idGenerator++
-    this._hostPort = hostPort
+    this._address = address
     this._userAgent = userAgent
     this._openConnections = {}
     this._authToken = authToken
@@ -103,7 +103,7 @@ class Driver {
    */
   _afterConstruction () {
     this._log.info(
-      `Direct driver ${this._id} created for server address ${this._hostPort}`
+      `Direct driver ${this._id} created for server address ${this._address}`
     )
   }
 
@@ -123,21 +123,23 @@ class Driver {
    * @return {Promise<Connection>} promise resolved with a new connection or rejected when failed to connect.
    * @access private
    */
-  _createConnection (hostPort, release) {
+  _createConnection (address, release) {
     const connection = Connection.create(
-      hostPort,
+      address,
       this._config,
       this._createConnectionErrorHandler(),
       this._log
     )
-    connection._release = () => release(hostPort, connection)
+    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
     })
@@ -213,9 +215,9 @@ class Driver {
   }
 
   // Extension point
-  _createConnectionProvider (hostPort, connectionPool, driverOnErrorCallback) {
+  _createConnectionProvider (address, connectionPool, driverOnErrorCallback) {
     return new DirectConnectionProvider(
-      hostPort,
+      address,
       connectionPool,
       driverOnErrorCallback
     )
@@ -230,7 +232,7 @@ class Driver {
     if (!this._connectionProvider) {
       const driverOnErrorCallback = this._driverOnErrorCallback.bind(this)
       this._connectionProvider = this._createConnectionProvider(
-        this._hostPort,
+        this._address,
         this._pool,
         driverOnErrorCallback
       )

src/index.js

@@ -55,6 +55,7 @@ import {
   LocalTime,
   Time
 } from './temporal-types'
+import ServerAddress from './internal/server-address'
 
 /**
  * @property {function(username: string, password: string, realm: ?string)} basic the function to create a
@@ -241,7 +242,7 @@ function driver (url, authToken, config = {}) {
   const parsedUrl = urlUtil.parseDatabaseUrl(url)
   if (parsedUrl.scheme === 'neo4j') {
     return new RoutingDriver(
-      parsedUrl.hostAndPort,
+      ServerAddress.fromUrl(parsedUrl.hostAndPort),
       parsedUrl.query,
       USER_AGENT,
       authToken,
@@ -253,7 +254,12 @@ function driver (url, authToken, config = {}) {
         `Parameters are not supported with scheme 'bolt'. Given URL: '${url}'`
       )
     }
-    return new Driver(parsedUrl.hostAndPort, USER_AGENT, authToken, config)
+    return new Driver(
+      ServerAddress.fromUrl(parsedUrl.hostAndPort),
+      USER_AGENT,
+      authToken,
+      config
+    )
   } else if (parsedUrl.scheme === 'http' || parsedUrl.scheme === 'https') {
     return new HttpDriver(parsedUrl, USER_AGENT, authToken, config)
   } else {

src/internal/browser/browser-channel.js

@@ -44,7 +44,7 @@ export default class WebSocketChannel {
       return
     }
 
-    this._ws = createWebSocket(scheme, config.url)
+    this._ws = createWebSocket(scheme, config.address)
     this._ws.binaryType = 'arraybuffer'
 
     let self = this
@@ -174,13 +174,13 @@ export default class WebSocketChannel {
   }
 }
 
-function createWebSocket (scheme, parsedUrl) {
-  const url = scheme + '://' + parsedUrl.hostAndPort
+function createWebSocket (scheme, address) {
+  const url = scheme + '://' + address.asHostPort()
 
   try {
     return new WebSocket(url)
   } catch (error) {
-    if (isIPv6AddressIssueOnWindows(error, parsedUrl)) {
+    if (isIPv6AddressIssueOnWindows(error, address)) {
       // WebSocket in IE and Edge browsers on Windows do not support regular IPv6 address syntax because they contain ':'.
       // It's an invalid character for UNC (https://en.wikipedia.org/wiki/IPv6_address#Literal_IPv6_addresses_in_UNC_path_names)
       // and Windows requires IPv6 to be changes in the following way:
@@ -194,34 +194,33 @@ function createWebSocket (scheme, parsedUrl) {
       // Creation of WebSocket with unconverted address results in SyntaxError without message or stacktrace.
       // That is why here we "catch" SyntaxError and rewrite IPv6 address if needed.
 
-      const windowsFriendlyUrl = asWindowsFriendlyIPv6Address(scheme, parsedUrl)
+      const windowsFriendlyUrl = asWindowsFriendlyIPv6Address(scheme, address)
       return new WebSocket(windowsFriendlyUrl)
     } else {
       throw error
     }
   }
 }
 
-function isIPv6AddressIssueOnWindows (error, parsedUrl) {
-  return error.name === 'SyntaxError' && isIPv6Address(parsedUrl)
+function isIPv6AddressIssueOnWindows (error, address) {
+  return error.name === 'SyntaxError' && isIPv6Address(address.asHostPort())
 }
 
-function isIPv6Address (parsedUrl) {
-  const hostAndPort = parsedUrl.hostAndPort
+function isIPv6Address (hostAndPort) {
   return hostAndPort.charAt(0) === '[' && hostAndPort.indexOf(']') !== -1
 }
 
-function asWindowsFriendlyIPv6Address (scheme, parsedUrl) {
+function asWindowsFriendlyIPv6Address (scheme, address) {
   // replace all ':' with '-'
-  const hostWithoutColons = parsedUrl.host.replace(new RegExp(':', 'g'), '-')
+  const hostWithoutColons = address.host().replace(new RegExp(':', 'g'), '-')
 
   // replace '%' with 's' for link-local IPv6 address like 'fe80::1%lo0'
   const hostWithoutPercent = hostWithoutColons.replace('%', 's')
 
   // append magic '.ipv6-literal.net' suffix
   const ipv6Host = hostWithoutPercent + '.ipv6-literal.net'
 
-  return `${scheme}://${ipv6Host}:${parsedUrl.port}`
+  return `${scheme}://${ipv6Host}:${address.port()}`
 }
 
 /**

src/internal/channel-config.js

@@ -42,12 +42,12 @@ const ALLOWED_VALUES_TRUST = [
 export default class ChannelConfig {
   /**
    * @constructor
-   * @param {Url} url the URL for the channel to connect to.
+   * @param {ServerAddress} address the address for the channel to connect to.
    * @param {object} driverConfig the driver config provided by the user when driver is created.
    * @param {string} connectionErrorCode the default error code to use on connection errors.
    */
-  constructor (url, driverConfig, connectionErrorCode) {
-    this.url = url
+  constructor (address, driverConfig, connectionErrorCode) {
+    this.address = address
     this.encrypted = extractEncrypted(driverConfig)
     this.trust = extractTrust(driverConfig)
     this.trustedCertificates = extractTrustedCertificates(driverConfig)

src/internal/connection-error-handler.js

@@ -37,15 +37,15 @@ export default class ConnectionErrorHandler {
   /**
    * Handle and transform the error.
    * @param {Neo4jError} error the original error.
-   * @param {string} hostPort the host and port of the connection where the error happened.
+   * @param {ServerAddress} address the address of the connection where the error happened.
    * @return {Neo4jError} new error that should be propagated to the user.
    */
-  handleAndTransformError (error, hostPort) {
+  handleAndTransformError (error, address) {
     if (isAvailabilityError(error)) {
-      return this._handleUnavailability(error, hostPort)
+      return this._handleUnavailability(error, address)
     }
     if (isFailureToWrite(error)) {
-      return this._handleWriteFailure(error, hostPort)
+      return this._handleWriteFailure(error, address)
     }
     return error
   }

src/internal/connection-providers.js

@@ -23,6 +23,7 @@ import Session from '../session'
 import RoutingTable from './routing-table'
 import Rediscovery from './rediscovery'
 import RoutingUtil from './routing-util'
+import { HostNameResolver } from './node'
 
 const UNAUTHORIZED_ERROR_CODE = 'Neo.ClientError.Security.Unauthorized'
 
@@ -43,15 +44,15 @@ class ConnectionProvider {
 }
 
 export class DirectConnectionProvider extends ConnectionProvider {
-  constructor (hostPort, connectionPool, driverOnErrorCallback) {
+  constructor (address, connectionPool, driverOnErrorCallback) {
     super()
-    this._hostPort = hostPort
+    this._address = address
     this._connectionPool = connectionPool
     this._driverOnErrorCallback = driverOnErrorCallback
   }
 
   acquireConnection (accessMode, db) {
-    const connectionPromise = this._connectionPool.acquire(this._hostPort)
+    const connectionPromise = this._connectionPool.acquire(this._address)
     return this._withAdditionalOnErrorCallback(
       connectionPromise,
       this._driverOnErrorCallback
@@ -61,7 +62,7 @@ export class DirectConnectionProvider extends ConnectionProvider {
 
 export class LoadBalancer extends ConnectionProvider {
   constructor (
-    hostPort,
+    address,
     routingContext,
     connectionPool,
     loadBalancingStrategy,
@@ -70,15 +71,16 @@ export class LoadBalancer extends ConnectionProvider {
     log
   ) {
     super()
-    this._seedRouter = hostPort
-    this._routingTable = new RoutingTable([this._seedRouter])
+    this._seedRouter = address
+    this._routingTable = new RoutingTable()
     this._rediscovery = new Rediscovery(new RoutingUtil(routingContext))
     this._connectionPool = connectionPool
     this._driverOnErrorCallback = driverOnErrorCallback
     this._loadBalancingStrategy = loadBalancingStrategy
     this._hostNameResolver = hostNameResolver
+    this._dnsResolver = new HostNameResolver()
     this._log = log
-    this._useSeedRouter = false
+    this._useSeedRouter = true
   }
 
   acquireConnection (accessMode, db) {
@@ -238,6 +240,20 @@ export class LoadBalancer extends ConnectionProvider {
     })
   }
 
+  _resolveSeedRouter (seedRouter) {
+    const customResolution = this._hostNameResolver.resolve(seedRouter)
+    const dnsResolutions = customResolution.then(resolvedAddresses => {
+      return Promise.all(
+        resolvedAddresses.map(address => {
+          return this._dnsResolver.resolve(address)
+        })
+      )
+    })
+    return dnsResolutions.then(results => {
+      return [].concat.apply([], results)
+    })
+  }
+
   _fetchRoutingTable (routerAddresses, routingTable) {
     return routerAddresses.reduce(
       (refreshedTablePromise, currentRouter, currentIndex) => {
@@ -260,10 +276,14 @@ export class LoadBalancer extends ConnectionProvider {
           return this._createSessionForRediscovery(currentRouter).then(
             session => {
               if (session) {
-                return this._rediscovery.lookupRoutingTableOnRouter(
-                  session,
-                  currentRouter
-                )
+                return this._rediscovery
+                  .lookupRoutingTableOnRouter(session, currentRouter)
+                  .catch(error => {
+                    this._log.warn(
+                      `unable to fetch routing table because of an error ${error}`
+                    )
+                    return null
+                  })
               } else {
                 // unable to acquire connection and create session towards the current router
                 // return null to signal that the next router should be tried
@@ -315,11 +335,8 @@ export class LoadBalancer extends ConnectionProvider {
   }
 
   _updateRoutingTable (newRoutingTable) {
-    const currentRoutingTable = this._routingTable
-
     // close old connections to servers not present in the new routing table
-    const staleServers = currentRoutingTable.serversDiff(newRoutingTable)
-    staleServers.forEach(server => this._connectionPool.purge(server))
+    this._connectionPool.keepAll(newRoutingTable.allServers())
 
     // make this driver instance aware of the new table
     this._routingTable = newRoutingTable