Added ability to enforce max connection lifetime

src/v1/driver.js

@@ -47,6 +47,8 @@ class Driver {
    * @protected
    */
   constructor(url, userAgent, token = {}, config = {}) {
+    sanitizeConfig(config);
+
     this._url = url;
     this._userAgent = userAgent;
     this._openSessions = {};
@@ -56,7 +58,7 @@ class Driver {
     this._pool = new Pool(
       this._createConnection.bind(this),
       this._destroyConnection.bind(this),
-      Driver._validateConnection.bind(this),
+      this._validateConnection.bind(this),
       config.connectionPoolSize
     );
 
@@ -90,8 +92,20 @@ class Driver {
    * @return {boolean} true if the connection is open
    * @access private
    **/
-  static _validateConnection(conn) {
-    return conn.isOpen();
+  _validateConnection(conn) {
+    if (!conn.isOpen()) {
+      return false;
+    }
+
+    const maxConnectionLifetime = this._config.maxConnectionLifetime;
+    if (maxConnectionLifetime) {
+      const lifetime = Date.now() - conn.creationTimestamp;
+      if (lifetime > maxConnectionLifetime) {
+        return false;
+      }
+    }
+
+    return true;
   }
 
   /**
@@ -213,7 +227,22 @@ class _ConnectionStreamObserver extends StreamObserver {
   }
 }
 
-
+/**
+ * @private
+ */
+function sanitizeConfig(config) {
+  const maxConnectionLifetime = config.maxConnectionLifetime;
+  if (maxConnectionLifetime) {
+    const sanitizedMaxConnectionLifetime = parseInt(maxConnectionLifetime, 10);
+    if (sanitizedMaxConnectionLifetime && sanitizedMaxConnectionLifetime > 0) {
+      config.maxConnectionLifetime = sanitizedMaxConnectionLifetime;
+    } else {
+      config.maxConnectionLifetime = null;
+    }
+  } else {
+    config.maxConnectionLifetime = null;
+  }
+}
 
 export {Driver, READ, WRITE}
 

src/v1/index.js

@@ -93,7 +93,7 @@ const USER_AGENT = "neo4j-javascript/" + VERSION;
  *       // TRUST_SYSTEM_CA_SIGNED_CERTIFICATES meand that you trust whatever certificates
  *       // are in the default certificate chain of th
  *       trust: "TRUST_ALL_CERTIFICATES" | "TRUST_ON_FIRST_USE" | "TRUST_SIGNED_CERTIFICATES" |
-  *       "TRUST_CUSTOM_CA_SIGNED_CERTIFICATES" | "TRUST_SYSTEM_CA_SIGNED_CERTIFICATES",
+ *       "TRUST_CUSTOM_CA_SIGNED_CERTIFICATES" | "TRUST_SYSTEM_CA_SIGNED_CERTIFICATES",
  *
  *       // List of one or more paths to trusted encryption certificates. This only
  *       // works in the NodeJS bundle, and only matters if you use "TRUST_CUSTOM_CA_SIGNED_CERTIFICATES".
@@ -112,11 +112,20 @@ const USER_AGENT = "neo4j-javascript/" + VERSION;
  *       // Connection will be destroyed if this threshold is exceeded.
  *       connectionPoolSize: 50,
  *
+ *       // The maximum allowed lifetime for a pooled connection in milliseconds. Pooled connections older than this
+ *       // threshold will be closed and removed from the pool. Such discarding happens during connection acquisition
+ *       // so that new session is never backed by an old connection. Setting this option to a low value will cause
+ *       // a high connection churn and might result in a performance hit. It is recommended to set maximum lifetime
+ *       // to a slightly smaller value than the one configured in network equipment (load balancer, proxy, firewall,
+ *       // etc. can also limit maximum connection lifetime). No maximum lifetime limit is imposed by default. Zero
+ *       // and negative values result in lifetime not being checked.
+ *       maxConnectionLifetime: 30 * 60 * 1000, // 30 minutes
+ *
  *       // Specify the maximum time in milliseconds transactions are allowed to retry via
  *       // {@link Session#readTransaction()} and {@link Session#writeTransaction()} functions. These functions
  *       // will retry the given unit of work on `ServiceUnavailable`, `SessionExpired` and transient errors with
  *       // exponential backoff using initial delay of 1 second. Default value is 30000 which is 30 seconds.
- *       maxTransactionRetryTime: 30000,
+ *       maxTransactionRetryTime: 30000, // 30 seconds
  *
  *       // Provide an alternative load balancing strategy for the routing driver to use.
  *       // Driver uses "least_connected" by default.

src/v1/internal/connector.js

@@ -174,6 +174,7 @@ class Connection {
      */
     this.url = url;
     this.server = {address: url};
+    this.creationTimestamp = Date.now();
     this._pendingObservers = [];
     this._currentObserver = undefined;
     this._ch = channel;

test/internal/connector.test.js

@@ -25,12 +25,19 @@ import {alloc} from '../../src/v1/internal/buf';
 import {Neo4jError} from '../../src/v1/error';
 import sharedNeo4j from '../internal/shared-neo4j';
 import {ServerVersion} from '../../src/v1/internal/server-version';
+import lolex from 'lolex';
 
 describe('connector', () => {
 
+  let clock;
   let connection;
 
   afterEach(done => {
+    if (clock) {
+      clock.uninstall();
+      clock = null;
+    }
+
     const usedConnection = connection;
     connection = null;
     if (usedConnection) {
@@ -39,6 +46,15 @@ describe('connector', () => {
     done();
   });
 
+  it('should have correct creation timestamp', () => {
+    clock = lolex.install();
+    clock.setSystemTime(424242);
+
+    connection = connect('bolt://localhost');
+
+    expect(connection.creationTimestamp).toEqual(424242);
+  });
+
   it('should read/write basic messages', done => {
     // Given
     connection = connect("bolt://localhost");

test/internal/fake-connection.js

@@ -27,6 +27,9 @@
 export default class FakeConnection {
 
   constructor() {
+    this._open = true;
+    this.creationTimestamp = Date.now();
+
     this.resetInvoked = 0;
     this.resetAsyncInvoked = 0;
     this.syncInvoked = 0;
@@ -68,6 +71,10 @@ export default class FakeConnection {
     return this._initializationPromise;
   }
 
+  isOpen() {
+    return this._open;
+  }
+
   isReleasedOnceOnSessionClose() {
     return this.isReleasedOnSessionCloseTimes(1);
   }
@@ -103,4 +110,14 @@ export default class FakeConnection {
     this._initializationPromise = Promise.reject(error);
     return this;
   }
+
+  withCreationTimestamp(value) {
+    this.creationTimestamp = value;
+    return this;
+  }
+
+  closed() {
+    this._open = false;
+    return this;
+  }
 };

test/internal/routing-util.test.js

@@ -30,12 +30,11 @@ describe('RoutingUtil', () => {
 
   let clock;
 
-  beforeAll(() => {
-    clock = lolex.install();
-  });
-
-  afterAll(() => {
-    clock.uninstall();
+  afterEach(() => {
+    if (clock) {
+      clock.uninstall();
+      clock = null;
+    }
   });
 
   it('should return retrieved records when query succeeds', done => {
@@ -141,6 +140,8 @@ describe('RoutingUtil', () => {
   });
 
   it('should parse valid ttl', () => {
+    clock = lolex.install();
+
     testValidTtlParsing(100, 5);
     testValidTtlParsing(Date.now(), 3600); // 1 hour
     testValidTtlParsing(Date.now(), 86400); // 24 hours
@@ -152,6 +153,7 @@ describe('RoutingUtil', () => {
 
   it('should not overflow parsing huge ttl', () => {
     const record = newRecord({ttl: Integer.MAX_VALUE});
+    clock = lolex.install();
     clock.setSystemTime(42);
 
     const expirationTime = parseTtl(record);
@@ -161,6 +163,7 @@ describe('RoutingUtil', () => {
 
   it('should return valid value parsing negative ttl', () => {
     const record = newRecord({ttl: int(-42)});
+    clock = lolex.install();
     clock.setSystemTime(42);
 
     const expirationTime = parseTtl(record);

test/internal/timers-util.js

@@ -66,21 +66,3 @@ class SetTimeoutMock {
 }
 
 export const setTimeoutMock = new SetTimeoutMock();
-
-export function hijackNextDateNowCall(newValue) {
-  const originalDate = global.Date;
-  global.Date = new FakeDate(originalDate, newValue);
-}
-
-class FakeDate {
-
-  constructor(originalDate, nextNowValue) {
-    this._originalDate = originalDate;
-    this._nextNowValue = nextNowValue;
-  }
-
-  now() {
-    global.Date = this._originalDate;
-    return this._nextNowValue;
-  }
-}

test/internal/transaction-executor.test.js

@@ -19,7 +19,8 @@
 
 import TransactionExecutor from '../../src/v1/internal/transaction-executor';
 import {newError, SERVICE_UNAVAILABLE, SESSION_EXPIRED} from '../../src/v1/error';
-import {hijackNextDateNowCall, setTimeoutMock} from './timers-util';
+import {setTimeoutMock} from './timers-util';
+import lolex from 'lolex';
 
 const TRANSIENT_ERROR_1 = 'Neo.TransientError.Transaction.DeadlockDetected';
 const TRANSIENT_ERROR_2 = 'Neo.TransientError.Network.CommunicationError';
@@ -30,13 +31,18 @@ const OOM_ERROR = 'Neo.DatabaseError.General.OutOfMemoryError';
 
 describe('TransactionExecutor', () => {
 
+  let clock;
   let fakeSetTimeout;
 
   beforeEach(() => {
     fakeSetTimeout = setTimeoutMock.install();
   });
 
   afterEach(() => {
+    if (clock) {
+      clock.uninstall();
+      clock = null;
+    }
     fakeSetTimeout.uninstall();
   });
 
@@ -81,7 +87,9 @@ describe('TransactionExecutor', () => {
       expect(tx).toBeDefined();
       workInvocationCounter++;
       if (workInvocationCounter === 3) {
-        hijackNextDateNowCall(Date.now() + 30001); // move next `Date.now()` call forward by 30 seconds
+        const currentTime = Date.now();
+        clock = lolex.install();
+        clock.setSystemTime(currentTime + 30001); // move `Date.now()` call forward by 30 seconds
       }
       return realWork();
     });