socket-function 1.1.18 → 1.1.20

package/SocketFunction.ts

@@ -16,7 +16,7 @@ import "./SetProcessVariables";
 import cborx from "cbor-x";
 import { setFlag } from "./require/compileFlags";
 import { isNode } from "./src/misc";
-import { getPendingCallCount, harvestCallTimes, harvestFailedCallCount, registerOwnReconnectionUrl } from "./src/CallFactory";
+import { getPendingCallCount, harvestCallTimes, harvestFailedCallCount } from "./src/CallFactory";
 import { measureWrap } from "./src/profiling/measure";
 
 setFlag(require, "cbor-x", "allowclient", true);

package/index.d.ts

@@ -495,7 +495,6 @@ declare module "socket-function/src/CallFactory" {
     }
     type InitializeState = {
         supportsLZ4?: boolean;
-        ownReconnectionUrl?: string;
     };
     export declare function harvestFailedCallCount(): number;
     export declare function getPendingCallCount(): number;
@@ -504,7 +503,6 @@ declare module "socket-function/src/CallFactory" {
         end: number;
     }[];
     export declare function createCallFactory(webSocketBase: SenderInterface | undefined, nodeId: string, localNodeId?: string): Promise<CallFactory>;
-    export declare function registerOwnReconnectionUrl(url: string): void;
     export {};
 
 }
