Merge branch 'staging' into ooBuild
yflory
5 years ago
commit
f7e0d03898
@ -0,0 +1,45 @@
|
|||||||
|
---
|
||||||
|
name: Bug report
|
||||||
|
about: Create a report to help us improve
|
||||||
|
title: ''
|
||||||
|
labels: ''
|
||||||
|
assignees: ''
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
**Describe the bug**
|
||||||
|
A clear and concise description of what the bug is.
|
||||||
|
|
||||||
|
**Where did it happen?**
|
||||||
|
Did the issue occur on CryptPad.fr or an instance hosted by a third-party?
|
||||||
|
If on another instance, please provide its full URL.
|
||||||
|
|
||||||
|
**To Reproduce**
|
||||||
|
Steps to reproduce the behavior:
|
||||||
|
1. Go to '...'
|
||||||
|
2. Click on '....'
|
||||||
|
3. Scroll down to '....'
|
||||||
|
4. See error
|
||||||
|
|
||||||
|
**Expected behavior**
|
||||||
|
A clear and concise description of what you expected to happen.
|
||||||
|
|
||||||
|
**Screenshots**
|
||||||
|
If applicable, add screenshots to help explain your problem.
|
||||||
|
|
||||||
|
**Browser (please complete the following information):**
|
||||||
|
- OS: [e.g. iOS]
|
||||||
|
- Browser [e.g. firefox, tor browser, chrome, safari, brave, edge, ???]
|
||||||
|
- variations [e.g. Firefox nightly, Firefox ESR, Chromium, Ungoogled chrome]
|
||||||
|
- Version [e.g. 22]
|
||||||
|
- Extensions installed (UBlock Origin, Passbolt, LibreJS]
|
||||||
|
- Browser tweaks [e.g. firefox "Enhanced Tracking Protection" strict/custom mode, tor browser "safer" security level, chrome incognito mode]
|
||||||
|
|
||||||
|
**Smartphone (please complete the following information):**
|
||||||
|
- Device: [e.g. iPhone6]
|
||||||
|
- OS: [e.g. iOS8.1]
|
||||||
|
- Browser [e.g. stock browser, safari]
|
||||||
|
- Version [e.g. 22]
|
||||||
|
|
||||||
|
**Additional context**
|
||||||
|
Add any other context about the problem here.
|
||||||
File diff suppressed because it is too large
Load Diff
@ -1,65 +0,0 @@
|
|||||||
#!/usr/bin/env node
|
|
||||||
/* globals process */
|
|
||||||
|
|
||||||
var Config = require("./config");
|
|
||||||
var Fs = require("fs");
|
|
||||||
var Storage = require(Config.storage);
|
|
||||||
|
|
||||||
var args = process.argv.slice(2);
|
|
||||||
|
|
||||||
if (!args.length) {
|
|
||||||
console.log("Insufficient arguments!");
|
|
||||||
console.log("Pass a path to a database backup!");
|
|
||||||
process.exit();
|
|
||||||
}
|
|
||||||
|
|
||||||
var dump = Fs.readFileSync(args[0], 'utf-8');
|
|
||||||
|
|
||||||
var ready = function (store) {
|
|
||||||
var lock = 0;
|
|
||||||
dump.split(/\n/)
|
|
||||||
.filter(function (line) {
|
|
||||||
return line;
|
|
||||||
})
|
|
||||||
.forEach(function (line, i) {
|
|
||||||
lock++;
|
|
||||||
var parts;
|
|
||||||
|
|
||||||
var channel;
|
|
||||||
var msg;
|
|
||||||
|
|
||||||
line.replace(/^(.*?)\|(.*)$/, function (all, c, m) {
|
|
||||||
channel = c;
|
|
||||||
msg = m;
|
|
||||||
return '';
|
|
||||||
});
|
|
||||||
|
|
||||||
if (!channel || !msg) {
|
|
||||||
console.log("BAD LINE on line %s", i);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
try {
|
|
||||||
JSON.parse(msg);
|
|
||||||
} catch (err) {
|
|
||||||
console.log("BAD LINE on line %s", i);
|
|
||||||
console.log(msg);
|
|
||||||
console.log();
|
|
||||||
}
|
|
||||||
|
|
||||||
store.message(channel, msg, function () {
|
|
||||||
console.log(line);
|
|
||||||
lock--;
|
|
||||||
if (!lock) {
|
|
||||||
console.log("DONE");
|
|
||||||
process.exit(0);
|
|
||||||
}
|
|
||||||
});
|
|
||||||
});
|
|
||||||
};
|
|
||||||
|
|
||||||
Storage.create(Config, function (store) {
|
|
||||||
console.log("READY");
|
|
||||||
ready(store);
|
|
||||||
});
|
|
||||||
|
|
||||||
@ -0,0 +1,34 @@
|
|||||||
|
/* jshint esversion: 6 */
|
||||||
|
const WebSocketServer = require('ws').Server;
|
||||||
|
const NetfluxSrv = require('chainpad-server');
|
||||||
|
|
||||||
|
module.exports.create = function (config) {
|
||||||
|
// asynchronously create a historyKeeper and RPC together
|
||||||
|
require('./historyKeeper.js').create(config, function (err, historyKeeper) {
|
||||||
|
if (err) { throw err; }
|
||||||
|
|
||||||
|
var log = config.log;
|
||||||
|
|
||||||
|
// spawn ws server and attach netflux event handlers
|
||||||
|
NetfluxSrv.create(new WebSocketServer({ server: config.httpServer}))
|
||||||
|
.on('channelClose', historyKeeper.channelClose)
|
||||||
|
.on('channelMessage', historyKeeper.channelMessage)
|
||||||
|
.on('channelOpen', historyKeeper.channelOpen)
|
||||||
|
.on('sessionClose', historyKeeper.sessionClose)
|
||||||
|
.on('error', function (error, label, info) {
|
||||||
|
if (!error) { return; }
|
||||||
|
/* labels:
|
||||||
|
SEND_MESSAGE_FAIL, SEND_MESSAGE_FAIL_2, FAIL_TO_DISCONNECT,
|
||||||
|
FAIL_TO_TERMINATE, HANDLE_CHANNEL_LEAVE, NETFLUX_BAD_MESSAGE,
|
||||||
|
NETFLUX_WEBSOCKET_ERROR
|
||||||
|
*/
|
||||||
|
log.error(label, {
|
||||||
|
code: error.code,
|
||||||
|
message: error.message,
|
||||||
|
stack: error.stack,
|
||||||
|
info: info,
|
||||||
|
});
|
||||||
|
})
|
||||||
|
.register(historyKeeper.id, historyKeeper.directMessage);
|
||||||
|
});
|
||||||
|
};
|
||||||
@ -0,0 +1,172 @@
|
|||||||
|
/*jshint esversion: 6 */
|
||||||
|
/* globals Buffer*/
|
||||||
|
var Block = module.exports;
|
||||||
|
|
||||||
|
const Fs = require("fs");
|
||||||
|
const Fse = require("fs-extra");
|
||||||
|
const Path = require("path");
|
||||||
|
const Nacl = require("tweetnacl/nacl-fast");
|
||||||
|
const nThen = require("nthen");
|
||||||
|
|
||||||
|
const Util = require("../common-util");
|
||||||
|
|
||||||
|
/*
|
||||||
|
We assume that the server is secured against MitM attacks
|
||||||
|
via HTTPS, and that malicious actors do not have code execution
|
||||||
|
capabilities. If they do, we have much more serious problems.
|
||||||
|
|
||||||
|
The capability to replay a block write or remove results in either
|
||||||
|
a denial of service for the user whose block was removed, or in the
|
||||||
|
case of a write, a rollback to an earlier password.
|
||||||
|
|
||||||
|
Since block modification is destructive, this can result in loss
|
||||||
|
of access to the user's drive.
|
||||||
|
|
||||||
|
So long as the detached signature is never observed by a malicious
|
||||||
|
party, and the server discards it after proof of knowledge, replays
|
||||||
|
are not possible. However, this precludes verification of the signature
|
||||||
|
at a later time.
|
||||||
|
|
||||||
|
Despite this, an integrity check is still possible by the original
|
||||||
|
author of the block, since we assume that the block will have been
|
||||||
|
encrypted with xsalsa20-poly1305 which is authenticated.
|
||||||
|
*/
|
||||||
|
var validateLoginBlock = function (Env, publicKey, signature, block, cb) { // FIXME BLOCKS
|
||||||
|
// convert the public key to a Uint8Array and validate it
|
||||||
|
if (typeof(publicKey) !== 'string') { return void cb('E_INVALID_KEY'); }
|
||||||
|
|
||||||
|
var u8_public_key;
|
||||||
|
try {
|
||||||
|
u8_public_key = Nacl.util.decodeBase64(publicKey);
|
||||||
|
} catch (e) {
|
||||||
|
return void cb('E_INVALID_KEY');
|
||||||
|
}
|
||||||
|
|
||||||
|
var u8_signature;
|
||||||
|
try {
|
||||||
|
u8_signature = Nacl.util.decodeBase64(signature);
|
||||||
|
} catch (e) {
|
||||||
|
Env.Log.error('INVALID_BLOCK_SIGNATURE', e);
|
||||||
|
return void cb('E_INVALID_SIGNATURE');
|
||||||
|
}
|
||||||
|
|
||||||
|
// convert the block to a Uint8Array
|
||||||
|
var u8_block;
|
||||||
|
try {
|
||||||
|
u8_block = Nacl.util.decodeBase64(block);
|
||||||
|
} catch (e) {
|
||||||
|
return void cb('E_INVALID_BLOCK');
|
||||||
|
}
|
||||||
|
|
||||||
|
// take its hash
|
||||||
|
var hash = Nacl.hash(u8_block);
|
||||||
|
|
||||||
|
// validate the signature against the hash of the content
|
||||||
|
var verified = Nacl.sign.detached.verify(hash, u8_signature, u8_public_key);
|
||||||
|
|
||||||
|
// existing authentication ensures that users cannot replay old blocks
|
||||||
|
|
||||||
|
// call back with (err) if unsuccessful
|
||||||
|
if (!verified) { return void cb("E_COULD_NOT_VERIFY"); }
|
||||||
|
|
||||||
|
return void cb(null, u8_block);
|
||||||
|
};
|
||||||
|
|
||||||
|
var createLoginBlockPath = function (Env, publicKey) { // FIXME BLOCKS
|
||||||
|
// prepare publicKey to be used as a file name
|
||||||
|
var safeKey = Util.escapeKeyCharacters(publicKey);
|
||||||
|
|
||||||
|
// validate safeKey
|
||||||
|
if (typeof(safeKey) !== 'string') {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
// derive the full path
|
||||||
|
// /home/cryptpad/cryptpad/block/fg/fg32kefksjdgjkewrjksdfksjdfsdfskdjfsfd
|
||||||
|
return Path.join(Env.paths.block, safeKey.slice(0, 2), safeKey);
|
||||||
|
};
|
||||||
|
|
||||||
|
Block.writeLoginBlock = function (Env, safeKey, msg, cb) { // FIXME BLOCKS
|
||||||
|
//console.log(msg);
|
||||||
|
var publicKey = msg[0];
|
||||||
|
var signature = msg[1];
|
||||||
|
var block = msg[2];
|
||||||
|
|
||||||
|
validateLoginBlock(Env, publicKey, signature, block, function (e, validatedBlock) {
|
||||||
|
if (e) { return void cb(e); }
|
||||||
|
if (!(validatedBlock instanceof Uint8Array)) { return void cb('E_INVALID_BLOCK'); }
|
||||||
|
|
||||||
|
// derive the filepath
|
||||||
|
var path = createLoginBlockPath(Env, publicKey);
|
||||||
|
|
||||||
|
// make sure the path is valid
|
||||||
|
if (typeof(path) !== 'string') {
|
||||||
|
return void cb('E_INVALID_BLOCK_PATH');
|
||||||
|
}
|
||||||
|
|
||||||
|
var parsed = Path.parse(path);
|
||||||
|
if (!parsed || typeof(parsed.dir) !== 'string') {
|
||||||
|
return void cb("E_INVALID_BLOCK_PATH_2");
|
||||||
|
}
|
||||||
|
|
||||||
|
nThen(function (w) {
|
||||||
|
// make sure the path to the file exists
|
||||||
|
Fse.mkdirp(parsed.dir, w(function (e) {
|
||||||
|
if (e) {
|
||||||
|
w.abort();
|
||||||
|
cb(e);
|
||||||
|
}
|
||||||
|
}));
|
||||||
|
}).nThen(function () {
|
||||||
|
// actually write the block
|
||||||
|
|
||||||
|
// flow is dumb and I need to guard against this which will never happen
|
||||||
|
/*:: if (typeof(validatedBlock) === 'undefined') { throw new Error('should never happen'); } */
|
||||||
|
/*:: if (typeof(path) === 'undefined') { throw new Error('should never happen'); } */
|
||||||
|
Fs.writeFile(path, Buffer.from(validatedBlock), { encoding: "binary", }, function (err) {
|
||||||
|
if (err) { return void cb(err); }
|
||||||
|
cb();
|
||||||
|
});
|
||||||
|
});
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
|
/*
|
||||||
|
When users write a block, they upload the block, and provide
|
||||||
|
a signature proving that they deserve to be able to write to
|
||||||
|
the location determined by the public key.
|
||||||
|
|
||||||
|
When removing a block, there is nothing to upload, but we need
|
||||||
|
to sign something. Since the signature is considered sensitive
|
||||||
|
information, we can just sign some constant and use that as proof.
|
||||||
|
|
||||||
|
*/
|
||||||
|
Block.removeLoginBlock = function (Env, safeKey, msg, cb) { // FIXME BLOCKS
|
||||||
|
var publicKey = msg[0];
|
||||||
|
var signature = msg[1];
|
||||||
|
var block = Nacl.util.decodeUTF8('DELETE_BLOCK'); // clients and the server will have to agree on this constant
|
||||||
|
|
||||||
|
validateLoginBlock(Env, publicKey, signature, block, function (e /*::, validatedBlock */) {
|
||||||
|
if (e) { return void cb(e); }
|
||||||
|
// derive the filepath
|
||||||
|
var path = createLoginBlockPath(Env, publicKey);
|
||||||
|
|
||||||
|
// make sure the path is valid
|
||||||
|
if (typeof(path) !== 'string') {
|
||||||
|
return void cb('E_INVALID_BLOCK_PATH');
|
||||||
|
}
|
||||||
|
|
||||||
|
// FIXME COLDSTORAGE
|
||||||
|
Fs.unlink(path, function (err) {
|
||||||
|
Env.Log.info('DELETION_BLOCK_BY_OWNER_RPC', {
|
||||||
|
publicKey: publicKey,
|
||||||
|
path: path,
|
||||||
|
status: err? String(err): 'SUCCESS',
|
||||||
|
});
|
||||||
|
|
||||||
|
if (err) { return void cb(err); }
|
||||||
|
cb();
|
||||||
|
});
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
@ -0,0 +1,301 @@
|
|||||||
|
/*jshint esversion: 6 */
|
||||||
|
const Channel = module.exports;
|
||||||
|
|
||||||
|
const Util = require("../common-util");
|
||||||
|
const nThen = require("nthen");
|
||||||
|
const Core = require("./core");
|
||||||
|
const Metadata = require("./metadata");
|
||||||
|
const HK = require("../hk-util");
|
||||||
|
|
||||||
|
Channel.clearOwnedChannel = function (Env, safeKey, channelId, cb, Server) {
|
||||||
|
if (typeof(channelId) !== 'string' || channelId.length !== 32) {
|
||||||
|
return cb('INVALID_ARGUMENTS');
|
||||||
|
}
|
||||||
|
var unsafeKey = Util.unescapeKeyCharacters(safeKey);
|
||||||
|
|
||||||
|
Metadata.getMetadata(Env, channelId, function (err, metadata) {
|
||||||
|
if (err) { return void cb(err); }
|
||||||
|
if (!Core.hasOwners(metadata)) { return void cb('E_NO_OWNERS'); }
|
||||||
|
// Confirm that the channel is owned by the user in question
|
||||||
|
if (!Core.isOwner(metadata, unsafeKey)) {
|
||||||
|
return void cb('INSUFFICIENT_PERMISSIONS');
|
||||||
|
}
|
||||||
|
return void Env.msgStore.clearChannel(channelId, function (e) {
|
||||||
|
if (e) { return void cb(e); }
|
||||||
|
cb();
|
||||||
|
|
||||||
|
const channel_cache = Env.channel_cache;
|
||||||
|
|
||||||
|
const clear = function () {
|
||||||
|
// delete the channel cache because it will have been invalidated
|
||||||
|
delete channel_cache[channelId];
|
||||||
|
};
|
||||||
|
|
||||||
|
nThen(function (w) {
|
||||||
|
Server.getChannelUserList(channelId).forEach(function (userId) {
|
||||||
|
Server.send(userId, [
|
||||||
|
0,
|
||||||
|
Env.historyKeeper.id,
|
||||||
|
'MSG',
|
||||||
|
userId,
|
||||||
|
JSON.stringify({
|
||||||
|
error: 'ECLEARED',
|
||||||
|
channel: channelId
|
||||||
|
})
|
||||||
|
], w());
|
||||||
|
});
|
||||||
|
}).nThen(function () {
|
||||||
|
clear();
|
||||||
|
}).orTimeout(function () {
|
||||||
|
Env.Log.warn("ON_CHANNEL_CLEARED_TIMEOUT", channelId);
|
||||||
|
clear();
|
||||||
|
}, 30000);
|
||||||
|
});
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
|
Channel.removeOwnedChannel = function (Env, safeKey, channelId, cb, Server) {
|
||||||
|
if (typeof(channelId) !== 'string' || !Core.isValidId(channelId)) {
|
||||||
|
return cb('INVALID_ARGUMENTS');
|
||||||
|
}
|
||||||
|
var unsafeKey = Util.unescapeKeyCharacters(safeKey);
|
||||||
|
|
||||||
|
if (Env.blobStore.isFileId(channelId)) {
|
||||||
|
var blobId = channelId;
|
||||||
|
|
||||||
|
return void nThen(function (w) {
|
||||||
|
// check if you have permissions
|
||||||
|
Env.blobStore.isOwnedBy(safeKey, blobId, w(function (err, owned) {
|
||||||
|
if (err || !owned) {
|
||||||
|
w.abort();
|
||||||
|
return void cb("INSUFFICIENT_PERMISSIONS");
|
||||||
|
}
|
||||||
|
}));
|
||||||
|
}).nThen(function (w) {
|
||||||
|
// remove the blob
|
||||||
|
return void Env.blobStore.archive.blob(blobId, w(function (err) {
|
||||||
|
Env.Log.info('ARCHIVAL_OWNED_FILE_BY_OWNER_RPC', {
|
||||||
|
safeKey: safeKey,
|
||||||
|
blobId: blobId,
|
||||||
|
status: err? String(err): 'SUCCESS',
|
||||||
|
});
|
||||||
|
if (err) {
|
||||||
|
w.abort();
|
||||||
|
return void cb(err);
|
||||||
|
}
|
||||||
|
}));
|
||||||
|
}).nThen(function () {
|
||||||
|
// archive the proof
|
||||||
|
return void Env.blobStore.archive.proof(safeKey, blobId, function (err) {
|
||||||
|
Env.Log.info("ARCHIVAL_PROOF_REMOVAL_BY_OWNER_RPC", {
|
||||||
|
safeKey: safeKey,
|
||||||
|
blobId: blobId,
|
||||||
|
status: err? String(err): 'SUCCESS',
|
||||||
|
});
|
||||||
|
if (err) {
|
||||||
|
return void cb("E_PROOF_REMOVAL");
|
||||||
|
}
|
||||||
|
cb(void 0, 'OK');
|
||||||
|
});
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
Metadata.getMetadata(Env, channelId, function (err, metadata) {
|
||||||
|
if (err) { return void cb(err); }
|
||||||
|
if (!Core.hasOwners(metadata)) { return void cb('E_NO_OWNERS'); }
|
||||||
|
if (!Core.isOwner(metadata, unsafeKey)) {
|
||||||
|
return void cb('INSUFFICIENT_PERMISSIONS');
|
||||||
|
}
|
||||||
|
// temporarily archive the file
|
||||||
|
return void Env.msgStore.archiveChannel(channelId, function (e) {
|
||||||
|
Env.Log.info('ARCHIVAL_CHANNEL_BY_OWNER_RPC', {
|
||||||
|
unsafeKey: unsafeKey,
|
||||||
|
channelId: channelId,
|
||||||
|
status: e? String(e): 'SUCCESS',
|
||||||
|
});
|
||||||
|
if (e) {
|
||||||
|
return void cb(e);
|
||||||
|
}
|
||||||
|
cb(void 0, 'OK');
|
||||||
|
|
||||||
|
const channel_cache = Env.channel_cache;
|
||||||
|
const metadata_cache = Env.metadata_cache;
|
||||||
|
|
||||||
|
const clear = function () {
|
||||||
|
delete channel_cache[channelId];
|
||||||
|
Server.clearChannel(channelId);
|
||||||
|
delete metadata_cache[channelId];
|
||||||
|
};
|
||||||
|
|
||||||
|
// an owner of a channel deleted it
|
||||||
|
nThen(function (w) {
|
||||||
|
// close the channel in the store
|
||||||
|
Env.msgStore.closeChannel(channelId, w());
|
||||||
|
}).nThen(function (w) {
|
||||||
|
// Server.channelBroadcast would be better
|
||||||
|
// but we can't trust it to track even one callback,
|
||||||
|
// let alone many in parallel.
|
||||||
|
// so we simulate it on this side to avoid race conditions
|
||||||
|
Server.getChannelUserList(channelId).forEach(function (userId) {
|
||||||
|
Server.send(userId, [
|
||||||
|
0,
|
||||||
|
Env.historyKeeper.id,
|
||||||
|
"MSG",
|
||||||
|
userId,
|
||||||
|
JSON.stringify({
|
||||||
|
error: 'EDELETED',
|
||||||
|
channel: channelId,
|
||||||
|
})
|
||||||
|
], w());
|
||||||
|
});
|
||||||
|
}).nThen(function () {
|
||||||
|
// clear the channel's data from memory
|
||||||
|
// once you've sent everyone a notice that the channel has been deleted
|
||||||
|
clear();
|
||||||
|
}).orTimeout(function () {
|
||||||
|
Env.Log.warn('ON_CHANNEL_DELETED_TIMEOUT', channelId);
|
||||||
|
clear();
|
||||||
|
}, 30000);
|
||||||
|
});
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
|
Channel.trimHistory = function (Env, safeKey, data, cb) {
|
||||||
|
if (!(data && typeof(data.channel) === 'string' && typeof(data.hash) === 'string' && data.hash.length === 64)) {
|
||||||
|
return void cb('INVALID_ARGS');
|
||||||
|
}
|
||||||
|
|
||||||
|
var channelId = data.channel;
|
||||||
|
var unsafeKey = Util.unescapeKeyCharacters(safeKey);
|
||||||
|
var hash = data.hash;
|
||||||
|
|
||||||
|
nThen(function (w) {
|
||||||
|
Metadata.getMetadata(Env, channelId, w(function (err, metadata) {
|
||||||
|
if (err) { return void cb(err); }
|
||||||
|
if (!Core.hasOwners(metadata)) {
|
||||||
|
w.abort();
|
||||||
|
return void cb('E_NO_OWNERS');
|
||||||
|
}
|
||||||
|
if (!Core.isOwner(metadata, unsafeKey)) {
|
||||||
|
w.abort();
|
||||||
|
return void cb("INSUFFICIENT_PERMISSIONS");
|
||||||
|
}
|
||||||
|
// else fall through to the next block
|
||||||
|
}));
|
||||||
|
}).nThen(function () {
|
||||||
|
Env.msgStore.trimChannel(channelId, hash, function (err) {
|
||||||
|
if (err) { return void cb(err); }
|
||||||
|
// clear historyKeeper's cache for this channel
|
||||||
|
Env.historyKeeper.channelClose(channelId);
|
||||||
|
cb(void 0, 'OK');
|
||||||
|
delete Env.channel_cache[channelId];
|
||||||
|
delete Env.metadata_cache[channelId];
|
||||||
|
});
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
|
var ARRAY_LINE = /^\[/;
|
||||||
|
|
||||||
|
/* Files can contain metadata but not content
|
||||||
|
call back with true if the channel log has no content other than metadata
|
||||||
|
otherwise false
|
||||||
|
*/
|
||||||
|
Channel.isNewChannel = function (Env, channel, cb) {
|
||||||
|
if (!Core.isValidId(channel)) { return void cb('INVALID_CHAN'); }
|
||||||
|
if (channel.length !== 32) { return void cb('INVALID_CHAN'); }
|
||||||
|
|
||||||
|
// TODO replace with readMessagesBin
|
||||||
|
var done = false;
|
||||||
|
Env.msgStore.getMessages(channel, function (msg) {
|
||||||
|
if (done) { return; }
|
||||||
|
try {
|
||||||
|
if (typeof(msg) === 'string' && ARRAY_LINE.test(msg)) {
|
||||||
|
done = true;
|
||||||
|
return void cb(void 0, false);
|
||||||
|
}
|
||||||
|
} catch (e) {
|
||||||
|
Env.WARN('invalid message read from store', e);
|
||||||
|
}
|
||||||
|
}, function () {
|
||||||
|
if (done) { return; }
|
||||||
|
// no more messages...
|
||||||
|
cb(void 0, true);
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
|
/* writePrivateMessage
|
||||||
|
allows users to anonymously send a message to the channel
|
||||||
|
prevents their netflux-id from being stored in history
|
||||||
|
and from being broadcast to anyone that might currently be in the channel
|
||||||
|
|
||||||
|
Otherwise behaves the same as sending to a channel
|
||||||
|
*/
|
||||||
|
Channel.writePrivateMessage = function (Env, args, _cb, Server, netfluxId) {
|
||||||
|
var cb = Util.once(Util.mkAsync(_cb));
|
||||||
|
|
||||||
|
var channelId = args[0];
|
||||||
|
var msg = args[1];
|
||||||
|
|
||||||
|
// don't bother handling empty messages
|
||||||
|
if (!msg) { return void cb("INVALID_MESSAGE"); }
|
||||||
|
|
||||||
|
// don't support anything except regular channels
|
||||||
|
if (!Core.isValidId(channelId) || channelId.length !== 32) {
|
||||||
|
return void cb("INVALID_CHAN");
|
||||||
|
}
|
||||||
|
|
||||||
|
// We expect a modern netflux-websocket-server instance
|
||||||
|
// if this API isn't here everything will fall apart anyway
|
||||||
|
if (!(Server && typeof(Server.send) === 'function')) {
|
||||||
|
return void cb("NOT_IMPLEMENTED");
|
||||||
|
}
|
||||||
|
|
||||||
|
nThen(function (w) {
|
||||||
|
Metadata.getMetadataRaw(Env, channelId, w(function (err, metadata) {
|
||||||
|
if (err) {
|
||||||
|
w.abort();
|
||||||
|
Env.Log.error('HK_WRITE_PRIVATE_MESSAGE', err);
|
||||||
|
return void cb('METADATA_ERR');
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!metadata || !metadata.restricted) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
var session = HK.getNetfluxSession(Env, netfluxId);
|
||||||
|
var allowed = HK.listAllowedUsers(metadata);
|
||||||
|
|
||||||
|
if (HK.isUserSessionAllowed(allowed, session)) { return; }
|
||||||
|
|
||||||
|
w.abort();
|
||||||
|
cb('INSUFFICIENT_PERMISSIONS');
|
||||||
|
}));
|
||||||
|
}).nThen(function () {
|
||||||
|
// historyKeeper expects something with an 'id' attribute
|
||||||
|
// it will fail unless you provide it, but it doesn't need anything else
|
||||||
|
var channelStruct = {
|
||||||
|
id: channelId,
|
||||||
|
};
|
||||||
|
|
||||||
|
// construct a message to store and broadcast
|
||||||
|
var fullMessage = [
|
||||||
|
0, // idk
|
||||||
|
null, // normally the netflux id, null isn't rejected, and it distinguishes messages written in this way
|
||||||
|
"MSG", // indicate that this is a MSG
|
||||||
|
channelId, // channel id
|
||||||
|
msg // the actual message content. Generally a string
|
||||||
|
];
|
||||||
|
|
||||||
|
|
||||||
|
// historyKeeper already knows how to handle metadata and message validation, so we just pass it off here
|
||||||
|
// if the message isn't valid it won't be stored.
|
||||||
|
Env.historyKeeper.channelMessage(Server, channelStruct, fullMessage);
|
||||||
|
|
||||||
|
Server.getChannelUserList(channelId).forEach(function (userId) {
|
||||||
|
Server.send(userId, fullMessage);
|
||||||
|
});
|
||||||
|
|
||||||
|
cb();
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
@ -0,0 +1,190 @@
|
|||||||
|
/*jshint esversion: 6 */
|
||||||
|
/* globals process */
|
||||||
|
const Core = module.exports;
|
||||||
|
const Util = require("../common-util");
|
||||||
|
const escapeKeyCharacters = Util.escapeKeyCharacters;
|
||||||
|
|
||||||
|
/* Use Nacl for checking signatures of messages */
|
||||||
|
const Nacl = require("tweetnacl/nacl-fast");
|
||||||
|
|
||||||
|
|
||||||
|
Core.DEFAULT_LIMIT = 50 * 1024 * 1024;
|
||||||
|
Core.SESSION_EXPIRATION_TIME = 60 * 1000;
|
||||||
|
|
||||||
|
Core.isValidId = function (chan) {
|
||||||
|
return chan && chan.length && /^[a-zA-Z0-9=+-]*$/.test(chan) &&
|
||||||
|
[32, 48].indexOf(chan.length) > -1;
|
||||||
|
};
|
||||||
|
|
||||||
|
var makeToken = Core.makeToken = function () {
|
||||||
|
return Number(Math.floor(Math.random() * Number.MAX_SAFE_INTEGER))
|
||||||
|
.toString(16);
|
||||||
|
};
|
||||||
|
|
||||||
|
Core.makeCookie = function (token) {
|
||||||
|
var time = (+new Date());
|
||||||
|
time -= time % 5000;
|
||||||
|
|
||||||
|
return [
|
||||||
|
time,
|
||||||
|
process.pid,
|
||||||
|
token
|
||||||
|
];
|
||||||
|
};
|
||||||
|
|
||||||
|
var parseCookie = function (cookie) {
|
||||||
|
if (!(cookie && cookie.split)) { return null; }
|
||||||
|
|
||||||
|
var parts = cookie.split('|');
|
||||||
|
if (parts.length !== 3) { return null; }
|
||||||
|
|
||||||
|
var c = {};
|
||||||
|
c.time = new Date(parts[0]);
|
||||||
|
c.pid = Number(parts[1]);
|
||||||
|
c.seq = parts[2];
|
||||||
|
return c;
|
||||||
|
};
|
||||||
|
|
||||||
|
Core.getSession = function (Sessions, key) {
|
||||||
|
var safeKey = escapeKeyCharacters(key);
|
||||||
|
if (Sessions[safeKey]) {
|
||||||
|
Sessions[safeKey].atime = +new Date();
|
||||||
|
return Sessions[safeKey];
|
||||||
|
}
|
||||||
|
var user = Sessions[safeKey] = {};
|
||||||
|
user.atime = +new Date();
|
||||||
|
user.tokens = [
|
||||||
|
makeToken()
|
||||||
|
];
|
||||||
|
return user;
|
||||||
|
};
|
||||||
|
|
||||||
|
Core.expireSession = function (Sessions, safeKey) {
|
||||||
|
var session = Sessions[safeKey];
|
||||||
|
if (!session) { return; }
|
||||||
|
if (session.blobstage) {
|
||||||
|
session.blobstage.close();
|
||||||
|
}
|
||||||
|
delete Sessions[safeKey];
|
||||||
|
};
|
||||||
|
|
||||||
|
Core.expireSessionAsync = function (Env, safeKey, cb) {
|
||||||
|
setTimeout(function () {
|
||||||
|
Core.expireSession(Env.Sessions, safeKey);
|
||||||
|
cb(void 0, 'OK');
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
|
var isTooOld = function (time, now) {
|
||||||
|
return (now - time) > 300000;
|
||||||
|
};
|
||||||
|
|
||||||
|
Core.expireSessions = function (Sessions) {
|
||||||
|
var now = +new Date();
|
||||||
|
Object.keys(Sessions).forEach(function (safeKey) {
|
||||||
|
var session = Sessions[safeKey];
|
||||||
|
if (session && isTooOld(session.atime, now)) {
|
||||||
|
Core.expireSession(Sessions, safeKey);
|
||||||
|
}
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
|
var addTokenForKey = function (Sessions, publicKey, token) {
|
||||||
|
if (!Sessions[publicKey]) { throw new Error('undefined user'); }
|
||||||
|
|
||||||
|
var user = Core.getSession(Sessions, publicKey);
|
||||||
|
user.tokens.push(token);
|
||||||
|
user.atime = +new Date();
|
||||||
|
if (user.tokens.length > 2) { user.tokens.shift(); }
|
||||||
|
};
|
||||||
|
|
||||||
|
Core.isValidCookie = function (Sessions, publicKey, cookie) {
|
||||||
|
var parsed = parseCookie(cookie);
|
||||||
|
if (!parsed) { return false; }
|
||||||
|
|
||||||
|
var now = +new Date();
|
||||||
|
|
||||||
|
if (!parsed.time) { return false; }
|
||||||
|
if (isTooOld(parsed.time, now)) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
// different process. try harder
|
||||||
|
if (process.pid !== parsed.pid) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
var user = Core.getSession(Sessions, publicKey);
|
||||||
|
if (!user) { return false; }
|
||||||
|
|
||||||
|
var idx = user.tokens.indexOf(parsed.seq);
|
||||||
|
if (idx === -1) { return false; }
|
||||||
|
|
||||||
|
if (idx > 0) {
|
||||||
|
// make a new token
|
||||||
|
addTokenForKey(Sessions, publicKey, Core.makeToken());
|
||||||
|
}
|
||||||
|
|
||||||
|
return true;
|
||||||
|
};
|
||||||
|
|
||||||
|
Core.checkSignature = function (Env, signedMsg, signature, publicKey) {
|
||||||
|
if (!(signedMsg && publicKey)) { return false; }
|
||||||
|
|
||||||
|
var signedBuffer;
|
||||||
|
var pubBuffer;
|
||||||
|
var signatureBuffer;
|
||||||
|
|
||||||
|
try {
|
||||||
|
signedBuffer = Nacl.util.decodeUTF8(signedMsg);
|
||||||
|
} catch (e) {
|
||||||
|
Env.Log.error('INVALID_SIGNED_BUFFER', signedMsg);
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
try {
|
||||||
|
pubBuffer = Nacl.util.decodeBase64(publicKey);
|
||||||
|
} catch (e) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
try {
|
||||||
|
signatureBuffer = Nacl.util.decodeBase64(signature);
|
||||||
|
} catch (e) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (pubBuffer.length !== 32) {
|
||||||
|
Env.Log.error('PUBLIC_KEY_LENGTH', publicKey);
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (signatureBuffer.length !== 64) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
return Nacl.sign.detached.verify(signedBuffer, signatureBuffer, pubBuffer);
|
||||||
|
};
|
||||||
|
|
||||||
|
// E_NO_OWNERS
|
||||||
|
Core.hasOwners = function (metadata) {
|
||||||
|
return Boolean(metadata && Array.isArray(metadata.owners));
|
||||||
|
};
|
||||||
|
|
||||||
|
Core.hasPendingOwners = function (metadata) {
|
||||||
|
return Boolean(metadata && Array.isArray(metadata.pending_owners));
|
||||||
|
};
|
||||||
|
|
||||||
|
// INSUFFICIENT_PERMISSIONS
|
||||||
|
Core.isOwner = function (metadata, unsafeKey) {
|
||||||
|
return metadata.owners.indexOf(unsafeKey) !== -1;
|
||||||
|
};
|
||||||
|
|
||||||
|
Core.isPendingOwner = function (metadata, unsafeKey) {
|
||||||
|
return metadata.pending_owners.indexOf(unsafeKey) !== -1;
|
||||||
|
};
|
||||||
|
|
||||||
|
Core.haveACookie = function (Env, safeKey, cb) {
|
||||||
|
cb();
|
||||||
|
};
|
||||||
|
|
||||||
@ -0,0 +1,197 @@
|
|||||||
|
/*jshint esversion: 6 */
|
||||||
|
const Data = module.exports;
|
||||||
|
|
||||||
|
const Meta = require("../metadata");
|
||||||
|
const WriteQueue = require("../write-queue");
|
||||||
|
const Core = require("./core");
|
||||||
|
const Util = require("../common-util");
|
||||||
|
const HK = require("../hk-util");
|
||||||
|
|
||||||
|
Data.getMetadataRaw = function (Env, channel /* channelName */, _cb) {
|
||||||
|
const cb = Util.once(Util.mkAsync(_cb));
|
||||||
|
if (!Core.isValidId(channel)) { return void cb('INVALID_CHAN'); }
|
||||||
|
if (channel.length !== HK.STANDARD_CHANNEL_LENGTH) { return cb("INVALID_CHAN_LENGTH"); }
|
||||||
|
|
||||||
|
var cached = Env.metadata_cache[channel];
|
||||||
|
if (HK.isMetadataMessage(cached)) {
|
||||||
|
return void cb(void 0, cached);
|
||||||
|
}
|
||||||
|
|
||||||
|
Env.batchMetadata(channel, cb, function (done) {
|
||||||
|
var ref = {};
|
||||||
|
var lineHandler = Meta.createLineHandler(ref, Env.Log.error);
|
||||||
|
return void Env.msgStore.readChannelMetadata(channel, lineHandler, function (err) {
|
||||||
|
if (err) {
|
||||||
|
// stream errors?
|
||||||
|
return void done(err);
|
||||||
|
}
|
||||||
|
done(void 0, ref.meta);
|
||||||
|
});
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
|
Data.getMetadata = function (Env, channel, cb, Server, netfluxId) {
|
||||||
|
Data.getMetadataRaw(Env, channel, function (err, metadata) {
|
||||||
|
if (err) { return void cb(err); }
|
||||||
|
|
||||||
|
if (!(metadata && metadata.restricted)) {
|
||||||
|
// if it's not restricted then just call back
|
||||||
|
return void cb(void 0, metadata);
|
||||||
|
}
|
||||||
|
|
||||||
|
const session = HK.getNetfluxSession(Env, netfluxId);
|
||||||
|
const allowed = HK.listAllowedUsers(metadata);
|
||||||
|
|
||||||
|
if (!HK.isUserSessionAllowed(allowed, session)) {
|
||||||
|
return void cb(void 0, {
|
||||||
|
restricted: metadata.restricted,
|
||||||
|
allowed: allowed,
|
||||||
|
rejected: true,
|
||||||
|
});
|
||||||
|
}
|
||||||
|
cb(void 0, metadata);
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
|
/* setMetadata
|
||||||
|
- write a new line to the metadata log if a valid command is provided
|
||||||
|
- data is an object: {
|
||||||
|
channel: channelId,
|
||||||
|
command: metadataCommand (string),
|
||||||
|
value: value
|
||||||
|
}
|
||||||
|
*/
|
||||||
|
var queueMetadata = WriteQueue();
|
||||||
|
Data.setMetadata = function (Env, safeKey, data, cb, Server) {
|
||||||
|
var unsafeKey = Util.unescapeKeyCharacters(safeKey);
|
||||||
|
|
||||||
|
var channel = data.channel;
|
||||||
|
var command = data.command;
|
||||||
|
if (!channel || !Core.isValidId(channel)) { return void cb ('INVALID_CHAN'); }
|
||||||
|
if (!command || typeof (command) !== 'string') { return void cb('INVALID_COMMAND'); }
|
||||||
|
if (Meta.commands.indexOf(command) === -1) { return void cb('UNSUPPORTED_COMMAND'); }
|
||||||
|
|
||||||
|
queueMetadata(channel, function (next) {
|
||||||
|
Data.getMetadataRaw(Env, channel, function (err, metadata) {
|
||||||
|
if (err) {
|
||||||
|
cb(err);
|
||||||
|
return void next();
|
||||||
|
}
|
||||||
|
if (!Core.hasOwners(metadata)) {
|
||||||
|
cb('E_NO_OWNERS');
|
||||||
|
return void next();
|
||||||
|
}
|
||||||
|
|
||||||
|
// if you are a pending owner and not an owner
|
||||||
|
// you can either ADD_OWNERS, or RM_PENDING_OWNERS
|
||||||
|
// and you should only be able to add yourself as an owner
|
||||||
|
// everything else should be rejected
|
||||||
|
// else if you are not an owner
|
||||||
|
// you should be rejected
|
||||||
|
// else write the command
|
||||||
|
|
||||||
|
// Confirm that the channel is owned by the user in question
|
||||||
|
// or the user is accepting a pending ownership offer
|
||||||
|
if (Core.hasPendingOwners(metadata) &&
|
||||||
|
Core.isPendingOwner(metadata, unsafeKey) &&
|
||||||
|
!Core.isOwner(metadata, unsafeKey)) {
|
||||||
|
|
||||||
|
// If you are a pending owner, make sure you can only add yourelf as an owner
|
||||||
|
if ((command !== 'ADD_OWNERS' && command !== 'RM_PENDING_OWNERS')
|
||||||
|
|| !Array.isArray(data.value)
|
||||||
|
|| data.value.length !== 1
|
||||||
|
|| data.value[0] !== unsafeKey) {
|
||||||
|
cb('INSUFFICIENT_PERMISSIONS');
|
||||||
|
return void next();
|
||||||
|
}
|
||||||
|
// FIXME wacky fallthrough is hard to read
|
||||||
|
// we could pass this off to a writeMetadataCommand function
|
||||||
|
// and make the flow easier to follow
|
||||||
|
} else if (!Core.isOwner(metadata, unsafeKey)) {
|
||||||
|
cb('INSUFFICIENT_PERMISSIONS');
|
||||||
|
return void next();
|
||||||
|
}
|
||||||
|
|
||||||
|
// Add the new metadata line
|
||||||
|
var line = [command, data.value, +new Date()];
|
||||||
|
var changed = false;
|
||||||
|
try {
|
||||||
|
changed = Meta.handleCommand(metadata, line);
|
||||||
|
} catch (e) {
|
||||||
|
cb(e);
|
||||||
|
return void next();
|
||||||
|
}
|
||||||
|
|
||||||
|
// if your command is valid but it didn't result in any change to the metadata,
|
||||||
|
// call back now and don't write any "useless" line to the log
|
||||||
|
if (!changed) {
|
||||||
|
cb(void 0, metadata);
|
||||||
|
return void next();
|
||||||
|
}
|
||||||
|
Env.msgStore.writeMetadata(channel, JSON.stringify(line), function (e) {
|
||||||
|
if (e) {
|
||||||
|
cb(e);
|
||||||
|
return void next();
|
||||||
|
}
|
||||||
|
|
||||||
|
// send the message back to the person who changed it
|
||||||
|
// since we know they're allowed to see it
|
||||||
|
cb(void 0, metadata);
|
||||||
|
next();
|
||||||
|
|
||||||
|
const metadata_cache = Env.metadata_cache;
|
||||||
|
|
||||||
|
// update the cached metadata
|
||||||
|
metadata_cache[channel] = metadata;
|
||||||
|
|
||||||
|
// it's easy to check if the channel is restricted
|
||||||
|
const isRestricted = metadata.restricted;
|
||||||
|
// and these values will be used in any case
|
||||||
|
const s_metadata = JSON.stringify(metadata);
|
||||||
|
const hk_id = Env.historyKeeper.id;
|
||||||
|
|
||||||
|
if (!isRestricted) {
|
||||||
|
// pre-allow-list behaviour
|
||||||
|
// if it's not restricted, broadcast the new metadata to everyone
|
||||||
|
return void Server.channelBroadcast(channel, s_metadata, hk_id);
|
||||||
|
}
|
||||||
|
|
||||||
|
// otherwise derive the list of users (unsafeKeys) that are allowed to stay
|
||||||
|
const allowed = HK.listAllowedUsers(metadata);
|
||||||
|
// anyone who is not allowed will get the same error message
|
||||||
|
const s_error = JSON.stringify({
|
||||||
|
error: 'ERESTRICTED',
|
||||||
|
channel: channel,
|
||||||
|
});
|
||||||
|
|
||||||
|
// iterate over the channel's userlist
|
||||||
|
const toRemove = [];
|
||||||
|
Server.getChannelUserList(channel).forEach(function (userId) {
|
||||||
|
const session = HK.getNetfluxSession(Env, userId);
|
||||||
|
|
||||||
|
// if the user is allowed to remain, send them the metadata
|
||||||
|
if (HK.isUserSessionAllowed(allowed, session)) {
|
||||||
|
return void Server.send(userId, [
|
||||||
|
0,
|
||||||
|
hk_id,
|
||||||
|
'MSG',
|
||||||
|
userId,
|
||||||
|
s_metadata
|
||||||
|
], function () {});
|
||||||
|
}
|
||||||
|
// otherwise they are not in the list.
|
||||||
|
// send them an error and kick them out!
|
||||||
|
Server.send(userId, [
|
||||||
|
0,
|
||||||
|
hk_id,
|
||||||
|
'MSG',
|
||||||
|
userId,
|
||||||
|
s_error
|
||||||
|
], function () {});
|
||||||
|
});
|
||||||
|
|
||||||
|
Server.removeFromChannel(channel, toRemove);
|
||||||
|
});
|
||||||
|
});
|
||||||
|
});
|
||||||
|
};
|
||||||
@ -0,0 +1,568 @@
|
|||||||
|
/*jshint esversion: 6 */
|
||||||
|
const Core = require("./core");
|
||||||
|
|
||||||
|
const BatchRead = require("../batch-read");
|
||||||
|
const Pins = require("../pins");
|
||||||
|
|
||||||
|
const Pinning = module.exports;
|
||||||
|
const Nacl = require("tweetnacl/nacl-fast");
|
||||||
|
const Util = require("../common-util");
|
||||||
|
const nThen = require("nthen");
|
||||||
|
const Saferphore = require("saferphore");
|
||||||
|
|
||||||
|
//const escapeKeyCharacters = Util.escapeKeyCharacters;
|
||||||
|
const unescapeKeyCharacters = Util.unescapeKeyCharacters;
|
||||||
|
|
||||||
|
var sumChannelSizes = function (sizes) {
|
||||||
|
return Object.keys(sizes).map(function (id) { return sizes[id]; })
|
||||||
|
.filter(function (x) {
|
||||||
|
// only allow positive numbers
|
||||||
|
return !(typeof(x) !== 'number' || x <= 0);
|
||||||
|
})
|
||||||
|
.reduce(function (a, b) { return a + b; }, 0);
|
||||||
|
};
|
||||||
|
|
||||||
|
// FIXME it's possible for this to respond before the server has had a chance
|
||||||
|
// to fetch the limits. Maybe we should respond with an error...
|
||||||
|
// or wait until we actually know the limits before responding
|
||||||
|
var getLimit = Pinning.getLimit = function (Env, safeKey, cb) {
|
||||||
|
var unsafeKey = unescapeKeyCharacters(safeKey);
|
||||||
|
var limit = Env.limits[unsafeKey];
|
||||||
|
var defaultLimit = typeof(Env.defaultStorageLimit) === 'number'?
|
||||||
|
Env.defaultStorageLimit: Core.DEFAULT_LIMIT;
|
||||||
|
|
||||||
|
var toSend = limit && typeof(limit.limit) === "number"?
|
||||||
|
[limit.limit, limit.plan, limit.note] : [defaultLimit, '', ''];
|
||||||
|
|
||||||
|
cb(void 0, toSend);
|
||||||
|
};
|
||||||
|
|
||||||
|
const answerDeferred = function (Env, channel, bool) {
|
||||||
|
const pending = Env.pendingPinInquiries;
|
||||||
|
const stack = pending[channel];
|
||||||
|
if (!Array.isArray(stack)) { return; }
|
||||||
|
|
||||||
|
delete pending[channel];
|
||||||
|
|
||||||
|
stack.forEach(function (cb) {
|
||||||
|
cb(void 0, bool);
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
|
var addPinned = function (
|
||||||
|
Env,
|
||||||
|
safeKey /*:string*/,
|
||||||
|
channelList /*Array<string>*/,
|
||||||
|
cb /*:()=>void*/)
|
||||||
|
{
|
||||||
|
channelList.forEach(function (channel) {
|
||||||
|
Pins.addUserPinToState(Env.pinnedPads, safeKey, channel);
|
||||||
|
answerDeferred(Env, channel, true);
|
||||||
|
});
|
||||||
|
cb();
|
||||||
|
};
|
||||||
|
|
||||||
|
const isEmpty = function (obj) {
|
||||||
|
if (!obj || typeof(obj) !== 'object') { return true; }
|
||||||
|
for (var key in obj) {
|
||||||
|
if (obj.hasOwnProperty(key)) { return true; }
|
||||||
|
}
|
||||||
|
return false;
|
||||||
|
};
|
||||||
|
|
||||||
|
const deferUserTask = function (Env, safeKey, deferred) {
|
||||||
|
const pending = Env.pendingUnpins;
|
||||||
|
(pending[safeKey] = pending[safeKey] || []).push(deferred);
|
||||||
|
};
|
||||||
|
|
||||||
|
const runUserDeferred = function (Env, safeKey) {
|
||||||
|
const pending = Env.pendingUnpins;
|
||||||
|
const stack = pending[safeKey];
|
||||||
|
if (!Array.isArray(stack)) { return; }
|
||||||
|
delete pending[safeKey];
|
||||||
|
|
||||||
|
stack.forEach(function (cb) {
|
||||||
|
cb();
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
|
const runRemainingDeferred = function (Env) {
|
||||||
|
const pending = Env.pendingUnpins;
|
||||||
|
for (var safeKey in pending) {
|
||||||
|
runUserDeferred(Env, safeKey);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
const removeSelfFromPinned = function (Env, safeKey, channelList) {
|
||||||
|
channelList.forEach(function (channel) {
|
||||||
|
const channelPinStatus = Env.pinnedPads[channel];
|
||||||
|
if (!channelPinStatus) { return; }
|
||||||
|
delete channelPinStatus[safeKey];
|
||||||
|
if (isEmpty(channelPinStatus)) {
|
||||||
|
delete Env.pinnedPads[channel];
|
||||||
|
}
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
|
var removePinned = function (
|
||||||
|
Env,
|
||||||
|
safeKey /*:string*/,
|
||||||
|
channelList /*Array<string>*/,
|
||||||
|
cb /*:()=>void*/)
|
||||||
|
{
|
||||||
|
|
||||||
|
// if pins are already loaded then you can just unpin normally
|
||||||
|
if (Env.pinsLoaded) {
|
||||||
|
removeSelfFromPinned(Env, safeKey, channelList);
|
||||||
|
return void cb();
|
||||||
|
}
|
||||||
|
|
||||||
|
// otherwise defer until later...
|
||||||
|
deferUserTask(Env, safeKey, function () {
|
||||||
|
removeSelfFromPinned(Env, safeKey, channelList);
|
||||||
|
cb();
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
|
var getMultipleFileSize = function (Env, channels, cb) {
|
||||||
|
if (!Array.isArray(channels)) { return cb('INVALID_PIN_LIST'); }
|
||||||
|
if (typeof(Env.msgStore.getChannelSize) !== 'function') {
|
||||||
|
return cb('GET_CHANNEL_SIZE_UNSUPPORTED');
|
||||||
|
}
|
||||||
|
|
||||||
|
var i = channels.length;
|
||||||
|
var counts = {};
|
||||||
|
|
||||||
|
var done = function () {
|
||||||
|
i--;
|
||||||
|
if (i === 0) { return cb(void 0, counts); }
|
||||||
|
};
|
||||||
|
|
||||||
|
channels.forEach(function (channel) {
|
||||||
|
Pinning.getFileSize(Env, channel, function (e, size) {
|
||||||
|
if (e) {
|
||||||
|
// most likely error here is that a file no longer exists
|
||||||
|
// but a user still has it in their drive, and wants to know
|
||||||
|
// its size. We should find a way to inform them of this in
|
||||||
|
// the future. For now we can just tell them it has no size.
|
||||||
|
|
||||||
|
//WARN('getFileSize', e);
|
||||||
|
counts[channel] = 0;
|
||||||
|
return done();
|
||||||
|
}
|
||||||
|
counts[channel] = size;
|
||||||
|
done();
|
||||||
|
});
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
|
const batchUserPins = BatchRead("LOAD_USER_PINS");
|
||||||
|
var loadUserPins = function (Env, safeKey, cb) {
|
||||||
|
var session = Core.getSession(Env.Sessions, safeKey);
|
||||||
|
|
||||||
|
if (session.channels) {
|
||||||
|
return cb(session.channels);
|
||||||
|
}
|
||||||
|
|
||||||
|
batchUserPins(safeKey, cb, function (done) {
|
||||||
|
var ref = {};
|
||||||
|
var lineHandler = Pins.createLineHandler(ref, function (label, data) {
|
||||||
|
Env.Log.error(label, {
|
||||||
|
log: safeKey,
|
||||||
|
data: data,
|
||||||
|
});
|
||||||
|
});
|
||||||
|
|
||||||
|
// if channels aren't in memory. load them from disk
|
||||||
|
// TODO replace with readMessagesBin
|
||||||
|
Env.pinStore.getMessages(safeKey, lineHandler, function () {
|
||||||
|
// no more messages
|
||||||
|
|
||||||
|
// only put this into the cache if it completes
|
||||||
|
session.channels = ref.pins;
|
||||||
|
done(ref.pins); // FIXME no error handling?
|
||||||
|
});
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
|
var truthyKeys = function (O) {
|
||||||
|
return Object.keys(O).filter(function (k) {
|
||||||
|
return O[k];
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
|
var getChannelList = Pinning.getChannelList = function (Env, safeKey, _cb) {
|
||||||
|
var cb = Util.once(Util.mkAsync(_cb));
|
||||||
|
loadUserPins(Env, safeKey, function (pins) {
|
||||||
|
cb(truthyKeys(pins));
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
|
const batchTotalSize = BatchRead("GET_TOTAL_SIZE");
|
||||||
|
Pinning.getTotalSize = function (Env, safeKey, cb) {
|
||||||
|
var unsafeKey = unescapeKeyCharacters(safeKey);
|
||||||
|
var limit = Env.limits[unsafeKey];
|
||||||
|
|
||||||
|
// Get a common key if multiple users share the same quota, otherwise take the public key
|
||||||
|
var batchKey = (limit && Array.isArray(limit.users)) ? limit.users.join('') : safeKey;
|
||||||
|
|
||||||
|
batchTotalSize(batchKey, cb, function (done) {
|
||||||
|
var channels = [];
|
||||||
|
var bytes = 0;
|
||||||
|
nThen(function (waitFor) {
|
||||||
|
// Get the channels list for our user account
|
||||||
|
getChannelList(Env, safeKey, waitFor(function (_channels) {
|
||||||
|
if (!_channels) {
|
||||||
|
waitFor.abort();
|
||||||
|
return done('INVALID_PIN_LIST');
|
||||||
|
}
|
||||||
|
Array.prototype.push.apply(channels, _channels);
|
||||||
|
}));
|
||||||
|
// Get the channels list for users sharing our quota
|
||||||
|
if (limit && Array.isArray(limit.users) && limit.users.length > 1) {
|
||||||
|
limit.users.forEach(function (key) {
|
||||||
|
if (key === unsafeKey) { return; } // Don't count ourselves twice
|
||||||
|
getChannelList(Env, key, waitFor(function (_channels) {
|
||||||
|
if (!_channels) { return; } // Broken user, don't count their quota
|
||||||
|
Array.prototype.push.apply(channels, _channels);
|
||||||
|
}));
|
||||||
|
});
|
||||||
|
}
|
||||||
|
}).nThen(function (waitFor) {
|
||||||
|
// Get size of the channels
|
||||||
|
var list = []; // Contains the channels already counted in the quota to avoid duplicates
|
||||||
|
channels.forEach(function (channel) { // TODO semaphore?
|
||||||
|
if (list.indexOf(channel) !== -1) { return; }
|
||||||
|
list.push(channel);
|
||||||
|
Pinning.getFileSize(Env, channel, waitFor(function (e, size) {
|
||||||
|
if (!e) { bytes += size; }
|
||||||
|
}));
|
||||||
|
});
|
||||||
|
}).nThen(function () {
|
||||||
|
done(void 0, bytes);
|
||||||
|
});
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
|
/* Users should be able to clear their own pin log with an authenticated RPC
|
||||||
|
*/
|
||||||
|
Pinning.removePins = function (Env, safeKey, cb) {
|
||||||
|
if (typeof(Env.pinStore.removeChannel) !== 'function') {
|
||||||
|
return void cb("E_NOT_IMPLEMENTED");
|
||||||
|
}
|
||||||
|
Env.pinStore.removeChannel(safeKey, function (err) {
|
||||||
|
Env.Log.info('DELETION_PIN_BY_OWNER_RPC', {
|
||||||
|
safeKey: safeKey,
|
||||||
|
status: err? String(err): 'SUCCESS',
|
||||||
|
});
|
||||||
|
|
||||||
|
if (err) { return void cb(err); }
|
||||||
|
cb(void 0, 'OK');
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
|
Pinning.trimPins = function (Env, safeKey, cb) {
|
||||||
|
cb("NOT_IMPLEMENTED");
|
||||||
|
};
|
||||||
|
|
||||||
|
var getFreeSpace = Pinning.getFreeSpace = function (Env, safeKey, cb) {
|
||||||
|
getLimit(Env, safeKey, function (e, limit) {
|
||||||
|
if (e) { return void cb(e); }
|
||||||
|
Pinning.getTotalSize(Env, safeKey, function (e, size) {
|
||||||
|
if (typeof(size) === 'undefined') { return void cb(e); }
|
||||||
|
|
||||||
|
var rem = limit[0] - size;
|
||||||
|
if (typeof(rem) !== 'number') {
|
||||||
|
return void cb('invalid_response');
|
||||||
|
}
|
||||||
|
cb(void 0, rem);
|
||||||
|
});
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
|
var hashChannelList = function (A) {
|
||||||
|
var uniques = [];
|
||||||
|
|
||||||
|
A.forEach(function (a) {
|
||||||
|
if (uniques.indexOf(a) === -1) { uniques.push(a); }
|
||||||
|
});
|
||||||
|
uniques.sort();
|
||||||
|
|
||||||
|
var hash = Nacl.util.encodeBase64(Nacl.hash(Nacl
|
||||||
|
.util.decodeUTF8(JSON.stringify(uniques))));
|
||||||
|
|
||||||
|
return hash;
|
||||||
|
};
|
||||||
|
|
||||||
|
var getHash = Pinning.getHash = function (Env, safeKey, cb) {
|
||||||
|
getChannelList(Env, safeKey, function (channels) {
|
||||||
|
cb(void 0, hashChannelList(channels));
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
|
Pinning.pinChannel = function (Env, safeKey, channels, cb) {
|
||||||
|
if (!channels && channels.filter) {
|
||||||
|
return void cb('INVALID_PIN_LIST');
|
||||||
|
}
|
||||||
|
|
||||||
|
// get channel list ensures your session has a cached channel list
|
||||||
|
getChannelList(Env, safeKey, function (pinned) {
|
||||||
|
var session = Core.getSession(Env.Sessions, safeKey);
|
||||||
|
|
||||||
|
// only pin channels which are not already pinned
|
||||||
|
var toStore = channels.filter(function (channel) {
|
||||||
|
return pinned.indexOf(channel) === -1;
|
||||||
|
});
|
||||||
|
|
||||||
|
if (toStore.length === 0) {
|
||||||
|
return void getHash(Env, safeKey, cb);
|
||||||
|
}
|
||||||
|
|
||||||
|
getMultipleFileSize(Env, toStore, function (e, sizes) {
|
||||||
|
if (typeof(sizes) === 'undefined') { return void cb(e); }
|
||||||
|
var pinSize = sumChannelSizes(sizes);
|
||||||
|
|
||||||
|
getFreeSpace(Env, safeKey, function (e, free) {
|
||||||
|
if (typeof(free) === 'undefined') {
|
||||||
|
Env.WARN('getFreeSpace', e);
|
||||||
|
return void cb(e);
|
||||||
|
}
|
||||||
|
if (pinSize > free) { return void cb('E_OVER_LIMIT'); }
|
||||||
|
|
||||||
|
Env.pinStore.message(safeKey, JSON.stringify(['PIN', toStore, +new Date()]),
|
||||||
|
function (e) {
|
||||||
|
if (e) { return void cb(e); }
|
||||||
|
toStore.forEach(function (channel) {
|
||||||
|
session.channels[channel] = true;
|
||||||
|
});
|
||||||
|
addPinned(Env, safeKey, toStore, () => {});
|
||||||
|
getHash(Env, safeKey, cb);
|
||||||
|
});
|
||||||
|
});
|
||||||
|
});
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
|
Pinning.unpinChannel = function (Env, safeKey, channels, cb) {
|
||||||
|
if (!channels && channels.filter) {
|
||||||
|
// expected array
|
||||||
|
return void cb('INVALID_PIN_LIST');
|
||||||
|
}
|
||||||
|
|
||||||
|
getChannelList(Env, safeKey, function (pinned) {
|
||||||
|
var session = Core.getSession(Env.Sessions, safeKey);
|
||||||
|
|
||||||
|
// only unpin channels which are pinned
|
||||||
|
var toStore = channels.filter(function (channel) {
|
||||||
|
return pinned.indexOf(channel) !== -1;
|
||||||
|
});
|
||||||
|
|
||||||
|
if (toStore.length === 0) {
|
||||||
|
return void getHash(Env, safeKey, cb);
|
||||||
|
}
|
||||||
|
|
||||||
|
Env.pinStore.message(safeKey, JSON.stringify(['UNPIN', toStore, +new Date()]),
|
||||||
|
function (e) {
|
||||||
|
if (e) { return void cb(e); }
|
||||||
|
toStore.forEach(function (channel) {
|
||||||
|
delete session.channels[channel];
|
||||||
|
});
|
||||||
|
removePinned(Env, safeKey, toStore, () => {});
|
||||||
|
getHash(Env, safeKey, cb);
|
||||||
|
});
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
|
Pinning.resetUserPins = function (Env, safeKey, channelList, cb) {
|
||||||
|
if (!Array.isArray(channelList)) { return void cb('INVALID_PIN_LIST'); }
|
||||||
|
var session = Core.getSession(Env.Sessions, safeKey);
|
||||||
|
|
||||||
|
if (!channelList.length) {
|
||||||
|
return void getHash(Env, safeKey, function (e, hash) {
|
||||||
|
if (e) { return cb(e); }
|
||||||
|
cb(void 0, hash);
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
var pins = {};
|
||||||
|
getMultipleFileSize(Env, channelList, function (e, sizes) {
|
||||||
|
if (typeof(sizes) === 'undefined') { return void cb(e); }
|
||||||
|
var pinSize = sumChannelSizes(sizes);
|
||||||
|
|
||||||
|
|
||||||
|
getLimit(Env, safeKey, function (e, limit) {
|
||||||
|
if (e) {
|
||||||
|
Env.WARN('[RESET_ERR]', e);
|
||||||
|
return void cb(e);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* we want to let people pin, even if they are over their limit,
|
||||||
|
but they should only be able to do this once.
|
||||||
|
|
||||||
|
This prevents data loss in the case that someone registers, but
|
||||||
|
does not have enough free space to pin their migrated data.
|
||||||
|
|
||||||
|
They will not be able to pin additional pads until they upgrade
|
||||||
|
or delete enough files to go back under their limit. */
|
||||||
|
if (pinSize > limit[0] && session.hasPinned) { return void(cb('E_OVER_LIMIT')); }
|
||||||
|
Env.pinStore.message(safeKey, JSON.stringify(['RESET', channelList, +new Date()]),
|
||||||
|
function (e) {
|
||||||
|
if (e) { return void cb(e); }
|
||||||
|
channelList.forEach(function (channel) {
|
||||||
|
pins[channel] = true;
|
||||||
|
});
|
||||||
|
|
||||||
|
var oldChannels;
|
||||||
|
if (session.channels && typeof(session.channels) === 'object') {
|
||||||
|
oldChannels = Object.keys(session.channels);
|
||||||
|
} else {
|
||||||
|
oldChannels = [];
|
||||||
|
}
|
||||||
|
removePinned(Env, safeKey, oldChannels, () => {
|
||||||
|
addPinned(Env, safeKey, channelList, ()=>{});
|
||||||
|
});
|
||||||
|
|
||||||
|
// update in-memory cache IFF the reset was allowed.
|
||||||
|
session.channels = pins;
|
||||||
|
getHash(Env, safeKey, function (e, hash) {
|
||||||
|
cb(e, hash);
|
||||||
|
});
|
||||||
|
});
|
||||||
|
});
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
|
Pinning.getFileSize = function (Env, channel, _cb) {
|
||||||
|
var cb = Util.once(Util.mkAsync(_cb));
|
||||||
|
if (!Core.isValidId(channel)) { return void cb('INVALID_CHAN'); }
|
||||||
|
if (channel.length === 32) {
|
||||||
|
if (typeof(Env.msgStore.getChannelSize) !== 'function') {
|
||||||
|
return cb('GET_CHANNEL_SIZE_UNSUPPORTED');
|
||||||
|
}
|
||||||
|
|
||||||
|
return void Env.msgStore.getChannelSize(channel, function (e, size /*:number*/) {
|
||||||
|
if (e) {
|
||||||
|
if (e.code === 'ENOENT') { return void cb(void 0, 0); }
|
||||||
|
return void cb(e.code);
|
||||||
|
}
|
||||||
|
cb(void 0, size);
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
// 'channel' refers to a file, so you need another API
|
||||||
|
Env.blobStore.size(channel, function (e, size) {
|
||||||
|
if (typeof(size) === 'undefined') { return void cb(e); }
|
||||||
|
cb(void 0, size);
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
|
/* accepts a list, and returns a sublist of channel or file ids which seem
|
||||||
|
to have been deleted from the server (file size 0)
|
||||||
|
|
||||||
|
we might consider that we should only say a file is gone if fs.stat returns
|
||||||
|
ENOENT, but for now it's simplest to just rely on getFileSize...
|
||||||
|
*/
|
||||||
|
Pinning.getDeletedPads = function (Env, channels, cb) {
|
||||||
|
if (!Array.isArray(channels)) { return cb('INVALID_LIST'); }
|
||||||
|
var L = channels.length;
|
||||||
|
|
||||||
|
var sem = Saferphore.create(10);
|
||||||
|
var absentees = [];
|
||||||
|
|
||||||
|
var job = function (channel, wait) {
|
||||||
|
return function (give) {
|
||||||
|
Pinning.getFileSize(Env, channel, wait(give(function (e, size) {
|
||||||
|
if (e) { return; }
|
||||||
|
if (size === 0) { absentees.push(channel); }
|
||||||
|
})));
|
||||||
|
};
|
||||||
|
};
|
||||||
|
|
||||||
|
nThen(function (w) {
|
||||||
|
for (var i = 0; i < L; i++) {
|
||||||
|
sem.take(job(channels[i], w));
|
||||||
|
}
|
||||||
|
}).nThen(function () {
|
||||||
|
cb(void 0, absentees);
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
|
const answerNoConclusively = function (Env) {
|
||||||
|
const pending = Env.pendingPinInquiries;
|
||||||
|
for (var channel in pending) {
|
||||||
|
answerDeferred(Env, channel, false);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
// inform that the
|
||||||
|
Pinning.loadChannelPins = function (Env) {
|
||||||
|
const stats = {
|
||||||
|
surplus: 0,
|
||||||
|
pinned: 0,
|
||||||
|
duplicated: 0,
|
||||||
|
// in theory we could use this number for the admin panel
|
||||||
|
// but we'd have to keep updating it whenever a new pin log
|
||||||
|
// was created or deleted. In practice it's probably not worth the trouble
|
||||||
|
users: 0,
|
||||||
|
};
|
||||||
|
|
||||||
|
const handler = function (ref, safeKey, pinned) {
|
||||||
|
if (ref.surplus) {
|
||||||
|
stats.surplus += ref.surplus;
|
||||||
|
}
|
||||||
|
for (var channel in ref.pins) {
|
||||||
|
if (!pinned.hasOwnProperty(channel)) {
|
||||||
|
answerDeferred(Env, channel, true);
|
||||||
|
stats.pinned++;
|
||||||
|
} else {
|
||||||
|
stats.duplicated++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
stats.users++;
|
||||||
|
runUserDeferred(Env, safeKey);
|
||||||
|
};
|
||||||
|
|
||||||
|
Pins.list(function (err) {
|
||||||
|
if (err) {
|
||||||
|
Env.pinsLoaded = true;
|
||||||
|
Env.Log.error("LOAD_CHANNEL_PINS", err);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
Env.pinsLoaded = true;
|
||||||
|
answerNoConclusively(Env);
|
||||||
|
runRemainingDeferred(Env);
|
||||||
|
}, {
|
||||||
|
pinPath: Env.paths.pin,
|
||||||
|
handler: handler,
|
||||||
|
pinned: Env.pinnedPads,
|
||||||
|
workers: Env.pinWorkers,
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
|
/*
|
||||||
|
const deferResponse = function (Env, channel, cb) {
|
||||||
|
const pending = Env.pendingPinInquiries;
|
||||||
|
(pending[channel] = pending[channel] || []).push(cb);
|
||||||
|
};
|
||||||
|
*/
|
||||||
|
|
||||||
|
Pinning.isChannelPinned = function (Env, channel, cb) {
|
||||||
|
return void cb(void 0, true); // XXX
|
||||||
|
/*
|
||||||
|
// if the pins are fully loaded then you can answer yes/no definitively
|
||||||
|
if (Env.pinsLoaded) {
|
||||||
|
return void cb(void 0, !isEmpty(Env.pinnedPads[channel]));
|
||||||
|
}
|
||||||
|
|
||||||
|
// you may already know that a channel is pinned
|
||||||
|
// even if you're still loading. answer immediately if so
|
||||||
|
if (!isEmpty(Env.pinnedPads[channel])) { return cb(void 0, true); }
|
||||||
|
|
||||||
|
// if you're still loading them then can answer 'yes' as soon
|
||||||
|
// as you learn that one account has pinned a file.
|
||||||
|
// negative responses have to wait until the end
|
||||||
|
deferResponse(Env, channel, cb);
|
||||||
|
*/
|
||||||
|
};
|
||||||
|
|
||||||
@ -0,0 +1,104 @@
|
|||||||
|
/*jshint esversion: 6 */
|
||||||
|
/* globals Buffer*/
|
||||||
|
const Quota = module.exports;
|
||||||
|
|
||||||
|
const Util = require("../common-util");
|
||||||
|
const Package = require('../../package.json');
|
||||||
|
const Https = require("https");
|
||||||
|
|
||||||
|
Quota.applyCustomLimits = function (Env) {
|
||||||
|
var isLimit = function (o) {
|
||||||
|
var valid = o && typeof(o) === 'object' &&
|
||||||
|
typeof(o.limit) === 'number' &&
|
||||||
|
typeof(o.plan) === 'string' &&
|
||||||
|
typeof(o.note) === 'string';
|
||||||
|
return valid;
|
||||||
|
};
|
||||||
|
|
||||||
|
// read custom limits from the Environment (taken from config)
|
||||||
|
var customLimits = (function (custom) {
|
||||||
|
var limits = {};
|
||||||
|
Object.keys(custom).forEach(function (k) {
|
||||||
|
k.replace(/\/([^\/]+)$/, function (all, safeKey) {
|
||||||
|
var id = Util.unescapeKeyCharacters(safeKey || '');
|
||||||
|
limits[id] = custom[k];
|
||||||
|
return '';
|
||||||
|
});
|
||||||
|
});
|
||||||
|
return limits;
|
||||||
|
}(Env.customLimits || {}));
|
||||||
|
|
||||||
|
Object.keys(customLimits).forEach(function (k) {
|
||||||
|
if (!isLimit(customLimits[k])) { return; }
|
||||||
|
Env.limits[k] = customLimits[k];
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
|
Quota.updateCachedLimits = function (Env, cb) {
|
||||||
|
Quota.applyCustomLimits(Env);
|
||||||
|
if (Env.allowSubscriptions === false || Env.blockDailyCheck === true) { return void cb(); }
|
||||||
|
|
||||||
|
var body = JSON.stringify({
|
||||||
|
domain: Env.myDomain,
|
||||||
|
subdomain: Env.mySubdomain || null,
|
||||||
|
adminEmail: Env.adminEmail,
|
||||||
|
version: Package.version
|
||||||
|
});
|
||||||
|
var options = {
|
||||||
|
host: 'accounts.cryptpad.fr',
|
||||||
|
path: '/api/getauthorized',
|
||||||
|
method: 'POST',
|
||||||
|
headers: {
|
||||||
|
"Content-Type": "application/json",
|
||||||
|
"Content-Length": Buffer.byteLength(body)
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
var req = Https.request(options, function (response) {
|
||||||
|
if (!('' + response.statusCode).match(/^2\d\d$/)) {
|
||||||
|
return void cb('SERVER ERROR ' + response.statusCode);
|
||||||
|
}
|
||||||
|
var str = '';
|
||||||
|
|
||||||
|
response.on('data', function (chunk) {
|
||||||
|
str += chunk;
|
||||||
|
});
|
||||||
|
|
||||||
|
response.on('end', function () {
|
||||||
|
try {
|
||||||
|
var json = JSON.parse(str);
|
||||||
|
Env.limits = json;
|
||||||
|
Quota.applyCustomLimits(Env);
|
||||||
|
cb(void 0);
|
||||||
|
} catch (e) {
|
||||||
|
cb(e);
|
||||||
|
}
|
||||||
|
});
|
||||||
|
});
|
||||||
|
|
||||||
|
req.on('error', function (e) {
|
||||||
|
Quota.applyCustomLimits(Env);
|
||||||
|
if (!Env.myDomain) { return cb(); }
|
||||||
|
// only return an error if your server allows subscriptions
|
||||||
|
cb(e);
|
||||||
|
});
|
||||||
|
|
||||||
|
req.end(body);
|
||||||
|
};
|
||||||
|
|
||||||
|
// The limits object contains storage limits for all the publicKey that have paid
|
||||||
|
// To each key is associated an object containing the 'limit' value and a 'note' explaining that limit
|
||||||
|
Quota.getUpdatedLimit = function (Env, safeKey, cb) { // FIXME BATCH?S
|
||||||
|
Quota.updateCachedLimits(Env, function (err) {
|
||||||
|
if (err) { return void cb(err); }
|
||||||
|
|
||||||
|
var limit = Env.limits[safeKey];
|
||||||
|
|
||||||
|
if (limit && typeof(limit.limit) === 'number') {
|
||||||
|
return void cb(void 0, [limit.limit, limit.plan, limit.note]);
|
||||||
|
}
|
||||||
|
|
||||||
|
return void cb(void 0, [Env.defaultStorageLimit, '', '']);
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
@ -0,0 +1,89 @@
|
|||||||
|
/*jshint esversion: 6 */
|
||||||
|
const Upload = module.exports;
|
||||||
|
const Util = require("../common-util");
|
||||||
|
const Pinning = require("./pin-rpc");
|
||||||
|
const nThen = require("nthen");
|
||||||
|
const Core = require("./core");
|
||||||
|
|
||||||
|
Upload.status = function (Env, safeKey, filesize, _cb) { // FIXME FILES
|
||||||
|
var cb = Util.once(Util.mkAsync(_cb));
|
||||||
|
|
||||||
|
// validate that the provided size is actually a positive number
|
||||||
|
if (typeof(filesize) !== 'number' &&
|
||||||
|
filesize >= 0) { return void cb('E_INVALID_SIZE'); }
|
||||||
|
|
||||||
|
nThen(function (w) {
|
||||||
|
// if the proposed upload size is within the regular limit
|
||||||
|
// jump ahead to the next block
|
||||||
|
if (filesize <= Env.maxUploadSize) { return; }
|
||||||
|
|
||||||
|
// if larger uploads aren't explicitly enabled then reject them
|
||||||
|
if (typeof(Env.premiumUploadSize) !== 'number') {
|
||||||
|
w.abort();
|
||||||
|
return void cb('TOO_LARGE');
|
||||||
|
}
|
||||||
|
|
||||||
|
// otherwise go and retrieve info about the user's quota
|
||||||
|
Pinning.getLimit(Env, safeKey, w(function (err, limit) {
|
||||||
|
if (err) {
|
||||||
|
w.abort();
|
||||||
|
return void cb("E_BAD_LIMIT");
|
||||||
|
}
|
||||||
|
|
||||||
|
var plan = limit[1];
|
||||||
|
|
||||||
|
// see if they have a special plan, reject them if not
|
||||||
|
if (plan === '') {
|
||||||
|
w.abort();
|
||||||
|
return void cb('TOO_LARGE');
|
||||||
|
}
|
||||||
|
|
||||||
|
// and that they're not over the greater limit
|
||||||
|
if (filesize >= Env.premiumUploadSize) {
|
||||||
|
w.abort();
|
||||||
|
return void cb("TOO_LARGE");
|
||||||
|
}
|
||||||
|
|
||||||
|
// fallthrough will proceed to the next block
|
||||||
|
}));
|
||||||
|
}).nThen(function (w) {
|
||||||
|
var abortAndCB = Util.both(w.abort, cb);
|
||||||
|
Env.blobStore.status(safeKey, w(function (err, inProgress) {
|
||||||
|
// if there's an error something is weird
|
||||||
|
if (err) { return void abortAndCB(err); }
|
||||||
|
|
||||||
|
// we cannot upload two things at once
|
||||||
|
if (inProgress) { return void abortAndCB(void 0, true); }
|
||||||
|
}));
|
||||||
|
}).nThen(function () {
|
||||||
|
// if yuo're here then there are no pending uploads
|
||||||
|
// check if you have space in your quota to upload something of this size
|
||||||
|
Pinning.getFreeSpace(Env, safeKey, function (e, free) {
|
||||||
|
if (e) { return void cb(e); }
|
||||||
|
if (filesize >= free) { return cb('NOT_ENOUGH_SPACE'); }
|
||||||
|
|
||||||
|
var user = Core.getSession(Env.Sessions, safeKey);
|
||||||
|
user.pendingUploadSize = filesize;
|
||||||
|
user.currentUploadSize = 0;
|
||||||
|
|
||||||
|
cb(void 0, false);
|
||||||
|
});
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
|
Upload.upload = function (Env, safeKey, chunk, cb) {
|
||||||
|
Env.blobStore.upload(safeKey, chunk, cb);
|
||||||
|
};
|
||||||
|
|
||||||
|
Upload.complete = function (Env, safeKey, arg, cb) {
|
||||||
|
Env.blobStore.complete(safeKey, arg, cb);
|
||||||
|
};
|
||||||
|
|
||||||
|
Upload.cancel = function (Env, safeKey, arg, cb) {
|
||||||
|
Env.blobStore.cancel(safeKey, arg, cb);
|
||||||
|
};
|
||||||
|
|
||||||
|
Upload.complete_owned = function (Env, safeKey, arg, cb) {
|
||||||
|
Env.blobStore.completeOwned(safeKey, arg, cb);
|
||||||
|
};
|
||||||
|
|
||||||
@ -1,11 +0,0 @@
|
|||||||
// remove duplicate elements in an array
|
|
||||||
module.exports = function (O) {
|
|
||||||
// make a copy of the original array
|
|
||||||
var A = O.slice();
|
|
||||||
for (var i = 0; i < A.length; i++) {
|
|
||||||
for (var j = i + 1; j < A.length; j++) {
|
|
||||||
if (A[i] === A[j]) { A.splice(j--, 1); }
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return A;
|
|
||||||
};
|
|
||||||
@ -0,0 +1,86 @@
|
|||||||
|
var Default = module.exports;
|
||||||
|
|
||||||
|
Default.commonCSP = function (domain) {
|
||||||
|
domain = ' ' + domain;
|
||||||
|
// Content-Security-Policy
|
||||||
|
|
||||||
|
return [
|
||||||
|
"default-src 'none'",
|
||||||
|
"style-src 'unsafe-inline' 'self' " + domain,
|
||||||
|
"font-src 'self' data:" + domain,
|
||||||
|
|
||||||
|
/* child-src is used to restrict iframes to a set of allowed domains.
|
||||||
|
* connect-src is used to restrict what domains can connect to the websocket.
|
||||||
|
*
|
||||||
|
* it is recommended that you configure these fields to match the
|
||||||
|
* domain which will serve your CryptPad instance.
|
||||||
|
*/
|
||||||
|
"child-src blob: *",
|
||||||
|
// IE/Edge
|
||||||
|
"frame-src blob: *",
|
||||||
|
|
||||||
|
/* this allows connections over secure or insecure websockets
|
||||||
|
if you are deploying to production, you'll probably want to remove
|
||||||
|
the ws://* directive, and change '*' to your domain
|
||||||
|
*/
|
||||||
|
"connect-src 'self' ws: wss: blob:" + domain,
|
||||||
|
|
||||||
|
// data: is used by codemirror
|
||||||
|
"img-src 'self' data: blob:" + domain,
|
||||||
|
"media-src * blob:",
|
||||||
|
|
||||||
|
// for accounts.cryptpad.fr authentication and cross-domain iframe sandbox
|
||||||
|
"frame-ancestors *",
|
||||||
|
""
|
||||||
|
];
|
||||||
|
};
|
||||||
|
|
||||||
|
Default.contentSecurity = function (domain) {
|
||||||
|
return (Default.commonCSP(domain).join('; ') + "script-src 'self' resource: " + domain).replace(/\s+/g, ' ');
|
||||||
|
};
|
||||||
|
|
||||||
|
Default.padContentSecurity = function (domain) {
|
||||||
|
return (Default.commonCSP(domain).join('; ') + "script-src 'self' 'unsafe-eval' 'unsafe-inline' resource: " + domain).replace(/\s+/g, ' ');
|
||||||
|
};
|
||||||
|
|
||||||
|
Default.httpHeaders = function () {
|
||||||
|
return {
|
||||||
|
"X-XSS-Protection": "1; mode=block",
|
||||||
|
"X-Content-Type-Options": "nosniff",
|
||||||
|
"Access-Control-Allow-Origin": "*"
|
||||||
|
};
|
||||||
|
};
|
||||||
|
|
||||||
|
Default.mainPages = function () {
|
||||||
|
return [
|
||||||
|
'index',
|
||||||
|
'privacy',
|
||||||
|
'terms',
|
||||||
|
'about',
|
||||||
|
'contact',
|
||||||
|
'what-is-cryptpad',
|
||||||
|
'features',
|
||||||
|
'faq',
|
||||||
|
'maintenance'
|
||||||
|
];
|
||||||
|
};
|
||||||
|
|
||||||
|
/* By default the CryptPad server will run scheduled tasks every five minutes
|
||||||
|
* If you want to run scheduled tasks in a separate process (like a crontab)
|
||||||
|
* you can disable this behaviour by setting the following value to true
|
||||||
|
*/
|
||||||
|
//disableIntegratedTasks: false,
|
||||||
|
|
||||||
|
/* CryptPad's file storage adaptor closes unused files after a configurable
|
||||||
|
* number of milliseconds (default 30000 (30 seconds))
|
||||||
|
*/
|
||||||
|
// channelExpirationMs: 30000,
|
||||||
|
|
||||||
|
/* CryptPad's file storage adaptor is limited by the number of open files.
|
||||||
|
* When the adaptor reaches openFileLimit, it will clean up older files
|
||||||
|
*/
|
||||||
|
//openFileLimit: 2048,
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
@ -0,0 +1,267 @@
|
|||||||
|
/* jshint esversion: 6 */
|
||||||
|
|
||||||
|
const nThen = require('nthen');
|
||||||
|
const Crypto = require('crypto');
|
||||||
|
const WriteQueue = require("./write-queue");
|
||||||
|
const BatchRead = require("./batch-read");
|
||||||
|
const RPC = require("./rpc");
|
||||||
|
const HK = require("./hk-util.js");
|
||||||
|
const Core = require("./commands/core");
|
||||||
|
|
||||||
|
const Store = require("./storage/file");
|
||||||
|
const BlobStore = require("./storage/blob");
|
||||||
|
|
||||||
|
module.exports.create = function (config, cb) {
|
||||||
|
const Log = config.log;
|
||||||
|
var WARN = function (e, output) {
|
||||||
|
if (e && output) {
|
||||||
|
Log.warn(e, {
|
||||||
|
output: output,
|
||||||
|
message: String(e),
|
||||||
|
stack: new Error(e).stack,
|
||||||
|
});
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
Log.silly('HK_LOADING', 'LOADING HISTORY_KEEPER MODULE');
|
||||||
|
|
||||||
|
// TODO populate Env with everything that you use from config
|
||||||
|
// so that you can stop passing around your raw config
|
||||||
|
// and more easily share state between historyKeeper and rpc
|
||||||
|
const Env = {
|
||||||
|
Log: Log,
|
||||||
|
// tasks
|
||||||
|
// store
|
||||||
|
id: Crypto.randomBytes(8).toString('hex'),
|
||||||
|
|
||||||
|
metadata_cache: {},
|
||||||
|
channel_cache: {},
|
||||||
|
queueStorage: WriteQueue(),
|
||||||
|
|
||||||
|
batchIndexReads: BatchRead("HK_GET_INDEX"),
|
||||||
|
batchMetadata: BatchRead('GET_METADATA'),
|
||||||
|
batchRegisteredUsers: BatchRead("GET_REGISTERED_USERS"),
|
||||||
|
batchDiskUsage: BatchRead('GET_DISK_USAGE'),
|
||||||
|
|
||||||
|
//historyKeeper: config.historyKeeper,
|
||||||
|
intervals: config.intervals || {},
|
||||||
|
maxUploadSize: config.maxUploadSize || (20 * 1024 * 1024),
|
||||||
|
premiumUploadSize: false, // overridden below...
|
||||||
|
Sessions: {},
|
||||||
|
paths: {},
|
||||||
|
//msgStore: config.store,
|
||||||
|
|
||||||
|
netfluxUsers: {},
|
||||||
|
|
||||||
|
pinStore: undefined,
|
||||||
|
pinnedPads: {},
|
||||||
|
pinsLoaded: false,
|
||||||
|
pendingPinInquiries: {},
|
||||||
|
pendingUnpins: {},
|
||||||
|
pinWorkers: 5,
|
||||||
|
|
||||||
|
limits: {},
|
||||||
|
admins: [],
|
||||||
|
WARN: WARN,
|
||||||
|
flushCache: config.flushCache,
|
||||||
|
adminEmail: config.adminEmail,
|
||||||
|
allowSubscriptions: config.allowSubscriptions === true,
|
||||||
|
blockDailyCheck: config.blockDailyCheck === true,
|
||||||
|
|
||||||
|
myDomain: config.myDomain,
|
||||||
|
mySubdomain: config.mySubdomain, // only exists for the accounts integration
|
||||||
|
customLimits: config.customLimits || {},
|
||||||
|
// FIXME this attribute isn't in the default conf
|
||||||
|
// but it is referenced in Quota
|
||||||
|
domain: config.domain
|
||||||
|
};
|
||||||
|
|
||||||
|
(function () {
|
||||||
|
var pes = config.premiumUploadSize;
|
||||||
|
if (!isNaN(pes) && pes >= Env.maxUploadSize) {
|
||||||
|
Env.premiumUploadSize = pes;
|
||||||
|
}
|
||||||
|
}());
|
||||||
|
|
||||||
|
var paths = Env.paths;
|
||||||
|
|
||||||
|
var keyOrDefaultString = function (key, def) {
|
||||||
|
return typeof(config[key]) === 'string'? config[key]: def;
|
||||||
|
};
|
||||||
|
|
||||||
|
var pinPath = paths.pin = keyOrDefaultString('pinPath', './pins');
|
||||||
|
paths.block = keyOrDefaultString('blockPath', './block');
|
||||||
|
paths.data = keyOrDefaultString('filePath', './datastore');
|
||||||
|
paths.staging = keyOrDefaultString('blobStagingPath', './blobstage');
|
||||||
|
paths.blob = keyOrDefaultString('blobPath', './blob');
|
||||||
|
|
||||||
|
Env.defaultStorageLimit = typeof(config.defaultStorageLimit) === 'number' && config.defaultStorageLimit > 0?
|
||||||
|
config.defaultStorageLimit:
|
||||||
|
Core.DEFAULT_LIMIT;
|
||||||
|
|
||||||
|
try {
|
||||||
|
Env.admins = (config.adminKeys || []).map(function (k) {
|
||||||
|
k = k.replace(/\/+$/, '');
|
||||||
|
var s = k.split('/');
|
||||||
|
return s[s.length-1];
|
||||||
|
});
|
||||||
|
} catch (e) {
|
||||||
|
console.error("Can't parse admin keys. Please update or fix your config.js file!");
|
||||||
|
}
|
||||||
|
|
||||||
|
config.historyKeeper = Env.historyKeeper = {
|
||||||
|
metadata_cache: Env.metadata_cache,
|
||||||
|
channel_cache: Env.channel_cache,
|
||||||
|
|
||||||
|
id: Env.id,
|
||||||
|
|
||||||
|
channelMessage: function (Server, channel, msgStruct) {
|
||||||
|
// netflux-server emits 'channelMessage' events whenever someone broadcasts to a channel
|
||||||
|
// historyKeeper stores these messages if the channel id indicates that they are
|
||||||
|
// a channel type with permanent history
|
||||||
|
HK.onChannelMessage(Env, Server, channel, msgStruct);
|
||||||
|
},
|
||||||
|
channelClose: function (channelName) {
|
||||||
|
// netflux-server emits 'channelClose' events whenever everyone leaves a channel
|
||||||
|
// we drop cached metadata and indexes at the same time
|
||||||
|
HK.dropChannel(Env, channelName);
|
||||||
|
},
|
||||||
|
channelOpen: function (Server, channelName, userId, wait) {
|
||||||
|
Env.channel_cache[channelName] = Env.channel_cache[channelName] || {};
|
||||||
|
|
||||||
|
var sendHKJoinMessage = function () {
|
||||||
|
Server.send(userId, [
|
||||||
|
0,
|
||||||
|
Env.id,
|
||||||
|
'JOIN',
|
||||||
|
channelName
|
||||||
|
]);
|
||||||
|
};
|
||||||
|
|
||||||
|
// a little backwards compatibility in case you don't have the latest server
|
||||||
|
// allow lists won't work unless you update, though
|
||||||
|
if (typeof(wait) !== 'function') { return void sendHKJoinMessage(); }
|
||||||
|
|
||||||
|
var next = wait();
|
||||||
|
var cb = function (err, info) {
|
||||||
|
next(err, info, sendHKJoinMessage);
|
||||||
|
};
|
||||||
|
|
||||||
|
// only conventional channels can be restricted
|
||||||
|
if ((channelName || "").length !== HK.STANDARD_CHANNEL_LENGTH) {
|
||||||
|
return void cb();
|
||||||
|
}
|
||||||
|
|
||||||
|
// gets and caches the metadata...
|
||||||
|
HK.getMetadata(Env, channelName, function (err, metadata) {
|
||||||
|
if (err) {
|
||||||
|
Log.error('HK_METADATA_ERR', {
|
||||||
|
channel: channelName,
|
||||||
|
error: err,
|
||||||
|
});
|
||||||
|
}
|
||||||
|
if (!metadata || (metadata && !metadata.restricted)) {
|
||||||
|
// the channel doesn't have metadata, or it does and it's not restricted
|
||||||
|
// either way, let them join.
|
||||||
|
return void cb();
|
||||||
|
}
|
||||||
|
|
||||||
|
// this channel is restricted. verify that the user in question is in the allow list
|
||||||
|
|
||||||
|
// construct a definitive list (owners + allowed)
|
||||||
|
var allowed = HK.listAllowedUsers(metadata);
|
||||||
|
// and get the list of keys for which this user has already authenticated
|
||||||
|
var session = HK.getNetfluxSession(Env, userId);
|
||||||
|
|
||||||
|
if (HK.isUserSessionAllowed(allowed, session)) {
|
||||||
|
return void cb();
|
||||||
|
}
|
||||||
|
|
||||||
|
// otherwise they're not allowed.
|
||||||
|
// respond with a special error that includes the list of keys
|
||||||
|
// which would be allowed...
|
||||||
|
// FIXME RESTRICT bonus points if you hash the keys to limit data exposure
|
||||||
|
cb("ERESTRICTED", allowed);
|
||||||
|
});
|
||||||
|
},
|
||||||
|
sessionClose: function (userId, reason) {
|
||||||
|
HK.closeNetfluxSession(Env, userId);
|
||||||
|
if (['BAD_MESSAGE', 'SOCKET_ERROR', 'SEND_MESSAGE_FAIL_2'].indexOf(reason) !== -1) {
|
||||||
|
if (reason && reason.code === 'ECONNRESET') { return; }
|
||||||
|
return void Log.error('SESSION_CLOSE_WITH_ERROR', {
|
||||||
|
userId: userId,
|
||||||
|
reason: reason,
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
if (['SOCKET_CLOSED', 'SOCKET_ERROR'].indexOf(reason)) { return; }
|
||||||
|
Log.verbose('SESSION_CLOSE_ROUTINE', {
|
||||||
|
userId: userId,
|
||||||
|
reason: reason,
|
||||||
|
});
|
||||||
|
},
|
||||||
|
directMessage: function (Server, seq, userId, json) {
|
||||||
|
// netflux-server allows you to register an id with a handler
|
||||||
|
// this handler is invoked every time someone sends a message to that id
|
||||||
|
HK.onDirectMessage(Env, Server, seq, userId, json);
|
||||||
|
},
|
||||||
|
};
|
||||||
|
|
||||||
|
Log.verbose('HK_ID', 'History keeper ID: ' + Env.id);
|
||||||
|
|
||||||
|
nThen(function (w) {
|
||||||
|
// create a pin store
|
||||||
|
Store.create({
|
||||||
|
filePath: pinPath,
|
||||||
|
}, w(function (s) {
|
||||||
|
Env.pinStore = s;
|
||||||
|
}));
|
||||||
|
|
||||||
|
// create a channel store
|
||||||
|
Store.create(config, w(function (_store) {
|
||||||
|
config.store = _store;
|
||||||
|
Env.msgStore = _store; // API used by rpc
|
||||||
|
Env.store = _store; // API used by historyKeeper
|
||||||
|
}));
|
||||||
|
|
||||||
|
// create a blob store
|
||||||
|
BlobStore.create({
|
||||||
|
blobPath: config.blobPath,
|
||||||
|
blobStagingPath: config.blobStagingPath,
|
||||||
|
archivePath: config.archivePath,
|
||||||
|
getSession: function (safeKey) {
|
||||||
|
return Core.getSession(Env.Sessions, safeKey);
|
||||||
|
},
|
||||||
|
}, w(function (err, blob) {
|
||||||
|
if (err) { throw new Error(err); }
|
||||||
|
Env.blobStore = blob;
|
||||||
|
}));
|
||||||
|
}).nThen(function (w) {
|
||||||
|
// create a task store
|
||||||
|
require("./storage/tasks").create(config, w(function (e, tasks) {
|
||||||
|
if (e) {
|
||||||
|
throw e;
|
||||||
|
}
|
||||||
|
Env.tasks = tasks;
|
||||||
|
config.tasks = tasks;
|
||||||
|
if (config.disableIntegratedTasks) { return; }
|
||||||
|
|
||||||
|
config.intervals = config.intervals || {};
|
||||||
|
config.intervals.taskExpiration = setInterval(function () {
|
||||||
|
tasks.runAll(function (err) {
|
||||||
|
if (err) {
|
||||||
|
// either TASK_CONCURRENCY or an error with tasks.list
|
||||||
|
// in either case it is already logged.
|
||||||
|
}
|
||||||
|
});
|
||||||
|
}, 1000 * 60 * 5); // run every five minutes
|
||||||
|
}));
|
||||||
|
}).nThen(function () {
|
||||||
|
RPC.create(Env, function (err, _rpc) {
|
||||||
|
if (err) { throw err; }
|
||||||
|
|
||||||
|
Env.rpc = _rpc;
|
||||||
|
cb(void 0, config.historyKeeper);
|
||||||
|
});
|
||||||
|
});
|
||||||
|
};
|
||||||
File diff suppressed because it is too large
Load Diff
@ -1,7 +0,0 @@
|
|||||||
module.exports = function (f, g) {
|
|
||||||
return function () {
|
|
||||||
if (!f) { return; }
|
|
||||||
f.apply(this, Array.prototype.slice.call(arguments));
|
|
||||||
f = g;
|
|
||||||
};
|
|
||||||
};
|
|
||||||
@ -0,0 +1,235 @@
|
|||||||
|
/*
|
||||||
|
|
||||||
|
There are many situations where we want to do lots of little jobs
|
||||||
|
in parallel and with few constraints as to their ordering.
|
||||||
|
|
||||||
|
One example is recursing over a bunch of directories and reading files.
|
||||||
|
The naive way to do this is to recurse over all the subdirectories
|
||||||
|
relative to a root while adding files to a list. Then to iterate over
|
||||||
|
the files in that list. Unfortunately, this means holding the complete
|
||||||
|
list of file paths in memory, which can't possible scale as our database grows.
|
||||||
|
|
||||||
|
A better way to do this is to recurse into one directory and
|
||||||
|
iterate over its contents until there are no more, then to backtrack
|
||||||
|
to the next directory and repeat until no more directories exist.
|
||||||
|
This kind of thing is easy enough when you perform one task at a time
|
||||||
|
and use synchronous code, but with multiple asynchronous tasks it's
|
||||||
|
easy to introduce subtle bugs.
|
||||||
|
|
||||||
|
This module is designed for these situations. It allows you to easily
|
||||||
|
and efficiently schedule a large number of tasks with an associated
|
||||||
|
degree of priority from 0 (highest priority) to Number.MAX_SAFE_INTEGER.
|
||||||
|
|
||||||
|
Initialize your scheduler with a degree of parallelism, and start planning
|
||||||
|
some initial jobs. Set it to run and it will keep going until all jobs are
|
||||||
|
complete, at which point it will optionally execute a 'done' callback.
|
||||||
|
|
||||||
|
Getting back to the original example:
|
||||||
|
|
||||||
|
List the contents of the root directory, then plan subsequent jobs
|
||||||
|
with a priority of 1 to recurse into subdirectories. The callback
|
||||||
|
of each of these recursions can then plan higher priority tasks
|
||||||
|
to actually process the contained files with a priority of 0.
|
||||||
|
|
||||||
|
As long as there are more files scheduled it will continue to process
|
||||||
|
them first. When there are no more files the scheduler will read
|
||||||
|
the next directory and repopulate the list of files to process.
|
||||||
|
This will repeat until everything is done.
|
||||||
|
|
||||||
|
// load the module
|
||||||
|
const Plan = require("./plan");
|
||||||
|
|
||||||
|
// instantiate a scheduler with a parallelism of 5
|
||||||
|
var plan = Plan(5)
|
||||||
|
|
||||||
|
// plan the first job which schedules more jobs...
|
||||||
|
.job(1, function (next) {
|
||||||
|
listRootDirectory(function (files) {
|
||||||
|
files.forEach(function (file) {
|
||||||
|
// highest priority, run as soon as there is a free worker
|
||||||
|
plan.job(0, function (next) {
|
||||||
|
processFile(file, function (result) {
|
||||||
|
console.log(result);
|
||||||
|
// don't forget to call next
|
||||||
|
next();
|
||||||
|
});
|
||||||
|
});
|
||||||
|
});
|
||||||
|
next(); // call 'next' to free up one worker
|
||||||
|
});
|
||||||
|
})
|
||||||
|
// chain commands together if you want
|
||||||
|
.done(function () {
|
||||||
|
console.log("DONE");
|
||||||
|
})
|
||||||
|
// it won't run unless you launch it
|
||||||
|
.start();
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
module.exports = function (max) {
|
||||||
|
var plan = {};
|
||||||
|
max = max || 5;
|
||||||
|
|
||||||
|
// finds an id that isn't in use in a particular map
|
||||||
|
// accepts an id in case you have one already chosen
|
||||||
|
// otherwise generates random new ids if one is not passed
|
||||||
|
// or if there is a collision
|
||||||
|
var uid = function (map, id) {
|
||||||
|
if (typeof(id) === 'undefined') {
|
||||||
|
id = Math.floor(Math.random() * Number.MAX_SAFE_INTEGER);
|
||||||
|
}
|
||||||
|
if (id && typeof(map[id]) === 'undefined') {
|
||||||
|
return id;
|
||||||
|
}
|
||||||
|
return uid(map);
|
||||||
|
};
|
||||||
|
|
||||||
|
// the queue of jobs is an array, which will be populated
|
||||||
|
// with maps for each level of priority
|
||||||
|
var jobs = [];
|
||||||
|
|
||||||
|
// the count of currently running jobs
|
||||||
|
var count = 0;
|
||||||
|
|
||||||
|
// a list of callbacks to be executed once everything is done
|
||||||
|
var completeHandlers = [];
|
||||||
|
|
||||||
|
// the recommended usage is to create a new scheduler for every job
|
||||||
|
// use it for internals in a scope, and let the garbage collector
|
||||||
|
// clean up when everything stops. This means you shouldn't
|
||||||
|
// go passing 'plan' around in a long-lived process!
|
||||||
|
var FINISHED = false;
|
||||||
|
var done = function () {
|
||||||
|
// 'done' gets called when there are no more jobs in the queue
|
||||||
|
// but other jobs might still be running...
|
||||||
|
|
||||||
|
// the count of running processes should never be less than zero
|
||||||
|
// because we guard against multiple callbacks
|
||||||
|
if (count < 0) { throw new Error("should never happen"); }
|
||||||
|
// greater than zero is definitely possible, it just means you aren't done yet
|
||||||
|
if (count !== 0) { return; }
|
||||||
|
// you will finish twice if you call 'start' a second time
|
||||||
|
// this behaviour isn't supported yet.
|
||||||
|
if (FINISHED) { throw new Error('finished twice'); }
|
||||||
|
FINISHED = true;
|
||||||
|
// execute all your 'done' callbacks
|
||||||
|
completeHandlers.forEach(function (f) { f(); });
|
||||||
|
};
|
||||||
|
|
||||||
|
var run;
|
||||||
|
|
||||||
|
// this 'next' is internal only.
|
||||||
|
// it iterates over all known jobs, running them until
|
||||||
|
// the scheduler achieves the desired amount of parallelism.
|
||||||
|
// If there are no more jobs it will call 'done'
|
||||||
|
// which will shortcircuit if there are still pending tasks.
|
||||||
|
// Whenever any tasks finishes it will return its lock and
|
||||||
|
// run as many new jobs as are allowed.
|
||||||
|
var next = function () {
|
||||||
|
// array.some skips over bare indexes in sparse arrays
|
||||||
|
var pending = jobs.some(function (bag /*, priority*/) {
|
||||||
|
if (!bag || typeof(bag) !== 'object') { return; }
|
||||||
|
// a bag is a map of jobs for any particular degree of priority
|
||||||
|
// iterate over jobs in the bag until you're out of 'workers'
|
||||||
|
for (var id in bag) {
|
||||||
|
// bail out if you hit max parallelism
|
||||||
|
if (count >= max) { return true; }
|
||||||
|
run(bag, id, next);
|
||||||
|
}
|
||||||
|
});
|
||||||
|
// check whether you're done if you hit the end of the array
|
||||||
|
if (!pending) { done(); }
|
||||||
|
};
|
||||||
|
|
||||||
|
// and here's the part that actually handles jobs...
|
||||||
|
run = function (bag, id) {
|
||||||
|
// this is just a sanity check.
|
||||||
|
// there should only ever be jobs in each bag.
|
||||||
|
if (typeof(bag[id]) !== 'function') {
|
||||||
|
throw new Error("expected function");
|
||||||
|
}
|
||||||
|
|
||||||
|
// keep a local reference to the function
|
||||||
|
var f = bag[id];
|
||||||
|
// remove it from the bag.
|
||||||
|
delete bag[id];
|
||||||
|
// increment the count of running jobs
|
||||||
|
count++;
|
||||||
|
|
||||||
|
// guard against it being called twice.
|
||||||
|
var called = false;
|
||||||
|
f(function () {
|
||||||
|
// watch out! it'll bite you.
|
||||||
|
// maybe this should just return?
|
||||||
|
// support that option for 'production' ?
|
||||||
|
if (called) { throw new Error("called twice"); }
|
||||||
|
// the code below is safe because we can't call back a second time
|
||||||
|
called = true;
|
||||||
|
|
||||||
|
// decrement the count of running jobs...
|
||||||
|
count--;
|
||||||
|
|
||||||
|
// and finally call next to replace this worker with more job(s)
|
||||||
|
next();
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
|
// this is exposed as API
|
||||||
|
plan.job = function (priority, cb) {
|
||||||
|
// you have to pass both the priority (a non-negative number) and an actual job
|
||||||
|
if (typeof(priority) !== 'number' || priority < 0) { throw new Error('expected a non-negative number'); }
|
||||||
|
// a job is an asynchronous function that takes a single parameter:
|
||||||
|
// a 'next' callback which will keep the whole thing going.
|
||||||
|
// forgetting to call 'next' means you'll never complete.
|
||||||
|
if (typeof(cb) !== 'function') { throw new Error('expected function'); }
|
||||||
|
|
||||||
|
// initialize the specified priority level if it doesn't already exist
|
||||||
|
var bag = jobs[priority] = jobs[priority] || {};
|
||||||
|
// choose a random id that isn't already in use for this priority level
|
||||||
|
var id = uid(bag);
|
||||||
|
|
||||||
|
// add the job to this priority level's bag
|
||||||
|
// most (all?) javascript engines will append this job to the bottom
|
||||||
|
// of the map. Meaning when we iterate it will be run later than
|
||||||
|
// other jobs that were scheduled first, effectively making a FIFO queue.
|
||||||
|
// However, this is undefined behaviour and you shouldn't ever rely on it.
|
||||||
|
bag[id] = function (next) {
|
||||||
|
cb(next);
|
||||||
|
};
|
||||||
|
// returning 'plan' lets us chain methods together.
|
||||||
|
return plan;
|
||||||
|
};
|
||||||
|
|
||||||
|
var started = false;
|
||||||
|
plan.start = function () {
|
||||||
|
// don't allow multiple starts
|
||||||
|
// even though it should work, it's simpler not to.
|
||||||
|
if (started) { return plan; }
|
||||||
|
// this seems to imply a 'stop' method
|
||||||
|
// but I don't need it, so I'm not implementing it now --ansuz
|
||||||
|
started = true;
|
||||||
|
|
||||||
|
// start asynchronously, otherwise jobs will start running
|
||||||
|
// before you've had a chance to return 'plan', and weird things
|
||||||
|
// happen.
|
||||||
|
setTimeout(function () {
|
||||||
|
next();
|
||||||
|
});
|
||||||
|
return plan;
|
||||||
|
};
|
||||||
|
|
||||||
|
// you can pass any number of functions to be executed
|
||||||
|
// when all pending jobs are complete.
|
||||||
|
// We don't pass any arguments, so you need to handle return values
|
||||||
|
// yourself if you want them.
|
||||||
|
plan.done = function (f) {
|
||||||
|
if (typeof(f) !== 'function') { throw new Error('expected function'); }
|
||||||
|
completeHandlers.push(f);
|
||||||
|
return plan;
|
||||||
|
};
|
||||||
|
|
||||||
|
// That's all! I hope you had fun reading this!
|
||||||
|
return plan;
|
||||||
|
};
|
||||||
|
|
||||||
@ -0,0 +1,216 @@
|
|||||||
|
/*jshint esversion: 6 */
|
||||||
|
const Util = require("./common-util");
|
||||||
|
|
||||||
|
const Core = require("./commands/core");
|
||||||
|
const Admin = require("./commands/admin-rpc");
|
||||||
|
const Pinning = require("./commands/pin-rpc");
|
||||||
|
const Quota = require("./commands/quota");
|
||||||
|
const Block = require("./commands/block");
|
||||||
|
const Metadata = require("./commands/metadata");
|
||||||
|
const Channel = require("./commands/channel");
|
||||||
|
const Upload = require("./commands/upload");
|
||||||
|
const HK = require("./hk-util");
|
||||||
|
|
||||||
|
var RPC = module.exports;
|
||||||
|
|
||||||
|
const UNAUTHENTICATED_CALLS = {
|
||||||
|
GET_FILE_SIZE: Pinning.getFileSize,
|
||||||
|
GET_MULTIPLE_FILE_SIZE: Pinning.getMultipleFileSize,
|
||||||
|
GET_DELETED_PADS: Pinning.getDeletedPads,
|
||||||
|
IS_CHANNEL_PINNED: Pinning.isChannelPinned,
|
||||||
|
IS_NEW_CHANNEL: Channel.isNewChannel,
|
||||||
|
WRITE_PRIVATE_MESSAGE: Channel.writePrivateMessage,
|
||||||
|
GET_METADATA: Metadata.getMetadata,
|
||||||
|
};
|
||||||
|
|
||||||
|
var isUnauthenticateMessage = function (msg) {
|
||||||
|
return msg && msg.length === 2 && typeof(UNAUTHENTICATED_CALLS[msg[0]]) === 'function';
|
||||||
|
};
|
||||||
|
|
||||||
|
var handleUnauthenticatedMessage = function (Env, msg, respond, Server, netfluxId) {
|
||||||
|
Env.Log.silly('LOG_RPC', msg[0]);
|
||||||
|
|
||||||
|
var method = UNAUTHENTICATED_CALLS[msg[0]];
|
||||||
|
method(Env, msg[1], function (err, value) {
|
||||||
|
if (err) {
|
||||||
|
Env.WARN(err, msg[1]);
|
||||||
|
return void respond(err);
|
||||||
|
}
|
||||||
|
respond(err, [null, value, null]);
|
||||||
|
}, Server, netfluxId);
|
||||||
|
};
|
||||||
|
|
||||||
|
const AUTHENTICATED_USER_TARGETED = {
|
||||||
|
RESET: Pinning.resetUserPins,
|
||||||
|
PIN: Pinning.pinChannel,
|
||||||
|
UNPIN: Pinning.unpinChannel,
|
||||||
|
CLEAR_OWNED_CHANNEL: Channel.clearOwnedChannel,
|
||||||
|
REMOVE_OWNED_CHANNEL: Channel.removeOwnedChannel,
|
||||||
|
TRIM_HISTORY: Channel.trimHistory,
|
||||||
|
UPLOAD_STATUS: Upload.status,
|
||||||
|
UPLOAD: Upload.upload,
|
||||||
|
UPLOAD_COMPLETE: Upload.complete,
|
||||||
|
UPLOAD_CANCEL: Upload.cancel,
|
||||||
|
OWNED_UPLOAD_COMPLETE: Upload.complete_owned,
|
||||||
|
WRITE_LOGIN_BLOCK: Block.writeLoginBlock,
|
||||||
|
REMOVE_LOGIN_BLOCK: Block.removeLoginBlock,
|
||||||
|
ADMIN: Admin.command,
|
||||||
|
SET_METADATA: Metadata.setMetadata,
|
||||||
|
};
|
||||||
|
|
||||||
|
const AUTHENTICATED_USER_SCOPED = {
|
||||||
|
GET_HASH: Pinning.getHash,
|
||||||
|
GET_TOTAL_SIZE: Pinning.getTotalSize,
|
||||||
|
UPDATE_LIMITS: Quota.getUpdatedLimit,
|
||||||
|
GET_LIMIT: Pinning.getLimit,
|
||||||
|
EXPIRE_SESSION: Core.expireSessionAsync,
|
||||||
|
REMOVE_PINS: Pinning.removePins,
|
||||||
|
TRIM_PINS: Pinning.trimPins,
|
||||||
|
COOKIE: Core.haveACookie,
|
||||||
|
};
|
||||||
|
|
||||||
|
var isAuthenticatedCall = function (call) {
|
||||||
|
if (call === 'UPLOAD') { return false; }
|
||||||
|
return typeof(AUTHENTICATED_USER_TARGETED[call] || AUTHENTICATED_USER_SCOPED[call]) === 'function';
|
||||||
|
};
|
||||||
|
|
||||||
|
var handleAuthenticatedMessage = function (Env, unsafeKey, msg, respond, Server) {
|
||||||
|
/* If you have gotten this far, you have signed the message with the
|
||||||
|
public key which you provided.
|
||||||
|
*/
|
||||||
|
|
||||||
|
var safeKey = Util.escapeKeyCharacters(unsafeKey);
|
||||||
|
|
||||||
|
var Respond = function (e, value) {
|
||||||
|
var session = Env.Sessions[safeKey];
|
||||||
|
var token = session? session.tokens.slice(-1)[0]: '';
|
||||||
|
var cookie = Core.makeCookie(token).join('|');
|
||||||
|
respond(e ? String(e): e, [cookie].concat(typeof(value) !== 'undefined' ?value: []));
|
||||||
|
};
|
||||||
|
|
||||||
|
msg.shift();
|
||||||
|
// discard validated cookie from message
|
||||||
|
if (!msg.length) {
|
||||||
|
return void Respond('INVALID_MSG');
|
||||||
|
}
|
||||||
|
|
||||||
|
var TYPE = msg[0];
|
||||||
|
|
||||||
|
Env.Log.silly('LOG_RPC', TYPE);
|
||||||
|
|
||||||
|
if (typeof(AUTHENTICATED_USER_TARGETED[TYPE]) === 'function') {
|
||||||
|
return void AUTHENTICATED_USER_TARGETED[TYPE](Env, safeKey, msg[1], function (e, value) {
|
||||||
|
Env.WARN(e, value);
|
||||||
|
return void Respond(e, value);
|
||||||
|
}, Server);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (typeof(AUTHENTICATED_USER_SCOPED[TYPE]) === 'function') {
|
||||||
|
return void AUTHENTICATED_USER_SCOPED[TYPE](Env, safeKey, function (e, value) {
|
||||||
|
if (e) {
|
||||||
|
Env.WARN(e, safeKey);
|
||||||
|
return void Respond(e);
|
||||||
|
}
|
||||||
|
Respond(e, value);
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
return void Respond('UNSUPPORTED_RPC_CALL', msg);
|
||||||
|
};
|
||||||
|
|
||||||
|
var rpc = function (Env, Server, userId, data, respond) {
|
||||||
|
if (!Array.isArray(data)) {
|
||||||
|
Env.Log.debug('INVALID_ARG_FORMET', data);
|
||||||
|
return void respond('INVALID_ARG_FORMAT');
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!data.length) {
|
||||||
|
return void respond("INSUFFICIENT_ARGS");
|
||||||
|
} else if (data.length !== 1) {
|
||||||
|
Env.Log.debug('UNEXPECTED_ARGUMENTS_LENGTH', data);
|
||||||
|
}
|
||||||
|
|
||||||
|
var msg = data[0].slice(0);
|
||||||
|
|
||||||
|
if (!Array.isArray(msg)) {
|
||||||
|
return void respond('INVALID_ARG_FORMAT');
|
||||||
|
}
|
||||||
|
|
||||||
|
if (isUnauthenticateMessage(msg)) {
|
||||||
|
return handleUnauthenticatedMessage(Env, msg, respond, Server, userId);
|
||||||
|
}
|
||||||
|
|
||||||
|
var signature = msg.shift();
|
||||||
|
var publicKey = msg.shift();
|
||||||
|
|
||||||
|
// make sure a user object is initialized in the cookie jar
|
||||||
|
var session;
|
||||||
|
if (publicKey) {
|
||||||
|
session = Core.getSession(Env.Sessions, publicKey);
|
||||||
|
} else {
|
||||||
|
Env.Log.debug("NO_PUBLIC_KEY_PROVIDED", publicKey);
|
||||||
|
}
|
||||||
|
|
||||||
|
var cookie = msg[0];
|
||||||
|
if (!Core.isValidCookie(Env.Sessions, publicKey, cookie)) {
|
||||||
|
// no cookie is fine if the RPC is to get a cookie
|
||||||
|
if (msg[1] !== 'COOKIE') {
|
||||||
|
return void respond('NO_COOKIE');
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
var serialized = JSON.stringify(msg);
|
||||||
|
|
||||||
|
if (!(serialized && typeof(publicKey) === 'string')) {
|
||||||
|
return void respond('INVALID_MESSAGE_OR_PUBLIC_KEY');
|
||||||
|
}
|
||||||
|
|
||||||
|
var command = msg[1];
|
||||||
|
|
||||||
|
if (command === 'UPLOAD') {
|
||||||
|
// UPLOAD is a special case that skips signature validation
|
||||||
|
// intentional fallthrough behaviour
|
||||||
|
return void handleAuthenticatedMessage(Env, publicKey, msg, respond, Server);
|
||||||
|
}
|
||||||
|
if (isAuthenticatedCall(command)) {
|
||||||
|
// check the signature on the message
|
||||||
|
// refuse the command if it doesn't validate
|
||||||
|
if (Core.checkSignature(Env, serialized, signature, publicKey) === true) {
|
||||||
|
HK.authenticateNetfluxSession(Env, userId, publicKey);
|
||||||
|
return void handleAuthenticatedMessage(Env, publicKey, msg, respond, Server);
|
||||||
|
}
|
||||||
|
return void respond("INVALID_SIGNATURE_OR_PUBLIC_KEY");
|
||||||
|
}
|
||||||
|
Env.Log.warn('INVALID_RPC_CALL', command);
|
||||||
|
return void respond("INVALID_RPC_CALL");
|
||||||
|
};
|
||||||
|
|
||||||
|
RPC.create = function (Env, cb) {
|
||||||
|
var Sessions = Env.Sessions;
|
||||||
|
var updateLimitDaily = function () {
|
||||||
|
Quota.updateCachedLimits(Env, function (e) {
|
||||||
|
if (e) {
|
||||||
|
Env.WARN('limitUpdate', e);
|
||||||
|
}
|
||||||
|
});
|
||||||
|
};
|
||||||
|
Quota.applyCustomLimits(Env);
|
||||||
|
updateLimitDaily();
|
||||||
|
Env.intervals.dailyLimitUpdate = setInterval(updateLimitDaily, 24*3600*1000);
|
||||||
|
|
||||||
|
//Pinning.loadChannelPins(Env); // XXX
|
||||||
|
|
||||||
|
// expire old sessions once per minute
|
||||||
|
Env.intervals.sessionExpirationInterval = setInterval(function () {
|
||||||
|
Core.expireSessions(Sessions);
|
||||||
|
}, Core.SESSION_EXPIRATION_TIME);
|
||||||
|
|
||||||
|
cb(void 0, function (Server, userId, data, respond) {
|
||||||
|
try {
|
||||||
|
return rpc(Env, Server, userId, data, respond);
|
||||||
|
} catch (e) {
|
||||||
|
console.log("Error from RPC with data " + JSON.stringify(data));
|
||||||
|
console.log(e.stack);
|
||||||
|
}
|
||||||
|
});
|
||||||
|
};
|
||||||
@ -0,0 +1,172 @@
|
|||||||
|
var WriteQueue = require("./write-queue");
|
||||||
|
var Util = require("./common-util");
|
||||||
|
|
||||||
|
/* This module provides implements a FIFO scheduler
|
||||||
|
which assumes the existence of three types of async tasks:
|
||||||
|
|
||||||
|
1. ordered tasks which must be executed sequentially
|
||||||
|
2. unordered tasks which can be executed in parallel
|
||||||
|
3. blocking tasks which must block the execution of all other tasks
|
||||||
|
|
||||||
|
The scheduler assumes there will be many resources identified by strings,
|
||||||
|
and that the constraints described above will only apply in the context
|
||||||
|
of identical string ids.
|
||||||
|
|
||||||
|
Many blocking tasks may be executed in parallel so long as they
|
||||||
|
concern resources identified by different ids.
|
||||||
|
|
||||||
|
USAGE:
|
||||||
|
|
||||||
|
const schedule = require("./schedule")();
|
||||||
|
|
||||||
|
// schedule two sequential tasks using the resource 'pewpew'
|
||||||
|
schedule.ordered('pewpew', function (next) {
|
||||||
|
appendToFile('beep\n', next);
|
||||||
|
});
|
||||||
|
schedule.ordered('pewpew', function (next) {
|
||||||
|
appendToFile('boop\n', next);
|
||||||
|
});
|
||||||
|
|
||||||
|
// schedule a task that can happen whenever
|
||||||
|
schedule.unordered('pewpew', function (next) {
|
||||||
|
displayFileSize(next);
|
||||||
|
});
|
||||||
|
|
||||||
|
// schedule a blocking task which will wait
|
||||||
|
// until the all unordered tasks have completed before commencing
|
||||||
|
schedule.blocking('pewpew', function (next) {
|
||||||
|
deleteFile(next);
|
||||||
|
});
|
||||||
|
|
||||||
|
// this will be queued for after the blocking task
|
||||||
|
schedule.ordered('pewpew', function (next) {
|
||||||
|
appendFile('boom', next);
|
||||||
|
});
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
// return a uid which is not already in a map
|
||||||
|
var unusedUid = function (set) {
|
||||||
|
var uid = Util.uid();
|
||||||
|
if (set[uid]) { return unusedUid(); }
|
||||||
|
return uid;
|
||||||
|
};
|
||||||
|
|
||||||
|
// return an existing session, creating one if it does not already exist
|
||||||
|
var lookup = function (map, id) {
|
||||||
|
return (map[id] = map[id] || {
|
||||||
|
//blocking: [],
|
||||||
|
active: {},
|
||||||
|
blocked: {},
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
|
var isEmpty = function (map) {
|
||||||
|
for (var key in map) {
|
||||||
|
if (map.hasOwnProperty(key)) { return false; }
|
||||||
|
}
|
||||||
|
return true;
|
||||||
|
};
|
||||||
|
|
||||||
|
module.exports = function () {
|
||||||
|
// every scheduler instance has its own queue
|
||||||
|
var queue = WriteQueue();
|
||||||
|
|
||||||
|
// ordered tasks don't require any extra logic
|
||||||
|
var Ordered = function (id, task) {
|
||||||
|
queue(id, task);
|
||||||
|
};
|
||||||
|
|
||||||
|
// unordered and blocking tasks need a little extra state
|
||||||
|
var map = {};
|
||||||
|
|
||||||
|
// regular garbage collection keeps memory consumption low
|
||||||
|
var collectGarbage = function (id) {
|
||||||
|
// avoid using 'lookup' since it creates a session implicitly
|
||||||
|
var local = map[id];
|
||||||
|
// bail out if no session
|
||||||
|
if (!local) { return; }
|
||||||
|
// bail out if there are blocking or active tasks
|
||||||
|
if (local.lock) { return; }
|
||||||
|
if (!isEmpty(local.active)) { return; }
|
||||||
|
// if there are no pending actions then delete the session
|
||||||
|
delete map[id];
|
||||||
|
};
|
||||||
|
|
||||||
|
// unordered tasks run immediately if there are no blocking tasks scheduled
|
||||||
|
// or immediately after blocking tasks finish
|
||||||
|
var runImmediately = function (local, task) {
|
||||||
|
// set a flag in the map of active unordered tasks
|
||||||
|
// to prevent blocking tasks from running until you finish
|
||||||
|
var uid = unusedUid(local.active);
|
||||||
|
local.active[uid] = true;
|
||||||
|
|
||||||
|
task(function () {
|
||||||
|
// remove the flag you set to indicate that your task completed
|
||||||
|
delete local.active[uid];
|
||||||
|
// don't do anything if other unordered tasks are still running
|
||||||
|
if (!isEmpty(local.active)) { return; }
|
||||||
|
// bail out if there are no blocking tasks scheduled or ready
|
||||||
|
if (typeof(local.waiting) !== 'function') {
|
||||||
|
return void collectGarbage();
|
||||||
|
}
|
||||||
|
setTimeout(local.waiting);
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
|
var runOnceUnblocked = function (local, task) {
|
||||||
|
var uid = unusedUid(local.blocked);
|
||||||
|
local.blocked[uid] = function () {
|
||||||
|
runImmediately(local, task);
|
||||||
|
};
|
||||||
|
};
|
||||||
|
|
||||||
|
// 'unordered' tasks are scheduled to run in after the most recently received blocking task
|
||||||
|
// or immediately and in parallel if there are no blocking tasks scheduled.
|
||||||
|
var Unordered = function (id, task) {
|
||||||
|
var local = lookup(map, id);
|
||||||
|
if (local.lock) { return runOnceUnblocked(local, task); }
|
||||||
|
runImmediately(local, task);
|
||||||
|
};
|
||||||
|
|
||||||
|
var runBlocked = function (local) {
|
||||||
|
for (var task in local.blocked) {
|
||||||
|
runImmediately(local, local.blocked[task]);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
// 'blocking' tasks must be run alone.
|
||||||
|
// They are queued alongside ordered tasks,
|
||||||
|
// and wait until any running 'unordered' tasks complete before commencing.
|
||||||
|
var Blocking = function (id, task) {
|
||||||
|
var local = lookup(map, id);
|
||||||
|
|
||||||
|
queue(id, function (next) {
|
||||||
|
// start right away if there are no running unordered tasks
|
||||||
|
if (isEmpty(local.active)) {
|
||||||
|
local.lock = true;
|
||||||
|
return void task(function () {
|
||||||
|
delete local.lock;
|
||||||
|
runBlocked(local);
|
||||||
|
next();
|
||||||
|
});
|
||||||
|
}
|
||||||
|
// otherwise wait until the running tasks have completed
|
||||||
|
local.waiting = function () {
|
||||||
|
local.lock = true;
|
||||||
|
task(function () {
|
||||||
|
delete local.lock;
|
||||||
|
delete local.waiting;
|
||||||
|
runBlocked(local);
|
||||||
|
next();
|
||||||
|
});
|
||||||
|
};
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
|
return {
|
||||||
|
ordered: Ordered,
|
||||||
|
unordered: Unordered,
|
||||||
|
blocking: Blocking,
|
||||||
|
};
|
||||||
|
};
|
||||||
@ -0,0 +1,84 @@
|
|||||||
|
/* jshint esversion: 6 */
|
||||||
|
/* global Buffer */
|
||||||
|
|
||||||
|
const ToPull = require('stream-to-pull-stream');
|
||||||
|
const Pull = require('pull-stream');
|
||||||
|
|
||||||
|
const Stream = module.exports;
|
||||||
|
|
||||||
|
// transform a stream of arbitrarily divided data
|
||||||
|
// into a stream of buffers divided by newlines in the source stream
|
||||||
|
// TODO see if we could improve performance by using libnewline
|
||||||
|
const NEWLINE_CHR = ('\n').charCodeAt(0);
|
||||||
|
const mkBufferSplit = () => {
|
||||||
|
let remainder = null;
|
||||||
|
return Pull((read) => {
|
||||||
|
return (abort, cb) => {
|
||||||
|
read(abort, function (end, data) {
|
||||||
|
if (end) {
|
||||||
|
if (data) { console.log("mkBufferSplit() Data at the end"); }
|
||||||
|
cb(end, remainder ? [remainder, data] : [data]);
|
||||||
|
remainder = null;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
const queue = [];
|
||||||
|
for (;;) {
|
||||||
|
const offset = data.indexOf(NEWLINE_CHR);
|
||||||
|
if (offset < 0) {
|
||||||
|
remainder = remainder ? Buffer.concat([remainder, data]) : data;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
let subArray = data.slice(0, offset);
|
||||||
|
if (remainder) {
|
||||||
|
subArray = Buffer.concat([remainder, subArray]);
|
||||||
|
remainder = null;
|
||||||
|
}
|
||||||
|
queue.push(subArray);
|
||||||
|
data = data.slice(offset + 1);
|
||||||
|
}
|
||||||
|
cb(end, queue);
|
||||||
|
});
|
||||||
|
};
|
||||||
|
}, Pull.flatten());
|
||||||
|
};
|
||||||
|
|
||||||
|
// return a streaming function which transforms buffers into objects
|
||||||
|
// containing the buffer and the offset from the start of the stream
|
||||||
|
const mkOffsetCounter = () => {
|
||||||
|
let offset = 0;
|
||||||
|
return Pull.map((buff) => {
|
||||||
|
const out = { offset: offset, buff: buff };
|
||||||
|
// +1 for the eaten newline
|
||||||
|
offset += buff.length + 1;
|
||||||
|
return out;
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
|
// readMessagesBin asynchronously iterates over the messages in a channel log
|
||||||
|
// the handler for each message must call back to read more, which should mean
|
||||||
|
// that this function has a lower memory profile than our classic method
|
||||||
|
// of reading logs line by line.
|
||||||
|
// it also allows the handler to abort reading at any time
|
||||||
|
Stream.readFileBin = (stream, msgHandler, cb) => {
|
||||||
|
//const stream = Fs.createReadStream(path, { start: start });
|
||||||
|
let keepReading = true;
|
||||||
|
Pull(
|
||||||
|
ToPull.read(stream),
|
||||||
|
mkBufferSplit(),
|
||||||
|
mkOffsetCounter(),
|
||||||
|
Pull.asyncMap((data, moreCb) => {
|
||||||
|
msgHandler(data, moreCb, () => {
|
||||||
|
try {
|
||||||
|
stream.close();
|
||||||
|
} catch (err) {
|
||||||
|
console.error("READ_FILE_BIN_ERR", err);
|
||||||
|
}
|
||||||
|
keepReading = false;
|
||||||
|
moreCb();
|
||||||
|
});
|
||||||
|
}),
|
||||||
|
Pull.drain(() => (keepReading), (err) => {
|
||||||
|
cb((keepReading) ? err : undefined);
|
||||||
|
})
|
||||||
|
);
|
||||||
|
};
|
||||||
@ -0,0 +1,46 @@
|
|||||||
|
/*jshint esversion: 6 */
|
||||||
|
const Pins = require("../../lib/pins");
|
||||||
|
|
||||||
|
var stats = {
|
||||||
|
users: 0,
|
||||||
|
lines: 0, // how many lines did you iterate over
|
||||||
|
surplus: 0, // how many of those lines were not needed?
|
||||||
|
pinned: 0, // how many files are pinned?
|
||||||
|
duplicated: 0,
|
||||||
|
};
|
||||||
|
|
||||||
|
var handler = function (ref, id /* safeKey */, pinned) {
|
||||||
|
if (ref.surplus) {
|
||||||
|
//console.log("%s has %s trimmable lines", id, ref.surplus);
|
||||||
|
stats.surplus += ref.surplus;
|
||||||
|
}
|
||||||
|
|
||||||
|
for (var item in ref.pins) {
|
||||||
|
if (!pinned.hasOwnProperty(item)) {
|
||||||
|
//console.log("> %s is pinned", item);
|
||||||
|
stats.pinned++;
|
||||||
|
} else {
|
||||||
|
//console.log("> %s was already pinned", item);
|
||||||
|
stats.duplicated++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
stats.users++;
|
||||||
|
stats.lines += ref.index;
|
||||||
|
//console.log(ref, id);
|
||||||
|
};
|
||||||
|
|
||||||
|
Pins.list(function (err) {
|
||||||
|
if (err) { return void console.error(err); }
|
||||||
|
/*
|
||||||
|
for (var id in pinned) {
|
||||||
|
console.log(id);
|
||||||
|
stats.pinned++;
|
||||||
|
}
|
||||||
|
*/
|
||||||
|
console.log(stats);
|
||||||
|
}, {
|
||||||
|
pinPath: require("../../lib/load-config").pinPath,
|
||||||
|
handler: handler,
|
||||||
|
});
|
||||||
|
|
||||||
@ -0,0 +1,41 @@
|
|||||||
|
/*jshint esversion: 6 */
|
||||||
|
const Plan = require("../../lib/plan");
|
||||||
|
|
||||||
|
var rand_delay = function (f) {
|
||||||
|
setTimeout(f, Math.floor(Math.random() * 1500) + 250);
|
||||||
|
};
|
||||||
|
|
||||||
|
var plan = Plan(6).job(1, function (next) {
|
||||||
|
[1,2,3,4,5,6,7,8,9,10,11,12].forEach(function (n) {
|
||||||
|
plan.job(0, function (next) {
|
||||||
|
rand_delay(function () {
|
||||||
|
console.log("finishing job %s", n);
|
||||||
|
next();
|
||||||
|
});
|
||||||
|
});
|
||||||
|
});
|
||||||
|
console.log("finishing job 0");
|
||||||
|
next();
|
||||||
|
}).job(2, function (next) {
|
||||||
|
console.log("finishing job 13");
|
||||||
|
|
||||||
|
[
|
||||||
|
100,
|
||||||
|
200,
|
||||||
|
300,
|
||||||
|
400
|
||||||
|
].forEach(function (n) {
|
||||||
|
plan.job(3, function (next) {
|
||||||
|
rand_delay(function () {
|
||||||
|
console.log("finishing job %s", n);
|
||||||
|
next();
|
||||||
|
});
|
||||||
|
});
|
||||||
|
});
|
||||||
|
|
||||||
|
next();
|
||||||
|
}).done(function () { console.log("DONE"); }).start();
|
||||||
|
|
||||||
|
//console.log(plan);
|
||||||
|
|
||||||
|
//plan.start();
|
||||||
@ -0,0 +1,220 @@
|
|||||||
|
/* three types of actions:
|
||||||
|
* read
|
||||||
|
* write
|
||||||
|
* append
|
||||||
|
each of which take a random amount of time
|
||||||
|
|
||||||
|
*/
|
||||||
|
var Util = require("../../lib/common-util");
|
||||||
|
var schedule = require("../../lib/schedule")();
|
||||||
|
var nThen = require("nthen");
|
||||||
|
|
||||||
|
var rand = function (n) {
|
||||||
|
return Math.floor(Math.random() * n);
|
||||||
|
};
|
||||||
|
|
||||||
|
var rand_time = function () {
|
||||||
|
// between 51 and 151
|
||||||
|
return rand(300) + 25;
|
||||||
|
};
|
||||||
|
|
||||||
|
var makeAction = function (type) {
|
||||||
|
var i = 0;
|
||||||
|
return function (time) {
|
||||||
|
var j = i++;
|
||||||
|
return function (next) {
|
||||||
|
console.log(" Beginning action: %s#%s", type, j);
|
||||||
|
setTimeout(function () {
|
||||||
|
console.log(" Completed action: %s#%s", type, j);
|
||||||
|
next();
|
||||||
|
}, time);
|
||||||
|
return j;
|
||||||
|
};
|
||||||
|
};
|
||||||
|
};
|
||||||
|
|
||||||
|
var TYPES = ['WRITE', 'READ', 'APPEND'];
|
||||||
|
var chooseAction = function () {
|
||||||
|
var n = rand(100);
|
||||||
|
|
||||||
|
if (n < 50) { return 'APPEND'; }
|
||||||
|
if (n < 90) { return 'READ'; }
|
||||||
|
return 'WRITE';
|
||||||
|
|
||||||
|
//return TYPES[rand(3)];
|
||||||
|
};
|
||||||
|
|
||||||
|
var test = function (script, cb) {
|
||||||
|
var uid = Util.uid();
|
||||||
|
|
||||||
|
var TO_RUN = script.length;
|
||||||
|
var total_run = 0;
|
||||||
|
|
||||||
|
var parallel = 0;
|
||||||
|
var last_run_ordered = -1;
|
||||||
|
//var i = 0;
|
||||||
|
|
||||||
|
var ACTIONS = {};
|
||||||
|
TYPES.forEach(function (type) {
|
||||||
|
ACTIONS[type] = makeAction(type);
|
||||||
|
});
|
||||||
|
|
||||||
|
nThen(function (w) {
|
||||||
|
setTimeout(w(), 3000);
|
||||||
|
// run scripted actions with assertions
|
||||||
|
script.forEach(function (scene) {
|
||||||
|
var type = scene[0];
|
||||||
|
var time = typeof(scene[1]) === 'number'? scene[1]: rand_time();
|
||||||
|
|
||||||
|
var action = ACTIONS[type](time);
|
||||||
|
console.log("Queuing action of type: %s(%s)", type, time);
|
||||||
|
|
||||||
|
var proceed = w();
|
||||||
|
|
||||||
|
switch (type) {
|
||||||
|
case 'APPEND':
|
||||||
|
return schedule.ordered(uid, w(function (next) {
|
||||||
|
parallel++;
|
||||||
|
var temp = action(function () {
|
||||||
|
parallel--;
|
||||||
|
total_run++;
|
||||||
|
proceed();
|
||||||
|
next();
|
||||||
|
});
|
||||||
|
if (temp !== (last_run_ordered + 1)) {
|
||||||
|
throw new Error("out of order");
|
||||||
|
}
|
||||||
|
last_run_ordered = temp;
|
||||||
|
}));
|
||||||
|
case 'WRITE':
|
||||||
|
return schedule.blocking(uid, w(function (next) {
|
||||||
|
parallel++;
|
||||||
|
action(function () {
|
||||||
|
parallel--;
|
||||||
|
total_run++;
|
||||||
|
proceed();
|
||||||
|
next();
|
||||||
|
});
|
||||||
|
if (parallel > 1) {
|
||||||
|
console.log("parallelism === %s", parallel);
|
||||||
|
throw new Error("too much parallel");
|
||||||
|
}
|
||||||
|
}));
|
||||||
|
case 'READ':
|
||||||
|
return schedule.unordered(uid, w(function (next) {
|
||||||
|
parallel++;
|
||||||
|
action(function () {
|
||||||
|
parallel--;
|
||||||
|
total_run++;
|
||||||
|
proceed();
|
||||||
|
next();
|
||||||
|
});
|
||||||
|
}));
|
||||||
|
default:
|
||||||
|
throw new Error("wut");
|
||||||
|
}
|
||||||
|
});
|
||||||
|
}).nThen(function () {
|
||||||
|
// make assertions about the whole script
|
||||||
|
if (total_run !== TO_RUN) {
|
||||||
|
console.log("Ran %s / %s", total_run, TO_RUN);
|
||||||
|
throw new Error("skipped tasks");
|
||||||
|
}
|
||||||
|
console.log("total_run === %s", total_run);
|
||||||
|
|
||||||
|
cb();
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
var randomScript = function () {
|
||||||
|
var len = rand(15) + 10;
|
||||||
|
var script = [];
|
||||||
|
while (len--) {
|
||||||
|
script.push([
|
||||||
|
chooseAction(),
|
||||||
|
rand_time(),
|
||||||
|
]);
|
||||||
|
}
|
||||||
|
return script;
|
||||||
|
};
|
||||||
|
|
||||||
|
var WRITE = function (t) {
|
||||||
|
return ['WRITE', t];
|
||||||
|
};
|
||||||
|
var READ = function (t) {
|
||||||
|
return ['READ', t];
|
||||||
|
};
|
||||||
|
|
||||||
|
var APPEND = function (t) {
|
||||||
|
return ['APPEND', t];
|
||||||
|
};
|
||||||
|
|
||||||
|
nThen(function (w) {
|
||||||
|
test([
|
||||||
|
['READ', 150],
|
||||||
|
['APPEND', 200],
|
||||||
|
['APPEND', 100],
|
||||||
|
['READ', 350],
|
||||||
|
['WRITE', 400],
|
||||||
|
['APPEND', 275],
|
||||||
|
['APPEND', 187],
|
||||||
|
['WRITE', 330],
|
||||||
|
['WRITE', 264],
|
||||||
|
['WRITE', 256],
|
||||||
|
], w(function () {
|
||||||
|
console.log("finished pre-scripted test\n");
|
||||||
|
}));
|
||||||
|
}).nThen(function (w) {
|
||||||
|
test([
|
||||||
|
WRITE(289),
|
||||||
|
APPEND(281),
|
||||||
|
READ(207),
|
||||||
|
WRITE(225),
|
||||||
|
READ(279),
|
||||||
|
WRITE(300),
|
||||||
|
READ(331),
|
||||||
|
APPEND(341),
|
||||||
|
APPEND(385),
|
||||||
|
READ(313),
|
||||||
|
WRITE(285),
|
||||||
|
READ(304),
|
||||||
|
APPEND(273),
|
||||||
|
APPEND(150),
|
||||||
|
WRITE(246),
|
||||||
|
READ(244),
|
||||||
|
WRITE(172),
|
||||||
|
APPEND(253),
|
||||||
|
READ(215),
|
||||||
|
READ(296),
|
||||||
|
APPEND(281),
|
||||||
|
APPEND(296),
|
||||||
|
WRITE(168),
|
||||||
|
], w(function () {
|
||||||
|
console.log("finished 2nd pre-scripted test\n");
|
||||||
|
}));
|
||||||
|
}).nThen(function () {
|
||||||
|
var totalTests = 50;
|
||||||
|
var randomTests = 1;
|
||||||
|
|
||||||
|
var last = nThen(function () {
|
||||||
|
console.log("beginning randomized tests");
|
||||||
|
});
|
||||||
|
|
||||||
|
var queueRandomTest = function (i) {
|
||||||
|
last = last.nThen(function (w) {
|
||||||
|
console.log("running random test script #%s\n", i);
|
||||||
|
test(randomScript(), w(function () {
|
||||||
|
console.log("finished random test #%s\n", i);
|
||||||
|
}));
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
|
while (randomTests <=totalTests) { queueRandomTest(randomTests++); }
|
||||||
|
|
||||||
|
last.nThen(function () {
|
||||||
|
console.log("finished %s random tests", totalTests);
|
||||||
|
});
|
||||||
|
});
|
||||||
|
|
||||||
|
|
||||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,246 @@
|
|||||||
|
define([
|
||||||
|
'/common/common-util.js',
|
||||||
|
'/common/common-hash.js',
|
||||||
|
'/common/userObject.js',
|
||||||
|
'/bower_components/nthen/index.js',
|
||||||
|
], function (Util, Hash, UserObject, nThen) {
|
||||||
|
var History = {};
|
||||||
|
var commands = {};
|
||||||
|
|
||||||
|
var getAccountChannels = function (ctx) {
|
||||||
|
var channels = [];
|
||||||
|
var edPublic = Util.find(ctx.store, ['proxy', 'edPublic']);
|
||||||
|
|
||||||
|
// Drive
|
||||||
|
var driveOwned = (Util.find(ctx.store, ['driveMetadata', 'owners']) || []).indexOf(edPublic) !== -1;
|
||||||
|
if (driveOwned) {
|
||||||
|
channels.push(ctx.store.driveChannel);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Profile
|
||||||
|
var profile = ctx.store.proxy.profile;
|
||||||
|
if (profile) {
|
||||||
|
var profileChan = profile.edit ? Hash.hrefToHexChannelId('/profile/#' + profile.edit, null) : null;
|
||||||
|
if (profileChan) { channels.push(profileChan); }
|
||||||
|
}
|
||||||
|
|
||||||
|
// Todo
|
||||||
|
if (ctx.store.proxy.todo) {
|
||||||
|
channels.push(Hash.hrefToHexChannelId('/todo/#' + ctx.store.proxy.todo, null));
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
// Mailboxes
|
||||||
|
var mailboxes = ctx.store.proxy.mailboxes;
|
||||||
|
if (mailboxes) {
|
||||||
|
var mList = Object.keys(mailboxes).map(function (m) {
|
||||||
|
return {
|
||||||
|
lastKnownHash: mailboxes[m].lastKnownHash,
|
||||||
|
channel: mailboxes[m].channel
|
||||||
|
};
|
||||||
|
});
|
||||||
|
Array.prototype.push.apply(channels, mList);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Shared folders owned by me
|
||||||
|
var sf = ctx.store.proxy[UserObject.SHARED_FOLDERS];
|
||||||
|
if (sf) {
|
||||||
|
var sfChannels = Object.keys(sf).map(function (fId) {
|
||||||
|
var data = sf[fId];
|
||||||
|
if (!data || !data.owners) { return; }
|
||||||
|
var isOwner = Array.isArray(data.owners) && data.owners.indexOf(edPublic) !== -1;
|
||||||
|
if (!isOwner) { return; }
|
||||||
|
return data.channel;
|
||||||
|
}).filter(Boolean);
|
||||||
|
Array.prototype.push.apply(channels, sfChannels);
|
||||||
|
}
|
||||||
|
|
||||||
|
return channels;
|
||||||
|
};
|
||||||
|
|
||||||
|
var getEdPublic = function (ctx, teamId) {
|
||||||
|
if (!teamId) { return Util.find(ctx.store, ['proxy', 'edPublic']); }
|
||||||
|
|
||||||
|
var teamData = Util.find(ctx, ['store', 'proxy', 'teams', teamId]);
|
||||||
|
return Util.find(teamData, ['keys', 'drive', 'edPublic']);
|
||||||
|
};
|
||||||
|
var getRpc = function (ctx, teamId) {
|
||||||
|
if (!teamId) { return ctx.store.rpc; }
|
||||||
|
var teams = ctx.store.modules['team'];
|
||||||
|
if (!teams) { return; }
|
||||||
|
var team = teams.getTeam(teamId);
|
||||||
|
if (!team) { return; }
|
||||||
|
return team.rpc;
|
||||||
|
};
|
||||||
|
|
||||||
|
var getHistoryData = function (ctx, channel, lastKnownHash, teamId, _cb) {
|
||||||
|
var cb = Util.once(Util.mkAsync(_cb));
|
||||||
|
var edPublic = getEdPublic(ctx, teamId);
|
||||||
|
var Store = ctx.Store;
|
||||||
|
|
||||||
|
var total = 0;
|
||||||
|
var history = 0;
|
||||||
|
var metadata = 0;
|
||||||
|
var hash;
|
||||||
|
nThen(function (waitFor) {
|
||||||
|
// Total size
|
||||||
|
Store.getFileSize(null, {
|
||||||
|
channel: channel
|
||||||
|
}, waitFor(function (obj) {
|
||||||
|
if (obj && obj.error) {
|
||||||
|
waitFor.abort();
|
||||||
|
return void cb(obj);
|
||||||
|
}
|
||||||
|
if (typeof(obj.size) === "undefined") {
|
||||||
|
waitFor.abort();
|
||||||
|
return void cb({error: 'ENOENT'});
|
||||||
|
}
|
||||||
|
total = obj.size;
|
||||||
|
}));
|
||||||
|
// Pad
|
||||||
|
Store.getHistory(null, {
|
||||||
|
channel: channel,
|
||||||
|
lastKnownHash: lastKnownHash
|
||||||
|
}, waitFor(function (obj) {
|
||||||
|
if (obj && obj.error) {
|
||||||
|
waitFor.abort();
|
||||||
|
return void cb(obj);
|
||||||
|
}
|
||||||
|
if (!Array.isArray(obj)) {
|
||||||
|
waitFor.abort();
|
||||||
|
return void cb({error: 'EINVAL'});
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!obj.length) { return; }
|
||||||
|
|
||||||
|
hash = obj[0].hash;
|
||||||
|
var messages = obj.map(function(data) {
|
||||||
|
return data.msg;
|
||||||
|
});
|
||||||
|
history = messages.join('\n').length;
|
||||||
|
}), true);
|
||||||
|
// Metadata
|
||||||
|
Store.getPadMetadata(null, {
|
||||||
|
channel: channel
|
||||||
|
}, waitFor(function (obj) {
|
||||||
|
if (obj && obj.error) { return; }
|
||||||
|
if (!obj || typeof(obj) !== "object") { return; }
|
||||||
|
metadata = JSON.stringify(obj).length;
|
||||||
|
if (!obj || !Array.isArray(obj.owners) ||
|
||||||
|
obj.owners.indexOf(edPublic) === -1) {
|
||||||
|
waitFor.abort();
|
||||||
|
return void cb({error: 'INSUFFICIENT_PERMISSIONS'});
|
||||||
|
}
|
||||||
|
}));
|
||||||
|
}).nThen(function () {
|
||||||
|
cb({
|
||||||
|
size: (total - metadata - history),
|
||||||
|
hash: hash
|
||||||
|
});
|
||||||
|
});
|
||||||
|
|
||||||
|
};
|
||||||
|
|
||||||
|
commands.GET_HISTORY_SIZE = function (ctx, data, cId, cb) {
|
||||||
|
if (!ctx.store.loggedIn || !ctx.store.rpc) { return void cb({ error: 'INSUFFICIENT_PERMISSIONS' }); }
|
||||||
|
var channels = data.channels;
|
||||||
|
if (!Array.isArray(channels)) { return void cb({ error: 'EINVAL' }); }
|
||||||
|
|
||||||
|
var warning = [];
|
||||||
|
|
||||||
|
// If account trim history, get the correct channels here
|
||||||
|
if (data.account) {
|
||||||
|
channels = getAccountChannels(ctx);
|
||||||
|
}
|
||||||
|
|
||||||
|
var size = 0;
|
||||||
|
var res = [];
|
||||||
|
nThen(function (waitFor) {
|
||||||
|
channels.forEach(function (chan) {
|
||||||
|
var channel = chan;
|
||||||
|
var lastKnownHash;
|
||||||
|
if (typeof (chan) === "object" && chan.channel) {
|
||||||
|
channel = chan.channel;
|
||||||
|
lastKnownHash = chan.lastKnownHash;
|
||||||
|
}
|
||||||
|
getHistoryData(ctx, channel, lastKnownHash, data.teamId, waitFor(function (obj) {
|
||||||
|
if (obj && obj.error) {
|
||||||
|
warning.push(obj.error);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
size += obj.size;
|
||||||
|
if (!obj.hash) { return; }
|
||||||
|
res.push({
|
||||||
|
channel: channel,
|
||||||
|
hash: obj.hash
|
||||||
|
});
|
||||||
|
}));
|
||||||
|
});
|
||||||
|
}).nThen(function () {
|
||||||
|
cb({
|
||||||
|
warning: warning.length ? warning : undefined,
|
||||||
|
channels: res,
|
||||||
|
size: size
|
||||||
|
});
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
|
commands.TRIM_HISTORY = function (ctx, data, cId, cb) {
|
||||||
|
if (!ctx.store.loggedIn || !ctx.store.rpc) { return void cb({ error: 'INSUFFICIENT_PERMISSIONS' }); }
|
||||||
|
var channels = data.channels;
|
||||||
|
if (!Array.isArray(channels)) { return void cb({ error: 'EINVAL' }); }
|
||||||
|
|
||||||
|
var rpc = getRpc(ctx, data.teamId);
|
||||||
|
if (!rpc) { return void cb({ error: 'ENORPC'}); }
|
||||||
|
|
||||||
|
var warning = [];
|
||||||
|
|
||||||
|
nThen(function (waitFor) {
|
||||||
|
channels.forEach(function (obj) {
|
||||||
|
rpc.trimHistory(obj, waitFor(function (err) {
|
||||||
|
if (err) {
|
||||||
|
warning.push(err);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}));
|
||||||
|
});
|
||||||
|
}).nThen(function () {
|
||||||
|
// Only one channel and warning: error
|
||||||
|
if (channels.length === 1 && warning.length) {
|
||||||
|
return void cb({error: warning[0]});
|
||||||
|
}
|
||||||
|
cb({
|
||||||
|
warning: warning.length ? warning : undefined
|
||||||
|
});
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
|
History.init = function (cfg, waitFor, emit) {
|
||||||
|
var history = {};
|
||||||
|
if (!cfg.store) { return; }
|
||||||
|
var ctx = {
|
||||||
|
store: cfg.store,
|
||||||
|
Store: cfg.Store,
|
||||||
|
pinPads: cfg.pinPads,
|
||||||
|
updateMetadata: cfg.updateMetadata,
|
||||||
|
emit: emit,
|
||||||
|
};
|
||||||
|
|
||||||
|
history.execCommand = function (clientId, obj, cb) {
|
||||||
|
var cmd = obj.cmd;
|
||||||
|
var data = obj.data;
|
||||||
|
try {
|
||||||
|
commands[cmd](ctx, data, clientId, cb);
|
||||||
|
} catch (e) {
|
||||||
|
console.error(e);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
return history;
|
||||||
|
};
|
||||||
|
|
||||||
|
return History;
|
||||||
|
});
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue