querysub 0.549.0 → 0.550.0

package/package.json

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

package/src/deployManager/components/RouteConfigView.tsx

@@ -4,14 +4,13 @@ import { css } from "typesafecss";
 import { sort } from "socket-function/src/misc";
 import { formatNumber, formatDateTime, formatTime } from "socket-function/src/formatting/format";
 import { parseHostedUrl, parseBackblazeUrl } from "sliftutils/storage/remoteStorage/remoteConfig";
-import { getServerActiveBucket } from "sliftutils/storage/remoteStorage/createArchives";
-import { STORAGE_ACCOUNT } from "../../-a-archives/archives2";
+import { SocketFunction } from "socket-function/SocketFunction";
 import { FULL_VALID_WINDOW, FULL_ROUTE } from "sliftutils/storage/IArchives";
 import type { RemoteConfig, RemoteConfigBase, HostedConfig, BackblazeConfig } from "sliftutils/storage/IArchives";
 import { showModal } from "../../5-diagnostics/Modal";
 import { FullscreenModal } from "../../5-diagnostics/FullscreenModal";
 import { Button } from "../../library-components/Button";
-import type { StorageServerBuckets } from "./StoragePage";
+import { StorageSynced, type StorageServerBuckets } from "./StoragePage";
 
 module.hotreload = true;
 
@@ -250,24 +249,32 @@ async function refreshWatch(key: string): Promise<void> {
         let current = liveWatchData().watches[key];
         if (current) current.loading = true;
     });
