core-3nweb-client-lib 0.43.5 → 0.43.7

package/build/api-defs/files.d.ts

@@ -169,6 +169,7 @@ declare namespace web3n.files {
 		local?: LocalVersion;
 		remote?: SyncVersionsBranch;
 		existsInSyncedParent?: boolean;
+		uploading?: UploadingState;
 	}
 
 	interface LocalVersion {
@@ -184,6 +185,24 @@ declare namespace web3n.files {
 
 	type SyncState = 'synced' | 'behind' | 'unsynced' | 'conflicting';
 
+	interface UploadingState {
+		/**
+		 * Local version that is uploaded to server.
+		 * If it is an upload of object removal, version is -1.
+		 */
+		localVersion: number;
+		/**
+		 * New remote version that is uploaded to server.
+		 * If it is an upload of object removal, version is -1.
+		 */
+		remoteVersion: number;
+		/**
+		 * Bytes left to upload.
+		 */
+		bytesLeftToUpload: number;
+		uploadStarted: boolean;
+	}
+
 	interface FileByteSource {
 
 		/**

package/build/core/asmail/inbox/inbox-events.d.ts

@@ -29,18 +29,13 @@ export declare class InboxEvents {
     private readonly newMsg$;
     private readonly connectionEvents;
     readonly connectionEvent$: Observable<InboxConnectionStatus>;
-    private listeningProc;
-    private networkActive;
+    private readonly wsProc;
     private disconnectedAt;
     constructor(msgReceiver: MailRecipient, getMsg: (msgId: string) => Promise<IncomingMessage>, listNewMsgs: (fromTS: number) => Promise<MsgInfo[]>, rmMsg: (msgId: string) => Promise<void>, logError: LogError);
-    private startListening;
-    private sleepAndRestart;
+    private makeProc;
     private getMessage;
     subscribe<T>(event: InboxEventType, observer: Observer<T>): () => void;
     close(): void;
-    get isListening(): boolean;
-    private shouldRestartAfterErr;
-    private stopListening;
     suspendNetworkActivity(): void;
     resumeNetworkActivity(): void;
     private listMsgsFromDisconnectedPeriod;

package/build/core/asmail/inbox/inbox-events.js

@@ -22,7 +22,6 @@ const retrieval_1 = require("../../../lib-common/service-api/asmail/retrieval");
 const operators_1 = require("rxjs/operators");
 const utils_for_observables_1 = require("../../../lib-common/utils-for-observables");
 const ws_ipc_1 = require("../../../lib-common/ipc/ws-ipc");
-const sleep_1 = require("../../../lib-common/processes/sleep");
 function toInboxConnectionStatus(status, params) {
     return (0, ws_ipc_1.addToStatus)(status, {
         service: 'inbox',
@@ -52,54 +51,30 @@ class InboxEvents {
         this.newMsg$ = this.newMsgs.asObservable().pipe((0, operators_1.share)());
         this.connectionEvents = new rxjs_1.Subject();
         this.connectionEvent$ = this.connectionEvents.asObservable().pipe((0, operators_1.share)());
-        this.listeningProc = undefined;
-        this.networkActive = true;
         this.disconnectedAt = undefined;
-        this.startListening();
+        this.wsProc = new ws_ipc_1.WebSocketListening(SERVER_EVENTS_RESTART_WAIT_SECS, this.makeProc.bind(this));
+        this.wsProc.startListening();
         Object.seal(this);
     }
-    startListening() {
-        if (this.listeningProc || !this.networkActive) {
-            return;
-        }
-        const clearListeningProc = () => {
-            if (this.listeningProc === sub) {
-                this.listeningProc = undefined;
-            }
-            if (!this.disconnectedAt) {
-                this.disconnectedAt = Date.now();
-            }
-        };
-        const sub = (0, rxjs_1.from)(this.msgReceiver.openEventSource().then(({ client, heartbeat }) => {
+    makeProc() {
+        const proc$ = (0, rxjs_1.from)(this.msgReceiver.openEventSource().then(({ client, heartbeat }) => {
             const channel = retrieval_1.msgRecievedCompletely.EVENT_NAME;
             heartbeat.subscribe({
                 next: ev => this.connectionEvents.next(toInboxConnectionStatus(ev))
             });
             return new rxjs_1.Observable(obs => client.subscribe(channel, obs));
         }))
-            .pipe((0, operators_1.mergeMap)(events => events), (0, operators_1.mergeMap)(async (ev) => this.getMessage(ev.msgId), 5))
-            .subscribe({
-            next: msg => {
-                if (msg) {
-                    this.newMsgs.next(msg);
-                }
-            },
-            complete: () => {
-                clearListeningProc();
-            },
-            error: async (exc) => {
-                clearListeningProc();
-                if (this.shouldRestartAfterErr(exc)) {
-                    this.sleepAndRestart();
+            .pipe((0, operators_1.mergeMap)(events => events), (0, operators_1.mergeMap)(async (ev) => this.getMessage(ev.msgId), 5), (0, operators_1.filter)(msg => !!msg), (0, operators_1.tap)({
+            next: msg => this.newMsgs.next(msg),
+            error: () => {
+                if (!this.disconnectedAt) {
+                    this.disconnectedAt = Date.now();
                 }
             }
-        });
-        this.listeningProc = sub;
+        }));
+        // list messages as a side effect of starting, or at point of starting.
         this.listMsgsFromDisconnectedPeriod();
-    }
-    async sleepAndRestart() {
-        await (0, sleep_1.sleep)(SERVER_EVENTS_RESTART_WAIT_SECS);
-        this.startListening();
+        return proc$;
     }
     async getMessage(msgId) {
         try {
@@ -123,45 +98,26 @@ class InboxEvents {
     }
     close() {
         this.newMsgs.complete();
+        this.wsProc.close();
     }
-    get isListening() {
-        return !!this.listeningProc;
-    }
-    shouldRestartAfterErr(exc) {
-        if (!exc.runtimeException) {
-            return false;
-        }
-        if (exc.type === 'connect') {
-            return true;
-        }
-        else if (exc.type === 'http-request') {
-            return false;
-        }
-        else if (exc.type === 'websocket') {
-            return true;
-        }
-        else {
-            return false;
-        }
-    }
-    stopListening() {
-        var _a;
-        (_a = this.listeningProc) === null || _a === void 0 ? void 0 : _a.unsubscribe();
-        this.listeningProc = undefined;
-    }
+    // XXX we should go along:
+    //  - last working connection and ping
+    //  - may be have an expect suspending of network, with less aggressive attempts to reconnect
+    //  - instead of talking about presence of network, expose methods to nudge restarting behaviour, as outside
+    //    may have better clues and able to command behaviour switch
     suspendNetworkActivity() {
-        this.networkActive = false;
-        if (this.isListening) {
-            if (!this.disconnectedAt) {
-                this.disconnectedAt = Date.now();
-            }
-            this.stopListening();
-        }
+        // XXX code below shutdown for good, but restart sometimes has been failing.
+        // 
+        // if (this.isListening) {
+        // 	if (!this.disconnectedAt) {
+        // 		this.disconnectedAt = Date.now();
+        // 	}
+        // 	this.stopListening();
+        // }
     }
     resumeNetworkActivity() {
-        this.networkActive = true;
-        if (!this.isListening) {
-            this.startListening();
+        if (!this.wsProc.isListening) {
+            this.wsProc.startListening();
         }
     }
     async listMsgsFromDisconnectedPeriod() {
@@ -178,9 +134,6 @@ class InboxEvents {
                     this.newMsgs.next(msg);
                     this.disconnectedAt = msg.deliveryTS;
                 }
-                else if (!this.networkActive) {
-                    return;
-                }
             }
             this.disconnectedAt = undefined;
         }

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

@@ -48,16 +48,37 @@ export interface RemovalUpload {
 export interface WholeVerOrderedUpload {
     type: 'ordered-whole';
     createObj?: boolean;
+    /**
+     * Header bytes that need to be uploaded. Undefined when header has been uploaded.
+     */
     header?: number;
+    /**
+     * Segments bytes left to upload.
+     */
     segsLeft: number;
+    /**
+     * Offset in segments, to which point bytes where uploaded.
+     */
     segsOfs: number;
+    /**
+     * Upload transaction id.
+     */
     transactionId?: string;
 }
 export interface DiffVerOrderedUpload {
     type: 'ordered-diff';
     diff: DiffInfo;
+    /**
+     * Header bytes that need to be uploaded. Undefined when header has been uploaded.
+     */
     header?: number;
+    /**
+     * New chunks of segments that should be uploaded.
+     */
     newSegsLeft: FiniteChunk[];
+    /**
+     * Upload transaction id.
+     */
     transactionId?: string;
 }
 export interface BytesSection {

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

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2016 - 2020, 2022 3NSoft Inc.
+ Copyright (C) 2016 - 2020, 2022, 2025 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
@@ -494,7 +494,8 @@ class ObjStatus {
             state: this.stateIndicator,
             local: localVersionFromStatus(this.status.local),
             remote,
-            synced
+            synced,
+            uploading: uploadInStatus(this.status.upload)
         };
     }
     neverUploaded() {
@@ -674,4 +675,46 @@ function skipNotFoundExc(exc) {
         throw exc;
     }
 }
+function uploadInStatus(upload) {
+    if (!upload) {
+        return;
+    }
+    if (upload.type === 'new-version') {
+        const { needUpload } = upload;
+        if (!needUpload) {
+            return;
+        }
+        let bytesLeftToUpload = 0;
+        if (needUpload.type === 'ordered-whole') {
+            const { header, segsLeft } = needUpload;
+            if (header) {
+                bytesLeftToUpload += header;
+            }
+            bytesLeftToUpload += segsLeft;
+        }
+        else if (needUpload.type === 'ordered-diff') {
+            const { header, newSegsLeft } = needUpload;
+            if (header) {
+                bytesLeftToUpload += header;
+            }
+            for (const { len: chunkLen } of newSegsLeft) {
+                bytesLeftToUpload += chunkLen;
+            }
+        }
+        return {
+            localVersion: upload.localVersion,
+            remoteVersion: upload.uploadVersion,
+            bytesLeftToUpload,
+            uploadStarted: !!needUpload.transactionId
+        };
+    }
+    else {
+        return {
+            localVersion: -1,
+            remoteVersion: -1,
+            bytesLeftToUpload: 0,
+            uploadStarted: false
+        };
+    }
+}
 Object.freeze(exports);

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

@@ -18,9 +18,10 @@ export declare class RemoteEvents {
     private readonly logError;
     private readonly connectionEvents;
     readonly connectionEvent$: Observable<StorageConnectionStatus>;
+    private readonly wsProc;
     constructor(remoteStorage: StorageOwner, files: ObjFiles, broadcastNodeEvent: Storage['broadcastNodeEvent'], logError: LogError);
-    private absorbingRemoteEventsProc;
-    startAbsorbingRemoteEvents(): void;
+    private makeProc;
+    startListening(): void;
     close(): Promise<void>;
     private absorbObjChange;
     private absorbObjRemoval;

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

@@ -33,6 +33,7 @@ const SERVER_EVENTS_RESTART_WAIT_SECS = 5;
  * events. Someone down the stream can react to these changes from remote.
  */
 class RemoteEvents {
+    // private listeningProc: Subscription|undefined = undefined;
     constructor(remoteStorage, files, broadcastNodeEvent, logError) {
         this.remoteStorage = remoteStorage;
         this.files = files;
@@ -40,11 +41,11 @@ class RemoteEvents {
         this.logError = logError;
         this.connectionEvents = new rxjs_1.Subject();
         this.connectionEvent$ = this.connectionEvents.asObservable().pipe((0, operators_1.share)());
-        this.absorbingRemoteEventsProc = undefined;
+        this.wsProc = new ws_ipc_1.WebSocketListening(SERVER_EVENTS_RESTART_WAIT_SECS, this.makeProc.bind(this));
         Object.seal(this);
     }
-    startAbsorbingRemoteEvents() {
-        this.absorbingRemoteEventsProc = (0, rxjs_1.from)(this.remoteStorage.openEventSource().then(({ client, heartbeat }) => {
+    makeProc() {
+        return (0, rxjs_1.from)(this.remoteStorage.openEventSource().then(({ client, heartbeat }) => {
             heartbeat.subscribe({
                 next: ev => this.connectionEvents.next(toStorageConnectionStatus(ev))
             });
@@ -56,23 +57,14 @@ class RemoteEvents {
                 // this.absorbArchVersionRemoval(client)
             ];
         }))
-            .pipe((0, operators_1.mergeMap)(event$ => event$), (0, operators_1.mergeMap)(event$ => event$))
-            .subscribe({
-            next: noop,
-            error: async (err) => {
-                await this.logError(err);
-                this.absorbingRemoteEventsProc = undefined;
-            },
-            complete: () => {
-                this.absorbingRemoteEventsProc = undefined;
-            }
-        });
+            .pipe((0, operators_1.mergeMap)(event$ => event$), (0, operators_1.mergeMap)(event$ => event$));
+    }
+    startListening() {
+        this.wsProc.startListening();
     }
     async close() {
-        if (this.absorbingRemoteEventsProc) {
-            this.absorbingRemoteEventsProc.unsubscribe();
-            this.absorbingRemoteEventsProc = undefined;
-        }
+        this.connectionEvents.complete();
+        this.wsProc.close();
     }
     absorbObjChange(client) {
         return (new rxjs_1.Observable(obs => client.subscribe(owner_1.events.objChanged.EVENT_NAME, obs)))
@@ -136,19 +128,22 @@ class RemoteEvents {
             });
         }, 1));
     }
+    // XXX we should go along:
+    //  - last working connection and ping
+    //  - may be have an expect suspending of network, with less aggressive attempts to reconnect
+    //  - instead of talking about presence of network, expose methods to nudge restarting behaviour, as outside
+    //    may have better clues and able to command behaviour switch
     suspendNetworkActivity() {
         // XXX
-        // - set haveNetwork flag to false
-        // - press breaks on events from server
+        // - ...
     }
     resumeNetworkActivity() {
-        // XXX
-        // - set haveNetwork flag to true
-        // - restart watching events from server
+        if (!this.wsProc.isListening) {
+            this.wsProc.startListening();
+        }
     }
 }
 exports.RemoteEvents = RemoteEvents;
 Object.freeze(RemoteEvents.prototype);
 Object.freeze(RemoteEvents);
-function noop() { }
 Object.freeze(exports);

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

@@ -51,7 +51,7 @@ class SyncedStore {
         return {
             syncedStore: (0, common_1.wrapSyncStorageImplementation)(s),
             startObjProcs: () => {
-                s.remoteEvents.startAbsorbingRemoteEvents();
+                s.remoteEvents.startListening();
             }
         };
     }
@@ -64,7 +64,7 @@ class SyncedStore {
             setupRemoteAndStartObjProcs: getSigner => {
                 setMid(getSigner);
                 s.uploader.start();
-                s.remoteEvents.startAbsorbingRemoteEvents();
+                s.remoteEvents.startListening();
             }
         };
     }

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

@@ -181,8 +181,7 @@ class UploadTask {
         }
     }
     async headerToUpload() {
-        return (this.uploadHeader ?
-            this.uploadHeader : await this.src.readHeader());
+        return (this.uploadHeader ? this.uploadHeader : await this.src.readHeader());
     }
     async startOrderedDiffUpload(upload) {
         const diff = buffer_utils_1.utf8.pack(JSON.stringify(upload.diff));

package/build/core-ipc/file.js

@@ -205,7 +205,8 @@ function syncStatusToMsg(s) {
         local: syncBranchToMsg(s.local),
         synced: syncBranchToMsg(s.synced),
         remote: syncBranchToMsg(s.remote),
-        existsInSyncedParent: (0, protobuf_msg_1.toOptVal)(s.existsInSyncedParent)
+        existsInSyncedParent: (0, protobuf_msg_1.toOptVal)(s.existsInSyncedParent),
+        uploading: uploadingToMsg(s.uploading)
     };
 }
 function msgToSyncStatus(m) {
@@ -217,7 +218,8 @@ function msgToSyncStatus(m) {
         local: msgToSyncBranch(m.local),
         synced: msgToSyncBranch(m.synced),
         remote: msgToSyncBranch(m.remote),
-        existsInSyncedParent: (0, protobuf_msg_1.valOfOpt)(m.existsInSyncedParent)
+        existsInSyncedParent: (0, protobuf_msg_1.valOfOpt)(m.existsInSyncedParent),
+        uploading: msgToUploading(m.uploading)
     };
 }
 function syncBranchToMsg(b) {
@@ -241,6 +243,28 @@ function msgToSyncBranch(m) {
         isArchived: (0, protobuf_msg_1.valOfOpt)(m.isArchived)
     };
 }
+function uploadingToMsg(u) {
+    if (!u) {
+        return;
+    }
+    return {
+        localVersion: (0, protobuf_msg_1.toVal)(u.localVersion),
+        remoteVersion: (0, protobuf_msg_1.toVal)(u.remoteVersion),
+        bytesLeftToUpload: (0, protobuf_msg_1.toVal)(u.bytesLeftToUpload),
+        uploadStarted: u.uploadStarted
+    };
+}
+function msgToUploading(u) {
+    if (!u) {
+        return;
+    }
+    return {
+        localVersion: (0, protobuf_msg_1.intValOf)(u.localVersion),
+        remoteVersion: (0, protobuf_msg_1.intValOf)(u.remoteVersion),
+        bytesLeftToUpload: (0, protobuf_msg_1.intValOf)(u.bytesLeftToUpload),
+        uploadStarted: u.uploadStarted
+    };
+}
 const syncStatusMsgType = protobuf_type_1.ProtoType.for(file_proto_1.file.SyncStatusMsg);
 function packSyncStatus(s) {
     return syncStatusMsgType.pack(syncStatusToMsg(s));