Rewrite WebSocket internals (#1410)

* Start rewriting Manager and Connection

* more stuff

* stuff

* Fix ready bug

* some stuff i forgot

* fix some stuff

* add stupid heartbeat ack like seriously who cares

* woo!

* fix a bug

* rate limit the dumb websocket

* stuff

* hdocs

* Docs

* Remove ClientManager#setupKeepAlive as it is now redundant

* Change Client._pingTimestamp to a getter that fetches the timestamp from the WebSocketConnection

* are you happy now eslint smh

* make gus happy

* Add CloseEvent external doc

* Make sure to emit 'reconnecting' when actually reconnecting

* ffs

* Fix RESUME logic

* Add heartbeat ack debug messages, including latency data

* Dumb stuff for Gus

* thx eslint

* more dumb stuff

* more dumb crap smh gus i h8 u

* moar messages

* fix for using wrong status, causing certain events not to be fired (#1422)

src/client/Client.js

@@ -156,13 +156,6 @@ class Client extends EventEmitter {
      */
     this.pings = [];
 
-    /**
-     * Timestamp of the latest ping's start time
-     * @type {number}
-     * @private
-     */
-    this._pingTimestamp = 0;
-
     /**
      * Timeouts set by {@link Client#setTimeout} that are still active
      * @type {Set<Timeout>}
@@ -182,6 +175,15 @@ class Client extends EventEmitter {
     }
   }
 
+  /**
+   * Timestamp of the latest ping's start time
+   * @type {number}
+   * @private
+   */
+  get _pingTimestamp() {
+    return this.ws.connection ? this.ws.connection.lastPingTimestamp : 0;
+  }
+
   /**
    * Current status of the client's connection to Discord
    * @type {?number}

src/client/ClientDataManager.js

@@ -15,7 +15,7 @@ class ClientDataManager {
   }
 
   get pastReady() {
-    return this.client.ws.status === Constants.Status.READY;
+    return this.client.ws.connection.status === Constants.Status.READY;
   }
 
   newGuild(data) {

src/client/ClientManager.js

@@ -20,6 +20,14 @@ class ClientManager {
     this.heartbeatInterval = null;
   }
 
+  /**
+   * The status of the client
+   * @type {number}
+   */
+  get status() {
+    return this.connection ? this.connection.status : Constants.Status.IDLE;
+  }
+
   /**
    * Connects the Client to the WebSocket
    * @param {string} token The authorization token
@@ -47,17 +55,9 @@ class ClientManager {
     }, reject);
   }
 
-  /**
-   * Sets up a keep-alive interval to keep the Client's connection valid
-   * @param {number} time The interval in milliseconds at which heartbeat packets should be sent
-   */
-  setupKeepAlive(time) {
-    this.heartbeatInterval = time;
-    this.client.setInterval(() => this.client.ws.heartbeat(true), time);
-  }
-
   destroy() {
     this.client.ws.destroy();
+    this.client.rest.destroy();
     if (!this.client.user) return Promise.resolve();
     if (this.client.user.bot) {
       this.client.token = null;

src/client/rest/RESTManager.js

@@ -15,6 +15,12 @@ class RESTManager {
     this.globallyRateLimited = false;
   }
 
+  destroy() {
+    for (const handlerID in this.handlers) {
+      this.handlers[handlerID].destroy();
+    }
+  }
+
   push(handler, apiRequest) {
     return new Promise((resolve, reject) => {
       handler.push({

src/client/rest/RequestHandlers/RequestHandler.js

@@ -45,6 +45,10 @@ class RequestHandler {
    * Attempts to get this RequestHandler to process its current queue
    */
   handle() {} // eslint-disable-line no-empty-function
+
+  destroy() {
+    this.queue = [];
+  }
 }
 
 module.exports = RequestHandler;

src/client/rest/RequestHandlers/Sequential.js

@@ -48,39 +48,42 @@ class SequentialRequestHandler extends RequestHandler {
   execute(item) {
     this.busy = true;
     return new Promise(resolve => {
-      item.request.gen().end((err, res) => {
-        if (res && res.headers) {
-          this.requestLimit = Number(res.headers['x-ratelimit-limit']);
-          this.requestResetTime = Number(res.headers['x-ratelimit-reset']) * 1000;
-          this.requestRemaining = Number(res.headers['x-ratelimit-remaining']);
-          this.timeDifference = Date.now() - new Date(res.headers.date).getTime();
-        }
-        if (err) {
-          if (err.status === 429) {
-            this.queue.unshift(item);
-            this.restManager.client.setTimeout(() => {
-              this.globalLimit = false;
-              resolve();
-            }, Number(res.headers['retry-after']) + this.restManager.client.options.restTimeOffset);
-            if (res.headers['x-ratelimit-global']) this.globalLimit = true;
-          } else {
-            item.reject(err);
-            resolve(err);
+      item.request
+        .gen()
+        .on('error', e => item.reject(e))
+        .end((err, res) => {
+          if (res && res.headers) {
+            this.requestLimit = Number(res.headers['x-ratelimit-limit']);
+            this.requestResetTime = Number(res.headers['x-ratelimit-reset']) * 1000;
+            this.requestRemaining = Number(res.headers['x-ratelimit-remaining']);
+            this.timeDifference = Date.now() - new Date(res.headers.date).getTime();
           }
-        } else {
-          this.globalLimit = false;
-          const data = res && res.body ? res.body : {};
-          item.resolve(data);
-          if (this.requestRemaining === 0) {
-            this.restManager.client.setTimeout(
+          if (err) {
+            if (err.status === 429) {
+              this.queue.unshift(item);
+              this.restManager.client.setTimeout(() => {
+                this.globalLimit = false;
+                resolve();
+              }, Number(res.headers['retry-after']) + this.restManager.client.options.restTimeOffset);
+              if (res.headers['x-ratelimit-global']) this.globalLimit = true;
+            } else {
+              item.reject(err);
+              resolve(err);
+            }
+          } else {
+            this.globalLimit = false;
+            const data = res && res.body ? res.body : {};
+            item.resolve(data);
+            if (this.requestRemaining === 0) {
+              this.restManager.client.setTimeout(
               () => resolve(data),
               this.requestResetTime - Date.now() + this.timeDifference + this.restManager.client.options.restTimeOffset
             );
-          } else {
-            resolve(data);
+            } else {
+              resolve(data);
+            }
           }
-        }
-      });
+        });
     });
   }