socket-function 1.1.4 → 1.1.6

package/SocketFunction.d.ts

@@ -29,6 +29,10 @@ export declare class SocketFunction {
         serialize: (obj: unknown) => MaybePromise<Buffer[]>;
         deserialize: (buffers: Buffer[]) => MaybePromise<unknown>;
     };
+    /** We will try the alternate node IDs first, however, if they fail, we will go through all of them and then eventually try the original node ID.
+     *      VERY useful, allowing us to change global ips to local ones, which short-circuits the router, massively increasing bandwidth and decreasing latency.
+     */
+    static GET_ALTERNATE_NODE_IDS: (nodeId: string) => MaybePromise<string[] | undefined>;
     static WIRE_WARN_TIME: number;
     private static onMountCallbacks;
     static exposedClasses: Set<string>;

package/SocketFunction.ts

@@ -17,6 +17,7 @@ import cborx from "cbor-x";
 import { setFlag } from "./require/compileFlags";
 import { isNode } from "./src/misc";
 import { getPendingCallCount, harvestCallTimes, harvestFailedCallCount } from "./src/CallFactory";
+import { measureWrap } from "./src/profiling/measure";
 
 setFlag(require, "cbor-x", "allowclient", true);
 let cborxInstance = new cborx.Encoder({ structuredClone: true });
@@ -71,11 +72,17 @@ export class SocketFunction {
     // In retrospect... dynamically changing the wire serializer is a BAD idea. If any calls happen
     //  before it is changed, things just break. Also, it needs to be changed on both sides,
     //  or else things break. Also, it is very hard to detect when the issue is different serializers
+    // NOTE: The only reason this is still exposed is in case in the future we want to intercept our traffic, and we want convenient functions to know how to decode it (although there are a still few other layers under this, for compression and Buffer[] sending efficiency).
     public static readonly WIRE_SERIALIZER = {
-        serialize: (obj: unknown): MaybePromise<Buffer[]> => [cborxInstance.encode(obj)],
-        deserialize: (buffers: Buffer[]): MaybePromise<unknown> => cborxInstance.decode(buffers[0]),
+        serialize: measureWrap((obj: unknown): MaybePromise<Buffer[]> => [cborxInstance.encode(obj)], "WIRE_SERIALIZER|serialize"),
+        deserialize: measureWrap((buffers: Buffer[]): MaybePromise<unknown> => cborxInstance.decode(buffers[0]), "WIRE_SERIALIZER|deserialize"),
     };
 
+    /** We will try the alternate node IDs first, however, if they fail, we will go through all of them and then eventually try the original node ID. 
+     *      VERY useful, allowing us to change global ips to local ones, which short-circuits the router, massively increasing bandwidth and decreasing latency.
+     */
+    public static GET_ALTERNATE_NODE_IDS = (nodeId: string): MaybePromise<string[] | undefined> => undefined;
+
     public static WIRE_WARN_TIME = 100;
 
     private static onMountCallbacks = new Map<string, (() => MaybePromise<void>)[]>();

package/index.d.ts

@@ -38,6 +38,10 @@ declare module "socket-function/SocketFunction" {
             serialize: (obj: unknown) => MaybePromise<Buffer[]>;
             deserialize: (buffers: Buffer[]) => MaybePromise<unknown>;
         };
+        /** We will try the alternate node IDs first, however, if they fail, we will go through all of them and then eventually try the original node ID.
+         *      VERY useful, allowing us to change global ips to local ones, which short-circuits the router, massively increasing bandwidth and decreasing latency.
+         */
+        static GET_ALTERNATE_NODE_IDS: (nodeId: string) => MaybePromise<string[] | undefined>;
         static WIRE_WARN_TIME: number;
         private static onMountCallbacks;
         static exposedClasses: Set<string>;
@@ -565,7 +569,7 @@ declare module "socket-function/src/args" {
 }
 
 declare module "socket-function/src/batching" {
-    import { AnyFunction } from "socket-function/src/types";
+    import { AnyFunction, MaybePromise } from "socket-function/src/types";
     export type DelayType = (number | "afterio" | "immediate" | "afterpromises" | "paintLoop" | "afterPaint");
     export declare function delay(delayTime: DelayType, immediateShortDelays?: "immediateShortDelays"): Promise<void>;
     export declare function batchFunctionNone<Arg, Result = void>(config: unknown, fnc: (arg: Arg[]) => (Promise<Result> | Result)): (arg: Arg) => Promise<Result>;
@@ -596,6 +600,13 @@ declare module "socket-function/src/batching" {
         minDelay?: number;
         maxDelay?: number;
     }): T;
+    export declare const safeLoop: typeof unblockLoop;
+    export declare const throttledLoop: typeof unblockLoop;
+    export declare function unblockLoop<T, R>(config: {
+        data: T[];
+        maxBlockingTime?: number;
+        backOffTime?: number;
+    } | T[], fnc: (item: T) => MaybePromise<R>): Promise<R[]>;
 
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "socket-function",
-	"version": "1.1.4",
+	"version": "1.1.6",
 	"main": "index.js",
 	"license": "MIT",
 	"dependencies": {
@@ -20,7 +20,6 @@
 		"type": "yarn tsc --noEmit",
 		"emit-dts": "yarn tsc --project tsconfig.declarations.json || exit 0",
 		"generate-index-dts": "node ./generateIndexDts.js",
-		"update-typings": "yarn generate-index-dts && yarn emit-dts",
 		"update-types": "yarn emit-dts && yarn generate-index-dts",
 		"prepublishOnly": "yarn update-types",
 		"testsni": "yarn typenode ./src/sniTest.ts"

package/src/CallFactory.ts

@@ -19,8 +19,6 @@ import { measureFnc, measureWrap, registerMeasureInfo } from "./profiling/measur
 import { MaybePromise } from "./types";
 import { Zip } from "./Zip";
 import { LZ4 } from "./lz4/LZ4";
-//LZ4.compress;
-//LZ4.decompress;
 
 setFlag(require, "pako", "allowclient", true);
 
@@ -269,7 +267,7 @@ export async function createCallFactory(
                         let arg = originalArgs[0] as any;
                         fncHack = `.${arg.DomainName}.${arg.ModuleId}.${arg.FunctionId}`;
                     }
-                    console.log(`SIZE\t${(formatNumberSuffixed(resultSize) + "B").padEnd(4, " ")}\tREMOTE CALL\t${call.classGuid}.${call.functionName}${fncHack} at ${Date.now()}`);
+                    console.log(`SIZE\t${(formatNumberSuffixed(resultSize) + `B`).padEnd(4, " ")}\t${formatNumber(data.length)} buffers\tREMOTE CALL\t${call.classGuid}.${call.functionName}${fncHack} at ${Date.now()}`);
                 }
             }
             // If sending OR resultPromise throws, we want to error out. This solves some issues with resultPromise
