Add supportsMultiDb function on driver

Author: ali-ince

src/driver.js

@@ -103,6 +103,19 @@ class Driver {
     return connectivityVerifier.verify({ database })
   }
 
+  /**
+   * Returns whether the server supports multi database capabilities based on the handshaked protocol
+   * version.
+   *
+   * Note that this function call _always_ causes a round-trip to the server.
+   *
+   * @returns {Promise<boolean>} promise resolved with a boolean or rejected with error.
+   */
+  supportsMultiDb () {
+    const connectionProvider = this._getOrCreateConnectionProvider()
+    return connectionProvider.supportsMultiDb()
+  }
+
   /**
    * Acquire a session to communicate with the database. The session will
    * borrow connections from the underlying connection pool as required and

src/internal/bolt-protocol-v1.js

@@ -16,24 +16,24 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import RequestMessage from './request-message'
-import * as v1 from './packstream-v1'
-import Bookmark from './bookmark'
-import TxConfig from './tx-config'
-import { ACCESS_MODE_WRITE } from './constants'
-import Connection from './connection'
-import { Chunker } from './chunking'
-import { Packer } from './packstream-v1'
 import {
   assertDatabaseIsEmpty,
   assertTxConfigIsEmpty
 } from './bolt-protocol-util'
+import Bookmark from './bookmark'
+import { Chunker } from './chunking'
+import Connection from './connection'
+import { ACCESS_MODE_WRITE, BOLT_PROTOCOL_V1 } from './constants'
+import * as v1 from './packstream-v1'
+import { Packer } from './packstream-v1'
+import RequestMessage from './request-message'
 import {
-  ResultStreamObserver,
   LoginObserver,
   ResetObserver,
+  ResultStreamObserver,
   StreamObserver
 } from './stream-observers'
+import TxConfig from './tx-config'
 
 export default class BoltProtocol {
   /**
@@ -48,6 +48,13 @@ export default class BoltProtocol {
     this._unpacker = this._createUnpacker(disableLosslessIntegers)
   }
 
+  /**
+   * Returns the numerical version identifier for this protocol
+   */
+  get version () {
+    return BOLT_PROTOCOL_V1
+  }
+
   /**
    * Get the packer.
    * @return {Packer} the protocol's packer.

src/internal/bolt-protocol-v2.js

@@ -18,6 +18,7 @@
  */
 import BoltProtocolV1 from './bolt-protocol-v1'
 import * as v2 from './packstream-v2'
