Add new TokenManager class.

Author: smithsz

lib/tokens/TokenManager.js

@@ -0,0 +1,115 @@
+// Copyright © 2019 IBM Corp. All rights reserved.
+//
+// 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.
+'use strict';
+
+const debug = require('debug')('cloudant:tokens:tokenmanager');
+const cookie = require('cookie');
+const EventEmitter = require('events');
+
+class TokenManager {
+  constructor(client, jar, sessionUrl) {
+    this._client = client;
+    this._jar = jar;
+    this._sessionUrl = sessionUrl;
+
+    this._attemptTokenRenewal = true;
+    this._isTokenRenewing = false;
+
+    this._tokenExchangeEE = new EventEmitter().setMaxListeners(Infinity);
+  }
+
+  _autoRenew() {
+    debug('Auto renewing token now...');
+    this._renew().then((response) => {
+      let maxAgeSecs = cookie.parse(response.headers['set-cookie'][0])['Max-Age'] || 3600000;
+      let delaySecs = maxAgeSecs / 2;
+      debug(`Renewing token in ${delaySecs} seconds.`);
+      setTimeout(this._autoRenew.bind(this), delaySecs * 1000).unref();
+    }).catch((error) => {
+      debug(`Failed to auto renew token - ${error}. Retrying in 60 seconds.`);
+      setTimeout(this._autoRenew.bind(this), 60000).unref();
+    });
+  }
+
+  _getToken(callback) {
+    // ** Method to be implemented by _all_ subclasses of `TokenManager` **
+    throw new Error('Not implemented.');
+  }
+
+  // Renew the token.
+  _renew() {
+    if (!this._isTokenRenewing) {
+      this._isTokenRenewing = true;
+      this._tokenExchangeEE.removeAllListeners();
+      debug('Starting token renewal.');
+      this._getToken((error, response) => {
+        if (error) {
+          this._tokenExchangeEE.emit('error', error, response);
+        } else {
+          this._tokenExchangeEE.emit('success', response);
+          this._attemptTokenRenewal = false;
+        }
+        debug('Finished token renewal.');
+        this._isTokenRenewing = false;
+      });
+    }
+    return new Promise((resolve, reject) => {
+      this._tokenExchangeEE.once('success', resolve);
+      this._tokenExchangeEE.once('error', (error, response) => {
+        error.response = response;
+        reject(error);
+      });
+    });
+  }
+
+  // Getter for `attemptTokenRenewal`.
+  // - `true`  A renewal attempt will be made on the next `renew` request.
+  // - `false` No renewal attempt will be made on the next `renew`
+  //           request. Instead the last good renewal response will be returned
+  //           to the client.
+  get attemptTokenRenewal() {
+    return this._attemptTokenRenewal;
+  }
+
+  // Getter for `isTokenRenewing`.
+  // - `true`  A renewal attempt is in progress.
+  // - `false` There are no in progress renewal attempts.
+  get isTokenRenewing() {
+    return this._isTokenRenewing;
+  }
+
+  // Settter for `attemptTokenRenewal`.
+  set attemptTokenRenewal(newAttemptTokenRenewal) {
+    this._attemptTokenRenewal = newAttemptTokenRenewal;
+  }
+
+  // Renew the token if `attemptTokenRenewal` is `true`. Otherwise this is a
+  // no-op so just resolve the promise.
+  renewIfRequired() {
+    if (this._attemptTokenRenewal) {
+      return this._renew();
+    } else {
+      return new Promise((resolve) => {
+        resolve();
+      });
+    }
+  }
+
+  // Start the auto renewal timer.
+  startAutoRenew() {
+    this._autoRenew();
+  }
+}
+
+module.exports = TokenManager;

package-lock.json

@@ -26,6 +26,7 @@
     "@types/request": "^2.47.0",
     "async": "2.1.2",
     "concat-stream": "^1.6.0",
