pingerchips-js 1.0.0-a

package/src/core/strategies/best_connected_ever_strategy.ts

@@ -0,0 +1,81 @@
+import * as Collections from '../utils/collections';
+import Util from '../util';
+import Strategy from './strategy';
+
+/** Launches all substrategies and emits prioritized connected transports.
+ *
+ * @param {Array} strategies
+ */
+export default class BestConnectedEverStrategy implements Strategy {
+  strategies: Strategy[];
+
+  constructor(strategies: Strategy[]) {
+    this.strategies = strategies;
+  }
+
+  isSupported(): boolean {
+    return Collections.any(this.strategies, Util.method('isSupported'));
+  }
+
+  connect(minPriority: number, callback: Function) {
+    return connect(this.strategies, minPriority, function(i, runners) {
+      return function(error, handshake) {
+        runners[i].error = error;
+        if (error) {
+          if (allRunnersFailed(runners)) {
+            callback(true);
+          }
+          return;
+        }
+        Collections.apply(runners, function(runner) {
+          runner.forceMinPriority(handshake.transport.priority);
+        });
+        callback(null, handshake);
+      };
+    });
+  }
+}
+
+/** Connects to all strategies in parallel.
+ *
+ * Callback builder should be a function that takes two arguments: index
+ * and a list of runners. It should return another function that will be
+ * passed to the substrategy with given index. Runners can be aborted using
+ * abortRunner(s) functions from this class.
+ *
+ * @param  {Array} strategies
+ * @param  {Function} callbackBuilder
+ * @return {Object} strategy runner
+ */
+function connect(
+  strategies: Strategy[],
+  minPriority: number,
+  callbackBuilder: Function
+) {
+  var runners = Collections.map(strategies, function(strategy, i, _, rs) {
+    return strategy.connect(minPriority, callbackBuilder(i, rs));
+  });
+  return {
+    abort: function() {
+      Collections.apply(runners, abortRunner);
+    },
+    forceMinPriority: function(p) {
+      Collections.apply(runners, function(runner) {
+        runner.forceMinPriority(p);
+      });
+    }
+  };
+}
+
+function allRunnersFailed(runners): boolean {
+  return Collections.all(runners, function(runner) {
+    return Boolean(runner.error);
+  });
+}
+
+function abortRunner(runner) {
+  if (!runner.error && !runner.aborted) {
+    runner.abort();
+    runner.aborted = true;
+  }
+}

package/src/core/strategies/delayed_strategy.ts

@@ -0,0 +1,48 @@
+import { OneOffTimer as Timer } from '../utils/timers';
+import Strategy from './strategy';
+import StrategyOptions from './strategy_options';
+
+/** Runs substrategy after specified delay.
+ *
+ * Options:
+ * - delay - time in miliseconds to delay the substrategy attempt
+ *
+ * @param {Strategy} strategy
+ * @param {Object} options
+ */
+export default class DelayedStrategy implements Strategy {
+  strategy: Strategy;
+  options: { delay: number };
+
+  constructor(strategy: Strategy, { delay: number }) {
+    this.strategy = strategy;
+    this.options = { delay: number };
+  }
+
+  isSupported(): boolean {
+    return this.strategy.isSupported();
+  }
+
+  connect(minPriority: number, callback: Function) {
+    var strategy = this.strategy;
+    var runner;
+    var timer = new Timer(this.options.delay, function() {
+      runner = strategy.connect(minPriority, callback);
+    });
+
+    return {
+      abort: function() {
+        timer.ensureAborted();
+        if (runner) {
+          runner.abort();
+        }
+      },
+      forceMinPriority: function(p) {
+        minPriority = p;
+        if (runner) {
+          runner.forceMinPriority(p);
+        }
+      }
+    };
+  }
+}

package/src/core/strategies/first_connected_strategy.ts

@@ -0,0 +1,28 @@
+import Strategy from './strategy';
+import StrategyRunner from './strategy_runner';
+
+/** Launches the substrategy and terminates on the first open connection.
+ *
+ * @param {Strategy} strategy
+ */
+export default class FirstConnectedStrategy implements Strategy {
+  strategy: Strategy;
+
+  constructor(strategy: Strategy) {
+    this.strategy = strategy;
+  }
+
+  isSupported(): boolean {
+    return this.strategy.isSupported();
+  }
+
+  connect(minPriority: number, callback: Function): StrategyRunner {
+    var runner = this.strategy.connect(minPriority, function(error, handshake) {
+      if (handshake) {
+        runner.abort();
+      }
+      callback(error, handshake);
+    });
+    return runner;
+  }
+}

package/src/core/strategies/if_strategy.ts

@@ -0,0 +1,34 @@
+import Strategy from './strategy';
+import StrategyRunner from './strategy_runner';
+
+/** Proxies method calls to one of substrategies basing on the test function.
+ *
+ * @param {Function} test
+ * @param {Strategy} trueBranch strategy used when test returns true
+ * @param {Strategy} falseBranch strategy used when test returns false
+ */
+export default class IfStrategy implements Strategy {
+  test: () => boolean;
+  trueBranch: Strategy;
+  falseBranch: Strategy;
+
+  constructor(
+    test: () => boolean,
+    trueBranch: Strategy,
+    falseBranch: Strategy
+  ) {
+    this.test = test;
+    this.trueBranch = trueBranch;
+    this.falseBranch = falseBranch;
+  }
+
+  isSupported(): boolean {
+    var branch = this.test() ? this.trueBranch : this.falseBranch;
+    return branch.isSupported();
+  }
+
+  connect(minPriority: number, callback: Function): StrategyRunner {
+    var branch = this.test() ? this.trueBranch : this.falseBranch;
+    return branch.connect(minPriority, callback);
+  }
+}

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() {}
+  };
+}