Extract channel config in a separate class

This commit introduces a dedicated named configuration class for
`NodeChannel` and `WebSocketChannel`. It encapsulates information
needed to establish a connection and logic of extracting values
from the user-defined driver configuration.

Author: lutovich

src/v1/internal/ch-config.js

@@ -0,0 +1,57 @@
+/**
+ * Copyright (c) 2002-2017 "Neo Technology,","
+ * Network Engine for Objects in Lund AB [http://neotechnology.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 hasFeature from './features';
+import {SERVICE_UNAVAILABLE} from '../error';
+
+export default class ChannelConfig {
+
+  constructor(host, port, driverConfig, connectionErrorCode) {
+    this.host = host;
+    this.port = port;
+    this.encrypted = ChannelConfig._extractEncrypted(driverConfig);
+    this.trust = ChannelConfig._extractTrust(driverConfig);
+    this.trustedCertificates = ChannelConfig._extractTrustedCertificates(driverConfig);
+    this.knownHostsPath = ChannelConfig._extractKnownHostsPath(driverConfig);
+    this.connectionErrorCode = connectionErrorCode || SERVICE_UNAVAILABLE;
+  }
+
+  static _extractEncrypted(driverConfig) {
+    // check if encryption was configured by the user, use explicit null check because we permit boolean value
+    const encryptionConfigured = driverConfig.encrypted == null;
+    // default to using encryption if trust-all-certificates is available
+    return encryptionConfigured ? hasFeature('trust_all_certificates') : driverConfig.encrypted;
+  }
+
+  static _extractTrust(driverConfig) {
+    if (driverConfig.trust) {
+      return driverConfig.trust;
+    }
+    // default to using TRUST_ALL_CERTIFICATES if it is available
+    return hasFeature('trust_all_certificates') ? 'TRUST_ALL_CERTIFICATES' : 'TRUST_CUSTOM_CA_SIGNED_CERTIFICATES';
+  }
+
+  static _extractTrustedCertificates(driverConfig) {
+    return driverConfig.trustedCertificates || [];
+  }
+
+  static _extractKnownHostsPath(driverConfig) {
+    return driverConfig.knownHosts || null;
+  }
+};

src/v1/internal/ch-dummy.js

@@ -26,23 +26,32 @@ const observer = {
 };
 
 class DummyChannel {
-  constructor(opts) {
+
+  /**
+   * @constructor
+   * @param {ChannelConfig} config - configuration for the new channel.
+   */
+  constructor(config) {
     this.written = [];
   }
+
   isEncrypted() {
     return false;
   }
+
   write( buf ) {
     this.written.push(buf);
     observer.updateInstance(this);
   }
+
   toHex() {
     var out = "";
     for( var i=0; i<this.written.length; i++ ) {
       out += this.written[i].toHex();
     }
     return out;
   }
+
   toBuffer () {
     return new CombinedBuffer( this.written );
   }

src/v1/internal/ch-node.js

@@ -23,7 +23,7 @@ import path from 'path';
 import {EOL} from 'os';
 import {NodeBuffer} from './buf';
 import {ENCRYPTION_OFF, isEmptyObjectOrNull} from './util';
-import {newError, SERVICE_UNAVAILABLE} from './../error';
+import {newError} from './../error';
 
 let _CONNECTION_IDGEN = 0;
 
