@cendarsoss/pusher-js 8.4.11

package/src/core/transports/assistant_to_the_transport_manager.ts

@@ -0,0 +1,104 @@
+import Util from '../util';
+import * as Collections from '../utils/collections';
+import TransportManager from './transport_manager';
+import TransportConnection from './transport_connection';
+import Transport from './transport';
+import PingDelayOptions from './ping_delay_options';
+
+/** Creates transport connections monitored by a transport manager.
+ *
+ * When a transport is closed, it might mean the environment does not support
+ * it. It's possible that messages get stuck in an intermediate buffer or
+ * proxies terminate inactive connections. To combat these problems,
+ * assistants monitor the connection lifetime, report unclean exits and
+ * adjust ping timeouts to keep the connection active. The decision to disable
+ * a transport is the manager's responsibility.
+ *
+ * @param {TransportManager} manager
+ * @param {TransportConnection} transport
+ * @param {Object} options
+ */
+export default class AssistantToTheTransportManager {
+  manager: TransportManager;
+  transport: Transport;
+  minPingDelay: number;
+  maxPingDelay: number;
+  pingDelay: number;
+
+  constructor(
+    manager: TransportManager,
+    transport: Transport,
+    options: PingDelayOptions,
+  ) {
+    this.manager = manager;
+    this.transport = transport;
+    this.minPingDelay = options.minPingDelay;
+    this.maxPingDelay = options.maxPingDelay;
+    this.pingDelay = undefined;
+  }
+
+  /** Creates a transport connection.
+   *
+   * This function has the same API as Transport#createConnection.
+   *
+   * @param {String} name
+   * @param {Number} priority
+   * @param {String} key the application key
+   * @param {Object} options
+   * @returns {TransportConnection}
+   */
+  createConnection(
+    name: string,
+    priority: number,
+    key: string,
+    options: Object,
+  ): TransportConnection {
+    options = Collections.extend({}, options, {
+      activityTimeout: this.pingDelay,
+    });
+    var connection = this.transport.createConnection(
+      name,
+      priority,
+      key,
+      options,
+    );
+
+    var openTimestamp = null;
+
+    var onOpen = function () {
+      connection.unbind('open', onOpen);
+      connection.bind('closed', onClosed);
+      openTimestamp = Util.now();
+    };
+    var onClosed = (closeEvent) => {
+      connection.unbind('closed', onClosed);
+
+      if (closeEvent.code === 1002 || closeEvent.code === 1003) {
+        // we don't want to use transports not obeying the protocol
+        this.manager.reportDeath();
+      } else if (!closeEvent.wasClean && openTimestamp) {
+        // report deaths only for short-living transport
+        var lifespan = Util.now() - openTimestamp;
+        if (lifespan < 2 * this.maxPingDelay) {
+          this.manager.reportDeath();
+          this.pingDelay = Math.max(lifespan / 2, this.minPingDelay);
+        }
+      }
+    };
+
+    connection.bind('open', onOpen);
+    return connection;
+  }
+
+  /** Returns whether the transport is supported in the environment.
+   *
+   * This function has the same API as Transport#isSupported. Might return false
+   * when the manager decides to kill the transport.
+   *
+   * @param {Object} environment the environment details (encryption, settings)
+   * @returns {Boolean} true when the transport is supported
+   */
+  isSupported(environment: string): boolean {
+    return this.manager.isAlive() && this.transport.isSupported(environment);
+  }
+}

package/src/core/transports/ping_delay_options.ts

@@ -0,0 +1,7 @@
+interface PingDelayOptions {
+  minPingDelay?: number;
+  maxPingDelay?: number;
+  pingDelay?: number;
+}
+
+export default PingDelayOptions;

package/src/core/transports/transport.ts

