keejef
/
session-desktop
mirror of https://github.com/oxen-io/session-desktop
2
0
Fork 0
Code Issues 8 Projects Releases Wiki Activity

Merge pull request #160 from Mikunj/code-cleanup

Browse Source 
Code cleanup
pull/161/head
sachaaaaa 6 years ago committed by GitHub
parent 9c98a1f654 efe95a70bc
commit 93015b151f
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
9 changed files with 149 additions and 167 deletions
Show Stats Download Patch File Download Diff File

247
js/modules/loki_message_api.js
Unescape Escape View File

@ -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 => {
// TODO: Confirm sensible timeout
const options = {
url: `${nodeUrl}${this.messageServerPort}/store`,
type: 'POST',
responseType: undefined,
timeout: 10000,
};
let swarmNodes = await window.Signal.Data.getSwarmNodesByPubkey(pubKey);
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') {
// TODO: Handle the case where lokinet is not working
if (e instanceof NotFoundError) {
canResolve = false;
return;
}
log.error(options.type, options.url, 0, 'Error sending message');
if (window.LokiSnodeAPI.unreachableNode(pubKey, nodeUrl)) {
completedNodes.push(nodeUrl);
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();
}
} else if (e instanceof HTTPError) {
log.error(
`POST ${e.response.url}`,
e.response.status,
'Error sending message'
);
if (response.status >= 0 && response.status < 400) {
completedNodes.push(nodeUrl);
swarmNodes = swarmNodes.filter(node => node !== nodeUrl);
successfulRequests += 1;
return;
// We mark the node as complete as we could still reach it
nodeComplete(nodeUrl);
} else {
log.error('Loki SendMessages:', e);
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);
swarmNodes = _.difference(swarmNodes, completedNodes);
const freshNodes = await window.LokiSnodeAPI.getFreshSwarmNodes(pubKey);
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) => {
// TODO: Confirm sensible timeout
const options = {
url: `${nodeUrl}${this.messageServerPort}/retrieve`,
type: 'GET',
responseType: 'json',
timeout: 10000,
};
let ourSwarmNodes;
try {
ourSwarmNodes = await window.LokiSnodeAPI.getOurSwarmNodes();
} catch (e) {
throw new window.textsecure.EmptySwarmError(ourKey, e);
}
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);
} catch (e) {
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;
}
const result = await fetch(url, {
headers,
});
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();
}
completedNodes.push(nodeUrl);
delete ourSwarmNodes[nodeUrl];
nodeComplete(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) {
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,
};
module.exports = LokiMessageAPI;

4
js/modules/loki_p2p_api.js
Unescape Escape View File

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

4
js/modules/loki_snode_api.js
Unescape Escape View File

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

5
js/modules/util_worker_interface.js
Unescape Escape View File

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

2
libloki/local_loki_server.js
Unescape Escape View File

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

2
libloki/test/node/local_loki_server_test.js
Unescape Escape View File

@ -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 () => {

29
libtextsecure/message_receiver.js
Unescape Escape View File

@ -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();
this.localServer.on('message', this.httpPollingResource.handleMessage);
libloki.api.broadcastOnlineStatus();
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) {
this.localServer.removeListener(
if (localLokiServer) {
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) {
this.localServer.close();
if (localLokiServer) {
localLokiServer.close();
}
return this.drain();
@ -900,11 +901,7 @@ MessageReceiver.prototype.extend({
},
async handleLokiAddressMessage(envelope, lokiAddressMessage) {
const { p2pAddress, p2pPort } = lokiAddressMessage;
window.LokiP2pAPI.addContactP2pDetails(
envelope.source,
p2pAddress,
p2pPort
);
lokiP2pAPI.addContactP2pDetails(envelope.source, p2pAddress, p2pPort);
return this.removeFromCache(envelope);
},
handleDataMessage(envelope, msg) {

7
libtextsecure/outgoing_message.js
Unescape Escape View File

@ -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

16
preload.js
Unescape Escape View File

@ -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');

Write Preview
Loading…
Cancel
Save