querysub 0.2.0

package/src/path.ts

@@ -0,0 +1,226 @@
+/**
+ *  Overview
+ *      We escape path segments so we can quickly create a str representing
+ *          that path. We do this by escaping some special character and then using a that
+ *          character to indicate special values.
+ *          - This appears to be faster than JSON.stringify
+ *              - A random benchmark showed 140ns per, compared to 260ns for a JSON.stringify call
+ *                  - ALSO, using "appendToPathStr(rootPathStr, str)" instead of getPathStr([str]) is even
+ *                      faster, about 70ns per.
+ *          - This lets us extend existing stres without recreating the entire str,
+ *              which is significantly faster than JSON.stringify.
+ *          - ALSO, escapes "." and "$", letting us use this to escape keys for mongodb usage.
+ */
+
+// TODO: Change our escaping so we can turn paths into valid mongodb key names see:
+//  https://stackoverflow.com/questions/7975185/mongodb-query-over-a-str-with-special-chars-in-keys/7976235#7976235
+
+const specialChar = ".";
+
+// The character after this character is special, forming a 2 character sequence.
+export const PATH_SPECIAL_CHAR = specialChar;
+
+const pathDelimitChar = ",";
+const specialCharEscape = specialChar + "_";
+
+
+// NOTE: Our paths end up looking something like: pathDelimitEscaped + arr[0] + pathDelimitEscaped + arr[1] + pathDelimitEscaped,
+//  with the delimitter at both ends and between all elements (and with everything escaped properly).
+
+const pathDelimitEscaped = specialChar + pathDelimitChar;
+
+const afterChildSuffix = specialChar + String.fromCharCode(pathDelimitChar.charCodeAt(0) + 1);
+
+export const rootPathStr = getPathStr([]);
+
+function regexEscape(text: string) {
+    text = text.replace(/\./g, "\\.");
+    text = text.replace(/\$/g, "\\$");
+    return text;
+}
+
+let regexSpecialChar = new RegExp(regexEscape(specialChar), "g");
+let regexUnescapeSpecialChar = new RegExp(regexEscape(specialCharEscape), "g");
+
+export function escapePathPart(part: string | number | boolean | undefined | null) {
+    if (typeof part !== "string") return part;
+    if (isValidPathStr(part)) {
+        if (part.indexOf(specialChar) < 0) {
+            return part;
+        }
+    }
+    return part.replace(regexSpecialChar, specialCharEscape);
+}
+function unescapePathPart(part: string) {
+    part = part.replace(regexUnescapeSpecialChar, specialChar);
+    return part;
+}
+
+
+
+export function getPathStr(path: (string | number | boolean | undefined | null)[]) {
+    return pathDelimitEscaped + path.map(x => escapePathPart(x) + pathDelimitEscaped).join("");
+}
+/** Equivalent to getPathStr([path0]), except a bit faster */
+export function getPathStr1(path0: string) {
+    return appendToPathStr(rootPathStr, path0);
+}
+/** Equivalent to getPathStr([path0, path1]), except a bit faster */
+export function getPathStr2(path0: string, path1: string) {
+    // TODO: Benchmark this again. If I recall correctly, if we are ONLY string paths, this is about
+    //  twice as fast as getPathStr([path0, path1])? This is because allocating arrays is slow.
+    return appendToPathStr(appendToPathStr(rootPathStr, path0), path1);
+}
+/** Equivalent to getPathStr([path0, path1, path2]), except a bit faster */
+export function getPathStr3(path0: string, path1: string, path2: string) {
+    return appendToPathStr(appendToPathStr(appendToPathStr(rootPathStr, path0), path1), path2);
+}
+export function getPathStr4(path0: string, path1: string, path2: string, path3: string) {
+    let value = rootPathStr;
+    value = appendToPathStr(value, path0);
+    value = appendToPathStr(value, path1);
+    value = appendToPathStr(value, path2);
+    value = appendToPathStr(value, path3);
+    return value;
+}
+
+export function appendToPathStr(pathStr: string, pathPart: string) {
+    return pathStr + escapePathPart(pathPart) + pathDelimitEscaped;
+}
+export function prependToPathStr(pathStr: string, pathPart: string) {
+    return pathDelimitEscaped + escapePathPart(pathPart) + pathStr;
+}
+
+export function pathStrIncludesValue(pathStr: string, value: string) {
+    value = String(escapePathPart(value));
+    return pathStr.includes(value);
+}
+
+export function joinPathStres(lhsStr: string, rhsStr: string) {
+    return lhsStr + rhsStr.slice(rootPathStr.length);
+}
+
+export function getPathIndexAssert(pathStr: string, index: number): string {
+    let value = getPathIndex(pathStr, index);
+    if (value === undefined) {
+        throw new Error(`Path index ${index} was undefined in pathStr ${pathStr}`);
+    }
+    return value;
+}
+export function getPathIndex(pathStr: string, index: number) {
+    let parts = pathStr.split(pathDelimitEscaped);
+    if (parts.length - 2 <= index) {
+        return undefined;
+    }
+    let part = parts[index + 1];
+    if (part === undefined) {
+        return undefined;
+    }
+    return unescapePathPart(part);
+}
+export function getPathFromStr(pathStr: string) {
+    return pathStr.split(pathDelimitEscaped).slice(1, -1).map(x => unescapePathPart(x));
+}
+
+export function isValidPathStr(pathStr: string) {
+    return pathStr.startsWith(pathDelimitEscaped) && pathStr.endsWith(pathDelimitEscaped);
+}
+
+/** Gets the path after all children of the pathStr, BUT, before the next sibling (when sorting lexicographically by path str). */
+export function getPathAfterLastChild(pathStr: string) {
+    if (pathStr === "") {
+        return afterChildSuffix;
+    }
+    // NOTE: assertArg isn't used, to reduce the readLocks of path.ts, which is used itself by assertArg.
+    if (!pathStr.endsWith(pathDelimitEscaped)) {
+        throw new Error(`pathStr must end with ${JSON.stringify(pathDelimitEscaped)}, was ${JSON.stringify(pathStr)}`);
+    }
+    // Any sibling before us, will lexicographically be < us BEFORE the last character, the same as any sibling after us.
+    //  However, children't will match all the way to our suffix, and then be < our modified suffix.
+    return pathStr.slice(0, -pathDelimitEscaped.length) + afterChildSuffix;
+}
+
+/** === getPathStr(getPathFromStr(pathStr).slice(0, -1)), getParentPathStr(rootPathStr) === rootPathStr */
+export function getParentPathStr(pathStr: string) {
+    // Allow empty string? Better than throwing on it, I guess
+    if (pathStr === "") {
+        return "";
+    }
+    // NOTE: If pathStr.length is too small, our index start becomes negative, and so this works without
+    //  an additional check.
+    let index = pathStr.lastIndexOf(pathDelimitEscaped, pathStr.length - pathDelimitEscaped.length - pathDelimitEscaped.length + 1);
+    return pathStr.slice(0, index + pathDelimitEscaped.length);
+}
+
+/** === getPathFromStr(pathStr).slice(-1)[0] */
+export function getLastPathPart(pathStr: string) {
+    let index = pathStr.lastIndexOf(pathDelimitEscaped, pathStr.length - pathDelimitEscaped.length - pathDelimitEscaped.length + 1);
+    return unescapePathPart(pathStr.slice(index + pathDelimitEscaped.length, -pathDelimitEscaped.length));
+}
+
+/** === getPathStr(getPathFromStr(pathStr).slice(0, -1)) */
+export function removePathLastPart(pathStr: string) {
+    let index = pathStr.lastIndexOf(pathDelimitEscaped, pathStr.length - pathDelimitEscaped.length - pathDelimitEscaped.length + 1);
+    return pathStr.slice(0, index + pathDelimitEscaped.length);
+}
+
+/** getPathDepth(pathStr) === getPathFromStr(pathStr).length */
+export function getPathDepth(pathStr: string): number {
+    // Start at 1, to skip the first pathDelimit
+    let index = 1;
+    // Start at -1, as the last loop doesn't have pathDelimitEscaped, but is still incremented
+    let count = -1;
+    while (index > 0) {
+        count++;
+        index = pathStr.indexOf(pathDelimitEscaped, index) + 1;
+    }
+    return count;
+}
+
+export const getPathPrefix = trimPathStrToDepth;
+export function trimPathStrToDepth(pathStr: string, depth: number): string {
+    let index = 0;
+    let count = 0;
+    while (count < depth) {
+        let nextIndex = pathStr.indexOf(pathDelimitEscaped, index + 1);
+        if (nextIndex < 0) break;
+        count++;
+        index = nextIndex;
+    }
+    return pathStr.slice(0, index + pathDelimitEscaped.length);
+}
+export const slicePathStrToDepth = trimPathStrToDepth;
+export function getPathSuffix(pathStr: string, depth: number): string {
+    let index = 0;
+    let count = 0;
+    while (count < depth) {
+        let nextIndex = pathStr.indexOf(pathDelimitEscaped, index + 1);
+        if (nextIndex < 0) break;
+        count++;
+        index = nextIndex;
+    }
+    return pathStr.slice(index);
+}
+
+/** A hack, which breaks some path functions, but... which works with enough to save a
+ *      lot of code and time when we need a bit more information that shouldn't count as
+ *      path information. */
+export function hack_setPackedPathSuffix(path: string, suffix: string): string {
+    return path + suffix;
+}
+export function hack_isPackedPath(path: string) {
+    return !path.endsWith(pathDelimitEscaped);
+}
+export function hack_getPackedPathSuffix(path: string): string {
+    if (!hack_isPackedPath(path)) {
+        return "";
+    }
+    return getPathSuffix(path, getPathDepth(path)).slice(pathDelimitEscaped.length);
+}
+export function hack_stripPackedPath(path: string): string {
+    if (!hack_isPackedPath(path)) {
+        return path;
+    }
+    let suffix = hack_getPackedPathSuffix(path);
+    return path.slice(0, -suffix.length);
+}

package/src/persistentLocalStore.ts

@@ -0,0 +1,37 @@
+module.allowclient = true;
+
+import { isNode } from "socket-function/src/misc";
+import fs from "fs";
+import { getStorageDir, getSubFolder } from "./fs";
+import { isClient } from "./config2";
+import { getDomain } from "./config";
+
+export function createKeyStore<T>(key: string): {
+    value: T | null;
+} {
+    if (isNode()) {
+        let path = getStorageDir() + key + ".json";
+        return {
+            get value() {
+                let contents: string | undefined = undefined;
+                try { contents = fs.readFileSync(path, "utf8"); } catch { }
+                if (!contents) return null;
+                return JSON.parse(contents) as T;
+            },
+            set value(value: T | null) {
+                fs.writeFileSync(path, JSON.stringify(value));
+            }
+        };
+    } else {
+        return {
+            get value() {
+                let json = localStorage.getItem(key);
+                if (!json) return null;
+                return JSON.parse(json) as T;
+            },
+            set value(value: T | null) {
+                localStorage.setItem(key, JSON.stringify(value));
+            }
+        };
+    }
+}

package/src/promise.ts

@@ -0,0 +1,15 @@
+export class PromiseObj<T = void> {
+    public promise: Promise<T>;
+    public resolve!: (value: T | PromiseLike<T>) => void;
+    public reject!: (reason?: any) => void;
+    public resolved = false;
+    public rejected = false;
+    constructor() {
+        this.promise = new Promise<T>((resolve, reject) => {
+            this.resolve = resolve;
+            this.reject = reject;
+        });
+        this.promise.finally(() => this.resolved = true);
+        this.promise.catch(() => this.rejected = true);
+    }
+}

