@cendarsoss/pusher-js 8.4.11

package/src/core/connection/connection_manager.ts

@@ -0,0 +1,371 @@
+import { default as EventsDispatcher } from '../events/dispatcher';
+import { OneOffTimer as Timer } from '../utils/timers';
+import { Config } from '../config';
+import Logger from '../logger';
+import HandshakePayload from './handshake/handshake_payload';
+import Connection from './connection';
+import Strategy from '../strategies/strategy';
+import StrategyRunner from '../strategies/strategy_runner';
+import * as Collections from '../utils/collections';
+import Timeline from '../timeline/timeline';
+import ConnectionManagerOptions from './connection_manager_options';
+import Runtime from 'runtime';
+
+import {
+  ErrorCallbacks,
+  HandshakeCallbacks,
+  ConnectionCallbacks,
+} from './callbacks';
+import Action from './protocol/action';
+
+/** Manages connection to Pusher.
+ *
+ * Uses a strategy (currently only default), timers and network availability
+ * info to establish a connection and export its state. In case of failures,
+ * manages reconnection attempts.
+ *
+ * Exports state changes as following events:
+ * - "state_change", { previous: p, current: state }
+ * - state
+ *
+ * States:
+ * - initialized - initial state, never transitioned to
+ * - connecting - connection is being established
+ * - connected - connection has been fully established
+ * - disconnected - on requested disconnection
+ * - unavailable - after connection timeout or when there's no network
+ * - failed - when the connection strategy is not supported
+ *
+ * Options:
+ * - unavailableTimeout - time to transition to unavailable state
+ * - activityTimeout - time after which ping message should be sent
+ * - pongTimeout - time for Pusher to respond with pong before reconnecting
+ *
+ * @param {String} key application key
+ * @param {Object} options
+ */
+export default class ConnectionManager extends EventsDispatcher {
+  key: string;
+  options: ConnectionManagerOptions;
+  state: string;
+  connection: Connection;
+  usingTLS: boolean;
+  timeline: Timeline;
+  socket_id: string;
+  unavailableTimer: Timer;
+  activityTimer: Timer;
+  retryTimer: Timer;
+  activityTimeout: number;
+  strategy: Strategy;
+  runner: StrategyRunner;
+  errorCallbacks: ErrorCallbacks;
+  handshakeCallbacks: HandshakeCallbacks;
+  connectionCallbacks: ConnectionCallbacks;
+
+  constructor(key: string, options: ConnectionManagerOptions) {
+    super();
+    this.state = 'initialized';
+    this.connection = null;
+
+    this.key = key;
+    this.options = options;
+    this.timeline = this.options.timeline;
+    this.usingTLS = this.options.useTLS;
+
+    this.errorCallbacks = this.buildErrorCallbacks();
+    this.connectionCallbacks = this.buildConnectionCallbacks(
+      this.errorCallbacks,
+    );
+    this.handshakeCallbacks = this.buildHandshakeCallbacks(this.errorCallbacks);
+
+    var Network = Runtime.getNetwork();
+
+    Network.bind('online', () => {
+      this.timeline.info({ netinfo: 'online' });
+      if (this.state === 'connecting' || this.state === 'unavailable') {
+        this.retryIn(0);
+      }
+    });
+    Network.bind('offline', () => {
+      this.timeline.info({ netinfo: 'offline' });
+      if (this.connection) {
+        this.sendActivityCheck();
+      }
+    });
+
+    this.updateStrategy();
+  }
+
+  /** Establishes a connection to Pusher.
+   *
+   * Does nothing when connection is already established. See top-level doc
+   * to find events emitted on connection attempts.
+   */
+  connect() {
+    if (this.connection || this.runner) {
+      return;
+    }
+    if (!this.strategy.isSupported()) {
+      this.updateState('failed');
+      return;
+    }
+    this.updateState('connecting');
+    this.startConnecting();
+    this.setUnavailableTimer();
+  }
+
+  /** Sends raw data.
+   *
+   * @param {String} data
+   */
+  send(data) {
+    if (this.connection) {
+      return this.connection.send(data);
+    } else {
+      return false;
+    }
+  }
+
+  /** Sends an event.
+   *
+   * @param {String} name
+   * @param {String} data
+   * @param {String} [channel]
+   * @returns {Boolean} whether message was sent or not
+   */
+  send_event(name: string, data: any, channel?: string) {
+    if (this.connection) {
+      return this.connection.send_event(name, data, channel);
+    } else {
+      return false;
+    }
+  }
+
+  /** Closes the connection. */
+  disconnect() {
+    this.disconnectInternally();
+    this.updateState('disconnected');
+  }
+
+  isUsingTLS() {
+    return this.usingTLS;
+  }
+
+  private startConnecting() {
+    var callback = (error, handshake) => {
+      if (error) {
+        this.runner = this.strategy.connect(0, callback);
+      } else {
+        if (handshake.action === 'error') {
+          this.emit('error', {
+            type: 'HandshakeError',
+            error: handshake.error,
+          });
+          this.timeline.error({ handshakeError: handshake.error });
+        } else {
+          this.abortConnecting(); // we don't support switching connections yet
+          this.handshakeCallbacks[handshake.action](handshake);
+        }
+      }
+    };
+    this.runner = this.strategy.connect(0, callback);
+  }
+
+  private abortConnecting() {
+    if (this.runner) {
+      this.runner.abort();
+      this.runner = null;
+    }
+  }
+
+  private disconnectInternally() {
+    this.abortConnecting();
+    this.clearRetryTimer();
+    this.clearUnavailableTimer();
+    if (this.connection) {
+      var connection = this.abandonConnection();
+      connection.close();
+    }
+  }
+
+  private updateStrategy() {
+    this.strategy = this.options.getStrategy({
+      key: this.key,
+      timeline: this.timeline,
+      useTLS: this.usingTLS,
+    });
+  }
+
+  private retryIn(delay) {
+    this.timeline.info({ action: 'retry', delay: delay });
+    if (delay > 0) {
+      this.emit('connecting_in', Math.round(delay / 1000));
+    }
+    this.retryTimer = new Timer(delay || 0, () => {
+      this.disconnectInternally();
+      this.connect();
+    });
+  }
+
+  private clearRetryTimer() {
+    if (this.retryTimer) {
+      this.retryTimer.ensureAborted();
+      this.retryTimer = null;
+    }
+  }
+
+  private setUnavailableTimer() {
+    this.unavailableTimer = new Timer(this.options.unavailableTimeout, () => {
+      this.updateState('unavailable');
+    });
+  }
+
+  private clearUnavailableTimer() {
+    if (this.unavailableTimer) {
+      this.unavailableTimer.ensureAborted();
+    }
+  }
+
+  private sendActivityCheck() {
+    this.stopActivityCheck();
+    this.connection.ping();
+    // wait for pong response
+    this.activityTimer = new Timer(this.options.pongTimeout, () => {
+      this.timeline.error({ pong_timed_out: this.options.pongTimeout });
+      this.retryIn(0);
+    });
+  }
+
+  private resetActivityCheck() {
+    this.stopActivityCheck();
+    // send ping after inactivity
+    if (this.connection && !this.connection.handlesActivityChecks()) {
+      this.activityTimer = new Timer(this.activityTimeout, () => {
+        this.sendActivityCheck();
+      });
+    }
+  }
+
+  private stopActivityCheck() {
+    if (this.activityTimer) {
+      this.activityTimer.ensureAborted();
+    }
+  }
+
+  private buildConnectionCallbacks(
+    errorCallbacks: ErrorCallbacks,
+  ): ConnectionCallbacks {
+    return Collections.extend<ConnectionCallbacks>({}, errorCallbacks, {
+      message: (message) => {
+        // includes pong messages from server
+        this.resetActivityCheck();
+        this.emit('message', message);
+      },
+      ping: () => {
+        this.send_event('pusher:pong', {});
+      },
+      activity: () => {
+        this.resetActivityCheck();
+      },
+      error: (error) => {
+        // just emit error to user - socket will already be closed by browser
+        this.emit('error', error);
+      },
+      closed: () => {
+        this.abandonConnection();
+        if (this.shouldRetry()) {
+          this.retryIn(1000);
+        }
+      },
+    });
+  }
+
+  private buildHandshakeCallbacks(
+    errorCallbacks: ErrorCallbacks,
+  ): HandshakeCallbacks {
+    return Collections.extend<HandshakeCallbacks>({}, errorCallbacks, {
+      connected: (handshake: HandshakePayload) => {
+        this.activityTimeout = Math.min(
+          this.options.activityTimeout,
+          handshake.activityTimeout,
+          handshake.connection.activityTimeout || Infinity,
+        );
+        this.clearUnavailableTimer();
+        this.setConnection(handshake.connection);
+        this.socket_id = this.connection.id;
+        this.updateState('connected', { socket_id: this.socket_id });
+      },
+    });
+  }
+
+  private buildErrorCallbacks(): ErrorCallbacks {
+    let withErrorEmitted = (callback) => {
+      return (result: Action | HandshakePayload) => {
+        if (result.error) {
+          this.emit('error', { type: 'WebSocketError', error: result.error });
+        }
+        callback(result);
+      };
+    };
+
+    return {
+      tls_only: withErrorEmitted(() => {
+        this.usingTLS = true;
+        this.updateStrategy();
+        this.retryIn(0);
+      }),
+      refused: withErrorEmitted(() => {
+        this.disconnect();
+      }),
+      backoff: withErrorEmitted(() => {
+        this.retryIn(1000);
+      }),
+      retry: withErrorEmitted(() => {
+        this.retryIn(0);
+      }),
+    };
+  }
+
+  private setConnection(connection) {
+    this.connection = connection;
+    for (var event in this.connectionCallbacks) {
+      this.connection.bind(event, this.connectionCallbacks[event]);
+    }
+    this.resetActivityCheck();
+  }
+
+  private abandonConnection() {
+    if (!this.connection) {
+      return;
+    }
+    this.stopActivityCheck();
+    for (var event in this.connectionCallbacks) {
+      this.connection.unbind(event, this.connectionCallbacks[event]);
+    }
+    var connection = this.connection;
+    this.connection = null;
+    return connection;
+  }
+
+  private updateState(newState: string, data?: any) {
+    var previousState = this.state;
+    this.state = newState;
+    if (previousState !== newState) {
+      var newStateDescription = newState;
+      if (newStateDescription === 'connected') {
+        newStateDescription += ' with new socket ID ' + data.socket_id;
+      }
+      Logger.debug(
+        'State changed',
+        previousState + ' -> ' + newStateDescription,
+      );
+      this.timeline.info({ state: newState, params: data });
+      this.emit('state_change', { previous: previousState, current: newState });
+      this.emit(newState, data);
+    }
+  }
+
+  private shouldRetry(): boolean {
+    return this.state === 'connecting' || this.state === 'connected';
+  }
+}