@@ -0,0 +1,54 @@
+import Factory from '../utils/factory';
+import TransportHooks from './transport_hooks';
+import TransportConnection from './transport_connection';
+import TransportConnectionOptions from './transport_connection_options';
+
+/** Provides interface for transport connection instantiation.
+ *
+ * Takes transport-specific hooks as the only argument, which allow checking
+ * for transport support and creating its connections.
+ *
+ * Supported hooks: * - file - the name of the file to be fetched during initialization
+ * - urls - URL scheme to be used by transport
+ * - handlesActivityCheck - true when the transport handles activity checks
+ * - supportsPing - true when the transport has a ping/activity API
+ * - isSupported - tells whether the transport is supported in the environment
+ * - getSocket - creates a WebSocket-compatible transport socket
+ *
+ * See transports.js for specific implementations.
+ *
+ * @param {Object} hooks object containing all needed transport hooks
+ */
+export default class Transport {
+  hooks: TransportHooks;
+
+  constructor(hooks: TransportHooks) {
+    this.hooks = hooks;
+  }
+
+  /** Returns whether the transport is supported in the environment.
+   *
+   * @param {Object} envronment te environment details (encryption, settings)
+   * @returns {Boolean} true when the transport is supported
+   */
+  isSupported(environment: any): boolean {
+    return this.hooks.isSupported(environment);
+  }
+
+  /** Creates a transport connection.
+   *
+   * @param {String} name
+   * @param {Number} priority
+   * @param {String} key the application key
+   * @param {Object} options
+   * @returns {TransportConnection}
+   */
+  createConnection(
+    name: string,
+    priority: number,
+    key: string,
+    options: any,
+  ): TransportConnection {
+    return new TransportConnection(this.hooks, name, priority, key, options);
+  }
+}

package/src/core/transports/transport_connection.ts