@@ -282,16 +280,22 @@ export async function createCallFactory(
     };
 
     let webSocketPromise: Promise<SenderInterface> | undefined;
+    let hasEverConnected = false;
     if (webSocketBase) {
         webSocketPromise = Promise.resolve(webSocketBase);
         await initializeWebsocket(webSocketBase);
     }
 
-    async function initializeWebsocket(newWebSocket: SenderInterface) {
+    async function initializeWebsocket(newWebSocket: SenderInterface, skipCloseHandling = false) {
         registerOnce();
         callFactory.receivedInitializeState = undefined;
 
         function onClose(error: string) {
+            // We try various connections, and if they fail, we will just try other node IDs until we finally do connect, and then we stick with that nodeId, and when it disconnects we need to handle disconnections normally.
+            if (skipCloseHandling && !hasEverConnected) {
+                return;
+            }
+
             callFactory.connectionId = { nodeId };
             callFactory.lastClosed = Date.now();
             callFactory.isConnected = false;
@@ -341,6 +345,7 @@ export async function createCallFactory(
                         console.log(`Connection established to ${niceConnectionName}`);
                     }
                     callFactory.isConnected = true;
+                    hasEverConnected = true;
                     resolve();
                 });
                 newWebSocket.addEventListener("close", () => resolve());
@@ -348,6 +353,7 @@ export async function createCallFactory(
             });
         } else if (newWebSocket.readyState === 1 /* OPEN */) {
             callFactory.isConnected = true;
+            hasEverConnected = true;
         } else {
             onClose(new Error(`Websocket received in closed state`).stack!);
         }
