core-3nweb-client-lib 0.25.6 → 0.27.0

package/build/core/storage/synced/upsyncer.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2020 3NSoft Inc.
+ Copyright (C) 2020, 2022 3NSoft Inc.
  
  This program is free software: you can redistribute it and/or modify it under
  the terms of the GNU General Public License as published by the Free Software
@@ -13,312 +13,285 @@
  See the GNU General Public License for more details.
  
  You should have received a copy of the GNU General Public License along with
- this program. If not, see <http://www.gnu.org/licenses/>. */
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UpSyncer = void 0;
-const operators_1 = require("rxjs/operators");
-const processes_1 = require("../../../lib-common/processes");
-const upsync_status_1 = require("./upsync-status");
+const labelled_exec_pools_1 = require("../../../lib-common/processes/labelled-exec-pools");
+const exceptions_1 = require("../../../lib-client/3nstorage/exceptions");
 const assert_1 = require("../../../lib-common/assert");
+const deferred_1 = require("../../../lib-common/processes/deferred");
+const buffer_utils_1 = require("../../../lib-common/buffer-utils");
 const MAX_CHUNK_SIZE = 512 * 1024;
+const MAX_FAST_UPLOAD = 2 * 1024 * 1024;
 class UpSyncer {
-    constructor(remoteStorage, files, logError) {
+    constructor(remoteStorage, logError) {
         this.remoteStorage = remoteStorage;
-        this.files = files;
         this.logError = logError;
-        this.uploads = new Map();
-        this.addToWorker = (ready) => {
-            this.worker.add(ready);
-        };
-        this.worker = new processes_1.Worker(async (u) => {
-            await u.process();
-            if (u.isDone() && (u === this.uploads.get(u.obj))) {
-                this.uploads.delete(u.obj);
-            }
-        }, async (queue) => {
-            for (const u of queue) {
-                u.stop();
-                this.uploads.delete(u.obj);
-            }
-        });
+        this.execPools = new labelled_exec_pools_1.LabelledExecPools([
+            { label: 'long', maxProcs: 1 },
+            { label: 'fast', maxProcs: 1 }
+        ], logError);
         Object.seal(this);
     }
-    getOrMakeUploadsFor(obj) {
-        let uploads = this.uploads.get(obj);
-        if (!uploads) {
-            const status = new upsync_status_1.UpSyncTasks(obj.objFolder, this.logError);
-            uploads = new ObjUpSync(obj, status, this.remoteStorage, this.addToWorker, this.logError);
-            this.uploads.set(obj, uploads);
-        }
-        return uploads;
-    }
     start() {
-        this.worker.start(2);
+        this.execPools.start();
     }
     async stop() {
-        await this.worker.stop();
-        for (const upload of this.uploads.values()) {
-            upload.stop();
-        }
-        this.uploads.clear();
-    }
-    get chunkSize() {
-        return (this.remoteStorage.maxChunkSize ?
-            Math.min(this.remoteStorage.maxChunkSize, MAX_CHUNK_SIZE) :
-            MAX_CHUNK_SIZE);
+        await this.execPools.stop(); // implicitly cancels all upsync tasks
     }
+    /**
+     * Creates an rxjs operator to tap saving process, starting upload while
+     * writing is ongoing.
+     */
     tapFileWrite(obj, isNew, newVersion, baseVersion) {
-        const objUploads = this.getOrMakeUploadsFor(obj);
-        return objUploads.tapFileWrite(isNew, newVersion, baseVersion);
+        throw new Error('UpSyncer.tapFileWrite() not implemented');
+        // const objUploads = this.getOrMakeUploadsFor(obj);
+        // return objUploads.tapFileWrite(isNew, newVersion, baseVersion);
     }
     async removeCurrentVersionOf(obj) {
-        const objUploads = this.getOrMakeUploadsFor(obj);
-        objUploads.removeCurrentVersion();
+        throw new Error('UpSyncer.removeCurrentVersionOf() not implemented');
+        // const objUploads = this.getOrMakeUploadsFor(obj);
+        // XXX is removal set in this older code? This may need to change anyway
+        // if (objUploads.neededExecutor()) {
+        // 	this.execPools.add(objUploads);
+        // }
+    }
+    async uploadFromDisk(obj, localVersion, uploadVersion, uploadHeader, syncedBase, createOnRemote) {
+        const task = await UploadTask.for(obj, localVersion, uploadVersion, uploadHeader, syncedBase, createOnRemote, this.remoteStorage, this.execPools);
+        this.execPools.add(task);
+        await task.completion();
     }
 }
 exports.UpSyncer = UpSyncer;
 Object.freeze(UpSyncer.prototype);
 Object.freeze(UpSyncer);
-class ObjUpSync {
-    constructor(obj, status, remoteStorage, addToWorker, logError) {
-        this.obj = obj;
-        this.status = status;
+class UploadTask {
+    constructor(remoteStorage, objId, objStatus, src, execPools, info, uploadHeader) {
         this.remoteStorage = remoteStorage;
-        this.addToWorker = addToWorker;
-        this.logError = logError;
-        this.objWriteTaps = new Map();
-        Object.freeze(this);
-    }
-    tapFileWrite(isObjNew, newVersion, baseVersion) {
-        const tap = new ObjWriteTap(this.obj, newVersion, baseVersion, isObjNew);
-        const uploadInfo = upsync_status_1.makeUploadInfo(tap.version, tap.baseVersion);
-        this.objWriteTaps.set(uploadInfo, tap);
-        return tap.tapOperator();
-    }
-    stop() {
-        // XXX
-        // - is something needed here?
+        this.objId = objId;
+        this.objStatus = objStatus;
+        this.src = src;
+        this.execPools = execPools;
+        this.info = info;
+        this.uploadHeader = uploadHeader;
+        this.uploadCompletion = (0, deferred_1.defer)();
+        this.execLabel = executorLabelFor(this.info.needUpload);
+        Object.seal(this);
     }
-    removeCurrentVersion() {
-        this.status.queueTask({
-            type: 'removal',
-            currentVersion: true
-        });
-        this.addToWorker(this);
+    static async for(obj, localVersion, uploadVersion, uploadHeader, syncedBase, createObj, remoteStorage, execPools) {
+        const src = await obj.getObjSrcFromLocalAndSyncedBranch(localVersion);
+        let needUpload;
+        if (syncedBase) {
+            const { diff, newSegsPackOrder } = await obj.diffForUploadOf(localVersion);
+            needUpload = await diffVerUpload(src, uploadHeader, diff, newSegsPackOrder);
+        }
+        else {
+            needUpload = await wholeVerUpload(src, uploadHeader, createObj);
+        }
+        const info = {
+            localVersion,
+            uploadVersion,
+            baseVersion: syncedBase,
+            needUpload
+        };
+        const objStatus = obj.statusObj();
+        await objStatus.recordUploadStart(info);
+        return new UploadTask(remoteStorage, obj.objId, objStatus, src, execPools, info, uploadHeader);
     }
-    removeArchivedVersion(version) {
-        this.status.queueTask({
-            type: 'removal',
-            archivedVersions: version
-        });
-        this.addToWorker(this);
+    neededExecutor() {
+        return (!this.info.needUpload ? undefined : this.execLabel);
     }
-    isDone() {
-        return this.status.isDone();
+    completion() {
+        return this.uploadCompletion.promise;
     }
     async process() {
-        if (this.isDone()) {
+        if (!this.info.needUpload) {
             return;
         }
         try {
-            const task = (await this.status.nextTask());
-            if (task.type === 'upload') {
-                await this.processUpload(task);
+            const upload = this.info.needUpload;
+            if (upload.type === 'ordered-diff') {
+                if (upload.transactionId) {
+                    await this.continueOrderedDiffUpload(upload);
+                }
+                else {
+                    await this.startOrderedDiffUpload(upload);
+                }
             }
-            else if (task.type === 'removal') {
-                await this.processRemoval(task);
-            }
-            else if (task.type === 'archiving') {
-                await this.processArchival(task);
+            else if (upload.type === 'ordered-whole') {
+                if (upload.transactionId) {
+                    await this.continueOrderedUpload(upload);
+                }
+                else {
+                    await this.startOrderedUpload(upload);
+                }
             }
             else {
-                throw new Error(`This shouldn't be reached`);
+                throw new Error(`Unimplemented ${upload.type} upload`);
             }
-        }
-        catch (err) {
-            await this.logError(err, `Error occured in uploader processing`);
-        }
-        if (!this.isDone()) {
-            this.addToWorker(this);
-        }
-    }
-    async processArchival(task) {
-        // XXX tell server to archive current version
-        await this.logError(`Archival of current version is not implemented, yet.`);
-        await this.status.recordTaskCompletion(task);
-    }
-    async processRemoval(task) {
-        if (task.currentVersion) {
-            if (this.obj.objId) {
-                await this.remoteStorage.deleteObj(this.obj.objId);
+            await this.objStatus.recordUploadInterimState(this.info);
+            if (this.info.needUpload) {
+                this.execPools.add(this);
             }
             else {
-                await this.logError(`Root obj can't be removed`);
+                this.uploadCompletion.resolve();
             }
         }
-        if (task.archivedVersions) {
-            // XXX tell server to remove given archived versions
-            await this.logError(`Removal of archived version is not implemented, yet.`);
+        catch (exc) {
+            this.info.needUpload = undefined;
+            this.uploadCompletion.reject((0, exceptions_1.makeFSSyncException)(`obj-upload`, {
+                message: `Fail to upload local version ${this.info.uploadVersion}`,
+                localVersion: this.info.uploadVersion,
+                cause: exc
+            }));
+            await this.objStatus.recordUploadCancellation(this.info);
         }
-        await this.status.recordTaskCompletion(task);
     }
-    async processUpload(task) {
-        const tap = this.objWriteTaps.get(task);
-        if (tap && !task.done) {
-            await this.uploadReadyBytes(task, tap);
+    async startOrderedUpload(upload) {
+        const maxSegs = this.maxUploadChunk() - upload.header;
+        (0, assert_1.assert)(maxSegs > 1);
+        const segsToUpload = Math.min(upload.segsLeft, maxSegs);
+        const header = await this.headerToUpload();
+        let segs = undefined;
+        if (segsToUpload > 0) {
+            await this.src.segSrc.seek(upload.segsOfs);
+            segs = await this.src.segSrc.read(segsToUpload);
         }
-        if (tap && !task.done) {
-            await this.status.recordInterimStateOfCurrentTask(task);
+        (0, assert_1.assert)(!!segs && (segs.length === segsToUpload));
+        const ver = this.info.uploadVersion;
+        const create = (upload.createObj ? true : undefined);
+        if (segsToUpload === upload.segsLeft) {
+            await this.remoteStorage.saveNewObjVersion(this.objId, { ver, create, last: true }, undefined, { header, segs });
+            this.info.needUpload = undefined;
         }
         else {
-            this.objWriteTaps.delete(task);
-            await this.status.recordTaskCompletion(task);
-        }
-    }
-    async uploadReadyBytes(uploadInfo, tap) {
-        if (tap.cancelledOrErred()) {
-            await this.cancelTransactionIfOpen(uploadInfo);
-            return;
-        }
-        if (uploadInfo.transactionId) {
-            await this.doUploadInTransaction(uploadInfo, tap);
-        }
-        else if (tap.isDone) {
-            // XXX current code does upload after file is written, future code
-            // can start upload sooner, and do diff-ed uploads
-            await this.doFirstUpload(uploadInfo, tap);
+            upload.transactionId = await this.remoteStorage.saveNewObjVersion(this.objId, { ver, create }, undefined, { header, segs });
+            if (!upload.transactionId) {
+                // XXX should this be runtime exception saying that remote acts badly ?
+                throw new Error(`Server didn't start obj saving transaction`);
+            }
+            upload.header = undefined;
+            upload.segsOfs += segsToUpload;
+            upload.segsLeft -= segsToUpload;
         }
     }
-    async cancelTransactionIfOpen(uploadInfo) {
-        const txnId = uploadInfo.transactionId;
-        if (!txnId) {
-            return;
-        }
-        await this.remoteStorage.cancelTransaction(this.obj.objId, txnId)
-            .catch((exc) => {
-            if (!exc.unknownTransaction) {
-                throw exc;
-            }
-        });
+    async headerToUpload() {
+        return (this.uploadHeader ?
+            this.uploadHeader : await this.src.readHeader());
     }
-    async doFirstUpload(uploadInfo, tap) {
-        assert_1.assert(tap.isDone, `Current implementation works only on completely saved to disk objects`);
-        assert_1.assert(!uploadInfo.awaiting);
-        const src = await this.obj.getObjSrc(uploadInfo.version);
-        // note that endlessness/finiteness of src is not used
-        const header = await src.readHeader();
-        const maxChunkLen = (this.remoteStorage.maxChunkSize ?
-            this.remoteStorage.maxChunkSize - header.length : MAX_CHUNK_SIZE);
-        assert_1.assert(maxChunkLen > 0);
-        const segs = await src.segSrc.read(maxChunkLen);
-        const srcLen = (await src.segSrc.getSize()).size;
-        let last;
-        let bytesToSend;
-        if (segs) {
-            if (segs.length === maxChunkLen) {
-                last = (srcLen === segs.length);
-            }
-            else {
-                last = false;
-            }
-            bytesToSend = [header, segs];
+    async startOrderedDiffUpload(upload) {
+        const diff = buffer_utils_1.utf8.pack(JSON.stringify(upload.diff));
+        const maxSegs = this.maxUploadChunk() - upload.header - diff.length;
+        (0, assert_1.assert)(maxSegs > 1);
+        const header = await this.headerToUpload();
+        const ver = this.info.uploadVersion;
+        if (upload.newSegsLeft.length === 0) {
+            await this.remoteStorage.saveNewObjVersion(this.objId, { ver, last: true }, undefined, { header, diff });
+            this.info.needUpload = undefined;
         }
         else {
-            last = true;
-            bytesToSend = header;
+            upload.transactionId = await this.remoteStorage.saveNewObjVersion(this.objId, { ver }, undefined, { header, diff });
+            if (!upload.transactionId) {
+                // XXX should this be runtime exception saying that remote acts badly ?
+                throw new Error(`Server didn't start obj saving transaction`);
+            }
+            upload.header = undefined;
         }
-        if (last) {
-            const opts = {
-                header: header.length, ver: uploadInfo.version, last
-            };
-            await this.remoteStorage.saveNewObjVersion(this.obj.objId, bytesToSend, opts, undefined);
-            uploadInfo.done = true;
+    }
+    maxUploadChunk() {
+        return (this.remoteStorage.maxChunkSize ?
+            this.remoteStorage.maxChunkSize : MAX_CHUNK_SIZE);
+    }
+    async continueOrderedUpload(upload) {
+        const segsToUpload = Math.min(upload.segsLeft, this.maxUploadChunk());
+        await this.src.segSrc.seek(upload.segsOfs);
+        const segs = await this.src.segSrc.read(segsToUpload);
+        (0, assert_1.assert)(!!segs && (segs.length === segsToUpload));
+        const ofs = upload.segsOfs;
+        const trans = upload.transactionId;
+        if (segsToUpload === upload.segsLeft) {
+            await this.remoteStorage.saveNewObjVersion(this.objId, undefined, { ofs, trans, last: true }, { segs });
+            this.info.needUpload = undefined;
         }
         else {
-            const opts = {
-                header: header.length, ver: uploadInfo.version
-            };
-            const txnId = await this.remoteStorage.saveNewObjVersion(this.obj.objId, bytesToSend, opts, undefined);
-            if (!txnId) {
-                throw new Error(`Server didn't start obj saving transaction`);
-            }
-            uploadInfo.transactionId = txnId;
-            uploadInfo.awaiting = {
-                allByteOnDisk: true,
-                segs: [{ ofs: segs.length, len: srcLen - segs.length }]
-            };
-            this.addToWorker(this);
+            await this.remoteStorage.saveNewObjVersion(this.objId, undefined, { ofs, trans }, { segs });
+            upload.segsOfs += segsToUpload;
+            upload.segsLeft -= segsToUpload;
         }
     }
-    async doUploadInTransaction(uploadInfo, tap) {
-        assert_1.assert(tap.isDone, `Current implementation works only on completely saved to disk objects`);
-        assert_1.assert(!!uploadInfo.transactionId
-            && !!uploadInfo.awaiting
-            && (uploadInfo.awaiting.segs.length > 0)
-            && (uploadInfo.awaiting.segs[0].len > 0));
-        const section = uploadInfo.awaiting.segs[0];
-        const lenToRead = Math.min(section.len, (this.remoteStorage.maxChunkSize ?
-            this.remoteStorage.maxChunkSize : MAX_CHUNK_SIZE));
-        const src = await this.obj.getObjSrc(uploadInfo.version);
-        await src.segSrc.seek(section.ofs);
-        const segs = await src.segSrc.read(lenToRead);
-        if (!segs || (segs.length < lenToRead)) {
-            throw new Error(`Unexpected end of obj source`);
+    async continueOrderedDiffUpload(upload) {
+        const maxSegs = this.maxUploadChunk();
+        const segInfo = upload.newSegsLeft[0];
+        (0, assert_1.assert)(!!segInfo);
+        const len = Math.min(maxSegs, segInfo.len);
+        const segs = await this.src.segSrc.read(len);
+        (0, assert_1.assert)(!!segs && (segs.length === len));
+        if (segInfo.len > len) {
+            upload.newSegsLeft.splice(1, 0, {
+                len: segInfo.len - len,
+                thisVerOfs: segInfo.thisVerOfs + len
+            });
         }
-        const last = ((uploadInfo.awaiting.segs.length === 0) &&
-            (segs.length === section.len));
-        if (last) {
-            const opts = {
-                ofs: section.ofs,
-                trans: uploadInfo.transactionId,
-                last: true
-            };
-            await this.remoteStorage.saveNewObjVersion(this.obj.objId, segs, undefined, opts);
-            uploadInfo.done = true;
-            uploadInfo.awaiting = undefined;
+        const ofs = segInfo.thisVerOfs;
+        const trans = upload.transactionId;
+        if (upload.newSegsLeft.length === 1) {
+            await this.remoteStorage.saveNewObjVersion(this.objId, undefined, { ofs, trans, last: true }, { segs });
+            this.info.needUpload = undefined;
         }
         else {
-            const opts = {
-                ofs: section.ofs,
-                trans: uploadInfo.transactionId
-            };
-            await this.remoteStorage.saveNewObjVersion(this.obj.objId, segs, undefined, opts);
-            if (segs.length === section.len) {
-                uploadInfo.awaiting.segs.splice(0, 1);
-            }
-            else {
-                section.ofs += segs.length;
-                section.len -= segs.length;
-            }
-            this.addToWorker(this);
+            await this.remoteStorage.saveNewObjVersion(this.objId, undefined, { ofs, trans }, { segs });
+            upload.newSegsLeft.splice(0, 1);
         }
     }
+    cancel() {
+        // XXX
+        throw new Error("UploadTask.cancel() not implemented.");
+    }
 }
-Object.freeze(ObjUpSync.prototype);
-Object.freeze(ObjUpSync);
-class ObjWriteTap {
-    constructor(obj, version, baseVersion, isObjNew) {
-        this.obj = obj;
-        this.version = version;
-        this.baseVersion = baseVersion;
-        this.isObjNew = isObjNew;
-        this.isDone = false;
-        this.isCancelled = false;
-        this.err = undefined;
-        Object.seal(this);
+Object.freeze(UploadTask.prototype);
+Object.freeze(UploadTask);
+async function wholeVerUpload(src, uploadHeader, createObj) {
+    const header = await expectedHeaderLen(src, uploadHeader);
+    const segsSize = (await src.segSrc.getSize()).size;
+    return {
+        type: 'ordered-whole',
+        createObj,
+        header,
+        segsOfs: 0,
+        segsLeft: segsSize
+    };
+}
+async function diffVerUpload(src, uploadHeader, diff, newSegsPackOrder) {
+    const header = await expectedHeaderLen(src, uploadHeader);
+    return {
+        type: 'ordered-diff',
+        diff,
+        newSegsLeft: newSegsPackOrder,
+        header
+    };
+}
+async function expectedHeaderLen(src, uploadHeader) {
+    return (uploadHeader ?
+        uploadHeader.length : (await src.readHeader()).length);
+}
+function uploadSize(info) {
+    if (info.type === 'ordered-whole') {
+        return info.header + info.segsLeft;
     }
-    tapOperator() {
-        return operators_1.tap(w => { }, err => {
-            this.err = err;
-            this.isDone = true;
-        }, () => {
-            this.isDone = true;
-        });
+    else if (info.type === 'ordered-diff') {
+        let uploadSize = info.header;
+        for (const { len } of info.newSegsLeft) {
+            uploadSize += len;
+        }
+        return uploadSize;
     }
-    cancelledOrErred() {
-        return (this.isCancelled || (this.isDone && this.err));
+    else {
+        throw new Error(`Unimplemented upload type ${info.type}`);
     }
 }
-Object.freeze(ObjWriteTap.prototype);
-Object.freeze(ObjWriteTap);
+function executorLabelFor(info) {
+    return ((uploadSize(info) <= MAX_FAST_UPLOAD) ? 'fast' : 'long');
+}
+function noop() { }
 Object.freeze(exports);

package/build/core/storage/system-folders/apps-data.d.ts

@@ -0,0 +1,16 @@
+declare type WritableFS = web3n.files.WritableFS;
+export declare class AppDataFolders {
+    private readonly fs;
+    private writingSync;
+    private syncFolderProc;
+    private constructor();
+    static make(rootFS: WritableFS): Promise<AppDataFolders>;
+    getOrMake(folder: string): Promise<WritableFS>;
+    private syncP;
+    private makeSyncedFolder;
+    private syncBeforeChange;
+    private uploadAfterCreationOf;
+    private startSyncProc;
+    stopSync(): void;
+}
+export {};

package/build/core/storage/system-folders/apps-data.js

@@ -0,0 +1,110 @@
+"use strict";
+/*
+ Copyright (C) 2022 3NSoft Inc.
+
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppDataFolders = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const _1 = require(".");
+const assert_1 = require("../../../lib-common/assert");
+const synced_1 = require("../../../lib-common/processes/synced");
+class AppDataFolders {
+    constructor(fs) {
+        var _a;
+        this.fs = fs;
+        this.writingSync = undefined;
+        (0, assert_1.assert)(!!((_a = this.fs.v) === null || _a === void 0 ? void 0 : _a.sync));
+        this.startSyncProc();
+        Object.seal(this);
+    }
+    static async make(rootFS) {
+        const fs = await rootFS.writableSubRoot(_1.sysFolders.appData, { create: false });
+        return new AppDataFolders(fs);
+    }
+    async getOrMake(folder) {
+        var _a;
+        if ((_a = this.fs.v) === null || _a === void 0 ? void 0 : _a.sync) {
+            try {
+                return await this.fs.writableSubRoot(folder, { create: false });
+            }
+            catch (exc) {
+                if ((exc.type === 'file')
+                    && exc.notFound) {
+                    return this.makeSyncedFolder(folder);
+                }
+                else {
+                    throw exc;
+                }
+            }
+        }
+        else {
+            return await this.fs.writableSubRoot(folder);
+        }
+    }
+    syncP() {
+        if (!this.writingSync) {
+            this.writingSync = new synced_1.SingleProc();
+        }
+        return this.writingSync;
+    }
+    makeSyncedFolder(folder) {
+        return this.syncP().startOrChain(async () => {
+            await this.syncBeforeChange();
+            try {
+                await this.fs.makeFolder(folder, true);
+            }
+            catch (exc) {
+                if ((exc.type === 'file')
+                    && exc.alreadyExists) {
+                    return this.fs.writableSubRoot(folder, { create: false });
+                }
+                else {
+                    throw exc;
+                }
+            }
+            const fs = await this.fs.writableSubRoot(folder, { create: false });
+            await this.uploadAfterCreationOf(folder);
+            return fs;
+        });
+    }
+    async syncBeforeChange() {
+        const { state } = await this.fs.v.sync.updateStatusInfo('');
+        if (state === 'behind') {
+            await this.fs.v.sync.adoptRemote('');
+        }
+    }
+    async uploadAfterCreationOf(folder) {
+        // XXX must add work with not-online condition
+        await this.fs.v.sync.upload(folder);
+        await this.fs.v.sync.upload('');
+    }
+    startSyncProc() {
+        this.syncFolderProc = (new rxjs_1.Observable((obs) => this.fs.watchFolder('', obs)))
+            .pipe((0, operators_1.filter)(ev => (ev.type === 'remote-change')), (0, operators_1.mergeMap)(() => this.syncP().startOrChain(() => this.fs.v.sync.adoptRemote('')), 1))
+            .subscribe();
+    }
+    stopSync() {
+        if (this.syncFolderProc) {
+            this.syncFolderProc.unsubscribe();
+            this.syncFolderProc = undefined;
+        }
+    }
+}
+exports.AppDataFolders = AppDataFolders;
+Object.freeze(AppDataFolders.prototype);
+Object.freeze(AppDataFolders);
+Object.freeze(exports);