package/src/server.ts

@@ -0,0 +1,73 @@
+import "./forceProduction";
+import "./inject";
+
+import { deepCloneJSON, isBufferType, isNode, isNodeTrue } from "socket-function/src/misc";
+import { SocketFunction } from "socket-function/SocketFunction";
+import { getOwnMachineId, getThreadKeyCert } from "./-a-auth/certs";
+import { logErrors } from "./errors";
+import { publishMachineARecords, verifyServicesAlive } from "./-e-certs/EdgeCertController";
+import { getPathStr, getPathStr1, prependToPathStr, rootPathStr } from "./path";
+import { authorityStorage, debugCoreMode, debugRejections, enableDebugRejections, pathValueArchives } from "./0-path-value-core/pathValueCore";
+import { listenOnDebugger } from "./diagnostics/listenOnDebugger";
+import fs from "fs";
+import { AuthorityPath, pathValueAuthority2 } from "./0-path-value-core/NodePathAuthorities";
+import { Querysub } from "./4-querysub/QuerysubController";
+import { ClientWatcher } from "./1-path-client/pathValueClientWatcher";
+import { delay } from "socket-function/src/batching";
+import yargs from "yargs";
+import { JSONLACKS } from "socket-function/src/JSONLACKS/JSONLACKS";
+import { green } from "socket-function/src/formatting/logColors";
+import { formatTime } from "socket-function/src/formatting/format";
+
+// As nice as it is that Querysub doesn't get imported, because our import hierarchy is so strict...
+//  we DO want to register some static diagnostics from Querysub, so... import it explicitly.
+import "./4-querysub/Querysub";
+import { getOwnThreadId } from "./-f-node-discovery/NodeDiscovery";
+import { getOurAuthorities } from "./config2";
+import { isPublic } from "./config";
+
+let yargObj = isNodeTrue() && yargs(process.argv)
+    .option("authority", { type: "string", desc: `Defines the base paths we are an authority on (the domain is prepended to them). Either a file path to a JSON(AuthorityPath[]), or a base64 representation of the JSON(AuthorityPath[]).` })
+    .argv || {}
+    ;
+
+logErrors(main());
+
+async function main() {
+    if (!isNode()) return;
+
+    console.log(`Time before main ${green(formatTime(process.uptime() * 1000))}`);
+
+    Error.stackTraceLimit = 20;
+
+    //SocketFunction.logMessages = true;
+
+    // ClientWatcher.DEBUG_READS = true;
+    // ClientWatcher.DEBUG_WRITES = true;
+
+    SocketFunction.WIRE_WARN_TIME = 50;
+
+    //setMaxChangeAge(1000 * 15);
+
+    //ActionsHistory.LOG_ACTION_HISTORY = "server";
+    listenOnDebugger("PathValueServer");
+
+    //debugCoreMode();
+    //enableDebugRejections();
+
+    for (let authority of getOurAuthorities()) {
+        pathValueAuthority2.becomePathAuthority(authority);
+    }
+
+    let keyPair = await getThreadKeyCert();
+    await SocketFunction.mount({
+        port: 0, ...keyPair, public: isPublic(),
+        // SHOULD be safe, because trust is still required. Otherwise we run into issues when we have some
+        //  public services, and some private, but still want to run things locally.
+        autoForwardPort: true,
+    });
+
+    verifyServicesAlive();
+
+    await publishMachineARecords();
+}

