@splitsoftware/splitio 10.17.3-rc.2 → 10.17.3

package/src/sync/PushManager/index.js

@@ -0,0 +1,328 @@
+import EventEmitter from 'events';
+import objectAssign from 'object-assign';
+
+import authenticate from '../AuthClient';
+import { checkPushRequirements } from './pushRequirements';
+import SegmentUpdateWorker from '../SegmentUpdateWorker';
+import SplitUpdateWorker from '../SplitUpdateWorker';
+import SSEClient from '../SSEClient';
+import SSEHandlerFactory from '../SSEHandler';
+
+import Backoff from '../../utils/backoff';
+import { hashUserKey } from '../../utils/jwt/hashUserKey';
+import logFactory from '../../utils/logger';
+import { SECONDS_BEFORE_EXPIRATION, PUSH_SUBSYSTEM_DOWN, PUSH_SUBSYSTEM_UP, PUSH_NONRETRYABLE_ERROR, PUSH_RETRYABLE_ERROR, SPLIT_KILL, SPLIT_UPDATE, SEGMENT_UPDATE, MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, ControlTypes } from '../constants';
+import { parseBitmap, parseKeyList, isInBitmap } from './mySegmentsV2utils';
+import { forOwn } from '../../utils/lang';
+import { _Set } from '../../utils/lang/Sets';
+import { hash64 } from '../../engine/engine/murmur3/murmur3_64';
+
+const log = logFactory('splitio-sync:push-manager');
+
+// const UnboundedFetchRequest = 0;
+const BoundedFetchRequest = 1;
+const KeyList = 2;
+const 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.
+ */
+export default function PushManagerFactory(context, clientContexts /* undefined for node */) {
+
+  // No return a PushManager if PUSH mode is not supported.
+  if (!checkPushRequirements(log)) return;
+
+  const pushEmitter = new EventEmitter();
+  const { splits: splitsEventEmitter } = context.get(context.constants.READINESS);
+  const settings = context.get(context.constants.SETTINGS);
+  const storage = context.get(context.constants.STORAGE);
+  const sseClient = SSEClient.getInstance(settings, clientContexts ? false : true);
+  const sseHandler = SSEHandlerFactory(pushEmitter);
+  sseClient.setEventHandler(sseHandler);
+
+  // map of hashes to user keys, to dispatch MY_SEGMENTS_UPDATE events to the corresponding MySegmentsUpdateWorker
+  const 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.
+  const clients = {};
+
+  // variable used on browser to reconnect only when a new client was added, saving some authentication and sse connections.
+  let 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
+  let disconnected;
+
+  /** PushManager functions related to initialization */
+
+  const connectPushRetryBackoff = new Backoff(connectPush, settings.scheduler.pushRetryBackoffBase);
+
+  let timeoutIdTokenRefresh;
+  let 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
+    const decodedToken = authData.decodedToken;
+    const refreshTokenDelay = decodedToken.exp - decodedToken.iat - SECONDS_BEFORE_EXPIRATION;
+    // Default connDelay of 60 secs
+    const 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(() => {
+      // 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;
+
+    const userKeys = clientContexts ? Object.keys(clientContexts) : undefined;
+    authenticate(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(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(PUSH_NONRETRYABLE_ERROR);
+          return;
+        }
+
+        // Handle other HTTP and network errors as recoverable errors
+        pushEmitter.emit(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(PUSH_SUBSYSTEM_DOWN, stopWorkers);
+
+  // Only required when streaming connects after a PUSH_RETRYABLE_ERROR.
+  // Otherwise it is unnecessary (e.g, STREAMING_RESUMED).
+  pushEmitter.on(PUSH_SUBSYSTEM_UP, () => {
+    connectPushRetryBackoff.reset();
+    stopWorkers();
+  });
+
+  /** Fallbacking without retry due to STREAMING_DISABLED control event, 'pushEnabled: false', and non-recoverable SSE and Authentication errors */
+
+  pushEmitter.on(PUSH_NONRETRYABLE_ERROR, function handleNonRetryableError() {
+    // Note: `stopWorkers` is been called twice, but it is not harmful
+    disconnectPush();
+    pushEmitter.emit(PUSH_SUBSYSTEM_DOWN); // no harm if polling already
+  });
+
+  /** Fallbacking with retry due to recoverable SSE and Authentication errors */
+
+  pushEmitter.on(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
+    let delayInMillis = connectPushRetryBackoff.scheduleCall();
+
+    log.info(`Attempting to reconnect in ${delayInMillis / 1000} seconds.`);
+
+    pushEmitter.emit(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(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) */
+
+  const producer = context.get(context.constants.PRODUCER);
+  const splitUpdateWorker = new SplitUpdateWorker(storage.splits, producer, splitsEventEmitter);
+  let 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();
+    forOwn(clients, ({ worker }) => worker.backoff.reset());
+  }
+
+  pushEmitter.on(SPLIT_KILL, splitUpdateWorker.killSplit);
+  pushEmitter.on(SPLIT_UPDATE, splitUpdateWorker.put);
+
+  if (clientContexts) { // browser
+    pushEmitter.on(MY_SEGMENTS_UPDATE, function handleMySegmentsUpdate(parsedData, channel) {
+      const userKeyHash = channel.split('_')[2];
+      const userKey = userKeyHashes[userKeyHash];
+      if (userKey && clientContexts[userKey]) { // check context since it can be undefined if client has been destroyed
+        const 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(MY_SEGMENTS_UPDATE_V2, function handleMySegmentsUpdate(parsedData) {
+      switch (parsedData.u) {
+        case BoundedFetchRequest: {
+          let bitmap;
+          try {
+            bitmap = parseBitmap(parsedData.d, parsedData.c);
+          } catch (e) {
+            log.warn(fallbackWarning('BoundedFetchRequest', e));
+            break;
+          }
+
+          forOwn(clients, ({ hash64, worker }) => {
+            if (isInBitmap(bitmap, hash64.hex)) {
+              worker.put(parsedData.changeNumber); // fetch mySegments
+            }
+          });
+          return;
+        }
+        case KeyList: {
+          let keyList, added, removed;
+          try {
+            keyList = parseKeyList(parsedData.d, parsedData.c);
+            added = new _Set(keyList.a);
+            removed = new _Set(keyList.r);
+          } catch (e) {
+            log.warn(fallbackWarning('KeyList', e));
+            break;
+          }
+
+          forOwn(clients, ({ hash64, worker }) => {
+            const add = added.has(hash64.dec) ? true : removed.has(hash64.dec) ? false : undefined;
+            if (add !== undefined) {
+              worker.put(parsedData.changeNumber, {
+                name: parsedData.segmentName,
+                add
+              });
+            }
+          });
+          return;
+        }
+        case SegmentRemoval:
+          if (!parsedData.segmentName) {
+            log.warn(fallbackWarning('SegmentRemoval', 'No segment name was provided'));
+            break;
+          }
+
+          forOwn(clients, ({ worker }) => {
+            worker.put(parsedData.changeNumber, {
+              name: parsedData.segmentName,
+              add: false
+            });
+          });
+          return;
+      }
+
+      // `UpdateStrategy.UnboundedFetchRequest` and fallbacks of other cases
+      forOwn(clients, ({ worker }) => {
+        worker.put(parsedData.changeNumber);
+      });
+    });
+
+  } else { // node
+    segmentUpdateWorker = new SegmentUpdateWorker(storage.segments, producer);
+    pushEmitter.on(SEGMENT_UPDATE, segmentUpdateWorker.put);
+  }
+
+  return objectAssign(
+    // 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(userKey, context) {
+        const hash = hashUserKey(userKey);
+        const storage = context.get(context.constants.STORAGE);
+        const 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
+        }
+        const mySegmentSync = new SegmentUpdateWorker(storage.segments, producer);
+        clients[userKey] = { worker: mySegmentSync, hash64: 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(userKey) {
+        const hash = hashUserKey(userKey);
+        delete userKeyHashes[hash];
+        delete clients[userKey];
+      }
+    }
+  );
+}

package/src/sync/PushManager/mySegmentsV2utils.js

@@ -0,0 +1,76 @@
+import { algorithms } from '../../utils/decompress';
+import { decodeFromBase64 } from '../../utils/base64';
+
+const GZIP = 1;
+const ZLIB = 2;
+
+function Uint8ArrayToString(myUint8Arr) {
+  return String.fromCharCode.apply(null, myUint8Arr);
+}
+
+function StringToUint8Array(myString) {
+  const charCodes = myString.split('').map((e) => 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) {
+  let compressData = decodeFromBase64(data);
+  const binData = StringToUint8Array(compressData);
+
+  if (typeof algorithms === 'string') throw new Error(algorithms);
+  if (compression === GZIP) return algorithms.gunzipSync(binData);
+  if (compression === ZLIB) return 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
+ */
+export function parseKeyList(data, compression) {
+  const binKeyList = decompress(data, compression);
+  const 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
+ */
+export 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}
+ */
+export function isInBitmap(bitmap, hash64hex) {
+  // using the lowest 32 bits as index, to avoid losing precision when converting to number
+  const index = parseInt(hash64hex.slice(8), 16) % (bitmap.length * 8);
+
+  const internal = Math.floor(index / 8);
+  const offset = index % 8;
+  return (bitmap[internal] & 1 << offset) > 0;
+}

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

@@ -0,0 +1,20 @@
+import getEventSource from '../../../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
+ */
+export function checkPushRequirements(logger) {
+  const esReference = getEventSource();
+  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/src/sync/PushManager/pushRequirements/node.js

@@ -0,0 +1,16 @@
+import getEventSource from '../../../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
+ */
+export function checkPushRequirements(logger) {
+  const esReference = getEventSource();
+  if (!esReference) {
+    logger.warn('EventSource API is not available. Falling back to polling mode.');
+    return false;
+  }
+  return true;
+}

package/src/sync/PushManager/pushRequirements/package.json

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

package/src/sync/SSEClient/index.js

@@ -0,0 +1,92 @@
+import getEventSource from '../../services/getEventSource';
+
+const VERSION = '1.1';
+
+const CONTROL_CHANNEL_REGEX = /^control_/;
+
+/**
+ * Build metadata headers for SSE connection.
+ *
+ * @param {Object} settings Validated settings.
+ */
+function buildSSEHeaders(settings) {
+  const headers = {
+    SplitSDKClientKey: settings.core.authorizationKey.slice(-4),
+    SplitSDKVersion: settings.version,
+  };
+
+  // ip and hostname are false if IPAddressesEnabled is false
+  const { ip, hostname } = settings.runtime;
+  if (ip) headers['SplitSDKMachineIP'] = ip;
+  if (hostname) headers['SplitSDKMachineName'] = hostname;
+
+  return headers;
+}
+
+export default class SSEClient {
+
+  /**
+   * 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.
+   */
+  static getInstance(settings, useHeaders) {
+    const EventSource = getEventSource();
+    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
+
+  constructor(EventSource, settings, useHeaders) {
+    this.EventSource = EventSource;
+    this.streamingUrl = settings.url('/sse');
+    this.useHeaders = useHeaders;
+    this.headers = buildSSEHeaders(settings);
+  }
+
+  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
+   */
+  open(authToken) {
+    this.close(); // it closes connection if previously opened
+
+    const channelsQueryParam = Object.keys(authToken.channels).map(
+      function (channel) {
+        const params = CONTROL_CHANNEL_REGEX.test(channel) ? '[?occupancy=metrics.publishers]' : '';
+        return encodeURIComponent(params + channel);
+      }
+    ).join(',');
+    const 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  */
+  close() {
+    if (this.connection) this.connection.close();
+  }
+}

package/src/sync/SSEHandler/NotificationKeeper.js

@@ -0,0 +1,90 @@
+import { PUSH_SUBSYSTEM_UP, PUSH_SUBSYSTEM_DOWN, PUSH_NONRETRYABLE_ERROR, ControlTypes } from '../constants';
+
+const CONTROL_CHANNEL_REGEXS = [/control_pri$/, /control_sec$/];
+
+export default function notificationKeeperFactory(feedbackLoopEmitter) {
+
+  let channels = CONTROL_CHANNEL_REGEXS.map(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
+  let hasPublishers = true;
+
+  // false if last CONTROL event was STREAMING_PAUSED or STREAMING_DISABLED
+  let hasResumed = true;
+
+  function getHasPublishers() { // computes the value of `hasPublishers`
+    return channels.some(c => c.hasPublishers);
+  }
+
+  return {
+    handleOpen() {
+      feedbackLoopEmitter.emit(PUSH_SUBSYSTEM_UP);
+    },
+
+    isStreamingUp() {
+      return hasResumed && hasPublishers;
+    },
+
+    handleOccupancyEvent(publishers, channel, timestamp) {
+      for (let i = 0; i < channels.length; i++) {
+        const c = channels[i];
+        if (c.regex.test(channel)) {
+          if (timestamp > c.oTime) {
+            c.oTime = timestamp;
+            c.hasPublishers = publishers !== 0;
+            const hasPublishersNow = getHasPublishers();
+            if (hasResumed) {
+              if (!hasPublishersNow && hasPublishers) {
+                feedbackLoopEmitter.emit(PUSH_SUBSYSTEM_DOWN);
+              } else if (hasPublishersNow && !hasPublishers) {
+                feedbackLoopEmitter.emit(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(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 === ControlTypes.STREAMING_RESET) {
+        feedbackLoopEmitter.emit(controlType);
+        return;
+      }
+
+      for (let i = 0; i < channels.length; i++) {
+        const c = channels[i];
+        if (c.regex.test(channel)) {
+          if (timestamp > c.cTime) {
+            c.cTime = timestamp;
+            if (controlType === ControlTypes.STREAMING_DISABLED) {
+              feedbackLoopEmitter.emit(PUSH_NONRETRYABLE_ERROR);
+            } else if (hasPublishers) {
+              if (controlType === ControlTypes.STREAMING_PAUSED && hasResumed) {
+                feedbackLoopEmitter.emit(PUSH_SUBSYSTEM_DOWN);
+              } else if (controlType === ControlTypes.STREAMING_RESUMED && !hasResumed) {
+                feedbackLoopEmitter.emit(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 === ControlTypes.STREAMING_RESUMED;
+          }
+          return;
+        }
+      }
+    },
+
+  };
+}

package/src/sync/SSEHandler/NotificationParser.js

@@ -0,0 +1,35 @@
+import { OCCUPANCY } from '../constants';
+import { isString } from '../../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
+ */
+export function errorParser(error) {
+  if (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
+ */
+export function messageParser(message) {
+  const 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 = OCCUPANCY;
+
+  return messageData;
+}