@cendarsoss/pusher-js 8.4.11

package/src/core/strategies/sequential_strategy.ts

@@ -0,0 +1,129 @@
+import * as Collections from '../utils/collections';
+import Util from '../util';
+import { OneOffTimer as Timer } from '../utils/timers';
+import Strategy from './strategy';
+import StrategyOptions from './strategy_options';
+
+/** Loops through strategies with optional timeouts.
+ *
+ * Options:
+ * - loop - whether it should loop through the substrategy list
+ * - timeout - initial timeout for a single substrategy
+ * - timeoutLimit - maximum timeout
+ *
+ * @param {Strategy[]} strategies
+ * @param {Object} options
+ */
+export default class SequentialStrategy implements Strategy {
+  strategies: Strategy[];
+  loop: boolean;
+  failFast: boolean;
+  timeout: number;
+  timeoutLimit: number;
+
+  constructor(strategies: Strategy[], options: StrategyOptions) {
+    this.strategies = strategies;
+    this.loop = Boolean(options.loop);
+    this.failFast = Boolean(options.failFast);
+    this.timeout = options.timeout;
+    this.timeoutLimit = options.timeoutLimit;
+  }
+
+  isSupported(): boolean {
+    return Collections.any(this.strategies, Util.method('isSupported'));
+  }
+
+  connect(minPriority: number, callback: Function) {
+    var strategies = this.strategies;
+    var current = 0;
+    var timeout = this.timeout;
+    var runner = null;
+
+    var tryNextStrategy = (error, handshake) => {
+      if (handshake) {
+        callback(null, handshake);
+      } else {
+        current = current + 1;
+        if (this.loop) {
+          current = current % strategies.length;
+        }
+
+        if (current < strategies.length) {
+          if (timeout) {
+            timeout = timeout * 2;
+            if (this.timeoutLimit) {
+              timeout = Math.min(timeout, this.timeoutLimit);
+            }
+          }
+          runner = this.tryStrategy(
+            strategies[current],
+            minPriority,
+            { timeout, failFast: this.failFast },
+            tryNextStrategy,
+          );
+        } else {
+          callback(true);
+        }
+      }
+    };
+
+    runner = this.tryStrategy(
+      strategies[current],
+      minPriority,
+      { timeout: timeout, failFast: this.failFast },
+      tryNextStrategy,
+    );
+
+    return {
+      abort: function () {
+        runner.abort();
+      },
+      forceMinPriority: function (p) {
+        minPriority = p;
+        if (runner) {
+          runner.forceMinPriority(p);
+        }
+      },
+    };
+  }
+
+  private tryStrategy(
+    strategy: Strategy,
+    minPriority: number,
+    options: StrategyOptions,
+    callback: Function,
+  ) {
+    var timer = null;
+    var runner = null;
+
+    if (options.timeout > 0) {
+      timer = new Timer(options.timeout, function () {
+        runner.abort();
+        callback(true);
+      });
+    }
+
+    runner = strategy.connect(minPriority, function (error, handshake) {
+      if (error && timer && timer.isRunning() && !options.failFast) {
+        // advance to the next strategy after the timeout
+        return;
+      }
+      if (timer) {
+        timer.ensureAborted();
+      }
+      callback(error, handshake);
+    });
+
+    return {
+      abort: function () {
+        if (timer) {
+          timer.ensureAborted();
+        }
+        runner.abort();
+      },
+      forceMinPriority: function (p) {
+        runner.forceMinPriority(p);
+      },
+    };
+  }
+}

package/src/core/strategies/strategy.ts

@@ -0,0 +1,8 @@
+import StrategyRunner from './strategy_runner';
+
+interface Strategy {
+  isSupported(): boolean;
+  connect(minPriority: number, callback: Function): StrategyRunner;
+}
+
+export default Strategy;

package/src/core/strategies/strategy_builder.ts

