querysub 0.459.0 → 0.461.0

package/src/diagnostics/AuditLogPage.tsx

@@ -1,147 +0,0 @@
-import { SocketFunction } from "socket-function/SocketFunction";
-import { qreact } from "../4-dom/qreact";
-import { assertIsManagementUser } from "./managementPages";
-import { css } from "typesafecss";
-import { getSyncedController } from "../library-components/SyncedController";
-import { DebugLog, DebugLogController, getLogHistoryEquals, getLogHistoryIncludes } from "../0-path-value-core/auditLogs";
-import { remoteWatcher } from "../1-path-client/RemoteWatcher";
-import { getBrowserUrlNode, getOwnNodeId } from "../-f-node-discovery/NodeDiscovery";
-import { nextId, sort } from "socket-function/src/misc";
-import { t } from "../2-proxy/schema2";
-import { InputLabelURL } from "../library-components/InputLabel";
-import { URLParam } from "../library-components/URLParam";
-import { Table } from "../5-diagnostics/Table";
-import { ObjectDisplay } from "./logs/ObjectDisplay";
-import { PathRouter } from "../0-path-value-core/PathRouter";
-
-/**
-TODO:
-    1) Support watching multiple paths at once
-    2) Show extra metadata for the paths
-        - Current value (raw, as in, don't sync it)
-        - If it is synced
-        - The authority of it
-        - An expander which shows a table of the full history of values, with valid state, etc
-*/
-
-type DebugLogWithSource = DebugLog & {
-    sourceType: "local" | "remote";
-    sourceNodeId: string;
-}
-
-let path = new URLParam("path", "");
-let includeDescendants = new URLParam("includeDescendants", false);
-export class AuditLogPage extends qreact.Component {
-    loadId = nextId();
-    state = t.state({
-        loadedId: t.string
-    });
-    render() {
-        let logs: DebugLogWithSource[] = [];
-        let loaded = this.loadId === this.state.loadedId;
-        if (loaded) {
-            let obj = auditLogController(getBrowserUrlNode()).getPathHistory({
-                path: path.value,
-                includeDescendants: includeDescendants.value,
-            });
-            if (obj) {
-                logs = obj.fullLogs;
-            }
-        }
-        return (
-            <div class={css.pad2(10).vbox(10).fillWidth}>
-                <InputLabelURL
-                    label="Path"
-                    url={path}
-                    fillWidth
-                    onChange={() => this.loadId = nextId()}
-                />
-                <InputLabelURL
-                    label="Include Descendants"
-                    url={includeDescendants}
-                    checkbox
-                    onChange={() => this.loadId = nextId()}
-                />
-                {!loaded && <button onClick={() => this.state.loadedId = this.loadId}>Load</button>}
-                <Table
-                    rows={logs}
-                    columns={{
-                        type: {},
-                        time: {},
-                        sourceType: {},
-                        sourceNodeId: {},
-                        values: {
-                            formatter(value) {
-                                return <ObjectDisplay value={value} />;
-                            },
-                        },
-                    }}
-                />
-            </div>
-        );
-    }
-}
-
-
-class AuditLogControllerBase {
-    public async getPathHistory(config: {
-        path: string;
-        includeDescendants?: boolean;
-    }) {
-        let { path, includeDescendants } = config;
-        let authorityNodeId = remoteWatcher.getExistingWatchRemoteNodeId(path);
-        if (!authorityNodeId) {
-            authorityNodeId = await PathRouter.getReadyAuthority(path)?.nodeId;
-        }
-        let logs: DebugLog[] = [];
-        let remoteLogs: DebugLog[] = [];
-        if (includeDescendants) {
-            // Also look for the parent, so we can capture keys() syncs as well
-            //  (this should give us child paths too, because that's how includes works)
-            logs = getLogHistoryIncludes(path);
-            if (authorityNodeId) {
-                remoteLogs = await DebugLogController.nodes[authorityNodeId].getLogHistoryEquals(path);
-            }
-        } else {
-            logs = getLogHistoryEquals(path);
-            if (authorityNodeId) {
-                remoteLogs = await DebugLogController.nodes[authorityNodeId].getLogHistoryEquals(path);
-            }
-        }
-
-        let fullLogs: DebugLogWithSource[] = [];
-        let ownNodeId = getOwnNodeId();
-        for (let log of logs) {
-            fullLogs.push({
-                ...log,
-                sourceType: "local",
-                sourceNodeId: ownNodeId,
-            });
-        }
-        if (authorityNodeId) {
-            for (let log of remoteLogs) {
-                fullLogs.push({
-                    ...log,
-                    sourceType: "remote",
-                    sourceNodeId: authorityNodeId,
-                });
-            }
-        }
-        sort(fullLogs, x => x.time);
-        return {
-            fullLogs,
-        };
-    }
-}
-
-export const AuditLogController = SocketFunction.register(
-    "AuditLogController-bf798faf-c803-4add-ac2c-99d0f44e753a",
-    new AuditLogControllerBase(),
-    () => ({
-        getPathHistory: {},
-    }),
-    () => ({
-        hooks: [assertIsManagementUser],
-    })
-);
-export const auditLogController = getSyncedController(AuditLogController);

