@splitsoftware/splitio 10.17.3-rc.2 → 10.17.3

package/lib/sync/PushManager/index.js

@@ -0,0 +1,340 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = PushManagerFactory;
+
+var _events = _interopRequireDefault(require("events"));
+
+var _objectAssign = _interopRequireDefault(require("object-assign"));
+
+var _AuthClient = _interopRequireDefault(require("../AuthClient"));
+
+var _pushRequirements = require("./pushRequirements");
+
+var _SegmentUpdateWorker = _interopRequireDefault(require("../SegmentUpdateWorker"));
+
+var _SplitUpdateWorker = _interopRequireDefault(require("../SplitUpdateWorker"));
+
+var _SSEClient = _interopRequireDefault(require("../SSEClient"));
+
+var _SSEHandler = _interopRequireDefault(require("../SSEHandler"));
+
+var _backoff = _interopRequireDefault(require("../../utils/backoff"));
+
+var _hashUserKey = require("../../utils/jwt/hashUserKey");
+
+var _logger = _interopRequireDefault(require("../../utils/logger"));
+
+var _constants = require("../constants");
+
+var _mySegmentsV2utils = require("./mySegmentsV2utils");
+
+var _lang = require("../../utils/lang");
+
+var _Sets = require("../../utils/lang/Sets");
+
+var _murmur3_ = require("../../engine/engine/murmur3/murmur3_64");
+
+var log = (0, _logger.default)('splitio-sync:push-manager'); // const UnboundedFetchRequest = 0;
+
+var BoundedFetchRequest = 1;
+var KeyList = 2;
+var SegmentRemoval = 3;
+
+function fallbackWarning(notificationType, e) {
+  return "Fetching MySegments due to an error processing " + notificationType + " notification: " + e;
+}
+/**
+ * Factory of the push mode manager.
+ *
+ * @param {Object} context context of main client.
+ * @param {Object | undefined} clientContexts map of user keys to client contexts to handle sync of MySegments. undefined for node.
+ */
+
+
+function PushManagerFactory(context, clientContexts
+/* undefined for node */
+) {
+  // No return a PushManager if PUSH mode is not supported.
+  if (!(0, _pushRequirements.checkPushRequirements)(log)) return;
+  var pushEmitter = new _events.default();
+
+  var _context$get = context.get(context.constants.READINESS),
+      splitsEventEmitter = _context$get.splits;
+
+  var settings = context.get(context.constants.SETTINGS);
+  var storage = context.get(context.constants.STORAGE);
+
+  var sseClient = _SSEClient.default.getInstance(settings, clientContexts ? false : true);
+
+  var sseHandler = (0, _SSEHandler.default)(pushEmitter);
+  sseClient.setEventHandler(sseHandler); // map of hashes to user keys, to dispatch MY_SEGMENTS_UPDATE events to the corresponding MySegmentsUpdateWorker
+
+  var userKeyHashes = {}; // map of user keys to their corresponding hash64 and MySegmentsUpdateWorker.
+  // Hash64 is used to process MY_SEGMENTS_UPDATE_V2 events and dispatch actions to the corresponding worker.
+
+  var clients = {}; // variable used on browser to reconnect only when a new client was added, saving some authentication and sse connections.
+
+  var connectForNewClient = false; // flag that indicates if `disconnectPush` was called, either by the SyncManager (when the client is destroyed) or by a PUSH_NONRETRYABLE_ERROR error
+
+  var disconnected;
+  /** PushManager functions related to initialization */
+
+  var connectPushRetryBackoff = new _backoff.default(connectPush, settings.scheduler.pushRetryBackoffBase);
+  var timeoutIdTokenRefresh;
+  var timeoutIdSseOpen;
+
+  function scheduleTokenRefreshAndSse(authData) {
+    // clear scheduled tasks if exist
+    if (timeoutIdTokenRefresh) clearTimeout(timeoutIdTokenRefresh);
+    if (timeoutIdSseOpen) clearTimeout(timeoutIdSseOpen); // Set token refresh 10 minutes before expirationTime - issuedAt
+
+    var decodedToken = authData.decodedToken;
+    var refreshTokenDelay = decodedToken.exp - decodedToken.iat - _constants.SECONDS_BEFORE_EXPIRATION; // Default connDelay of 60 secs
+
+    var connDelay = typeof authData.connDelay === 'number' && authData.connDelay >= 0 ? authData.connDelay : 60;
+    log.info("Refreshing streaming token in " + refreshTokenDelay + " seconds, and connecting streaming in " + connDelay + " seconds");
+    timeoutIdTokenRefresh = setTimeout(connectPush, refreshTokenDelay * 1000);
+    timeoutIdSseOpen = setTimeout(function () {
+      // halt if disconnected
+      if (disconnected) return;
+      sseClient.open(authData);
+    }, connDelay * 1000);
+  }
+
+  function connectPush() {
+    // Halt connecting in case `stop/disconnectPush` has been called
+    if (disconnected) return;
+    log.info((disconnected === undefined ? 'Connecting' : 'Re-connecting') + " to push streaming.");
+    disconnected = false;
+    var userKeys = clientContexts ? Object.keys(clientContexts) : undefined;
+    (0, _AuthClient.default)(settings, userKeys).then(function (authData) {
+      if (disconnected) return; // 'pushEnabled: false' is handled as a PUSH_NONRETRYABLE_ERROR instead of PUSH_SUBSYSTEM_DOWN, in order to
+      // close the sseClient in case the org has been bloqued while the instance was connected to streaming
+
+      if (!authData.pushEnabled) {
+        log.info('Streaming is not available. Switching to polling mode.');
+        pushEmitter.emit(_constants.PUSH_NONRETRYABLE_ERROR);
+        return;
+      } // don't open SSE connection if a new shared client was added, since it means that a new authentication is taking place
+
+
+      if (userKeys && userKeys.length < Object.keys(clientContexts).length) return; // Schedule SSE connection and refresh token
+
+      scheduleTokenRefreshAndSse(authData);
+    }).catch(function (error) {
+      if (disconnected) return;
+      log.error("Failed to authenticate for streaming. Error: " + error.message + "."); // Handle 4XX HTTP errors: 401 (invalid API Key) or 400 (using incorrect API Key, i.e., client-side API Key on server-side)
+
+      if (error.statusCode >= 400 && error.statusCode < 500) {
+        pushEmitter.emit(_constants.PUSH_NONRETRYABLE_ERROR);
+        return;
+      } // Handle other HTTP and network errors as recoverable errors
+
+
+      pushEmitter.emit(_constants.PUSH_RETRYABLE_ERROR);
+    });
+  } // close SSE connection and cancel scheduled tasks
+
+
+  function disconnectPush() {
+    // Halt disconnecting, just to avoid redundant logs if called multiple times
+    if (disconnected) return;
+    disconnected = true;
+    sseClient.close();
+    log.info('Disconnecting from push streaming.');
+    if (timeoutIdTokenRefresh) clearTimeout(timeoutIdTokenRefresh);
+    if (timeoutIdSseOpen) clearTimeout(timeoutIdSseOpen);
+    connectPushRetryBackoff.reset();
+    stopWorkers();
+  }
+
+  pushEmitter.on(_constants.PUSH_SUBSYSTEM_DOWN, stopWorkers); // Only required when streaming connects after a PUSH_RETRYABLE_ERROR.
+  // Otherwise it is unnecessary (e.g, STREAMING_RESUMED).
+
+  pushEmitter.on(_constants.PUSH_SUBSYSTEM_UP, function () {
+    connectPushRetryBackoff.reset();
+    stopWorkers();
+  });
+  /** Fallbacking without retry due to STREAMING_DISABLED control event, 'pushEnabled: false', and non-recoverable SSE and Authentication errors */
+
+  pushEmitter.on(_constants.PUSH_NONRETRYABLE_ERROR, function handleNonRetryableError() {
+    // Note: `stopWorkers` is been called twice, but it is not harmful
+    disconnectPush();
+    pushEmitter.emit(_constants.PUSH_SUBSYSTEM_DOWN); // no harm if polling already
+  });
+  /** Fallbacking with retry due to recoverable SSE and Authentication errors */
+
+  pushEmitter.on(_constants.PUSH_RETRYABLE_ERROR, function handleRetryableError() {
+    // HTTP or network error in SSE connection
+    // SSE connection is closed to avoid repeated errors due to retries
+    sseClient.close(); // retry streaming reconnect with backoff algorithm
+
+    var delayInMillis = connectPushRetryBackoff.scheduleCall();
+    log.info("Attempting to reconnect in " + delayInMillis / 1000 + " seconds.");
+    pushEmitter.emit(_constants.PUSH_SUBSYSTEM_DOWN); // no harm if polling already
+  });
+  /** STREAMING_RESET notification. Unlike a PUSH_RETRYABLE_ERROR, it doesn't emit PUSH_SUBSYSTEM_DOWN to fallback polling */
+
+  pushEmitter.on(_constants.ControlTypes.STREAMING_RESET, function handleStreamingReset() {
+    if (disconnected) return; // should never happen
+    // Minimum required clean-up.
+    // `disconnectPush` cannot be called because it sets `disconnected` and thus `connectPush` will not execute
+
+    if (timeoutIdTokenRefresh) clearTimeout(timeoutIdTokenRefresh);
+    connectPush();
+  });
+  /** Functions related to synchronization (Queues and Workers in the spec) */
+
+  var producer = context.get(context.constants.PRODUCER);
+  var splitUpdateWorker = new _SplitUpdateWorker.default(storage.splits, producer, splitsEventEmitter);
+  var segmentUpdateWorker; // used in Node
+  // cancel scheduled fetch retries of Split, Segment, and MySegment Update Workers
+
+  function stopWorkers() {
+    splitUpdateWorker.backoff.reset();
+    if (segmentUpdateWorker) segmentUpdateWorker.backoff.reset();
+    (0, _lang.forOwn)(clients, function (_ref) {
+      var worker = _ref.worker;
+      return worker.backoff.reset();
+    });
+  }
+
+  pushEmitter.on(_constants.SPLIT_KILL, splitUpdateWorker.killSplit);
+  pushEmitter.on(_constants.SPLIT_UPDATE, splitUpdateWorker.put);
+
+  if (clientContexts) {
+    // browser
+    pushEmitter.on(_constants.MY_SEGMENTS_UPDATE, function handleMySegmentsUpdate(parsedData, channel) {
+      var userKeyHash = channel.split('_')[2];
+      var userKey = userKeyHashes[userKeyHash];
+
+      if (userKey && clientContexts[userKey]) {
+        // check context since it can be undefined if client has been destroyed
+        var mySegmentSync = clientContexts[userKey].get(context.constants.MY_SEGMENTS_CHANGE_WORKER, true);
+        mySegmentSync && mySegmentSync.put(parsedData.changeNumber, parsedData.includesPayload ? parsedData.segmentList ? parsedData.segmentList : [] : undefined);
+      }
+    });
+    pushEmitter.on(_constants.MY_SEGMENTS_UPDATE_V2, function handleMySegmentsUpdate(parsedData) {
+      switch (parsedData.u) {
+        case BoundedFetchRequest:
+          {
+            var bitmap;
+
+            try {
+              bitmap = (0, _mySegmentsV2utils.parseBitmap)(parsedData.d, parsedData.c);
+            } catch (e) {
+              log.warn(fallbackWarning('BoundedFetchRequest', e));
+              break;
+            }
+
+            (0, _lang.forOwn)(clients, function (_ref2) {
+              var hash64 = _ref2.hash64,
+                  worker = _ref2.worker;
+
+              if ((0, _mySegmentsV2utils.isInBitmap)(bitmap, hash64.hex)) {
+                worker.put(parsedData.changeNumber); // fetch mySegments
+              }
+            });
+            return;
+          }
+
+        case KeyList:
+          {
+            var keyList, added, removed;
+
+            try {
+              keyList = (0, _mySegmentsV2utils.parseKeyList)(parsedData.d, parsedData.c);
+              added = new _Sets._Set(keyList.a);
+              removed = new _Sets._Set(keyList.r);
+            } catch (e) {
+              log.warn(fallbackWarning('KeyList', e));
+              break;
+            }
+
+            (0, _lang.forOwn)(clients, function (_ref3) {
+              var hash64 = _ref3.hash64,
+                  worker = _ref3.worker;
+              var add = added.has(hash64.dec) ? true : removed.has(hash64.dec) ? false : undefined;
+
+              if (add !== undefined) {
+                worker.put(parsedData.changeNumber, {
+                  name: parsedData.segmentName,
+                  add: add
+                });
+              }
+            });
+            return;
+          }
+
+        case SegmentRemoval:
+          if (!parsedData.segmentName) {
+            log.warn(fallbackWarning('SegmentRemoval', 'No segment name was provided'));
+            break;
+          }
+
+          (0, _lang.forOwn)(clients, function (_ref4) {
+            var worker = _ref4.worker;
+            worker.put(parsedData.changeNumber, {
+              name: parsedData.segmentName,
+              add: false
+            });
+          });
+          return;
+      } // `UpdateStrategy.UnboundedFetchRequest` and fallbacks of other cases
+
+
+      (0, _lang.forOwn)(clients, function (_ref5) {
+        var worker = _ref5.worker;
+        worker.put(parsedData.changeNumber);
+      });
+    });
+  } else {
+    // node
+    segmentUpdateWorker = new _SegmentUpdateWorker.default(storage.segments, producer);
+    pushEmitter.on(_constants.SEGMENT_UPDATE, segmentUpdateWorker.put);
+  }
+
+  return (0, _objectAssign.default)( // Expose Event Emitter functionality and Event constants
+  Object.create(pushEmitter), {
+    // Expose functionality for starting and stoping push mode:
+    stop: disconnectPush,
+    // `handleNonRetryableError` cannot be used as `stop`, because it emits PUSH_SUBSYSTEM_DOWN event, which start polling.
+    // used in node
+    start: connectPush,
+    // used in browser
+    startNewClient: function startNewClient(userKey, context) {
+      var hash = (0, _hashUserKey.hashUserKey)(userKey);
+      var storage = context.get(context.constants.STORAGE);
+      var producer = context.get(context.constants.PRODUCER);
+
+      if (!userKeyHashes[hash]) {
+        userKeyHashes[hash] = userKey;
+        connectForNewClient = true; // we must reconnect on start, to listen the channel for the new user key
+      }
+
+      var mySegmentSync = new _SegmentUpdateWorker.default(storage.segments, producer);
+      clients[userKey] = {
+        worker: mySegmentSync,
+        hash64: (0, _murmur3_.hash64)(userKey)
+      };
+      context.put(context.constants.MY_SEGMENTS_CHANGE_WORKER, mySegmentSync); // Reconnects in case of a new client.
+      // Run in next event-loop cycle to save authentication calls
+      // in case the user is creating several clients in the current cycle.
+
+      setTimeout(function checkForReconnect() {
+        if (connectForNewClient) {
+          connectForNewClient = false;
+          connectPush();
+        }
+      }, 0);
+    },
+    removeClient: function removeClient(userKey) {
+      var hash = (0, _hashUserKey.hashUserKey)(userKey);
+      delete userKeyHashes[hash];
+      delete clients[userKey];
+    }
+  });
+}