@@ -0,0 +1,67 @@
+import * as Collections from '../utils/collections';
+import Util from '../util';
+import TransportManager from '../transports/transport_manager';
+import * as Errors from '../errors';
+import Strategy from './strategy';
+import TransportStrategy from './transport_strategy';
+import StrategyOptions from '../strategies/strategy_options';
+import { Config } from '../config';
+import Runtime from 'runtime';
+
+const { Transports } = Runtime;
+
+export var defineTransport = function (
+  config: Config,
+  name: string,
+  type: string,
+  priority: number,
+  options: StrategyOptions,
+  manager?: TransportManager,
+): Strategy {
+  var transportClass = Transports[type];
+  if (!transportClass) {
+    throw new Errors.UnsupportedTransport(type);
+  }
+
+  var enabled =
+    (!config.enabledTransports ||
+      Collections.arrayIndexOf(config.enabledTransports, name) !== -1) &&
+    (!config.disabledTransports ||
+      Collections.arrayIndexOf(config.disabledTransports, name) === -1);
+
+  var transport;
+  if (enabled) {
+    options = Object.assign(
+      { ignoreNullOrigin: config.ignoreNullOrigin },
+      options,
+    );
+
+    transport = new TransportStrategy(
+      name,
+      priority,
+      manager ? manager.getAssistant(transportClass) : transportClass,
+      options,
+    );
+  } else {
+    transport = UnsupportedStrategy;
+  }
+
+  return transport;
+};
+
+var UnsupportedStrategy: Strategy = {
+  isSupported: function () {
+    return false;
+  },
+  connect: function (_, callback) {
+    var deferred = Util.defer(function () {
+      callback(new Errors.UnsupportedStrategy());
+    });
+    return {
+      abort: function () {
+        deferred.ensureAborted();
+      },
+      forceMinPriority: function () {},
+    };
+  },
+};

package/src/core/strategies/strategy_options.ts

@@ -0,0 +1,18 @@
+import Timeline from '../timeline/timeline';
+
+interface StrategyOptions {
+  failFast?: boolean;
+  hostNonTLS?: string;
+  hostTLS?: string;
+  httpPath?: string;
+  ignoreNullOrigin?: boolean;
+  key?: string;
+  loop?: boolean;
+  timeline?: Timeline;
+  timeout?: number;
+  timeoutLimit?: number;
+  ttl?: number;
+  useTLS?: boolean;
+}
+
+export default StrategyOptions;

package/src/core/strategies/strategy_runner.ts

@@ -0,0 +1,6 @@
+interface StrategyRunner {
+  forceMinPriority: (number) => void;
+  abort: () => void;
+}
+
+export default StrategyRunner;

package/src/core/strategies/transport_strategy.ts

@@ -0,0 +1,144 @@
+import Factory from '../utils/factory';
+import Util from '../util';
+import * as Errors from '../errors';
+import * as Collections from '../utils/collections';
+import Strategy from './strategy';
+import Transport from '../transports/transport';
+import StrategyOptions from './strategy_options';
+import Handshake from '../connection/handshake';
+
+/** Provides a strategy interface for transports.
+ *
+ * @param {String} name
+ * @param {Number} priority
+ * @param {Class} transport
+ * @param {Object} options
+ */
+export default class TransportStrategy implements Strategy {
+  name: string;
+  priority: number;
+  transport: Transport;
+  options: StrategyOptions;
+
+  constructor(
+    name: string,
+    priority: number,
+    transport: Transport,
+    options: StrategyOptions,
+  ) {
+    this.name = name;
+    this.priority = priority;
+    this.transport = transport;
+    this.options = options || {};
+  }
+
+  /** Returns whether the transport is supported in the browser.
+   *
+   * @returns {Boolean}
+   */
+  isSupported(): boolean {
+    return this.transport.isSupported({
+      useTLS: this.options.useTLS,
+    });
+  }
+
+  /** Launches a connection attempt and returns a strategy runner.
+   *
+   * @param  {Function} callback
+   * @return {Object} strategy runner
+   */
+  connect(minPriority: number, callback: Function) {
+    if (!this.isSupported()) {
+      return failAttempt(new Errors.UnsupportedStrategy(), callback);
+    } else if (this.priority < minPriority) {
+      return failAttempt(new Errors.TransportPriorityTooLow(), callback);
+    }
+
+    var connected = false;
+    var transport = this.transport.createConnection(
+      this.name,
+      this.priority,
+      this.options.key,
+      this.options,
+    );
+    var handshake = null;
+
+    var onInitialized = function () {
+      transport.unbind('initialized', onInitialized);
+      transport.connect();
+    };
+    var onOpen = function () {
+      handshake = Factory.createHandshake(transport, function (result) {
+        connected = true;
+        unbindListeners();
+        callback(null, result);
+      });
+    };
+    var onError = function (error) {
+      unbindListeners();
+      callback(error);
+    };
+    var onClosed = function () {
+      unbindListeners();
+      var serializedTransport;
+
+      // The reason for this try/catch block is that on React Native
+      // the WebSocket object is circular. Therefore transport.socket will
+      // throw errors upon stringification. Collections.safeJSONStringify
+      // discards circular references when serializing.
+      serializedTransport = Collections.safeJSONStringify(transport);
+      callback(new Errors.TransportClosed(serializedTransport));
+    };
+
+    var unbindListeners = function () {
+      transport.unbind('initialized', onInitialized);
+      transport.unbind('open', onOpen);
+      transport.unbind('error', onError);
+      transport.unbind('closed', onClosed);
+    };
+
+    transport.bind('initialized', onInitialized);
+    transport.bind('open', onOpen);
+    transport.bind('error', onError);
+    transport.bind('closed', onClosed);
+
+    // connect will be called automatically after initialization
+    transport.initialize();
+
+    return {
+      abort: () => {
+        if (connected) {
+          return;
+        }
+        unbindListeners();
+        if (handshake) {
+          handshake.close();
+        } else {
+          transport.close();
+        }
+      },
+      forceMinPriority: (p) => {
+        if (connected) {
+          return;
+        }
+        if (this.priority < p) {
+          if (handshake) {
+            handshake.close();
+          } else {
+            transport.close();
+          }
+        }
+      },
+    };
+  }
+}
+
+function failAttempt(error: Error, callback: Function) {
+  Util.defer(function () {
+    callback(error);
+  });
+  return {
+    abort: function () {},
+    forceMinPriority: function () {},
+  };
+}

