socket-function 0.12.16 → 0.14.0

package/src/batching.ts

@@ -11,8 +11,19 @@ import { MaybePromise } from "./types";
         - The ensures a prompt return, without resorting to setTimeout in the browser (which will cause
             the callback to be delayed a frame).
 */
-export type DelayType = number | "afterio" | "immediate" | "afterpromises";
-export function delay(delayTime: DelayType): Promise<void> {
+export type DelayType = (
+    number | "afterio" | "immediate" | "afterpromises"
+    // Waits for paint, usable in a loop. The first wait doesn't wait until the next
+    //  wait, but the second wait will.
+    | "paintLoop"
+    // Waits until after paint, by waiting twice.
+    | "afterPaint"
+)
+export function delay(
+    delayTime: DelayType,
+    // Delays < 10ms become "immediate"
+    immediateShortDelays?: "immediateShortDelays"
+): Promise<void> {
     if (delayTime === "afterio") {
         return new Promise<void>(resolve => setImmediate(resolve));
     } else if (delayTime === "afterpromises") {
@@ -25,16 +36,45 @@ export function delay(delayTime: DelayType): Promise<void> {
         } else {
             return delay("afterpromises");
         }
+    } else if (delayTime === "paintLoop") {
+        if (isNode()) {
+            return delay("immediate");
+        }
+        return (async () => {
+            await new Promise(resolve => requestAnimationFrame(resolve));
+        })();
+    } else if (delayTime === "afterPaint") {
+        if (isNode()) {
+            return delay("immediate");
+        } else {
+            return (async () => {
+                await new Promise(resolve => requestAnimationFrame(resolve));
+                // Before first paint
+                await new Promise(resolve => requestAnimationFrame(resolve));
+                // After first paint
+            })();
+        }
     } else {
-        // NOTE: setTimeout can't wait this short of a time, so just setImmediate. This should be hard to distinguish
-        //  anyways, as setImmediate (at least in nodejs), should happen after io, so... it should just work
-        //  (the only difference is there will be less unnecessary delay).
-        // NOTE: THIS DOES break certain cases where io is depending on true delay, and by only waiting a microtick
-        //  we don't give it a chance. But... we should just handle those cases explicitly, via an explicit "afterio".
-        if (delayTime < 10) {
+
+        if (delayTime < 10 && immediateShortDelays) {
+            // NOTE: setTimeout can't wait this short of a time, so just setImmediate. This should be hard to distinguish
+            //  anyways, as setImmediate (at least in nodejs), should happen after io, so... it should just work
+            //  (the only difference is there will be less unnecessary delay).
+            // NOTE: THIS DOES break certain cases where io is depending on true delay, and by only waiting a microtick
+            //  we don't give it a chance. But... we should just handle those cases explicitly, via an explicit "afterio".
             return delay("immediate");
         }
-        return new Promise<void>(resolve => setTimeout(resolve, delayTime));
+        // NOTE: We check Date.now() and wait longer if setTimeout didn't wait long enough.
+        return (async () => {
+            let targetTime = Date.now() + delayTime;
+            while (true) {
+                let timeToWait = targetTime - Date.now();
+                await new Promise<void>(resolve => setTimeout(resolve, timeToWait));
+                if (Date.now() >= targetTime) {
+                    break;
+                }
+            }
+        })();
     }
 }
 
@@ -110,7 +150,7 @@ export function batchFunction<Arg, Result = void>(
         let args: Arg[] = [arg];
         let promise = Promise.resolve().then(async () => {
             await curPrevPromise;
-            await delay(curDelay);
+            await delay(curDelay, "immediateShortDelays");
             // Reset batching, as we once we start the function we can't accept args. `prevPromise` will block
             //  the next batch from starting before we finish.
             batching = undefined;

package/src/caching.ts

@@ -37,8 +37,10 @@ export function cacheEmptyArray<T>(array: T[]): T[] {
     return array;
 }
 
-export function cache<Output, Key>(getValue: (key: Key) => Output): {
-    (key: Key): Output;
+export function cache<Output, Key, Untracked extends unknown[]>(
+    getValue: (key: Key, ...untracked: Untracked) => Output
+): {
+    (key: Key, ...untracked: Untracked): Output;
     // NOTE: If you want to clear all, just make a new cache!
     clear(key: Key): void;
     clearAll(): void;
@@ -48,7 +50,7 @@ export function cache<Output, Key>(getValue: (key: Key) => Output): {
 } {
     let startingCalculating = new Set<Key>();
     let values = new Map<Key, Output>();
-    function cache(input: Key) {
+    function cache(input: Key, ...untracked: Untracked) {
         let key = input;
         if (values.has(key)) {
             return values.get(key) as any;
@@ -59,7 +61,7 @@ export function cache<Output, Key>(getValue: (key: Key) => Output): {
             return undefined;
         }
         startingCalculating.add(key);
-        let value = getValue(input);
+        let value = getValue(input, ...untracked);
         values.set(key, value);
         return value;
     }

package/src/callManager.ts

@@ -1,6 +1,6 @@
-import { CallerContext, CallType, ClientHookContext, FullCallType, HookContext, SocketExposedInterface, SocketExposedInterfaceClass, SocketExposedShape, SocketFunctionClientHook, SocketFunctionHook, SocketRegistered } from "../SocketFunctionTypes";
+import { CallerContext, CallType, ClientHookContext, FullCallType, FunctionFlags, HookContext, SocketExposedInterface, SocketExposedInterfaceClass, SocketExposedShape, SocketFunctionClientHook, SocketFunctionHook, SocketRegistered } from "../SocketFunctionTypes";
 import { _setSocketContext } from "../SocketFunction";
-import { isNode } from "./misc";
+import { entries, isNode } from "./misc";
 import debugbreak from "debugbreak";
 import { measureWrap } from "./profiling/measure";
 
@@ -15,6 +15,9 @@ let exposedClasses = new Set<string>();
 let globalHooks: SocketFunctionHook[] = [];
 let globalClientHooks: SocketFunctionClientHook[] = [];
 
+export function getCallFlags(call: CallType): FunctionFlags | undefined {
+    return classes[call.classGuid]?.shape[call.functionName];
+}
 export function shouldCompressCall(call: CallType) {
     return !!classes[call.classGuid]?.shape[call.functionName]?.compress;
 }
@@ -63,11 +66,26 @@ export function isDataImmutable(call: CallType) {
     return !!classes[call.classGuid]?.shape[call.functionName]?.dataImmutable;
 }
 
-export function registerClass(classGuid: string, controller: SocketExposedInterface, shape: SocketExposedShape) {
+export function registerClass(classGuid: string, controller: SocketExposedInterface, shape: SocketExposedShape, config?: {
+    noFunctionMeasure?: boolean;
+}) {
     if (classes[classGuid]) {
         throw new Error(`Class ${classGuid} already registered`);
     }
 
+    if (!config?.noFunctionMeasure) {
+        let keys = new Set([
+            ...Object.keys(controller),
+            ...Object.getOwnPropertyNames(controller.__proto__ || {}),
+        ]);
+        let niceClassName = controller.constructor.name || classGuid;
+        for (let functionName of keys) {
+            if (functionName === "constructor") continue;
+            let fnc = controller[functionName];
+            if (typeof fnc !== "function") continue;
+            controller[functionName] = measureWrap(fnc, `${niceClassName}().${functionName}`);
+        }
+    }
     classes[classGuid] = {
         controller,
         shape,

package/src/formatting/format.ts

@@ -122,6 +122,7 @@ export function formatMaxDecimals(num: number, targetDigits: number, maxAbsolute
 
 /** Actually formats any number, including decimals, by using K, M and B suffixes to get smaller values
  *      TODO: Support uK, uM and uB suffixes for very small numbers?
+ *      <= 6 characters (<= 5 if positive)
  */
 export function formatNumber(count: number | undefined, maxAbsoluteValue?: number, noDecimal?: boolean, specialCurrency?: boolean): string {
     if (typeof count !== "number") return "0";
@@ -230,4 +231,11 @@ export function formatDate(time: number) {
     }
     let date = new Date(time);
     return date.getFullYear() + "/" + p(date.getMonth() + 1) + "/" + p(date.getDate());
+}
+
+/** <= 6 characters (<= 5 if positive) */
+export function formatPercent(value: number) {
+    if (Number.isNaN(value)) return "0%";
+    // 1 decimal point, so we have 5 characters (just like formatNumber returns 5 characters)
+    return Math.round(value * 1000) / 10 + "%";
 }

package/src/misc.ts

@@ -324,6 +324,16 @@ export function compare(lhs: unknown, rhs: unknown): number {
         return compare(typeof lhs, typeof rhs);
     }
     if (lhs === rhs) return 0;
+    if (lhs === null && rhs !== null) return -1;
+    if (lhs !== null && rhs === null) return 1;
+    if (typeof lhs === "number") {
+        if (Number.isNaN(lhs)) {
+            if (Number.isNaN(rhs)) return 0;
+            return -1;
+        } else {
+            if (Number.isNaN(rhs)) return +1;
+        }
+    }
     if (lhs as any < (rhs as any)) return -1;
     return 1;
 }

package/src/nodeCache.ts

@@ -18,6 +18,7 @@ export function getNodeId(domain: string, port: number): string {
     return `${domain}:${port}`;
 }
 
+/** @deprecated, call getBrowserUrlNode instead, which does important additional checks. */
 export function getNodeIdFromLocation() {
     return SocketFunction.browserNodeId();
 }

package/src/profiling/measure.ts

@@ -61,7 +61,7 @@ export function measureWrap<T extends (...args: any[]) => any>(fnc: T, name?: st
         functionsSkipped++;
         return fnc;
     }
-    let usedName = name || fnc.name;
+    let usedName = name || fnc.name || fnc.toString().slice(0, 100).replaceAll(/\s/g, " ");
     return nameFunction(usedName, (function (this: any, ...args: unknown[]): unknown {
         if (outstandingProfiles.length === 0) {
             return fnc.apply(this, args);
@@ -127,17 +127,18 @@ export interface LogMeasureTableConfig {
     minTimeToLog?: number;
     // Defaults to 2
     mergeDepth?: number;
+    // Defaults to 10
+    maxTableEntries?: number;
 }
 
 export function logMeasureTable(
     profile: MeasureProfile,
     config?: LogMeasureTableConfig
 ) {
-    let { useTotalTime, name, thresholdInTable } = config || {};
-    if (thresholdInTable === undefined) {
-        thresholdInTable = 0.05;
-    }
+    let { useTotalTime, name } = config || {};
+    const thresholdInTable = config?.thresholdInTable ?? 0.05;
     let minTimeToLog = config?.minTimeToLog ?? 50;
+    const maxTableEntries = config?.maxTableEntries ?? 10;
 
     function getTime(entry: ProfileEntry) {
         return useTotalTime ? entry.totalTime : entry.ownTime;
@@ -188,11 +189,30 @@ export function logMeasureTable(
         return `${(value * 100).toFixed(2)}%`;
     }
 
-    entries = entries.slice(0, 10);
+    let remaining = entries.slice(maxTableEntries);
+    entries = entries.slice(0, maxTableEntries);
+    entries = entries.filter(entry => {
+        const include = getTime(entry).sum / totalTime >= thresholdInTable;
+        if (!include) {
+            remaining.push(entry);
+        }
+        return include;
+    });
+    entries.push({
+        name: "Other",
+        ownTime: createStatsValue(),
+        totalTime: createStatsValue(),
+        stillOpenCount: 0,
+    });
+    let remainingEntry = entries[entries.length - 1];
+    for (let entry of remaining) {
+        addToStats(remainingEntry.ownTime, entry.ownTime);
+        addToStats(remainingEntry.totalTime, entry.totalTime);
+        remainingEntry.stillOpenCount += entry.stillOpenCount;
+    }
     let maxNameLength = Math.max(...entries.map(x => x.name.length));
 
-    for (let entry of entries.slice(0, 10)) {
-        if (getTime(entry).sum / totalTime < thresholdInTable) break;
+    for (let entry of entries) {
         let output = "";
         output += `${blue(entry.name)}`;
         output += Array(maxNameLength + 4 - entry.name.length).fill(" ").join("");

package/src/tlsParsing.ts

@@ -3,14 +3,17 @@ export function parseTLSHello(buffer: Buffer): {
         type: number;
         data: Buffer;
     }[];
+    missingBytes: number;
 } {
     let output: {
         extensions: {
             type: number;
             data: Buffer;
         }[];
+        missingBytes: number;
     } = {
-        extensions: []
+        extensions: [],
+        missingBytes: 0
     };
 
     try {
@@ -50,6 +53,7 @@ export function parseTLSHello(buffer: Buffer): {
         pos += compressionLength;
 
         let extensionsLength = readShort();
+        output.missingBytes = contentLength - (pos + extensionsLength);
         let extensionsEnd = pos + extensionsLength;
         while (pos < extensionsEnd) {
             let extensionType = readShort();

package/src/webSocketServer.ts

@@ -58,7 +58,12 @@ export async function startSocketServer(
         let httpServerPromise = new Promise<https.Server>(r => onHttpServer = r);
         let lastOptions!: https.ServerOptions;
         await watchOptions(value => {
-            lastOptions = { ...value, ca: getTrustedCertificates() };
+            lastOptions = {
+                ...value,
+                ca: getTrustedCertificates(),
+                // Attempt to disable sessions, because they make SNI significantly harder to parse.
+                secureOptions: require("node:constants").SSL_OP_NO_TICKET,
+            };
             if (!httpsServerLast) {
                 httpsServerLast = https.createServer(lastOptions);
             } else {
@@ -119,7 +124,7 @@ export async function startSocketServer(
                     let host = new URL("ws://" + request.headers["host"]).hostname;
                     let origin = new URL(originHeader).hostname;
                     if (host !== origin && !allowedHostnames.has(origin)) {
-                        throw new Error(`Invalid cross domain request, ${JSON.stringify(host)} !== ${JSON.stringify(origin)} (also not config.allowedHostnames ${JSON.stringify(config.allowHostnames)})`);
+                        throw new Error(`Invalid cross domain request, ${JSON.stringify(host)} !== ${JSON.stringify(origin)} (also not in config.allowedHostnames ${JSON.stringify(config.allowHostnames)})`);
                     }
                 } catch (e) {
                     console.error(e);
@@ -167,18 +172,17 @@ export async function startSocketServer(
     });
 
     let realServer = net.createServer(socket => {
-        // NOTE: ONCE is used, so we only look at the first buffer, and then after that
-        //  we pipe. This should be very efficient, as pipe has insane throughput
-        //  (100s of MB/s, easily, even on a terrible machine).
-        socket.once("data", buffer => {
+        function handleTLSHello(buffer: Buffer, packetCount: number): void | "more" {
             // All HTTPS requests start with 22, and no HTTP requests start with 22,
             //  so we just need to read the first byte.
-
             let server: https.Server | http.Server;
             if (buffer[0] !== 22) {
                 server = httpServer;
             } else {
                 let data = parseTLSHello(buffer);
+                if (data.missingBytes > 0) {
+                    return "more";
+                }
                 let sni = data.extensions.filter(x => x.type === SNIType).flatMap(x => parseSNIExtension(x.data))[0];
                 if (!SocketFunction.silent) {
                     console.log(`Received TCP connection with SNI ${JSON.stringify(sni)}`);
@@ -189,7 +193,21 @@ export async function startSocketServer(
             // NOTE: Messages aren't dequeued until the current handler finishes, so we don't need to pause the socket or anything.
             server.emit("connection", socket);
             socket.unshift(buffer);
-        });
+        }
+        let buffers: Buffer[] = [];
+        function getNextData() {
+            // NOTE: ONCE is used, so we only look at the first buffer, and then after that
+            //  we pipe. This should be very efficient, as pipe has insane throughput
+            //  (100s of MB/s, easily, even on a terrible machine).
+            socket.once("data", buffer => {
+                buffers.push(buffer);
+                let result = handleTLSHello(Buffer.concat(buffers), buffers.length);
+                if (result === "more") {
+                    getNextData();
+                }
+            });
+        }
+        getNextData();
         socket.on("error", (e) => {
             console.error(`Exposed socket error, ${e.stack}`);
         });

package/src/websocketFactory.ts

@@ -1,51 +1,57 @@
-import ws from "ws";
-import tls from "tls";
-import { isNode } from "./misc";
-import { SenderInterface } from "./CallFactory";
-import { getTrustedCertificates } from "./certStore";
-import { getNodeIdLocation } from "./nodeCache";
-import debugbreak from "debugbreak";
-import { SocketFunction } from "../SocketFunction";
-
-
-export function getTLSSocket(webSocket: ws.WebSocket) {
-    return (webSocket as any)._socket as tls.TLSSocket;
-}
-
-/** NOTE: We create a factory, which embeds the key/cert information. Otherwise retries might use
- *      a different key/cert context.
- */
-export function createWebsocketFactory(): (nodeId: string) => SenderInterface {
-
-    if (!isNode()) {
-        return (nodeId: string) => {
-            let location = getNodeIdLocation(nodeId);
-            if (!location) throw new Error(`Cannot connect to ${nodeId}, no address known`);
-            let { address, port } = location;
-
-            if (!SocketFunction.silent) {
-                console.log(`Connecting to ${address}:${port}`);
-            }
-            return new WebSocket(`wss://${address}:${port}`);
-        };
-    } else {
-        return (nodeId: string) => {
-            let location = getNodeIdLocation(nodeId);
-            if (!location) throw new Error(`Cannot connect to ${nodeId}, no address known`);
-            let { address, port } = location;
-
-            if (!SocketFunction.silent) {
-                console.log(`Connecting to ${address}:${port}`);
-            }
-            let webSocket = new ws.WebSocket(`wss://${address}:${port}`, {
-                ca: getTrustedCertificates()
-            });
-            let result = Object.assign(webSocket, { socket: undefined as tls.TLSSocket | undefined });
-            webSocket.once("upgrade", e => {
-                result.socket = e.socket as tls.TLSSocket;
-            });
-            return result;
-        };
-    }
-}
-
+import ws from "ws";
+import tls from "tls";
+import { isNode } from "./misc";
+import { SenderInterface } from "./CallFactory";
+import { getTrustedCertificates } from "./certStore";
+import { getNodeIdLocation } from "./nodeCache";
+import debugbreak from "debugbreak";
+import { SocketFunction } from "../SocketFunction";
+
+export function getTLSSocket(webSocket: ws.WebSocket) {
+    return (webSocket as any)._socket as tls.TLSSocket;
+}
+
+/** NOTE: We create a factory, which embeds the key/cert information. Otherwise retries might use
+ *      a different key/cert context.
+ */
+export function createWebsocketFactory(): (nodeId: string) => SenderInterface {
+
+    if (!isNode()) {
+        return (nodeId: string) => {
+            let location = getNodeIdLocation(nodeId);
+            if (!location) throw new Error(`Cannot connect to ${nodeId}, no address known`);
+            let { address, port } = location;
+
+            if (!SocketFunction.silent) {
+                console.log(`Connecting to ${address}:${port}`);
+            }
+            return new WebSocket(`wss://${address}:${port}`);
+        };
+    } else {
+        return (nodeId: string) => {
+            let location = getNodeIdLocation(nodeId);
+            if (!location) throw new Error(`Cannot connect to ${nodeId}, no address known`);
+            let { address, port } = location;
+
+            if (!SocketFunction.silent) {
+                console.log(`Connecting to ${address}:${port}`);
+            }
+            let webSocket = new ws.WebSocket(`wss://${address}:${port}`, undefined, {
+                ca: getTrustedCertificates(),
+                // createConnection(options, oncreate) {
+                //     // NOTE: If our latency is 500ms, with 10MB/s, then we need a high water
+                //     //  mark of at least 5MB, otherwise our connection is slowed down.
+                //     //(options as any).writableHighWaterMark = 5 * 1024 * 1024;
+                //     return tls.connect(options as any, oncreate as any);
+                // },
+            });
+
+            // NOTE: Little setup is done here, because Sometimes websockets are created here,
+            //      and sometimes via incoming connections, We should do most setup in
+            //      CallFactory.ts:initializeWebsocket
+
+            return webSocket;
+        };
+    }
+}
+

package/time/trueTimeShim.ts

@@ -1,4 +1,5 @@
 import { SocketFunction } from "../SocketFunction";
+import { blue, green, red, yellow } from "../src/formatting/logColors";
 import { isNode } from "../src/misc";
 
 module.allowclient = true;
@@ -121,6 +122,13 @@ async function updateTimeOffset() {
             }
 
             let prevOffset = trueTimeOffset;
+            let offsetRound = Math.abs(Math.round(offset));
+            let offsetColored = (
+                Math.abs(offset) > 600 && red(offsetRound + "ms")
+                || Math.abs(offset) > 300 && yellow(offsetRound + "ms")
+                || green(offsetRound + "ms")
+            );
+            console.log(`${blue("Synchronized time")}, local clock was ${offset > 0 ? "behind" : "ahead"} by ${offsetColored}`);
             for (let i = 0; i < currentSmearCount; i++) {
                 let fraction = (i + 1) / currentSmearCount;
                 trueTimeOffset = prevOffset * (1 - fraction) + offset * fraction;