package/lib/sync/PushManager/mySegmentsV2utils.js

@@ -0,0 +1,87 @@
+"use strict";
+
+exports.__esModule = true;
+exports.parseKeyList = parseKeyList;
+exports.parseBitmap = parseBitmap;
+exports.isInBitmap = isInBitmap;
+
+var _decompress = require("../../utils/decompress");
+
+var _base = require("../../utils/base64");
+
+var GZIP = 1;
+var ZLIB = 2;
+
+function Uint8ArrayToString(myUint8Arr) {
+  return String.fromCharCode.apply(null, myUint8Arr);
+}
+
+function StringToUint8Array(myString) {
+  var charCodes = myString.split('').map(function (e) {
+    return e.charCodeAt();
+  });
+  return new Uint8Array(charCodes);
+}
+/**
+ * Decode and decompress 'data' with 'compression' algorithm
+ *
+ * @param {string} data
+ * @param {number} compression 1 GZIP, 2 ZLIB
+ * @returns {Uint8Array}
+ * @throws if data string cannot be decoded, decompressed or the provided compression value is invalid (not 1 or 2)
+ */
+
+
+function decompress(data, compression) {
+  var compressData = (0, _base.decodeFromBase64)(data);
+  var binData = StringToUint8Array(compressData);
+  if (typeof _decompress.algorithms === 'string') throw new Error(_decompress.algorithms);
+  if (compression === GZIP) return _decompress.algorithms.gunzipSync(binData);
+  if (compression === ZLIB) return _decompress.algorithms.unzlibSync(binData);
+  throw new Error("Invalid compression algorithm #" + compression);
+}
+/**
+ * Decode, decompress and parse the provided 'data' into a KeyList object
+ *
+ * @param {string} data
+ * @param {number} compression
+ * @returns {{a?: string[], r?: string[] }}
+ * @throws if data string cannot be decoded, decompressed or parsed
+ */
+
+
+function parseKeyList(data, compression) {
+  var binKeyList = decompress(data, compression);
+  var strKeyList = Uint8ArrayToString(binKeyList); // replace numbers to strings, to avoid losing precision
+
+  return JSON.parse(strKeyList.replace(/\d+/g, '"$&"'));
+}
+/**
+ * Decode, decompress and parse the provided 'data' into a Bitmap object
+ *
+ * @param {string} data
+ * @param {number} compression
+ * @returns {Uint8Array}
+ * @throws if data string cannot be decoded or decompressed
+ */
+
+
+function parseBitmap(data, compression) {
+  return decompress(data, compression);
+}
+/**
+ * Check if the 'bitmap' bit at 'hash64hex' position is 1
+ *
+ * @param {Uint8Array} bitmap
+ * @param {string} hash64hex 16-chars string, representing a number in hexa
+ * @returns {boolean}
+ */
+
+
+function isInBitmap(bitmap, hash64hex) {
+  // using the lowest 32 bits as index, to avoid losing precision when converting to number
+  var index = parseInt(hash64hex.slice(8), 16) % (bitmap.length * 8);
+  var internal = Math.floor(index / 8);
+  var offset = index % 8;
+  return (bitmap[internal] & 1 << offset) > 0;
+}