package/src/core/strategies/websocket_prioritized_cached_strategy.ts

@@ -0,0 +1,157 @@
+import Util from '../util';
+import Runtime from 'runtime';
+import Strategy from './strategy';
+import SequentialStrategy from './sequential_strategy';
+import StrategyOptions from './strategy_options';
+import TransportStrategy from './transport_strategy';
+import Timeline from '../timeline/timeline';
+import * as Collections from '../utils/collections';
+
+export interface TransportStrategyDictionary {
+  [key: string]: TransportStrategy;
+}
+
+/** Caches the last successful transport and, after the first few attempts,
+ *  uses the cached transport for subsequent attempts.
+ *
+ * @param {Strategy} strategy
+ * @param {Object} transports
+ * @param {Object} options
+ */
+export default class WebSocketPrioritizedCachedStrategy implements Strategy {
+  strategy: Strategy;
+  transports: TransportStrategyDictionary;
+  ttl: number;
+  usingTLS: boolean;
+  timeline: Timeline;
+
+  constructor(
+    strategy: Strategy,
+    transports: TransportStrategyDictionary,
+    options: StrategyOptions,
+  ) {
+    this.strategy = strategy;
+    this.transports = transports;
+    this.ttl = options.ttl || 1800 * 1000;
+    this.usingTLS = options.useTLS;
+    this.timeline = options.timeline;
+  }
+
+  isSupported(): boolean {
+    return this.strategy.isSupported();
+  }
+
+  connect(minPriority: number, callback: Function) {
+    var usingTLS = this.usingTLS;
+    var info = fetchTransportCache(usingTLS);
+    var cacheSkipCount = info && info.cacheSkipCount ? info.cacheSkipCount : 0;
+
+    var strategies = [this.strategy];
+    if (info && info.timestamp + this.ttl >= Util.now()) {
+      var transport = this.transports[info.transport];
+      if (transport) {
+        if (['ws', 'wss'].includes(info.transport) || cacheSkipCount > 3) {
+          this.timeline.info({
+            cached: true,
+            transport: info.transport,
+            latency: info.latency,
+          });
+          strategies.push(
+            new SequentialStrategy([transport], {
+              timeout: info.latency * 2 + 1000,
+              failFast: true,
+            }),
+          );
+        } else {
+          cacheSkipCount++;
+        }
+      }
+    }
+
+    var startTimestamp = Util.now();
+    var runner = strategies
+      .pop()
+      .connect(minPriority, function cb(error, handshake) {
+        if (error) {
+          flushTransportCache(usingTLS);
+          if (strategies.length > 0) {
+            startTimestamp = Util.now();
+            runner = strategies.pop().connect(minPriority, cb);
+          } else {
+            callback(error);
+          }
+        } else {
+          storeTransportCache(
+            usingTLS,
+            handshake.transport.name,
+            Util.now() - startTimestamp,
+            cacheSkipCount,
+          );
+          callback(null, handshake);
+        }
+      });
+
+    return {
+      abort: function () {
+        runner.abort();
+      },
+      forceMinPriority: function (p) {
+        minPriority = p;
+        if (runner) {
+          runner.forceMinPriority(p);
+        }
+      },
+    };
+  }
+}
+
+function getTransportCacheKey(usingTLS: boolean): string {
+  return 'pusherTransport' + (usingTLS ? 'TLS' : 'NonTLS');
+}
+
+function fetchTransportCache(usingTLS: boolean): any {
+  var storage = Runtime.getLocalStorage();
+  if (storage) {
+    try {
+      var serializedCache = storage[getTransportCacheKey(usingTLS)];
+      if (serializedCache) {
+        return JSON.parse(serializedCache);
+      }
+    } catch (e) {
+      flushTransportCache(usingTLS);
+    }
+  }
+  return null;
+}
+
+function storeTransportCache(
+  usingTLS: boolean,
+  transport: TransportStrategy,
+  latency: number,
+  cacheSkipCount: number,
+) {
+  var storage = Runtime.getLocalStorage();
+  if (storage) {
+    try {
+      storage[getTransportCacheKey(usingTLS)] = Collections.safeJSONStringify({
+        timestamp: Util.now(),
+        transport: transport,
+        latency: latency,
+        cacheSkipCount: cacheSkipCount,
+      });
+    } catch (e) {
+      // catch over quota exceptions raised by localStorage
+    }
+  }
+}
+
+function flushTransportCache(usingTLS: boolean) {
+  var storage = Runtime.getLocalStorage();
+  if (storage) {
+    try {
+      delete storage[getTransportCacheKey(usingTLS)];
+    } catch (e) {
+      // catch exceptions raised by localStorage
+    }
+  }
+}

