socket-function 0.8.39 → 0.8.40

package/SocketFunction.ts

@@ -201,6 +201,8 @@ export class SocketFunction {
     public static mountedNodeId: string = "";
     public static mountedIP: string = "";
     private static hasMounted = false;
+    private static onMountCallback: () => void = () => { };
+    public static mountPromise: Promise<void> = new Promise(r => this.onMountCallback = r);
     public static async mount(config: SocketServerConfig) {
         if (this.mountedNodeId) {
             throw new Error("SocketFunction already mounted, mounting twice in one thread is not allowed.");
@@ -223,6 +225,7 @@ export class SocketFunction {
                 await callback();
             }
         }
+        this.onMountCallback();
         return this.mountedNodeId;
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "socket-function",
-	"version": "0.8.39",
+	"version": "0.8.40",
 	"main": "index.js",
 	"license": "MIT",
 	"note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
@@ -10,7 +10,7 @@
 		"node-forge": "https://github.com/sliftist/forge#name",
 		"preact": "^10.10.6",
 		"rdtsc-now": "^0.3.0",
-		"typenode": "^4.9.4-c",
+		"typenode": "^4.9.4-f",
 		"ws": "^8.8.0"
 	},
 	"scripts": {

package/src/CallFactory.ts

@@ -10,8 +10,9 @@ import { getClientNodeId, getNodeIdLocation, registerNodeClient } from "./nodeCa
 import debugbreak from "debugbreak";
 import { lazy } from "./caching";
 import { JSONLACKS } from "./JSONLACKS/JSONLACKS";
-import { red } from "./formatting/logColors";
-import { isSplitableArray } from "./fixLargeNetworkCalls";
+import { red, yellow } from "./formatting/logColors";
+import { isSplitableArray, markArrayAsSplitable } from "./fixLargeNetworkCalls";
+import { delay } from "./batching";
 
 const MIN_RETRY_DELAY = 1000;
 
@@ -56,6 +57,8 @@ export interface SenderInterface {
     addEventListener(event: "message", listener: (data: ws.RawData | ws.MessageEvent | string) => void): void;
 
     readyState: number;
+
+    ping?(): void;
 }
 
 export async function createCallFactory(
@@ -82,6 +85,18 @@ export async function createCallFactory(
     //  in return calls.
     let nextSeqNum = Date.now() + Math.random();
 
+    // NOTE: I'm not sure if this is needed, I thought it was, but... now I think
+    //  it probably isn't...
+    // if (webSocketBase?.readyState === 1 /* OPEN */ && webSocketBase.ping) {
+    //     // Heartbeat loop, otherwise onDisconnect is never called.
+    //     ((async () => {
+    //         while (webSocketBase?.readyState === 1 /* OPEN */ && webSocketBase.ping) {
+    //             await delay(1000 * 60);
+    //             webSocketBase.ping?.();
+    //         }
+    //     }))().catch(() => { });
+    // }
+
     let lastConnectionAttempt = 0;
 
     let callerContext: CallerContextBase = {
@@ -120,6 +135,7 @@ export async function createCallFactory(
             if (data.byteLength > SocketFunction.MAX_MESSAGE_SIZE * 1.5) {
                 let splitArgIndex = call.args.findIndex(isSplitableArray);
                 if (splitArgIndex >= 0) {
+                    console.log(yellow(`Splitting large call due to large args: ${call.classGuid}.${call.functionName}`));
                     let SPLIT_GROUPS = 10;
                     let splitArg = call.args[splitArgIndex] as unknown[];
                     let subCalls = list(SPLIT_GROUPS).map(index => {
@@ -127,12 +143,15 @@ export async function createCallFactory(
                         let end = Math.floor((index + 1) / SPLIT_GROUPS * splitArg.length);
                         return splitArg.slice(start, end);
                     }).filter(x => x.length > 0);
-                    for (let splitList of subCalls) {
+
+                    let calls = subCalls.map(async splitList => {
                         let subCall = { ...call };
                         subCall.args = subCall.args.slice();
-                        subCall.args[splitArgIndex] = splitList;
+                        subCall.args[splitArgIndex] = markArrayAsSplitable(splitList);
                         await callFactory.performCall(subCall);
-                    }
+                    });
+                    await Promise.allSettled(calls);
+                    await Promise.all(calls);
                     // Eh... we COULD return the array of results, but... then the result would sometimes be an array,
                     //  some times not, so, it is better to return a string which will make it more clear why it sometimes varies.
                     return "CALLS_SPLIT_DUE_TO_LARGE_ARGS";
@@ -355,7 +374,7 @@ export async function createCallFactory(
             }
             throw new Error(`Unhandled data type ${typeof message}`);
         } catch (e: any) {
-            debugbreak(1);
+            debugbreak(2);
             debugger;
             console.error(e.stack);
         }

package/src/caching.ts

@@ -3,7 +3,6 @@ import { AnyFunction, Args, canHaveChildren } from "./types";
 
 export function lazy<T>(factory: () => T): () => T {
     let value: { value: T } | undefined = undefined;
-
     return () => {
         if (!value) {
             value = { value: factory() };
@@ -33,8 +32,10 @@ export function cacheEmptyArray<T>(array: T[]): T[] {
 
 export function cache<Output, Key>(getValue: (key: Key) => Output): {
     (key: Key): Output;
+    // NOTE: If you want to clear all, just make a new cache!
     clear(key: Key): void;
     forceSet(key: Key, value: Output): void;
+    getAllKeys(): Key[];
 } {
     let startingCalculating = new Set<Key>();
     let values = new Map<Key, Output>();
@@ -61,6 +62,9 @@ export function cache<Output, Key>(getValue: (key: Key) => Output): {
         values.set(key, value);
         startingCalculating.add(key);
     };
+    cache.getAllKeys = () => {
+        return [...values.keys()];
+    };
     return cache;
 }
 

package/src/fixLargeNetworkCalls.ts

@@ -5,5 +5,5 @@ export function markArrayAsSplitable<T>(data: T[]): T[] {
 }
 export function isSplitableArray<T>(data: T): data is T & (unknown[]) {
     if (!Array.isArray(data)) return false;
-    return (data as any)[arrayIsSplitable] === true;
+    return !!(data as any)[arrayIsSplitable];
 }

package/src/misc.ts

@@ -139,6 +139,9 @@ export function getKeys(obj: unknown) {
     }
     return keyArray;
 }
+export function getStringKeys<T extends {}>(obj: T): ((keyof T) & string)[] {
+    return Object.keys(obj) as any;
+}
 
 if (isNode()) {
     // TODO: Find a better place for this...

package/src/profiling/measure.ts

@@ -1,6 +1,6 @@
 import debugbreak from "debugbreak";
 import { formatTime, formatNumber } from "../formatting/format";
-import { red, yellow, blue } from "../formatting/logColors";
+import { red, yellow, blue, magenta } from "../formatting/logColors";
 
 import { getOwnTime, getPendingOwnTimeInstances, getPendingOwnTimeObjs, OwnTimeObj } from "./getOwnTime";
 import { addToStats, addToStatsValue, createStatsValue, getStatsTop, StatsValue } from "./stats";
@@ -108,9 +108,9 @@ export function logMeasureTable(
     let totalTime = entries.map(x => getTime(x).sum).reduce((a, b) => a + b, 0);
 
     console.log();
-    let title = yellow(`Profiled ${formatTime(totalTime)}`);
+    let title = yellow(`Profiled ${formatTime(totalTime)} (logged at ${new Date().toISOString()})`);
     if (name) {
-        title += ` ${blue(name)}`;
+        title = `(${blue(name)}) ${title}`;
     }
     console.log(title);
     function percent(value: number) {
@@ -142,7 +142,7 @@ export function logMeasureTable(
 
         let ownTimeTop = getStatsTop(getTime(entry));
         if (ownTimeTop.topHeavy) {
-            output += red(`    TOP ${percent(ownTimeTop.valueFraction)} of the time is owned by ${percent(ownTimeTop.countFraction)} of the calls`);
+            output += red(`    TOP ${percent(ownTimeTop.valueFraction)} of the time is owned by ${percent(ownTimeTop.countFraction)} of the calls (${formatTime(ownTimeTop.value / ownTimeTop.count)} per * ${formatNumber(ownTimeTop.count)} = ${formatTime(ownTimeTop.value)})`);
         }
 
         if (entry.stillOpenCount > 0) {

package/src/webSocketServer.ts

@@ -12,6 +12,7 @@ import debugbreak from "debugbreak";
 import { getNodeId } from "./nodeCache";
 import crypto from "crypto";
 import { Watchable } from "./misc";
+import { delay, runInfinitePoll } from "./batching";
 
 export type SocketServerConfig = (
     https.ServerOptions & {

package/src/websocketFactory.ts

@@ -38,7 +38,7 @@ export function createWebsocketFactory(): (nodeId: string) => SenderInterface {
                 console.log(`Connecting to ${address}:${port}`);
             }
             let webSocket = new ws.WebSocket(`wss://${address}:${port}`, {
-                ca: tls.rootCertificates.concat(getTrustedCertificates()),
+                ca: getTrustedCertificates()
             });
             let result = Object.assign(webSocket, { socket: undefined as tls.TLSSocket | undefined });
             webSocket.once("upgrade", e => {