package/src/diagnostics/NodeConnectionsPage.tsx

@@ -1,167 +0,0 @@
-import { SocketFunction } from "socket-function/SocketFunction";
-import { qreact } from "../4-dom/qreact";
-import { assertIsManagementUser } from "./managementPages";
-import { css } from "typesafecss";
-import { getSyncedController } from "../library-components/SyncedController";
-import { getAllNodeIds, getBrowserUrlNode } from "../-f-node-discovery/NodeDiscovery";
-import { debugGetAllCallFactories } from "socket-function/src/nodeCache";
-import { debugNodeId } from "../-c-identity/IdentityController";
-import { fastHash } from "../misc/hash";
-import { NodeCapabilitiesController } from "../-g-core-values/NodeCapabilities";
-import { sort } from "socket-function/src/misc";
-
-
-
-function getColorForNodeId(friendlyNodeId: string): string {
-    let hash = fastHash(friendlyNodeId);
-    let hue = hash % 360;
-    return `hsl(${hue}, 70%, 60%)`;
-}
-
-export class NodeConnectionsPage extends qreact.Component {
-    render() {
-        let browserNode = getBrowserUrlNode();
-        let controller = nodeConnectionsController(browserNode);
-
-        let nodeIds = controller.getAllNodeIds();
-        if (!nodeIds) {
-            return <div class={css.pad2(10)}>Loading...</div>;
-        }
-
-        let connectableNodes: Array<{ nodeId: string; friendlyNodeId: string; entryPoint: string | undefined; connections: Array<{ nodeId: string; friendlyNodeId: string }> }> = [];
-        let nonConnectableNodes: string[] = [];
-
-        for (let nodeId of nodeIds) {
-            try {
-                let result = controller.getNodeConnections_forBrowser(nodeId);
-                if (result) {
-                    let friendlyNodeId = debugNodeId(nodeId);
-                    let entryPoint: string | undefined;
-                    try {
-                        entryPoint = controller.getEntryPoint_forBrowser(nodeId);
-                    } catch (e) {
-                        entryPoint = undefined;
-                    }
-                    connectableNodes.push({
-                        nodeId,
-                        friendlyNodeId,
-                        entryPoint,
-                        connections: result.connections,
-                    });
-                }
-            } catch (e) {
-                nonConnectableNodes.push(nodeId);
-            }
-        }
-
-        return (
-            <div class={css.pad2(10).vbox(20).fillWidth}>
-                <h1>Connectable Nodes</h1>
-                <div class={css.hbox(20).wrap.fillWidth}>
-                    {connectableNodes.map(node => {
-                        let color = getColorForNodeId(node.friendlyNodeId);
-                        return (
-                            <div class={css.vbox(5).pad2(10).maxHeight(400).overflowAuto.bord(1, { h: 0, s: 0, l: 80 })}>
-                                <div class={css.vbox(3)}>
-                                    {node.entryPoint && (
-                                        <div class={css.fontSize(14).fontWeight("bold")}>
-                                            {node.entryPoint}
-                                        </div>
-                                    )}
-                                    <div class={css.hbox(5)}>
-                                        <span class={css.background(color).pad2(4, 2).fontWeight("bold")}>
-                                            {node.friendlyNodeId}
-                                        </span>
-                                        <span class={css.color("gray").fontSize(12)}>
-                                            ({node.nodeId})
-                                        </span>
-                                    </div>
-                                </div>
-                                <div class={css.vbox(3).paddingLeft(20)}>
-                                    {node.connections.length === 0 && (
-                                        <div class={css.color("gray")}>No connections</div>
-                                    )}
-                                    {node.connections.map(conn => {
-                                        let connColor = getColorForNodeId(conn.friendlyNodeId);
-                                        return (
-                                            <div class={css.hbox(5)}>
-                                                <span>→ Connected to:</span>
-                                                <span class={css.background(connColor).pad2(4, 2).fontWeight("bold")}>
-                                                    {conn.friendlyNodeId}
-                                                </span>
-                                                <span class={css.color("gray").fontSize(12)}>
-                                                    ({conn.nodeId})
-                                                </span>
-                                            </div>
-                                        );
-                                    })}
-                                </div>
-                            </div>
-                        );
-                    })}
-                </div>
-
-                <div class={css.vbox(10).fillWidth}>
-                    <h1>Non-Connectable Nodes</h1>
-                    <div class={css.vbox(5).pad2(10).maxHeight(600).overflowAuto.bord(1, { h: 0, s: 0, l: 80 })}>
-                        {nonConnectableNodes.map(nodeId => {
-                            let friendlyNodeId = debugNodeId(nodeId);
-                            return (
-                                <div class={css.hbox(5)}>
-                                    <span class={css.background("lightgray").pad2(4, 2).fontWeight("bold")}>
-                                        {friendlyNodeId}
-                                    </span>
-                                    <span class={css.color("gray").fontSize(12)}>
-                                        ({nodeId})
-                                    </span>
-                                    <span class={css.color("gray")}>- Can't connect</span>
-                                </div>
-                            );
-                        })}
-                    </div>
-                </div>
-            </div>
-        );
-    }
-}
-
-class NodeConnectionsControllerBase {
-    public async getNodeConnections() {
-        let factories = debugGetAllCallFactories();
-        let connections = factories.filter(x => x.isConnected).map(factory => ({
-            nodeId: factory.nodeId,
-            friendlyNodeId: debugNodeId(factory.nodeId),
-        }));
-        return { connections };
-    }
-
-    public async getNodeConnections_forBrowser(nodeId: string) {
-        let result = await NodeConnectionsController.nodes[nodeId].getNodeConnections();
-        sort(result.connections, x => x.friendlyNodeId);
-        return result;
-    }
-
-    public async getEntryPoint_forBrowser(nodeId: string) {
-        return (await NodeCapabilitiesController.nodes[nodeId].getMetadata()).entryPoint;
-    }
-
-    public async getAllNodeIds() {
-        return await getAllNodeIds();
-    }
-}
-
-export const NodeConnectionsController = SocketFunction.register(
-    "NodeConnectionsController-8f3e2a1b-4c5d-4f2e-9a3b-7c8d1e2f3a4b",
-    new NodeConnectionsControllerBase(),
-    () => ({
-        getNodeConnections: {},
-        getNodeConnections_forBrowser: {},
-        getEntryPoint_forBrowser: {},
-        getAllNodeIds: {},
-    }),
-    () => ({
-        hooks: [assertIsManagementUser],
-    })
-);
-
-export const nodeConnectionsController = getSyncedController(NodeConnectionsController);