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

package/src/producer/browser.js

@@ -0,0 +1,82 @@
+/**
+Copyright 2016 Split Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+**/
+
+import logFactory from '../utils/logger';
+import TaskFactory from './task';
+import SplitChangesUpdater from './updater/SplitChanges';
+import PartialBrowserProducer from './browser/Partial';
+
+const log = logFactory('splitio-producer:updater');
+
+/**
+ * Startup all the background jobs required for a Browser SDK instance.
+ */
+const FullBrowserProducer = (context) => {
+  const settings = context.get(context.constants.SETTINGS);
+
+  const splitsUpdater = SplitChangesUpdater(context);
+
+  const splitsUpdaterTask = TaskFactory(synchronizeSplits, settings.scheduler.featuresRefreshRate);
+
+  const mySegmentsProducer = PartialBrowserProducer(context);
+
+  let isSynchronizingSplits = false;
+
+  /**
+   * @param {boolean | undefined} noCache true to revalidate data to fetch
+   */
+  function synchronizeSplits(noCache) {
+    isSynchronizingSplits = true;
+    // `splitsUpdater` promise always resolves, and with a false value if it fails to fetch or store splits
+    return splitsUpdater(0, noCache).then(function (res) {
+      isSynchronizingSplits = false;
+      return res;
+    });
+  }
+
+  return {
+    // Start periodic fetching (polling)
+    start() {
+      log.info('Starting BROWSER producer');
+
+      splitsUpdaterTask.start();
+      mySegmentsProducer.start();
+    },
+
+    // Stop periodic fetching (polling)
+    stop() {
+      log.info('Stopping BROWSER producer');
+
+      splitsUpdaterTask.stop();
+      mySegmentsProducer.stop();
+    },
+
+    // Used by SyncManager to know if running in polling mode.
+    isRunning: splitsUpdaterTask.isRunning,
+
+    // Used by SplitUpdateWorker
+    isSynchronizingSplits() {
+      return isSynchronizingSplits;
+    },
+    synchronizeSplits,
+
+    // Used by MySegmentUpdateWorker
+    isSynchronizingMySegments: mySegmentsProducer.isSynchronizingMySegments,
+    synchronizeMySegments: mySegmentsProducer.synchronizeMySegments,
+  };
+};
+
+export default FullBrowserProducer;

package/src/producer/fetcher/MySegments.js

@@ -0,0 +1,40 @@
+/**
+Copyright 2016 Split Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+**/
+
+import timeout from '../../utils/promise/timeout';
+import tracker from '../../utils/timeTracker';
+import { SplitError } from '../../utils/lang/Errors';
+import mySegmentsService from '../../services/mySegments';
+import mySegmentsRequest from '../../services/mySegments/get';
+
+const mySegmentsFetcher = (settings, startingUp = false, metricCollectors, noCache) => {
+  let mySegmentsPromise = mySegmentsService(mySegmentsRequest(settings, noCache));
+
+  mySegmentsPromise = tracker.start(tracker.TaskNames.MY_SEGMENTS_FETCH, startingUp ? metricCollectors : false, mySegmentsPromise);
+
+  // Decorate with the timeout functionality if required
+  if (startingUp) {
+    mySegmentsPromise = timeout(settings.startup.requestTimeoutBeforeReady, mySegmentsPromise);
+  }
+
+  // Extract segment names
+  return mySegmentsPromise
+    // JSON parsing errors are handled as SplitErrors, to distinguish from user callback errors
+    .then(resp => resp.json().catch(error => { throw new SplitError(error.message); }))
+    .then(json => json.mySegments.map(segment => segment.name));
+};
+
+export default mySegmentsFetcher;

package/src/producer/fetcher/SegmentChanges.js

