querysub 0.638.0 → 0.640.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.638.0",
+  "version": "0.640.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
@@ -79,7 +79,7 @@
     "node-forge": "https://github.com/sliftist/forge#e618181b469b07bdc70b968b0391beb8ef5fecd6",
     "pako": "^2.1.0",
     "peggy": "^5.0.6",
-    "sliftutils": "^1.7.108",
+    "sliftutils": "^1.7.112",
     "socket-function": "^1.2.31",
     "terser": "^5.31.0",
     "typenode": "^6.6.1",

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

@@ -539,6 +539,9 @@ async function runServerSyncLoops() {
         if (!isNoNetwork()) {
             // FIRST, verify we didn't delay too long (to make sure we kill any nodes that were disconnected
             //  from the internet for too long)
+            // NOTE: If get can't contact a server, it will throw. It won't return undefined. So if this does return undefined, It means we actually talk to the server and it says the file doesn't exist, which means we are fairly safe in self-terminating.
+            //let lastTime = Number((await archives().get(selfNodeId, { noFallbacks: true }))?.toString());
+            // NOTE: We're temporary not using no fallbacks, So, this is a good canary to tell us if something's wrong with storage. We're writing so many heartbeats, at least one of the writes should have gotten to Backblaze.
             let lastTime = Number((await archives().get(selfNodeId))?.toString());
             let suicideThreshold = Date.now() - SUICIDE_HEARTBEAT_THRESHOLD;
             if (!lastTime || lastTime < suicideThreshold) {

package/src/deployManager/components/storage/StorageLogsPage.tsx

@@ -20,6 +20,7 @@ import { atomic } from "../../../2-proxy/PathValueProxyWatcher";
 import { TimeRangeSelector, getTimeRange } from "../../../diagnostics/logs/TimeRangeSelector";
 import { StorageLogsSynced } from "./storageLogsController";
 import { searchStorageLogs, invalidateStorageLogSearchCache, FailedLogFile } from "./storageLogSearch";
+import { showStoragePathModal } from "./storagePathView";
 
 module.hotreload = true;
 
@@ -308,12 +309,30 @@ export class StorageLogsPage extends qreact.Component {
                 </Button>;
             },
         };
+        let serverUrls = listings.map(listing => listing.url);
         for (let column of selectedFields) {
             if (column === "time") {
                 columnsConfig[column] = {
                     title: "Time",
                     formatter: value => typeof value === "number" && <span className={css.whiteSpace("nowrap")}>{formatDateTime(value)}</span> || value as preact.ComponentChild,
                 };
+            } else if (column === "path") {
+                columnsConfig[column] = {
+                    formatter: (value, context) => {
+                        let bucketName = context?.row?.bucketName;
+                        if (typeof value !== "string" || !value || typeof bucketName !== "string" || !bucketName) return value as preact.ComponentChild;
+                        return <div className={css.hbox(6).alignItems("center")}>
+                            <span>{value}</span>
+                            <Button
+                                flavor="tiny"
+                                title="The live value of this path on every storage server"
+                                onClick={() => showStoragePathModal(serverUrls, bucketName, value)}
+                            >
+                                Values
+                            </Button>
+                        </div>;
+                    },
+                };
             } else {
                 columnsConfig[column] = {};
             }

package/src/deployManager/components/storage/storageController.ts

@@ -13,7 +13,7 @@ import { STORAGE_ACCOUNT } from "../../../-a-archives/archives2";
 module.hotreload = false;
 
 /** The access-stats endpoints have no client wrapper in sliftutils (a pinned dependency), so we reconnect and authenticate the same way its own callServer does. */
-async function callStorageServer<T>(url: string, run: (controller: typeof RemoteStorageController.nodes[string]) => Promise<T>): Promise<T> {
+export async function callStorageServer<T>(url: string, run: (controller: typeof RemoteStorageController.nodes[string]) => Promise<T>): Promise<T> {
     SocketFunction.ENABLE_CLIENT_MODE = true;
     let parsed = parseStorageUrl(url);
     let nodeId = SocketFunction.connect({ address: parsed.address, port: parsed.port });

package/src/deployManager/components/storage/storageLogsController.ts

@@ -1,13 +1,33 @@
 import { SocketFunction } from "socket-function/SocketFunction";
 import { listServerLogFiles, getServerLogs, searchServerLogs } from "sliftutils/storage/remoteStorage/createArchives";
 import type { LogFileInfo } from "sliftutils/storage/StreamingLogs";
+import { parseStorageUrl } from "sliftutils/storage/remoteStorage/ArchivesRemote";
+import { ROUTING_FILE, parseRoutingData, normalizeSource, parseHostedUrl } from "sliftutils/storage/remoteStorage/remoteConfig";
 import { getSyncedController } from "../../../library-components/SyncedController";
 import { assertIsManagementUser } from "../../../diagnostics/managementPages";
 import { STORAGE_ACCOUNT } from "../../../-a-archives/archives2";
+import { callStorageServer } from "./storageController";
 
 // The registered controller and its synced wrapper have to keep a stable identity, so this file is a full-refresh boundary rather than a hot-reload one (matching SyncedController itself).
 module.hotreload = false;
 
+// Enough for any value a human is going to eyeball; the full size still comes back, so the UI can say how much was left behind
+const VALUE_PREVIEW_LIMIT = 256 * 1024;
+
+export type PathValueRead = {
+    writeTime: number;
+    /** The full size - data may be a capped prefix of it */
+    size: number;
+    data: Buffer;
+};
+export type ServerPathValue = {
+    /** The server's own newest copy across its stores (an internal read - no store selection, no fallbacks to other machines) */
+    internal?: PathValueRead;
+    /** What a normal (non-internal) read serves, per store this server's routing config gives it */
+    stores: { store: string; error?: string; value?: PathValueRead }[];
+    fetchTime: number;
+};
+
 export type ServerLogFiles = {
     files: LogFileInfo[];
     /** When this listing was fetched, so the UI can say how stale a cached listing is. */
@@ -32,6 +52,46 @@ class StorageLogsControllerBase {
         let results = await searchServerLogs({ url, account: STORAGE_ACCOUNT, names: [name], searches });
         return results[0]?.entries || [];
     }
+    /** One path's live value on ONE server: its own newest copy (internal), plus what each of its configured stores serves normally. One call per server, so a locked-up server only stalls its own row. */
+    public async getServerPathValue(url: string, bucketName: string, path: string): Promise<ServerPathValue> {
+        let account = STORAGE_ACCOUNT;
+        let range = { start: 0, end: VALUE_PREVIEW_LIMIT };
+        return await callStorageServer(url, async controller => {
+            let parsed = parseStorageUrl(url);
+            // get2's internal reads ignore the sourceConfig, but the arg is still required - fabricated the same way getBucketInfo does
+            let fabricatedSource = normalizeSource(`${url.replace(/\/+$/, "")}/file/${account}/${bucketName}/storage/storagerouting.json`);
+            let internal = await controller.get2({ account, bucketName, path, sourceConfig: fabricatedSource, range, internal: true, includeTombstones: true });
+            // Only store names out of the server's OWN routing config go into non-internal reads: asking for a made-up name would CREATE that store
+            let stores: ServerPathValue["stores"] = [];
+            try {
+                let routing = await controller.get2({ account, bucketName, path: ROUTING_FILE, sourceConfig: fabricatedSource, internal: true });
+                let sources = routing && parseRoutingData(routing.data).sources.map(normalizeSource) || [];
+                let seenNames = new Set<string>();
+                for (let source of sources) {
+                    if (source.type !== "remote") continue;
+                    let hosted;
+                    try {
+                        hosted = parseHostedUrl(source.url);
+                    } catch {
+                        continue;
+                    }
+                    if (hosted.address !== parsed.address || String(hosted.port) !== String(parsed.port)) continue;
+                    if (hosted.bucketName !== bucketName) continue;
+                    if (seenNames.has(source.name)) continue;
+                    seenNames.add(source.name);
+                    try {
+                        let value = await controller.get2({ account, bucketName, path, sourceConfig: source, range, includeTombstones: true });
+                        stores.push({ store: source.name, value: value || undefined });
+                    } catch (e) {
+                        stores.push({ store: source.name, error: String((e as Error).stack ?? e) });
+                    }
+                }
+            } catch (e) {
+                stores.push({ store: "(routing config unreadable)", error: String((e as Error).stack ?? e) });
+            }
+            return { internal: internal || undefined, stores, fetchTime: Date.now() };
+        });
+    }
 }
 
 export const StorageLogsController = SocketFunction.register(
@@ -40,6 +100,7 @@ export const StorageLogsController = SocketFunction.register(
     () => ({
         getServerLogFiles: {},
         searchLogFile: {},
+        getServerPathValue: {},
     }),
     () => ({
         hooks: [assertIsManagementUser],

package/src/deployManager/components/storage/storagePathView.tsx

@@ -0,0 +1,128 @@
+import { SocketFunction } from "socket-function/SocketFunction";
+import { qreact } from "../../../4-dom/qreact";
+import { css } from "typesafecss";
+import { Querysub } from "../../../4-querysub/Querysub";
+import { t } from "../../../2-proxy/schema2";
+import { formatNumber, formatTime, formatDateTimeDetailed } from "socket-function/src/formatting/format";
+import { timeInSecond } from "socket-function/src/misc";
+import { showModal } from "../../../5-diagnostics/Modal";
+import { FullscreenModal } from "../../../5-diagnostics/FullscreenModal";
+import { StorageLogsController, ServerPathValue, PathValueRead } from "./storageLogsController";
+
+module.hotreload = true;
+
+// The live values of one path, across every storage server: each server's own copy (internal) plus what each of its stores serves normally. One call per server, fired on mount, so a locked-up server shows as in progress while the others fill in.
+
+const BUFFER_PREVIEW_CHARS = 100;
+const ERROR_COLOR = { h: 0, s: 60, l: 40 };
+const DETAIL_COLOR = { h: 0, s: 0, l: 45 };
+const DETAIL_FONT_SIZE = 12;
+const ROW_LABEL_MIN_WIDTH = 220;
+
+class BufferPreview extends qreact.Component<{ data: Buffer; totalSize: number }> {
+    state = t.state({
+        expanded: t.boolean,
+    });
+    render() {
+        let data = this.props.data;
+        let text = Buffer.from(data).toString("utf8");
+        let shown = this.state.expanded ? text : text.slice(0, BUFFER_PREVIEW_CHARS);
+        let clipped = text.length > BUFFER_PREVIEW_CHARS;
+        return <div className={css.vbox(2)}>
+            <div className={css.fontSize(DETAIL_FONT_SIZE).colorhsl(DETAIL_COLOR.h, DETAIL_COLOR.s, DETAIL_COLOR.l)}>
+                {formatNumber(this.props.totalSize)}B{data.length < this.props.totalSize && ` (only the first ${formatNumber(data.length)}B were fetched)`}
+            </div>
+            <div
+                className={css.fontFamily("monospace").whiteSpace("pre-wrap").wordBreak("break-all") + (clipped && css.pointer)}
+                title={clipped && (this.state.expanded ? "Click to collapse" : "Click to show the rest") || undefined}
+                onClick={() => this.state.expanded = !this.state.expanded}
+            >
+                {shown}{!this.state.expanded && clipped && "…"}
+            </div>
+        </div>;
+    }
+}
+
+class ValueRow extends qreact.Component<{ label: string; value?: PathValueRead; error?: string }> {
+    render() {
+        let { label, value, error } = this.props;
+        let now = Querysub.nowDelayed(timeInSecond);
+        return <div className={css.hbox(10).alignItems("flex-start")}>
+            <div className={css.boldStyle.minWidth(ROW_LABEL_MIN_WIDTH)}>{label}</div>
+            {error && <div className={css.colorhsl(ERROR_COLOR.h, ERROR_COLOR.s, ERROR_COLOR.l).whiteSpace("pre-wrap")}>{error}</div>}
+            {!error && !value && <div className={css.colorhsl(DETAIL_COLOR.h, DETAIL_COLOR.s, DETAIL_COLOR.l)}>missing</div>}
+            {value && <div className={css.vbox(2).flexGrow(1)}>
+                <div className={css.fontSize(DETAIL_FONT_SIZE).colorhsl(DETAIL_COLOR.h, DETAIL_COLOR.s, DETAIL_COLOR.l)}>
+                    written {formatDateTimeDetailed(value.writeTime)} ({formatTime(now - value.writeTime)} ago)
+                </div>
+                <BufferPreview data={value.data} totalSize={value.size} />
+            </div>}
+        </div>;
+    }
+}
+
+export class StoragePathViewModal extends qreact.Component<{
+    urls: string[];
+    bucketName: string;
+    path: string;
+    onClose: () => void;
+}> {
+    state = t.state({
+        results: t.atomic<Record<string, { error?: string; value?: ServerPathValue }>>({}),
+    });
+    componentDidMount() {
+        // Props are synchronized state, so the plain values the async work needs are read here
+        let { urls, bucketName, path } = this.props;
+        for (let url of urls) {
+            void (async () => {
+                let setResult = (result: { error?: string; value?: ServerPathValue }) => {
+                    Querysub.commit(() => {
+                        this.state.results = { ...this.state.results, [url]: result };
+                    });
+                };
+                try {
+                    let value = await StorageLogsController.nodes[SocketFunction.browserNodeId()].getServerPathValue(url, bucketName, path);
+                    setResult({ value });
+                } catch (e) {
+                    setResult({ error: (e as Error).stack ?? String(e) });
+                }
+            })();
+        }
+    }
+    render() {
+        let now = Querysub.nowDelayed(timeInSecond);
+        return <FullscreenModal onCancel={this.props.onClose}>
+            <div className={css.vbox(14).pad2(16)}>
+                <div className={css.boldStyle}>{this.props.bucketName} / {this.props.path}</div>
+                {this.props.urls.map(url => {
+                    let result = this.state.results[url];
+                    return <div key={url} className={css.vbox(6)}>
+                        <div className={css.hbox(8).alignItems("center")}>
+                            <b>{url}</b>
+                            {!result && <span>⏳ loading...</span>}
+                            {result?.value && <span className={css.fontSize(DETAIL_FONT_SIZE).colorhsl(DETAIL_COLOR.h, DETAIL_COLOR.s, DETAIL_COLOR.l)}>
+                                fetched {formatTime(now - result.value.fetchTime)} ago
+                            </span>}
+                        </div>
+                        {result?.error && <div className={css.colorhsl(ERROR_COLOR.h, ERROR_COLOR.s, ERROR_COLOR.l).whiteSpace("pre-wrap")}>{result.error}</div>}
+                        {result?.value && <div className={css.vbox(6).pad2(10, 0)}>
+                            <ValueRow label="internal (server's own copy)" value={result.value.internal} />
+                            {result.value.stores.map(store => <ValueRow
+                                key={store.store}
+                                label={`store ${store.store}`}
+                                value={store.value}
+                                error={store.error}
+                            />)}
+                        </div>}
+                    </div>;
+                })}
+            </div>
+        </FullscreenModal>;
+    }
+}
+
+export function showStoragePathModal(urls: string[], bucketName: string, path: string): void {
+    let close = showModal({
+        content: <StoragePathViewModal urls={urls} bucketName={bucketName} path={path} onClose={() => close.close()} />
+    });
+}