package/lib/sync/PushManager/pushRequirements/browser.js

@@ -0,0 +1,30 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.checkPushRequirements = checkPushRequirements;
+
+var _browser = _interopRequireDefault(require("../../../services/getEventSource/browser"));
+
+/**
+ * Check if the JS environment has the necessary features to run in PUSH mode,
+ * i.e., EventSource, base64 encoder and decoder.
+ *
+ * @return {boolean} if push is supported
+ */
+function checkPushRequirements(logger) {
+  var esReference = (0, _browser.default)();
+
+  if (!esReference) {
+    logger.warn('EventSource API is not available. Falling back to polling mode.');
+    return false;
+  }
+
+  if (typeof atob !== 'function' || typeof btoa !== 'function') {
+    logger.warn('"atob" and "btoa" functions for Base64 encoding are not available. Falling back to polling mode.');
+    return false;
+  }
+
+  return true;
+}

package/lib/sync/PushManager/pushRequirements/node.js

@@ -0,0 +1,25 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.checkPushRequirements = checkPushRequirements;
+
+var _node = _interopRequireDefault(require("../../../services/getEventSource/node"));
+
+/**
+ * Check if the Node environment has the necessary features to run in PUSH mode,
+ * i.e., EventSource, base64 encoder and decoder.
+ *
+ * @return {boolean} if push is supported
+ */
+function checkPushRequirements(logger) {
+  var esReference = (0, _node.default)();
+
+  if (!esReference) {
+    logger.warn('EventSource API is not available. Falling back to polling mode.');
+    return false;
+  }
+
+  return true;
+}

