core-3nweb-client-lib 0.26.1 → 0.27.3

package/build/core/storage/synced/remote-events.d.ts

@@ -1,23 +1,22 @@
 import { StorageOwner } from '../../../lib-client/3nstorage/service';
 import { ObjFiles } from './obj-files';
-import { Node, ObjId } from '../../../lib-client/3nstorage/xsp-fs/common';
+import { Storage } from '../../../lib-client/3nstorage/xsp-fs/common';
 import { LogError } from '../../../lib-client/logging/log-to-file';
-export declare type GetFSNode = (objId: ObjId) => Node | undefined;
+/**
+ * Remote events are absorbed into objects' statuses, broadcasting respective
+ * events. Someone down the stream can react to these changes from remote.
+ */
 export declare class RemoteEvents {
     private readonly remoteStorage;
     private readonly files;
-    private readonly fsNodes;
+    private readonly broadcastNodeEvent;
     private readonly logError;
-    constructor(remoteStorage: StorageOwner, files: ObjFiles, fsNodes: GetFSNode, logError: LogError);
+    constructor(remoteStorage: StorageOwner, files: ObjFiles, broadcastNodeEvent: Storage['broadcastNodeEvent'], logError: LogError);
     private absorbingRemoteEventsProc;
     startAbsorbingRemoteEvents(): void;
     close(): Promise<void>;
-    /**
-     * Information about external event is recorded into obj status before
-     * main processing takes place. This allows to synchronize all obj changes,
-     * while informing already scheduled processes.
-     * @param objChange
-     */
-    private remoteChange;
-    private remoteRemoval;
+    private absorbObjChange;
+    private absorbObjRemoval;
+    private absorbObjVersionArchival;
+    private absorbArchVersionRemoval;
 }

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

@@ -22,83 +22,100 @@ const server_events_1 = require("../../../lib-client/server-events");
 const owner_1 = require("../../../lib-common/service-api/3nstorage/owner");
 const operators_1 = require("rxjs/operators");
 const SERVER_EVENTS_RESTART_WAIT_SECS = 30;