package/src/src.d.ts

@@ -0,0 +1 @@
+/// <reference path="./-a-auth/node-forge-ed25519.d.ts" />

package/src/test/heapProcess.ts

@@ -0,0 +1,36 @@
+import { formatNumber } from "socket-function/src/formatting/format";
+import { parseHeapSnapshot, processAndSummarizeHeapsnapshot } from "../heapDumps";
+import fs from "fs";
+
+async function heapProcess() {
+    /*
+    let targetRatePerSecond = 50;
+    let startTime = Date.now();
+    
+    for(let i = 0; i < 300 * 300; i++) {
+        sat_functions.setValues([i]);
+        
+        while (true) {
+            let rate = i / (Date.now() - startTime) * 1000;
+            if(rate < targetRatePerSecond) break;
+            await delay(16);
+        }
+    }
+    */
+
+    let buffer = fs.readFileSync("./heapdump.heapsnapshot");
+    let parsed = await parseHeapSnapshot("stressTest", buffer, () => { });
+
+    let snapshot = await processAndSummarizeHeapsnapshot(parsed, () => { }, {
+
+    });
+    console.log();
+
+    console.log(`Total ${formatNumber(snapshot.total)}`);
+    let values = Object.values(snapshot.summary);
+    values.sort((a, b) => b.sum - a.sum);
+    for (let value of values.slice(0, 100)) {
+        console.log(`${formatNumber(value.sum)} (${value.count})`.padEnd(20, "") + " " + value.key + ` (ex id ${value.firstId})`);
+    }
+}
+heapProcess().catch(e => console.error(e)).finally(() => process.exit());

package/src/test/mongoSatTest.tsx

