neo4j-driver 1.1.1 → 1.3.0

package/lib/v1/internal/connector.js

@@ -3,7 +3,11 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.Connection = exports.parseUrl = exports.parseScheme = exports.connect = undefined;
+exports.Connection = exports.connect = undefined;
+
+var _promise = require('babel-runtime/core-js/promise');
+
+var _promise2 = _interopRequireDefault(_promise);
 
 var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
 
@@ -27,10 +31,6 @@ var _chNode2 = _interopRequireDefault(_chNode);
 
 var _chunking = require('./chunking');
 
-var _features = require('./features');
-
-var _features2 = _interopRequireDefault(_features);
-
 var _packstream = require('./packstream');
 
 var _buf = require('./buf');
@@ -39,6 +39,16 @@ var _graphTypes = require('../graph-types');
 
 var _error = require('./../error');
 
+var _chConfig = require('./ch-config');
+
+var _chConfig2 = _interopRequireDefault(_chConfig);
+
+var _util = require('./util');
+
+var _streamObserver = require('./stream-observer');
+
+var _streamObserver2 = _interopRequireDefault(_streamObserver);
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 /**
@@ -59,6 +69,7 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 var Channel = void 0;
 if (_chNode2.default.available) {
   Channel = _chNode2.default.channel;
@@ -101,28 +112,6 @@ NODE = 0x4E,
 MAGIC_PREAMBLE = 0x6060B017,
     DEBUG = false;
 
-var URLREGEX = new RegExp(["([^/]+//)?", // scheme
-"(([^:/?#]*)", // hostname
-"(?::([0-9]+))?)", // port (optional)
-".*"].join("")); // everything else
-
-function parseScheme(url) {
-  var scheme = url.match(URLREGEX)[1] || '';
-  return scheme.toLowerCase();
-}
-
-function parseUrl(url) {
-  return url.match(URLREGEX)[2];
-}
-
-function parseHost(url) {
-  return url.match(URLREGEX)[3];
-}
-
-function parsePort(url) {
-  return url.match(URLREGEX)[4];
-}
-
 /**
  * Very rudimentary log handling, should probably be replaced by something proper at some point.
  * @param actor the part that sent the message, 'S' for server and 'C' for client
@@ -245,6 +234,8 @@ var Connection = function () {
     this._isHandlingFailure = false;
     this._currentFailure = null;
 
+    this._state = new ConnectionState(this);
+
     // Set to true on fatal errors, to get this out of session pool.
     this._isBroken = false;
 
@@ -312,7 +303,7 @@ var Connection = function () {
    * failing, and the connection getting ejected from the session pool.
    *
    * @param err an error object, forwarded to all current and future subscribers
-   * @private
+   * @protected
    */
 
 