+import { BOLT_PROTOCOL_V2 } from './constants'
 
 export default class BoltProtocol extends BoltProtocolV1 {
   _createPacker (chunker) {
@@ -27,4 +28,8 @@ export default class BoltProtocol extends BoltProtocolV1 {
   _createUnpacker (disableLosslessIntegers) {
     return new v2.Unpacker(disableLosslessIntegers)
   }
+
+  get version () {
+    return BOLT_PROTOCOL_V2
+  }
 }

src/internal/bolt-protocol-v3.js

@@ -24,10 +24,15 @@ import {
   LoginObserver,
   ResultStreamObserver
 } from './stream-observers'
+import { BOLT_PROTOCOL_V3 } from './constants'
 
 const noOpObserver = new StreamObserver()
 
 export default class BoltProtocol extends BoltProtocolV2 {
+  get version () {
+    return BOLT_PROTOCOL_V3
+  }
+
   transformMetadata (metadata) {
     if ('t_first' in metadata) {
       // Bolt V3 uses shorter key 't_first' to represent 'result_available_after'

src/internal/bolt-protocol-v4.js

@@ -19,8 +19,13 @@
 import BoltProtocolV3 from './bolt-protocol-v3'
 import RequestMessage from './request-message'
 import { ResultStreamObserver } from './stream-observers'
+import { BOLT_PROTOCOL_V4 } from './constants'
 
 export default class BoltProtocol extends BoltProtocolV3 {
+  get version () {
+    return BOLT_PROTOCOL_V4
+  }
+
   beginTransaction ({
     bookmark,
     txConfig,

src/internal/connection-provider-direct.js

@@ -19,6 +19,8 @@
 
 import PooledConnectionProvider from './connection-provider-pooled'
 import DelegateConnection from './connection-delegate'
+import ChannelConnection from './connection-channel'
+import { BOLT_PROTOCOL_V4 } from './constants'
 
 export default class DirectConnectionProvider extends PooledConnectionProvider {
   constructor ({ id, config, log, address, userAgent, authToken }) {
@@ -36,4 +38,26 @@ export default class DirectConnectionProvider extends PooledConnectionProvider {
       .acquire(this._address)
       .then(connection => new DelegateConnection(connection, null))
   }
+
+  async supportsMultiDb () {
+    const connection = ChannelConnection.create(
+      this._address,
+      this._config,
+      this._createConnectionErrorHandler(),
+      this._log
+    )
+
+    try {
+      await connection._negotiateProtocol()
+
+      const protocol = connection.protocol()
+      if (protocol) {
+        return protocol.version >= BOLT_PROTOCOL_V4
+      }
+
+      return false
+    } finally {
+      await connection.close()
+    }
+  }
 }

src/internal/connection-provider-routing.js

@@ -31,8 +31,10 @@ import ConnectionErrorHandler from './connection-error-handler'
 import DelegateConnection from './connection-delegate'
 import LeastConnectedLoadBalancingStrategy from './least-connected-load-balancing-strategy'
 import Bookmark from './bookmark'
+import ChannelConnection from './connection-channel'
 import { int } from '../integer'
 import { ConsoleReporter } from 'jasmine'
+import { BOLT_PROTOCOL_V4 } from './constants'
 
 const UNAUTHORIZED_ERROR_CODE = 'Neo.ClientError.Security.Unauthorized'
 const DATABASE_NOT_FOUND_ERROR_CODE =
@@ -151,6 +153,41 @@ export default class RoutingConnectionProvider extends PooledConnectionProvider
     }
   }
 
+  async supportsMultiDb () {
+    const addresses = await this._resolveSeedRouter(this._seedRouter)
+
+    let lastError
+    for (let i = 0; i < addresses.length; i++) {
+      const connection = ChannelConnection.create(
+        addresses[i],
+        this._config,
+        this._createConnectionErrorHandler(),
+        this._log
+      )
+
+      try {
+        await connection._negotiateProtocol()
+
+        const protocol = connection.protocol()
+        if (protocol) {
+          return protocol.version >= BOLT_PROTOCOL_V4
+        }
+
+        return false
+      } catch (error) {
+        lastError = error
+      } finally {
+        await connection.close()
+      }
+    }
+
+    if (lastError) {
+      throw lastError
+    }
+
+    return false
+  }
+
   forget (address, database) {
     if (database || database === '') {
       this._routingTables[database].forget(address)

src/internal/connection-provider.js

@@ -38,6 +38,16 @@ export default class ConnectionProvider {
     throw new Error('not implemented')
   }
 
+  /**
+   * This method checks whether the backend database supports multi database functionality
+   * by checking protocol handshake result.
+   *
+   * @returns {Promise<boolean>}
+   */
+  supportsMultiDb () {
+    throw new Error('not implemented')
+  }
+
   /**
    * Closes this connection provider along with its internals (connections, pools, etc.)
    *

src/internal/constants.js

@@ -20,4 +20,16 @@
 const ACCESS_MODE_READ = 'READ'
 const ACCESS_MODE_WRITE = 'WRITE'
 
-export { ACCESS_MODE_READ, ACCESS_MODE_WRITE }
+const BOLT_PROTOCOL_V1 = 1
+const BOLT_PROTOCOL_V2 = 2
+const BOLT_PROTOCOL_V3 = 3
+const BOLT_PROTOCOL_V4 = 4
+
+export {
+  ACCESS_MODE_READ,
+  ACCESS_MODE_WRITE,
+  BOLT_PROTOCOL_V1,
+  BOLT_PROTOCOL_V2,
+  BOLT_PROTOCOL_V3,
+  BOLT_PROTOCOL_V4
+}

test/internal/bolt-protocol-v1.test.js

@@ -57,7 +57,7 @@ describe('#unit BoltProtocolV1', () => {
     const recorder = new utils.MessageRecordingConnection()
     const protocol = new BoltProtocolV1(recorder, null, false)
 
-    const onError = error => {}
+    const onError = _error => {}
     const onComplete = () => {}
     const clientName = 'js-driver/1.2.3'
     const authToken = { username: 'neo4j', password: 'secret' }
@@ -166,6 +166,12 @@ describe('#unit BoltProtocolV1', () => {
     expect(recorder.flushes).toEqual([false, true])
   })
 
+  it('should return correct bolt version number', () => {
+    const protocol = new BoltProtocolV1(null, null, false)
+
+    expect(protocol.version).toBe(1)
+  })
+
   describe('Bolt V3', () => {
     /**
      * @param {function(protocol: BoltProtocolV1)} fn
@@ -202,7 +208,7 @@ describe('#unit BoltProtocolV1', () => {
 
     describe('run', () => {
       function verifyRun (txConfig) {
-        verifyError((protocol, observer) =>
+        verifyError((protocol, _observer) =>
           protocol.run('statement', {}, { txConfig })
         )
       }

test/internal/bolt-protocol-v2.test.js

@@ -0,0 +1,33 @@
+/**
+ * Copyright (c) 2002-2019 "Neo4j,"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import BoltProtocolV2 from '../../src/internal/bolt-protocol-v2'
+import utils from './test-utils'
+
+describe('#unit BoltProtocolV2', () => {
+  beforeEach(() => {
+    jasmine.addMatchers(utils.matchers)
+  })
+
+  it('should return correct bolt version number', () => {
+    const protocol = new BoltProtocolV2(null, null, false)
+
+    expect(protocol.version).toBe(2)
+  })
+})

test/internal/bolt-protocol-v3.test.js

@@ -145,6 +145,12 @@ describe('#unit BoltProtocolV3', () => {
     expect(recorder.flushes).toEqual([true])
   })
 
+  it('should return correct bolt version number', () => {
+    const protocol = new BoltProtocolV3(null, null, false)
+
+    expect(protocol.version).toBe(3)
+  })
+
   describe('Bolt V4', () => {
     /**
      * @param {function(protocol: BoltProtocolV3)} fn

test/internal/bolt-protocol-v4.test.js

@@ -94,4 +94,10 @@ describe('#unit BoltProtocolV4', () => {
     expect(recorder.observers).toEqual([observer])
     expect(recorder.flushes).toEqual([true])
   })
+
+  it('should return correct bolt version number', () => {
+    const protocol = new BoltProtocolV4(null, null, false)
+
+    expect(protocol.version).toBe(4)
+  })
 })

test/internal/node/direct.driver.boltkit.test.js

@@ -411,6 +411,42 @@ describe('#stub-direct direct driver with stub server', () => {
     it('v3', () => verifyFailureOnCommit('v3'))
   })
 
+  describe('should report whether multi db is supported', () => {
+    async function verifySupportsMultiDb (version, expected) {
+      if (!boltStub.supported) {
+        return
+      }
+
+      const server = await boltStub.start(
+        `./test/resources/boltstub/${version}/supports_multi_db.script`,
+        9001
+      )
+
+      const driver = boltStub.newDriver('bolt://127.0.0.1:9001')
+
+      await expectAsync(driver.supportsMultiDb()).toBeResolvedTo(expected)
+
+      await driver.close()
+      await server.exit()
+    }
+
+    it('v1', () => verifySupportsMultiDb('v1', false))
+    it('v2', () => verifySupportsMultiDb('v2', false))
+    it('v3', () => verifySupportsMultiDb('v3', false))
+    it('v4', () => verifySupportsMultiDb('v4', true))
+    it('on error', async () => {
+      const driver = boltStub.newDriver('bolt://127.0.0.1:9001')
+
+      await expectAsync(driver.supportsMultiDb()).toBeRejectedWith(
+        jasmine.objectContaining({
+          code: SERVICE_UNAVAILABLE
+        })
+      )
+
+      await driver.close()
+    })
+  })
+
   function connectionPool (driver, key) {
     return driver._connectionProvider._connectionPool._pools[key]
   }