@splitsoftware/splitio 10.17.3-rc.4 → 10.17.4-rc.1

package/src/storage/RedisAdapter.js

@@ -1,170 +0,0 @@
-import ioredis from 'ioredis';
-import { merge, isString } from '../utils/lang';
-import { _Set, setToArray } from '../utils/lang/Sets';
-import thenable from '../utils/promise/thenable';
-import timeout from '../utils/promise/timeout';
-
-import LogFactory from '../utils/logger';
-const log = LogFactory('splitio-storage:redis-adapter');
-
-// If we ever decide to fully wrap every method, there's a Commander.getBuiltinCommands from ioredis.
-const METHODS_TO_PROMISE_WRAP = ['set', 'exec', 'del', 'get', 'keys', 'sadd', 'srem', 'sismember', 'smembers', 'incr', 'rpush', 'pipeline', 'expire', 'mget'];
-
-// Not part of the settings since it'll vary on each storage. We should be removing storage specific logic from elsewhere.
-const DEFAULT_OPTIONS = {
-  connectionTimeout: 10000,
-  operationTimeout: 5000
-};
-// Library specifics.
-const DEFAULT_LIBRARY_OPTIONS = {
-  enableOfflineQueue: false,
-  connectTimeout: DEFAULT_OPTIONS.connectionTimeout,
-  lazyConnect: false
-};
-
-/**
- * Redis adapter on top of the library of choice (written with ioredis) for some extra control.
- */
-export default class RedisAdapter extends ioredis {
-  constructor(storageSettings) {
-    const options = RedisAdapter._defineOptions(storageSettings);
-    // Call the ioredis constructor
-    super(...RedisAdapter._defineLibrarySettings(options));
-
-    this._options = options;
-    this._notReadyCommandsQueue = [];
-    this._runningCommands = new _Set();
-    this._listenToEvents();
-    this._setTimeoutWrappers();
-    this._setDisconnectWrapper();
-  }
-
-  _listenToEvents() {
-    this.once('ready', () => {
-      const commandsCount = this._notReadyCommandsQueue ? this._notReadyCommandsQueue.length : 0;
-      log.info(`Redis connection established. Queued commands: ${commandsCount}.`);
-      commandsCount && this._notReadyCommandsQueue.forEach(queued => {
-        log.info(`Executing queued ${queued.name} command.`);
-        queued.command().then(queued.resolve).catch(queued.reject);
-      });
-      // After the SDK is ready for the first time we'll stop queueing commands. This is just so we can keep handling BUR for them.
-      this._notReadyCommandsQueue = false;
-    });
-    this.once('close', () => {
-      log.info('Redis connection closed.');
-    });
-  }
-
-  _setTimeoutWrappers() {
-    const instance = this;
-
-    METHODS_TO_PROMISE_WRAP.forEach(method => {
-      const originalMethod = instance[method];
-
-      instance[method] = function() {
-        const params = arguments;
-
-        function commandWrapper() {
-          log.debug(`Executing ${method}.`);
-          // Return original method
-          const result = originalMethod.apply(instance, params);
-
-          if (thenable(result)) {
-            // For handling pending commands on disconnect, add to the set and remove once finished.
-            // On sync commands there's no need, only thenables.
-            instance._runningCommands.add(result);
-            const cleanUpRunningCommandsCb = function(res) {
-              instance._runningCommands.delete(result);
-              return res;
-            };
-            // Both success and error remove from queue.
-            result.then(cleanUpRunningCommandsCb, cleanUpRunningCommandsCb);
-
-            return timeout(instance._options.operationTimeout, result).catch(err => {
-              log.error(`${method} operation threw an error or exceeded configured timeout of ${instance._options.operationTimeout}ms. Message: ${err}`);
-              // Handling is not the adapter responsibility.
-              throw err;
-            });
-          }
-
-          return result;
-        }
-
-        if (instance._notReadyCommandsQueue) {
-          return new Promise((res, rej) => {
-            instance._notReadyCommandsQueue.unshift({
-              resolve: res,
-              reject: rej,
-              command: commandWrapper,
-              name: method.toUpperCase()
-            });
-          });
-        } else {
-          return commandWrapper();
-        }
-      };
-    });
-  }
-
-  _setDisconnectWrapper() {
-    const instance = this;
-    const originalMethod = instance.disconnect;
-
-    instance.disconnect = function disconnect() {
-      const params = arguments;
-
-      setTimeout(function deferedDisconnect() {
-        if (instance._runningCommands.size > 0) {
-          log.info(`Attempting to disconnect but there are ${instance._runningCommands.size} commands still waiting for resolution. Defering disconnection until those finish.`);
-
-          Promise.all(setToArray(instance._runningCommands))
-            .then(() => {
-              log.debug('Pending commands finished successfully, disconnecting.');
-              originalMethod.apply(instance, params);
-            })
-            .catch(e => {
-              log.warn(`Pending commands finished with error: ${e}. Proceeding with disconnection.`);
-              originalMethod.apply(instance, params);
-            });
-        } else {
-          log.debug('No commands pending execution, disconnect.');
-          // Nothing pending, just proceed.
-          originalMethod.apply(instance, params);
-        }
-      }, 10);
-    };
-  }
-
-  /**
-   * Receives the options and returns an array of parameters for the ioredis constructor.
-   * Keeping both redis setup options for backwards compatibility.
-   */
-  static _defineLibrarySettings(options) {
-    const opts = merge({}, DEFAULT_LIBRARY_OPTIONS);
-    const result = [opts];
-
-    if (!isString(options.url)) {
-      merge(opts, { // If it's not the string URL, merge the params separately.
-        host: options.host,
-        port: options.port,
-        db: options.db,
-        password: options.pass
-      });
-    } else { // If it IS the string URL, that'll be the first param for ioredis.
-      result.unshift(options.url);
-    }
-
-    return result;
-  }
-
-  /**
-   * Parses the options into what we care about.
-   */
-  static _defineOptions({ connectionTimeout, operationTimeout, url, host, port, db, pass }) {
-    const parsedOptions = {
-      connectionTimeout, operationTimeout, url, host, port, db, pass
-    };
-
-    return merge({}, DEFAULT_OPTIONS, parsedOptions);
-  }
-}

