ReconnectingWebsocket.js - a Websocket with an automatic reconnect

From https://github.com/joewalnes/reconnecting-websocket/.

This behaves like a WebSocket in every way, except if it fails to connect, or it gets disconnected, it will repeatedly poll until it successfully connects again.

It is API compatible, so when you have:

ws = new WebSocket('ws://....');

you can replace with:

ws = new ReconnectingWebSocket(‘ws://….’);

The event stream will typically look like:

onconnecting
onopen
onmessage
onmessage
onclose // lost connection
onconnecting
onopen  // sometime later...
onmessage
onmessage
etc...

It is API compatible with the standard WebSocket API, apart from the following members:

• bufferedAmount

• extensions

• binaryType

Latest version: https://github.com/joewalnes/reconnecting-websocket/

author:

Joe Walnes

Syntax

var socket = new ReconnectingWebSocket(url, protocols, options);

Parameters

url:

The url you are connecting to.

protocols:

Optional string or array of protocols.

options:

See below

Options

Options can either be passed upon instantiation or set after instantiation:

var socket = new ReconnectingWebSocket(url, null, { debug: true, reconnectInterval: 4000 });

or:

var socket = new ReconnectingWebSocket(url);
socket.debug = true;
socket.reconnectInterval = 4000;

debug:

Whether this instance should log debug messages. Accepts true or false. Default: false.

automaticOpen:

Whether or not the websocket should attempt to connect immediately upon instantiation. The socket can be manually opened or closed at any time using ws.open() and ws.close().

reconnectInterval:

The number of milliseconds to delay before attempting to reconnect. Accepts integer. Default: 1000.

maxReconnectInterval:

The maximum number of milliseconds to delay a reconnection attempt. Accepts integer. Default: 30000.

reconnectDecay:

The rate of increase of the reconnect delay. Allows reconnect attempts to back off when problems persist. Accepts integer or float. Default: 1.5.

timeoutInterval:

The maximum time in milliseconds to wait for a connection to succeed before closing and retrying. Accepts integer. Default: 2000.

(function (global, factory) {
  if (typeof define === "function" && define.amd) {
    define([], factory);
  } else if (typeof module !== "undefined" && module.exports) {
    module.exports = factory();
  } else {
    global.ReconnectingWebSocket = factory();
  }
})(this, function () {
  if (!("WebSocket" in window)) {
    return;
  }

  function ReconnectingWebSocket(url, protocols, options) {

Default settings

    var settings = {
      /** Whether this instance should log debug messages. */
      debug: false,

      /** Whether or not the websocket should attempt to connect immediately upon instantiation. */
      automaticOpen: true,

      /** The number of milliseconds to delay before attempting to reconnect. */
      reconnectInterval: 1000,
      /** The maximum number of milliseconds to delay a reconnection attempt. */
      maxReconnectInterval: 30000,
      /** The rate of increase of the reconnect delay. Allows reconnect attempts to back off when problems persist. */
      reconnectDecay: 1.5,

      /** The maximum time in milliseconds to wait for a connection to succeed before closing and retrying. */
      timeoutInterval: 2000,

      /** The maximum number of reconnection attempts to make. Unlimited if null. */
      maxReconnectAttempts: null,

      /** The binary type, possible values 'blob' or 'arraybuffer', default 'blob'. */
      binaryType: "blob",
    };
    if (!options) {
      options = {};
    }
 

Overwrite and define settings with options if they exist.

    for (var key in settings) {
      if (typeof options[key] !== "undefined") {
        this[key] = options[key];
      } else {
        this[key] = settings[key];
      }
    }
 

These should be treated as read-only properties

 
    /** The URL as resolved by the constructor. This is always an absolute URL. Read only. */
    this.url = url;

    /** The number of attempted reconnects since starting, or the last successful connection. Read only. */
    this.reconnectAttempts = 0;

    /**
     * The current state of the connection.
     * Can be one of: WebSocket.CONNECTING, WebSocket.OPEN, WebSocket.CLOSING, WebSocket.CLOSED
     * Read only.
     */
    this.readyState = WebSocket.CONNECTING;

    /**
     * A string indicating the name of the sub-protocol the server selected; this will be one of
     * the strings specified in the protocols parameter when creating the WebSocket object.
     * Read only.
     */
    this.protocol = null;
 

Private state variables

 
    var self = this;
    var ws;
    var forcedClose = false;
    var timedOut = false;
    var eventTarget = document.createElement("div");
 

Wire up “on*” properties as event handlers

 
    eventTarget.addEventListener("open", function (event) {
      self.onopen(event);
    });
    eventTarget.addEventListener("close", function (event) {
      self.onclose(event);
    });
    eventTarget.addEventListener("connecting", function (event) {
      self.onconnecting(event);
    });
    eventTarget.addEventListener("message", function (event) {
      self.onmessage(event);
    });
    eventTarget.addEventListener("error", function (event) {
      self.onerror(event);
    });
 

Expose the API required by EventTarget

 
    this.addEventListener = eventTarget.addEventListener.bind(eventTarget);
    this.removeEventListener =
      eventTarget.removeEventListener.bind(eventTarget);
    this.dispatchEvent = eventTarget.dispatchEvent.bind(eventTarget);

    /**
     * This function generates an event that is compatible with standard
     * compliant browsers and IE9 - IE11
     *
     * This will prevent the error:
     * Object doesn't support this action
     *
     * http://stackoverflow.com/questions/19345392/why-arent-my-parameters-getting-passed-through-to-a-dispatched-event/19345563#19345563
     * @param s String The name that the event should use
     * @param args Object an optional object that the event will use
     */
    function generateEvent(s, args) {
      var evt = document.createEvent("CustomEvent");
      evt.initCustomEvent(s, false, false, args);
      return evt;
    }

    this.open = function (reconnectAttempt) {
      ws = new WebSocket(self.url, protocols || []);
      ws.binaryType = this.binaryType;

      if (reconnectAttempt) {
        if (
          this.maxReconnectAttempts &&
          this.reconnectAttempts > this.maxReconnectAttempts
        ) {
          return;
        }
      } else {
        eventTarget.dispatchEvent(generateEvent("connecting"));
        this.reconnectAttempts = 0;
      }

      if (self.debug || ReconnectingWebSocket.debugAll) {
        console.debug("ReconnectingWebSocket", "attempt-connect", self.url);
      }

      var localWs = ws;
      var timeout = setTimeout(function () {
        if (self.debug || ReconnectingWebSocket.debugAll) {
          console.debug(
            "ReconnectingWebSocket",
            "connection-timeout",
            self.url
          );
        }
        timedOut = true;
        localWs.close();
        timedOut = false;
      }, self.timeoutInterval);

      ws.onopen = function (event) {
        clearTimeout(timeout);
        if (self.debug || ReconnectingWebSocket.debugAll) {
          console.debug("ReconnectingWebSocket", "onopen", self.url);
        }
        self.protocol = ws.protocol;
        self.readyState = WebSocket.OPEN;
        self.reconnectAttempts = 0;
        var e = generateEvent("open");
        e.isReconnect = reconnectAttempt;
        reconnectAttempt = false;
        eventTarget.dispatchEvent(e);
      };

      ws.onclose = function (event) {
        clearTimeout(timeout);
        ws = null;
        if (forcedClose) {
          self.readyState = WebSocket.CLOSED;
          eventTarget.dispatchEvent(generateEvent("close"));
        } else {
          self.readyState = WebSocket.CONNECTING;
          var e = generateEvent("connecting");
          e.code = event.code;
          e.reason = event.reason;
          e.wasClean = event.wasClean;
          eventTarget.dispatchEvent(e);
          if (!reconnectAttempt && !timedOut) {
            if (self.debug || ReconnectingWebSocket.debugAll) {
              console.debug("ReconnectingWebSocket", "onclose", self.url);
            }
            eventTarget.dispatchEvent(generateEvent("close"));
          }

          var timeout =
            self.reconnectInterval *
            Math.pow(self.reconnectDecay, self.reconnectAttempts);
          setTimeout(
            function () {
              self.reconnectAttempts++;
              self.open(true);
            },
            timeout > self.maxReconnectInterval
              ? self.maxReconnectInterval
              : timeout
          );
        }
      };
      ws.onmessage = function (event) {
        if (self.debug || ReconnectingWebSocket.debugAll) {
          console.debug(
            "ReconnectingWebSocket",
            "onmessage",
            self.url,
            event.data
          );
        }
        var e = generateEvent("message");
        e.data = event.data;
        eventTarget.dispatchEvent(e);
      };
      ws.onerror = function (event) {
        if (self.debug || ReconnectingWebSocket.debugAll) {
          console.debug("ReconnectingWebSocket", "onerror", self.url, event);
        }
        eventTarget.dispatchEvent(generateEvent("error"));
      };
    };
 

Whether or not to create a websocket upon instantiation

    if (this.automaticOpen == true) {
      this.open(false);
    }

    /**
     * Transmits data to the server over the WebSocket connection.
     *
     * @param data a text string, ArrayBuffer or Blob to send to the server.
     */
    this.send = function (data) {
      if (ws) {
        if (self.debug || ReconnectingWebSocket.debugAll) {
          console.debug("ReconnectingWebSocket", "send", self.url, data);
        }
        return ws.send(data);
      } else {
        throw "INVALID_STATE_ERR : Pausing to reconnect websocket";
      }
    };

    /**
     * Closes the WebSocket connection or connection attempt, if any.
     * If the connection is already CLOSED, this method does nothing.
     */
    this.close = function (code, reason) {

Default CLOSE_NORMAL code

      if (typeof code == "undefined") {
        code = 1000;
      }
      forcedClose = true;
      if (ws) {
        ws.close(code, reason);
      }
    };

    /**
     * Additional public API method to refresh the connection if still open (close, re-open).
     * For example, if the app suspects bad data / missed heart beats, it can try to refresh.
     */
    this.refresh = function () {
      if (ws) {
        ws.close();
      }
    };
  }

  /**
   * An event listener to be called when the WebSocket connection's readyState changes to OPEN;
   * this indicates that the connection is ready to send and receive data.
   */
  ReconnectingWebSocket.prototype.onopen = function (event) {};
  /** An event listener to be called when the WebSocket connection's readyState changes to CLOSED. */
  ReconnectingWebSocket.prototype.onclose = function (event) {};
  /** An event listener to be called when a connection begins being attempted. */
  ReconnectingWebSocket.prototype.onconnecting = function (event) {};
  /** An event listener to be called when a message is received from the server. */
  ReconnectingWebSocket.prototype.onmessage = function (event) {};
  /** An event listener to be called when an error occurs. */
  ReconnectingWebSocket.prototype.onerror = function (event) {};

  /**
   * Whether all instances of ReconnectingWebSocket should log debug messages.
   * Setting this to true is the equivalent of setting all instances of ReconnectingWebSocket.debug to true.
   */
  ReconnectingWebSocket.debugAll = false;

  ReconnectingWebSocket.CONNECTING = WebSocket.CONNECTING;
  ReconnectingWebSocket.OPEN = WebSocket.OPEN;
  ReconnectingWebSocket.CLOSING = WebSocket.CLOSING;
  ReconnectingWebSocket.CLOSED = WebSocket.CLOSED;

  return ReconnectingWebSocket;
});