Switch between WS and HTTP upload

lib/storage/blob.js

@@ -272,6 +272,44 @@ var readBlobMetadata = function (env, blobId, handler, _cb) {
 
 /**********  METHODS **************/
 
+var uploadWs = function (Env, safeKey, content, cb) {
+    var dec;
+
+    try { dec = Buffer.from(content, 'base64'); }
+    catch (e) { return void cb('DECODE_BUFFER'); }
+
+    var len = dec.length;
+
+    var session = Env.getSession(safeKey);
+
+    if (typeof(session.currentUploadSize) !== 'number' ||
+        typeof(session.pendingUploadSize) !== 'number') {
+        // improperly initialized... maybe they didn't check before uploading?
+        // reject it, just in case
+        return cb('NOT_READY');
+    }
+
+    if (session.currentUploadSize > session.pendingUploadSize) {
+        return cb('E_OVER_LIMIT');
+    }
+
+    var stagePath = makeStagePath(Env, safeKey);
+
+    if (!session.blobstage) {
+        makeFileStream(stagePath, function (e, stream) {
+            if (!stream) { return void cb(e); }
+
+            var blobstage = session.blobstage = stream;
+            blobstage.write(dec);
+            session.currentUploadSize += len;
+            cb(void 0, dec.length);
+        });
+    } else {
+        session.blobstage.write(dec);
+        session.currentUploadSize += len;
+        cb(void 0, dec.length);
+    }
+};
 var upload = function (Env, safeKey, content, cb) {
     var dec;
 

src/worker/async-store.js

@@ -484,6 +484,18 @@ const factory = (Sortify, UserObject, ProxyManager,
             });
         };
 
+        Store.uploadChunk = function (clientId, data, cb) {
+            var s = getStore(data.teamId);
+            if (!s) { return void cb({ error: 'ENOTFOUND' }); }
+            if (!s.rpc) { return void cb({error: 'RPC_NOT_READY'}); }
+            s.rpc.send.unauthenticated('UPLOAD', data.chunk, function (e, msg) {
+                cb({
+                    error: e,
+                    msg: msg
+                });
+            });
+        };
+
         var initTempRpc = (clientId, cb) => {
             if (store.rpc) { return void cb(store.rpc); }
             var kp = Crypto.Nacl.sign.keyPair();

src/worker/core/store-rpc.js

@@ -22,6 +22,7 @@ const factory = AStore => {
             GET_PIN_LIMIT: Store.getPinLimit,
             CLEAR_OWNED_CHANNEL: Store.clearOwnedChannel,
             REMOVE_OWNED_CHANNEL: Store.removeOwnedChannel,
+            UPLOAD_CHUNK: Store.uploadChunk,
             UPLOAD_COMPLETE: Store.uploadComplete,
             UPLOAD_STATUS: Store.uploadStatus,
             UPLOAD_CANCEL: Store.uploadCancel,

www/common/cryptpad-common.js

@@ -644,6 +644,13 @@ define([
         });
     };
 
+    common.uploadChunk = function (teamId, data, cb) {
+        postMessage("UPLOAD_CHUNK", {teamId: teamId, chunk: data}, function (obj) {
+            if (obj && obj.error) { return void cb(obj.error); }
+            cb(null, obj);
+        });
+    };
+
     // ANON RPC
 
     // SFRAME: talk to anon_rpc from the iframe

www/common/outer/upload.js

@@ -13,6 +13,7 @@ define([
     '/components/nthen/index.js',
 ], function (ApiConfig, FileCrypto, Hash, Util, Cache, ServerCommand, Crypto, nThen) {
     var module = {};
+    const USE_WS = false;
 
     module.uploadU8 = function (common, data, cb) {
         var teamId = data.teamId;
@@ -30,13 +31,23 @@ define([
 
         var estimate = FileCrypto.computeEncryptedSize(u8.length, metadata);
 
+
+
+        var sendChunkWs = function (box, cb) {
+            var enc = Util.encodeBase64(box);
+            common.uploadChunk(teamId, enc, function (e, msg) {
+                cb(e, msg);
+            });
+        };
+
+
         let uploadUrl = '/upload-blob';
         let size = 0;
         if (ApiConfig.fileHost) {
             const origin = new URL(ApiConfig.fileHost).origin;
             uploadUrl = origin + uploadUrl;
         }
-        var sendChunk = function (box,  cb) {
+        var sendChunk = function (box, cb) {
             const enc = Util.encodeBase64(box);
             size += enc.length;
 
@@ -78,7 +89,11 @@ define([
                 progressValue = Math.min(progressValue, 100);
                 updateProgress(progressValue);
 
-                return void sendChunk(box, function (e) {
+                let send = sendChunk;
+                if (USE_WS) {
+                    send = sendChunkWs;
+                }
+                return void send(box, function (e) {
                     if (e) { return console.error(e); }
                     next(again);
                 });
@@ -103,6 +118,9 @@ define([
         };
 
         const startUpload = () => {
+            if (USE_WS) {
+                return void next(again);
+            }
             common.getAccessKeys(arr => {
                 const myKeys = arr.find(obj => {
                     return (!obj.id && !teamId) || +obj.id === +teamId;