querysub 0.617.0 → 0.619.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.617.0",
+  "version": "0.619.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",

package/src/-f-node-discovery/NodeDiscovery.ts

@@ -541,9 +541,9 @@ async function runServerSyncLoops() {
             let suicideThreshold = Date.now() - SUICIDE_HEARTBEAT_THRESHOLD;
             if (!lastTime || lastTime < suicideThreshold) {
                 if (!lastTime) {
-                    console.error(red(`Self node was removed due to not heartbeating. Terminating self process, as it likely has very stale data.`));
+                    console.error(red(`Self node was removed due to heartbeat file not existing (${selfNodeId}). Terminating self process, as it likely has very stale data.`));
                 } else {
-                    console.error(red(`Self node was has very old heartbeat. Terminating self process, as it likely has very stale data.`));
+                    console.error(red(`Self node was has very old heartbeat. Terminating self process, as it likely has very stale data. ${formatDateTime(lastTime)} < ${formatDateTime(suicideThreshold)}, now is ${formatDateTime(Date.now())}`));
                 }
                 process.exit();
             }

package/src/0-path-value-core/archiveLocks/archiveSnapshots.ts

@@ -215,9 +215,4 @@ export async function loadSnapshot(config: {
     for (let i = 0; i < 10; i++) {
         console.log(green(`!!!Finished loading snapshot!!!`));
     }
-
-    if (!config.noExit && !isPublic()) {
-        // Exit so we know when this is done. Really, all the servers need to be restarted after we load the snapshot, anyway. 
-        process.exit();
-    }
 }

package/src/1-path-client/RemoteWatcher.ts

@@ -35,7 +35,9 @@ const SHUTDOWN_REHOME_WINDOW = timeInMinute * 3;
 const SHUTDOWN_REHOME_POLL_INTERVAL = timeInSecond * 30;
 
 // Rehome the watches on an authority when an equivalent authority has this factor lower latency. At 2 the router's full-confidence cutoff factor (also 2) then reliably routes everything to the better node on the rewatch.
-const LATENCY_REHOME_FACTOR = 2;
+const LATENCY_REHOME_FACTOR = 1.5;
+// Jitter floor added to the candidate's latency before the factor comparison. Below roughly this many milliseconds the difference between two nodes is noise, not speed (1ms vs 2ms isn't "twice as fast"), and without the floor a candidate that momentarily reads near-zero always looks infinitely faster, so we rehome on pure jitter. Added only to the candidate, keeping us biased against needless moves.
+const LATENCY_REHOME_JITTER_MS = 50;
 // Both latencies must be medians over this many samples — with fewer we don't trust either number enough to move watches over it.
 const LATENCY_REHOME_HISTORY_COUNT = 10;
 const LATENCY_REHOME_POLL_INTERVAL = timeInMinute;
@@ -186,7 +188,7 @@ export class RemoteWatcher {
                 if (!areAuthoritySpecsEquivalent(entry.authoritySpec, candidate.authoritySpec)) continue;
                 let candidateLatency = getNodeLatencyMedian({ nodeId: candidate.nodeId, historyCount: LATENCY_REHOME_HISTORY_COUNT });
                 if (!candidateLatency || candidateLatency.historyUsed < LATENCY_REHOME_HISTORY_COUNT) continue;
-                if (candidateLatency.latency * LATENCY_REHOME_FACTOR > current.latency) continue;
+                if ((candidateLatency.latency + LATENCY_REHOME_JITTER_MS) * LATENCY_REHOME_FACTOR > current.latency) continue;
                 console.log(yellow(`Authority ${authorityId} has high latency (${formatTime(current.latency)}), and the equivalent authority ${candidate.nodeId} is much faster (${formatTime(candidateLatency.latency)}), so we are rehoming all paths watched on it`));
                 logErrors(this.refreshAllWatches(authorityId));
                 break;

package/src/deployManager/MachinesPage.tsx

@@ -10,6 +10,7 @@ import { MachineDetailPage } from "./components/MachineDetailPage";
 import { Anchor } from "../library-components/ATag";
 import { DeployPage } from "./components/DeployPage";
 import { StoragePage } from "./components/storage/StoragePage";
+import { RoutingTablePage } from "../diagnostics/misc-pages/RoutingTablePage";
 
 export class MachinesPage extends qreact.Component {
     private renderTabs() {
@@ -22,6 +23,7 @@ export class MachinesPage extends qreact.Component {
                 { key: "services", label: "Services", otherKeys: ["service-detail"] },
                 { key: "deploy", label: "Deploy", otherKeys: [] },
                 { key: "storage", label: "Storage", otherKeys: [] },
+                { key: "routing", label: "PathValues / Functions Routing", otherKeys: [] },
             ].map(tab => {
                 let isActive = currentViewParam.value === tab.key || tab.otherKeys.includes(currentViewParam.value);
                 return <Anchor noStyles key={tab.key}
@@ -50,6 +52,7 @@ export class MachinesPage extends qreact.Component {
                 {currentViewParam.value === "machine-detail" && <MachineDetailPage />}
                 {currentViewParam.value === "deploy" && <DeployPage />}
                 {currentViewParam.value === "storage" && <StoragePage />}
+                {currentViewParam.value === "routing" && <RoutingTablePage />}
             </div>
         </div>;
     }

package/src/deployManager/urlParams.ts

@@ -1,6 +1,6 @@
 import { URLParam } from "../library-components/URLParam";
 
-export type ViewType = "services" | "machines" | "service-detail" | "machine-detail" | "deploy" | "storage";
+export type ViewType = "services" | "machines" | "service-detail" | "machine-detail" | "deploy" | "storage" | "routing";
 
 export const currentViewParam = new URLParam<ViewType>("machineview", "machines");
 export const selectedServiceIdParam = new URLParam("serviceId", "");

package/src/diagnostics/managementPages.tsx

@@ -80,12 +80,6 @@ export async function registerManagementPages2(config: {
     let inputPages: typeof config.pages = [];
 
 
-    inputPages.push({
-        title: "Routing Table",
-        componentName: "RoutingTablePage",
-        controllerName: "RoutingTablePageController",
-        getModule: () => import("./misc-pages/RoutingTablePage"),
-    });
     inputPages.push({
         title: "LOG VIEWER",
         componentName: "LogViewer3",
@@ -404,6 +398,10 @@ class ManagementRoot extends qreact.Component {
                             managementPageURL.getOverride("MachinesPage"),
                             currentViewParam.getOverride("storage"),
                         ]}>Storage</ATag>
+                        <ATag values={[
+                            managementPageURL.getOverride("MachinesPage"),
+                            currentViewParam.getOverride("routing"),
+                        ]}>PathValues / Functions Routing</ATag>
                         {pages.map(page =>
                             <ATag values={[{ param: managementPageURL, value: page.componentName }]}>{page.title}</ATag>
                         )}

package/src/diagnostics/misc-pages/PathValueServersSection.tsx

@@ -45,19 +45,18 @@ class PathSummaryTable extends qreact.Component<{ nodeId: string; direction: Pat
 
 // One row per path-value server, grouped by machine. Reads/writes lead the line; expanding reveals that server's
 // per-path breakdown for both directions.
-class AuthorityNodeRow extends qreact.Component<{ info: NodeAuthorityInfo; firstOfMachine: boolean }> {
+class AuthorityNodeRow extends qreact.Component<{ info: NodeAuthorityInfo }> {
     state = {
         expanded: false,
     };
     render() {
         let info = this.props.info;
-        let spec = info.spec!;
+        let spec = info.spec;
         let expanded = this.state.expanded;
         let totals = RoutingTableSynced(getBrowserUrlNode()).getNodePathTotals(info.nodeId);
         let machineId = machineIdOf(info.nodeId);
         return <div
-            className={css.button.vbox(6).pad2(10).fillWidth.hsl(0, 0, 99)
-                .borderTop(this.props.firstOfMachine ? "2px solid hsl(0, 0%, 78%)" : "1px solid hsl(0, 0%, 90%)")}
+            className={css.button.vbox(6).pad2(10).fillWidth.hsl(0, 0, 99).borderTop("1px solid hsl(0, 0%, 88%)")}
             onClick={() => this.state.expanded = !expanded}
         >
             <div className={css.hbox(10).fillWidth}>
@@ -66,12 +65,12 @@ class AuthorityNodeRow extends qreact.Component<{ info: NodeAuthorityInfo; first
                     ↓{totals ? formatNumber(totals.received) : "…"} ↑{totals ? formatNumber(totals.sent) : "…"}
                 </span>
                 <span className={css.width(`${MACHINE_CELL_WIDTH_CH}ch`).flexShrink0.colorhsl(0, 0, 45)} title={machineId}>
-                    {this.props.firstOfMachine ? machineId.slice(0, ID_CHARS) : ""}
+                    {machineId.slice(0, ID_CHARS)}
                 </span>
                 <span className={css.boldStyle} title={info.nodeId}>{threadLabel(info.nodeId)}</span>
-                <span className={css.colorhsl(0, 0, 45)}>{spec.routeStart.toFixed(4)} - {spec.routeEnd.toFixed(4)}</span>
-                <AuthorityRangeBar start={spec.routeStart} end={spec.routeEnd} />
-                {spec.excludeDefault && <span className={css.colorhsl(0, 70, 35)}>(excludes default)</span>}
+                {spec && <span className={css.colorhsl(0, 0, 45)}>{spec.routeStart.toFixed(4)} - {spec.routeEnd.toFixed(4)}</span>}
+                {spec && <AuthorityRangeBar start={spec.routeStart} end={spec.routeEnd} />}
+                {spec?.excludeDefault && <span className={css.colorhsl(0, 70, 35)}>(excludes default)</span>}
             </div>
             {expanded &&
                 <div className={css.hbox(16).wrap.fillWidth.alignItems("flex-start")} onClick={e => e.stopPropagation()}>
@@ -89,42 +88,67 @@ class AuthorityNodeRow extends qreact.Component<{ info: NodeAuthorityInfo; first
     }
 }
 
-// Invalidate: drop every cached synced call for this node so the whole page's data disappears and refetches. Clear:
-// wipe the in-memory path-value stats (totals and trees) on every node, then invalidate so the now-empty stats reload.
+// Invalidate: drop every cached synced call for this node so the whole page's data disappears and refetches.
 function invalidateRoutingTable(): void {
-    RoutingTableSynced(getBrowserUrlNode()).resetAll();
+    let synced = RoutingTableSynced(getBrowserUrlNode());
+    synced.getNodePathTotals.resetAll();
+    synced.getNodePathSummary.resetAll();
 }
+// Clear: wipe the in-memory path-value stats (totals and trees) on every node, then drop only the stats caches so the
+// now-empty stats reload — leaving the specs/latency/traffic caches untouched.
 async function clearAllPathStats(nodeIds: string[]): Promise<void> {
     let synced = RoutingTableSynced(getBrowserUrlNode());
     await Promise.all(nodeIds.map(nodeId => synced.clearNodePathStats.promise(nodeId).catch(() => { })));
-    synced.resetAll();
+    synced.getNodePathTotals.resetAll();
+    synced.getNodePathSummary.resetAll();
+}
+
+// A list of server rows, most-active first (by total path values sent + received).
+class PathServerList extends qreact.Component<{ infos: NodeAuthorityInfo[]; emptyText: string }> {
+    render() {
+        let synced = RoutingTableSynced(getBrowserUrlNode());
+        let sumOf = (nodeId: string) => {
+            let totals = synced.getNodePathTotals(nodeId);
+            return (totals?.sent ?? 0) + (totals?.received ?? 0);
+        };
+        let infos = this.props.infos.slice();
+        // Two stable passes: machine/thread as a tiebreak, then sent+received descending as the primary order (so rows
+        // with equal — or still-loading, hence 0 — totals keep a stable machine/thread order instead of jittering).
+        let sep = String.fromCharCode(1);
+        sort(infos, x => `${machineIdOf(x.nodeId)}${sep}${threadLabel(x.nodeId)}`);
+        sort(infos, x => -sumOf(x.nodeId));
+        if (!infos.length) return <div className={css.colorhsl(0, 0, 50)}>{this.props.emptyText}</div>;
+        return <div className={css.vbox(0).fillWidth.bord2(0, 0, 88)}>
+            {infos.map(info => <AuthorityNodeRow key={info.nodeId} info={info} />)}
+        </div>;
+    }
 }
 
 export class PathValueServersSection extends qreact.Component<{ infos: NodeAuthorityInfo[] }> {
     render() {
         let infos = this.props.infos;
         let allNodeIds = infos.map(x => x.nodeId);
-        let routableInfos = infos.filter(x => x.spec && x.spec.routeStart >= 0 && x.spec.routeEnd >= 0);
-        // Group each server's threads under their machine (machine, then thread), so a machine's servers sit together.
-        let sep = String.fromCharCode(1);
-        sort(routableInfos, x => `${machineIdOf(x.nodeId)}${sep}${threadLabel(x.nodeId)}`);
+        // Path value servers are the authorities (they own a route range). Every other node can still send/receive
+        // path values, so it gets its own list below.
+        let serverInfos = infos.filter(x => x.spec && x.spec.routeStart >= 0 && x.spec.routeEnd >= 0);
+        let otherInfos = infos.filter(x => !(x.spec && x.spec.routeStart >= 0 && x.spec.routeEnd >= 0));
 
         let buttonClass = css.pad2(12, 8).button.bord2(0, 0, 20).hsl(0, 0, 100).whiteSpace("nowrap");
         return <div className={css.vbox(8).fillWidth}>
             <div className={css.hbox(12).alignItems("center")}>
-                <h2 className={css.margin(0)}>Path Value Servers ({routableInfos.length})</h2>
+                <h2 className={css.margin(0)}>Path Value Servers ({serverInfos.length})</h2>
                 <button className={buttonClass} onClick={() => invalidateRoutingTable()}>Invalidate</button>
                 <button className={buttonClass} onClick={() => void clearAllPathStats(allNodeIds)}>Clear stats</button>
             </div>
             <div className={css.fontSize(13).colorhsl(0, 0, 45)}>
                 Path values each server has received (↓) and sent (↑) since startup or the last clear. Expand a server for its top {PATH_SUMMARY_LIMIT} paths in each direction.
             </div>
-            <div className={css.vbox(0).fillWidth.bord2(0, 0, 88)}>
-                {routableInfos.map((info, i) => {
-                    let firstOfMachine = i === 0 || machineIdOf(routableInfos[i - 1].nodeId) !== machineIdOf(info.nodeId);
-                    return <AuthorityNodeRow key={info.nodeId} info={info} firstOfMachine={firstOfMachine} />;
-                })}
+            <PathServerList infos={serverInfos} emptyText="(no path value servers)" />
+            <h2 className={css.margin(0)}>Other Senders ({otherInfos.length})</h2>
+            <div className={css.fontSize(13).colorhsl(0, 0, 45)}>
+                Nodes that aren't path value servers but still send/receive path values.
             </div>
+            <PathServerList infos={otherInfos} emptyText="(no other senders)" />
         </div>;
     }
 }

package/src/diagnostics/misc-pages/RoutingTablePage.tsx

@@ -107,9 +107,6 @@ export const RoutingTablePageController = SocketFunction.register(
     () => ({
         hooks: [assertIsManagementUser],
     }),
-    {
-        noAutoExpose: true,
-    }
 );
 
 export const RoutingTableSynced = getSyncedController(RoutingTablePageController, {

package/src/diagnostics/misc-pages/SnapshotViewer.tsx

@@ -126,7 +126,7 @@ export class SnapshotViewer extends qreact.Component {
                 }
                 <Button onClick={async () => {
                     let didConfirm = await seriousConfirm({
-                        message: `Restoring will break all servers. This won't break your data, but you will have to restart all servers before the system will be stable again. Before then data will be random, and invalid writes might be allowed. It is recommend to run this with only 1 querysub server running, on a developers machine. Consider writing a database iterate script instead of restoring (similar to how gc and join work).`,
+                        message: `Restoring will put the servers in a bad state. You're gonna need to restart all services after this.`,
                     });
                     if (!didConfirm) {
                         console.log(red("Aborted restore"));
@@ -137,7 +137,6 @@ export class SnapshotViewer extends qreact.Component {
                         overview: entry
                     });
                     console.log(green("Restored snapshot"));
-                    window.location.reload();
                 }}>
                     Restore
                 </Button>