@@ -0,0 +1,52 @@
+/**
+Copyright 2016 Split Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+**/
+
+import segmentChangesService from '../../services/segmentChanges';
+import segmentChangesRequest from '../../services/segmentChanges/get';
+import tracker from '../../utils/timeTracker';
+
+function greedyFetch(settings, lastSinceValue, segmentName, metricCollectors, noCache) {
+  return tracker.start(tracker.TaskNames.SEGMENTS_FETCH, metricCollectors, segmentChangesService(segmentChangesRequest(settings, {
+    since: lastSinceValue,
+    segmentName
+  }, noCache)))
+    // no need to handle json parsing errors as SplitError, since errors are handled differently for segments
+    .then(resp => resp.json())
+    .then(json => {
+      let { since, till } = json;
+      if (since === till) {
+        return [json];
+      } else {
+        return Promise.all([json, greedyFetch(settings, till, segmentName, undefined, noCache)]).then(flatMe => {
+          return [flatMe[0], ...flatMe[1]];
+        });
+      }
+    })
+    .catch(err => {
+      // If the operation is forbidden it may be due to permissions, don't recover and propagate the error.
+      if (err.statusCode === 403) throw err;
+      // if something goes wrong with the request to the server, we are going to
+      // stop requesting information till the next round of downloading
+      return [];
+    });
+}
+
+// @TODO migrate to a generator function and do the job incrementally
+function segmentChangesFetcher(settings, segmentName, since, metricCollectors, noCache) {
+  return greedyFetch(settings, since, segmentName, metricCollectors, noCache);
+}
+
+export default segmentChangesFetcher;

package/src/producer/fetcher/SplitChanges.js

@@ -0,0 +1,39 @@
+/**
+Copyright 2016 Split Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+**/
+
+import timeout from '../../utils/promise/timeout';
+import tracker from '../../utils/timeTracker';
+import { SplitError } from '../../utils/lang/Errors';
+import splitChangesService from '../../services/splitChanges';
+import splitChangesRequest from '../../services/splitChanges/get';
+
+function splitChangesFetcher(settings, since, startingUp = false, metricCollectors, isNode, noCache) {
+  const filterQueryString = settings.sync.__splitFiltersValidation.queryString;
+  let splitsPromise = splitChangesService(splitChangesRequest(settings, since, filterQueryString, noCache));
+  const collectMetrics = startingUp || isNode; // If we are on the browser, only collect this metric for first fetch. On node do it always.
+
+  splitsPromise = tracker.start(tracker.TaskNames.SPLITS_FETCH, collectMetrics ? metricCollectors : false, splitsPromise);
+
+  if (startingUp) { // Decorate with the timeout functionality if required
+    splitsPromise = timeout(settings.startup.requestTimeoutBeforeReady, splitsPromise);
+  }
+
+  return splitsPromise
+    // JSON parsing errors are handled as SplitErrors, to distinguish from user callback errors
+    .then(resp => resp.json().catch(error => { throw new SplitError(error.message); }));
+}
+
+export default splitChangesFetcher;

package/src/producer/node.js