+/**
+ * Remote events are absorbed into objects' statuses, broadcasting respective
+ * events. Someone down the stream can react to these changes from remote.
+ */
 class RemoteEvents {
-    constructor(remoteStorage, files, fsNodes, logError) {
+    constructor(remoteStorage, files, broadcastNodeEvent, logError) {
         this.remoteStorage = remoteStorage;
         this.files = files;
-        this.fsNodes = fsNodes;
+        this.broadcastNodeEvent = broadcastNodeEvent;
         this.logError = logError;
         this.absorbingRemoteEventsProc = undefined;
         Object.seal(this);
     }
     startAbsorbingRemoteEvents() {
         const serverEvents = new server_events_1.ServerEvents(() => this.remoteStorage.openEventSource(), SERVER_EVENTS_RESTART_WAIT_SECS);
-        const objChange$ = serverEvents.observe(owner_1.objChanged.EVENT_NAME)
-            .pipe(operators_1.filter(objChange => Number.isInteger(objChange.newVer) && (objChange.newVer > 1)), operators_1.mergeMap(objChange => this.remoteChange(objChange)));
-        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$)
+        this.absorbingRemoteEventsProc = (0, rxjs_1.merge)(this.absorbObjChange(serverEvents), this.absorbObjRemoval(serverEvents), this.absorbObjVersionArchival(serverEvents), this.absorbArchVersionRemoval(serverEvents))
             .subscribe({
             next: noop,
-            error: err => this.logError(err),
-            complete: () => { this.absorbingRemoteEventsProc = undefined; }
+            error: async (err) => {
+                await this.logError(err);
+                this.absorbingRemoteEventsProc = undefined;
+            },
+            complete: () => {
+                this.absorbingRemoteEventsProc = undefined;
+            }
         });
     }
     async close() {
         if (this.absorbingRemoteEventsProc) {
             this.absorbingRemoteEventsProc.unsubscribe();
+            this.absorbingRemoteEventsProc = undefined;
         }
     }
-    /**
-     * Information about external event is recorded into obj status before
-     * main processing takes place. This allows to synchronize all obj changes,
-     * while informing already scheduled processes.
-     * @param objChange
-     */
-    async remoteChange(objChange) {
-        const obj = await this.files.findObj(objChange.objId);
-        if (!obj) {
-            return;
-        }
-        if (obj.isRemoteVersionGreaterOrEqualTo(objChange.newVer)) {
-            return;
-        }
-        await obj.setRemoteVersion(objChange.newVer);
-        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`);
+    absorbObjChange(serverEvents) {
+        return serverEvents.observe(owner_1.events.objChanged.EVENT_NAME)
+            .pipe((0, operators_1.mergeMap)(async ({ newVer, objId }) => {
+            if (!Number.isInteger(newVer) || (newVer < 1)) {
+                return;
             }
-        });
+            const obj = await this.files.findObj(objId);
+            if (!obj) {
+                return;
+            }
+            obj.statusObj().recordRemoteChange(newVer);
+            this.broadcastNodeEvent(obj.objId, undefined, undefined, {
+                type: 'remote-change',
+                path: '',
+                newVersion: newVer
+            });
+        }, 1));
     }
-    async remoteRemoval(objRm) {
-        const obj = await this.files.findObj(objRm.objId);
-        if (!obj) {
-            return;
-        }
-        if (obj.isArchived() || obj.isDeletedOnRemote()) {
-            return;
-        }
-        await obj.setDeletedOnRemote();
-        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`);
+    absorbObjRemoval(serverEvents) {
+        return serverEvents.observe(owner_1.events.objRemoved.EVENT_NAME)
+            .pipe((0, operators_1.filter)((objRm) => !!objRm.objId), (0, operators_1.mergeMap)(async ({ objId }) => {
+            const obj = await this.files.findObj(objId);
+            if (!obj) {
+                return;
             }
-        });
+            obj.statusObj().recordRemoteRemoval();
+            this.broadcastNodeEvent(obj.objId, undefined, undefined, {
+                type: 'remote-removal',
+                path: ''
+            });
+        }, 1));
+    }
+    absorbObjVersionArchival(serverEvents) {
+        return serverEvents.observe(owner_1.events.objVersionArchived.EVENT_NAME)
+            .pipe((0, operators_1.mergeMap)(async ({ objId, archivedVer }) => {
+            const obj = await this.files.findObj(objId);
+            if (!obj) {
+                return;
+            }
+            obj.statusObj().recordVersionArchival(archivedVer);
+            this.broadcastNodeEvent(obj.objId, undefined, undefined, {
+                type: 'remote-version-archival',
+                path: '',
+                archivedVersion: archivedVer
+            });
+        }, 1));
+    }
+    absorbArchVersionRemoval(serverEvents) {
+        return serverEvents.observe(owner_1.events.objArchivedVersionRemoved.EVENT_NAME)
+            .pipe((0, operators_1.mergeMap)(async ({ objId, archivedVer }) => {
+            const obj = await this.files.findObj(objId);
+            if (!obj) {
+                return;
+            }
+            obj.statusObj().recordArchVersionRemoval(archivedVer);
+            this.broadcastNodeEvent(obj.objId, undefined, undefined, {
+                type: 'remote-arch-ver-removal',
+                path: '',
+                removedArchVer: archivedVer
+            });
+        }, 1));
     }
 }
 exports.RemoteEvents = RemoteEvents;

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

@@ -1,19 +1,21 @@
 import { IGetMailerIdSigner } from '../../../lib-client/user-with-mid-session';
-import { SyncedStorage as ISyncedStorage, NodesContainer, Storage as IStorage, StorageGetter, ObjId, NodeEvent } from '../../../lib-client/3nstorage/xsp-fs/common';
+import { SyncedStorage as ISyncedStorage, NodesContainer, Storage as IStorage, StorageGetter, ObjId, NodeEvent, SyncedObjStatus } 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';
+import { UploadHeaderChange } from '../../../lib-client/3nstorage/xsp-fs/common';
 declare type FolderEvent = web3n.files.FolderEvent;
 declare type FileEvent = web3n.files.FileEvent;
