querysub 0.433.0 → 0.436.0

package/src/-g-core-values/NodeCapabilities.ts

@@ -1,201 +1,201 @@
-/*
-    Find nodes that implement a specific controller.
-*/
-
-import { SocketFunction } from "socket-function/SocketFunction";
-import { SocketRegistered } from "socket-function/SocketFunctionTypes";
-import { errorToUndefined, errorToUndefinedSilent, timeoutToUndefinedSilent } from "../errors";
-import { getAllNodeIds, isNodeIdOnOwnMachineId } from "../-f-node-discovery/NodeDiscovery";
-import { green, red, yellow } from "socket-function/src/formatting/logColors";
-import { shuffle } from "../misc/random";
-import { delay } from "socket-function/src/batching";
-import debugbreak from "debugbreak";
-import { formatTime } from "socket-function/src/formatting/format";
-import type { DebugFunctionShardInfo } from "../3-path-functions/PathFunctionRunner";
-import { requiresNetworkTrustHook } from "../-d-trust/NetworkTrust2";
-import { isNoNetwork } from "../config";
-import { getDebuggerUrl } from "../diagnostics/listenOnDebugger";
-import { hackDevtoolsWebsocketForward } from "./oneTimeForward";
-import { getOwnMachineId, decodeNodeId, decodeNodeIdAssert, getMachineId } from "../-a-auth/certs";
-import { sort } from "socket-function/src/misc";
-import { getPathStr2 } from "../path";
-import { PromiseObj } from "../promise";
-import { getTrueTimeOffset } from "socket-function/time/trueTimeShim";
-setImmediate(() => {
-    import("../diagnostics/MachineThreadInfo");
-});
-
-let controllerNodeIdCache = new Map<string, string | Promise<string | undefined>>();
-
-// NOTE: If this becomes slow (because we are just trying all servers), we could start to store capabilities
-//  in PersistedStorage. However, I don't think it will be a problem for quite some time.
-export async function getControllerNodeId(
-    controller: SocketRegistered<{}>,
-    quiet = false,
-    retryCount = 1,
-    initialTime = Date.now(),
-): Promise<string | undefined> {
-    let cached = controllerNodeIdCache.get(controller._classGuid);
-    if (cached && typeof cached !== "string") {
-        cached = await cached;
-    }
-    // TODO: We are relying on is node connected to do a lot of work here. If the node's connected, but somehow doesn't work, we can get in an unrecoverable state, even if there are plenty of other working nodes.
-    if (cached && !SocketFunction.isNodeConnected(cached)) {
-        controllerNodeIdCache.delete(controller._classGuid);
-        cached = undefined;
-    }
-    if (cached) return cached;
-    let promise = getInternal(retryCount);
-    controllerNodeIdCache.set(controller._classGuid, promise);
-    return promise;
-
-    async function getInternal(retryCount: number) {
-        let nodeIdsToTest = await getAllNodeIds();
-        // Shuffle, so we aren't always using the same node!
-        nodeIdsToTest = shuffle(nodeIdsToTest, Date.now());
-        let resolvedNode = new PromiseObj<string>();
-
-        if (!quiet) {
-            console.log(`Checking ${nodeIdsToTest.length} nodes for capability ${controller._classGuid}`);
-        }
-        let allFinished = Promise.all(nodeIdsToTest.map(async nodeId => {
-            if (await doesNodeExposeController(nodeId, controller)) {
-                if (!quiet) {
-                    let duration = Date.now() - initialTime;
-                    console.log(green(`Resolved capability ${controller._classGuid} with node ${nodeId}, in ${formatTime(duration)}`));
-                }
-                resolvedNode.resolve(nodeId);
-            }
-        }));
-        let result = await Promise.race([allFinished, resolvedNode.promise]);
-        if (typeof result === "string") {
-            return result;
-        }
-
-        if (retryCount > 0) {
-            if (!quiet) {
-                console.log(`Did not find capability in ${nodeIdsToTest.length} nodes, retrying... ${controller._classGuid}`);
-            }
-            await delay(2000);
-            return getInternal(retryCount - 1);
-        }
-        if (!quiet) {
-            console.warn(yellow(`Could not find a node that exposes controller ${controller._classGuid}, tried: ${JSON.stringify(nodeIdsToTest)}`));
-        }
-        return undefined;
-    }
-}
-
-export async function getControllerNodeIdList(
-    controller: SocketRegistered<{}>,
-): Promise<{ nodeId: string; entryPoint: string }[]> {
-    let nodeIdsToTest = await getAllNodeIds();
-    let passedNodeIds = new Map<string, { machineId: string; entryPoint: string }>();
-    await Promise.all(nodeIdsToTest.map(async nodeId => {
-        let result = await doesNodeExposeController(nodeId, controller);
-        if (result) {
-            let entryPoint = await NodeCapabilitiesController.nodes[nodeId].getEntryPoint();
-            passedNodeIds.set(nodeId, {
-                machineId: getMachineId(nodeId),
-                entryPoint,
-            });
-        }
-    }));
-
-    let results = Array.from(passedNodeIds.entries());
-    // Prefer localhost connections as they're faster.
-    sort(results, (x) => isNodeIdOnOwnMachineId(x[0]) ? 0 : 1);
-    let lookup = new Map<string, { nodeId: string; entryPoint: string }>();
-    for (let x of results) {
-        let key = getPathStr2(x[1].machineId, decodeNodeIdAssert(x[0]).port.toString());
-        if (key in lookup) continue;
-        lookup.set(key, { nodeId: x[0], entryPoint: x[1].entryPoint });
-    }
-
-    return Array.from(lookup.values());
-}
-
-
-export async function doesNodeExposeController(reconnectNodeId: string, controller: SocketRegistered<{}>): Promise<boolean> {
-    let exposedControllers = await timeoutToUndefinedSilent(10_000, NodeCapabilitiesController.nodes[reconnectNodeId].getExposedControllers());
-
-    if (exposedControllers?.includes(controller._classGuid)) {
-        return true;
-    }
-    return false;
-}
-
-const startupTime = Date.now();
-class NodeCapabilitiesControllerBase {
-    public async getExposedControllers() {
-        return Array.from(SocketFunction.exposedClasses);
-    }
-    public async getEntryPoint() {
-        return process.argv[1];
-    }
-    public async getStartupTime() {
-        return startupTime;
-    }
-    public async getMemoryUsage() {
-        return process.memoryUsage();
-    }
-    public async getFunctionRunnerShards() {
-        return getFunctionRunnerShards();
-    }
-
-    public async getTrueTimeOffset() {
-        return getTrueTimeOffset();
-    }
-
-    public async getInspectURL() {
-        return await getDebuggerUrl();
-    }
-
-    public async exposeExternalDebugPortOnce(forExternalIP: string) {
-        // https://notdevtools.com/devtools/inspector.html?experiments=true&v8only=true&ws=127.0.0.1:62448/22895aed-f8da-4dfb-8d50-e432a9c2d827
-        let debugURL = await this.getInspectURL();
-
-        const outerUrl = new URL(debugURL);
-        const wsParam = outerUrl.searchParams.get("ws");
-        if (!wsParam) throw new Error("No ws parameter found");
-
-        // Add ws:// protocol to make it parseable by URL
-        const innerUrl = new URL(`ws://${wsParam}`);
-        const port = innerUrl.port;
-        if (!port) throw new Error("No port found");
-
-        const portNumber = parseInt(port, 10);
-        if (isNaN(portNumber)) throw new Error("Invalid port number");
-
-        let { externalPort, cancel } = await hackDevtoolsWebsocketForward({ internalPort: portNumber, externalIP: forExternalIP });
-        lastExposed?.();
-        lastExposed = cancel;
-        return { externalPort, internalPort: portNumber, internalInspectURL: debugURL };
-    }
-}
-let lastExposed: (() => void) | undefined;
-
-
-let getFunctionRunnerShards = () => [] as DebugFunctionShardInfo[];
-export function set_debug_getFunctionRunnerShards(fnc: () => DebugFunctionShardInfo[]) {
-    getFunctionRunnerShards = fnc;
-}
-
-export const NodeCapabilitiesController = SocketFunction.register(
-    "NodeCapabilitiesController-399b7067-75c3-4d92-8be3-8470bde32d3c",
-    new NodeCapabilitiesControllerBase(),
-    () => ({
-        getExposedControllers: {},
-        getEntryPoint: {},
-        getStartupTime: {},
-        getMemoryUsage: {},
-        getFunctionRunnerShards: {},
-        getTrueTimeOffset: {},
-        getInspectURL: { hooks: [requiresNetworkTrustHook] },
-        exposeExternalDebugPortOnce: { hooks: [requiresNetworkTrustHook] },
-    }),
-    () => ({
-        // I think assert is management user didn't exist when we wrote these functions, and so we just made them public. But now that it does exist, we might as well use it. Servers will count as management users anyway, and I don't see any reason a non-management user or a non-server needs to access any of these functions. 
-        hooks: [(require("../diagnostics/managementPages") as typeof import("../diagnostics/managementPages")).assertIsManagementUser],
-    })
+/*
+    Find nodes that implement a specific controller.
+*/
+
+import { SocketFunction } from "socket-function/SocketFunction";
+import { SocketRegistered } from "socket-function/SocketFunctionTypes";
+import { errorToUndefined, errorToUndefinedSilent, timeoutToUndefinedSilent } from "../errors";
+import { getAllNodeIds, isNodeIdOnOwnMachineId } from "../-f-node-discovery/NodeDiscovery";
+import { green, red, yellow } from "socket-function/src/formatting/logColors";
+import { shuffle } from "../misc/random";
+import { delay } from "socket-function/src/batching";
+import debugbreak from "debugbreak";
+import { formatTime } from "socket-function/src/formatting/format";
+import type { DebugFunctionShardInfo } from "../3-path-functions/PathFunctionRunner";
+import { requiresNetworkTrustHook } from "../-d-trust/NetworkTrust2";
+import { isNoNetwork } from "../config";
+import { getDebuggerUrl } from "../diagnostics/listenOnDebugger";
+import { hackDevtoolsWebsocketForward } from "./oneTimeForward";
+import { getOwnMachineId, decodeNodeId, decodeNodeIdAssert, getMachineId } from "../-a-auth/certs";
+import { sort } from "socket-function/src/misc";
+import { getPathStr2 } from "../path";
+import { PromiseObj } from "../promise";
+import { getTrueTimeOffset } from "socket-function/time/trueTimeShim";
+setImmediate(() => {
+    import("../diagnostics/MachineThreadInfo");
+});
+
+let controllerNodeIdCache = new Map<string, string | Promise<string | undefined>>();
+
+// NOTE: If this becomes slow (because we are just trying all servers), we could start to store capabilities
+//  in PersistedStorage. However, I don't think it will be a problem for quite some time.
+export async function getControllerNodeId(
+    controller: SocketRegistered<{}>,
+    quiet = false,
+    retryCount = 1,
+    initialTime = Date.now(),
+): Promise<string | undefined> {
+    let cached = controllerNodeIdCache.get(controller._classGuid);
+    if (cached && typeof cached !== "string") {
+        cached = await cached;
+    }
+    // TODO: We are relying on is node connected to do a lot of work here. If the node's connected, but somehow doesn't work, we can get in an unrecoverable state, even if there are plenty of other working nodes.
+    if (cached && !SocketFunction.isNodeConnected(cached)) {
+        controllerNodeIdCache.delete(controller._classGuid);
+        cached = undefined;
+    }
+    if (cached) return cached;
+    let promise = getInternal(retryCount);
+    controllerNodeIdCache.set(controller._classGuid, promise);
+    return promise;
+
+    async function getInternal(retryCount: number) {
+        let nodeIdsToTest = await getAllNodeIds();
+        // Shuffle, so we aren't always using the same node!
+        nodeIdsToTest = shuffle(nodeIdsToTest, Date.now());
+        let resolvedNode = new PromiseObj<string>();
+
+        if (!quiet) {
+            console.log(`Checking ${nodeIdsToTest.length} nodes for capability ${controller._classGuid}`);
+        }
+        let allFinished = Promise.all(nodeIdsToTest.map(async nodeId => {
+            if (await doesNodeExposeController(nodeId, controller)) {
+                if (!quiet) {
+                    let duration = Date.now() - initialTime;
+                    console.log(green(`Resolved capability ${controller._classGuid} with node ${nodeId}, in ${formatTime(duration)}`));
+                }
+                resolvedNode.resolve(nodeId);
+            }
+        }));
+        let result = await Promise.race([allFinished, resolvedNode.promise]);
+        if (typeof result === "string") {
+            return result;
+        }
+
+        if (retryCount > 0) {
+            if (!quiet) {
+                console.log(`Did not find capability in ${nodeIdsToTest.length} nodes, retrying... ${controller._classGuid}`);
+            }
+            await delay(2000);
+            return getInternal(retryCount - 1);
+        }
+        if (!quiet) {
+            console.warn(yellow(`Could not find a node that exposes controller ${controller._classGuid}, tried: ${JSON.stringify(nodeIdsToTest)}`));
+        }
+        return undefined;
+    }
+}
+
+export async function getControllerNodeIdList(
+    controller: SocketRegistered<{}>,
+): Promise<{ nodeId: string; entryPoint: string }[]> {
+    let nodeIdsToTest = await getAllNodeIds();
+    let passedNodeIds = new Map<string, { machineId: string; entryPoint: string }>();
+    await Promise.all(nodeIdsToTest.map(async nodeId => {
+        let result = await doesNodeExposeController(nodeId, controller);
+        if (result) {
+            let entryPoint = await NodeCapabilitiesController.nodes[nodeId].getEntryPoint();
+            passedNodeIds.set(nodeId, {
+                machineId: getMachineId(nodeId),
+                entryPoint,
+            });
+        }
+    }));
+
+    let results = Array.from(passedNodeIds.entries());
+    // Prefer localhost connections as they're faster.
+    sort(results, (x) => isNodeIdOnOwnMachineId(x[0]) ? 0 : 1);
+    let lookup = new Map<string, { nodeId: string; entryPoint: string }>();
+    for (let x of results) {
+        let key = getPathStr2(x[1].machineId, decodeNodeIdAssert(x[0]).port.toString());
+        if (key in lookup) continue;
+        lookup.set(key, { nodeId: x[0], entryPoint: x[1].entryPoint });
+    }
+
+    return Array.from(lookup.values());
+}
+
+
+export async function doesNodeExposeController(reconnectNodeId: string, controller: SocketRegistered<{}>): Promise<boolean> {
+    let exposedControllers = await timeoutToUndefinedSilent(10_000, NodeCapabilitiesController.nodes[reconnectNodeId].getExposedControllers());
+
+    if (exposedControllers?.includes(controller._classGuid)) {
+        return true;
+    }
+    return false;
+}
+
+const startupTime = Date.now();
+class NodeCapabilitiesControllerBase {
+    public async getExposedControllers() {
+        return Array.from(SocketFunction.exposedClasses);
+    }
+    public async getEntryPoint() {
+        return process.argv[1];
+    }
+    public async getStartupTime() {
+        return startupTime;
+    }
+    public async getMemoryUsage() {
+        return process.memoryUsage();
+    }
+    public async getFunctionRunnerShards() {
+        return getFunctionRunnerShards();
+    }
+
+    public async getTrueTimeOffset() {
+        return getTrueTimeOffset();
+    }
+
+    public async getInspectURL() {
+        return await getDebuggerUrl();
+    }
+
+    public async exposeExternalDebugPortOnce(forExternalIP: string) {
+        // https://notdevtools.com/devtools/inspector.html?experiments=true&v8only=true&ws=127.0.0.1:62448/22895aed-f8da-4dfb-8d50-e432a9c2d827
+        let debugURL = await this.getInspectURL();
+
+        const outerUrl = new URL(debugURL);
+        const wsParam = outerUrl.searchParams.get("ws");
+        if (!wsParam) throw new Error("No ws parameter found");
+
+        // Add ws:// protocol to make it parseable by URL
+        const innerUrl = new URL(`ws://${wsParam}`);
+        const port = innerUrl.port;
+        if (!port) throw new Error("No port found");
+
+        const portNumber = parseInt(port, 10);
+        if (isNaN(portNumber)) throw new Error("Invalid port number");
+
+        let { externalPort, cancel } = await hackDevtoolsWebsocketForward({ internalPort: portNumber, externalIP: forExternalIP });
+        lastExposed?.();
+        lastExposed = cancel;
+        return { externalPort, internalPort: portNumber, internalInspectURL: debugURL };
+    }
+}
+let lastExposed: (() => void) | undefined;
+
+
+let getFunctionRunnerShards = () => [] as DebugFunctionShardInfo[];
+export function set_debug_getFunctionRunnerShards(fnc: () => DebugFunctionShardInfo[]) {
+    getFunctionRunnerShards = fnc;
+}
+
+export const NodeCapabilitiesController = SocketFunction.register(
+    "NodeCapabilitiesController-399b7067-75c3-4d92-8be3-8470bde32d3c",
+    new NodeCapabilitiesControllerBase(),
+    () => ({
+        getExposedControllers: {},
+        getEntryPoint: {},
+        getStartupTime: {},
+        getMemoryUsage: {},
+        getFunctionRunnerShards: {},
+        getTrueTimeOffset: {},
+        getInspectURL: { hooks: [requiresNetworkTrustHook] },
+        exposeExternalDebugPortOnce: { hooks: [requiresNetworkTrustHook] },
+    }),
+    () => ({
+        // I think assert is management user didn't exist when we wrote these functions, and so we just made them public. But now that it does exist, we might as well use it. Servers will count as management users anyway, and I don't see any reason a non-management user or a non-server needs to access any of these functions. 
+        hooks: [(require("../diagnostics/managementPages") as typeof import("../diagnostics/managementPages")).assertIsManagementUser],
+    })
 );