@@ -0,0 +1,142 @@
+/**
+Copyright 2016 Split Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+**/
+
+import logFactory from '../utils/logger';
+const log = logFactory('splitio-producer:updater');
+import repeat from '../utils/fn/repeat';
+import SplitChangesUpdater from './updater/SplitChanges';
+import SegmentChangesUpdater from './updater/SegmentChanges';
+
+/**
+ * Expose start / stop mechanism for pulling data from services.
+ */
+const NodeUpdater = (context) => {
+  const splitsUpdater = SplitChangesUpdater(context, true /* tell split updater we are in node */);
+  const segmentsUpdater = SegmentChangesUpdater(context);
+  const settings = context.get(context.constants.SETTINGS);
+
+  let stopSplitsUpdate = false;
+  let stopSegmentsUpdate = false;
+  let splitFetchCompleted = false;
+  let isRunning = false;
+  let isSynchronizingSplits = false;
+  let isSynchronizingSegments = false;
+
+  /**
+   * @param {boolean | undefined} noCache true to revalidate data to fetch
+   */
+  function synchronizeSplits(noCache) {
+    isSynchronizingSplits = true;
+    // `splitsUpdater` promise always resolves, and with a false value if it fails to fetch or store splits
+    return splitsUpdater(0, noCache).then(function (res) {
+      // Mark splits as ready (track first successfull call to start downloading segments)
+      splitFetchCompleted = true;
+      isSynchronizingSplits = false;
+      return res;
+    });
+  }
+
+  /**
+   * @param {string[] | undefined} segmentNames list of segment names to fetch. By passing `undefined` it fetches the list of segments registered at the storage
+   * @param {boolean | undefined} noCache true to revalidate data to fetch on a SEGMENT_UPDATE notifications.
+   * @param {boolean | undefined} fetchOnlyNew if true, only fetch the segments that not exists, i.e., which `changeNumber` is equal to -1.
+   * This param is used by SplitUpdateWorker on server-side SDK, to fetch new registered segments on SPLIT_UPDATE notifications.
+   */
+  function synchronizeSegment(segmentNames, noCache, fetchOnlyNew) {
+    isSynchronizingSegments = true;
+    // `segmentsUpdater` promise always resolves, and with a false value if it fails to fetch or store some segment
+    return segmentsUpdater(segmentNames, noCache, fetchOnlyNew).then(function (res) {
+      isSynchronizingSegments = false;
+      return res;
+    });
+  }
+
+  return {
+    // Start periodic fetching (polling)
+    start() {
+      log.info('Starting NODEJS updater');
+      log.debug(`Splits will be refreshed each ${settings.scheduler.featuresRefreshRate} millis`);
+      log.debug(`Segments will be refreshed each ${settings.scheduler.segmentsRefreshRate} millis`);
+
+      // Schedule incremental update of segments only if needed
+      const spinUpSegmentUpdater = () => {
+        // We must check that Split polling is running (i.e. `stopSplitsUpdate !== false`),
+        // in case that `spinUpSegmentUpdater` is called once the client has been destroyed.
+        if (stopSplitsUpdate && !stopSegmentsUpdate) {
+          stopSegmentsUpdate = repeat(
+            scheduleSegmentsUpdate => {
+              if (splitFetchCompleted) {
+                log.debug('Fetching segments');
+                synchronizeSegment().then(() => scheduleSegmentsUpdate());
+              } else {
+                scheduleSegmentsUpdate();
+              }
+            },
+            settings.scheduler.segmentsRefreshRate
+          );
+        }
+      };
+
+      stopSplitsUpdate = repeat(
+        scheduleSplitsUpdate => {
+          log.debug('Fetching splits');
+
+          synchronizeSplits()
+            .then(() => {
+              // Spin up the segments update if needed
+              spinUpSegmentUpdater();
+              // Re-schedule update
+              scheduleSplitsUpdate();
+            });
+        },
+        settings.scheduler.featuresRefreshRate
+      );
+
+      isRunning = true;
+    },
+
+    // Stop periodic fetching (polling)
+    stop() {
+      log.info('Stopping NODEJS updater');
+
+      stopSplitsUpdate && stopSplitsUpdate();
+      stopSplitsUpdate = false; // Mark polling stopped, to be able to call `start` again and to avoid polling segments if `spinUpSegmentUpdater` is called after the client has been destroyed.
+      stopSegmentsUpdate && stopSegmentsUpdate();
+      stopSegmentsUpdate = false;
+
+      isRunning = false;
+    },
+
+    // Used by SyncManager to know if running in polling mode.
+    isRunning() {
+      return isRunning;
+    },
+
+    // Used by SplitUpdateWorker
+    isSynchronizingSplits() {
+      return isSynchronizingSplits;
+    },
+    synchronizeSplits,
+
+    // Used by SegmentUpdateWorker
+    isSynchronizingSegments() {
+      return isSynchronizingSegments;
+    },
+    synchronizeSegment
+  };
+};
+
+export default NodeUpdater;

package/src/producer/offline/browser.js

@@ -0,0 +1,28 @@
+/**
+Copyright 2016 Split Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+**/
+
+import TaskFactory from '../task';
+import FromFeaturesUpdater from '../updater/SplitChangesFromFeatures';
+
+const OfflineFeatureProducer = (context) => {
+  const settings = context.get(context.constants.SETTINGS);
+  const updater = FromFeaturesUpdater(context);
+  const updaterTask = TaskFactory(updater, settings.scheduler.offlineRefreshRate);
+
+  return updaterTask;
+};
+
+export default OfflineFeatureProducer;

package/src/producer/offline/node.js

@@ -0,0 +1,28 @@
+/**
+Copyright 2016 Split Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+**/
+
+import TaskFactory from '../task';
+import FromFileSystemUpdater from '../updater/SplitChangesFromFileSystem';
+
+const OfflineFileSystemProducer = (context) => {
+  const settings = context.get(context.constants.SETTINGS);
+  const updater = FromFileSystemUpdater(context);
+  const updaterTask = TaskFactory(updater, settings.scheduler.offlineRefreshRate);
+
+  return updaterTask;
+};
+
+export default OfflineFileSystemProducer;

package/src/producer/offline/package.json

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

package/src/producer/package.json

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

package/src/producer/task.js

