core-3nweb-client-lib 0.26.0 → 0.26.1

package/build/ipc-via-protobuf/connector-clients-side.d.ts

@@ -16,9 +16,11 @@ export declare class ClientsSideImpl implements ClientsSide {
     processInterimCallReply(fnCallNum: number, body: EnvelopeBody): void;
     processEndCallReply(fnCallNum: number, body: EnvelopeBody): void;
     processCallError(fnCallNum: number, body: EnvelopeBody): void;
+    private retryWithOtherCallNum;
     private nextFnCallNum;
     caller(): Caller;
     private startCall;
+    private setupFnCall;
     startPromiseCall(path: string[], req: EnvelopeBody): Promise<EnvelopeBody>;
     startObservableCall(path: string[], req: EnvelopeBody, obs: Subject<EnvelopeBody>): () => void;
     registerClientDrop(o: any, srvRef: ObjectReference<any>): void;

package/build/ipc-via-protobuf/connector-clients-side.js

@@ -21,6 +21,7 @@ const protobuf_msg_1 = require("./protobuf-msg");
 const deferred_1 = require("../lib-common/processes/deferred");
 const weakref_1 = require("../lib-common/weakref");
 const connector_1 = require("./connector");
+const MAX_DUPLICATE_ATTEMPTS = 100;
 // XXX can have an optimized use of WeakRef and FinalizationRegistry, when
 // these are available.
 class ClientsSideImpl {
@@ -104,7 +105,13 @@ class ClientsSideImpl {
         if (!call) {
             return;
         }
+        this.fnCalls.delete(fnCallNum);
         const err = (body ? protobuf_msg_1.errFromMsg(protobuf_msg_1.errBodyType.unpack(body)) : undefined);
+        if (err && (err.type === 'ipc')
+            && err.duplicateFnCallNum) {
+            this.retryWithOtherCallNum(call);
+            return;
+        }
         if (call.obs) {
             call.obs.error(err);
         }
@@ -114,7 +121,32 @@ class ClientsSideImpl {
         else {
             // XXX log presence of fn call without fields to signal reply
         }
-        this.fnCalls.delete(fnCallNum);
+    }
+    retryWithOtherCallNum(call) {
+        if (call.countOfDuplicateFnCallNum) {
+            call.countOfDuplicateFnCallNum += 1;
+            if (call.countOfDuplicateFnCallNum >= MAX_DUPLICATE_ATTEMPTS) {
+                return;
+            }
+        }
+        else {
+            call.countOfDuplicateFnCallNum = 1;
+        }
+        const fnCallNum = this.nextFnCallNum();
+        call.reqEnv.headers.fnCallNum.value = fnCallNum;
+        this.fnCalls.set(fnCallNum, call);
+        try {
+            this.sendMsg(call.reqEnv);
+        }
+        catch (err) {
+            this.fnCalls.delete(fnCallNum);
+            if (call.deferred) {
+                call.deferred.reject(err);
+            }
+            else if (call.obs) {
+                call.obs.error(err);
+            }
+        }
     }
     nextFnCallNum() {
         while (this.fnCalls.has(this.fnCallCounter)) {
@@ -141,21 +173,27 @@ class ClientsSideImpl {
         };
         return callerWrap;
     }
-    startCall(fnCallNum, path, body) {
+    startCall(reqEnv) {
         if (this.isStopped) {
             throw connector_1.makeIPCException({ 'ipcNotConnected': true });
         }
-        this.sendMsg({
+        this.sendMsg(reqEnv);
+    }
+    setupFnCall(path, body, deferred, obs) {
+        const fnCallNum = this.nextFnCallNum();
+        const reqEnv = {
             headers: { fnCallNum: protobuf_msg_1.toVal(fnCallNum), msgType: 'start', path },
             body: protobuf_msg_1.toOptVal(body)
-        });
+        };
+        this.fnCalls.set(fnCallNum, { deferred, obs, reqEnv });
+        return reqEnv;
     }
     startPromiseCall(path, req) {
         const deferred = deferred_1.defer();
-        const fnCallNum = this.nextFnCallNum();
-        this.fnCalls.set(fnCallNum, { deferred });
+        const reqEnv = this.setupFnCall(path, req, deferred, undefined);
+        const fnCallNum = reqEnv.headers.fnCallNum.value;
         try {
-            this.startCall(fnCallNum, path, req);
+            this.startCall(reqEnv);
             return deferred.promise;
         }
         catch (err) {
@@ -164,10 +202,10 @@ class ClientsSideImpl {
         }
     }
     startObservableCall(path, req, obs) {
-        const fnCallNum = this.nextFnCallNum();
-        this.fnCalls.set(fnCallNum, { obs });
+        const reqEnv = this.setupFnCall(path, req, undefined, obs);
+        const fnCallNum = reqEnv.headers.fnCallNum.value;
         try {
-            this.startCall(fnCallNum, path, req);
+            this.startCall(reqEnv);
             return () => this.sendCallCancellation(fnCallNum);
         }
         catch (err) {