package/src/core/connection/connection_manager_options.ts

@@ -0,0 +1,14 @@
+import Timeline from '../timeline/timeline';
+import Strategy from '../strategies/strategy';
+import StategyOptions from '../strategies/strategy_options';
+
+interface ConnectionManagerOptions {
+  timeline: Timeline;
+  getStrategy: (StrategyOptions) => Strategy;
+  unavailableTimeout: number;
+  pongTimeout: number;
+  activityTimeout: number;
+  useTLS: boolean;
+}
+
+export default ConnectionManagerOptions;

package/src/core/connection/handshake/handshake_payload.ts

@@ -0,0 +1,10 @@
+import TransportConnection from '../../transports/transport_connection';
+import Action from '../protocol/action';
+import Connection from '../connection';
+
+interface HandshakePayload extends Action {
+  transport: TransportConnection;
+  connection?: Connection;
+}
+
+export default HandshakePayload;

package/src/core/connection/handshake/index.ts

@@ -0,0 +1,90 @@
+import Util from '../../util';
+import * as Collections from '../../utils/collections';
+import Protocol from '../protocol/protocol';
+import Connection from '../connection';
+import TransportConnection from '../../transports/transport_connection';
+import HandshakePayload from './handshake_payload';
+
+/**
+ * Handles Pusher protocol handshakes for transports.
+ *
+ * Calls back with a result object after handshake is completed. Results
+ * always have two fields:
+ * - action - string describing action to be taken after the handshake
+ * - transport - the transport object passed to the constructor
+ *
+ * Different actions can set different additional properties on the result.
+ * In the case of 'connected' action, there will be a 'connection' property
+ * containing a Connection object for the transport. Other actions should
+ * carry an 'error' property.
+ *
+ * @param {AbstractTransport} transport
+ * @param {Function} callback
+ */
+export default class Handshake {
+  transport: TransportConnection;
+  callback: (HandshakePayload) => void;
+  onMessage: Function;
+  onClosed: Function;
+
+  constructor(
+    transport: TransportConnection,
+    callback: (HandshakePayload) => void,
+  ) {
+    this.transport = transport;
+    this.callback = callback;
+    this.bindListeners();
+  }
+
+  close() {
+    this.unbindListeners();
+    this.transport.close();
+  }
+
+  private bindListeners() {
+    this.onMessage = (m) => {
+      this.unbindListeners();
+
+      var result;
+      try {
+        result = Protocol.processHandshake(m);
+      } catch (e) {
+        this.finish('error', { error: e });
+        this.transport.close();
+        return;
+      }
+
+      if (result.action === 'connected') {
+        this.finish('connected', {
+          connection: new Connection(result.id, this.transport),
+          activityTimeout: result.activityTimeout,
+        });
+      } else {
+        this.finish(result.action, { error: result.error });
+        this.transport.close();
+      }
+    };
+
+    this.onClosed = (closeEvent) => {
+      this.unbindListeners();
+
+      var action = Protocol.getCloseAction(closeEvent) || 'backoff';
+      var error = Protocol.getCloseError(closeEvent);
+      this.finish(action, { error: error });
+    };
+
+    this.transport.bind('message', this.onMessage);
+    this.transport.bind('closed', this.onClosed);
+  }
+
+  private unbindListeners() {
+    this.transport.unbind('message', this.onMessage);
+    this.transport.unbind('closed', this.onClosed);
+  }
+
+  private finish(action: string, params: any) {
+    this.callback(
+      Collections.extend({ transport: this.transport, action: action }, params),
+    );
+  }
+}

