@splitsoftware/splitio 10.17.3-rc.2 → 10.17.3

package/lib/sync/SSEHandler/NotificationKeeper.js

@@ -0,0 +1,104 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = notificationKeeperFactory;
+
+var _constants = require("../constants");
+
+var CONTROL_CHANNEL_REGEXS = [/control_pri$/, /control_sec$/];
+
+function notificationKeeperFactory(feedbackLoopEmitter) {
+  var channels = CONTROL_CHANNEL_REGEXS.map(function (regex) {
+    return {
+      regex: regex,
+      hasPublishers: true,
+      // keep track of publishers presence per channel, in order to compute `hasPublishers`. Init with true, to emit PUSH_SUBSYSTEM_UP if initial OCCUPANCY notifications have 0 publishers
+      oTime: -1,
+      // keep track of most recent occupancy notification timestamp per channel
+      cTime: -1 // keep track of most recent control notification timestamp per channel
+
+    };
+  }); // false if the number of publishers is equal to 0 in all regions
+
+  var hasPublishers = true; // false if last CONTROL event was STREAMING_PAUSED or STREAMING_DISABLED
+
+  var hasResumed = true;
+
+  function getHasPublishers() {
+    // computes the value of `hasPublishers`
+    return channels.some(function (c) {
+      return c.hasPublishers;
+    });
+  }
+
+  return {
+    handleOpen: function handleOpen() {
+      feedbackLoopEmitter.emit(_constants.PUSH_SUBSYSTEM_UP);
+    },
+    isStreamingUp: function isStreamingUp() {
+      return hasResumed && hasPublishers;
+    },
+    handleOccupancyEvent: function handleOccupancyEvent(publishers, channel, timestamp) {
+      for (var i = 0; i < channels.length; i++) {
+        var c = channels[i];
+
+        if (c.regex.test(channel)) {
+          if (timestamp > c.oTime) {
+            c.oTime = timestamp;
+            c.hasPublishers = publishers !== 0;
+            var hasPublishersNow = getHasPublishers();
+
+            if (hasResumed) {
+              if (!hasPublishersNow && hasPublishers) {
+                feedbackLoopEmitter.emit(_constants.PUSH_SUBSYSTEM_DOWN);
+              } else if (hasPublishersNow && !hasPublishers) {
+                feedbackLoopEmitter.emit(_constants.PUSH_SUBSYSTEM_UP);
+              } // nothing to do when hasResumed === false:
+              // streaming is already down for `!hasPublishersNow`, and cannot be up for `hasPublishersNow`
+
+            }
+
+            hasPublishers = hasPublishersNow;
+          }
+
+          return;
+        }
+      }
+    },
+    handleControlEvent: function handleControlEvent(controlType, channel, timestamp) {
+      /* STREAMING_RESET event is handled by PushManager directly since it doesn't require
+       * tracking timestamp and state like OCCUPANCY or CONTROL. It also ignores previous
+       * OCCUPANCY and CONTROL notifications, and whether PUSH_SUBSYSTEM_DOWN has been emitted or not */
+      if (controlType === _constants.ControlTypes.STREAMING_RESET) {
+        feedbackLoopEmitter.emit(controlType);
+        return;
+      }
+
+      for (var i = 0; i < channels.length; i++) {
+        var c = channels[i];
+
+        if (c.regex.test(channel)) {
+          if (timestamp > c.cTime) {
+            c.cTime = timestamp;
+
+            if (controlType === _constants.ControlTypes.STREAMING_DISABLED) {
+              feedbackLoopEmitter.emit(_constants.PUSH_NONRETRYABLE_ERROR);
+            } else if (hasPublishers) {
+              if (controlType === _constants.ControlTypes.STREAMING_PAUSED && hasResumed) {
+                feedbackLoopEmitter.emit(_constants.PUSH_SUBSYSTEM_DOWN);
+              } else if (controlType === _constants.ControlTypes.STREAMING_RESUMED && !hasResumed) {
+                feedbackLoopEmitter.emit(_constants.PUSH_SUBSYSTEM_UP);
+              } // nothing to do when hasPublishers === false:
+              // streaming is already down for `STREAMING_PAUSED`, and cannot be up for `STREAMING_RESUMED`
+
+            }
+
+            hasResumed = controlType === _constants.ControlTypes.STREAMING_RESUMED;
+          }
+
+          return;
+        }
+      }
+    }
+  };
+}

package/lib/sync/SSEHandler/NotificationParser.js