@@ -0,0 +1,55 @@
+// import * as mongodb from "mongodb";
+// import { lazy } from "socket-function/src/caching";
+// import { BenchmarkFunctions, DriftValues, runSaturationTests } from "../diagnostics/runSaturationTest";
+
+// export type MongoRow = {
+//     _id: string;
+//     [prop: string]: unknown;
+// };
+
+// let getMongoClient = lazy(async (): Promise<mongodb.MongoClient> => {
+//     let client = await mongodb.MongoClient.connect(
+//         `mongodb://admin:password@127.0.0.1:33208/?authSource=admin&readPreference=primary&appname=MongoDB%20Compass&ssl=false`,
+//         {
+//             ignoreUndefined: true
+//         }
+//     );
+//     return client;
+// });
+// async function getCollection(database: string, collection: string) {
+//     let client = await getMongoClient();
+//     return await client.db(database).collection<MongoRow>(collection);
+// }
+
+// export async function createBenchmarkFunctions(): Promise<BenchmarkFunctions> {
+//     let collection = await getCollection("TEST_DB", "TEST_COLLECTION");
+//     return {
+//         async setValues(indexes: number[], value?: number) {
+//             if (value !== undefined) {
+//                 await collection.updateMany({ _id: { $in: indexes.map(i => i.toString()) } }, { $set: { value } }, { upsert: true });
+//             } else if (indexes.length === 1) {
+//                 await collection.updateOne({ _id: indexes[0].toString() }, { $inc: { value: 1 } }, {});
+//             } else {
+//                 await collection.updateMany({ _id: { $in: indexes.map(i => i.toString()) } }, { $inc: { value: 1 } as any }, {});
+//             }
+//         },
+//         async getValues(indexes: number[]): Promise<number[]> {
+//             let rows = await collection.find({ _id: { $in: indexes.map(i => i.toString()) } }).toArray();
+//             return rows.map(row => row.value as number);
+//         },
+//     };
+// }
+
+
+// export async function main() {
+//     await runSaturationTests({
+//         durationPer: 1000,
+//         //writeSpec: new DriftValues({ count: 77, modulus: INDEX_EXTENT, driftFraction: 0.1 }),
+//         //writeSpec: new DriftValues({ count: 10, modulus: INDEX_EXTENT, driftFraction: 0.1 }),
+//         //writeSpec: new DriftValues({ count: 9, modulus: 50 * 50, driftFraction: 0.1 }),
+//         writeSpec: new DriftValues({ count: 9, modulus: 50 * 50, driftFraction: 0.1 }),
+//         functions: await createBenchmarkFunctions(),
+//     });
+// }
+
+// main().catch(e => console.error(e)).finally(() => process.exit());

package/src/test/satTest.ts

