wip
This commit is contained in:
Caleb James DeLisle
@@ -15,39 +15,17 @@
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
define([
|
||||
'/bower_components/netflux-websocket/netflux-client.js',
|
||||
'/common/sframe-channel.js',
|
||||
'/bower_components/chainpad/chainpad.dist.js',
|
||||
], function (Netflux) {
|
||||
], function (SFrameChannel) {
|
||||
var ChainPad = window.ChainPad;
|
||||
var USE_HISTORY = true;
|
||||
var module = { exports: {} };
|
||||
|
||||
var verbose = function (x) { console.log(x); };
|
||||
verbose = function () {}; // comment out to enable verbose logging
|
||||
|
||||
var unBencode = function (str) { return str.replace(/^\d+:/, ''); };
|
||||
|
||||
module.exports.start = function (config) {
|
||||
console.log(config);
|
||||
var websocketUrl = config.websocketURL;
|
||||
var userName = config.userName;
|
||||
var channel = config.channel;
|
||||
var Crypto = config.crypto;
|
||||
var validateKey = config.validateKey;
|
||||
var readOnly = config.readOnly || false;
|
||||
|
||||
// make sure configuration is defined
|
||||
config = config || {};
|
||||
|
||||
var initializing = true;
|
||||
var toReturn = {};
|
||||
var messagesHistory = [];
|
||||
var chainpadAdapter = {};
|
||||
var realtime;
|
||||
var network = config.network;
|
||||
var lastKnownHash;
|
||||
|
||||
var userList = {
|
||||
var mkUserList = function () {
|
||||
var userList = Object.freeze({
|
||||
change : [],
|
||||
onChange : function(newData) {
|
||||
userList.change.forEach(function (el) {
|
||||
@@ -55,9 +33,9 @@ define([
|
||||
});
|
||||
},
|
||||
users: []
|
||||
};
|
||||
});
|
||||
|
||||
var onJoining = function(peer) {
|
||||
var onJoining = function (peer) {
|
||||
if(peer.length !== 32) { return; }
|
||||
var list = userList.users;
|
||||
var index = list.indexOf(peer);
|
||||
@@ -67,100 +45,8 @@ define([
|
||||
userList.onChange();
|
||||
};
|
||||
|
||||
var onReady = function(wc, network) {
|
||||
// Trigger onReady only if not ready yet. This is important because the history keeper sends a direct
|
||||
// message through "network" when it is synced, and it triggers onReady for each channel joined.
|
||||
if (!initializing) { return; }
|
||||
|
||||
realtime.start();
|
||||
|
||||
if(config.setMyID) {
|
||||
config.setMyID({
|
||||
myID: wc.myID
|
||||
});
|
||||
}
|
||||
// Trigger onJoining with our own Cryptpad username to tell the toolbar that we are synced
|
||||
if (!readOnly) {
|
||||
onJoining(wc.myID);
|
||||
}
|
||||
|
||||
// we're fully synced
|
||||
initializing = false;
|
||||
|
||||
if (config.onReady) {
|
||||
config.onReady({
|
||||
realtime: realtime,
|
||||
network: network,
|
||||
userList: userList,
|
||||
myId: wc.myID,
|
||||
leave: wc.leave
|
||||
});
|
||||
}
|
||||
};
|
||||
|
||||
var onMessage = function(peer, msg, wc, network, direct) {
|
||||
// unpack the history keeper from the webchannel
|
||||
var hk = network.historyKeeper;
|
||||
|
||||
// Old server
|
||||
if(wc && (msg === 0 || msg === '0')) {
|
||||
onReady(wc, network);
|
||||
return;
|
||||
}
|
||||
if (direct && peer !== hk) {
|
||||
return;
|
||||
}
|
||||
if (direct) {
|
||||
var parsed = JSON.parse(msg);
|
||||
if (parsed.validateKey && parsed.channel) {
|
||||
if (parsed.channel === wc.id && !validateKey) {
|
||||
validateKey = parsed.validateKey;
|
||||
}
|
||||
// We have to return even if it is not the current channel:
|
||||
// we don't want to continue with other channels messages here
|
||||
return;
|
||||
}
|
||||
if (parsed.state && parsed.state === 1 && parsed.channel) {
|
||||
if (parsed.channel === wc.id) {
|
||||
onReady(wc, network);
|
||||
}
|
||||
// We have to return even if it is not the current channel:
|
||||
// we don't want to continue with other channels messages here
|
||||
return;
|
||||
}
|
||||
}
|
||||
// The history keeper is different for each channel :
|
||||
// no need to check if the message is related to the current channel
|
||||
if (peer === hk){
|
||||
// if the peer is the 'history keeper', extract their message
|
||||
var parsed1 = JSON.parse(msg);
|
||||
msg = parsed1[4];
|
||||
// Check that this is a message for us
|
||||
if (parsed1[3] !== wc.id) { return; }
|
||||
}
|
||||
|
||||
lastKnownHash = msg.slice(0,64);
|
||||
var message = chainpadAdapter.msgIn(peer, msg);
|
||||
|
||||
verbose(message);
|
||||
|
||||
if (!initializing) {
|
||||
if (config.onLocal) {
|
||||
config.onLocal();
|
||||
}
|
||||
}
|
||||
|
||||
// slice off the bencoded header
|
||||
// Why are we getting bencoded stuff to begin with?
|
||||
// FIXME this shouldn't be necessary
|
||||
message = unBencode(message);//.slice(message.indexOf(':[') + 1);
|
||||
|
||||
// pass the message into Chainpad
|
||||
realtime.message(message);
|
||||
};
|
||||
|
||||
// update UI components to show that one of the other peers has left
|
||||
var onLeaving = function(peer) {
|
||||
var onLeaving = function (peer) {
|
||||
var list = userList.users;
|
||||
var index = list.indexOf(peer);
|
||||
if(index !== -1) {
|
||||
@@ -169,246 +55,93 @@ define([
|
||||
userList.onChange();
|
||||
};
|
||||
|
||||
// shim between chainpad and netflux
|
||||
chainpadAdapter = {
|
||||
msgIn : function(peerId, msg) {
|
||||
msg = msg.replace(/^cp\|/, '');
|
||||
try {
|
||||
var decryptedMsg = Crypto.decrypt(msg, validateKey);
|
||||
messagesHistory.push(decryptedMsg);
|
||||
return decryptedMsg;
|
||||
} catch (err) {
|
||||
console.error(err);
|
||||
return msg;
|
||||
}
|
||||
},
|
||||
msgOut : function(msg) {
|
||||
if (readOnly) { return; }
|
||||
try {
|
||||
var cmsg = Crypto.encrypt(msg);
|
||||
if (msg.indexOf('[4') === 0) { cmsg = 'cp|' + cmsg; }
|
||||
return cmsg;
|
||||
} catch (err) {
|
||||
console.log(msg);
|
||||
throw err;
|
||||
}
|
||||
}
|
||||
var onReset = function () {
|
||||
userList.users.forEach(onLeaving);
|
||||
};
|
||||
|
||||
var createRealtime = function() {
|
||||
return ChainPad.create({
|
||||
userName: userName,
|
||||
initialState: config.initialState,
|
||||
transformFunction: config.transformFunction,
|
||||
validateContent: config.validateContent,
|
||||
avgSyncMilliseconds: config.avgSyncMilliseconds,
|
||||
logLevel: typeof(config.logLevel) !== 'undefined'? config.logLevel : 1
|
||||
});
|
||||
};
|
||||
|
||||
// We use an object to store the webchannel so that we don't have to push new handlers to chainpad
|
||||
// and remove the old ones when reconnecting and keeping the same 'realtime' object
|
||||
// See realtime.onMessage below: we call wc.bcast(...) but wc may change
|
||||
var wcObject = {};
|
||||
var onOpen = function(wc, network, initialize) {
|
||||
wcObject.wc = wc;
|
||||
channel = wc.id;
|
||||
|
||||
// Add the existing peers in the userList
|
||||
wc.members.forEach(onJoining);
|
||||
|
||||
// Add the handlers to the WebChannel
|
||||
wc.on('message', function (msg, sender) { //Channel msg
|
||||
onMessage(sender, msg, wc, network);
|
||||
});
|
||||
wc.on('join', onJoining);
|
||||
wc.on('leave', onLeaving);
|
||||
|
||||
if (initialize) {
|
||||
toReturn.realtime = realtime = createRealtime();
|
||||
|
||||
realtime._patch = realtime.patch;
|
||||
realtime.patch = function (patch, x, y) {
|
||||
if (initializing) {
|
||||
console.error("attempted to change the content before chainpad was synced");
|
||||
}
|
||||
return realtime._patch(patch, x, y);
|
||||
};
|
||||
realtime._change = realtime.change;
|
||||
realtime.change = function (offset, count, chars) {
|
||||
if (initializing) {
|
||||
console.error("attempted to change the content before chainpad was synced");
|
||||
}
|
||||
return realtime._change(offset, count, chars);
|
||||
};
|
||||
|
||||
if (config.onInit) {
|
||||
config.onInit({
|
||||
myID: wc.myID,
|
||||
realtime: realtime,
|
||||
getLag: network.getLag,
|
||||
userList: userList,
|
||||
network: network,
|
||||
channel: channel
|
||||
});
|
||||
}
|
||||
|
||||
// Sending a message...
|
||||
realtime.onMessage(function(message, cb) {
|
||||
// Filter messages sent by Chainpad to make it compatible with Netflux
|
||||
message = chainpadAdapter.msgOut(message);
|
||||
if(message) {
|
||||
// Do not remove wcObject, it allows us to use a new 'wc' without changing the handler if we
|
||||
// want to keep the same chainpad (realtime) object
|
||||
wcObject.wc.bcast(message).then(function() {
|
||||
cb();
|
||||
}, function(err) {
|
||||
// The message has not been sent, display the error.
|
||||
console.error(err);
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
realtime.onPatch(function () {
|
||||
if (config.onRemote) {
|
||||
config.onRemote({
|
||||
realtime: realtime
|
||||
});
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
// Get the channel history
|
||||
if(USE_HISTORY) {
|
||||
var hk;
|
||||
|
||||
wc.members.forEach(function (p) {
|
||||
if (p.length === 16) { hk = p; }
|
||||
});
|
||||
network.historyKeeper = hk;
|
||||
|
||||
var msg = ['GET_HISTORY', wc.id];
|
||||
// Add the validateKey if we are the channel creator and we have a validateKey
|
||||
msg.push(validateKey);
|
||||
msg.push(lastKnownHash);
|
||||
if (hk) { network.sendto(hk, JSON.stringify(msg)); }
|
||||
}
|
||||
else {
|
||||
onReady(wc, network);
|
||||
}
|
||||
};
|
||||
|
||||
// Set a flag to avoid calling onAbort or onConnectionChange when the user is leaving the page
|
||||
var isIntentionallyLeaving = false;
|
||||
window.addEventListener("beforeunload", function () {
|
||||
isIntentionallyLeaving = true;
|
||||
return Object.freeze({
|
||||
list: userList,
|
||||
onJoin: onJoining,
|
||||
onLeave: onLeaving,
|
||||
onReset: onReset
|
||||
});
|
||||
};
|
||||
|
||||
var findChannelById = function(webChannels, channelId) {
|
||||
var webChannel;
|
||||
module.exports.start = function (config) {
|
||||
var onConnectionChange = config.onConnectionChange || function () { };
|
||||
var onRemote = config.onRemote || function () { };
|
||||
var onInit = config.onInit || function () { };
|
||||
var onLocal = config.onLocal || function () { };
|
||||
var setMyID = config.setMyID || function () { };
|
||||
var onReady = config.onReady || function () { };
|
||||
var userName = config.userName;
|
||||
var initialState = config.initialState;
|
||||
var transformFunction = config.transformFunction;
|
||||
var validateContent = config.validateContent;
|
||||
var avgSyncMilliseconds = config.avgSyncMilliseconds;
|
||||
var logLevel = typeof(config.logLevel) !== 'undefined'? config.logLevel : 1;
|
||||
var readOnly = config.readOnly || false;
|
||||
config = undefined;
|
||||
|
||||
// Array.some terminates once a truthy value is returned
|
||||
// best case is faster than forEach, though webchannel arrays seem
|
||||
// to consistently have a length of 1
|
||||
webChannels.some(function(chan) {
|
||||
if(chan.id === channelId) { webChannel = chan; return true;}
|
||||
var chainpad;
|
||||
var userList = mkUserList();
|
||||
var myID;
|
||||
var isReady = false;
|
||||
|
||||
SFrameChannel.on('EV_RT_JOIN', userList.onJoin);
|
||||
SFrameChannel.on('EV_RT_LEAVE', userList.onLeave);
|
||||
SFrameChannel.on('EV_RT_DISCONNECT', function () {
|
||||
isReady = false;
|
||||
userList.onReset();
|
||||
onConnectionChange({ state: false });
|
||||
});
|
||||
SFrameChannel.on('EV_RT_CONNECT', function (content) {
|
||||
content.members.forEach(userList.onJoin);
|
||||
myID = content.myID;
|
||||
isReady = false;
|
||||
if (chainpad) {
|
||||
// it's a reconnect
|
||||
onConnectionChange({ state: true, myId: myID });
|
||||
return;
|
||||
}
|
||||
chainpad = ChainPad.create({
|
||||
userName: userName,
|
||||
initialState: initialState,
|
||||
transformFunction: transformFunction,
|
||||
validateContent: validateContent,
|
||||
avgSyncMilliseconds: avgSyncMilliseconds,
|
||||
logLevel: logLevel
|
||||
});
|
||||
return webChannel;
|
||||
};
|
||||
|
||||
var onConnectError = function (err) {
|
||||
if (config.onError) {
|
||||
config.onError({
|
||||
error: err.type
|
||||
});
|
||||
}
|
||||
};
|
||||
|
||||
var joinSession = function (endPoint, cb) {
|
||||
// a websocket URL has been provided
|
||||
// connect to it with Netflux.
|
||||
if (typeof(endPoint) === 'string') {
|
||||
Netflux.connect(endPoint).then(cb, onConnectError);
|
||||
} else if (typeof(endPoint.then) === 'function') {
|
||||
// a netflux network promise was provided
|
||||
// connect to it and use a channel
|
||||
endPoint.then(cb, onConnectError);
|
||||
} else {
|
||||
// assume it's a network and try to connect.
|
||||
cb(endPoint);
|
||||
}
|
||||
};
|
||||
|
||||
var firstConnection = true;
|
||||
/* Connect to the Netflux network, or fall back to a WebSocket
|
||||
in theory this lets us connect to more netflux channels using only
|
||||
one network. */
|
||||
var connectTo = function (network) {
|
||||
// join the netflux network, promise to handle opening of the channel
|
||||
network.join(channel || null).then(function(wc) {
|
||||
onOpen(wc, network, firstConnection);
|
||||
firstConnection = false;
|
||||
}, function(error) {
|
||||
console.error(error);
|
||||
chainpad.onMessage(function(message, cb) {
|
||||
SFrameChannel.query('Q_RT_MESSAGE', message, cb);
|
||||
});
|
||||
};
|
||||
|
||||
joinSession(network || websocketUrl, function (network) {
|
||||
// pass messages that come out of netflux into our local handler
|
||||
if (firstConnection) {
|
||||
toReturn.network = network;
|
||||
|
||||
network.on('disconnect', function (reason) {
|
||||
if (isIntentionallyLeaving) { return; }
|
||||
if (reason === "network.disconnect() called") { return; }
|
||||
if (config.onConnectionChange) {
|
||||
config.onConnectionChange({
|
||||
state: false
|
||||
});
|
||||
return;
|
||||
}
|
||||
if (config.onAbort) {
|
||||
config.onAbort({
|
||||
reason: reason
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
network.on('reconnect', function (uid) {
|
||||
if (config.onConnectionChange) {
|
||||
config.onConnectionChange({
|
||||
state: true,
|
||||
myId: uid
|
||||
});
|
||||
var afterReconnecting = function () {
|
||||
initializing = true;
|
||||
userList.users=[];
|
||||
joinSession(network, connectTo);
|
||||
};
|
||||
if (config.beforeReconnecting) {
|
||||
config.beforeReconnecting(function (newKey, newContent) {
|
||||
channel = newKey;
|
||||
config.initialState = newContent;
|
||||
afterReconnecting();
|
||||
});
|
||||
return;
|
||||
}
|
||||
afterReconnecting();
|
||||
}
|
||||
});
|
||||
|
||||
network.on('message', function (msg, sender) { // Direct message
|
||||
var wchan = findChannelById(network.webChannels, channel);
|
||||
if(wchan) {
|
||||
onMessage(sender, msg, wchan, network, true);
|
||||
}
|
||||
});
|
||||
chainpad.onPatch(function () {
|
||||
onRemote({ realtime: chainpad });
|
||||
});
|
||||
onInit({
|
||||
myID: content.myID,
|
||||
realtime: chainpad,
|
||||
userList: userList,
|
||||
readOnly: readOnly
|
||||
});
|
||||
});
|
||||
SFrameChannel.on('Q_RT_MESSAGE', function (content, cb) {
|
||||
if (isReady) {
|
||||
onLocal(); // should be onBeforeMessage
|
||||
}
|
||||
|
||||
connectTo(network);
|
||||
}, onConnectError);
|
||||
|
||||
return toReturn;
|
||||
chainpad.message(content);
|
||||
cb('OK');
|
||||
});
|
||||
SFrameChannel.on('EV_RT_READY', function () {
|
||||
if (isReady) { return; }
|
||||
isReady = true;
|
||||
chainpad.start();
|
||||
setMyID({ myID: myID });
|
||||
// Trigger onJoining with our own Cryptpad username to tell the toolbar that we are synced
|
||||
if (!readOnly) { userList.onJoin(myID); }
|
||||
onReady({ realtime: chainpad });
|
||||
});
|
||||
return;
|
||||
};
|
||||
return module.exports;
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user