@@ -0,0 +1,39 @@
+"use strict";
+
+exports.__esModule = true;
+exports.errorParser = errorParser;
+exports.messageParser = messageParser;
+
+var _constants = require("../constants");
+
+var _lang = require("../../utils/lang");
+
+/**
+ * Parses the `data` JSON string, if exists, of a given SSE error notifications.
+ * HTTP errors handled by Ably (e.g., 400 due to invalid token, 401 due to expired token, 500) have the `data` property.
+ * Other network and HTTP errors do not have this property.
+ *
+ * @param {Object} error
+ * @throws {SyntaxError} if `error.data` is an invalid JSON string
+ */
+function errorParser(error) {
+  if ((0, _lang.isString)(error.data)) error.parsedData = JSON.parse(error.data); // cannot assign to read only property 'data'
+
+  return error;
+}
+/**
+ * Parses the `data` JSON string of a given SSE message notifications.
+ * Also assigns the type OCCUPANCY, if it corresponds, so that all supported messages (e.g., SPLIT_UPDATE, CONTROL) have a type.
+ *
+ * @param {Object} message
+ * @throws {SyntaxError} if `message.data` or `JSON.parse(message.data).data` are invalid JSON strings
+ */
+
+
+function messageParser(message) {
+  var messageData = JSON.parse(message.data);
+  messageData.parsedData = JSON.parse(messageData.data); // set the event type to OCCUPANCY, to handle all events uniformely
+
+  if (messageData.name && messageData.name === '[meta]occupancy') messageData.parsedData.type = _constants.OCCUPANCY;
+  return messageData;
+}

package/lib/sync/SSEHandler/index.js

@@ -0,0 +1,121 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = SSEHandlerFactory;
+
+var _NotificationParser = require("./NotificationParser");
+
+var _NotificationKeeper = _interopRequireDefault(require("./NotificationKeeper"));
+
+var _constants = require("../constants");
+
+var _logger = _interopRequireDefault(require("../../utils/logger"));
+
+var log = (0, _logger.default)('splitio-sync:sse-handler');
+
+function isRetryableError(error) {
+  if (error.parsedData && error.parsedData.code) {
+    var code = error.parsedData.code; // 401 errors due to invalid or expired token (e.g., if refresh token coudn't be executed)
+
+    if (40140 <= code && code <= 40149) return true; // Others 4XX errors (e.g., bad request from the SDK)
+
+    if (40000 <= code && code <= 49999) return false;
+  } // network errors or 5XX HTTP errors
+
+
+  return true;
+}
+/**
+ * Factory for SSEHandler
+ *
+ * @param {Object} pushEmitter emitter for emitting events related to feedback-loop & update queues
+ */
+
+
+function SSEHandlerFactory(pushEmitter) {
+  var notificationKeeper = (0, _NotificationKeeper.default)(pushEmitter);
+  return {
+    handleOpen: function handleOpen() {
+      notificationKeeper.handleOpen();
+    },
+
+    /* HTTP & Network errors */
+    handleError: function handleError(error) {
+      var errorWithParsedData = error;
+
+      try {
+        errorWithParsedData = (0, _NotificationParser.errorParser)(error);
+      } catch (err) {
+        log.warn("Error parsing SSE error notification: " + err);
+      }
+
+      var errorMessage = errorWithParsedData.parsedData && errorWithParsedData.parsedData.message;
+      log.error("Fail to connect to streaming" + (errorMessage ? ", with error message: \"" + errorMessage + "\"" : ''));
+
+      if (isRetryableError(errorWithParsedData)) {
+        pushEmitter.emit(_constants.PUSH_RETRYABLE_ERROR);
+      } else {
+        pushEmitter.emit(_constants.PUSH_NONRETRYABLE_ERROR);
+      }
+    },
+
+    /* NotificationProcessor */
+    handleMessage: function handleMessage(message) {
+      var messageWithParsedData;
+
+      try {
+        messageWithParsedData = (0, _NotificationParser.messageParser)(message);
+      } catch (err) {
+        log.warn("Error parsing new SSE message notification: " + err);
+        return;
+      }
+
+      var _messageWithParsedDat = messageWithParsedData,
+          parsedData = _messageWithParsedDat.parsedData,
+          data = _messageWithParsedDat.data,
+          channel = _messageWithParsedDat.channel,
+          timestamp = _messageWithParsedDat.timestamp;
+      log.debug("New SSE message received, with data: " + data + "."); // we only handle update events if streaming is up.
+
+      if (!notificationKeeper.isStreamingUp() && [_constants.OCCUPANCY, _constants.CONTROL].indexOf(parsedData.type) === -1) return;
+
+      switch (parsedData.type) {
+        /* update events */
+        case _constants.SPLIT_UPDATE:
+          pushEmitter.emit(_constants.SPLIT_UPDATE, parsedData.changeNumber);
+          break;
+
+        case _constants.SEGMENT_UPDATE:
+          pushEmitter.emit(_constants.SEGMENT_UPDATE, parsedData.changeNumber, parsedData.segmentName);
+          break;
+
+        case _constants.MY_SEGMENTS_UPDATE:
+          pushEmitter.emit(_constants.MY_SEGMENTS_UPDATE, parsedData, channel);
+          break;
+
+        case _constants.MY_SEGMENTS_UPDATE_V2:
+          pushEmitter.emit(_constants.MY_SEGMENTS_UPDATE_V2, parsedData);
+          break;
+
+        case _constants.SPLIT_KILL:
+          pushEmitter.emit(_constants.SPLIT_KILL, parsedData.changeNumber, parsedData.splitName, parsedData.defaultTreatment);
+          break;
+
+        /* occupancy & control events, handled by NotificationManagerKeeper */
+
+        case _constants.OCCUPANCY:
+          notificationKeeper.handleOccupancyEvent(parsedData.metrics.publishers, channel, timestamp);
+          break;
+
+        case _constants.CONTROL:
+          notificationKeeper.handleControlEvent(parsedData.controlType, channel, timestamp);
+          break;
+
+        default:
+          break;
+      }
+    }
+  };
+}