package/src/storage/SegmentCache/InLocalStorage/index.js

@@ -1,140 +0,0 @@
-import logFactory from '../../../utils/logger';
-const log = logFactory('splitio-storage:localstorage');
-
-const DEFINED = '1';
-
-class SegmentCacheInLocalStorage {
-
-  constructor(keys) {
-    this.keys = keys;
-    // There is not need to flush segments cache like splits cache, since resetSegments receives the up-to-date list of active segments
-  }
-
-  addToSegment(segmentName/*, segmentKeys: Array<string>*/) {
-    const segmentKey = this.keys.buildSegmentNameKey(segmentName);
-
-    try {
-      localStorage.setItem(segmentKey, DEFINED);
-      return true;
-    } catch (e) {
-      log.error(e);
-      return false;
-    }
-  }
-
-  removeFromSegment(segmentName/*, segmentKeys: Array<string>*/) {
-    const segmentKey = this.keys.buildSegmentNameKey(segmentName);
-
-    try {
-      localStorage.removeItem(segmentKey);
-      return true;
-    } catch (e) {
-      log.error(e);
-      return false;
-    }
-  }
-
-  /**
-   * Reset (update) the cached list of segments with the given list, removing and adding segments if necessary.
-   *
-   * @param {string[]} segmentNames list of segment names
-   * @returns boolean indicating if the cache was updated (i.e., given list was different from the cached one)
-   */
-  resetSegments(segmentNames) {
-    let isDiff = false;
-    let index;
-
-    // Scan current values from localStorage
-    const storedSegmentNames = Object.keys(localStorage).reduce((accum, key) => {
-      let segmentName = this.keys.extractSegmentName(key);
-
-      if (segmentName) {
-        accum.push(segmentName);
-      } else {
-        // @BREAKING: This is only to clean up "old" keys. Remove this whole else code block.
-        segmentName = this.keys.extractOldSegmentKey(key);
-
-        if (segmentName) { // this was an old segment key, let's clean up.
-          const newSegmentKey = this.keys.buildSegmentNameKey(segmentName);
-          try {
-            // If the new format key is not there, create it.
-            if (!localStorage.getItem(newSegmentKey) && segmentNames.indexOf(segmentName) > -1) {
-              localStorage.setItem(newSegmentKey, DEFINED);
-              // we are migrating a segment, let's track it.
-              accum.push(segmentName);
-            }
-            localStorage.removeItem(key); // we migrated the current key, let's delete it.
-          } catch (e) {
-            log.error(e);
-          }
-        }
-      }
-
-      return accum;
-    }, []);
-
-    // Extreme fast => everything is empty
-    if (segmentNames.length === 0 && storedSegmentNames.length === segmentNames.length)
-      return isDiff;
-
-    // Quick path
-    if (storedSegmentNames.length !== segmentNames.length) {
-      isDiff = true;
-
-      storedSegmentNames.forEach(segmentName => this.removeFromSegment(segmentName));
-      segmentNames.forEach(segmentName => this.addToSegment(segmentName));
-    } else {
-      // Slowest path => we need to find at least 1 difference because
-      for (index = 0; index < segmentNames.length && storedSegmentNames.indexOf(segmentNames[index]) !== -1; index++) {
-        // TODO: why empty statement?
-      }
-
-      if (index < segmentNames.length) {
-        isDiff = true;
-
-        storedSegmentNames.forEach(segmentName => this.removeFromSegment(segmentName));
-        segmentNames.forEach(segmentName => this.addToSegment(segmentName));
-      }
-    }
-
-    return isDiff;
-  }
-
-  isInSegment(segmentName/*, key: string*/) {
-    return localStorage.getItem(this.keys.buildSegmentNameKey(segmentName)) === DEFINED;
-  }
-
-  setChangeNumber(/*segmentName: string, changeNumber: number*/) {
-    return true;
-  }
-
-  getChangeNumber(/*segmentName: string*/) {
-    return -1;
-  }
-
-  registerSegment(/*segment: string*/) {
-    return false;
-  }
-
-  registerSegments(/*segments: Iterable<string>*/) {
-    return false;
-  }
-
-  getRegisteredSegments() {
-    return [];
-  }
-
-  /**
-   * Removes list of segments from localStorage
-   * @NOTE this method is not being used at the moment
-   */
-  flush() {
-    log.info('Flushing MySegments data from localStorage');
-
-    // We cannot simply call `localStorage.clear()` since that implies removing user items from the storage
-    // We could optimize next sentence, since it implies iterating over all localStorage items
-    this.resetSegments([]);
-  }
-}
-
-export default SegmentCacheInLocalStorage;

