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

Cleaned up a lot of the logs, stop them from printing more than once etc

Browse Source
pull/255/head
Beaudan 6 years ago
parent bf76767ed8
commit 6656a89092
4 changed files with 35 additions and 73 deletions
Show Stats Download Patch File Download Diff File

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

@ -138,14 +138,20 @@ class LokiMessageAPI {
}); });
lokiP2pAPI.setContactOnline(pubKey); lokiP2pAPI.setContactOnline(pubKey);
window.Whisper.events.trigger('p2pMessageSent', messageEventData); window.Whisper.events.trigger('p2pMessageSent', messageEventData);
if (isPing) {
log.info(`Successfully pinged ${pubKey}`);
} else {
log.info(`Successful p2p message to ${pubKey}`);
}
return; return;
} catch (e) { } catch (e) {
log.warn('Failed to send P2P message, falling back to storage', e);
lokiP2pAPI.setContactOffline(pubKey); lokiP2pAPI.setContactOffline(pubKey);
if (isPing) { if (isPing) {
// If this was just a ping, we don't bother sending to storage server // If this was just a ping, we don't bother sending to storage server
log.warn('Ping failed, contact marked offline', e);
return; return;
} }
log.warn('Failed to send P2P message, falling back to storage', e);
} }
} }
@ -194,16 +200,10 @@ class LokiMessageAPI {
nodeComplete(nodeUrl); nodeComplete(nodeUrl);
successfulRequests += 1; successfulRequests += 1;
} catch (e) { } catch (e) {
log.warn('Send message error:', e); log.warn('Loki send message:', e);
if (e instanceof NotFoundError) { if (e instanceof NotFoundError) {
canResolve = false; canResolve = false;
} else if (e instanceof HTTPError) { } else if (e instanceof HTTPError) {
log.error(
`POST ${e.response.url} (store)`,
e.response.status,
'Error sending message'
);
// We mark the node as complete as we could still reach it // We mark the node as complete as we could still reach it
nodeComplete(nodeUrl); nodeComplete(nodeUrl);
} else { } else {
@ -212,7 +212,7 @@ class LokiMessageAPI {
nodeUrl nodeUrl
); );
if (removeNode) { if (removeNode) {
log.error('Loki SendMessages:', e); log.error('Loki send message:', e);
nodeComplete(nodeUrl); nodeComplete(nodeUrl);
failedNodes.push(nodeUrl); failedNodes.push(nodeUrl);
} }
@ -232,11 +232,12 @@ class LokiMessageAPI {
if (swarmNodes.length === 0) { if (swarmNodes.length === 0) {
if (successfulRequests !== 0) { if (successfulRequests !== 0) {
// TODO: Decide how to handle some completed requests but not enough // TODO: Decide how to handle some completed requests but not enough
log.warn(`Partially successful storage message to ${pubKey}`);
return; return;
} }
throw new window.textsecure.EmptySwarmError( throw new window.textsecure.EmptySwarmError(
pubKey, pubKey,
new Error('Ran out of swarm nodes to query') 'Ran out of swarm nodes to query'
); );
} }
} }
@ -250,6 +251,7 @@ class LokiMessageAPI {
.map(nodeUrl => doRequest(nodeUrl)) .map(nodeUrl => doRequest(nodeUrl))
); );
} }
log.info(`Successful storage message to ${pubKey}`);
} }
async retrieveMessages(callback) { async retrieveMessages(callback) {
@ -258,12 +260,7 @@ class LokiMessageAPI {
let canResolve = true; let canResolve = true;
let successfulRequests = 0; let successfulRequests = 0;
let ourSwarmNodes; let ourSwarmNodes = await lokiSnodeAPI.getOurSwarmNodes();
try {
ourSwarmNodes = await lokiSnodeAPI.getOurSwarmNodes();
} catch (e) {
throw new window.textsecure.EmptySwarmError(ourKey, e);
}
const nodeComplete = nodeUrl => { const nodeComplete = nodeUrl => {
completedNodes.push(nodeUrl); completedNodes.push(nodeUrl);
@ -292,16 +289,10 @@ class LokiMessageAPI {
} }
successfulRequests += 1; successfulRequests += 1;
} catch (e) { } catch (e) {
log.warn('Retrieve message error:', e); log.warn('Loki retrieve messages:', e);
if (e instanceof NotFoundError) { if (e instanceof NotFoundError) {
canResolve = false; canResolve = false;
} else if (e instanceof HTTPError) { } else if (e instanceof HTTPError) {
log.error(
`POST ${e.response.url} (retrieve)`,
e.response.status,
`Error retrieving messages from ${nodeUrl}`
);
// We mark the node as complete as we could still reach it // We mark the node as complete as we could still reach it
nodeComplete(nodeUrl); nodeComplete(nodeUrl);
} else { } else {
@ -310,7 +301,7 @@ class LokiMessageAPI {
nodeUrl nodeUrl
); );
if (removeNode) { if (removeNode) {
log.error('Loki RetrieveMessages:', e); log.error('Loki retrieve messages:', e);
nodeComplete(nodeUrl); nodeComplete(nodeUrl);
} }
} }
@ -322,24 +313,18 @@ class LokiMessageAPI {
throw new window.textsecure.DNSResolutionError('Retrieving messages'); throw new window.textsecure.DNSResolutionError('Retrieving messages');
} }
if (Object.keys(ourSwarmNodes).length === 0) { if (Object.keys(ourSwarmNodes).length === 0) {
try {
ourSwarmNodes = await lokiSnodeAPI.getOurSwarmNodes(); ourSwarmNodes = await lokiSnodeAPI.getOurSwarmNodes();
// Filter out the nodes we have already got responses from // Filter out the nodes we have already got responses from
completedNodes.forEach(nodeUrl => delete ourSwarmNodes[nodeUrl]); completedNodes.forEach(nodeUrl => delete ourSwarmNodes[nodeUrl]);
} catch (e) {
throw new window.textsecure.EmptySwarmError(
window.textsecure.storage.user.getNumber(),
e
);
}
if (Object.keys(ourSwarmNodes).length === 0) { if (Object.keys(ourSwarmNodes).length === 0) {
if (successfulRequests !== 0) { if (successfulRequests !== 0) {
// TODO: Decide how to handle some completed requests but not enough // TODO: Decide how to handle some completed requests but not enough
return; return;
} }
throw new window.textsecure.EmptySwarmError( throw new window.textsecure.EmptySwarmError(
window.textsecure.storage.user.getNumber(), ourKey,
new Error('Ran out of swarm nodes to query') 'Ran out of swarm nodes to query'
); );
} }
} }

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

@ -1,5 +1,5 @@
/* eslint-disable class-methods-use-this */ /* eslint-disable class-methods-use-this */
/* global log, window, ConversationController */ /* global window, ConversationController */
const fetch = require('node-fetch'); const fetch = require('node-fetch');
const is = require('@sindresorhus/is'); const is = require('@sindresorhus/is');
@ -148,9 +148,6 @@ class LokiSnodeAPI {
// Try refresh our swarm list once // Try refresh our swarm list once
const ourKey = window.textsecure.storage.user.getNumber(); const ourKey = window.textsecure.storage.user.getNumber();
const nodeAddresses = await this.getSwarmNodes(ourKey); const nodeAddresses = await this.getSwarmNodes(ourKey);
if (!nodeAddresses || nodeAddresses.length === 0) {
throw Error('Could not load our swarm');
}
nodeAddresses.forEach(url => { nodeAddresses.forEach(url => {
this.ourSwarmNodes[url] = { this.ourSwarmNodes[url] = {
@ -174,7 +171,6 @@ class LokiSnodeAPI {
newSwarmNodes = await this.getSwarmNodes(pubKey); newSwarmNodes = await this.getSwarmNodes(pubKey);
} catch (e) { } catch (e) {
// TODO: Handle these errors sensibly // TODO: Handle these errors sensibly
log.error(e);
newSwarmNodes = []; newSwarmNodes = [];
} }
resolve(newSwarmNodes); resolve(newSwarmNodes);
@ -218,7 +214,10 @@ class LokiSnodeAPI {
try { try {
response = await fetch(options.url, fetchOptions); response = await fetch(options.url, fetchOptions);
} catch (e) { } catch (e) {
throw HTTPError('getSwarmNodes fetch error', 0, e.toString()); throw new window.textsecure.EmptySwarmError(
pubKey,
'Could not retrieve swarm nodes'
);
} }
let result; let result;
@ -233,25 +232,15 @@ class LokiSnodeAPI {
result = await response.text(); result = await response.text();
} }
if (response.status >= 0 && response.status < 400) { if (response.status !== 200 || !result.nodes || result.nodes === []) {
return result.nodes; throw new window.textsecure.EmptySwarmError(
} pubKey,
throw HTTPError('getSwarmNodes: error response', response.status, result); 'Could not retrieve swarm nodes'
} );
} }
function HTTPError(message, providedCode, response, stack) { return result.nodes;
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 = LokiSnodeAPI; module.exports = LokiSnodeAPI;

10
libloki/api.js
Unescape Escape View File

@ -33,14 +33,6 @@
lokiAddressMessage, lokiAddressMessage,
}); });
// will be called once the transmission succeeded or failed
const callback = res => {
if (res.errors.length > 0) {
res.errors.forEach(error => log.error(error));
} else {
log.info('Online broadcast message sent successfully');
}
};
const options = { messageType: 'onlineBroadcast', isPing }; const options = { messageType: 'onlineBroadcast', isPing };
// Send a empty message with information about how to contact us directly // Send a empty message with information about how to contact us directly
const outgoingMessage = new textsecure.OutgoingMessage( const outgoingMessage = new textsecure.OutgoingMessage(
@ -49,7 +41,7 @@
[pubKey], // numbers [pubKey], // numbers
content, // message content, // message
true, // silent true, // silent
callback, // callback () => null, // callback
options options
); );
await outgoingMessage.sendToNumber(pubKey); await outgoingMessage.sendToNumber(pubKey);

8
libtextsecure/errors.js
Unescape Escape View File

@ -127,18 +127,14 @@
} }
inherit(Error, UnregisteredUserError); inherit(Error, UnregisteredUserError);
function EmptySwarmError(number, error) { function EmptySwarmError(number, message) {
// eslint-disable-next-line prefer-destructuring // eslint-disable-next-line prefer-destructuring
this.number = number.split('.')[0]; this.number = number.split('.')[0];
ReplayableError.call(this, { ReplayableError.call(this, {
name: 'EmptySwarmError', name: 'EmptySwarmError',
message: 'Could not get any swarm nodes to query', message,
}); });
if (error) {
appendStack(this, error);
}
} }
inherit(ReplayableError, EmptySwarmError); inherit(ReplayableError, EmptySwarmError);

Write Preview
Loading…
Cancel
Save