@@ -0,0 +1,57 @@
+/**
+Copyright 2016 Split Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+**/
+
+import logFactory from '../utils/logger';
+const log = logFactory('splitio-producer:task');
+import repeat from '../utils/fn/repeat';
+import { getFnName } from '../utils/lang';
+
+/**
+ * Startable task factory.
+ */
+const TaskFactory = (updater, period) => {
+  const updaterName = getFnName(updater);
+  let stopUpdater = false;
+
+  return {
+    start() {
+      if (!stopUpdater) {
+        log.debug(`Starting ${updaterName} refreshing each ${period}`);
+
+        stopUpdater = repeat(
+          reschedule => {
+            log.debug(`Running ${updaterName}`);
+            updater().then(() => reschedule());
+          },
+          period
+        );
+      }
+    },
+
+    stop() {
+      log.debug(`Stopping ${updaterName}`);
+
+      stopUpdater && stopUpdater();
+      stopUpdater = false;
+    },
+
+    isRunning() {
+      return stopUpdater ? true : false;
+    }
+  };
+};
+
+export default TaskFactory;

package/src/producer/updater/MySegments.js

@@ -0,0 +1,104 @@
+/**
+Copyright 2016 Split Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+**/
+
+import logFactory from '../../utils/logger';
+import { SplitError } from '../../utils/lang/Errors';
+const log = logFactory('splitio-producer:my-segments');
+import mySegmentsFetcher from '../fetcher/MySegments';
+
+export default function MySegmentsUpdaterFactory(context) {
+  const {
+    [context.constants.SETTINGS]: settings,
+    [context.constants.READINESS]: readiness,
+    [context.constants.STORAGE]: storage,
+    [context.constants.COLLECTORS]: metricCollectors
+  } = context.getAll();
+
+  const segmentsEventEmitter = readiness.segments;
+
+  let readyOnAlreadyExistentState = true;
+  let startingUp = true;
+
+  // @TODO if allowing custom storages, handle async execution and wrap errors as SplitErrors to distinguish from user callback errors
+  function updateSegments(segmentsData) {
+
+    const mySegmentsCache = storage.segments;
+    let shouldNotifyUpdate;
+    if (Array.isArray(segmentsData)) {
+      // Update the list of segment names available
+      shouldNotifyUpdate = mySegmentsCache.resetSegments(segmentsData);
+    } else {
+      // Add/Delete the segment
+      const { name, add } = segmentsData;
+      if (mySegmentsCache.isInSegment(name) !== add) {
+        shouldNotifyUpdate = true;
+        if (add) mySegmentsCache.addToSegment(name);
+        else mySegmentsCache.removeFromSegment(name);
+      } else {
+        shouldNotifyUpdate = false;
+      }
+    }
+
+    // Notify update if required
+    if (storage.splits.usesSegments() && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
+      readyOnAlreadyExistentState = false;
+      segmentsEventEmitter.emit(segmentsEventEmitter.SDK_SEGMENTS_ARRIVED);
+    }
+  }
+
+  /**
+   * MySegments updater returns a promise that resolves with a `false` boolean value if it fails to fetch mySegments or synchronize them with the storage.
+   *
+   * @param {number | undefined} retry current number of retry attemps. this param is only set by SplitChangesUpdater itself.
+   * @param {string[] | { name: string, add: boolean } | undefined} segmentsData it can be:
+   *  (1) the list of segment names to sync in the storage,
+   *  (2) an object with a segment name and action (true: add, or false: delete) to update the storage,
+   *  (3) or `undefined`, for which the updater will fetch mySegments in order to sync the storage.
+   * @param {boolean | undefined} noCache true to revalidate data to fetch
+   */
+  return function MySegmentsUpdater(retry = 0, segmentsData, noCache) {
+    let updaterPromise;
+
+    if (segmentsData) {
+      // If segmentsData is provided, there is no need to fetch mySegments
+      updaterPromise = new Promise((res) => { updateSegments(segmentsData); res(); });
+    } else {
+      // NOTE: We only collect metrics on startup.
+      updaterPromise = mySegmentsFetcher(settings, startingUp, metricCollectors, noCache).then(segments => {
+        // Only when we have downloaded segments completely, we should not keep retrying anymore
+        startingUp = false;
+
+        updateSegments(segments);
+      });
+    }
+
+    return updaterPromise.catch(error => {
+      // handle user callback errors
+      if (!(error instanceof SplitError)) setTimeout(() => { throw error; }, 0);
+
+      if (startingUp && settings.startup.retriesOnFailureBeforeReady > retry) {
+        retry += 1;
+        log.warn(`Retrying download of segments #${retry}. Reason: ${error}`);
+        return MySegmentsUpdater(retry);
+      } else {
+        startingUp = false;
+      }
+
+      return false; // shouldUpdate = false
+    });
+  };
+
+}