Merge pull request #160 from Mikunj/code-cleanup

Code cleanup

js/modules/loki_message_api.js

@@ -2,9 +2,59 @@
 /* eslint-disable no-loop-func */
 /* global log, dcodeIO, window, callWorker, Whisper */
 
-const fetch = require('node-fetch');
+const nodeFetch = require('node-fetch');
 const _ = require('lodash');
 
+class HTTPError extends Error {
+  constructor(response) {
+    super(response.statusText);
+    this.name = 'HTTPError';
+    this.response = response;
+  }
+}
+
+class NotFoundError extends Error {
+  constructor() {
+    super('ENOTFOUND');
+    this.name = 'NotFoundError';
+  }
+}
+
+// A small wrapper around node-fetch which deserializes response
+const fetch = async (url, options = {}) => {
+  const timeout = options.timeout || 10000;
+  const method = options.method || 'GET';
+
+  try {
+    const response = await nodeFetch(url, {
+      timeout,
+      method,
+      ...options,
+    });
+
+    if (!response.ok) {
+      throw new HTTPError(response);
+    }
+
+    let result;
+    if (response.headers.get('Content-Type') === 'application/json') {
+      result = await response.json();
+    } else if (options.responseType === 'arraybuffer') {
+      result = await response.buffer();
+    } else {
+      result = await response.text();
+    }
+
+    return result;
+  } catch (e) {
+    if (e.code === 'ENOTFOUND') {
+      throw new NotFoundError();
+    }
+
+    throw e;
+  }
+};
+
 // Will be raised (to 3?) when we get more nodes
 const MINIMUM_SUCCESSFUL_REQUESTS = 2;
 