package/src/core/timeline/level.ts

@@ -0,0 +1,7 @@
+enum TimelineLevel {
+  ERROR = 3,
+  INFO = 6,
+  DEBUG = 7,
+}
+
+export default TimelineLevel;

package/src/core/timeline/timeline.ts

@@ -0,0 +1,90 @@
+import * as Collections from '../utils/collections';
+import Util from '../util';
+import { default as Level } from './level';
+
+export interface TimelineOptions {
+  level?: Level;
+  limit?: number;
+  version?: string;
+  cluster?: string;
+  features?: string[];
+  params?: any;
+}
+
+export default class Timeline {
+  key: string;
+  session: number;
+  events: any[];
+  options: TimelineOptions;
+  sent: number;
+  uniqueID: number;
+
+  constructor(key: string, session: number, options: TimelineOptions) {
+    this.key = key;
+    this.session = session;
+    this.events = [];
+    this.options = options || {};
+    this.sent = 0;
+    this.uniqueID = 0;
+  }
+
+  log(level, event) {
+    if (level <= this.options.level) {
+      this.events.push(
+        Collections.extend({}, event, { timestamp: Util.now() }),
+      );
+      if (this.options.limit && this.events.length > this.options.limit) {
+        this.events.shift();
+      }
+    }
+  }
+
+  error(event) {
+    this.log(Level.ERROR, event);
+  }
+
+  info(event) {
+    this.log(Level.INFO, event);
+  }
+
+  debug(event) {
+    this.log(Level.DEBUG, event);
+  }
+
+  isEmpty() {
+    return this.events.length === 0;
+  }
+
+  send(sendfn, callback) {
+    var data = Collections.extend(
+      {
+        session: this.session,
+        bundle: this.sent + 1,
+        key: this.key,
+        lib: 'js',
+        version: this.options.version,
+        cluster: this.options.cluster,
+        features: this.options.features,
+        timeline: this.events,
+      },
+      this.options.params,
+    );
+
+    this.events = [];
+    sendfn(data, (error, result) => {
+      if (!error) {
+        this.sent++;
+      }
+      if (callback) {
+        callback(error, result);
+      }
+    });
+
+    return true;
+  }
+
+  generateUniqueID(): number {
+    this.uniqueID++;
+    return this.uniqueID;
+  }
+}

package/src/core/timeline/timeline_sender.ts

@@ -0,0 +1,33 @@
+import * as Collections from '../utils/collections';
+import Util from '../util';
+import base64encode from '../base64';
+import Timeline from './timeline';
+import Runtime from 'runtime';
+
+export interface TimelineSenderOptions {
+  host?: string;
+  port?: number;
+  path?: string;
+}
+
+export default class TimelineSender {
+  timeline: Timeline;
+  options: TimelineSenderOptions;
+  host: string;
+
+  constructor(timeline: Timeline, options: TimelineSenderOptions) {
+    this.timeline = timeline;
+    this.options = options || {};
+  }
+
+  send(useTLS: boolean, callback?: Function) {
+    if (this.timeline.isEmpty()) {
+      return;
+    }
+
+    this.timeline.send(
+      Runtime.TimelineTransport.getAgent(this, useTLS),
+      callback,
+    );
+  }
+}

package/src/core/timeline/timeline_transport.ts

@@ -0,0 +1,11 @@
+import TimelineSender from '../timeline/timeline_sender';
+
+interface TimelineTransport {
+  name: string;
+  getAgent: (
+    sender: TimelineSender,
+    useTLS: boolean,
+  ) => (data: any, callback: Function) => void;
+}
+
+export default TimelineTransport;