package/src/core/connection/protocol/action.ts

@@ -0,0 +1,8 @@
+interface Action {
+  action: string;
+  id?: string;
+  activityTimeout?: number;
+  error?: any;
+}
+
+export default Action;

package/src/core/connection/protocol/message-types.ts

@@ -0,0 +1,11 @@
+interface PusherEvent {
+  event: string;
+  channel?: string;
+  data?: any;
+  user_id?: string;
+  rawMessage?: string; // Raw WebSocket message for delta compression
+  sequence?: number; // Delta compression sequence number
+  conflation_key?: string; // Delta compression conflation key
+}
+
+export { PusherEvent };

package/src/core/connection/protocol/protocol.ts

@@ -0,0 +1,166 @@
+import Action from './action';
+import { PusherEvent } from './message-types';
+/**
+ * Provides functions for handling Pusher protocol-specific messages.
+ */
+
+const Protocol = {
+  /**
+   * Decodes a message in a Pusher format.
+   *
+   * The MessageEvent we receive from the transport should contain a pusher event
+   * (https://pusher.com/docs/pusher_protocol#events) serialized as JSON in the
+   * data field
+   *
+   * The pusher event may contain a data field too, and it may also be
+   * serialised as JSON
+   *
+   * Throws errors when messages are not parse'able.
+   *
+   * @param  {MessageEvent} messageEvent
+   * @return {PusherEvent}
+   */
+  decodeMessage: function (messageEvent: MessageEvent): PusherEvent {
+    try {
+      var messageData = JSON.parse(messageEvent.data);
+      var pusherEventData = messageData.data;
+      if (typeof pusherEventData === 'string') {
+        try {
+          pusherEventData = JSON.parse(messageData.data);
+        } catch (e) {}
+      }
+      var pusherEvent: PusherEvent = {
+        event: messageData.event,
+        channel: messageData.channel,
+        data: pusherEventData,
+        rawMessage: messageEvent.data, // Preserve raw message for delta compression
+      };
+      if (messageData.user_id) {
+        pusherEvent.user_id = messageData.user_id;
+      }
+      // Copy sequence and conflation_key for delta compression
+      // Server sends these as __delta_seq and __conflation_key
+      const sequence = messageData.__delta_seq ?? messageData.sequence;
+      const conflationKey =
+        messageData.__conflation_key ?? messageData.conflation_key;
+      if (typeof sequence === 'number') {
+        (pusherEvent as any).sequence = sequence;
+      }
+      if (conflationKey !== undefined) {
+        (pusherEvent as any).conflation_key = conflationKey;
+      }
+      return pusherEvent;
+    } catch (e) {
+      throw { type: 'MessageParseError', error: e, data: messageEvent.data };
+    }
+  },
+
+  /**
+   * Encodes a message to be sent.
+   *
+   * @param  {PusherEvent} event
+   * @return {String}
+   */
+  encodeMessage: function (event: PusherEvent): string {
+    return JSON.stringify(event);
+  },
+
+  /**
+   * Processes a handshake message and returns appropriate actions.
+   *
+   * Returns an object with an 'action' and other action-specific properties.
+   *
+   * There are three outcomes when calling this function. First is a successful
+   * connection attempt, when pusher:connection_established is received, which
+   * results in a 'connected' action with an 'id' property. When passed a
+   * pusher:error event, it returns a result with action appropriate to the
+   * close code and an error. Otherwise, it raises an exception.
+   *
+   * @param {String} message
+   * @result Object
+   */
+  processHandshake: function (messageEvent: MessageEvent): Action {
+    var message = Protocol.decodeMessage(messageEvent);
+
+    if (message.event === 'pusher:connection_established') {
+      if (!message.data.activity_timeout) {
+        throw 'No activity timeout specified in handshake';
+      }
+      return {
+        action: 'connected',
+        id: message.data.socket_id,
+        activityTimeout: message.data.activity_timeout * 1000,
+      };
+    } else if (message.event === 'pusher:error') {
+      // From protocol 6 close codes are sent only once, so this only
+      // happens when connection does not support close codes
+      return {
+        action: this.getCloseAction(message.data),
+        error: this.getCloseError(message.data),
+      };
+    } else {
+      throw 'Invalid handshake';
+    }
+  },
+
+  /**
+   * Dispatches the close event and returns an appropriate action name.
+   *
+   * See:
+   * 1. https://developer.mozilla.org/en-US/docs/WebSockets/WebSockets_reference/CloseEvent
+   * 2. http://pusher.com/docs/pusher_protocol
+   *
+   * @param  {CloseEvent} closeEvent
+   * @return {String} close action name
+   */
+  getCloseAction: function (closeEvent): string {
+    if (closeEvent.code < 4000) {
+      // ignore 1000 CLOSE_NORMAL, 1001 CLOSE_GOING_AWAY,
+      //        1005 CLOSE_NO_STATUS, 1006 CLOSE_ABNORMAL
+      // ignore 1007...3999
+      // handle 1002 CLOSE_PROTOCOL_ERROR, 1003 CLOSE_UNSUPPORTED,
+      //        1004 CLOSE_TOO_LARGE
+      if (closeEvent.code >= 1002 && closeEvent.code <= 1004) {
+        return 'backoff';
+      } else {
+        return null;
+      }
+    } else if (closeEvent.code === 4000) {
+      return 'tls_only';
+    } else if (closeEvent.code < 4100) {
+      return 'refused';
+    } else if (closeEvent.code < 4200) {
+      return 'backoff';
+    } else if (closeEvent.code < 4300) {
+      return 'retry';
+    } else {
+      // unknown error
+      return 'refused';
+    }
+  },
+
+  /**
+   * Returns an error or null basing on the close event.
+   *
+   * Null is returned when connection was closed cleanly. Otherwise, an object
+   * with error details is returned.
+   *
+   * @param  {CloseEvent} closeEvent
+   * @return {Object} error object
+   */
+  getCloseError: function (closeEvent): any {
+    if (closeEvent.code !== 1000 && closeEvent.code !== 1001) {
+      return {
+        type: 'PusherError',
+        data: {
+          code: closeEvent.code,
+          message: closeEvent.reason || closeEvent.message,
+        },
+      };
+    } else {
+      return null;
+    }
+  },
+};
+
+export default Protocol;