sliftutils 1.7.33 → 1.7.34

package/storage/remoteStorage/storageController.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import { ArchiveFileInfo, ArchivesConfig, ArchivesSyncStatus } from "../IArchives";
-import { ServerBucketInfo } from "./storageServerState";
+import { ServerBucketInfo, ActiveBucketInfo } from "./storageServerState";
 export declare const REMOTE_STORAGE_CLASS_GUID = "RemoteStorageController-b7e42a91";
 export declare const STORAGE_AUTH_PURPOSE = "remoteStorage-auth-1";
 export declare const STORAGE_NOT_AUTHENTICATED = "REMOTE_STORAGE_NOT_AUTHENTICATED_cf2f7b1e";
@@ -79,6 +79,8 @@ export declare const RemoteStorageController: import("socket-function/SocketFunc
     getChangesAfter: (account: string, bucketName: string, time: number) => Promise<ArchiveFileInfo[]>;
     getArchivesConfig: (account: string, bucketName: string) => Promise<ArchivesConfig>;
     listBuckets: (account: string) => Promise<ServerBucketInfo[]>;
+    getActiveBucket: (account: string, bucketName: string) => Promise<ActiveBucketInfo | string>;
+    activateBucket: (account: string, bucketName: string) => Promise<ActiveBucketInfo | string>;
     clearWriteStats: (account: string) => Promise<{
         clearedBuckets: number;
     }>;

package/storage/remoteStorage/storageController.ts

@@ -14,6 +14,7 @@ import {
     getStorageServerConfig, getTrust, getRequests, getLoadedBucket, writeBucketFile,
     deleteBucketFile, assertWritesAllowed, assertMutable, LoadedBucket,
     getBucketConfig, listAccountBuckets, ServerBucketInfo, clearAccountWriteStats,
+    getActiveBucket, activateBucket, ActiveBucketInfo,
 } from "./storageServerState";
 import { StorageClientController } from "./storageClientController";
 
@@ -23,6 +24,7 @@ export const STORAGE_NOT_AUTHENTICATED = "REMOTE_STORAGE_NOT_AUTHENTICATED_cf2f7
 export const STORAGE_ACCESS_DENIED = "REMOTE_STORAGE_ACCESS_DENIED_9d81a4c0";
 
 const AUTH_TIME_WINDOW = timeInMinute * 10;
+const ACCESS_CHECK_SLOW_TIME = 50;
 const MAX_SESSIONS = 100 * 1000;
 const MAX_REQUESTS_PER_IP = 50;
 
@@ -325,7 +327,23 @@ class RemoteStorageControllerBase {
         return getBucketConfig(bucket);
     }
     async listBuckets(account: string): Promise<ServerBucketInfo[]> {
-        return await listAccountBuckets(account);
+        let start = Date.now();
+        try {
+            return await listAccountBuckets(account);
+        } finally {
+            // The access hook (and the storage it initializes) runs before this, so a large gap between this and the caller's timing is the hook
+            console.log(`listBuckets(${account}) call body took ${Date.now() - start}ms`);
+        }
+    }
+    /** The live, in-memory state of one bucket, or a string saying why it is unavailable. Answered without touching the disk, so it is cheap - but only works while the bucket is loaded here. */
+    async getActiveBucket(account: string, bucketName: string): Promise<ActiveBucketInfo | string> {
+        assertValidName(bucketName, "bucket name");
+        return await getActiveBucket(account, bucketName);
+    }
+    /** Loads a bucket that exists on this server into memory (starting its synchronization) and returns its live state, or a string saying why it could not be loaded. */
+    async activateBucket(account: string, bucketName: string): Promise<ActiveBucketInfo | string> {
+        assertValidName(bucketName, "bucket name");
+        return await activateBucket(account, bucketName);
     }
     /** Zeroes the write statistics listBuckets reports, for every bucket in the account. */
     async clearWriteStats(account: string): Promise<{ clearedBuckets: number }> {
@@ -466,7 +484,12 @@ class RemoteStorageControllerBase {
 const largeUploadInfo = new Map<string, { account: string; bucketName: string; path: string }>();
 
 const accountAccess: SocketFunctionHook = async (context) => {
+    let start = Date.now();
     await requireAccess(String(context.call.args[0]));
+    let duration = Date.now() - start;
+    if (duration > ACCESS_CHECK_SLOW_TIME) {
+        console.log(`Access check for ${context.call.functionName} took ${duration}ms`);
+    }
 };
 const uploadAccess: SocketFunctionHook = async (context) => {
     let info = largeUploadInfo.get(String(context.call.args[0]));
@@ -499,6 +522,8 @@ export const RemoteStorageController = SocketFunction.register(
         getArchivesConfig: { hooks: [accountAccess] },
         getIndexInfo: { hooks: [accountAccess] },
         listBuckets: { hooks: [accountAccess] },
+        getActiveBucket: { hooks: [accountAccess] },
+        activateBucket: { hooks: [accountAccess] },
         clearWriteStats: { hooks: [accountAccess] },
         getSyncStatus: { hooks: [accountAccess] },
         startLargeFile: { hooks: [accountAccess] },

package/storage/remoteStorage/storageServerState.d.ts

@@ -76,6 +76,19 @@ export type ServerBucketInfo = {
     config?: ArchivesConfig;
     error?: string;
 };
+export type ActiveBucketInfo = {
+    folder: string;
+    /** The routing config the bucket is RUNNING on, straight from memory - including switchover windows written since it loaded */
+    routing: RemoteConfig;
+    /** Our own entries in that config, and the one currently valid */
+    selfEntries: HostedConfig[];
+    self?: HostedConfig;
+    config: ArchivesConfig;
+};
+/** The live in-memory state of ONE bucket, answered without touching the disk (no routing file read, no statfs, no stored write stats). Returns an error string when the bucket is not loaded here, which is the normal state for a bucket nothing has accessed since startup. */
+export declare function getActiveBucket(account: string, bucketName: string): Promise<ActiveBucketInfo | string>;
+/** Loads a bucket that exists on this server's disk into memory, which starts its synchronization and window timers, and returns its live state. Nothing is written and no other server is contacted - unlike building an ArchivesChain for it, which would probe every source and could write the routing config. Already-loaded buckets just return their state. */
+export declare function activateBucket(account: string, bucketName: string): Promise<ActiveBucketInfo | string>;
 export declare function listAccountBuckets(account: string): Promise<ServerBucketInfo[]>;
 export declare function deleteBucketFile(account: string, bucketName: string, filePath: string): Promise<void>;
 export declare function getLocalArchives(account: string, bucketName: string): IArchives;

package/storage/remoteStorage/storageServerState.ts

@@ -818,48 +818,123 @@ async function getDiskInfo(folder: string): Promise<BucketDiskInfo> {
     };
 }
 
+export type ActiveBucketInfo = {
+    folder: string;
+    /** The routing config the bucket is RUNNING on, straight from memory - including switchover windows written since it loaded */
+    routing: RemoteConfig;
+    /** Our own entries in that config, and the one currently valid */
+    selfEntries: HostedConfig[];
+    self?: HostedConfig;
+    config: ArchivesConfig;
+};
+
+/** The live in-memory state of ONE bucket, answered without touching the disk (no routing file read, no statfs, no stored write stats). Returns an error string when the bucket is not loaded here, which is the normal state for a bucket nothing has accessed since startup. */
+export async function getActiveBucket(account: string, bucketName: string): Promise<ActiveBucketInfo | string> {
+    let key = `${account}/${bucketName}`;
+    let loadedPromise = buckets.get(key);
+    if (!loadedPromise) {
+        return `Bucket ${key} is not loaded on this server, so it has no live state (it loads on first access)`;
+    }
+    let loaded: LoadedBucket | undefined;
+    try {
+        loaded = await loadedPromise;
+    } catch (e) {
+        return `Bucket ${key} failed to load on this server: ${String((e as Error).stack ?? e).slice(0, 500)}`;
+    }
+    if (!loaded) {
+        return `Bucket ${key} does not exist on this server`;
+    }
+    return toActiveBucketInfo(loaded);
+}
+
+function toActiveBucketInfo(loaded: LoadedBucket): ActiveBucketInfo {
+    return {
+        folder: getBucketFolder(loaded.account, loaded.bucketName),
+        routing: loaded.routing,
+        selfEntries: loaded.selfEntries,
+        self: loaded.self,
+        config: getBucketConfig(loaded),
+    };
+}
+
+/** Loads a bucket that exists on this server's disk into memory, which starts its synchronization and window timers, and returns its live state. Nothing is written and no other server is contacted - unlike building an ArchivesChain for it, which would probe every source and could write the routing config. Already-loaded buckets just return their state. */
+export async function activateBucket(account: string, bucketName: string): Promise<ActiveBucketInfo | string> {
+    let key = `${account}/${bucketName}`;
+    let wasLoaded = buckets.has(key);
+    let loaded: LoadedBucket | undefined;
+    try {
+        loaded = await getLoadedBucket(account, bucketName);
+    } catch (e) {
+        return `Bucket ${key} failed to load on this server: ${String((e as Error).stack ?? e).slice(0, 500)}`;
+    }
+    if (!loaded) {
+        return `Bucket ${key} does not exist on this server (no routing file in ${getBucketFolder(account, bucketName)})`;
+    }
+    if (!wasLoaded) {
+        console.log(`Activated bucket ${key} on request: it is now loaded and synchronizing`);
+    }
+    return toActiveBucketInfo(loaded);
+}
+
 export async function listAccountBuckets(account: string): Promise<ServerBucketInfo[]> {
+    let start = Date.now();
+    let timings = new Map<string, number>();
+    async function timed<T>(name: string, run: () => Promise<T>): Promise<T> {
+        let began = Date.now();
+        try {
+            return await run();
+        } finally {
+            timings.set(name, (timings.get(name) || 0) + (Date.now() - began));
+        }
+    }
     let accountFolder = path.join(getStorageServerConfig().folder, "buckets2", account);
     let names: string[];
     try {
-        names = await fs.promises.readdir(accountFolder);
+        names = await timed("readdir", () => fs.promises.readdir(accountFolder));
     } catch {
         return [];
     }
-    return await Promise.all(names.map(async bucketName => {
-        let key = `${account}/${bucketName}`;
-        let folder = getBucketFolder(account, bucketName);
-        let base: ServerBucketInfo = { bucketName, active: false, folder };
-        let [disk, writeStats] = await Promise.all([
-            getDiskInfo(folder).catch((e: Error) => {
-                base.diskError = String(e.stack ?? e).slice(0, 500);
-                return undefined;
-            }),
-            getBucketWriteStats(key),
-        ]);
-        base.disk = disk;
-        base.writeStats = writeStats;
-        let loadedPromise = buckets.get(key);
-        if (loadedPromise) {
+    try {
+        return await Promise.all(names.map(async bucketName => {
+            let key = `${account}/${bucketName}`;
+            let folder = getBucketFolder(account, bucketName);
+            let base: ServerBucketInfo = { bucketName, active: false, folder };
+            let [disk, writeStats] = await Promise.all([
+                timed("statfs", () => getDiskInfo(folder)).catch((e: Error) => {
+                    base.diskError = String(e.stack ?? e).slice(0, 500);
+                    return undefined;
+                }),
+                timed("writeStats", () => getBucketWriteStats(key)),
+            ]);
+            base.disk = disk;
+            base.writeStats = writeStats;
+            const loadedPromise = buckets.get(key);
+            if (loadedPromise) {
+                try {
+                    let loaded = await timed("awaitLoaded", () => loadedPromise);
+                    if (loaded) {
+                        return { ...base, active: true, config: getBucketConfig(loaded) };
+                    }
+                } catch (e) {
+                    return { ...base, active: true, error: String((e as Error).stack ?? e).slice(0, 500) };
+                }
+            }
             try {
-                let loaded = await loadedPromise;
-                if (loaded) {
-                    return { ...base, active: true, config: getBucketConfig(loaded) };
+                const data = await timed("readRoutingFile", () => readRoutingFile(folder));
+                if (!data) {
+                    return { ...base, error: `No routing file (${ROUTING_FILE})` };
                 }
+                let parsed = await timed("parseRouting", async () => parseRoutingData(data));
+                return { ...base, config: { remoteConfig: parsed } };
             } catch (e) {
-                return { ...base, active: true, error: String((e as Error).stack ?? e).slice(0, 500) };
-            }
-        }
-        try {
-            let data = await readRoutingFile(folder);
-            if (!data) {
-                return { ...base, error: `No routing file (${ROUTING_FILE})` };
+                return { ...base, error: String((e as Error).stack ?? e).slice(0, 500) };
             }
-            return { ...base, config: { remoteConfig: parseRoutingData(data) } };
-        } catch (e) {
-            return { ...base, error: String((e as Error).stack ?? e).slice(0, 500) };
-        }
-    }));
+        }));
+    } finally {
+        // The parts run concurrently, so these are summed wall times per part, not a breakdown of the total
+        let parts = [...timings].map(([name, ms]) => `${name} ${ms}ms`).join(", ");
+        console.log(`listAccountBuckets(${account}) took ${Date.now() - start}ms for ${names.length} buckets: ${parts}`);
+    }
 }
 
 export async function deleteBucketFile(account: string, bucketName: string, filePath: string): Promise<void> {