@@ -441,6 +447,23 @@ export async function createCallFactory(
         }
         lastConnectionAttempt = Date.now();
 
+        // Try alternates, and if any work, use them
+        try {
+            let alternates = await SocketFunction.GET_ALTERNATE_NODE_IDS(nodeId);
+            if (alternates) {
+                for (let alternateNodeId of alternates) {
+                    let newWebSocket = createWebsocket(alternateNodeId);
+                    await initializeWebsocket(newWebSocket, true);
+
+                    if (callFactory.isConnected) {
+                        return newWebSocket;
+                    }
+                }
+            }
+        } catch (e) {
+            console.error("Error getting alternate node IDs", e);
+        }
+
         let newWebSocket = createWebsocket(nodeId);
         await initializeWebsocket(newWebSocket);
 
@@ -449,6 +472,7 @@ export async function createCallFactory(
 
     let pendingCall: MessageHeader & {
         buffers: Buffer[];
+        firstReceivedTime?: number;
     } | undefined;
 
     async function processPendingCall() {
@@ -523,7 +547,6 @@ export async function createCallFactory(
         if (call.isReturn) {
             if (!SocketFunction.LEGACY_INITIALIZE && call.seqNum === INITIALIZE_STATE_SEQ_NUM) {
                 callFactory.receivedInitializeState = call.result as InitializeState;
-                console.log(green(`Received initialize state: ${JSON.stringify(callFactory.receivedInitializeState)}`));
                 return;
             }
             let callbackObj = pendingCalls.get(call.seqNum);
@@ -536,10 +559,10 @@ export async function createCallFactory(
             }
             if (SocketFunction.logMessages) {
                 let call = callbackObj.call;
-                console.log(`SIZE\t${(formatNumberSuffixed(resultSize) + "B").padEnd(4, " ")}\tRETURN\t${call.classGuid}.${call.functionName} at ${Date.now()}, (${nodeId} / ${localNodeId})`);
+                console.log(`SIZE\t${(formatNumberSuffixed(resultSize) + "B").padEnd(4, " ")}\t${formatNumber(currentBuffers.length)} buffers\tRETURN\t${call.classGuid}.${call.functionName} at ${Date.now()}, (${nodeId} / ${localNodeId})`);
             }
             if (call.isResultCompressed === "LZ4") {
-                call.result = await decompressObjLZ4(call.result as Buffer, receiveStats);
+                call.result = await decompressObjLZ4(call.result as Buffer[], receiveStats);
                 call.isResultCompressed = undefined;
             } else if (call.isResultCompressed === "zip" || call.isResultCompressed === true) {
                 call.result = await decompressObj(call.result as Buffer, receiveStats);
@@ -548,7 +571,7 @@ export async function createCallFactory(
             callbackObj.callback(call);
         } else {
             if (call.isArgsCompressed === "LZ4") {
-                call.args = await decompressObjLZ4(call.args as any as Buffer, sendStats) as any;
+                call.args = await decompressObjLZ4(call.args as any as Buffer[], sendStats) as any;
                 call.isArgsCompressed = undefined;
             } else if (call.isArgsCompressed === "zip" || call.isArgsCompressed === true) {
                 call.args = await decompressObj(call.args as any as Buffer, sendStats) as any;
@@ -576,12 +599,12 @@ export async function createCallFactory(
                 if (callFactory.receivedInitializeState?.supportsLZ4) {
                     let compressMode = shouldCompressCall(call);
                     if (compressMode !== false) {
-                        response.result = await compressObjLZ4(response.result, sendStats) as any;
+                        response.result = await compressObjLZ4(response.result, sendStats);
                         response.isResultCompressed = "LZ4";
                     }
                 } else {
                     if (shouldCompressCall(call)) {
-                        response.result = await compressObj(response.result, sendStats) as any;
+                        response.result = await compressObj(response.result, sendStats);
                         response.isResultCompressed = "zip";
                     }
                 }
@@ -693,11 +716,19 @@ export async function createCallFactory(
                 return;
             }
             if (message instanceof Buffer) {
-                if (message.byteLength > 1000 * 1000 * 10) {
-                    console.log(`Received large packet ${formatNumber(message.byteLength)}B at ${Date.now()}`);
-                }
                 if (!pendingCall) {
-                    throw new Error(`Received data without size`);
+                    throw new Error(`Received data without size ${message.byteLength}B, first 100 bytes: ${message.slice(0, 100).toString("hex")}`);
+                }
+                if (message.byteLength > 1000 * 1000 * 10 || pendingCall.bufferCount > 1000 && (pendingCall.buffers.length % 100 === 0)) {
+                    if (pendingCall.buffers.length === 0) {
+                        console.log(`Received large/many packets ${formatNumber(message.byteLength)}B (${pendingCall.buffers.length} / ${pendingCall.bufferCount}) at ${Date.now()}`);
+                    } else {
+                        let elapsed = Date.now() - (pendingCall.firstReceivedTime || 0);
+                        console.log(`Received large/many packets ${formatNumber(message.byteLength)}B (${pendingCall.buffers.length} / ${pendingCall.bufferCount}) after ${formatTime(elapsed)}`);
+                    }
+                }
+                if (pendingCall.buffers.length === 0) {
+                    pendingCall.firstReceivedTime = Date.now();
                 }
                 pendingCall.buffers.push(message);
                 if (pendingCall.buffers.length !== pendingCall.bufferCount) {
@@ -771,6 +802,9 @@ type CompressionStats = {
 
 const compressObj = measureWrap(async function wireCallCompress(obj: unknown, stats: CompressionStats): Promise<Buffer> {
     let buffers = await SocketFunction.WIRE_SERIALIZER.serialize(obj);
+    if (buffers.length > 1) {
+        throw new Error("Legacy CompressObj only supports single buffer");
+    }
     let lengthBuffer = Buffer.from((new Float64Array(buffers.map(x => x.length))).buffer);
     let buffer = Buffer.concat([lengthBuffer, ...buffers]);
     stats.uncompressedSize += buffer.length;
@@ -794,27 +828,177 @@ const decompressObj = measureWrap(async function wireCallDecompress(obj: Buffer,
     return result;
 });
 
-const compressObjLZ4 = measureWrap(async function wireCallCompressLZ4(obj: unknown, stats: CompressionStats): Promise<Buffer> {
-    let buffers = await SocketFunction.WIRE_SERIALIZER.serialize(obj);
-    let lengthBuffer = Buffer.from((new Float64Array(buffers.map(x => x.length))).buffer);
-    let buffer = Buffer.concat([lengthBuffer, ...buffers]);
-    stats.uncompressedSize += buffer.length;
-    let result = LZ4.compress(buffer);
-    stats.compressedSize += result.length;
-    return result;
+const compressObjLZ4 = measureWrap(async function wireCallCompressLZ4(obj: unknown, stats: CompressionStats): Promise<Buffer[]> {
+    let headerParts: number[];
+    let dataBuffers: Buffer[];
+
+    if (obj instanceof Buffer) {
+        headerParts = [1];
+        dataBuffers = [obj];
+    } else if (Array.isArray(obj) && obj.every((x: any) => x instanceof Buffer)) {
+        let bufferArray = obj as Buffer[];
+        const TARGET_SIZE = 50 * 1024 * 1024;
+        const MIN_INDIVIDUAL_SIZE = 10 * 1024 * 1024;
+        const MAX_UNSPLIT_SIZE = 100 * 1024 * 1024;
+
+        let outputBuffers: Buffer[] = [];
+        let outputDescriptors: number[][] = [];
+        let currentGroup: Buffer[] = [];
+        let currentGroupSize = 0;
+
+        function flushCurrentGroup() {
+            if (currentGroup.length > 0) {
+                outputBuffers.push(Buffer.concat(currentGroup));
+                outputDescriptors.push(currentGroup.map(b => b.length));
+                currentGroup = [];
+                currentGroupSize = 0;
+            }
+        }
+
+        for (let buf of bufferArray) {
+            if (buf.length >= MIN_INDIVIDUAL_SIZE) {
+                flushCurrentGroup();
+
+                if (buf.length > MAX_UNSPLIT_SIZE) {
+                    let offset = 0;
+                    while (offset < buf.length) {
+                        let chunkSize = Math.min(TARGET_SIZE, buf.length - offset);
+                        outputBuffers.push(buf.slice(offset, offset + chunkSize));
+                        outputDescriptors.push([chunkSize]);
+                        offset += chunkSize;
+                    }
+                } else {
+                    outputBuffers.push(buf);
+                    outputDescriptors.push([buf.length]);
+                }
+            } else {
+                currentGroup.push(buf);
+                currentGroupSize += buf.length;
+
+                if (currentGroupSize >= TARGET_SIZE) {
+                    flushCurrentGroup();
+                }
+            }
+        }
+
+        flushCurrentGroup();
+
+        headerParts = [2, outputBuffers.length];
+        for (let descriptor of outputDescriptors) {
+            headerParts.push(descriptor.length, ...descriptor);
+        }
+        dataBuffers = outputBuffers;
+    } else {
+        let buffers = await SocketFunction.WIRE_SERIALIZER.serialize(obj);
+        headerParts = [3, buffers.length];
+        dataBuffers = buffers;
+    }
+
+    let headerBuffer = Buffer.from((new Float64Array(headerParts)).buffer);
+    let allBuffers = [headerBuffer, ...dataBuffers];
+
+    stats.uncompressedSize += allBuffers.reduce((sum, buf) => sum + buf.length, 0);
+
+    let compressed: Buffer[] = [];
+    let startTime = Date.now();
+    let lastWarnTime = startTime;
+    let currentUncompressedSize = 0;
+    let currentCompressedSize = 0;
+
+    function logIfSlow(i: number) {
+        let now = Date.now();
+        if (now - lastWarnTime > 500) {
+            let elapsed = now - startTime;
+            console.log(`Slow LZ4 compress (${formatTime(elapsed)}: ${i + 1}/${allBuffers.length} buffers, ${formatNumber(currentUncompressedSize)}B => ${formatNumber(currentCompressedSize)}B`);
+            lastWarnTime = now;
+        }
+    }
+
+    for (let i = 0; i < allBuffers.length; i++) {
+        let buf = allBuffers[i];
+        currentUncompressedSize += buf.length;
+        let compressedBuf = LZ4.compress(buf);
+        compressed.push(compressedBuf);
+        currentCompressedSize += compressedBuf.length;
+
+        logIfSlow(i);
+    }
+    logIfSlow(allBuffers.length);
+
+    stats.compressedSize += currentCompressedSize;
+
+    return compressed;
 });
 
-const decompressObjLZ4 = measureWrap(async function wireCallDecompressLZ4(obj: Buffer, stats: CompressionStats): Promise<unknown> {
-    let buffer = LZ4.decompress(obj);
-    stats.uncompressedSize += buffer.length - obj.length;
-    let lengthBuffer = buffer.slice(0, 8);
-    let lengths = new Float64Array(lengthBuffer.buffer, lengthBuffer.byteOffset, lengthBuffer.byteLength / 8);
-    let buffers: Buffer[] = [];
-    let offset = 8;
-    for (let length of lengths) {
-        buffers.push(buffer.slice(offset, offset + length));
-        offset += length;
+const decompressObjLZ4 = measureWrap(async function wireCallDecompressLZ4(obj: Buffer[], stats: CompressionStats): Promise<unknown> {
+    stats.compressedSize += obj.reduce((sum, buf) => sum + buf.length, 0);
+
+    let decompressed: Buffer[] = [];
+    let startTime = Date.now();
+    let lastWarnTime = startTime;
+    let currentCompressedSize = 0;
+    let currentUncompressedSize = 0;
+    function logIfSlow(i: number) {
+        let now = Date.now();
+        if (now - lastWarnTime > 500) {
+            let elapsed = now - startTime;
+            console.log(`Slow LZ4 decompress (${formatTime(elapsed)}): ${i + 1}/${obj.length} buffers, ${formatNumber(currentCompressedSize)}B => ${formatNumber(currentUncompressedSize)}B`);
+            lastWarnTime = now;
+        }
     }
-    let result = await SocketFunction.WIRE_SERIALIZER.deserialize(buffers);
-    return result;
+
+    for (let i = 0; i < obj.length; i++) {
+        let buf = obj[i];
+        currentCompressedSize += buf.length;
+        let decompressedBuf = LZ4.decompress(buf);
+        decompressed.push(decompressedBuf);
+        currentUncompressedSize += decompressedBuf.length;
+
+        logIfSlow(i);
+    }
+    logIfSlow(obj.length);
+
+    stats.uncompressedSize += currentUncompressedSize;
+
+    let headerBuffer = decompressed[0];
+    let dataBuffers = decompressed.slice(1);
+
+    let typeBuffer = headerBuffer.slice(0, 8);
+    let type = new Float64Array(typeBuffer.buffer, typeBuffer.byteOffset, 1)[0];
+
+    if (type === 1) {
+        return dataBuffers[0];
+    }
+
+    if (type === 2) {
+        let headerData = new Float64Array(headerBuffer.buffer, headerBuffer.byteOffset, headerBuffer.byteLength / 8);
+        let outputBufferCount = headerData[1];
+
+        let buffers: Buffer[] = [];
+        let headerIndex = 2;
+
+        for (let i = 0; i < outputBufferCount; i++) {
+            let inputBufferCount = headerData[headerIndex++];
+            let sizes: number[] = [];
+            for (let j = 0; j < inputBufferCount; j++) {
+                sizes.push(headerData[headerIndex++]);
+            }
+
+            let outputBuffer = dataBuffers[i];
+            let offset = 0;
+            for (let size of sizes) {
+                buffers.push(outputBuffer.slice(offset, offset + size));
+                offset += size;
+            }
+        }
+
+        return buffers;
+    }
+
+    if (type === 3) {
+        let result = await SocketFunction.WIRE_SERIALIZER.deserialize(dataBuffers);
+        return result;
+    }
+
+    throw new Error(`Unknown compression type ${type}`);
 });

package/src/batching.d.ts

@@ -1,4 +1,4 @@
-import { AnyFunction } from "./types";
+import { AnyFunction, MaybePromise } from "./types";
 export type DelayType = (number | "afterio" | "immediate" | "afterpromises" | "paintLoop" | "afterPaint");
 export declare function delay(delayTime: DelayType, immediateShortDelays?: "immediateShortDelays"): Promise<void>;
 export declare function batchFunctionNone<Arg, Result = void>(config: unknown, fnc: (arg: Arg[]) => (Promise<Result> | Result)): (arg: Arg) => Promise<Result>;
@@ -29,3 +29,10 @@ export declare function retryFunctional<T extends AnyFunction>(fnc: T, config?:
     minDelay?: number;
     maxDelay?: number;
 }): T;
+export declare const safeLoop: typeof unblockLoop;
+export declare const throttledLoop: typeof unblockLoop;
+export declare function unblockLoop<T, R>(config: {
+    data: T[];
+    maxBlockingTime?: number;
+    backOffTime?: number;
+} | T[], fnc: (item: T) => MaybePromise<R>): Promise<R[]>;

package/src/batching.ts

@@ -329,4 +329,41 @@ export function retryFunctional<T extends AnyFunction>(fnc: T, config?: {
     return async function (...args: any[]) {
         return await runFnc(args, maxRetries);
     } as any;
+}
+
+export const safeLoop = unblockLoop;
+export const throttledLoop = unblockLoop;
+export async function unblockLoop<T, R>(config: {
+    data: T[];
+    maxBlockingTime?: number;
+    backOffTime?: number;
+} | T[], fnc: (item: T) => MaybePromise<R>): Promise<R[]> {
+
+    let data = Array.isArray(config) ? config : config.data;
+    let maxBlockingTime = 300;
+    let backOffTime = 50;
+    if (!Array.isArray(config)) {
+        maxBlockingTime = config.maxBlockingTime ?? 300;
+        backOffTime = config.backOffTime ?? 50;
+    }
+
+    let lastYieldTime = Date.now();
+    let results: R[] = [];
+
+    for (let item of data) {
+        let result = fnc(item);
+
+        // If the function returns a promise, await it
+        if (result && typeof result === "object" && "then" in result) {
+            result = await result;
+        }
+        results.push(result);
+
+        // Check if we've been blocking for too long
+        if (Date.now() - lastYieldTime > maxBlockingTime) {
+            await delay(backOffTime);
+            lastYieldTime = Date.now();
+        }
+    }
+    return results;
 }