package/lib/sync/SegmentUpdateWorker/browser.js

@@ -0,0 +1,81 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _backoff = _interopRequireDefault(require("../../utils/backoff"));
+
+/**
+ * MySegmentUpdateWorker class
+ */
+var MySegmentUpdateWorker = /*#__PURE__*/function () {
+  /**
+   *
+   * @param {Object} mySegmentsStorage
+   * @param {Object} mySegmentsProducer
+   */
+  function MySegmentUpdateWorker(mySegmentsStorage, mySegmentsProducer) {
+    this.mySegmentsStorage = mySegmentsStorage;
+    this.mySegmentsProducer = mySegmentsProducer;
+    this.maxChangeNumber = 0; // keeps the maximum changeNumber among queued events
+
+    this.segmentsData = undefined; // keeps the segmentsData (if included in notification payload) from the queued event with maximum changeNumber
+
+    this.currentChangeNumber = -1; // @TODO: remove once `/mySegments` endpoint provides the changeNumber
+
+    this.put = this.put.bind(this);
+    this.__handleMySegmentUpdateCall = this.__handleMySegmentUpdateCall.bind(this);
+    this.backoff = new _backoff.default(this.__handleMySegmentUpdateCall);
+  } // Private method
+  // Preconditions: this.mySegmentsProducer.isSynchronizingMySegments === false
+  // @TODO update this block similar to SplitUpdateWorker, once `/mySegments` endpoint provides the changeNumber
+
+
+  var _proto = MySegmentUpdateWorker.prototype;
+
+  _proto.__handleMySegmentUpdateCall = function __handleMySegmentUpdateCall() {
+    var _this = this;
+
+    if (this.maxChangeNumber > this.currentChangeNumber) {
+      this.handleNewEvent = false;
+      var currentMaxChangeNumber = this.maxChangeNumber; // fetch mySegments revalidating data if cached
+
+      this.mySegmentsProducer.synchronizeMySegments(this.segmentsData, true).then(function (result) {
+        if (result !== false) // Unlike `Split\SegmentUpdateWorker`, we cannot use `mySegmentsStorage.getChangeNumber` since `/mySegments` endpoint doesn't provide this value.
+          _this.currentChangeNumber = Math.max(_this.currentChangeNumber, currentMaxChangeNumber); // use `currentMaxChangeNumber`, in case that `this.maxChangeNumber` was updated during fetch.
+
+        if (_this.handleNewEvent) {
+          _this.__handleMySegmentUpdateCall();
+        } else {
+          _this.backoff.scheduleCall();
+        }
+      });
+    }
+  }
+  /**
+   * Invoked by NotificationProcessor on MY_SEGMENTS_UPDATE event
+   *
+   * @param {number} changeNumber change number of the MY_SEGMENTS_UPDATE notification
+   * @param {string[] | { name: string, add: boolean } | undefined} segmentsData might be undefined
+   */
+  ;
+
+  _proto.put = function put(changeNumber, segmentsData) {
+    // @TODO uncomment next line once `/mySegments` endpoint provides the changeNumber
+    // const currentChangeNumber = this.mySegmentsStorage.getChangeNumber();
+    if (changeNumber <= this.currentChangeNumber || changeNumber <= this.maxChangeNumber) return;
+    this.maxChangeNumber = changeNumber;
+    this.handleNewEvent = true;
+    this.backoff.reset();
+    this.segmentsData = segmentsData;
+    if (this.mySegmentsProducer.isSynchronizingMySegments()) return;
+
+    this.__handleMySegmentUpdateCall();
+  };
+
+  return MySegmentUpdateWorker;
+}();
+
+exports.default = MySegmentUpdateWorker;