@@ -336,6 +327,12 @@ var Connection = function () {
     value: function _handleMessage(msg) {
       var _this = this;
 
+      if (this._isBroken) {
+        // ignore all incoming messages when this connection is broken. all previously pending observers failed
+        // with the fatal error. all future observers will fail with same fatal error.
+        return;
+      }
+
       var payload = msg.fields[0];
 
       switch (msg.signature) {
@@ -348,7 +345,7 @@ var Connection = function () {
           try {
             this._currentObserver.onCompleted(payload);
           } finally {
-            this._currentObserver = this._pendingObservers.shift();
+            this._updateCurrentObserver();
           }
           break;
         case FAILURE:
@@ -357,7 +354,7 @@ var Connection = function () {
             this._currentFailure = (0, _error.newError)(payload.message, payload.code);
             this._currentObserver.onError(this._currentFailure);
           } finally {
-            this._currentObserver = this._pendingObservers.shift();
+            this._updateCurrentObserver();
             // Things are now broken. Pending observers will get FAILURE messages routed until
             // We are done handling this failure.
             if (!this._isHandlingFailure) {
@@ -384,7 +381,7 @@ var Connection = function () {
           try {
             if (this._currentFailure && this._currentObserver.onError) this._currentObserver.onError(this._currentFailure);else if (this._currentObserver.onError) this._currentObserver.onError(payload);
           } finally {
-            this._currentObserver = this._pendingObservers.shift();
+            this._updateCurrentObserver();
           }
           break;
         default:
@@ -400,7 +397,8 @@ var Connection = function () {
       var _this2 = this;
 
       log("C", "INIT", clientName, token);
-      this._queueObserver(observer);
+      var initObserver = this._state.wrap(observer);
+      this._queueObserver(initObserver);
       this._packer.packStruct(INIT, [this._packable(clientName), this._packable(token)], function (err) {
         return _this2._handleFatalError(err);
       });
@@ -453,14 +451,14 @@ var Connection = function () {
       this._chunker.messageBoundary();
     }
 
-    /** Queue a RESET-message to be sent to the database */
+    /** Queue a RESET-message to be sent to the database. Mutes failure handling. */
 
   }, {
-    key: 'reset',
-    value: function reset(observer) {
+    key: 'resetAsync',
+    value: function resetAsync(observer) {
       var _this6 = this;
 
-      log("C", "RESET");
+      log("C", "RESET_ASYNC");
       this._isHandlingFailure = true;
       var self = this;
       var wrappedObs = {
@@ -480,17 +478,32 @@ var Connection = function () {
       this._chunker.messageBoundary();
     }
 
+    /** Queue a RESET-message to be sent to the database */
+
+  }, {
+    key: 'reset',
+    value: function reset(observer) {
+      var _this7 = this;
+
+      log('C', 'RESET');
+      this._queueObserver(observer);
+      this._packer.packStruct(RESET, [], function (err) {
+        return _this7._handleFatalError(err);
+      });
+      this._chunker.messageBoundary();
+    }
+
     /** Queue a ACK_FAILURE-message to be sent to the database */
 
   }, {
     key: '_ackFailure',
     value: function _ackFailure(observer) {
-      var _this7 = this;
+      var _this8 = this;
 
       log("C", "ACK_FAILURE");
       this._queueObserver(observer);
       this._packer.packStruct(ACK_FAILURE, [], function (err) {
-        return _this7._handleFatalError(err);
+        return _this8._handleFatalError(err);
       });
       this._chunker.messageBoundary();
     }
@@ -514,6 +527,29 @@ var Connection = function () {
       }
     }
 
+    /**
+     * Get promise resolved when connection initialization succeed or rejected when it fails.
+     * Connection is initialized using {@link initialize} function.
+     * @return {Promise<Connection>} the result of connection initialization.
+     */
+
+  }, {
+    key: 'initializationCompleted',
+    value: function initializationCompleted() {
+      return this._state.initializationCompleted();
+    }
+
+    /*
+     * Pop next pending observer form the list of observers and make it current observer.
+     * @protected
+     */
+
+  }, {
+    key: '_updateCurrentObserver',
+    value: function _updateCurrentObserver() {
+      this._currentObserver = this._pendingObservers.shift();
+    }
+
     /**
      * Synchronize - flush all queued outgoing messages and route their responses
      * to their respective handlers.
@@ -551,10 +587,10 @@ var Connection = function () {
   }, {
     key: '_packable',
     value: function _packable(value) {
-      var _this8 = this;
+      var _this9 = this;
 
       return this._packer.packable(value, function (err) {
-        return _this8._handleFatalError(err);
+        return _this9._handleFatalError(err);
       });
     }
   }, {
@@ -566,36 +602,122 @@ var Connection = function () {
   return Connection;
 }();
 
+var ConnectionState = function () {
+
+  /**
+   * @constructor
+   * @param {Connection} connection the connection to track state for.
+   */
+  function ConnectionState(connection) {
+    (0, _classCallCheck3.default)(this, ConnectionState);
+
+    this._connection = connection;
+
+    this._initialized = false;
+    this._initializationError = null;
+
+    this._resolvePromise = null;
+    this._rejectPromise = null;
+  }
+
+  /**
+   * Wrap the given observer to track connection's initialization state. Connection is closed by the server if
+   * processing of INIT message fails so returned observer will handle initialization failure as a fatal error.
+   * @param {StreamObserver} observer the observer used for INIT message.
+   * @return {StreamObserver} updated observer.
+   */
+
+
+  (0, _createClass3.default)(ConnectionState, [{
+    key: 'wrap',
+    value: function wrap(observer) {
+      var _this10 = this;
+
+      return {
+        onNext: function onNext(record) {
+          if (observer && observer.onNext) {
+            observer.onNext(record);
+          }
+        },
+        onError: function onError(error) {
+          _this10._initializationError = error;
+          if (_this10._rejectPromise) {
+            _this10._rejectPromise(error);
+            _this10._rejectPromise = null;
+          }
+
+          _this10._connection._updateCurrentObserver(); // make sure this same observer will not be called again
+          try {
+            if (observer && observer.onError) {
+              observer.onError(error);
+            }
+          } finally {
+            _this10._connection._handleFatalError(error);
+          }
+        },
+        onCompleted: function onCompleted(metaData) {
+          if (metaData && metaData.server) {
+            _this10._connection.setServerVersion(metaData.server);
+          }
+          _this10._initialized = true;
+          if (_this10._resolvePromise) {
+            _this10._resolvePromise(_this10._connection);
+            _this10._resolvePromise = null;
+          }
+          if (observer && observer.onCompleted) {
+            observer.onCompleted(metaData);
+          }
+        }
+      };
+    }
+
+    /**
+     * Get promise resolved when connection initialization succeed or rejected when it fails.
+     * @return {Promise<Connection>} the result of connection initialization.
+     */
+
+  }, {
+    key: 'initializationCompleted',
+    value: function initializationCompleted() {
+      var _this11 = this;
+
+      if (this._initialized) {
+        return _promise2.default.resolve(this._connection);
+      } else if (this._initializationError) {
+        return _promise2.default.reject(this._initializationError);
+      } else {
+        return new _promise2.default(function (resolve, reject) {
+          _this11._resolvePromise = resolve;
+          _this11._rejectPromise = reject;
+        });
+      }
+    }
+  }]);
+  return ConnectionState;
+}();
+
 /**
  * Crete new connection to the provided url.
  * @access private
  * @param {string} url - 'neo4j'-prefixed URL to Neo4j Bolt endpoint
- * @param {object} config
+ * @param {object} config - this driver configuration
+ * @param {string=null} connectionErrorCode - error code for errors raised on connection errors
  * @return {Connection} - New connection
  */
 
 
 function connect(url) {
   var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var connectionErrorCode = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
 
   var Ch = config.channel || Channel;
-  var host = parseHost(url);
-  var port = parsePort(url) || 7687;
+  var host = (0, _util.parseHost)(url);
+  var port = (0, _util.parsePort)(url) || 7687;
   var completeUrl = host + ':' + port;
+  var channelConfig = new _chConfig2.default(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 ? (0, _features2.default)("trust_all_certificates") : config.encrypted,
-    // Default to using TRUST_ALL_CERTIFICATES if it is available
-    trust: config.trust || ((0, _features2.default)("trust_all_certificates") ? "TRUST_ALL_CERTIFICATES" : "TRUST_CUSTOM_CA_SIGNED_CERTIFICATES"),
-    trustedCertificates: config.trustedCertificates || [],
-    knownHosts: config.knownHosts
-  }), completeUrl);
+  return new Connection(new Ch(channelConfig), completeUrl);
 }
 
 exports.connect = connect;
-exports.parseScheme = parseScheme;
-exports.parseUrl = parseUrl;
 exports.Connection = Connection;

package/lib/v1/internal/features.js

@@ -45,6 +45,17 @@ var FEATURES = {
     } catch (e) {
       return false;
     }
+  },
+  dns_lookup: function dns_lookup() {
+    try {
+      var lookupFunction = require('dns').lookup;
+      if (lookupFunction && typeof lookupFunction === 'function') {
+        return true;
+      }
+      return false;
+    } catch (e) {
+      return false;
+    }
   }
 };
 

package/lib/v1/internal/get-servers-util.js

@@ -1,28 +1,28 @@
-"use strict";
+'use strict';
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 
-var _stringify = require("babel-runtime/core-js/json/stringify");
+var _stringify = require('babel-runtime/core-js/json/stringify');
 
 var _stringify2 = _interopRequireDefault(_stringify);
 
-var _classCallCheck2 = require("babel-runtime/helpers/classCallCheck");
+var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
 
 var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
 
-var _createClass2 = require("babel-runtime/helpers/createClass");
+var _createClass2 = require('babel-runtime/helpers/createClass');
 
 var _createClass3 = _interopRequireDefault(_createClass2);
 
-var _roundRobinArray = require("./round-robin-array");
+var _roundRobinArray = require('./round-robin-array');
 
 var _roundRobinArray2 = _interopRequireDefault(_roundRobinArray);
 
-var _error = require("../error");
+var _error = require('../error');
 
-var _integer = require("../integer");
+var _integer = require('../integer');
 
 var _integer2 = _interopRequireDefault(_integer);
 
@@ -55,7 +55,7 @@ var GetServersUtil = function () {
   }
 
   (0, _createClass3.default)(GetServersUtil, [{
-    key: "callGetServers",
+    key: 'callGetServers',
     value: function callGetServers(session, routerAddress) {
       return session.run(PROCEDURE_CALL).then(function (result) {
         session.close();
@@ -71,7 +71,7 @@ var GetServersUtil = function () {
       });
     }
   }, {
-    key: "parseTtl",
+    key: 'parseTtl',
     value: function parseTtl(record, routerAddress) {
       try {
         var now = (0, _integer.int)(Date.now());
@@ -86,7 +86,7 @@ var GetServersUtil = function () {
       }
     }
   }, {
-    key: "parseServers",
+    key: 'parseServers',
     value: function parseServers(record, routerAddress) {
       try {
         var servers = record.get('servers');

package/lib/v1/internal/host-name-resolvers.js

@@ -0,0 +1,131 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DnsHostNameResolver = exports.DummyHostNameResolver = undefined;
+
+var _promise = require('babel-runtime/core-js/promise');
+
+var _promise2 = _interopRequireDefault(_promise);
+
+var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of');
+
+var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);
+
+var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');
+
+var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
+
+var _inherits2 = require('babel-runtime/helpers/inherits');
+
+var _inherits3 = _interopRequireDefault(_inherits2);
+
+var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _createClass2 = require('babel-runtime/helpers/createClass');
+
+var _createClass3 = _interopRequireDefault(_createClass2);
+
+var _util = require('./util');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var HostNameResolver = function () {
+  function HostNameResolver() {
+    (0, _classCallCheck3.default)(this, HostNameResolver);
+  }
+
+  (0, _createClass3.default)(HostNameResolver, [{
+    key: 'resolve',
+    value: function resolve() {
+      throw new Error('Abstract function');
+    }
+  }]);
+  return HostNameResolver;
+}(); /**
+      * 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.
+      */
+
+var DummyHostNameResolver = exports.DummyHostNameResolver = function (_HostNameResolver) {
+  (0, _inherits3.default)(DummyHostNameResolver, _HostNameResolver);
+
+  function DummyHostNameResolver() {
+    (0, _classCallCheck3.default)(this, DummyHostNameResolver);
+    return (0, _possibleConstructorReturn3.default)(this, (DummyHostNameResolver.__proto__ || (0, _getPrototypeOf2.default)(DummyHostNameResolver)).apply(this, arguments));
+  }
+
+  (0, _createClass3.default)(DummyHostNameResolver, [{
+    key: 'resolve',
+    value: function resolve(seedRouter) {
+      return resolveToItself(seedRouter);
+    }
+  }]);
+  return DummyHostNameResolver;
+}(HostNameResolver);
+
+var DnsHostNameResolver = exports.DnsHostNameResolver = function (_HostNameResolver2) {
+  (0, _inherits3.default)(DnsHostNameResolver, _HostNameResolver2);
+
+  function DnsHostNameResolver() {
+    (0, _classCallCheck3.default)(this, DnsHostNameResolver);
+
+    var _this2 = (0, _possibleConstructorReturn3.default)(this, (DnsHostNameResolver.__proto__ || (0, _getPrototypeOf2.default)(DnsHostNameResolver)).call(this));
+
+    _this2._dns = require('dns');
+    return _this2;
+  }
+
+  (0, _createClass3.default)(DnsHostNameResolver, [{
+    key: 'resolve',
+    value: function resolve(seedRouter) {
+      var _this3 = this;
+
+      var seedRouterHost = (0, _util.parseHost)(seedRouter);
+      var seedRouterPort = (0, _util.parsePort)(seedRouter);
+
+      return new _promise2.default(function (resolve) {
+        _this3._dns.lookup(seedRouterHost, { all: true }, function (error, addresses) {
+          if (error) {
+            resolve(resolveToItself(seedRouter));
+          } else {
+            var addressesWithPorts = addresses.map(function (address) {
+              return addressWithPort(address, seedRouterPort);
+            });
+            resolve(addressesWithPorts);
+          }
+        });
+      });
+    }
+  }]);
+  return DnsHostNameResolver;
+}(HostNameResolver);
+
+function resolveToItself(address) {
+  return _promise2.default.resolve([address]);
+}
+
+function addressWithPort(addressObject, port) {
+  var address = addressObject.address;
+  if (port) {
+    return address + ':' + port;
+  }
+  return address;
+}