pingerchips-js 1.0.0-a

package/src/core/connection/connection.ts

@@ -0,0 +1,160 @@
+import * as Collections from '../utils/collections';
+import { default as EventsDispatcher } from '../events/dispatcher';
+import Protocol from './protocol/protocol';
+import { PusherEvent } from './protocol/message-types';
+import Logger from '../logger';
+import TransportConnection from '../transports/transport_connection';
+import Socket from '../socket';
+/**
+ * Provides Pusher protocol interface for transports.
+ *
+ * Emits following events:
+ * - message - on received messages
+ * - ping - on ping requests
+ * - pong - on pong responses
+ * - error - when the transport emits an error
+ * - closed - after closing the transport
+ *
+ * It also emits more events when connection closes with a code.
+ * See Protocol.getCloseAction to get more details.
+ *
+ * @param {Number} id
+ * @param {AbstractTransport} transport
+ */
+export default class Connection extends EventsDispatcher implements Socket {
+  id: string;
+  transport: TransportConnection;
+  activityTimeout: number;
+
+  constructor(id: string, transport: TransportConnection) {
+    super();
+    this.id = id;
+    this.transport = transport;
+    this.activityTimeout = transport.activityTimeout;
+    this.bindListeners();
+  }
+
+  /** Returns whether used transport handles activity checks by itself
+   *
+   * @returns {Boolean} true if activity checks are handled by the transport
+   */
+  handlesActivityChecks() {
+    return this.transport.handlesActivityChecks();
+  }
+
+  /** Sends raw data.
+   *
+   * @param {String} data
+   */
+  send(data: any): boolean {
+    return this.transport.send(data);
+  }
+
+  /** 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): boolean {
+    var event: PusherEvent = { event: name, data: data };
+    if (channel) {
+      event.channel = channel;
+    }
+    Logger.debug('Event sent', event);
+    return this.send(Protocol.encodeMessage(event));
+  }
+
+  /** Sends a ping message to the server.
+   *
+   * Basing on the underlying transport, it might send either transport's
+   * protocol-specific ping or pusher:ping event.
+   */
+  ping() {
+    if (this.transport.supportsPing()) {
+      this.transport.ping();
+    } else {
+      this.send_event('pusher:ping', {});
+    }
+  }
+
+  /** Closes the connection. */
+  close() {
+    this.transport.close();
+  }
+
+  private bindListeners() {
+    var listeners = {
+      message: (messageEvent: MessageEvent) => {
+        var pusherEvent;
+        try {
+          pusherEvent = Protocol.decodeMessage(messageEvent);
+        } catch (e) {
+          this.emit('error', {
+            type: 'MessageParseError',
+            error: e,
+            data: messageEvent.data
+          });
+        }
+
+        if (pusherEvent !== undefined) {
+          Logger.debug('Event recd', pusherEvent);
+
+          switch (pusherEvent.event) {
+            case 'pusher:error':
+              this.emit('error', {
+                type: 'PusherError',
+                data: pusherEvent.data
+              });
+              break;
+            case 'pusher:ping':
+              this.emit('ping');
+              break;
+            case 'pusher:pong':
+              this.emit('pong');
+              break;
+          }
+          this.emit('message', pusherEvent);
+        }
+      },
+      activity: () => {
+        this.emit('activity');
+      },
+      error: error => {
+        this.emit('error', error);
+      },
+      closed: closeEvent => {
+        unbindListeners();
+
+        if (closeEvent && closeEvent.code) {
+          this.handleCloseEvent(closeEvent);
+        }
+
+        this.transport = null;
+        this.emit('closed');
+      }
+    };
+
+    var unbindListeners = () => {
+      Collections.objectApply(listeners, (listener, event) => {
+        this.transport.unbind(event, listener);
+      });
+    };
+
+    Collections.objectApply(listeners, (listener, event) => {
+      this.transport.bind(event, listener);
+    });
+  }
+
+  private handleCloseEvent(closeEvent: any) {
+    var action = Protocol.getCloseAction(closeEvent);
+    var error = Protocol.getCloseError(closeEvent);
+    if (error) {
+      this.emit('error', error);
+    }
+    if (action) {
+      this.emit(action, { action: action, error: error });
+    }
+  }
+}

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,8 @@
+interface PusherEvent {
+  event: string;
+  channel?: string;
+  data?: any;
+  user_id?: string;
+}
+
+export { PusherEvent };