package/lib/sync/SegmentUpdateWorker/node.js

@@ -0,0 +1,86 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _backoff = _interopRequireDefault(require("../../utils/backoff"));
+
+/**
+ * SegmentUpdateWorker class
+ */
+var SegmentUpdateWorker = /*#__PURE__*/function () {
+  /**
+   * @param {Object} segmentsStorage
+   * @param {Object} segmentsProducer
+   */
+  function SegmentUpdateWorker(segmentsStorage, segmentsProducer) {
+    this.segmentsStorage = segmentsStorage;
+    this.segmentsProducer = segmentsProducer;
+    this.maxChangeNumbers = {};
+    this.put = this.put.bind(this);
+    this.__handleSegmentUpdateCall = this.__handleSegmentUpdateCall.bind(this);
+    this.backoff = new _backoff.default(this.__handleSegmentUpdateCall);
+  } // Private method
+  // Preconditions: this.segmentsProducer.isSynchronizingSegments === false
+  // Approach similar to MySegmentUpdateWorker due to differences on Segments notifications and endpoint changeNumbers
+
+
+  var _proto = SegmentUpdateWorker.prototype;
+
+  _proto.__handleSegmentUpdateCall = function __handleSegmentUpdateCall() {
+    var _this = this;
+
+    var segmentsToFetch = Object.keys(this.maxChangeNumbers).filter(function (segmentName) {
+      return _this.maxChangeNumbers[segmentName] > _this.segmentsStorage.getChangeNumber(segmentName);
+    });
+
+    if (segmentsToFetch.length > 0) {
+      this.handleNewEvent = false;
+      var currentMaxChangeNumbers = segmentsToFetch.map(function (segmentToFetch) {
+        return _this.maxChangeNumbers[segmentToFetch];
+      }); // fetch segments revalidating data if cached
+
+      this.segmentsProducer.synchronizeSegment(segmentsToFetch, true).then(function (result) {
+        // Unlike `SplitUpdateWorker` where changeNumber is consistent between notification and endpoint, if there is no error,
+        // we must clean the `maxChangeNumbers` of those segments that didn't receive a new update notification during the fetch.
+        if (result !== false) {
+          segmentsToFetch.forEach(function (fetchedSegment, index) {
+            if (_this.maxChangeNumbers[fetchedSegment] === currentMaxChangeNumbers[index]) _this.maxChangeNumbers[fetchedSegment] = -1;
+          });
+        } else {
+          // recursive invocation with backoff if there was some error
+          _this.backoff.scheduleCall();
+        } // immediate recursive invocation if a new notification was queued during fetch
+
+
+        if (_this.handleNewEvent) {
+          _this.__handleSegmentUpdateCall();
+        }
+      });
+    }
+  }
+  /**
+   * Invoked by NotificationProcessor on SEGMENT_UPDATE event
+   *
+   * @param {number} changeNumber change number of the SEGMENT_UPDATE notification
+   * @param {string} segmentName segment name of the SEGMENT_UPDATE notification
+   */
+  ;
+
+  _proto.put = function put(changeNumber, segmentName) {
+    var currentChangeNumber = this.segmentsStorage.getChangeNumber(segmentName);
+    if (changeNumber <= currentChangeNumber || changeNumber <= this.maxChangeNumbers[segmentName]) return;
+    this.maxChangeNumbers[segmentName] = changeNumber;
+    this.handleNewEvent = true;
+    this.backoff.reset();
+    if (this.segmentsProducer.isSynchronizingSegments()) return;
+
+    this.__handleSegmentUpdateCall();
+  };
+
+  return SegmentUpdateWorker;
+}();
+
+exports.default = SegmentUpdateWorker;

