querysub 0.2.0

package/src/diagnostics/NodeViewer.tsx

@@ -0,0 +1,503 @@
+import preact from "preact"; import { qreact } from "../../src/4-dom/qreact";
+import { SocketFunction } from "socket-function/SocketFunction";
+import { css } from "typesafecss";
+import { getAllNodeIds, getBrowserUrlNode, getOwnNodeId, syncNodesNow } from "../../src/-f-node-discovery/NodeDiscovery";
+import { errorToUndefined, logErrors, timeoutToError } from "../../src/errors";
+import { Querysub } from "../../src/4-querysub/QuerysubController";
+import { NodeCapabilitiesController, getControllerNodeIdList } from "../../src/-g-core-values/NodeCapabilities";
+import { AuthorityPath, debug_getAuthorityPaths, debug_isReadReady, nodePathAuthority } from "../../src/0-path-value-core/NodePathAuthorities";
+import { lazy } from "socket-function/src/caching";
+import { atomicObjectWrite } from "../../src/2-proxy/PathValueProxyWatcher";
+import { formatNumber } from "socket-function/src/formatting/format";
+import { Button } from "../../src/library-components/Button";
+import { URLParam } from "../../src/library-components/URLParam";
+import { InputLabelURL } from "../../src/library-components/InputLabel";
+import { ColumnType, ColumnsType, RowType, Table, TableType } from "../../src/5-diagnostics/Table";
+import { MaybePromise } from "socket-function/src/types";
+import { requiresNetworkTrustHook } from "../../src/-d-trust/NetworkTrust2";
+import { getDomain, isNoNetwork } from "../../src/config";
+import { NodeMetadataController } from "../../src/5-diagnostics/nodeMetadata";
+import { isDefined } from "../../src/misc";
+import { errorMessage, formatValue, toSpaceCase } from "../../src/5-diagnostics/GenericFormat";
+import { ValueAuditController } from "../../src/5-diagnostics/memoryValueAudit";
+import { getExternalIP } from "../../src/misc/networking";
+import dns from "dns";
+import { getNodeIdDomain, getNodeIdIP } from "socket-function/src/nodeCache";
+import { debugGetRawEdgeCert } from "../../src/-e-certs/EdgeCertController";
+import ws from "ws";
+import https from "https";
+import debugbreak from "debugbreak";
+import { forwardPort } from "socket-function/src/forwardPort";
+import { setRecord } from "../-b-authorities/dnsAuthority";
+import tls from "tls";
+import net from "net";
+import { ButtonSelector } from "../library-components/ButtonSelector";
+import { assertIsManagementUser } from "./managementPages";
+import { SocketRegistered } from "socket-function/SocketFunctionTypes";
+
+
+type NodeData = {
+    nodeId: string;
+
+    ip?: string;
+    devToolsURL?: string;
+
+    live_isReadReady?: number;
+    live_authorityPaths?: AuthorityPath[];
+    live_exposedControllers?: string[];
+    live_entryPoint?: string;
+    apiError?: string;
+    table?: {
+        columns: ColumnsType;
+        row: RowType;
+    };
+
+};
+
+module.hotreload = true;
+const showNotReadyNodes = new URLParam("showNotReadyNodes", false);
+const selectedGroup = new URLParam("viewGroup", "Default");
+export class NodeViewer extends qreact.Component {
+    state = {
+        access: "verifying" as "verifying" | "no" | "yes",
+        error: "",
+
+        nodeIds: [] as string[],
+        nodes: {} as {
+            // atomic
+            [nodeId: string]: NodeData
+        },
+    };
+    populateNodeInfos = lazy(() => {
+        logErrors((async () => {
+            try {
+                const controller = NodeViewerController.nodes[getBrowserUrlNode()];
+                let nodeIds = await controller.getAllNodeIds();
+                Querysub.commit(() => this.state.nodeIds = nodeIds);
+
+                let ourIP = await controller.getCallerIP();
+
+                await Promise.allSettled(nodeIds.map(async nodeId => {
+                    let data: NodeData = { nodeId };
+                    try {
+                        data.table = await controller.getMiscInfo(nodeId);
+                        data.live_isReadReady = await controller.live_isReadReady(nodeId);
+                        data.live_exposedControllers = await controller.getExposedControllers(nodeId);
+                        data.live_entryPoint = await controller.live_getEntryPoint(nodeId);
+                        data.live_authorityPaths = await controller.live_getAuthorityPaths(nodeId);
+                        data.ip = await controller.getNodeIP(nodeId);
+                        if (data.ip === ourIP || data.ip === "127.0.0.1") {
+                            data.devToolsURL = await controller.getInspectURL(nodeId);
+                            if (data.devToolsURL) {
+                                data.devToolsURL = data.devToolsURL + "<inspect>";
+                            }
+                        } else {
+                            data.devToolsURL = nodeId;
+                        }
+                    } catch (e: any) {
+                        data.apiError = "Error: " + e.stack;
+                    }
+                    Querysub.commit(() => {
+                        this.state.nodes[nodeId] = atomicObjectWrite(data);
+                    });
+                }));
+            } catch (e: any) {
+                Querysub.commit(() => this.state.error = e.stack);
+            }
+        })());
+    });
+    componentWillMount(): void {
+        logErrors((async () => {
+            const controller = NodeViewerController.nodes[getBrowserUrlNode()];
+            let verifyAccess = await errorToUndefined(controller.verifyAccess());
+            Querysub.commit(() => this.state.access = verifyAccess ? "yes" : "no");
+
+            this.populateNodeInfos();
+        })());
+    }
+    renderTable(columns: string[], objs: { [key: string]: unknown }[]) {
+        return (
+            <table class={css.borderCollapse("collapse")}>
+                <tr>
+                    {columns.map(x => <th>{x}</th>)}
+                </tr>
+                {objs.map(obj => (
+                    <tr>
+                        {columns.map(x => <td>{obj[x] as any}</td>)}
+                    </tr>
+                ))}
+            </table>
+        );
+    }
+    render() {
+        if (this.state.access === "no") {
+            return <div>Requires superadmin to access</div>;
+        }
+        if (this.state.access === "verifying") {
+            return <div>Verifying access...</div>;
+        }
+        let nodeDatas = Object.values(this.state.nodes);
+        if (!showNotReadyNodes.value) {
+            nodeDatas = nodeDatas.filter(x => x.live_isReadReady);
+        }
+
+        function mergeTables(tables: TableType[]): TableType {
+            let columns: ColumnsType = {};
+            for (let table of tables) {
+                for (let [columnName, column] of Object.entries(table.columns)) {
+                    columns[columnName] = column;
+                }
+            }
+            let rows = tables.flatMap(x => x.rows);
+            for (let column in columns) {
+                if (rows.every(x => {
+                    let value = x[column];
+                    return value === undefined || value === null || value === "" || Array.isArray(value) && value.length === 0;
+                })) {
+                    delete columns[column];
+                }
+            }
+            return { columns, rows, };
+        }
+
+        let tables: { [key: string]: NodeData[] } = {};
+        tables["PathValueServer"] = [];
+        tables["FunctionRunner"] = [];
+        tables["Querysub"] = [];
+        for (let datum of nodeDatas) {
+            if (datum.live_authorityPaths?.length) {
+                tables["PathValueServer"].push(datum);
+            } else if (datum.live_exposedControllers?.includes("QuerysubController-6db5ef05-7563-4473-a440-2f64f03fe6ef")) {
+                tables["Querysub"].push(datum);
+            } else if (datum.live_entryPoint?.endsWith("function.js")) {
+                tables["FunctionRunner"].push(datum);
+            } else {
+                let entryName = datum.live_entryPoint?.replaceAll("\\", "/").split("/").pop() || "Unknown";
+                tables[entryName] = tables[entryName] || [];
+                tables[entryName].push(datum);
+            }
+        }
+
+        let builtinGroups = {
+            "Default": ["buttons", "devToolsURL", "ip", "uptime", "Heap", "All Memory", "Blocking Lag", "port", "threadId", "machineId", "apiError"],
+        };
+        // Column => group
+        let builtInGroupsLookup = new Map<string, string>();
+        for (let [group, columns] of Object.entries(builtinGroups)) {
+            for (let column of columns) {
+                builtInGroupsLookup.set(column, group);
+            }
+        }
+        let groupedTables: {
+            [groupTitle: string]: {
+                [key: string]: true;
+            };
+        } = {};
+        for (let [group, values] of Object.entries(builtinGroups)) {
+            groupedTables[group] = Object.fromEntries(values.map(x => [x, true]));
+        }
+        for (let [name, tableList] of Object.entries(tables)) {
+            for (let table of tableList) {
+                let row = table.table?.row || {};
+                for (let column in row) {
+                    let groupTitle = builtInGroupsLookup.get(column) || "Other";
+                    if (column.includes("|")) {
+                        groupTitle = column.split("|")[0];
+                    }
+                    groupedTables[groupTitle] = groupedTables[groupTitle] || {};
+                    groupedTables[groupTitle][column] = true;
+                }
+            }
+        }
+
+        let visibleColumns = Object.keys(groupedTables[selectedGroup.value] || {});
+
+        return (
+            <div class={css.pad2(10).vbox(10)}>
+                <ButtonSelector
+                    options={Object.keys(groupedTables).map(x => ({ value: x, title: toSpaceCase(x) }))}
+                    onChange={x => selectedGroup.value = x}
+                    value={selectedGroup.value}
+                />
+                <div class={css.wrap.hbox(10)}>
+                    <Button onClick={async () => {
+                        await NodeViewerController.nodes[getBrowserUrlNode()].forceRefreshNodes();
+                        this.populateNodeInfos.reset();
+                        this.populateNodeInfos();
+                    }}>Refresh</Button>
+                    <InputLabelURL label="Show Not Ready" checkbox url={showNotReadyNodes} />
+                    {this.state.error && <div class={errorMessage}>{this.state.error}</div>}
+                </div>
+                <div class={css.vbox(10)}>
+                    {Object.entries(tables).map(([name, data]) => {
+                        let finalTable = mergeTables(data.map(x => ({
+                            columns: {
+                                buttons: {
+                                    formatter: () => {
+                                        return <span class={css.hbox(6)}>
+                                            <Button onClick={() => NodeViewerController.nodes[getBrowserUrlNode()].diskAuditNow(x.nodeId)}>Disk Audit</Button>
+                                            <Button onClick={() => NodeViewerController.nodes[getBrowserUrlNode()].memoryAuditNow(x.nodeId)}>Memory Audit</Button>
+                                        </span>;
+                                    }
+                                },
+                                devToolsURL: {
+                                    formatter: (obj) => {
+                                        let str = String(obj);
+                                        if (str.startsWith("http")) return formatValue(obj);
+                                        return (
+                                            <button onClick={async () => {
+                                                const controller = NodeViewerController.nodes[getBrowserUrlNode()];
+                                                let url = await controller.getExternalInspectURL(str);
+
+                                                window.open(url, "_blank");
+                                            }}>
+                                                Inspect
+                                            </button>
+                                        );
+                                    },
+                                },
+                                ip: {},
+                                ...x.table?.columns,
+                                //capabilities: null,
+                                apiError: { formatter: "error" },
+                            },
+                            rows: [{
+                                buttons: true,
+                                ...x.table?.row,
+                                ...x,
+                            }],
+                        })));
+                        finalTable.columns = Object.fromEntries(visibleColumns.filter(x => x in finalTable.columns).map(x => [x, finalTable.columns[x]]));
+                        for (let [title, column] of Object.entries(finalTable.columns)) {
+                            if (!column) continue;
+                            column = { ...column };
+                            finalTable.columns[title] = column;
+                            column.title = column.title || toSpaceCase(title.split("|")[1] || title);
+                        }
+                        return (
+                            <div class={css.hsl(75, 50, 75).pad2(10)}>
+                                <h2>{name} ({data.length})</h2>
+                                <Table
+                                    {...finalTable}
+                                />
+                            </div>
+                        );
+                    })}
+                </div>
+            </div>
+        );
+    }
+}
+
+class NodeViewerControllerBase {
+    public async verifyAccess() {
+        return true;
+    }
+
+    public async getNodeIP(nodeId: string) {
+        let domain = nodeId.split(":")[0];
+        // Resolve the domain to an IP
+        let result = await dns.promises.lookup(domain);
+        return result.address;
+    }
+
+    public async getCallerIP() {
+        let callerIP = getNodeIdIP(SocketFunction.getCaller().nodeId);
+        return (await dns.promises.lookup(callerIP)).address;
+    }
+
+    public async getExternalInspectURL(nodeId: string) {
+        let callerIP = getNodeIdIP(SocketFunction.getCaller().nodeId);
+        let ourIP = await getExternalIP();
+        let { externalPort, internalPort, internalInspectURL } = await NodeCapabilitiesController.nodes[nodeId].exposeExternalDebugPortOnce(ourIP);
+
+        let baseNodeIP = getNodeIdIP(nodeId);
+        let baseNodeIPResolved = (await dns.promises.lookup(baseNodeIP)).address;
+
+        // Listen on a websocket, and forward to externalPort:baseNodeIP
+        let cert = await debugGetRawEdgeCert();
+
+        let tlsServer = new tls.Server({
+            key: cert.key,
+            cert: cert.cert,
+        });
+        tlsServer.listen(0, "0.0.0.0");
+        await new Promise((resolve, reject) => {
+            tlsServer.once("listening", resolve);
+            tlsServer.once("error", reject);
+        });
+
+        let finalPort = (tlsServer.address() as any).port;
+
+        await forwardPort({ internalPort: finalPort, externalPort: finalPort, });
+        await forwardPort({ internalPort: externalPort, externalPort: externalPort, });
+
+        tlsServer.on("secureConnection", (socket) => {
+            if (socket.remoteAddress !== callerIP) {
+                console.error(`Rejecting connection from ${socket.remoteAddress}, expected ${callerIP}`);
+                socket.end();
+                return;
+            }
+
+            let internalConnection = net.createConnection({
+                host: baseNodeIPResolved,
+                port: externalPort,
+            });
+            socket.pipe(internalConnection);
+            internalConnection.pipe(socket);
+
+            socket.on("close", () => {
+                tlsServer.close();
+            });
+        });
+
+        // Ugh... what a nightmare...
+        let ourDomain = ourIP.replaceAll(".", "-") + "." + getDomain();
+        await setRecord("A", ourDomain, ourIP);
+
+        console.log(`${ourDomain}:${finalPort} => ${baseNodeIPResolved}:${externalPort} => 127.0.0.1:${internalPort}, for ${callerIP}`);
+
+        return internalInspectURL.replace(`ws=127.0.0.1:${internalPort}`, `wss=${ourDomain}:${finalPort}`);
+    }
+
+    public async getInspectURL(nodeId: string) {
+        return await NodeCapabilitiesController.nodes[nodeId].getInspectURL();
+    }
+
+    public async getAllNodeIds() {
+        return await getAllNodeIds();
+    }
+    public async forceRefreshNodes() {
+        await syncNodesNow();
+    }
+
+    public async getExposedControllers(nodeId: string) {
+        return await NodeCapabilitiesController.nodes[nodeId].getExposedControllers();
+    }
+
+    public async getControllerNodeIdList(controller: SocketRegistered<{}>) {
+        return await getControllerNodeIdList(controller);
+    }
+
+    public async live_isReadReady(nodeId: string) {
+        return debug_isReadReady(nodeId);
+    }
+    public async live_getAuthorityPaths(nodeId: string) {
+        return debug_getAuthorityPaths(nodeId);
+    }
+    public async live_getEntryPoint(nodeId: string) {
+        return NodeCapabilitiesController.nodes[nodeId].getEntryPoint();
+    }
+
+    public async getMiscInfo(nodeId: string): Promise<{
+        columns: ColumnsType;
+        row: RowType;
+    }> {
+        let row: RowType = {};
+        let columns: ColumnsType = {};
+        async function wrapAddTableValue(columnName: string, column: ColumnType, getValue: () => Promise<unknown>) {
+            columns[columnName] = column;
+            try {
+                let value = await timeoutToError(10000, getValue(), () => new Error(`Timeout after 10s`));
+                row[columnName] = value;
+            } catch (e: any) {
+                row[columnName] = "Error: " + e.stack;
+            }
+        }
+        let promises = [
+            wrapAddTableValue("paths|paths", {}, async () => {
+                let live_authorityPaths = await debug_getAuthorityPaths(nodeId);
+                return live_authorityPaths.map(x => JSON.stringify(x)).join(" | ");
+            }),
+            wrapAddTableValue("paths|functions", {}, async () => {
+                let live_functionRunnerShards = await NodeCapabilitiesController.nodes[nodeId].getFunctionRunnerShards();
+                return live_functionRunnerShards.map(x => `${x.domainName}[${x.shardRange.startFraction}-${x.shardRange.endFraction}]${x.secondaryShardRange && `+[${x.secondaryShardRange?.startFraction || 0}-${x.secondaryShardRange?.endFraction || 0}]` || ""}`).join(" | ");
+            }),
+            wrapAddTableValue("uptime", { formatter: "timeSpan" }, async () => {
+                let startupTime = await NodeCapabilitiesController.nodes[nodeId].getStartupTime();
+                return Date.now() - startupTime;
+            }),
+            wrapAddTableValue("port", {}, async () => {
+                return nodeId.split(":").at(-1);
+            }),
+            // 
+            wrapAddTableValue("threadId", {
+                formatter: "link:/?page=user&showingmanagement&managementpage=LogViewer&filterThreadIds=$VALUE$<Thread Errors $VALUE$>"
+            }, async () => {
+                return nodeId.split(".").at(-4);
+            }),
+            wrapAddTableValue("machineId", {
+                formatter: "link:/?page=user&showingmanagement&managementpage=LogViewer&filterMachineIds=$VALUE$<Machine Errors =$VALUE$>"
+            }, async () => {
+                return nodeId.split(".").at(-3);
+            }),
+            wrapAddTableValue("miscAudits", { formatter: "varray:error" }, async () => {
+                let live_authorityPaths = await debug_getAuthorityPaths(nodeId);
+                let cached_authority = await nodePathAuthority.debug_getAuthority(nodeId);
+                let live_isReadReady = await debug_isReadReady(nodeId);
+                return [
+                    live_isReadReady && !cached_authority && `Authority is missing in cache`,
+                    JSON.stringify(live_authorityPaths) !== JSON.stringify(cached_authority?.authorityPaths) && `Paths are out of sync. Cache has ${JSON.stringify(cached_authority?.authorityPaths)} live has ${JSON.stringify(live_authorityPaths)}`,
+                    live_isReadReady !== cached_authority?.isReadReady && `isReadReady is out of sync. Cache has ${cached_authority?.isReadReady} live has ${live_isReadReady}`,
+                ].filter(x => x);
+            }),
+            wrapAddTableValue("capabilities|capabilities", {}, async () => {
+                let live_exposedControllers = await NodeCapabilitiesController.nodes[nodeId].getExposedControllers();
+                return live_exposedControllers.map(x => x.split("-")[0]);
+            }),
+        ];
+        await Promise.allSettled(promises);
+        try {
+            let extraMetadatas = await timeoutToError(10000, NodeMetadataController.nodes[nodeId].getExtraMetadatas(), () => new Error(`Timeout after 10s`));
+            for (let { columnName, column, value } of extraMetadatas) {
+                columns[columnName] = column;
+                row[columnName] = value;
+            }
+        } catch (e: any) {
+            // Any errors almost certainly mean they aren't exposing any extra metadata, which is fine.
+            // columns["extraMetadatasError"] = { formatter: "error" };
+            // row["extraMetadatasError"] = "Error: " + e.stack;
+        }
+        return {
+            columns,
+            row,
+        };
+    }
+
+    public async diskAuditNow(nodeId: string) {
+        await ValueAuditController.nodes[nodeId].diskAuditNow();
+    }
+    public async memoryAuditNow(nodeId: string) {
+        await ValueAuditController.nodes[nodeId].memoryAuditNow();
+    }
+}
+
+export const NodeViewerController = SocketFunction.register(
+    "NodeViewerController-82b982f4-279e-4850-997e-ece8ac7604ee",
+    new NodeViewerControllerBase(),
+    () => ({
+        getNodeIP: {},
+        getInspectURL: {},
+        getCallerIP: {},
+        getExternalInspectURL: {},
+        verifyAccess: {},
+        getAllNodeIds: {},
+        getExposedControllers: {},
+        getControllerNodeIdList: {},
+        live_isReadReady: {},
+        live_getAuthorityPaths: {},
+        live_getEntryPoint: {},
+        getMiscInfo: {},
+
+        diskAuditNow: {},
+        memoryAuditNow: {},
+        forceRefreshNodes: {},
+    }),
+    () => ({
+        hooks: [assertIsManagementUser],
+    }),
+    {
+        // Auto expose, for getMiscInfo. This is protected via assertIsManagementUser anyways.
+        //noAutoExpose: true,
+    }
+);