@@ -107,13 +107,13 @@ const TrustStrategy = {
   /**
    * @deprecated Since version 1.0. Will be deleted in a future version. {@link #TRUST_CUSTOM_CA_SIGNED_CERTIFICATES}.
    */
-  TRUST_SIGNED_CERTIFICATES: function( opts, onSuccess, onFailure ) {
+  TRUST_SIGNED_CERTIFICATES: function( config, onSuccess, onFailure ) {
     console.log("`TRUST_SIGNED_CERTIFICATES` has been deprecated as option and will be removed in a future version of " +
       "the driver. Please use `TRUST_CUSTOM_CA_SIGNED_CERTIFICATES` instead.");
-    return TrustStrategy.TRUST_CUSTOM_CA_SIGNED_CERTIFICATES(opts, onSuccess, onFailure);
+    return TrustStrategy.TRUST_CUSTOM_CA_SIGNED_CERTIFICATES(config, onSuccess, onFailure);
   },
-  TRUST_CUSTOM_CA_SIGNED_CERTIFICATES : function( opts, onSuccess, onFailure ) {
-    if( !opts.trustedCertificates || opts.trustedCertificates.length == 0 ) {
+  TRUST_CUSTOM_CA_SIGNED_CERTIFICATES : function( config, onSuccess, onFailure ) {
+    if( !config.trustedCertificates || config.trustedCertificates.length === 0 ) {
       onFailure(newError("You are using TRUST_CUSTOM_CA_SIGNED_CERTIFICATES as the method " +
         "to verify trust for encrypted  connections, but have not configured any " +
         "trustedCertificates. You  must specify the path to at least one trusted " +
@@ -124,13 +124,13 @@ const TrustStrategy = {
     }
 
     let tlsOpts = {
-      ca: opts.trustedCertificates.map((f) => fs.readFileSync(f)),
+      ca: config.trustedCertificates.map((f) => fs.readFileSync(f)),
       // Because we manually check for this in the connect callback, to give
       // a more helpful error to the user
       rejectUnauthorized: false
     };
 
-    let socket = tls.connect(opts.port, opts.host, tlsOpts, function () {
+    let socket = tls.connect(config.port, config.host, tlsOpts, function () {
       if (!socket.authorized) {
         onFailure(newError("Server certificate is not trusted. If you trust the database you are connecting to, add" +
           " the signing certificate, or the server certificate, to the list of certificates trusted by this driver" +
@@ -145,14 +145,14 @@ const TrustStrategy = {
     socket.on('error', onFailure);
     return socket;
   },
-  TRUST_SYSTEM_CA_SIGNED_CERTIFICATES : function( opts, onSuccess, onFailure ) {
+  TRUST_SYSTEM_CA_SIGNED_CERTIFICATES : function( config, onSuccess, onFailure ) {
 
     let tlsOpts = {
       // Because we manually check for this in the connect callback, to give
       // a more helpful error to the user
       rejectUnauthorized: false
     };
-    let socket = tls.connect(opts.port, opts.host, tlsOpts, function () {
+    let socket = tls.connect(config.port, config.host, tlsOpts, function () {
       if (!socket.authorized) {
         onFailure(newError("Server certificate is not trusted. If you trust the database you are connecting to, use " +
           "TRUST_CUSTOM_CA_SIGNED_CERTIFICATES and add" +
@@ -171,7 +171,7 @@ const TrustStrategy = {
   /**
    * @deprecated in 1.1 in favour of {@link #TRUST_ALL_CERTIFICATES}. Will be deleted in a future version.
    */
-  TRUST_ON_FIRST_USE : function( opts, onSuccess, onFailure ) {
+  TRUST_ON_FIRST_USE : function( config, onSuccess, onFailure ) {
       console.log("`TRUST_ON_FIRST_USE` has been deprecated as option and will be removed in a future version of " +
           "the driver. Please use `TRUST_ALL_CERTIFICATES` instead.");
 
@@ -180,7 +180,7 @@ const TrustStrategy = {
       rejectUnauthorized: false
     };
 
-    let socket = tls.connect(opts.port, opts.host, tlsOpts, function () {
+    let socket = tls.connect(config.port, config.host, tlsOpts, function () {
       var serverCert = socket.getPeerCertificate(/*raw=*/true);
 
       if( !serverCert.raw ) {
@@ -195,9 +195,9 @@ const TrustStrategy = {
         return;
       }
 
-      var serverFingerprint = require('crypto').createHash('sha512').update(serverCert.raw).digest("hex");
-      let knownHostsPath = opts.knownHosts || path.join(userHome(), ".neo4j", "known_hosts");
-      let serverId = opts.host + ":" + opts.port;
+      const serverFingerprint = require('crypto').createHash('sha512').update(serverCert.raw).digest("hex");
+      const knownHostsPath = config.knownHostsPath || path.join(userHome(), ".neo4j", "known_hosts");
+      const serverId = config.host + ":" + config.port;
 
       loadFingerprint(serverId, knownHostsPath, (knownFingerprint) => {
         if( knownFingerprint === serverFingerprint ) {
@@ -228,11 +228,11 @@ const TrustStrategy = {
     return socket;
   },
 
-  TRUST_ALL_CERTIFICATES: function (opts, onSuccess, onFailure) {
+  TRUST_ALL_CERTIFICATES: function (config, onSuccess, onFailure) {
     const tlsOpts = {
       rejectUnauthorized: false
     };
-    const socket = tls.connect(opts.port, opts.host, tlsOpts, function () {
+    const socket = tls.connect(config.port, config.host, tlsOpts, function () {
       const certificate = socket.getPeerCertificate();
       if (isEmptyObjectOrNull(certificate)) {
         onFailure(newError("Secure connection was successful but server did not return any valid " +
@@ -249,16 +249,23 @@ const TrustStrategy = {
   }
 };
 
-function connect( opts, onSuccess, onFailure=(()=>null) ) {
+/**
+ * Connect using node socket.
+ * @param {ChannelConfig} config - configuration of this channel.
+ * @param {function} onSuccess - callback to execute on connection success.
+ * @param {function} onFailure - callback to execute on connection failure.
+ * @return {*} socket connection.
+ */
+function connect( config, onSuccess, onFailure=(()=>null) ) {
   //still allow boolean for backwards compatibility
-  if (opts.encrypted === false || opts.encrypted === ENCRYPTION_OFF) {
-    var conn = net.connect(opts.port, opts.host, onSuccess);
+  if (config.encrypted === false || config.encrypted === ENCRYPTION_OFF) {
+    var conn = net.connect(config.port, config.host, onSuccess);
     conn.on('error', onFailure);
     return conn;
-  } else if( TrustStrategy[opts.trust]) {
-    return TrustStrategy[opts.trust](opts, onSuccess, onFailure);
+  } else if( TrustStrategy[config.trust]) {
+    return TrustStrategy[config.trust](config, onSuccess, onFailure);
   } else {
-    onFailure(newError("Unknown trust strategy: " + opts.trust + ". Please use either " +
+    onFailure(newError("Unknown trust strategy: " + config.trust + ". Please use either " +
       "trust:'TRUST_CUSTOM_CA_SIGNED_CERTIFICATES' or trust:'TRUST_ALL_CERTIFICATES' in your driver " +
       "configuration. Alternatively, you can disable encryption by setting " +
       "`encrypted:\"" + ENCRYPTION_OFF + "\"`. There is no mechanism to use encryption without trust verification, " +
@@ -277,11 +284,9 @@ class NodeChannel {
 
   /**
    * Create new instance
-   * @param {Object} opts - Options object
-   * @param {string} opts.host - The host, including protocol to connect to.
-   * @param {Integer} opts.port - The port to use.
+   * @param {ChannelConfig} config - configuration for this channel.
    */
-  constructor (opts) {
+  constructor (config) {
     let self = this;
 
     this.id = _CONNECTION_IDGEN++;
@@ -291,10 +296,10 @@ class NodeChannel {
     this._error = null;
     this._handleConnectionError = this._handleConnectionError.bind(this);
     this._handleConnectionTerminated = this._handleConnectionTerminated.bind(this);
-    this._errorCode = opts.errorCode || SERVICE_UNAVAILABLE;
+    this._connectionErrorCode = config.connectionErrorCode;
 
-    this._encrypted = opts.encrypted;
-    this._conn = connect(opts, () => {
+    this._encrypted = config.encrypted;
+    this._conn = connect(config, () => {
       if(!self._open) {
         return;
       }
@@ -319,14 +324,14 @@ class NodeChannel {
 
   _handleConnectionError( err ) {
     let msg = err.message || 'Failed to connect to server';
-    this._error = newError(msg, this._errorCode);
+    this._error = newError(msg, this._connectionErrorCode);
     if( this.onerror ) {
       this.onerror(this._error);
     }
   }
 
   _handleConnectionTerminated() {
-      this._error = newError('Connection was closed by server', this._errorCode);
+      this._error = newError('Connection was closed by server', this._connectionErrorCode);
       if( this.onerror ) {
         this.onerror(this._error);
       }

src/v1/internal/ch-websocket.js

@@ -18,7 +18,7 @@
  */
 
 import {HeapBuffer} from './buf';
-import {newError, SERVICE_UNAVAILABLE} from './../error';
+import {newError} from './../error';
 import {ENCRYPTION_OFF, ENCRYPTION_ON} from './util';
 
 /**
@@ -29,34 +29,32 @@ class WebSocketChannel {
 
   /**
    * Create new instance
-   * @param {Object} opts - Options object
-   * @param {string} opts.host - The host, including protocol to connect to.
-   * @param {Integer} opts.port - The port to use.
+   * @param {ChannelConfig} config - configuration for this channel.
    */
-  constructor (opts) {
+  constructor(config) {
 
     this._open = true;
     this._pending = [];
     this._error = null;
     this._handleConnectionError = this._handleConnectionError.bind(this);
-    this._errorCode = opts.errorCode || SERVICE_UNAVAILABLE;
+    this._connectionErrorCode = config.connectionErrorCode;
 
-    this._encrypted = opts.encrypted;
+    this._encrypted = config.encrypted;
 
     let scheme = "ws";
     //Allow boolean for backwards compatibility
-    if( opts.encrypted === true || opts.encrypted === ENCRYPTION_ON) {
-      if((!opts.trust) || opts.trust === "TRUST_CUSTOM_CA_SIGNED_CERTIFICATES" ) {
+    if (config.encrypted === true || config.encrypted === ENCRYPTION_ON) {
+      if ((!config.trust) || config.trust === 'TRUST_CUSTOM_CA_SIGNED_CERTIFICATES') {
         scheme = "wss";
       } else {
         this._error = newError("The browser version of this driver only supports one trust " +
-          "strategy, 'TRUST_CUSTOM_CA_SIGNED_CERTIFICATES'. "+opts.trust+" is not supported. Please " +
+          'strategy, \'TRUST_CUSTOM_CA_SIGNED_CERTIFICATES\'. ' + config.trust + ' is not supported. Please ' +
           "either use TRUST_CUSTOM_CA_SIGNED_CERTIFICATES or disable encryption by setting " +
           "`encrypted:\"" + ENCRYPTION_OFF + "\"` in the driver configuration.");
         return;
       }
     }
-    this._url = scheme + "://" + opts.host + ":" + opts.port;
+    this._url = scheme + '://' + config.host + ':' + config.port;
     this._ws = new WebSocket(this._url);
     this._ws.binaryType = "arraybuffer";
 
@@ -96,7 +94,7 @@ class WebSocketChannel {
         "the root cause of the failure. Common reasons include the database being " +
         "unavailable, using the wrong connection URL or temporary network problems. " +
         "If you have enabled encryption, ensure your browser is configured to trust the " +
-        "certificate Neo4j is configured to use. WebSocket `readyState` is: " + this._ws.readyState, this._errorCode );
+        "certificate Neo4j is configured to use. WebSocket `readyState` is: " + this._ws.readyState, this._connectionErrorCode );
       if (this.onerror) {
         this.onerror(this._error);
       }

src/v1/internal/connector.js

@@ -19,11 +19,11 @@
 import WebSocketChannel from './ch-websocket';
 import NodeChannel from './ch-node';
 import {Chunker, Dechunker} from './chunking';
-import hasFeature from './features';
 import {Packer, Unpacker} from './packstream';
 import {alloc} from './buf';
 import {Node, Path, PathSegment, Relationship, UnboundRelationship} from '../graph-types';
-import {newError, SERVICE_UNAVAILABLE} from './../error';
+import {newError} from './../error';
+import ChannelConfig from './ch-config';
 
 let Channel;
 if( NodeChannel.available ) {
@@ -476,26 +476,17 @@ class Connection {
  * @access private
  * @param {string} url - 'neo4j'-prefixed URL to Neo4j Bolt endpoint
  * @param {object} config - this driver configuration
- * @param {string} errorCode - error code for errors raised on connection errors
+ * @param {string=null} connectionErrorCode - error code for errors raised on connection errors
  * @return {Connection} - New connection
  */
-function connect( url, config = {}, errorCode = SERVICE_UNAVAILABLE) {
-  let Ch = config.channel || Channel;
+function connect(url, config = {}, connectionErrorCode = null) {
+  const Ch = config.channel || Channel;
   const host = parseHost(url);
   const port = parsePort(url) || 7687;
   const completeUrl = host + ':' + port;
+  const channelConfig = new ChannelConfig(host, port, config, connectionErrorCode);
 
-  return new Connection( new Ch({
-    host: parseHost(url),
-    port: parsePort(url) || 7687,
-    // Default to using encryption if trust-on-first-use is available
-    encrypted : (config.encrypted == null) ?  hasFeature("trust_all_certificates") : config.encrypted,
-    // Default to using TRUST_ALL_CERTIFICATES if it is available
-    trust : config.trust || (hasFeature("trust_all_certificates") ? "TRUST_ALL_CERTIFICATES" : "TRUST_CUSTOM_CA_SIGNED_CERTIFICATES"),
-    trustedCertificates : config.trustedCertificates || [],
-    knownHosts : config.knownHosts,
-    errorCode: errorCode
-  }), completeUrl);
+  return new Connection( new Ch(channelConfig), completeUrl);
 }
 
 export {