package/lib/sync/SegmentUpdateWorker/package.json

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

package/lib/sync/SplitUpdateWorker/index.js

@@ -0,0 +1,93 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _backoff = _interopRequireDefault(require("../../utils/backoff"));
+
+/**
+ * SplitUpdateWorker class
+ */
+var SplitUpdateWorker = /*#__PURE__*/function () {
+  /**
+   * @param {Object} splitStorage splits cache
+   * @param {Object} splitProducer node producer or full browser producer
+   * @param {Object} splitsEventEmitter
+   */
+  function SplitUpdateWorker(splitStorage, splitProducer, splitsEventEmitter) {
+    this.splitStorage = splitStorage;
+    this.splitProducer = splitProducer;
+    this.maxChangeNumber = 0;
+    this.splitsEventEmitter = splitsEventEmitter;
+    this.put = this.put.bind(this);
+    this.killSplit = this.killSplit.bind(this);
+    this.__handleSplitUpdateCall = this.__handleSplitUpdateCall.bind(this);
+    this.backoff = new _backoff.default(this.__handleSplitUpdateCall);
+  } // Private method
+  // Preconditions: this.splitProducer.isSynchronizingSplits === false
+
+
+  var _proto = SplitUpdateWorker.prototype;
+
+  _proto.__handleSplitUpdateCall = function __handleSplitUpdateCall() {
+    var _this = this;
+
+    if (this.maxChangeNumber > this.splitStorage.getChangeNumber()) {
+      this.handleNewEvent = false; // fetch splits revalidating data if cached
+
+      this.splitProducer.synchronizeSplits(true).then(function () {
+        if (_this.handleNewEvent) {
+          _this.__handleSplitUpdateCall();
+        } else {
+          // fetch new registered segments for server-side API. Not retrying on error
+          if (_this.splitProducer.synchronizeSegment) _this.splitProducer.synchronizeSegment(undefined, false, true);
+
+          _this.backoff.scheduleCall();
+        }
+      });
+    }
+  }
+  /**
+   * Invoked by NotificationProcessor on SPLIT_UPDATE event
+   *
+   * @param {number} changeNumber change number of the SPLIT_UPDATE notification
+   */
+  ;
+
+  _proto.put = function put(changeNumber) {
+    var currentChangeNumber = this.splitStorage.getChangeNumber();
+    if (changeNumber <= currentChangeNumber || changeNumber <= this.maxChangeNumber) return;
+    this.maxChangeNumber = changeNumber;
+    this.handleNewEvent = true;
+    this.backoff.reset();
+    if (this.splitProducer.isSynchronizingSplits()) return;
+
+    this.__handleSplitUpdateCall();
+  }
+  /**
+   * Invoked by NotificationProcessor on SPLIT_KILL event
+   *
+   * @param {number} changeNumber change number of the SPLIT_UPDATE notification
+   * @param {string} splitName name of split to kill
+   * @param {string} defaultTreatment default treatment value
+   */
+  ;
+
+  _proto.killSplit = function killSplit(changeNumber, splitName, defaultTreatment) {
+    var _this2 = this;
+
+    // @TODO handle retry due to errors in storage, once we allow the definition of custom async storages
+    this.splitStorage.killLocally(splitName, defaultTreatment, changeNumber).then(function (updated) {
+      // trigger an SDK_UPDATE if Split was killed locally
+      if (updated) _this2.splitsEventEmitter.emit(_this2.splitsEventEmitter.SDK_SPLITS_ARRIVED, true); // queues the SplitChanges fetch (only if changeNumber is newer)
+
+      _this2.put(changeNumber);
+    });
+  };
+
+  return SplitUpdateWorker;
+}();
+
+exports.default = SplitUpdateWorker;

package/lib/sync/browser.js