@@ -40,17 +90,17 @@ class LokiMessageAPI {
     let successfulRequests = 0;
     let canResolve = true;
 
-    const doRequest = async nodeUrl => {
+    let swarmNodes = await window.Signal.Data.getSwarmNodesByPubkey(pubKey);
-      // TODO: Confirm sensible timeout
-      const options = {
-        url: `${nodeUrl}${this.messageServerPort}/store`,
-        type: 'POST',
-        responseType: undefined,
-        timeout: 10000,
-      };
 
+    const nodeComplete = nodeUrl => {
+      completedNodes.push(nodeUrl);
+      swarmNodes = swarmNodes.filter(node => node !== nodeUrl);
+    };
+
+    const doRequest = async nodeUrl => {
+      const url = `${nodeUrl}${this.messageServerPort}/store`;
       const fetchOptions = {
-        method: options.type,
+        method: 'POST',
         body: data64,
         headers: {
           'X-Loki-pow-nonce': nonce,
@@ -58,61 +108,41 @@ class LokiMessageAPI {
           'X-Loki-ttl': ttl.toString(),
           'X-Loki-recipient': pubKey,
         },
-        timeout: options.timeout,
       };
 
-      let response;
       try {
-        response = await fetch(options.url, fetchOptions);
+        await fetch(url, fetchOptions);
+
+        nodeComplete(nodeUrl);
+        successfulRequests += 1;
       } catch (e) {
-        if (e.code === 'ENOTFOUND') {
+        if (e instanceof NotFoundError) {
-          // TODO: Handle the case where lokinet is not working
           canResolve = false;
-          return;
+        } else if (e instanceof HTTPError) {
-        }
+          log.error(
-        log.error(options.type, options.url, 0, 'Error sending message');
+            `POST ${e.response.url}`,
-        if (window.LokiSnodeAPI.unreachableNode(pubKey, nodeUrl)) {
+            e.response.status,
-          completedNodes.push(nodeUrl);
+            'Error sending message'
-          swarmNodes = swarmNodes.filter(node => node !== nodeUrl);
+          );
-        }
-        return;
-      }
-
-      let result;
-      if (
-        options.responseType === 'json' &&
-        response.headers.get('Content-Type') === 'application/json'
-      ) {
-        result = await response.json();
-      } else if (options.responseType === 'arraybuffer') {
-        result = await response.buffer();
-      } else {
-        result = await response.text();
-      }
 
-      if (response.status >= 0 && response.status < 400) {
+          // We mark the node as complete as we could still reach it
-        completedNodes.push(nodeUrl);
+          nodeComplete(nodeUrl);
-        swarmNodes = swarmNodes.filter(node => node !== nodeUrl);
+        } else {
-        successfulRequests += 1;
+          log.error('Loki SendMessages:', e);
-        return;
+          if (window.LokiSnodeAPI.unreachableNode(pubKey, nodeUrl)) {
+            nodeComplete(nodeUrl);
+          }
+        }
       }
-      log.error(
-        options.type,
-        options.url,
-        response.status,
-        'Error sending message'
-      );
-      throw HTTPError('sendMessage: error response', response.status, result);
     };
 
-    let swarmNodes = await window.Signal.Data.getSwarmNodesByPubkey(pubKey);
     while (successfulRequests < MINIMUM_SUCCESSFUL_REQUESTS) {
       if (!canResolve) {
         throw new window.textsecure.DNSResolutionError('Sending messages');
       }
       if (swarmNodes.length === 0) {
-        swarmNodes = await window.LokiSnodeAPI.getFreshSwarmNodes(pubKey);
+        const freshNodes = await window.LokiSnodeAPI.getFreshSwarmNodes(pubKey);
-        swarmNodes = _.difference(swarmNodes, completedNodes);
+        swarmNodes = _.difference(freshNodes, completedNodes);
         if (swarmNodes.length === 0) {
           if (successfulRequests !== 0) {
             // TODO: Decide how to handle some completed requests but not enough
@@ -127,8 +157,10 @@ class LokiMessageAPI {
           Conversation: Whisper.Conversation,
         });
       }
+
       const remainingRequests =
         MINIMUM_SUCCESSFUL_REQUESTS - completedNodes.length;
+
       await Promise.all(
         swarmNodes
           .splice(0, remainingRequests)
@@ -143,15 +175,20 @@ class LokiMessageAPI {
     let canResolve = true;
     let successfulRequests = 0;
 
-    const doRequest = async (nodeUrl, nodeData) => {
+    let ourSwarmNodes;
-      // TODO: Confirm sensible timeout
+    try {
-      const options = {
+      ourSwarmNodes = await window.LokiSnodeAPI.getOurSwarmNodes();
-        url: `${nodeUrl}${this.messageServerPort}/retrieve`,
+    } catch (e) {
-        type: 'GET',
+      throw new window.textsecure.EmptySwarmError(ourKey, e);
-        responseType: 'json',
+    }
-        timeout: 10000,
+
-      };
+    const nodeComplete = nodeUrl => {
+      completedNodes.push(nodeUrl);
+      delete ourSwarmNodes[nodeUrl];
+    };
 
+    const doRequest = async (nodeUrl, nodeData) => {
+      const url = `${nodeUrl}${this.messageServerPort}/retrieve`;
       const headers = {
         'X-Loki-recipient': ourKey,
       };
@@ -160,68 +197,39 @@ class LokiMessageAPI {
         headers['X-Loki-last-hash'] = nodeData.lastHash;
       }
 
-      const fetchOptions = {
-        method: options.type,
-        headers,
-        timeout: options.timeout,
-      };
-      let response;
       try {
-        response = await fetch(options.url, fetchOptions);
+        const result = await fetch(url, {
-      } catch (e) {
+          headers,
-        if (e.code === 'ENOTFOUND') {
+        });
-          // TODO: Handle the case where lokinet is not working
-          canResolve = false;
-          return;
-        }
-        log.error(
-          options.type,
-          options.url,
-          0,
-          `Error retrieving messages from ${nodeUrl}`
-        );
-        if (window.LokiSnodeAPI.unreachableNode(ourKey, nodeUrl)) {
-          completedNodes.push(nodeUrl);
-          delete ourSwarmNodes[nodeUrl];
-        }
-        return;
-      }
 
-      let result;
+        nodeComplete(nodeUrl);
-      if (
-        options.responseType === 'json' &&
-        response.headers.get('Content-Type') === 'application/json'
-      ) {
-        result = await response.json();
-      } else if (options.responseType === 'arraybuffer') {
-        result = await response.buffer();
-      } else {
-        result = await response.text();
-      }
-      completedNodes.push(nodeUrl);
-      delete ourSwarmNodes[nodeUrl];
 
-      if (response.status === 200) {
         if (result.lastHash) {
           window.LokiSnodeAPI.updateLastHash(nodeUrl, result.lastHash);
           callback(result.messages);
         }
         successfulRequests += 1;
-        return;
+      } catch (e) {
+        if (e instanceof NotFoundError) {
+          canResolve = false;
+        } else if (e instanceof HTTPError) {
+          log.error(
+            `GET ${e.response.url}`,
+            e.response.status,
+            `Error retrieving messages from ${nodeUrl}`
+          );
+
+          // We mark the node as complete as we could still reach it
+          nodeComplete(nodeUrl);
+        } else {
+          log.error('Loki RetrieveMessages:', e);
+          if (window.LokiSnodeAPI.unreachableNode(ourKey, nodeUrl)) {
+            nodeComplete(nodeUrl);
+          }
+        }
       }
-      // Handle error from snode
-      log.error(options.type, options.url, response.status, 'Error');
     };
 
-    let ourSwarmNodes;
-    try {
-      ourSwarmNodes = await window.LokiSnodeAPI.getOurSwarmNodes();
-    } catch (e) {
-      throw new window.textsecure.EmptySwarmError(
-        window.textsecure.storage.user.getNumber(),
-        e
-      );
-    }
     while (successfulRequests < MINIMUM_SUCCESSFUL_REQUESTS) {
       if (!canResolve) {
         throw new window.textsecure.DNSResolutionError('Retrieving messages');
@@ -251,6 +259,7 @@ class LokiMessageAPI {
 
       const remainingRequests =
         MINIMUM_SUCCESSFUL_REQUESTS - completedNodes.length;
+
       await Promise.all(
         Object.entries(ourSwarmNodes)
           .splice(0, remainingRequests)
@@ -260,20 +269,4 @@ class LokiMessageAPI {
   }
 }
 
-function HTTPError(message, providedCode, response, stack) {
+module.exports = LokiMessageAPI;
-  const code = providedCode > 999 || providedCode < 100 ? -1 : providedCode;
-  const e = new Error(`${message}; code: ${code}`);
-  e.name = 'HTTPError';
-  e.code = code;
-  if (stack) {
-    e.stack += `\nOriginal stack:\n${stack}`;
-  }
-  if (response) {
-    e.response = response;
-  }
-  return e;
-}
-
-module.exports = {
-  LokiMessageAPI,
-};

js/modules/loki_p2p_api.js

@@ -19,6 +19,4 @@ class LokiP2pAPI {
   }
 }
 
-module.exports = {
+module.exports = LokiP2pAPI;
-  LokiP2pAPI,
-};

js/modules/loki_snode_api.js

@@ -212,6 +212,4 @@ function HTTPError(message, providedCode, response, stack) {
   return e;
 }
 
-module.exports = {
+module.exports = LokiSnodeAPI;
-  LokiSnodeAPI,
-};

js/modules/util_worker_interface.js

@@ -122,7 +122,4 @@ class WorkerInterface {
   }
 }
 
-module.exports = {
+module.exports = WorkerInterface;
-  WorkerInterface,
-  TimedOutError,
-};

libloki/local_loki_server.js

@@ -87,4 +87,4 @@ class LocalLokiServer extends EventEmitter {
   }
 }
 
-exports.LocalLokiServer = LocalLokiServer;
+module.exports = LocalLokiServer;

libloki/test/node/local_loki_server_test.js

@@ -1,6 +1,6 @@
 const axios = require('axios');
 const { assert } = require('chai');
-const { LocalLokiServer } = require('../../local_loki_server');
+const LocalLokiServer = require('../../local_loki_server');
 
 describe('LocalLokiServer', () => {
   before(async () => {

libtextsecure/message_receiver.js

@@ -12,6 +12,10 @@
 /* global ContactBuffer: false */
 /* global GroupBuffer: false */
 /* global WebSocketResource: false */
+/* global localLokiServer: false */
+/* global localServerPort: false */
+/* global lokiMessageAPI: false */
+/* global lokiP2pAPI: false */
 
 /* eslint-disable more/no-then */
 /* eslint-disable no-unreachable */
@@ -22,8 +26,6 @@ function MessageReceiver(username, password, signalingKey, options = {}) {
   this.signalingKey = signalingKey;
   this.username = username;
   this.password = password;
-  this.lokiMessageAPI = window.LokiMessageAPI;
-  this.localServer = window.LocalLokiServer;
 
   if (!options.serverTrustRoot) {
     throw new Error('Server trust root is required!');
@@ -68,7 +70,7 @@ MessageReceiver.prototype.extend({
     }
 
     this.hasConnected = true;
-    this.httpPollingResource = new HttpResource(this.lokiMessageAPI, {
+    this.httpPollingResource = new HttpResource(lokiMessageAPI, {
       handleRequest: this.handleRequest.bind(this),
     });
     this.httpPollingResource.startPolling(connected => {
@@ -82,10 +84,10 @@ MessageReceiver.prototype.extend({
       }
     });
 
-    this.localServer.start(window.localServerPort).then(port => {
+    localLokiServer.start(localServerPort).then(port => {
       window.log.info(`Local Server started at localhost:${port}`);
-      window.libloki.api.broadcastOnlineStatus();
+      libloki.api.broadcastOnlineStatus();
-      this.localServer.on('message', this.httpPollingResource.handleMessage);
+      localLokiServer.on('message', this.httpPollingResource.handleMessage);
     });
 
     // TODO: Rework this socket stuff to work with online messaging
@@ -130,12 +132,11 @@ MessageReceiver.prototype.extend({
       this.wsr = null;
     }
 
-    if (this.localServer) {
+    if (localLokiServer) {
-      this.localServer.removeListener(
+      localLokiServer.removeListener(
         'message',
         this.httpPollingResource.handleMessage
       );
-      this.localServer = null;
     }
   },
   close() {
@@ -148,8 +149,8 @@ MessageReceiver.prototype.extend({
       this.wsr.close(3000, 'called close');
     }
 
-    if (this.localServer) {
+    if (localLokiServer) {
-      this.localServer.close();
+      localLokiServer.close();
     }
 
     return this.drain();
@@ -900,11 +901,7 @@ MessageReceiver.prototype.extend({
   },
   async handleLokiAddressMessage(envelope, lokiAddressMessage) {
     const { p2pAddress, p2pPort } = lokiAddressMessage;
-    window.LokiP2pAPI.addContactP2pDetails(
+    lokiP2pAPI.addContactP2pDetails(envelope.source, p2pAddress, p2pPort);
-      envelope.source,
-      p2pAddress,
-      p2pPort
-    );
     return this.removeFromCache(envelope);
   },
   handleDataMessage(envelope, msg) {

libtextsecure/outgoing_message.js

@@ -7,6 +7,7 @@
   StringView,
   dcodeIO,
   log,
+  lokiMessageAPI,
 */
 
 /* eslint-disable more/no-then */
@@ -34,8 +35,6 @@ function OutgoingMessage(
   this.callback = callback;
   this.silent = silent;
 
-  this.lokiMessageAPI = window.LokiMessageAPI;
-
   this.numbersCompleted = 0;
   this.errors = [];
   this.successfulNumbers = [];
@@ -123,7 +122,7 @@ OutgoingMessage.prototype = {
               .processPreKey(device)
               .then(async () => {
                 // TODO: only remove the keys that were used above!
-                await window.libloki.storage.removeContactPreKeyBundle(number);
+                await libloki.storage.removeContactPreKeyBundle(number);
                 return true;
               })
               .catch(error => {
@@ -186,7 +185,7 @@ OutgoingMessage.prototype = {
   async transmitMessage(number, data, timestamp, ttl = 24 * 60 * 60) {
     const pubKey = number;
     try {
-      await this.lokiMessageAPI.sendMessage(pubKey, data, timestamp, ttl);
+      await lokiMessageAPI.sendMessage(pubKey, data, timestamp, ttl);
     } catch (e) {
       if (e.name === 'HTTPError' && (e.code !== 409 && e.code !== 410)) {
         // 409 and 410 should bubble and be handled by doSendMessage

preload.js

@@ -269,31 +269,31 @@ window.WebAPI = initializeWebAPI({
   proxyUrl: config.proxyUrl,
 });
 
-const { LokiSnodeAPI } = require('./js/modules/loki_snode_api');
+const LokiSnodeAPI = require('./js/modules/loki_snode_api');
 
 window.LokiSnodeAPI = new LokiSnodeAPI({
   url: config.serverUrl,
   swarmServerPort: config.swarmServerPort,
 });
 
-const { LokiP2pAPI } = require('./js/modules/loki_p2p_api');
+const LokiP2pAPI = require('./js/modules/loki_p2p_api');
 
-window.LokiP2pAPI = new LokiP2pAPI();
+window.lokiP2pAPI = new LokiP2pAPI();
 
-const { LokiMessageAPI } = require('./js/modules/loki_message_api');
+const LokiMessageAPI = require('./js/modules/loki_message_api');
 
-window.LokiMessageAPI = new LokiMessageAPI({
+window.lokiMessageAPI = new LokiMessageAPI({
   url: config.serverUrl,
   messageServerPort: config.messageServerPort,
 });
 
-const { LocalLokiServer } = require('./libloki/local_loki_server');
+const LocalLokiServer = require('./libloki/local_loki_server');
 
 window.localServerPort = config.localServerPort;
-window.LocalLokiServer = new LocalLokiServer();
+window.localLokiServer = new LocalLokiServer();
 
 window.mnemonic = require('./libloki/mnemonic');
-const { WorkerInterface } = require('./js/modules/util_worker_interface');
+const WorkerInterface = require('./js/modules/util_worker_interface');
 
 // A Worker with a 3 minute timeout
 const utilWorkerPath = path.join(app.getAppPath(), 'js', 'util_worker.js');