package/src/storage/SegmentCache/InMemory/browser.js

@@ -1,99 +0,0 @@
-class SegmentCacheInMemory {
-
-  constructor(keys) {
-    this.keys = keys;
-    this.flush();
-  }
-
-  flush() {
-    this.segmentCache = {};
-  }
-
-  addToSegment(segmentName/*, segmentKeys: Array<string>*/) {
-    const segmentKey = this.keys.buildSegmentNameKey(segmentName);
-
-    this.segmentCache[segmentKey] = true;
-
-    return true;
-  }
-
-  removeFromSegment(segmentName/*, segmentKeys: Array<string>*/) {
-    const segmentKey = this.keys.buildSegmentNameKey(segmentName);
-
-    delete this.segmentCache[segmentKey];
-
-    return true;
-  }
-
-  /**
-   * Reset (update) the cached list of segments with the given list, removing and adding segments if necessary.
-   * @NOTE based on the way we use segments in the browser, this way is the best option
-   *
-   * @param {string[]} segmentNames list of segment names
-   * @returns boolean indicating if the cache was updated (i.e., given list was different from the cached one)
-   */
-  resetSegments(segmentNames) {
-    let isDiff = false;
-    let index;
-
-    const storedSegmentKeys = Object.keys(this.segmentCache);
-
-    // Extreme fast => everything is empty
-    if (segmentNames.length === 0 && storedSegmentKeys.length === segmentNames.length)
-      return isDiff;
-
-    // Quick path
-    if (storedSegmentKeys.length !== segmentNames.length) {
-      isDiff = true;
-
-      this.segmentCache = {};
-      segmentNames.forEach (s => {
-        this.addToSegment(s);
-      });
-    } else {
-      // Slowest path => we need to find at least 1 difference because
-      for(index = 0; index < segmentNames.length && this.isInSegment(segmentNames[index]); index++) {
-        // TODO: why empty statement?
-      }
-
-      if (index < segmentNames.length) {
-        isDiff = true;
-
-        this.segmentCache = {};
-        segmentNames.forEach (s => {
-          this.addToSegment(s);
-        });
-      }
-    }
-
-    return isDiff;
-  }
-
-  isInSegment(segmentName/*, key: string*/) {
-    const segmentKey = this.keys.buildSegmentNameKey(segmentName);
-
-    return this.segmentCache[segmentKey] === true;
-  }
-
-  setChangeNumber(/*segmentName: string, changeNumber: number*/) {
-    return true;
-  }
-
-  getChangeNumber(/*segmentName: string*/) {
-    return -1;
-  }
-
-  registerSegment(/*segment: string*/) {
-    return false;
-  }
-
-  registerSegments(/*segments: Iterable<string>*/) {
-    return false;
-  }
-
-  getRegisteredSegments() {
-    return [];
-  }
-}
-
-export default SegmentCacheInMemory;

package/src/storage/SegmentCache/InMemory/node.js