@@ -0,0 +1,241 @@
+import Util from '../util';
+import * as Collections from '../utils/collections';
+import { default as EventsDispatcher } from '../events/dispatcher';
+import Logger from '../logger';
+import TransportHooks from './transport_hooks';
+import Socket from '../socket';
+import Runtime from 'runtime';
+import Timeline from '../timeline/timeline';
+import TransportConnectionOptions from './transport_connection_options';
+
+/** Provides universal API for transport connections.
+ *
+ * Transport connection is a low-level object that wraps a connection method
+ * and exposes a simple evented interface for the connection state and
+ * messaging. It does not implement Pusher-specific WebSocket protocol.
+ *
+ * Additionally, it fetches resources needed for transport to work and exposes
+ * an interface for querying transport features.
+ *
+ * States:
+ * - new - initial state after constructing the object
+ * - initializing - during initialization phase, usually fetching resources
+ * - intialized - ready to establish a connection
+ * - connection - when connection is being established
+ * - open - when connection ready to be used
+ * - closed - after connection was closed be either side
+ *
+ * Emits:
+ * - error - after the connection raised an error
+ *
+ * Options:
+ * - useTLS - whether connection should be over TLS
+ * - hostTLS - host to connect to when connection is over TLS
+ * - hostNonTLS - host to connect to when connection is over TLS
+ *
+ * @param {String} key application key
+ * @param {Object} options
+ */
+export default class TransportConnection extends EventsDispatcher {
+  hooks: TransportHooks;
+  name: string;
+  priority: number;
+  key: string;
+  options: TransportConnectionOptions;
+  state: string;
+  timeline: Timeline;
+  activityTimeout: number;
+  id: number;
+  socket: Socket;
+  beforeOpen: Function;
+  initialize: Function;
+
+  constructor(
+    hooks: TransportHooks,
+    name: string,
+    priority: number,
+    key: string,
+    options: TransportConnectionOptions,
+  ) {
+    super();
+    this.initialize = Runtime.transportConnectionInitializer;
+    this.hooks = hooks;
+    this.name = name;
+    this.priority = priority;
+    this.key = key;
+    this.options = options;
+
+    this.state = 'new';
+    this.timeline = options.timeline;
+    this.activityTimeout = options.activityTimeout;
+    this.id = this.timeline.generateUniqueID();
+  }
+
+  /** Checks whether the transport handles activity checks by itself.
+   *
+   * @return {Boolean}
+   */
+  handlesActivityChecks(): boolean {
+    return Boolean(this.hooks.handlesActivityChecks);
+  }
+
+  /** Checks whether the transport supports the ping/pong API.
+   *
+   * @return {Boolean}
+   */
+  supportsPing(): boolean {
+    return Boolean(this.hooks.supportsPing);
+  }
+
+  /** Tries to establish a connection.
+   *
+   * @returns {Boolean} false if transport is in invalid state
+   */
+  connect(): boolean {
+    if (this.socket || this.state !== 'initialized') {
+      return false;
+    }
+
+    var url = this.hooks.urls.getInitial(this.key, this.options);
+    try {
+      this.socket = this.hooks.getSocket(url, this.options);
+    } catch (e) {
+      Util.defer(() => {
+        this.onError(e);
+        this.changeState('closed');
+      });
+      return false;
+    }
+
+    this.bindListeners();
+
+    Logger.debug('Connecting', { transport: this.name, url });
+    this.changeState('connecting');
+    return true;
+  }
+
+  /** Closes the connection.
+   *
+   * @return {Boolean} true if there was a connection to close
+   */
+  close(): boolean {
+    if (this.socket) {
+      this.socket.close();
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  /** Sends data over the open connection.
+   *
+   * @param {String} data
+   * @return {Boolean} true only when in the "open" state
+   */
+  send(data: any): boolean {
+    if (this.state === 'open') {
+      // Workaround for MobileSafari bug (see https://gist.github.com/2052006)
+      Util.defer(() => {
+        if (this.socket) {
+          this.socket.send(data);
+        }
+      });
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  /** Sends a ping if the connection is open and transport supports it. */
+  ping() {
+    if (this.state === 'open' && this.supportsPing()) {
+      this.socket.ping();
+    }
+  }
+
+  private onOpen() {
+    if (this.hooks.beforeOpen) {
+      this.hooks.beforeOpen(
+        this.socket,
+        this.hooks.urls.getPath(this.key, this.options),
+      );
+    }
+    this.changeState('open');
+    this.socket.onopen = undefined;
+  }
+
+  private onError(error) {
+    this.emit('error', { type: 'WebSocketError', error: error });
+    this.timeline.error(this.buildTimelineMessage({ error: error.toString() }));
+  }
+
+  private onClose(closeEvent?: any) {
+    if (closeEvent) {
+      this.changeState('closed', {
+        code: closeEvent.code,
+        reason: closeEvent.reason,
+        wasClean: closeEvent.wasClean,
+      });
+    } else {
+      this.changeState('closed');
+    }
+    this.unbindListeners();
+    this.socket = undefined;
+  }
+
+  private onMessage(message) {
+    this.emit('message', message);
+  }
+
+  private onActivity() {
+    this.emit('activity');
+  }
+
+  private bindListeners() {
+    this.socket.onopen = () => {
+      this.onOpen();
+    };
+    this.socket.onerror = (error) => {
+      this.onError(error);
+    };
+    this.socket.onclose = (closeEvent) => {
+      this.onClose(closeEvent);
+    };
+    this.socket.onmessage = (message) => {
+      this.onMessage(message);
+    };
+
+    if (this.supportsPing()) {
+      this.socket.onactivity = () => {
+        this.onActivity();
+      };
+    }
+  }
+
+  private unbindListeners() {
+    if (this.socket) {
+      this.socket.onopen = undefined;
+      this.socket.onerror = undefined;
+      this.socket.onclose = undefined;
+      this.socket.onmessage = undefined;
+      if (this.supportsPing()) {
+        this.socket.onactivity = undefined;
+      }
+    }
+  }
+
+  private changeState(state: string, params?: any) {
+    this.state = state;
+    this.timeline.info(
+      this.buildTimelineMessage({
+        state: state,
+        params: params,
+      }),
+    );
+    this.emit(state, params);
+  }
+
+  buildTimelineMessage(message): any {
+    return Collections.extend({ cid: this.id }, message);
+  }
+}

package/src/core/transports/transport_connection_options.ts

@@ -0,0 +1,8 @@
+import Timeline from '../timeline/timeline';
+
+interface TransportConnectionOptions {
+  timeline: Timeline;
+  activityTimeout: number;
+}
+
+export default TransportConnectionOptions;

package/src/core/transports/transport_hooks.ts

@@ -0,0 +1,16 @@
+import Factory from '../utils/factory';
+import URLScheme from './url_scheme';
+import Socket from '../socket';
+
+interface TransportHooks {
+  file?: string;
+  urls: URLScheme;
+  handlesActivityChecks: boolean;
+  supportsPing: boolean;
+  isInitialized(): boolean;
+  isSupported(environment?: any): boolean;
+  getSocket(url: string, options?: any): Socket;
+  beforeOpen?: Function;
+}
+
+export default TransportHooks;

package/src/core/transports/transport_manager.ts

@@ -0,0 +1,52 @@
+import AssistantToTheTransportManager from './assistant_to_the_transport_manager';
+import Transport from './transport';
+import PingDelayOptions from './ping_delay_options';
+import Factory from '../utils/factory';
+
+export interface TransportManagerOptions extends PingDelayOptions {
+  lives?: number;
+}
+
+/** Keeps track of the number of lives left for a transport.
+ *
+ * In the beginning of a session, transports may be assigned a number of
+ * lives. When an AssistantToTheTransportManager instance reports a transport
+ * connection closed uncleanly, the transport loses a life. When the number
+ * of lives drops to zero, the transport gets disabled by its manager.
+ *
+ * @param {Object} options
+ */
+export default class TransportManager {
+  options: TransportManagerOptions;
+  livesLeft: number;
+
+  constructor(options: TransportManagerOptions) {
+    this.options = options || {};
+    this.livesLeft = this.options.lives || Infinity;
+  }
+
+  /** Creates a assistant for the transport.
+   *
+   * @param {Transport} transport
+   * @returns {AssistantToTheTransportManager}
+   */
+  getAssistant(transport: Transport): AssistantToTheTransportManager {
+    return Factory.createAssistantToTheTransportManager(this, transport, {
+      minPingDelay: this.options.minPingDelay,
+      maxPingDelay: this.options.maxPingDelay,
+    });
+  }
+
+  /** Returns whether the transport has any lives left.
+   *
+   * @returns {Boolean}
+   */
+  isAlive(): boolean {
+    return this.livesLeft > 0;
+  }
+
+  /** Takes one life from the transport. */
+  reportDeath() {
+    this.livesLeft -= 1;
+  }
+}

package/src/core/transports/transports_table.ts

@@ -0,0 +1,12 @@
+import Transport from './transport';
+
+interface TransportsTable {
+  ws: Transport;
+  xhr_streaming: Transport;
+  xdr_streaming?: Transport;
+  xhr_polling: Transport;
+  xdr_polling?: Transport;
+  sockjs?: Transport;
+}
+
+export default TransportsTable;

package/src/core/transports/url_scheme.ts

@@ -0,0 +1,13 @@
+export interface URLSchemeParams {
+  useTLS: boolean;
+  hostTLS: string;
+  hostNonTLS: string;
+  httpPath: string;
+}
+
+interface URLScheme {
+  getInitial(key: string, params: any): string;
+  getPath?(key: string, options: any): string;
+}
+
+export default URLScheme;

package/src/core/transports/url_schemes.ts

@@ -0,0 +1,47 @@
+import Defaults from '../defaults';
+import { default as URLScheme, URLSchemeParams } from './url_scheme';
+
+function getGenericURL(
+  baseScheme: string,
+  params: URLSchemeParams,
+  path: string,
+): string {
+  var scheme = baseScheme + (params.useTLS ? 's' : '');
+  var host = params.useTLS ? params.hostTLS : params.hostNonTLS;
+  return scheme + '://' + host + path;
+}
+
+function getGenericPath(key: string, queryString?: string): string {
+  var path = '/app/' + key;
+  var query =
+    '?protocol=' +
+    Defaults.PROTOCOL +
+    '&client=js' +
+    '&version=' +
+    Defaults.VERSION +
+    (queryString ? '&' + queryString : '');
+  return path + query;
+}
+
+export var ws: URLScheme = {
+  getInitial: function (key: string, params: URLSchemeParams): string {
+    var path = (params.httpPath || '') + getGenericPath(key, 'flash=false');
+    return getGenericURL('ws', params, path);
+  },
+};
+
+export var http: URLScheme = {
+  getInitial: function (key: string, params: URLSchemeParams): string {
+    var path = (params.httpPath || '/pusher') + getGenericPath(key);
+    return getGenericURL('http', params, path);
+  },
+};
+
+export var sockjs: URLScheme = {
+  getInitial: function (key: string, params: URLSchemeParams): string {
+    return getGenericURL('http', params, params.httpPath || '/pusher');
+  },
+  getPath: function (key: string, params: URLSchemeParams): string {
+    return getGenericPath(key);
+  },
+};