@@ -0,0 +1,139 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = BrowserSyncManagerFactory;
+
+var _PushManager = _interopRequireDefault(require("./PushManager"));
+
+var _producer = _interopRequireDefault(require("../producer"));
+
+var _Partial = _interopRequireDefault(require("../producer/browser/Partial"));
+
+var _factory = require("../utils/key/factory");
+
+var _lang = require("../utils/lang");
+
+var _logger = _interopRequireDefault(require("../utils/logger"));
+
+var _constants = require("./constants");
+
+var log = (0, _logger.default)('splitio-sync:sync-manager');
+/**
+ * Factory of sync manager for browser
+ *
+ * @param context main client context
+ */
+
+function BrowserSyncManagerFactory(mainContext) {
+  // map of user keys to client contexts
+  var contexts = {};
+  var settings = mainContext.get(mainContext.constants.SETTINGS); // call `createInstance` before creating PushManager, since it is in charge of creating the full producer and adding it into the main context.
+
+  var syncManager = createInstance(false, mainContext);
+  var pushManager = settings.streamingEnabled ? (0, _PushManager.default)(mainContext, contexts) : undefined;
+  var mainProducer = mainContext.get(mainContext.constants.PRODUCER);
+
+  function startPolling() {
+    if (!mainProducer.isRunning()) {
+      log.info('Streaming not available. Starting periodic fetch of data.');
+      (0, _lang.forOwn)(contexts, function (context) {
+        var producer = context.get(context.constants.PRODUCER);
+        producer.start();
+      });
+    } else {
+      log.info('Streaming couldn\'t connect. Continue periodic fetch of data.');
+    }
+  }
+
+  function stopPollingAndSyncAll() {
+    if (mainProducer.isRunning()) {
+      log.info('PUSH (re)connected. Syncing and stopping periodic fetch of data.'); // if polling, stop
+
+      (0, _lang.forOwn)(contexts, function (context) {
+        var producer = context.get(context.constants.PRODUCER);
+        producer.stop();
+      });
+    }
+
+    syncAll();
+  }
+
+  function syncAll() {
+    // fetch splits and segments
+    var mainProducer = mainContext.get(mainContext.constants.PRODUCER);
+    mainProducer.synchronizeSplits();
+    (0, _lang.forOwn)(contexts, function (context) {
+      var producer = context.get(context.constants.PRODUCER);
+      producer.synchronizeMySegments();
+    });
+  }
+  /**
+   * Creates a SyncManager that handles the synchronization of clients (main and shared ones).
+   * Internally, it creates the client producer, adds it into its context, and defines the `start` and `stop` methods that handle synchronization.
+   *
+   * @param {Object} context
+   * @param {boolean} isSharedClient
+   */
+
+
+  function createInstance(isSharedClient, context) {
+    var producer = isSharedClient ? (0, _Partial.default)(context) : (0, _producer.default)(context);
+    var settings = context.get(context.constants.SETTINGS); // we need to stringify the user key (or matching key) in case it is not an string, to hash and pass as query param for authentication
+
+    var userKey = (0, _lang.toString)((0, _factory.matching)(settings.core.key));
+    context.put(context.constants.PRODUCER, producer);
+    if (contexts[userKey]) log.warn('A client with the same user key has already been created. Only the new instance will be properly synchronized.');
+    contexts[userKey] = context;
+    return {
+      start: function start() {
+        // start syncing
+        if (pushManager) {
+          if (!isSharedClient) {
+            syncAll(); // initial syncAll (only when main client is created)
+
+            pushManager.on(_constants.PUSH_SUBSYSTEM_UP, stopPollingAndSyncAll);
+            pushManager.on(_constants.PUSH_SUBSYSTEM_DOWN, startPolling);
+          } else {
+            if (mainProducer.isRunning()) {
+              // if doing polling, we must start the producer periodic fetch of data
+              producer.start();
+            } else {
+              // if not doing polling, we must perform a `producer.synchronizeMySegments` for the initial fetch
+              // of segments since `syncAll` was already executed when starting the main client
+              producer.synchronizeMySegments();
+            }
+          }
+
+          pushManager.startNewClient(userKey, context);
+        } else {
+          producer.start();
+        }
+      },
+      stop: function stop() {
+        var context = contexts[userKey];
+
+        if (context) {
+          // check in case `client.destroy()` has been invoked more than once for the same client
+          delete contexts[userKey];
+
+          if (pushManager) {
+            pushManager.removeClient(userKey); // stop push if stoping main client
+
+            if (!isSharedClient) pushManager.stop(); // We don't reconnect pushmanager when removing a shared client,
+            // since it is more costly than continue listening the channel
+          }
+
+          if (producer.isRunning()) producer.stop();
+        }
+      }
+    };
+  } // For the main client we return a SyncManager with 3 methods: start, stop and shared. The last is used to instantiate "partial SyncManagers".
+
+
+  syncManager.shared = createInstance.bind(null, true); // pushManager is exposed to close SSE connection in browser on 'unload' DOM event.
+
+  syncManager.pushManager = pushManager;
+  return syncManager;
+}