@@ -0,0 +1,193 @@
+import debugbreak from "debugbreak";
+import { configRootDiscoveryLocation } from "../-f-node-discovery/NodeDiscovery";
+import { ClientWatcher } from "../1-path-client/pathValueClientWatcher";
+import { Querysub } from "../4-querysub/QuerysubController";
+configRootDiscoveryLocation({ domain: "querysub.com", port: 5050 });
+
+import { Benchmark } from "../diagnostics/benchmark";
+import { createBenchmarkFunctions, sat_functions } from "../diagnostics/satSchema";
+import { runSaturationTests, DriftValues, runSingleSaturationTest } from "../diagnostics/runSaturationTest";
+import { PermissionsCheck } from "../4-querysub/permissions";
+import { appendToPathStr, getPathIndex, getPathStr, getPathSuffix, rootPathStr, trimPathStrToDepth } from "../path";
+import { runCodeWithDatabase } from "../2-proxy/pathDatabaseProxyBase";
+import { createPathValueProxy } from "../2-proxy/pathValueProxy";
+import { proxyWatcher } from "../2-proxy/PathValueProxyWatcher";
+import { measureCode, measureFnc, measureWrap } from "socket-function/src/profiling/measure";
+import { DEPTH_TO_DATA, DOMAIN_INDEX, MODULE_INDEX, overrideCurrentCall } from "../3-path-functions/PathFunctionRunner";
+import { cache } from "socket-function/src/caching";
+import { timeInHour, timeInMinute } from "socket-function/src/misc";
+import { delay } from "socket-function/src/batching";
+import { parseHeapSnapshot, processAndSummarizeHeapsnapshot, writeHeapSnapshot } from "../heapDumps";
+import { formatNumber } from "socket-function/src/formatting/format";
+import fs from "fs";
+
+
+// A stress test with a single watcher
+/*
+    (watchdog at 12/31/2023) Profiled 684ms (logged at 2023-12-31T07:05:41.871Z)
+    ClientWatcher().setWatches(async)           34.47% (  236ms = 85 * 2.73ms   +  114 * 33.2us )
+    findFunctionsToCall                         16.12% (  110ms =      85 *  1.3ms )
+    PathWatcher().watchPath                     15.25% (  104ms = 85 * 1.22ms   +  114 * 8.68us )
+    watchLatest|getSingleReadNode                7.23% ( 49.5ms = 85 *  570us   +  114 * 9.35us )
+    PathWatcher().triggerLatestWatcher           5.95% ( 40.7ms =     169 *  241us )
+
+    (watchdog at 12/31/2023) Profiled 1.21s (logged at 2023-12-31T07:23:31.501Z)
+    findFunctionsToCall                         21.14% (  256ms = 5 * 42.1ms   +  19 * 2.39ms )
+    PathWatcher().triggerLatestWatcher          15.39% (  186ms =     919 *  203us )
+    PathValueCommitter().commitValues           12.14% (  147ms =     898 *  164us )
+    RemoteWatcher().watchLatest(async)          11.21% (  136ms =     922 *  147us )
+    AuthorityPathValueStorage().ingestValues     6.22% ( 75.3ms = 52 *  696us   +  869 * 45us )
+*/
+//  The proxyWatcher is taking most of the time, specifically due to the fact that it does not natively
+//      support delta based functions.
+
+async function stressTest() {
+    let targetRatePerSecond = 200;
+    let startTime = Date.now();
+
+    for (let i = 0; i < 300 * 300; i++) {
+        sat_functions.setValues([i]);
+
+        while (true) {
+            let rate = i / (Date.now() - startTime) * 1000;
+            if (rate < targetRatePerSecond) break;
+            await delay(16);
+        }
+    }
+
+}
+stressTest().catch(e => console.error(e)).finally(() => process.exit());
+
+async function timeTest() {
+    await Querysub.hostService("test");
+
+    await proxyWatcher.commitFunction({
+        watchFunction() {
+            const check = new PermissionsCheck({ callerMachineId: "", callerIP: "" });
+            let allowed = check.checkPermissions(getPathStr(["querysub.com", "PathFunctionRunner", "test", "Data", "test", "1"]));
+            console.log({ allowed });
+        },
+    });
+
+    // ~1.62us, so... if we can optimize this code... that would be good...
+    //  AND, it doesn't even emit any specific paths, so... we can probably cache it a lot...
+    let cache = new Map<string, { domainName: string; moduleId: string; pathPrefix: string; rootKey: string }>();
+    function splitParts(path: string): { domainName: string; moduleId: string; pathPrefix: string; rootKey: string } {
+        let pathPrefix = trimPathStrToDepth(path, DEPTH_TO_DATA);
+        let result = cache.get(pathPrefix);
+        if (!result) {
+            const domainName = getPathIndex(path, DOMAIN_INDEX) || "";
+            const moduleId = getPathIndex(path, MODULE_INDEX) || "";
+            let rootKey = getPathIndex(path, DEPTH_TO_DATA - 1) || "";
+            result = { domainName, moduleId, pathPrefix, rootKey };
+            cache.set(pathPrefix, result);
+        }
+        return result;
+    }
+
+    const simulateCheckPermissions = measureWrap(function simulateCheckPermissions(path: string) {
+        return trimPathStrToDepth(path, DEPTH_TO_DATA);
+
+        // let obj = splitParts(path);
+        // if (!obj.domainName) return { permissionsPath: trimPathStrToDepth(path, DOMAIN_INDEX + 1), allowed: false };
+        // if (!obj.moduleId) return { permissionsPath: trimPathStrToDepth(path, MODULE_INDEX + 1), allowed: false };
+        // if (!obj.rootKey) return { permissionsPath: trimPathStrToDepth(path, DEPTH_TO_DATA), allowed: false };
+
+        // let pathInModule = getPathSuffix(path, DEPTH_TO_DATA - 1);
+        // if (!pathInModule) return { permissionsPath: path, allowed: false };
+        // if (pathInModule === rootPathStr) return { permissionsPath: path, allowed: false };
+
+        // return obj;
+    });
+
+
+    await measureCode(async function permissionsCheckTest() {
+        await proxyWatcher.commitFunction({
+            watchFunction() {
+                console.log(`Start perf test`);
+
+                const check = new PermissionsCheck({ callerMachineId: "", callerIP: "127.0.0.1" });
+                let paths: string[] = [];
+                for (let i = 0; i < 1000 * 100; i++) {
+                    paths.push(getPathStr(["querysub.com", "PathFunctionRunner", "test", "Results", i.toString()]));
+                    //paths.push(getPathStr(["querysub.com", "PathFunctionRunner", "test", "Data", i.toString()]));
+                }
+                for (let path of paths) {
+                    check.checkPermissions(path);
+                }
+            },
+        });
+    });
+}
+//timeTest().catch(e => console.error(e)).finally(() => process.exit());
+
+export async function main() {
+    // let values = new DriftValues({ count: 9, modulus: 50 * 50, driftFraction: 0.1 });
+    // for (let i = 0; i < 10; i++) {
+    //     let calls = Array(100).fill(0).map(() =>
+    //         Benchmark.waitForCallToFinish(sat_functions.setValues(values.getNextValues()))
+    //     );
+    //     await Promise.all(calls);
+    // }
+
+
+    // await runSingleSaturationTest({
+    //     duration: 5000,
+    //     saturation: 100,
+    //     writeSpec: new DriftValues({ count: 9, modulus: 50 * 50, driftFraction: 0.1 }),
+    //     functions: createBenchmarkFunctions(),
+    // });
+
+    await runSaturationTests({
+        durationPer: 1000,
+        //writeSpec: new DriftValues({ count: 77, modulus: INDEX_EXTENT, driftFraction: 0.1 }),
+        //writeSpec: new DriftValues({ count: 10, modulus: INDEX_EXTENT, driftFraction: 0.1 }),
+        //writeSpec: new DriftValues({ count: 9, modulus: 50 * 50, driftFraction: 0.1 }),
+        writeSpec: new DriftValues({ count: 1, modulus: 50 * 50, driftFraction: 0.1 }),
+        functions: createBenchmarkFunctions(),
+    });
+}
+//main().catch(e => console.error(e)).finally(() => process.exit());
+
+
+/* 1s test time, 0 watchers (more watchers is slower)
+    new DriftValues({ count: 9, modulus: 50 * 50, driftFraction: 0.1 })
+Suggestions
+    Min latency          60.7/s     latency = 16.5ms (24.68% saturation)       (15 count)
+*** Min latency 2X       259/s      latency = 30.9ms (799.51% saturation)      (264 count)
+    100ms latency        348/s      latency = 91.6ms (3190.90% saturation)     (352 count)
+*/
+
+/*  1s test time
+    new DriftValues({ count: 1, modulus: 50 * 50, driftFraction: 0.1 })
+Suggestions
+    Min latency          42.6/s     latency = 23.4ms (25.45% saturation)       (11 count)
+*** Min latency 2X       303/s      latency = 52.7ms (1596.21% saturation)     (304 count)
+    100ms latency        368/s      latency = 86.8ms (3191.19% saturation)     (384 count)
+*/
+
+
+/* Same test on MongoDB
+    1s test time
+    writeSpec: new DriftValues({ count: 1, modulus: 50 * 50, driftFraction: 0.1 }),
+Suggestions
+    Min latency          214/s      latency = 4.68ms (24.53% saturation)       (53 count)
+*** Min latency 2X       4467/s     latency = 7.14ms (3190.04% saturation)     (4485 count)
+    100ms latency        4768/s     latency = 104ms  (49459.71% saturation)    (4983 count)
+    !!!! ERROR !!!!: 534 indexes were wrong, 1.80% of operations were missed
+
+    So mongo has about 1/4 the latency and 15X the throughput.
+        - Although, only 10X the throughput if we oversaturate our server and allow our latency to jump to 76.6ms.
+            WHICH, is fair, because the clientside predicts all the values, so the perceived latency will still usually be 0ms.
+        - ALSO, technically our perceived latency will be 0ms, at least for writes, due to client side prediction.
+            - ALSO, on any reasonable network the latency will be MUCH higher than 7ms, or 26ms, due to the network latency.
+                Except due to clientside prediction, Querysub will again, have 0ms perceived latency, so... our latency is
+                    actually MUCH better.
+        - The throughput different is promising, considering how we use javascript (and worse, Proxies) for everything. Also,
+            we are bottlenecked on function evaluation, which technically evaluates arbitrary application functions, which makes
+            it significantly more powerful than what mongodb support.
+            - The overwhelming majority of our time is spent in function evaluation (~80%), which is quite isolated, so
+                optimization should be possible (ex, rewriting FunctionRunner to run in another language, to run
+                specially application optimized functions in that other language).
+*/
+