+    "cookie": "^0.4.0",
     "debug": "^3.1.0",
     "lockfile": "1.0.3",
     "nano": "^8.1.0",

package.json

@@ -0,0 +1,133 @@
+// Copyright © 2019 IBM Corp. All rights reserved.
+//
+// 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.
+
+/* global describe it */
+'use strict';
+
+const assert = require('assert');
+
+const TokenManager = require('../../lib/tokens/TokenManager');
+
+class TokenManagerRenewSuccess extends TokenManager {
+  constructor() {
+    super();
+    this._getTokenCallCount = 0;
+  }
+
+  _getToken(callback) {
+    this._getTokenCallCount += 1;
+    setTimeout(() => {
+      callback(null, { headers: { 'set-cookie': [ 'Max-Age=1' ] } });
+    }, 100);
+  }
+
+  // mock successful token renewal
+  get getTokenCallCount() {
+    return this._getTokenCallCount;
+  }
+}
+
+class TokenManagerRenewFailure extends TokenManager {
+  constructor() {
+    super();
+    this._getTokenCallCount = 0;
+  }
+
+  // mock failed token renewal
+  _getToken(callback) {
+    this._getTokenCallCount += 1;
+    setTimeout(() => {
+      callback(new Error('err'), {ok: false});
+    }, 100);
+  }
+
+  get getTokenCallCount() {
+    return this._getTokenCallCount;
+  }
+}
+
+describe('Token Manger', (done) => {
+  it('renews the token successfully', (done) => {
+    let t = new TokenManagerRenewSuccess();
+    t.renewIfRequired().then(() => {
+      assert.equal(t.getTokenCallCount, 1);
+      done();
+    }).catch(done);
+    assert.ok(t.isTokenRenewing);
+  });
+
+  it('handles a token renewal failure', (done) => {
+    let t = new TokenManagerRenewFailure();
+    t.renewIfRequired().then(() => {
+      assert.fail('Unexpected success.');
+    }).catch((error) => {
+      assert.equal(t.getTokenCallCount, 1);
+      assert.equal(error.message, 'err');
+      assert.equal(error.response.ok, false);
+      done();
+    });
+    assert.ok(t.isTokenRenewing);
+  });
+
+  it('correctly auto renews token', (done) => {
+    let t = new TokenManagerRenewSuccess();
+    t.startAutoRenew();
+    setTimeout(() => {
+      // one renew every 0.5 seconds
+      assert.equal(t.getTokenCallCount, 4);
+      done();
+    }, 2000);
+  });
+
+  it('only makes one renewal request', (done) => {
+    let t = new TokenManagerRenewSuccess();
+    let renewalCount = 0;
+    let lim = 10000;
+
+    for (let i = 1; i < lim + 1; i++) {
+      if (i === lim) {
+        t.renewIfRequired().then(() => {
+          renewalCount += 1;
+          assert.equal(renewalCount, lim);
+          assert.equal(t.getTokenCallCount, 1);
+          done();
+        }).catch(done);
+      } else {
+        t.renewIfRequired().then(() => {
+          renewalCount += 1;
+        }).catch(done);
+      }
+    }
+    assert.ok(t.isTokenRenewing);
+  });
+
+  it('makes another renewal only after setting force renew', (done) => {
+    let t = new TokenManagerRenewSuccess();
+    // renew 1 - make request
+    t.renewIfRequired().then(() => {
+      assert.equal(t.getTokenCallCount, 1);
+      // renew 2 - return last good response
+      t.renewIfRequired().then(() => {
+        assert.equal(t.getTokenCallCount, 1);
+        t.attemptTokenRenewal = true;
+        // renew 3 - make request
+        t.renewIfRequired().then(() => {
+          assert.equal(t.getTokenCallCount, 2);
+          done();
+        });
+      });
+    }).catch(done);
+    assert.ok(t.isTokenRenewing);
+  });
+});