package/lib/sync/PushManager/pushRequirements/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "./node.js",
+  "browser": "./browser.js"
+}

package/lib/sync/SSEClient/index.js

@@ -0,0 +1,101 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _getEventSource = _interopRequireDefault(require("../../services/getEventSource"));
+
+var VERSION = '1.1';
+var CONTROL_CHANNEL_REGEX = /^control_/;
+/**
+ * Build metadata headers for SSE connection.
+ *
+ * @param {Object} settings Validated settings.
+ */
+
+function buildSSEHeaders(settings) {
+  var headers = {
+    SplitSDKClientKey: settings.core.authorizationKey.slice(-4),
+    SplitSDKVersion: settings.version
+  }; // ip and hostname are false if IPAddressesEnabled is false
+
+  var _settings$runtime = settings.runtime,
+      ip = _settings$runtime.ip,
+      hostname = _settings$runtime.hostname;
+  if (ip) headers['SplitSDKMachineIP'] = ip;
+  if (hostname) headers['SplitSDKMachineName'] = hostname;
+  return headers;
+}
+
+var SSEClient = /*#__PURE__*/function () {
+  /**
+   * Returns a SSEClient instance, or undefined if EventSource is not available.
+   * @param {Object} settings Validated SDK settings.
+   * @param {boolean} useHeaders True for Node and false for Browser, used to send metadata as headers or query params respectively.
+   */
+  SSEClient.getInstance = function getInstance(settings, useHeaders) {
+    var EventSource = (0, _getEventSource.default)();
+    if (EventSource) return new SSEClient(EventSource, settings, useHeaders);
+  } // Instance properties:
+  //  streamingUrl: string
+  //  EventSource: EventSource constructor
+  //  connection: EventSource | undefined
+  //  handler: EventHandler for open, close, error and messages events
+  ;
+
+  function SSEClient(EventSource, settings, useHeaders) {
+    this.EventSource = EventSource;
+    this.streamingUrl = settings.url('/sse');
+    this.useHeaders = useHeaders;
+    this.headers = buildSSEHeaders(settings);
+  }
+
+  var _proto = SSEClient.prototype;
+
+  _proto.setEventHandler = function setEventHandler(handler) {
+    this.handler = handler;
+  }
+  /**
+   * Open the connection with a given authToken
+   *
+   * @param {Object} authToken
+   * @throws {TypeError} Will throw an error if `authToken` is undefined
+   */
+  ;
+
+  _proto.open = function open(authToken) {
+    this.close(); // it closes connection if previously opened
+
+    var channelsQueryParam = Object.keys(authToken.channels).map(function (channel) {
+      var params = CONTROL_CHANNEL_REGEX.test(channel) ? '[?occupancy=metrics.publishers]' : '';
+      return encodeURIComponent(params + channel);
+    }).join(',');
+    var url = this.streamingUrl + "?channels=" + channelsQueryParam + "&accessToken=" + authToken.token + "&v=" + VERSION + "&heartbeats=true"; // same results using `&heartbeats=false`
+
+    this.connection = new this.EventSource( // For Browser, SplitSDKClientKey and SplitSDKClientKey headers are passed as query params,
+    // because native EventSource implementations for browser doesn't support headers.
+    this.useHeaders ? url : url + ("&SplitSDKVersion=" + this.headers.SplitSDKVersion + "&SplitSDKClientKey=" + this.headers.SplitSDKClientKey), // For Node, metadata headers are passed because 'eventsource' package supports them.
+    this.useHeaders ? {
+      headers: this.headers
+    } : undefined);
+
+    if (this.handler) {
+      // no need to check if SSEClient is used only by PushManager
+      this.connection.onopen = this.handler.handleOpen;
+      this.connection.onmessage = this.handler.handleMessage;
+      this.connection.onerror = this.handler.handleError;
+    }
+  }
+  /** Close connection  */
+  ;
+
+  _proto.close = function close() {
+    if (this.connection) this.connection.close();
+  };
+
+  return SSEClient;
+}();
+
+exports.default = SSEClient;