-declare type Stats = web3n.files.Stats;
+declare type SyncStatus = web3n.files.SyncStatus;
+declare type OptionsToAdopteRemote = web3n.files.OptionsToAdopteRemote;
 export declare class SyncedStore implements ISyncedStorage {
     private readonly files;
     private readonly remoteStorage;
     private readonly getStorages;
     readonly cryptor: AsyncSBoxCryptor;
-    private readonly logError;
+    readonly logError: LogError;
     readonly type: web3n.files.FSType;
     readonly versioned = true;
     readonly nodes: NodesContainer;
@@ -21,21 +23,33 @@ export declare class SyncedStore implements ISyncedStorage {
     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<{
+    static makeAndStart(path: string, user: string, getSigner: IGetMailerIdSigner, getStorages: StorageGetter, cryptor: AsyncSBoxCryptor, remoteServiceUrl: () => Promise<string>, net: NetClient, logError: LogError): Promise<{
         syncedStore: ISyncedStorage;
         startObjProcs: () => void;
     }>;
+    static makeAndStartWithoutRemote(path: string, user: string, getStorages: StorageGetter, cryptor: AsyncSBoxCryptor, remoteServiceUrl: () => Promise<string>, net: NetClient, logError: LogError): Promise<{
+        syncedStore: ISyncedStorage;
+        setupRemoteAndStartObjProcs: (getSigner: IGetMailerIdSigner) => void;
+    }>;
     getNodeEvents(): Observable<NodeEvent>;
-    broadcastNodeEvent(objId: ObjId, parentObjId: ObjId | undefined, event: FolderEvent | FileEvent): void;
-    private broadcastUpSyncEvent;
+    broadcastNodeEvent(objId: ObjId, parentObjId: ObjId | undefined, childObjId: ObjId | undefined, event: FolderEvent | FileEvent): void;
     storageForLinking(type: web3n.files.FSType, location?: string): IStorage;
-    getObjSyncInfo(objId: ObjId): Promise<Stats['sync']>;
+    status(objId: ObjId): Promise<SyncedObjStatus>;
+    adoptRemote(objId: ObjId, opts: OptionsToAdopteRemote | undefined): Promise<number | undefined>;
+    updateStatusInfo(objId: ObjId): Promise<SyncStatus>;
+    isObjOnDisk(objId: ObjId): Promise<boolean>;
+    isRemoteVersionOnDisk(objId: ObjId, version: number): Promise<'complete' | 'partial' | 'none'>;
+    download(objId: ObjId, version: number): Promise<void>;
+    upload(objId: ObjId, localVersion: number, uploadVersion: number, uploadHeader: UploadHeaderChange | undefined, createOnRemote: boolean): Promise<void>;
+    uploadObjRemoval(objId: ObjId): Promise<void>;
+    dropCachedLocalObjVersionsLessOrEqual(objId: ObjId, version: number): void;
+    archiveVersionOnServer(objId: ObjId, version: number): Promise<void>;
     getRootKeyDerivParamsFromServer(): Promise<ScryptGenParams>;
     generateNewObjId(): Promise<string>;
     private objFromDiskOrDownload;
-    private getObjNonArchOrThrow;
-    getObj(objId: ObjId): Promise<ObjSource>;
-    getRemoteConflictObjVersion(objId: ObjId, version: number): Promise<ObjSource>;
+    private getObjOrThrow;
+    getObjSrc(objId: ObjId, version?: number, allowArchived?: boolean): Promise<ObjSource>;
+    getObjSrcOfRemoteVersion(objId: ObjId, version: number): Promise<ObjSource>;
     saveObj(objId: ObjId, version: number, encSub: Subscribe): Promise<void>;
     removeObj(objId: string): Promise<void>;
     close(): Promise<void>;

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

@@ -24,7 +24,6 @@ const obj_files_1 = require("./obj-files");
 const random_node_1 = require("../../../lib-common/random-node");
 const buffer_utils_1 = require("../../../lib-common/buffer-utils");
 const xsp_files_1 = require("xsp-files");
-const downloader_1 = require("./downloader");
 const remote_events_1 = require("./remote-events");
 const upsyncer_1 = require("./upsyncer");
 const utils_for_observables_1 = require("../../../lib-common/utils-for-observables");
@@ -39,39 +38,48 @@ class SyncedStore {
         this.versioned = true;
         this.nodes = new common_1.NodesContainer();
         this.events = new utils_for_observables_1.Broadcast();
-        const getFSNodes = (objId) => this.nodes.get(objId);
-        this.remoteEvents = new remote_events_1.RemoteEvents(this.remoteStorage, this.files, getFSNodes, this.logError);
-        this.uploader = new upsyncer_1.UpSyncer(this.remoteStorage, this.logError, this.broadcastUpSyncEvent.bind(this));
+        this.remoteEvents = new remote_events_1.RemoteEvents(this.remoteStorage, this.files, this.broadcastNodeEvent.bind(this), this.logError);
+        this.uploader = new upsyncer_1.UpSyncer(this.remoteStorage, this.logError);
         Object.seal(this);
     }
-    static async makeAndStart(path, user, getSigner, getStorages, cryptor, remoteServiceUrl, makeNet, logError) {
-        const remote = new service_1.StorageOwner(user, getSigner, remoteServiceUrl, makeNet());
-        const objFiles = await obj_files_1.ObjFiles.makeFor(path, new downloader_1.Downloader(remote), logError);
+    static async makeAndStart(path, user, getSigner, getStorages, cryptor, remoteServiceUrl, net, logError) {
+        const remote = service_1.StorageOwner.make(user, getSigner, remoteServiceUrl, net);
+        const objFiles = await obj_files_1.ObjFiles.makeFor(path, remote, logError);
         const s = new SyncedStore(objFiles, remote, getStorages, cryptor, logError);
         s.uploader.start();
+        // XXX ??
+        // s.remoteEvents.startAbsorbingRemoteEvents();
         return {
-            syncedStore: common_1.wrapSyncStorageImplementation(s),
+            syncedStore: (0, common_1.wrapSyncStorageImplementation)(s),
             startObjProcs: () => {
                 s.remoteEvents.startAbsorbingRemoteEvents();
             }
         };
     }
+    static async makeAndStartWithoutRemote(path, user, getStorages, cryptor, remoteServiceUrl, net, logError) {
+        const { remote, setMid } = service_1.StorageOwner.makeBeforeMidSetup(user, remoteServiceUrl, net);
+        const objFiles = await obj_files_1.ObjFiles.makeFor(path, remote, logError);
+        const s = new SyncedStore(objFiles, remote, getStorages, cryptor, logError);
+        // XXX ??
+        // s.remoteEvents.startAbsorbingRemoteEvents();
+        return {
+            syncedStore: (0, common_1.wrapSyncStorageImplementation)(s),
+            setupRemoteAndStartObjProcs: getSigner => {
+                setMid(getSigner);
+                s.uploader.start();
+                s.remoteEvents.startAbsorbingRemoteEvents();
+            }
+        };
+    }
     getNodeEvents() {
         return this.events.event$;
     }
-    broadcastNodeEvent(objId, parentObjId, event) {
-        this.events.next({ objId, parentObjId, event });
-    }
-    broadcastUpSyncEvent(objId, task) {
-        const node = this.nodes.get(objId);
-        if (!node) {
-            return;
-        }
-        node.broadcastUpSyncEvent(task);
+    broadcastNodeEvent(objId, parentObjId, childObjId, event) {
+        this.events.next({ objId, parentObjId, childObjId, event });
     }
     storageForLinking(type, location) {
         if (type === 'synced') {
-            return common_1.wrapStorageImplementation(this);
+            return (0, common_1.wrapStorageImplementation)(this);
         }
         else if (type === 'share') {
             return this.getStorages('share', location);
@@ -80,18 +88,107 @@ class SyncedStore {
             throw new Error(`Getting ${type} storage is not implemented in local storage.`);
         }
     }
-    async getObjSyncInfo(objId) {
+    async status(objId) {
+        const obj = await this.getObjOrThrow(objId, true);
+        return obj.syncStatus();
+    }
+    async adoptRemote(objId, opts) {
+        const obj = await this.getObjOrThrow(objId);
+        const objStatus = obj.statusObj();
+        await objStatus.adoptRemoteVersion(opts === null || opts === void 0 ? void 0 : opts.remoteVersion, opts === null || opts === void 0 ? void 0 : opts.dropLocalVer);
+        if (opts && opts.download) {
+            // XXX this needs implementation
+            throw new Error('SyncedStore.adoptRemote() with download option needs implementation, probably using SyncedStore.download().');
+        }
+        this.files.scheduleGC(obj);
+        return objStatus.syncStatus().synced.latest;
+    }
+    async updateStatusInfo(objId) {
+        const obj = await this.getObjOrThrow(objId, true);
+        try {
+            const statusOnServer = await this.remoteStorage.getObjStatus(objId);
+            const objStatus = obj.statusObj();
+            await objStatus.recordStatusFromServer(statusOnServer);
+            return objStatus.syncStatus();
+        }
+        catch (exc) {
+            if ((exc.type === 'storage')
+                && exc.objNotFound) {
+                const objStatus = obj.statusObj();
+                await objStatus.recordStatusFromServer({});
+                return objStatus.syncStatus();
+            }
+            throw exc;
+        }
+    }
+    async isObjOnDisk(objId) {
         const obj = await this.files.findObj(objId);
+        return !!obj;
+    }
+    async isRemoteVersionOnDisk(objId, version) {
+        var _a;
+        const obj = await this.getObjOrThrow(objId, true);
+        const status = obj.statusObj();
+        const { remote } = status.syncStatus();
+        if (((remote === null || remote === void 0 ? void 0 : remote.latest) !== version)
+            || !((_a = remote.archived) === null || _a === void 0 ? void 0 : _a.includes(version))) {
+            throw (0, exceptions_1.makeObjVersionNotFoundExc)(objId, version);
+        }
+        // XXX
+        //  - get state of file
+        throw new Error('SyncedStore.isRemoteVersionOnDisk() not implemented.');
+    }
+    download(objId, version) {
+        // XXX
+        //  - check if on disk
+        //  - download header
+        //  - want result of DC-296, calculation of diff to download, relative to
+        //    latest version on the disk, using headers of both versions.
+        throw new Error('SyncedStore.download() not implemented.');
+    }
+    async upload(objId, localVersion, uploadVersion, uploadHeader, createOnRemote) {
+        const obj = await this.getObjOrThrow(objId, true);
+        const syncedBase = await obj.combineLocalBaseIfPresent(localVersion);
+        if (uploadHeader) {
+            await obj.saveUploadHeaderFile(uploadHeader);
+        }
+        await this.uploader.uploadFromDisk(obj, localVersion, uploadVersion, uploadHeader === null || uploadHeader === void 0 ? void 0 : uploadHeader.uploadHeader, syncedBase, createOnRemote);
+        await obj.recordUploadCompletion(localVersion, uploadVersion, (uploadHeader ? {
+            newHeader: uploadHeader.uploadHeader,
+            originalHeader: uploadHeader.localHeader
+        } : undefined));
+        if (localVersion > uploadVersion) {
+            await obj.removeLocalVersionFilesLessThan(localVersion);
+        }
+    }
+    async uploadObjRemoval(objId) {
+        if (!objId) {
+            return;
+        }
+        const obj = await this.getObjOrThrow(objId, true);
+        const status = obj.statusObj();
+        if (status.neverUploaded()) {
+            return;
+        }
+        if (await status.clearPostponeFlagInRemovalOnRemote()) {
+            await this.uploader.removeCurrentVersionOf(obj);
+        }
+    }
+    dropCachedLocalObjVersionsLessOrEqual(objId, version) {
+        const obj = this.files.getObjInCache(objId);
         if (!obj) {
             return;
         }
-        return obj.sync().stat();
+        obj.dropCachedLocalObjVersionsLessOrEqual(version);
+    }
+    async archiveVersionOnServer(objId, version) {
+        await this.remoteStorage.archiveObjVersion(objId, version);
     }
     getRootKeyDerivParamsFromServer() {
         return this.remoteStorage.getKeyDerivParams();
     }
     async generateNewObjId() {
-        const nonce = await random_node_1.bytes(xsp_files_1.NONCE_LENGTH);
+        const nonce = await (0, random_node_1.bytes)(xsp_files_1.NONCE_LENGTH);
         const id = buffer_utils_1.base64urlSafe.pack(nonce);
         if (this.nodes.reserveId(id)) {
             return id;
@@ -105,53 +202,56 @@ class SyncedStore {
         if (obj) {
             return obj;
         }
+        // XXX
+        //  - can we create object by getting obj status
         return await this.files.makeByDownloadingCurrentVersion(objId);
     }
-    async getObjNonArchOrThrow(objId) {
+    async getObjOrThrow(objId, allowArchived = false) {
         const obj = await this.objFromDiskOrDownload(objId);
-        if (obj.isArchived()) {
-            throw exceptions_1.makeObjNotFoundExc(objId);
+        if (!allowArchived && obj.statusObj().isArchived()) {
+            throw (0, exceptions_1.makeObjNotFoundExc)(objId);
+        }
+        else {
+            return obj;
         }
-        return obj;
     }
-    async getObj(objId) {
-        const obj = await this.getObjNonArchOrThrow(objId);
-        const currentVer = obj.getCurrentVersionOrThrow();
-        return obj.getObjSrc(currentVer);
+    async getObjSrc(objId, version, allowArchived = false) {
+        const obj = await this.getObjOrThrow(objId, allowArchived);
+        if (!version) {
+            version = obj.statusObj().getCurrentLocalOrSynced();
+        }
+        return obj.getObjSrcFromLocalAndSyncedBranch(version);
     }
-    async getRemoteConflictObjVersion(objId, version) {
-        const obj = await this.getObjNonArchOrThrow(objId);
-        return obj.getRemoteConflictObjVersion(version);
+    async getObjSrcOfRemoteVersion(objId, version) {
+        const obj = await this.getObjOrThrow(objId);
+        return obj.getObjSrcFromRemoteAndSyncedBranch(version);
     }
     async saveObj(objId, version, encSub) {
         if (version === 1) {
             const obj = await this.files.findObj(objId);
             if (obj) {
-                throw exceptions_1.makeObjExistsExc(objId);
+                throw (0, exceptions_1.makeObjExistsExc)(objId);
             }
-            const { fileWrite$, newObj } = await this.files.saveFirstVersion(objId, encSub);
-            await fileWrite$
-                .pipe(this.uploader.tapFileWrite(newObj, true, version))
-                .toPromise();
+            const { fileWrite$ } = await this.files.saveFirstVersion(objId, encSub);
+            await fileWrite$.toPromise();
         }
         else {
-            const obj = await this.files.findObj(objId);
-            if (!obj) {
-                throw exceptions_1.makeObjNotFoundExc(objId);
-            }
-            const { fileWrite$, baseVer } = await obj.saveNewVersion(version, encSub);
-            await fileWrite$
-                .pipe(this.uploader.tapFileWrite(obj, false, version, baseVer))
-                .toPromise();
+            const obj = await this.getObjOrThrow(objId);
+            const { fileWrite$ } = await obj.saveNewVersion(version, encSub);
+            await fileWrite$.toPromise();
         }
     }
     async removeObj(objId) {
-        const obj = await this.files.findObj(objId);
+        const obj = await this.getObjOrThrow(objId)
+            .catch((exc) => {
+            if (!exc.objNotFound) {
+                throw exc;
+            }
+        });
         if (!obj) {
             return;
         }
         await obj.removeCurrentVersion();
-        await this.uploader.removeCurrentVersionOf(obj);
     }
     async close() {
         try {

package/build/core/storage/synced/upload-header-file.d.ts

@@ -0,0 +1,4 @@
+import { UploadHeaderChange } from "../../../lib-client/3nstorage/xsp-fs/common";
+export declare const UPLOAD_HEADER_FILE_NAME_EXT = "upload";
+export declare function saveUploadHeaderFile(objFolder: string, headers: UploadHeaderChange): Promise<void>;
+export declare function readUploadHeaderFromFile(objFolder: string, uploadVersion: number): Promise<UploadHeaderChange | undefined>;

package/build/core/storage/synced/upload-header-file.js

@@ -0,0 +1,64 @@
+"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.readUploadHeaderFromFile = exports.saveUploadHeaderFile = exports.UPLOAD_HEADER_FILE_NAME_EXT = void 0;
+const path_1 = require("path");
+const async_fs_node_1 = require("../../../lib-common/async-fs-node");
+const file_1 = require("../../../lib-common/exceptions/file");
+const big_endian_1 = require("../../../lib-common/big-endian");
+const assert_1 = require("../../../lib-common/assert");
+exports.UPLOAD_HEADER_FILE_NAME_EXT = 'upload';
+async function saveUploadHeaderFile(objFolder, headers) {
+    const bytes = packUploadHeaderChange(headers);
+    await (0, async_fs_node_1.writeFile)(uploadHeaderFilePath(objFolder, headers.uploadVersion), bytes);
+}
+exports.saveUploadHeaderFile = saveUploadHeaderFile;
+async function readUploadHeaderFromFile(objFolder, uploadVersion) {
+    try {
+        const bytes = await (0, async_fs_node_1.readFile)(uploadHeaderFilePath(objFolder, uploadVersion));
+        return unpackUploadHeaderChange(bytes);
+    }
+    catch (exc) {
+        if (exc.code !== file_1.Code.notFound) {
+            throw exc;
+        }
+    }
+}
+exports.readUploadHeaderFromFile = readUploadHeaderFromFile;
+function uploadHeaderFilePath(objFolder, uploadVersion) {
+    return (0, path_1.join)(objFolder, `${uploadVersion}.${exports.UPLOAD_HEADER_FILE_NAME_EXT}`);
+}
+function packUploadHeaderChange({ localHeader, localVersion, uploadHeader, uploadVersion }) {
+    (0, assert_1.assert)(localHeader.length === uploadHeader.length);
+    const bytes = Buffer.allocUnsafe(16 + 2 * localHeader.length);
+    (0, big_endian_1.packUintTo8Bytes)(localVersion, bytes, 0);
+    (0, big_endian_1.packUintTo8Bytes)(uploadVersion, bytes, 8);
+    bytes.set(localHeader, 16);
+    bytes.set(uploadHeader, 16 + localHeader.length);
+    return bytes;
+}
+function unpackUploadHeaderChange(bytes) {
+    const localVersion = (0, big_endian_1.uintFrom8Bytes)(bytes, 0);
+    const uploadVersion = (0, big_endian_1.uintFrom8Bytes)(bytes, 8);
+    const headerLen = (bytes.length - 16) / 2;
+    (0, assert_1.assert)(Number.isInteger(headerLen));
+    const localHeader = bytes.slice(16, 16 + headerLen);
+    const uploadHeader = bytes.slice(16 + headerLen);
+    return { localHeader, localVersion, uploadHeader, uploadVersion };
+}
+Object.freeze(exports);

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

@@ -3,20 +3,25 @@ import { SyncedObj } from "./obj-files";
 import { MonoTypeOperatorFunction } from "rxjs";
 import { FileWrite } from "../../../lib-client/objs-on-disk/file-writing-proc";
 import { LogError } from "../../../lib-client/logging/log-to-file";
-import { UpSyncTaskInfo } from "./obj-status";
-import { ObjId } from "../../../lib-client/3nstorage/xsp-fs/common";
+import { NewVersionUpload } from "./obj-status";
 export declare type FileWriteTapOperator = MonoTypeOperatorFunction<FileWrite[]>;
-export declare type BroadcastUpSyncEvent = (objId: ObjId, task: UpSyncTaskInfo) => void;
 export declare class UpSyncer {
     private readonly remoteStorage;
     private readonly logError;
-    private readonly broadcastUpSyncEvent;
     private readonly execPools;
-    private readonly uploads;
-    constructor(remoteStorage: StorageOwner, logError: LogError, broadcastUpSyncEvent: BroadcastUpSyncEvent);
-    private getOrMakeUploadsFor;
+    constructor(remoteStorage: StorageOwner, logError: LogError);
     start(): void;
     stop(): Promise<void>;
+    /**
+     * Creates an rxjs operator to tap saving process, starting upload while
+     * writing is ongoing.
+     */
     tapFileWrite(obj: SyncedObj, isNew: boolean, newVersion: number, baseVersion?: number): FileWriteTapOperator;
     removeCurrentVersionOf(obj: SyncedObj): Promise<void>;
+    uploadFromDisk(obj: SyncedObj, localVersion: number, uploadVersion: number, uploadHeader: Uint8Array | undefined, syncedBase: number | undefined, createOnRemote: boolean): Promise<void>;
+}
+export interface UploadStatusRecorder {
+    recordUploadStart(info: NewVersionUpload): Promise<void>;
+    recordUploadCancellation(info: NewVersionUpload): Promise<void>;
+    recordUploadInterimState(info: NewVersionUpload): Promise<void>;
 }