core-3nweb-client-lib 0.25.3 → 0.26.0

package/build/core/storage/synced/obj-status.js

@@ -16,52 +16,61 @@
  this program. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ObjStatus = void 0;
-const processes_1 = require("../../../lib-common/processes");
-const fs = require("../../../lib-common/async-fs-node");
+exports.readAndCheckStatus = exports.ObjStatus = exports.STATUS_FILE_NAME = void 0;
 const path_1 = require("path");
 const exceptions_1 = require("../../../lib-client/3nstorage/exceptions");
+const json_saving_1 = require("../common/json-saving");
 const obj_info_file_1 = require("../common/obj-info-file");
-const STATUS_FILE_NAME = 'status';
+const json_utils_1 = require("../../../lib-common/json-utils");
+exports.STATUS_FILE_NAME = 'status';
 class ObjStatus {
-    constructor(objFolder, status) {
+    constructor(objFolder, status, logError) {
         this.objFolder = objFolder;
         this.status = status;
-        this.saveProc = new processes_1.DeduppedRunner(() => this.saveFile());
+        this.logError = logError;
+        this.saveProc = new json_saving_1.JSONSavingProc(path_1.join(this.objFolder, exports.STATUS_FILE_NAME), () => this.status);
         Object.freeze(this);
     }
-    static async readFrom(objFolder, objId) {
+    static async readFrom(objFolder, objId, logError) {
         const status = await readAndCheckStatus(objFolder, objId);
-        return new ObjStatus(objFolder, status);
+        return new ObjStatus(objFolder, status, logError);
     }
-    static async makeNew(objFolder, objId) {
+    static async makeNew(objFolder, objId, logError) {
         const status = {
             objId,
-            syncState: 'unsynced',
-            versions: {}
+            sync: {
+                state: 'unsynced'
+            },
+            versions: {
+                baseToDiff: {},
+                diffToBase: {},
+            }
         };
-        const s = new ObjStatus(objFolder, status);
-        await s.saveProc.trigger();
+        const s = new ObjStatus(objFolder, status, logError);
+        await s.triggerSaveProc();
         return s;
     }
-    static async makeForDownloadedVersion(objFolder, objId, version) {
+    static async makeForDownloadedVersion(objFolder, objId, version, currentRemote, logError) {
         const status = {
             objId,
-            syncState: 'synced',
+            sync: {
+                state: 'synced',
+                remote: currentRemote,
+                latest: currentRemote,
+            },
             versions: {
-                current: version
+                current: version,
+                baseToDiff: {},
+                diffToBase: {}
             }
         };
-        const s = new ObjStatus(objFolder, status);
-        await s.saveProc.trigger();
+        const s = new ObjStatus(objFolder, status, logError);
+        await s.triggerSaveProc();
         return s;
     }
     static async fileShowsObjNotInSyncedState(objFolder, objId) {
         const status = await readAndCheckStatus(objFolder, objId);
-        return (status.syncState !== 'synced');
-    }
-    async saveFile() {
-        await fs.writeFile(path_1.join(this.objFolder, STATUS_FILE_NAME), JSON.stringify(this.status), { encoding: 'utf8' });
+        return (status.sync.state !== 'synced');
     }
     isArchived() {
         return !!this.status.isArchived;
@@ -72,58 +81,98 @@ class ObjStatus {
         }
         return this.status.versions.current;
     }
+    getNonGarbageVersions() {
+        const versions = this.status.versions;
+        const nonGarbage = obj_info_file_1.nonGarbageVersionsIn(versions);
+        if (this.status.syncTasks) {
+            const tasks = this.status.syncTasks;
+            if (tasks.current) {
+                obj_info_file_1.addWithBasesTo(nonGarbage, nonGarbageVersionInTask(tasks.current), versions);
+            }
+            for (const t of tasks.queued) {
+                obj_info_file_1.addWithBasesTo(nonGarbage, nonGarbageVersionInTask(t), versions);
+            }
+        }
+        return {
+            nonGarbage,
+            gcMaxVer: versions.current
+        };
+    }
     isRemoteVersionGreaterOrEqualTo(newRemoteVersion) {
-        return ((typeof this.status.versions.remote === 'number') ?
-            (this.status.versions.remote >= newRemoteVersion) : false);
+        return ((typeof this.status.sync.remote === 'number') ?
+            (this.status.sync.remote >= newRemoteVersion) : false);
     }
     isDeletedOnRemote() {
-        return !!this.status.deletedOnRemote;
+        return !!this.status.sync.deletedOnRemote;
     }
     syncedVersionGreaterOrEqual(version) {
-        return ((typeof this.status.versions.latestSynced !== 'number') ?
-            false : (version <= this.status.versions.latestSynced));
+        return ((typeof this.status.sync.latest !== 'number') ?
+            false : (version <= this.status.sync.latest));
     }
     async removeCurrentVersion(verObjs) {
         this.status.isArchived = true;
-        if (this.status.versions.current) {
-            verObjs.delete(this.status.versions.current);
-            rmNonArchVersionsIn(this.status, this.status.versions.current);
-            delete this.status.versions.current;
+        const current = obj_info_file_1.rmCurrentVersionIn(this.status.versions);
+        if (typeof current === 'number') {
+            verObjs.delete(current);
+        }
+        this.addRemoveCurrentToQueue();
+        await this.triggerSaveProc().catch((exc) => {
+            if (exc.notFound && this.status.isArchived) {
+                return;
+            }
+            else {
+                throw exc;
+            }
+        });
+    }
+    async triggerSaveProc(captureErrors = false, logErr = false) {
+        try {
+            await this.saveProc.trigger();
+        }
+        catch (exc) {
+            if (captureErrors) {
+                if (logErr) {
+                    await this.logError(exc);
+                }
+            }
+            else {
+                throw exc;
+            }
         }
-        await this.saveProc.trigger();
     }
     async setDeletedOnRemote() {
-        this.status.deletedOnRemote = true;
-        await this.saveProc.trigger();
+        this.status.sync.deletedOnRemote = true;
+        await this.triggerSaveProc();
     }
     async setRemoteVersion(version) {
-        if (this.status.versions.remote >= version) {
+        if (this.status.sync.remote >= version) {
             return;
         }
-        this.status.versions.remote = version;
-        if (this.status.syncState === 'synced') {
-            if (this.status.versions.current < this.status.versions.remote) {
-                this.status.syncState = 'behind';
+        this.status.sync.remote = version;
+        if (this.status.sync.state === 'synced') {
+            if (this.status.versions.current < this.status.sync.remote) {
+                this.status.sync.state = 'behind';
             }
         }
-        else if (this.status.syncState === 'unsynced') {
-            this.status.syncState = 'conflicting';
+        else if (this.status.sync.state === 'unsynced') {
+            this.status.sync.state = 'conflicting';
         }
-        await this.saveProc.trigger();
+        await this.triggerSaveProc();
     }
-    async setSyncedCurrentVersion(version) {
-        this.status.versions.current = version;
-        this.status.syncState = 'synced';
-        this.status.versions.latestSynced = version;
-        await this.saveProc.trigger();
+    async markVersionSynced(version) {
+        if (!this.status.sync.latest
+            || (this.status.sync.latest < version)) {
+            this.status.sync.latest = version;
+            if (this.status.versions.current === version) {
+                this.status.sync.state = 'synced';
+            }
+            await this.triggerSaveProc();
+        }
     }
-    async setUnsyncedCurrentVersion(version) {
-        // XXX should this code be like that from commented
-        // setNewCurrentVersionAfterWriteIn, or should we use that function
-        // reused by GC.
-        this.status.versions.current = version;
-        this.status.syncState = 'unsynced';
-        await this.saveProc.trigger();
+    async setUnsyncedCurrentVersion(version, baseVer) {
+        obj_info_file_1.setCurrentVersionIn(this.status.versions, version, baseVer);
+        this.status.sync.state = 'unsynced';
+        await this.triggerSaveProc();
     }
     /**
      * This method ignores remote conflicting versions.
@@ -133,20 +182,196 @@ class ObjStatus {
         if (this.status.versions.current === undefined) {
             return false;
         }
-        if (this.status.syncState == 'synced') {
+        if (this.status.sync.state == 'synced') {
             return true;
         }
-        if (this.status.versions.latestSynced === undefined) {
+        if (this.status.sync.latest === undefined) {
             return false;
         }
-        return (this.status.versions.latestSynced >= version);
+        return (this.status.sync.latest >= version);
+    }
+    isVersionArchived(version) {
+        if (!this.status.versions.archived) {
+            return false;
+        }
+        return this.status.versions.archived.includes(version);
+    }
+    queueTask(t) {
+        if (t.type === 'upload') {
+            this.addUploadToQueue(t);
+        }
+        else if (t.type === 'removal') {
+            if (t.currentVersion) {
+                throw new Error(`Removal of current task needs other method`);
+            }
+            else if (t.archivedVersions) {
+                this.addRemoveArchivedToQueue(t.archivedVersions);
+            }
+        }
+        else if (t.type === 'archiving') {
+            this.addArchivalToQueue(t);
+        }
+        else {
+            throw new Error(`Unsupported upsync task type`);
+        }
+    }
+    addUploadToQueue(u) {
+        if (!this.status.syncTasks) {
+            this.status.syncTasks = { queued: [u] };
+        }
+        else {
+            const q = this.status.syncTasks.queued;
+            const last = lastIn(q);
+            if (last) {
+                if (last.type === 'upload') {
+                    if (!this.isVersionArchived(last.version)) {
+                        if (last.createObj) {
+                            u.createObj = true;
+                        }
+                        q[q.length - 1] = u;
+                    }
+                    else {
+                        q.push(u);
+                    }
+                }
+                else if (last.type === 'archiving') {
+                    q.push(u);
+                }
+                else if ((last.type === 'removal') && last.archivedVersions) {
+                    q.push(u);
+                }
+            }
+            else {
+                q.push(u);
+            }
+        }
+        this.triggerSaveProc(true);
+    }
+    addRemoveCurrentToQueue() {
+        const r = { type: 'removal', currentVersion: true };
+        if (this.status.syncTasks) {
+            const q = this.status.syncTasks.queued;
+            const last = lastIn(q);
+            if (last) {
+                if (last.type === 'archiving') {
+                    q.push(r);
+                }
+                else if (last.type === 'upload') {
+                    if (this.isVersionArchived(last.version)) {
+                        q.push(r);
+                    }
+                    else if (this.status.sync.latest
+                        || this.status.syncTasks.current) {
+                        q[q.length - 1] = r;
+                    }
+                    else {
+                        q.splice(q.length - 1, 1);
+                        this.addRemoveCurrentToQueue();
+                        return;
+                    }
+                }
+            }
+            else if (this.status.sync.latest
+                || this.status.syncTasks.current) {
+                q.push(r);
+            }
+            else {
+                this.status.syncTasks = undefined;
+            }
+        }
+        else {
+            if (this.status.sync.latest) {
+                this.status.syncTasks = { queued: [r] };
+            }
+        }
+    }
+    addRemoveArchivedToQueue(archVer) {
+        const r = { type: 'removal', archivedVersions: archVer };
+        if (this.status.syncTasks) {
+            this.status.syncTasks.queued.push(r);
+        }
+        else {
+            this.status.syncTasks = { queued: [r] };
+        }
+        this.triggerSaveProc(true);
+    }
+    addArchivalToQueue(a) {
+        if (!this.status.syncTasks) {
+            this.status.syncTasks = { queued: [a] };
+        }
+        else {
+            this.status.syncTasks.queued.push(a);
+        }
+        this.triggerSaveProc(true);
+    }
+    async getTaskForProcessing() {
+        const syncTasks = this.status.syncTasks;
+        if (!syncTasks) {
+            return;
+        }
+        if (syncTasks.current) {
+            return syncTasks.current;
+        }
+        syncTasks.current = syncTasks.queued.shift();
+        if (syncTasks.current) {
+            await this.triggerSaveProc();
+        }
+        return syncTasks.current;
+    }
+    glanceOnNextTask() {
+        const syncTasks = this.status.syncTasks;
+        if (!syncTasks) {
+            return;
+        }
+        if (syncTasks.current) {
+            return syncTasks.current;
+        }
+        else if (syncTasks.queued.length > 0) {
+            return syncTasks.queued[0];
+        }
+    }
+    async recordInterimStateOfCurrentTask(t) {
+        const syncTasks = this.status.syncTasks;
+        if (!syncTasks) {
+            throw new Error(`This method is called too early.`);
+        }
+        if (syncTasks.current === t) {
+            await this.triggerSaveProc();
+        }
+        else {
+            throw new Error(`Can save interim state of a current task only`);
+        }
+    }
+    async recordTaskCompletion(t) {
+        const syncTasks = this.status.syncTasks;
+        if (!syncTasks) {
+            throw new Error(`This method is called too early.`);
+        }
+        if (syncTasks.current === t) {
+            if (syncTasks.queued.length > 0) {
+                syncTasks.current = undefined;
+            }
+            else {
+                this.status.syncTasks = undefined;
+            }
+            await this.triggerSaveProc();
+        }
+    }
+    isSyncDone() {
+        return !this.status.syncTasks;
+    }
+    isFileSaved() {
+        return this.saveProc.isSaved();
+    }
+    stat() {
+        return json_utils_1.copy(this.status.sync);
     }
 }
 exports.ObjStatus = ObjStatus;
 Object.freeze(ObjStatus.prototype);
 Object.freeze(ObjStatus);
 async function readAndCheckStatus(objFolder, objId) {
-    const status = await obj_info_file_1.readJSONInfoFileIn(objFolder, STATUS_FILE_NAME);
+    const status = await obj_info_file_1.readJSONInfoFileIn(objFolder, exports.STATUS_FILE_NAME);
     if (!status) {
         throw exceptions_1.makeStorageException({
             message: `Obj status file is not found in obj folder ${objFolder}`
@@ -158,54 +383,13 @@ async function readAndCheckStatus(objFolder, objId) {
     }
     return status;
 }
-function rmNonArchVersionsIn(status, ver) {
-    // XXX this is an analog of a function in local storage obj-files
-    //     Should code be structured the same way?
-    if (!status.versions.archived
-        || !status.versions.archived.includes(ver)) {
-        return;
-    }
-    // XXX code below is from local
-    //
-    // if (status.baseToDiff[ver]) { return; }
-    // const base = status.diffToBase[ver];
-    // if (typeof base !== 'number') { return; }
-    // delete status.diffToBase[ver];
-    // const diffs = status.baseToDiff[base];
-    // if (!diffs) { return; }
-    // const diffInd = diffs.indexOf(ver);
-    // if (diffInd < 0) { return; }
-    // diffs.splice(diffInd, 1);
-    // if (diffs.length === 0) {
-    // 	delete status.baseToDiff[base];
-    // 	rmNonArchVersionsIn(status, base);
-    // }
+exports.readAndCheckStatus = readAndCheckStatus;
+function lastIn(arr) {
+    return ((arr.length > 0) ? arr[arr.length - 1] : undefined);
+}
+function nonGarbageVersionInTask(task) {
+    if (task.type === 'upload') {
+        return task.version;
+    }
 }
-// export function setNewCurrentVersionAfterWriteIn(
-// 	status: ObjStatusInfo, newVersion: number, baseVer: number|undefined
-// ): void {
-// 	if (status.isArchived) { return; }
-// 	if (status.syncState === 'synced') {
-// 		status.syncState = 'unsynced';
-// 	}
-// 	if (baseVer !== undefined) {
-// 		// base->diff links should be added before removals
-// 		addBaseToDiffLinkInStatus(status, newVersion, baseVer);
-// 	}
-// 	if (status.versions.current) {
-// 		rmNonArchVersionsIn(status, status.versions.current);
-// 	}
-// 	status.versions.current = newVersion;
-// }
-// export function addConflictingRemoteVersionTo(
-// 	status: ObjStatusInfo, conflictVersion: number
-// ): void {
-// 	if (!status.versions.conflictingRemote) {
-// 		status.versions.conflictingRemote = [];
-// 	}
-// 	const conflicts = status.versions.conflictingRemote;
-// 	if (conflicts.find(v => v >= conflictVersion)) { return; }
-// 	status.syncState = 'conflicting';
-// 	status.versions.conflictingRemote.push(conflictVersion);
-// }
 Object.freeze(exports);

package/build/core/storage/synced/remote-events.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2019 - 2020 3NSoft Inc.
+ Copyright (C) 2019 - 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,7 +13,8 @@
  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.RemoteEvents = void 0;
 const rxjs_1 = require("rxjs");
@@ -37,7 +38,11 @@ class RemoteEvents {
         const objRemoval$ = serverEvents.observe(owner_1.objRemoved.EVENT_NAME)
             .pipe(operators_1.filter(objRm => !!objRm.objId), operators_1.mergeMap(objRm => this.remoteRemoval(objRm)));
         this.absorbingRemoteEventsProc = rxjs_1.merge(objChange$, objRemoval$)
-            .subscribe(undefined, err => this.logError(err), () => { this.absorbingRemoteEventsProc = undefined; });
+            .subscribe({
+            next: noop,
+            error: err => this.logError(err),
+            complete: () => { this.absorbingRemoteEventsProc = undefined; }
+        });
     }
     async close() {
         if (this.absorbingRemoteEventsProc) {
@@ -59,19 +64,19 @@ class RemoteEvents {
             return;
         }
         await obj.setRemoteVersion(objChange.newVer);
-        try {
-            const nodeInFS = this.fsNodes(objChange.objId);
-            if (nodeInFS) {
-                await nodeInFS.processRemoteEvent({
-                    type: 'remote-change',
-                    newVer: objChange.newVer,
-                    objId: objChange.objId
-                });
-            }
-        }
-        catch (err) {
-            this.logError(err, `Error in processing remote change event`);
+        const nodeInFS = this.fsNodes(objChange.objId);
+        if (!nodeInFS) {
+            return;
         }
+        await nodeInFS.processRemoteEvent({
+            type: 'remote-change',
+            newVer: objChange.newVer,
+            objId: objChange.objId
+        }).catch(async (exc) => {
+            if (!exc.notFound) {
+                await this.logError(exc, `Error in processing remote change event`);
+            }
+        });
     }
     async remoteRemoval(objRm) {
         const obj = await this.files.findObj(objRm.objId);
@@ -82,21 +87,22 @@ class RemoteEvents {
             return;
         }
         await obj.setDeletedOnRemote();
-        try {
-            const nodeInFS = this.fsNodes(objRm.objId);
-            if (nodeInFS) {
-                await nodeInFS.processRemoteEvent({
-                    type: 'remote-delete',
-                    objId: objRm.objId
-                });
-            }
-        }
-        catch (err) {
-            this.logError(err, `Error in processing remote change event`);
+        const nodeInFS = this.fsNodes(objRm.objId);
+        if (!nodeInFS) {
+            return;
         }
+        await nodeInFS.processRemoteEvent({
+            type: 'remote-delete',
+            objId: objRm.objId
+        }).catch(async (exc) => {
+            if (!exc.notFound) {
+                await this.logError(exc, `Error in processing remote removal event`);
+            }
+        });
     }
 }
 exports.RemoteEvents = RemoteEvents;
 Object.freeze(RemoteEvents.prototype);
 Object.freeze(RemoteEvents);
+function noop() { }
 Object.freeze(exports);

package/build/core/storage/synced/storage.d.ts

@@ -1,9 +1,13 @@
 import { IGetMailerIdSigner } from '../../../lib-client/user-with-mid-session';
-import { SyncedStorage as ISyncedStorage, NodesContainer, Storage as IStorage, StorageGetter, ObjId } from '../../../lib-client/3nstorage/xsp-fs/common';
+import { SyncedStorage as ISyncedStorage, NodesContainer, Storage as IStorage, StorageGetter, ObjId, NodeEvent } from '../../../lib-client/3nstorage/xsp-fs/common';
 import { ScryptGenParams } from '../../../lib-client/key-derivation';
 import { LogError } from '../../../lib-client/logging/log-to-file';
 import { AsyncSBoxCryptor, Subscribe, ObjSource } from 'xsp-files';
 import { NetClient } from '../../../lib-client/request-utils';
+import { Observable } from 'rxjs';
+declare type FolderEvent = web3n.files.FolderEvent;
+declare type FileEvent = web3n.files.FileEvent;
+declare type Stats = web3n.files.Stats;
 export declare class SyncedStore implements ISyncedStorage {
     private readonly files;
     private readonly remoteStorage;
@@ -15,12 +19,17 @@ export declare class SyncedStore implements ISyncedStorage {
     readonly nodes: NodesContainer;
     private readonly remoteEvents;
     private readonly uploader;
+    private readonly events;
     private constructor();
     static makeAndStart(path: string, user: string, getSigner: IGetMailerIdSigner, getStorages: StorageGetter, cryptor: AsyncSBoxCryptor, remoteServiceUrl: () => Promise<string>, makeNet: () => NetClient, logError: LogError): Promise<{
         syncedStore: ISyncedStorage;
         startObjProcs: () => void;
     }>;
+    getNodeEvents(): Observable<NodeEvent>;
+    broadcastNodeEvent(objId: ObjId, parentObjId: ObjId | undefined, event: FolderEvent | FileEvent): void;
+    private broadcastUpSyncEvent;
     storageForLinking(type: web3n.files.FSType, location?: string): IStorage;
+    getObjSyncInfo(objId: ObjId): Promise<Stats['sync']>;
     getRootKeyDerivParamsFromServer(): Promise<ScryptGenParams>;
     generateNewObjId(): Promise<string>;
     private objFromDiskOrDownload;
@@ -31,3 +40,4 @@ export declare class SyncedStore implements ISyncedStorage {
     removeObj(objId: string): Promise<void>;
     close(): Promise<void>;
 }
+export {};