@@ -1,84 +0,0 @@
-import { numberIsInteger } from '../../../utils/lang';
-import { _Set } from '../../../utils/lang/Sets';
-
-class SegmentCacheInMemory {
-
-  constructor(keys) {
-    this.keys = keys;
-    this.flush();
-  }
-
-  addToSegment(segmentName, segmentKeys) {
-    const values = this.segmentCache[segmentName];
-    const keySet = values ? values : new _Set();
-
-    segmentKeys.forEach(k => keySet.add(k));
-
-    this.segmentCache[segmentName] = keySet;
-
-    return true;
-  }
-
-  removeFromSegment(segmentName, segmentKeys) {
-    const values = this.segmentCache[segmentName];
-    const keySet = values ? values : new _Set();
-
-    segmentKeys.forEach(k => keySet.delete(k));
-
-    this.segmentCache[segmentName] = keySet;
-
-    return true;
-  }
-
-  isInSegment(segmentName, key) {
-    const segmentValues = this.segmentCache[segmentName];
-
-    if (segmentValues) {
-      return segmentValues.has(key);
-    }
-
-    return false;
-  }
-
-  registerSegment(segmentName) {
-    if (!this.segmentCache[segmentName]) {
-      this.segmentCache[segmentName] = new _Set();
-    }
-
-    return true;
-  }
-
-  registerSegments(segments) {
-    for (let i = 0; i < segments.length; i++) {
-      this.registerSegment(segments[i]);
-    }
-
-    return true;
-  }
-
-  getRegisteredSegments() {
-    return Object.keys(this.segmentCache);
-  }
-
-  setChangeNumber(segmentName, changeNumber) {
-    const segmentChangeNumberKey = this.keys.buildSegmentTillKey(segmentName);
-
-    this.segmentChangeNumber[segmentChangeNumberKey] = changeNumber;
-
-    return true;
-  }
-
-  getChangeNumber(segmentName) {
-    const segmentChangeNumberKey = this.keys.buildSegmentTillKey(segmentName);
-    const value = this.segmentChangeNumber[segmentChangeNumberKey];
-
-    return numberIsInteger(value) ? value: -1;
-  }
-
-  flush() {
-    this.segmentCache = {};
-    this.segmentChangeNumber = {};
-  }
-}
-
-export default SegmentCacheInMemory;

package/src/storage/SegmentCache/InMemory/package.json

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

package/src/storage/SegmentCache/InRedis/index.js

@@ -1,71 +0,0 @@
-import { numberIsNaN } from '../../../utils/lang';
-
-class SegmentCacheInRedis {
-
-  constructor(keys, redis) {
-    this.redis = redis;
-    this.keys = keys;
-  }
-
-  addToSegment(segmentName, segmentKeys) {
-    const segmentKey = this.keys.buildSegmentNameKey(segmentName);
-
-    if (segmentKeys.length) {
-      return this.redis.sadd(segmentKey, segmentKeys).then(() => true);
-    } else {
-      return Promise.resolve(true);
-    }
-  }
-
-  removeFromSegment(segmentName, segmentKeys) {
-    const segmentKey = this.keys.buildSegmentNameKey(segmentName);
-
-    if (segmentKeys.length) {
-      return this.redis.srem(segmentKey, segmentKeys).then(() => true);
-    } else {
-      return Promise.resolve(true);
-    }
-  }
-
-  isInSegment(segmentName, key) {
-    return this.redis.sismember(
-      this.keys.buildSegmentNameKey(segmentName), key
-    ).then(matches => matches !== 0);
-  }
-
-  setChangeNumber(segmentName, changeNumber) {
-    return this.redis.set(
-      this.keys.buildSegmentTillKey(segmentName), changeNumber + ''
-    ).then(status => status === 'OK');
-  }
-
-  getChangeNumber(segmentName) {
-    return this.redis.get(this.keys.buildSegmentTillKey(segmentName)).then(value => {
-      const i = parseInt(value, 10);
-
-      return numberIsNaN(i) ? -1 : i;
-    });
-  }
-
-  registerSegment(segment) {
-    return this.registerSegments(segment);
-  }
-
-  registerSegments(segments) {
-    if (segments.length) {
-      return this.redis.sadd(this.keys.buildRegisteredSegmentsKey(), segments).then(() => true);
-    } else {
-      return Promise.resolve(true);
-    }
-  }
-
-  getRegisteredSegments() {
-    return this.redis.smembers(this.keys.buildRegisteredSegmentsKey());
-  }
-
-  flush() {
-    return this.redis.flushdb().then(status => status === 'OK');
-  }
-}
-
-export default SegmentCacheInRedis;