@@ -1267,16 +1265,11 @@ declare module "socket-function/src/profiling/tcpLagProxy" {
 }
 
 declare module "socket-function/src/promiseRace" {
-    export declare class PromiseLessLeaky<T> extends Promise<T> {
-        constructor(executor: ((resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void) | undefined);
-    }
-    /** A promise race function which doesn't leak, unlike Promise.race
-
-        See https://github.com/nodejs/node/issues/17469
-        See https://bugs.chromium.org/p/v8/issues/detail?id=9858#c9
-
+    /** Fixed Promise.race, which doesn't leak promises values. Promises still leak the Promise object themselves, but a Promise is < 100 bytes, where as the promise VALUE might be arbitrarily large.
      */
-    export declare function promiseRace<T extends readonly unknown[] | []>(promises: T): Promise<Awaited<T[number]>>;
+    export declare function PromiseRace<T extends any[]>(promises: {
+        [K in keyof T]: Promise<T[K]>;
+    }): Promise<T[number]>;
 
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "socket-function",
-	"version": "1.1.18",
+	"version": "1.1.20",
 	"main": "index.js",
 	"license": "MIT",
 	"dependencies": {

package/src/CallFactory.d.ts

@@ -34,7 +34,6 @@ export interface SenderInterface {
 }
 type InitializeState = {
     supportsLZ4?: boolean;
-    ownReconnectionUrl?: string;
 };
 export declare function harvestFailedCallCount(): number;
 export declare function getPendingCallCount(): number;
@@ -43,5 +42,4 @@ export declare function harvestCallTimes(): {
     end: number;
 }[];
 export declare function createCallFactory(webSocketBase: SenderInterface | undefined, nodeId: string, localNodeId?: string): Promise<CallFactory>;
-export declare function registerOwnReconnectionUrl(url: string): void;
 export {};

package/src/CallFactory.ts

@@ -78,7 +78,6 @@ export interface SenderInterface {
 
 type InitializeState = {
     supportsLZ4?: boolean;
-    ownReconnectionUrl?: string;
 };
 
 const INITIALIZE_STATE_SEQ_NUM = -1;
@@ -112,8 +111,7 @@ export async function createCallFactory(
     // The node id we are connecting to (or that connected to us)
     nodeId: string,
     // The node id that we were contacted on
-    // NOTE: This used to default to empty string, which would be the case if we made the connection. But this caused problems when we want it to stop making two connections per server and reuse the connection if both the servers want it to talk to each other. I guess we can default it to our reconnection URL. I mean, how else are people going to connect to us other than that?
-    localNodeId = ownReconnectionUrl || "",
+    localNodeId = "",
 ): Promise<CallFactory> {
     let niceConnectionName = nodeId;
 
@@ -560,28 +558,9 @@ export async function createCallFactory(
         if (call.isReturn) {
             if (!SocketFunction.LEGACY_INITIALIZE && call.seqNum === INITIALIZE_STATE_SEQ_NUM) {
                 callFactory.receivedInitializeState = call.result as InitializeState;
-                let otherReconnectionUrl = callFactory.receivedInitializeState.ownReconnectionUrl;
-                callFactory.realNodeId = otherReconnectionUrl;
                 if (SocketFunction.logMessages) {
                     console.log(green(`Received initialize state from ${callFactory.realNodeId} (for ${nodeId}) at ${Date.now()}`));
                 }
-                if (otherReconnectionUrl && !canReconnect && !!getNodeIdLocation(otherReconnectionUrl) && otherReconnectionUrl !== ownReconnectionUrl) {
-                    if (changeNodeId({
-                        originalNodeId: nodeId,
-                        newNodeId: otherReconnectionUrl,
-                        callFactory,
-                    })) {
-                        if (SocketFunction.logMessages) {
-                            console.log(green(`Changed node id from ${nodeId} to ${otherReconnectionUrl}`));
-                        }
-                        nodeId = otherReconnectionUrl;
-                        niceConnectionName = otherReconnectionUrl;
-                        callerContext.nodeId = nodeId;
-                        canReconnect = !!getNodeIdLocation(nodeId);
-                        callFactory.nodeId = nodeId;
-                        callFactory.connectionId = { nodeId };
-                    }
-                }
                 return;
             }
             let callbackObj = pendingCalls.get(call.seqNum);
@@ -794,7 +773,6 @@ export async function createCallFactory(
     if (!SocketFunction.LEGACY_INITIALIZE) {
         let initState: InitializeState = {
             supportsLZ4: true,
-            ownReconnectionUrl,
         };
         let initReturn: InternalReturnType = {
             isReturn: true,
@@ -814,11 +792,6 @@ export async function createCallFactory(
     return callFactory;
 }
 
-let ownReconnectionUrl: string | undefined;
-export function registerOwnReconnectionUrl(url: string) {
-    ownReconnectionUrl = url;
-}
-
 
 let uncompressedSent = 0;
 let compressedSent = 0;

package/src/promiseRace.d.ts

@@ -1,10 +1,5 @@
-export declare class PromiseLessLeaky<T> extends Promise<T> {
-    constructor(executor: ((resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void) | undefined);
-}
-/** A promise race function which doesn't leak, unlike Promise.race
-
-    See https://github.com/nodejs/node/issues/17469
-    See https://bugs.chromium.org/p/v8/issues/detail?id=9858#c9
-
+/** Fixed Promise.race, which doesn't leak promises values. Promises still leak the Promise object themselves, but a Promise is < 100 bytes, where as the promise VALUE might be arbitrarily large.
  */
-export declare function promiseRace<T extends readonly unknown[] | []>(promises: T): Promise<Awaited<T[number]>>;
+export declare function PromiseRace<T extends any[]>(promises: {
+    [K in keyof T]: Promise<T[K]>;
+}): Promise<T[number]>;

package/src/promiseRace.ts

@@ -1,184 +1,110 @@
-
-// Less leaky promise.
-//  See https://github.com/nodejs/node/issues/17469
-//  See https://bugs.chromium.org/p/v8/issues/detail?id=9858#c9
-// Basically, make resolve/reject weakly reference the Promise, so that
-//  resolved promises aren't kept alive. The `resolve` function is still leaked
-//  itself, but at least it doesn't leak the underlying data.
-export class PromiseLessLeaky<T> extends Promise<T> {
-    constructor(executor: ((
-        resolve: (value: T | PromiseLike<T>) => void,
-        reject: (reason?: any) => void
-    ) => void) | undefined
-    ) {
-        super(((
-            resolve: ((value: T | PromiseLike<T>) => void) | undefined,
-            reject: ((reason?: any) => void) | undefined
-        ) => {
-            executor?.(
-                function PromiseLessLeakyResolved(value) {
-                    let callback = resolve;
-                    resolve = undefined;
-                    reject = undefined;
-                    if (callback) {
-                        callback(value);
-                    }
-                },
-                function PromiseLessLeakyRejected(value) {
-                    let callback = reject;
-                    resolve = undefined;
-                    reject = undefined;
-                    if (callback) {
-                        callback(value);
-                    }
-                }
-            );
-            executor = undefined;
-        }));
-    }
-}
-function remove<T>(list: T[], value: T) {
-    let index = list.indexOf(value);
-    if (index >= 0) {
-        list.splice(index, 1);
-    }
-}
-const promiseCallbacks = new WeakMap<object, {
-    onResolve: ((value: any) => void)[];
-    onReject: ((value: any) => void)[];
-    onFinally: (() => void)[];
-}>();
-/** A promise race function which doesn't leak, unlike Promise.race
-
-    See https://github.com/nodejs/node/issues/17469
-    See https://bugs.chromium.org/p/v8/issues/detail?id=9858#c9
-
+/** Fixed Promise.race, which doesn't leak promises values. Promises still leak the Promise object themselves, but a Promise is < 100 bytes, where as the promise VALUE might be arbitrarily large.
  */
-export function promiseRace<T extends readonly unknown[] | []>(promises: T): Promise<Awaited<T[number]>> {
-    return new PromiseLessLeaky((resolve, reject) => {
-        let actualPromises: Promise<unknown>[] = [];
+export function PromiseRace<T extends any[]>(promises: { [K in keyof T]: Promise<T[K]> }): Promise<T[number]> {
+    return new PromiseLessLeaky((resolve: any, reject: any) => {
         function onFinally() {
-            for (let promise of actualPromises) {
-                let callbackObj = promiseCallbacks.get(promise);
-                if (!callbackObj) continue;
-                remove(callbackObj.onResolve, resolve);
-                remove(callbackObj.onReject, reject);
-                remove(callbackObj.onFinally, onFinally);
+            for (let promise of promises) {
+                if (promise && typeof promise === "object" && promise instanceof Promise) {
+                    let callbackObj = promiseCallbacks.get(promise);
+                    if (!callbackObj) continue;
+                    remove(callbackObj.onResolve, resolve);
+                    remove(callbackObj.onReject, reject);
+                    remove(callbackObj.onFinally, onFinally);
+                }
             }
         }
         for (let promise of promises) {
-            // If not a thenable, use Promise.resolve to make it a promise, and use the build in functions, as it won't hold a reference because it will resolve immediately.
-            if (!(promise && (typeof promise === "object" || typeof promise === "function") && ("then" in promise))) {
-                Promise.resolve(promise).then(resolve as any, reject);
+            // NOTE: This "if" statement greatly reduce leaks, although it might
+            //  reduce speed as well?
+            if (promise && typeof promise === "object" && promise instanceof Promise) {
+                let callbackObj = promiseCallbacks.get(promise);
+                let firstSetup = false;
+                if (!callbackObj) {
+                    firstSetup = true;
+                    callbackObj = {
+                        onResolve: [],
+                        onReject: [],
+                        onFinally: [],
+                    };
+                    promiseCallbacks.set(promise, callbackObj);
+                }
+                callbackObj.onResolve.push(resolve);
+                callbackObj.onReject.push(reject);
+                callbackObj.onFinally.push(onFinally);
+                // We need to delay this in case we're immediately triggered, because we're already resolved. 
+                if (firstSetup) {
+                    connectPromiseToCallbackObj(promise, callbackObj);
+                }
                 continue;
             }
-            actualPromises.push(promise as Promise<unknown>);
-            let callbackObj = promiseCallbacks.get(promise);
-            if (!callbackObj) {
-                callbackObj = {
-                    onResolve: [],
-                    onReject: [],
-                    onFinally: [],
-                };
-                promiseCallbacks.set(promise, callbackObj);
-                connectPromiseToCallbackObj(Promise.resolve(promise), callbackObj);
-            }
-            callbackObj.onResolve.push(resolve);
-            callbackObj.onReject.push(reject);
-            callbackObj.onFinally.push(onFinally);
+
+            void Promise.resolve(promise).then(resolve, reject);
         }
     }) as any;
-};
+}
 
-function connectPromiseToCallbackObj(promise: Promise<any>, callbackObj: {
-    onResolve: ((value: any) => void)[];
-    onReject: ((value: any) => void)[];
-    onFinally: (() => void)[];
-}) {
+function remove(list: any, value: any) {
+    let index = list.indexOf(value);
+    if (index >= 0) {
+        list.splice(index, 1);
+    }
+}
+const promiseCallbacks = new WeakMap();
+
+function connectPromiseToCallbackObj(promise: any, callbackObj: any) {
     // NOTE: If the promise stays alive forever... this will leak callbackObj. BUT,
     //  it is only called once per promise, ever, so... the leak isn't so bad!
     promise.then(
-        value => {
-            for (let fnc of callbackObj.onResolve) {
+        (value: any) => {
+            // We need to delete the callback lists once on finally happens. Because we only connect to the promise once, And so it'll only trigger us once. So removing it is the only way to get it to trigger us again if someone subscribes to a finished promise. 
+            promiseCallbacks.delete(promise);
+            for (let fnc of callbackObj.onResolve.slice()) {
                 try { fnc(value); } finally { }
             }
         },
-        value => {
-            for (let fnc of callbackObj.onReject) {
+        (value: any) => {
+            promiseCallbacks.delete(promise);
+            for (let fnc of callbackObj.onReject.slice()) {
                 try { fnc(value); } finally { }
             }
         }
     ).finally(() => {
-        for (let fnc of callbackObj.onFinally) {
+        for (let fnc of callbackObj.onFinally.slice()) {
             try { fnc(); } finally { }
         }
     });
 }
 
 
-async function main() {
-    const { formatTime } = await import("./formatting/format");
-    const os = require("os");
-    let count = 0;
-
-    // @ts-ignore
-    function createNamedObject(name) {
-        return eval(`(class ${name} {  
-            memory = (() => {
-                // let memory = new Float64Array(1024 * 1024);
-                // for (let i = 0; i < memory.length; i++) {
-                //     memory[i] = Math.random();
-                // }
-                // return memory;
-            })();
-        })`);
-    }
-    let LeakedTag = createNamedObject("LeakedTag");
-    let LeakedTag2 = createNamedObject("LeakedTag2");
-    function createPromiseObj<T>() {
-        let resolve!: ((value: T | PromiseLike<T>) => void);
-        let reject!: ((reason?: any) => void);
-        let promise = new Promise<T>((_resolve, _reject) => {
-            resolve = _resolve;
-            reject = _reject;
-        });
-        void promise.finally(() => {
-            (globalThis as any)["keepAliveValueTest"] = ((globalThis as any)["keepAliveValueTest"] || 0) + 1;
+// Less leaky promise.
+//  See https://github.com/nodejs/node/issues/17469
+//  See https://bugs.chromium.org/p/v8/issues/detail?id=9858#c9
+// Basically, make resolve/reject weakly reference the Promise, so that
+//  resolved promises aren't kept alive. The `resolve` function is still leaked
+//  itself, but at least it doesn't leak the underlying data.
+// IMPORTANT! This still leaks! So... maybe don't even use Promise.race?
+class PromiseLessLeaky extends Promise<any> {
+    constructor(executor: any) {
+        super((resolve, reject) => {
+            executor(
+                function PromiseLessLeakyResolved(value: any) {
+                    let callback = resolve;
+                    resolve = undefined as any;
+                    reject = undefined as any;
+                    if (callback) {
+                        callback(value);
+                    }
+                },
+                function PromiseLessLeakyRejected(value: any) {
+                    let callback = reject;
+                    resolve = undefined as any;
+                    reject = undefined as any;
+                    if (callback) {
+                        callback(value);
+                    }
+                }
+            );
+            executor = undefined;
         });
-        return {
-            promise,
-            resolve,
-            reject,
-        };
-    }
-
-    let exitPromiseObj = createPromiseObj<void>();
-    setTimeout(() => {
-        exitPromiseObj.resolve(undefined);
-    }, 1000 * 60 * 60);
-
-    async function doWork() {
-        return new LeakedTag();
-    }
-
-    // @ts-ignore
-    let createRace: (promises: Promise<any>[]) => Promise<any>;
-
-    // Leaks (you can see LeakedTag in the heap dump, and also usage goes to the moon)
-    //createRace = promises => Promise.race(promises);
-
-    // Doesn't leak
-    createRace = promises => promiseRace(promises);
-
-    let time = Date.now();
-
-    while (true) {
-        await createRace([doWork(), exitPromiseObj.promise]);
-        count++;
-        if (count % 100000 === 0) {
-            let duration = Date.now() - time;
-            console.log(`Did ${count} test runs, used memory is at ${(process.memoryUsage().heapUsed)}, time per count is ${formatTime(duration / count)}`);
-        }
     }
 }
-//void main();

package/src/webSocketServer.ts

@@ -5,7 +5,7 @@ import tls from "tls";
 import { getNodeIdsFromRequest, httpCallHandler } from "./callHTTPHandler";
 import { SocketFunction } from "../SocketFunction";
 import { getTrustedCertificates, watchTrustedCertificates } from "./certStore";
-import { createCallFactory, registerOwnReconnectionUrl } from "./CallFactory";
+import { createCallFactory } from "./CallFactory";
 import { parseSNIExtension, parseTLSHello, SNIType } from "./tlsParsing";
 import debugbreak from "debugbreak";
 import { getNodeId } from "./nodeCache";
@@ -351,7 +351,6 @@ export async function startSocketServer(
 
     let nodeId = getNodeId(getCommonName(config.cert), port);
     console.log(green(`Started Listening on ${nodeId} (${host}) after ${formatTime(process.uptime() * 1000)}`));
-    registerOwnReconnectionUrl(nodeId);
 
     return nodeId;
 }