-    let live = await getServerActiveBucket({ url: serverUrl, account: STORAGE_ACCOUNT, bucketName });
-    // "Not loaded here" comes back as a string - it's a normal result, not an error
-    let error: string | undefined;
-    let result: RemoteConfig | undefined;
-    if (typeof live === "string") {
-        error = live;
-    } else {
-        result = live.routing;
+    try {
+        // Proxied through our server, which holds the identity the storage servers authenticate against
+        let live = await StorageSynced(SocketFunction.browserNodeId()).getActiveBucket.promise(serverUrl, bucketName);
+        // "Not loaded here" comes back as a string - it's a normal result, not an error
+        let error: string | undefined;
+        let result: RemoteConfig | undefined;
+        if (typeof live === "string") {
+            error = live;
+        } else {
+            result = live.routing;
+        }
+        Querysub.commit(() => {
+            let current = liveWatchData().watches[key];
+            // The watch may have been removed while the call was in flight
+            if (!current) return;
+            current.routing = result;
+            current.error = error;
+            current.updatedTime = Date.now();
+        });
+    } finally {
+        // Without this a throw would leave the watch stuck showing "refreshing..."
+        Querysub.commit(() => {
+            let current = liveWatchData().watches[key];
+            if (current) current.loading = false;
+        });
     }
-    Querysub.commit(() => {
-        let current = liveWatchData().watches[key];
-        // The watch may have been removed while the call was in flight
-        if (!current) return;
-        current.loading = false;
-        current.routing = result;
-        current.error = error;
-        current.updatedTime = Date.now();
-    });
 }
 
 function isWatched(serverUrl: string, bucketName: string): boolean {

package/src/deployManager/components/StoragePage.tsx

@@ -5,8 +5,8 @@ import { formatNumber, formatTime, formatDateTimeDetailed } from "socket-functio
 import { sort, timeInSecond } from "socket-function/src/misc";
 import preact from "preact";
 import { Querysub } from "../../4-querysub/Querysub";
-import { listServerBuckets, clearServerWriteStats, activateServerBucket } from "sliftutils/storage/remoteStorage/createArchives";
-import type { ServerBucketInfo, BucketDiskInfo, BucketWriteStats } from "sliftutils/storage/remoteStorage/storageServerState";
+import { listServerBuckets, clearServerWriteStats, activateServerBucket, getServerActiveBucket } from "sliftutils/storage/remoteStorage/createArchives";
+import type { ServerBucketInfo, BucketDiskInfo, BucketWriteStats, ActiveBucketInfo } from "sliftutils/storage/remoteStorage/storageServerState";
 import type { ArchivesConfig } from "sliftutils/storage/IArchives";
 import { UsageBar, getUsageThresholds } from "../../library-components/UsageBar";
 import { getSyncedController } from "../../library-components/SyncedController";
@@ -86,11 +86,21 @@ export function getStorageServices(servers: StorageServer[]): StorageService[] {
     return [...byKey.values()];
 }
 
+/** Every storage call is proxied through here: they authenticate with this machine's identity CA, which the browser has no access to. */
 class StoragePageControllerBase {
-    /** Purely a forwarder - browsers can't authenticate to a storage server themselves. One call per server, so each caches and refreshes on its own. */
+    /** One call per server, so each caches and refreshes on its own. */
     public async getServerBuckets(url: string): Promise<ServerBucketInfo[]> {
         return await listServerBuckets({ url, account: STORAGE_ACCOUNT });
     }
+    public async activateBucket(url: string, bucketName: string): Promise<ActiveBucketInfo | string> {
+        return await activateServerBucket({ url, account: STORAGE_ACCOUNT, bucketName });
+    }
+    public async getActiveBucket(url: string, bucketName: string): Promise<ActiveBucketInfo | string> {
+        return await getServerActiveBucket({ url, account: STORAGE_ACCOUNT, bucketName });
+    }
+    public async clearWriteStats(url: string): Promise<{ clearedBuckets: number }> {
+        return await clearServerWriteStats({ url, account: STORAGE_ACCOUNT });
+    }
 }
 
 export const StoragePageController = SocketFunction.register(
@@ -98,6 +108,9 @@ export const StoragePageController = SocketFunction.register(
     new StoragePageControllerBase(),
     () => ({
         getServerBuckets: {},
+        activateBucket: {},
+        getActiveBucket: {},
+        clearWriteStats: {},
     }),
     () => ({
         hooks: [assertIsManagementUser],
@@ -106,7 +119,7 @@ export const StoragePageController = SocketFunction.register(
     }
 );
 
-const StorageSynced = getSyncedController(StoragePageController, {
+export const StorageSynced = getSyncedController(StoragePageController, {
     reads: {},
     writes: {},
 });
@@ -219,22 +232,28 @@ class ActivateBucketButton extends qreact.Component<{ serverUrl: string; bucketN
                     this.state.activating = true;
                     this.state.error = "";
                     Querysub.onCommitFinished(async () => {
-                        let result = await activateServerBucket({ url: serverUrl, account: STORAGE_ACCOUNT, bucketName });
-                        // A refusal comes back as a string - it's a normal result, not an error
-                        let refusal = typeof result === "string" && result || "";
-                        if (refusal) {
-                            console.log(`Activating bucket ${bucketName} on ${serverUrl} was refused: ${refusal}`);
-                        } else {
-                            console.log(`Activated bucket ${bucketName} on ${serverUrl}`);
-                        }
-                        Querysub.commit(() => {
-                            this.state.activating = false;
-                            this.state.error = refusal;
-                            // Only this server's buckets changed
-                            if (!refusal) {
-                                StorageSynced(SocketFunction.browserNodeId()).getServerBuckets.reset(serverUrl);
+                        try {
+                            let result = await StorageSynced(SocketFunction.browserNodeId()).activateBucket.promise(serverUrl, bucketName);
+                            // A refusal comes back as a string - it's a normal result, not an error
+                            let refusal = typeof result === "string" && result || "";
+                            if (refusal) {
+                                console.log(`Activating bucket ${bucketName} on ${serverUrl} was refused: ${refusal}`);
+                            } else {
+                                console.log(`Activated bucket ${bucketName} on ${serverUrl}`);
                             }
-                        });
+                            Querysub.commit(() => {
+                                this.state.error = refusal;
+                                // Only this server's buckets changed
+                                if (!refusal) {
+                                    StorageSynced(SocketFunction.browserNodeId()).getServerBuckets.reset(serverUrl);
+                                }
+                            });
+                        } finally {
+                            // Without this a throw would leave the button disabled and stuck on "Activating..."
+                            Querysub.commit(() => {
+                                this.state.activating = false;
+                            });
+                        }
                     });
                 }}
             >
@@ -403,7 +422,7 @@ class DeployNotices extends qreact.Component<{ services: StorageService[] }> {
 async function resetWriteStats(servers: StorageServerBuckets[]): Promise<void> {
     await Promise.all(servers.map(async server => {
         if (server.loading) return;
-        let { clearedBuckets } = await clearServerWriteStats({ url: server.url, account: STORAGE_ACCOUNT });
+        let { clearedBuckets } = await StorageSynced(SocketFunction.browserNodeId()).clearWriteStats.promise(server.url);
         console.log(`Cleared write stats for ${clearedBuckets} buckets on ${server.url}`);
     }));
     Querysub.commit(() => {