core-3nweb-client-lib 0.26.1 → 0.27.3

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

@@ -1,26 +1,29 @@
-import { Storage, NodesContainer, StorageGetter, ObjId, NodeEvent } from '../../../lib-client/3nstorage/xsp-fs/common';
+import { Storage, NodesContainer, StorageGetter, ObjId, NodeEvent, LocalObjStatus } from '../../../lib-client/3nstorage/xsp-fs/common';
 import { LogError } from '../../../lib-client/logging/log-to-file';
 import { AsyncSBoxCryptor, Subscribe, ObjSource } from 'xsp-files';
 import { Observable } from 'rxjs';
 declare type FolderEvent = web3n.files.FolderEvent;
 declare type FileEvent = web3n.files.FileEvent;
+declare type FSType = web3n.files.FSType;
 export declare class LocalStorage implements Storage {
     private readonly files;
     private readonly getStorages;
     readonly cryptor: AsyncSBoxCryptor;
-    private readonly logError;
-    readonly type: web3n.files.FSType;
+    readonly logError: LogError;
+    readonly type = "local";
     readonly versioned = true;
     readonly nodes: NodesContainer;
+    readonly connect: undefined;
     private readonly events;
     private constructor();
     static makeAndStart(path: string, getStorages: StorageGetter, cryptor: AsyncSBoxCryptor, logError: LogError): Promise<Storage>;
     getNodeEvents(): Observable<NodeEvent>;
-    broadcastNodeEvent(objId: ObjId, parentObjId: ObjId | undefined, event: FolderEvent | FileEvent): void;
-    storageForLinking(type: web3n.files.FSType, location?: string): Storage;
+    broadcastNodeEvent(objId: ObjId, parentObjId: ObjId | undefined, childObjId: ObjId | undefined, event: FolderEvent | FileEvent): void;
+    storageForLinking(type: FSType, location?: string): Storage;
+    private getObjOrThrow;
+    status(objId: ObjId): Promise<LocalObjStatus>;
     generateNewObjId(): Promise<string>;
-    private getObjNonArchOrThrow;
-    getObj(objId: ObjId): Promise<ObjSource>;
+    getObjSrc(objId: ObjId, version?: number): Promise<ObjSource>;
     saveObj(objId: string, version: number, encSub: Subscribe): Promise<void>;
     removeObj(objId: string): Promise<void>;
     close(): Promise<void>;

package/build/core/storage/local/storage.js

@@ -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.LocalStorage = void 0;
 const common_1 = require("../../../lib-client/3nstorage/xsp-fs/common");
@@ -32,19 +33,20 @@ class LocalStorage {
         this.type = 'local';
         this.versioned = true;
         this.nodes = new common_1.NodesContainer();
+        this.connect = undefined;
         this.events = new utils_for_observables_1.Broadcast();
         Object.seal(this);
     }
     static async makeAndStart(path, getStorages, cryptor, logError) {
         const files = await obj_files_1.ObjFiles.makeFor(path, logError);
         const s = new LocalStorage(files, getStorages, cryptor, logError);
-        return common_1.wrapStorageImplementation(s);
+        return (0, common_1.wrapStorageImplementation)(s);
     }
     getNodeEvents() {
         return this.events.event$;
     }
-    broadcastNodeEvent(objId, parentObjId, event) {
-        this.events.next({ objId, parentObjId, event });
+    broadcastNodeEvent(objId, parentObjId, childObjId, event) {
+        this.events.next({ objId, parentObjId, childObjId, event });
     }
     storageForLinking(type, location) {
         if ((type === 'local') || (type === 'synced')) {
@@ -57,8 +59,22 @@ class LocalStorage {
             throw new Error(`Getting ${type} storage is not implemented in local storage.`);
         }
     }
+    async getObjOrThrow(objId, allowArchived = false) {
+        const obj = await this.files.findObj(objId);
+        if (!obj
+            || (!allowArchived && obj.statusObj().isArchived())) {
+            throw (0, exceptions_1.makeObjNotFoundExc)(objId);
+        }
+        else {
+            return obj;
+        }
+    }
+    async status(objId) {
+        const obj = await this.getObjOrThrow(objId);
+        return obj.localStatus();
+    }
     async generateNewObjId() {
-        const nonce = await random_node_1.bytes(ecma_nacl_1.secret_box.NONCE_LENGTH);
+        const nonce = await (0, random_node_1.bytes)(ecma_nacl_1.secret_box.NONCE_LENGTH);
         const id = buffer_utils_1.base64urlSafe.pack(nonce);
         if (this.nodes.reserveId(id)) {
             return id;
@@ -67,35 +83,30 @@ class LocalStorage {
             return this.generateNewObjId();
         }
     }
-    async getObjNonArchOrThrow(objId) {
-        const obj = await this.files.findObj(objId);
-        if (!obj || obj.isArchived()) {
-            throw exceptions_1.makeObjNotFoundExc(objId);
+    async getObjSrc(objId, version) {
+        const obj = await this.getObjOrThrow(objId);
+        if (!version) {
+            version = obj.statusObj().getCurrentVersionOrThrow();
         }
-        return obj;
-    }
-    async getObj(objId) {
-        const obj = await this.getObjNonArchOrThrow(objId);
-        const currentVer = obj.getCurrentVersionOrThrow();
-        return obj.getObjSrc(currentVer);
+        return obj.getObjSrc(version);
     }
     async saveObj(objId, version, encSub) {
         const obj = await this.files.findObj(objId);
         if (version === 1) {
             if (obj) {
-                throw exceptions_1.makeObjExistsExc(objId);
+                throw (0, exceptions_1.makeObjExistsExc)(objId);
             }
             await this.files.saveFirstVersion(objId, encSub);
         }
         else {
             if (!obj) {
-                throw exceptions_1.makeObjNotFoundExc(objId);
+                throw (0, exceptions_1.makeObjNotFoundExc)(objId);
             }
             await obj.saveNewVersion(version, encSub);
         }
     }
     async removeObj(objId) {
-        const obj = await this.getObjNonArchOrThrow(objId);
+        const obj = await this.getObjOrThrow(objId);
         await obj.removeCurrentVersion();
     }
     async close() {

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

@@ -64,7 +64,7 @@ class Downloader {
                     chunks.push(chunk);
                     ofs += chunk.length;
                 }
-                return buffer_utils_1.joinByteArrs(chunks);
+                return (0, buffer_utils_1.joinByteArrs)(chunks);
             }
         });
     }

package/build/core/storage/synced/obj-files-gc.d.ts

@@ -23,4 +23,5 @@ export declare class GC {
     stop(): Promise<void>;
     private objCollecting;
     private collectIn;
+    private checkAndRemoveWholeObjFolder;
 }

package/build/core/storage/synced/obj-files-gc.js

@@ -17,9 +17,12 @@
 */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GC = void 0;
+const obj_files_1 = require("./obj-files");
 const synced_1 = require("../../../lib-common/processes/synced");
 const fs = require("../../../lib-common/async-fs-node");
 const path_1 = require("path");
+const utils_1 = require("../common/utils");
+const upload_header_file_1 = require("./upload-header-file");
 class GC {
     constructor(sync, rmObjFromCache, rmObjFolder) {
         this.sync = sync;
@@ -54,11 +57,11 @@ class GC {
             if (this.wip.size === 0) {
                 [this.wip, this.scheduled] = [this.scheduled, this.wip];
             }
-            const obj = getAndRemoveOneFrom(this.wip);
+            const obj = (0, utils_1.getAndRemoveOneFrom)(this.wip);
             if (!obj) {
                 return;
             }
-            await this.sync(obj.objId, () => this.collectIn(obj).catch(noop));
+            await this.sync(obj.objId, () => this.collectIn(obj).catch(utils_1.noop));
             return this.objCollecting();
         };
         Object.seal(this);
@@ -67,52 +70,86 @@ class GC {
         this.isStopped = true;
     }
     async collectIn(obj) {
-        // calculate versions that should not be removed
-        const { gcMaxVer, nonGarbage } = obj.getNonGarbageVersions();
-        // if object is set archived, and there is nothing in it worth keeping,
-        // whole folder can be removed
-        if ((nonGarbage.size === 0)
-            && obj.isArchived() && obj.sync().isSyncDone()) {
-            if (!obj.isStatusFileSaved()) {
-                return;
-            }
-            this.rmObjFromCache(obj);
-            if (obj.objId) {
-                await this.rmObjFolder(obj.objId);
-            }
-            return;
-        }
-        // for all other cases, we remove version files that are not worth
-        // keeping.
-        const lst = await fs.readdir(obj.objFolder).catch(noop);
-        if (!lst) {
-            return;
+        const nonGarbage = obj.statusObj().getNonGarbageVersions();
+        if (!(await this.checkAndRemoveWholeObjFolder(obj, nonGarbage))) {
+            await removeGarbageFiles(obj, nonGarbage);
         }
-        const rmProcs = [];
-        for (const f of lst) {
-            const ver = parseInt(f);
-            if (isNaN(ver) || nonGarbage.has(ver)
-                || (gcMaxVer && (ver >= gcMaxVer))) {
-                continue;
-            }
-            rmProcs.push(fs.unlink(path_1.join(obj.objFolder, f)).catch(noop));
+    }
+    async checkAndRemoveWholeObjFolder(obj, { local, remote }) {
+        if (obj.objId
+            && obj.statusObj().isArchived()
+            && !needsUpsyncOfRemoval(obj)
+            && (!local || (local.nonGarbage.size === 0))
+            && (remote.nonGarbage.size === 0)) {
+            this.rmObjFromCache(obj);
+            await this.rmObjFolder(obj.objId);
+            return true;
         }
-        if (rmProcs.length > 0) {
-            await Promise.all(rmProcs);
+        else {
+            return false;
         }
     }
 }
 exports.GC = GC;
 Object.freeze(GC.prototype);
 Object.freeze(GC);
-function getAndRemoveOneFrom(set) {
-    const iter = set.values();
-    const { value, done } = iter.next();
-    if (done) {
+function needsUpsyncOfRemoval(obj) {
+    const s = obj.statusObj();
+    return !(s.neverUploaded() || (s.syncStatus().state === 'synced'));
+}
+function canRemove(f, { local, remote, uploadVersion }) {
+    if (f.endsWith(obj_files_1.UNSYNCED_FILE_NAME_EXT)) {
+        const verStr = f.slice(0, f.length - 1 - obj_files_1.UNSYNCED_FILE_NAME_EXT.length);
+        return (local ? canGC(verStr, local) : true);
+    }
+    else if (f.endsWith(obj_files_1.REMOTE_FILE_NAME_EXT)) {
+        const verStr = f.slice(0, f.length - 1 - obj_files_1.REMOTE_FILE_NAME_EXT.length);
+        return canGC(verStr, remote);
+    }
+    else if (!!uploadVersion
+        && f.endsWith(upload_header_file_1.UPLOAD_HEADER_FILE_NAME_EXT)) {
+        const verStr = f.slice(0, f.length - 1 - upload_header_file_1.UPLOAD_HEADER_FILE_NAME_EXT.length);
+        return canGCUploadHeader(verStr, uploadVersion);
+    }
+    else {
+        return false;
+    }
+}
+function canGC(verStr, nonGC) {
+    const ver = parseInt(verStr);
+    if (isNaN(ver)) {
+        return true;
+    }
+    else if (!nonGC.nonGarbage.has(ver)
+        && (!nonGC.gcMaxVer || (ver < nonGC.gcMaxVer))) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+function canGCUploadHeader(verStr, uploadVersion) {
+    const ver = parseInt(verStr);
+    if (isNaN(ver)) {
+        return true;
+    }
+    else {
+        return (ver === uploadVersion);
+    }
+}
+async function removeGarbageFiles(obj, nonGarbage) {
+    const lst = await fs.readdir(obj.objFolder).catch(utils_1.noop);
+    if (!lst) {
         return;
     }
-    set.delete(value);
-    return value;
+    const rmProcs = [];
+    for (const f of lst) {
+        if (canRemove(f, nonGarbage)) {
+            rmProcs.push(fs.unlink((0, path_1.join)(obj.objFolder, f)).catch(utils_1.noop));
+        }
+    }
+    if (rmProcs.length > 0) {
+        await Promise.all(rmProcs);
+    }
 }
-function noop() { }
 Object.freeze(exports);

package/build/core/storage/synced/obj-files.d.ts

@@ -1,22 +1,36 @@
 import { Observable } from 'rxjs';
-import { ObjId } from '../../../lib-client/3nstorage/xsp-fs/common';
+import { ObjId, SyncedObjStatus } from '../../../lib-client/3nstorage/xsp-fs/common';
 import { InitDownloadParts } from '../../../lib-client/objs-on-disk/obj-on-disk';
 import { ObjSource, Subscribe } from 'xsp-files';
 import { Downloader } from './downloader';
 import { FileWrite } from '../../../lib-client/objs-on-disk/file-writing-proc';
 import { GC } from './obj-files-gc';
-import { UpSyncStatus } from './obj-status';
+import { ObjStatus } from './obj-status';
 import { LogError } from '../../../lib-client/logging/log-to-file';
+import { DiffInfo } from '../../../lib-common/service-api/3nstorage/owner';
+import { FiniteChunk } from '../../../lib-common/objs-on-disk/file-layout';
+import { StorageOwner as RemoteStorage } from '../../../lib-client/3nstorage/service';
+import { UploadHeaderChange } from '../../../lib-client/3nstorage/xsp-fs/common';
+export declare const UNSYNCED_FILE_NAME_EXT = "unsynced";
+export declare const REMOTE_FILE_NAME_EXT = "v";
+/**
+ * File system has nodes. Each node may have data in one or many objects of
+ * storage. SyncedObj allows to work with files of storage object, even when
+ * file system node no longer exists. ObjFiles is a holder and factory of
+ * SyncedObj's.
+ */
 export declare class ObjFiles {
     private readonly folders;
-    private readonly downloader;
     private readonly logError;
     private readonly objs;
     private readonly sync;
+    private readonly downloader;
     private readonly gc;
     private constructor();
-    static makeFor(path: string, downloader: Downloader, logError: LogError): Promise<ObjFiles>;
+    static makeFor(path: string, remote: RemoteStorage, logError: LogError): Promise<ObjFiles>;
+    private canMoveObjToDeeperCache;
     findObj(objId: ObjId): Promise<SyncedObj | undefined>;
+    getObjInCache(objId: ObjId): SyncedObj | undefined;
     private makeObj;
     private removeFailedNewObj;
     makeByDownloadingCurrentVersion(objId: ObjId): Promise<SyncedObj>;
@@ -24,7 +38,8 @@ export declare class ObjFiles {
         fileWrite$: Observable<FileWrite[]>;
         newObj: SyncedObj;
     }>;
-    collectUnsyncedObjs(): Observable<ObjId>;
+    findObjsToRemoveOnRemote(): Observable<ObjId>;
+    scheduleGC(obj: SyncedObj): void;
 }
 export declare type SynchronizerOnObjId = <T>(objId: ObjId, action: () => Promise<T>) => Promise<T>;
 export declare class SyncedObj {
@@ -33,46 +48,45 @@ export declare class SyncedObj {
     private readonly status;
     private readonly downloader;
     private readonly scheduleGC;
-    /**
-     * These versions are what simple programs see. It is a local opinion about
-     * object's versions. Versions here can be either synced, or unsynced.
-     */
-    private readonly verObjs;
-    /**
-     * These are conflicting versions, coming from a server. Of course, universal
-     * truth is spread by server, but in situations of parallel changes, local
-     * version allows things to work, while conflicting version from server
-     * should be adopted by conflict resolution process. In other words, these
-     * versions are not for common use.
-     */
-    private readonly remoteConflictVerObjs;
+    private readonly remoteVers;
+    private readonly localVers;
     private constructor();
     static forExistingObj(objId: ObjId, objFolder: string, downloader: Downloader, scheduleGC: GC['scheduleCollection'], logError: LogError): Promise<SyncedObj>;
     static forDownloadedObj(objId: ObjId, objFolder: string, downloader: Downloader, scheduleGC: GC['scheduleCollection'], version: number, parts: InitDownloadParts, logError: LogError): Promise<SyncedObj>;
     static forNewObj(objId: ObjId, objFolder: string, downloader: Downloader, scheduleGC: GC['scheduleCollection'], logError: LogError): Promise<SyncedObj>;
-    sync(): UpSyncStatus;
     scheduleSelfGC(): void;
-    private path;
-    getObjSrc(version: number): Promise<ObjSource>;
-    private objSegsGetterFromDisk;
-    getRemoteConflictObjVersion(version: number): Promise<ObjSource>;
-    private conflictObjSegsGetterFromDisk;
+    private localVerPath;
+    private remoteVerPath;
+    getObjSrcFromLocalAndSyncedBranch(version: number): Promise<ObjSource>;
+    getObjSrcFromRemoteAndSyncedBranch(version: number): Promise<ObjSource>;
+    private instanceOfLocalObjVer;
+    private instanceOfRemoteObjVer;
+    private readonly localAndSyncedObjSegsGetterFromDisk;
+    private readonly remoteObjSegsGetterFromDisk;
     saveNewVersion(version: number, encSub: Subscribe): Promise<{
         fileWrite$: Observable<FileWrite[]>;
         baseVer?: number;
     }>;
-    isArchived(): boolean;
-    getCurrentVersionOrThrow(): number;
-    isRemoteVersionGreaterOrEqualTo(newRemoteVersion: number): boolean;
-    isDeletedOnRemote(): boolean;
+    combineLocalBaseIfPresent(version: number): Promise<number | undefined>;
+    saveUploadHeaderFile(uploadHeader: UploadHeaderChange): Promise<void>;
     private setUnsyncedCurrentVersion;
-    markVersionSynced(version: number): Promise<void>;
-    setRemoteVersion(version: number): Promise<void>;
-    setDeletedOnRemote(): Promise<void>;
+    /**
+     * This renames/moves version file from local to remote.
+     * Removes upload info from status, updating enumerations of local and
+     * synced versions.
+     */
+    recordUploadCompletion(localVersion: number, uploadVersion: number, headerChange: {
+        newHeader: Uint8Array;
+        originalHeader: Uint8Array;
+    } | undefined): Promise<void>;
+    dropCachedLocalObjVersionsLessOrEqual(version: number): void;
+    removeLocalVersionFilesLessThan(version: number): Promise<void>;
     removeCurrentVersion(): Promise<void>;
-    getNonGarbageVersions(): {
-        gcMaxVer?: number;
-        nonGarbage: Set<number>;
-    };
-    isStatusFileSaved(): boolean;
+    diffForUploadOf(version: number): Promise<{
+        diff: DiffInfo;
+        newSegsPackOrder: FiniteChunk[];
+    }>;
+    syncStatus(): SyncedObjStatus;
+    statusObj(): ObjStatus;
+    recordRemovalUploadAndGC(): Promise<void>;
 }