package/src/diagnostics/SizeLimiter.ts

@@ -0,0 +1,62 @@
+import diskusage from "diskusage";
+import { readDirRecursive } from "../fs";
+import fs from "fs";
+import { sort } from "socket-function/src/misc";
+
+export type SizeSpec = {
+    time: number;
+    bytes: number;
+};
+export class SizeLimiter {
+    constructor(private config: {
+        diskRoot: string;
+        maxBytes: number;
+        minBytes: number;
+        // Ex, 5%
+        maxDiskFraction: number;
+        // Max the disk can be full. We still respect minBytes, this just makes us be more respectful of space
+        //  usage if the disk is about to run out of space.
+        // Ex, 95%
+        maxTotalDiskFraction: number;
+        maxFiles: number;
+    }) { }
+
+    public async limit<T extends SizeSpec>(files: T[]): Promise<{
+        keep: T[];
+        remove: T[];
+        availableBytes: number;
+        availableFiles: number;
+    }> {
+        const { diskRoot, maxBytes, minBytes, maxDiskFraction, maxTotalDiskFraction, maxFiles } = this.config;
+
+        let minCandidates: number[] = [];
+        let usage = await diskusage.check(diskRoot);
+
+        minCandidates.push(usage.free - usage.total * (1 - maxTotalDiskFraction));
+        minCandidates.push(usage.total * maxDiskFraction);
+        minCandidates.push(maxBytes);
+
+        let remainingSpace = Math.max(minBytes, Math.min(...minCandidates));
+
+        files = files.slice();
+        sort(files, x => -x.time);
+
+        let keepIndex = 0;
+        let usedBytes = 0;
+        for (let i = 0; i < files.length && i < maxFiles; i++) {
+            usedBytes += files[i].bytes;
+            if (usedBytes > remainingSpace) {
+                break;
+            }
+            keepIndex = i;
+        }
+        return {
+            keep: files.slice(0, keepIndex + 1),
+            remove: files.slice(keepIndex + 1),
+            availableBytes: remainingSpace - usedBytes,
+            availableFiles: maxFiles - keepIndex - 1,
+        };
+    }
+}
+
+

package/src/diagnostics/TimeDebug.tsx

@@ -0,0 +1,18 @@
+import preact from "preact"; import { qreact } from "../../src/4-dom/qreact";
+import { Querysub } from "../../src/4-querysub/QuerysubController";
+import { formatTime } from "socket-function/src/formatting/format";
+import { getTrueTimeOffset } from "socket-function/time/trueTimeShim";
+import { css } from "typesafecss";
+
+export class TimeDebug extends qreact.Component {
+    render() {
+        Querysub.timeDelayed(100);
+        return (
+            <div class={css.pad2(10).vbox(10)}>
+                <div>System Clock Offset: {formatTime(getTrueTimeOffset())}</div>
+                <div>Current Time: {Date.now()}</div>
+                <div>{new Date(Date.now()).toLocaleString()}</div>
+            </div>
+        );
+    }
+}