querysub 0.591.0 → 0.593.0

package/src/deployManager/machineSchema.ts

@@ -1,6 +1,5 @@
 import { isNodeTrue, list, timeInDay, timeInMinute, timeInSecond } from "socket-function/src/misc";
-import { nestArchives } from "../-a-archives/archives";
-import { getArchivesBackblaze } from "../-a-archives/archivesBackBlaze";
+import { getArchives2 } from "../-a-archives/archives2";
 import { getDomain } from "../config";
 import { archiveJSONT } from "../-a-archives/archivesJSONT";
 import { SocketFunction } from "socket-function/SocketFunction";
@@ -187,9 +186,9 @@ export type MachineConfig = {
     machineId: string;
     disabled: boolean;
 };
-export const machineInfos = archiveJSONT<MachineInfo>(() => nestArchives("machines/machine-heartbeats/", getArchivesBackblaze(getDomain())));
-export const serviceConfigs = archiveJSONT<ServiceConfig>(() => nestArchives("machines/service-configs/", getArchivesBackblaze(getDomain())));
-export const machineConfigs = archiveJSONT<MachineConfig>(() => nestArchives("machines/machine-configs/", getArchivesBackblaze(getDomain())));
+export const machineInfos = archiveJSONT<MachineInfo>(() => getArchives2("machines/machine-heartbeats/"));
+export const serviceConfigs = archiveJSONT<ServiceConfig>(() => getArchives2("machines/service-configs/"));
+export const machineConfigs = archiveJSONT<MachineConfig>(() => getArchives2("machines/machine-configs/"));
 
 export type LaunchRecord = {
     serviceId: string;
@@ -207,7 +206,7 @@ export type LaunchSummary = {
     key: string;
 };
 
-const launches = lazy(() => nestArchives("machines/launches/", getArchivesBackblaze(getDomain())));
+const launches = lazy(() => getArchives2("machines/launches/"));
 
 function formatLaunchDay(time: number): string {
     let date = new Date(time);

package/src/deployManager/setupMachineMain.ts

@@ -8,13 +8,12 @@ import readline from "readline";
 import open from "open";
 import { fsExistsAsync } from "../fs";
 import { delay } from "socket-function/src/batching";
+import { SERVICE_NAME, SERVICE_UNIT_NAME } from "./machineDaemonShared";
 // Import querysub, to fix missing dependencies
 Querysub;
 
 const pinnedNodeVersion = 22;
 
-const SERVICE_NAME = "machine-alwaysup";
-const SERVICE_UNIT_NAME = `${SERVICE_NAME}.service`;
 const DAEMON_SCRIPT_NAME = "machine-daemon.sh";
 // How long after the process dies before it is started again. Short, because until it is back nothing on the machine is being deployed or repaired.
 const SERVICE_RESTART_DELAY_SECONDS = 5;

package/src/deployManager/stopMachineMain.ts

@@ -0,0 +1,45 @@
+import { runPromise } from "../functional/runCommand";
+import { SERVICE_NAME, SERVICE_UNIT_NAME } from "./machineDaemonShared";
+
+const DPLY_SCREEN_SUFFIX = "-dply";
+
+async function main() {
+    let sshRemote = process.argv.slice(2).join(" ");
+    if (!sshRemote) {
+        console.error("Incorrect usage. Examples:\nyarn stop-machine 153.34.64.2\nyarn stop-machine devops@153.34.64.2");
+        process.exit(1);
+    }
+
+    await runPromise(`ssh ${sshRemote} whoami`);
+
+    let daemonState = (await runPromise(`ssh ${sshRemote} "systemctl is-active ${SERVICE_UNIT_NAME} || true"`, { nothrow: true })).trim();
+    if (daemonState === "active") {
+        console.log(`Stopping the ${SERVICE_UNIT_NAME} daemon...`);
+        await runPromise(`ssh ${sshRemote} "sudo systemctl stop ${SERVICE_UNIT_NAME}"`);
+        console.log(`✅ Daemon stopped`);
+    } else {
+        console.log(`✅ The ${SERVICE_UNIT_NAME} daemon is not running (state: ${daemonState || "unknown"})`);
+    }
+
+    let sessions = (await runPromise(`ssh ${sshRemote} "tmux list-sessions -F '#{session_name}' 2>/dev/null || true"`, { nothrow: true }))
+        .split("\n").map(x => x.trim()).filter(x => x);
+    // The machine's own screen first, so it cannot restart a service screen while the rest are being killed
+    let toKill = [
+        ...sessions.filter(name => name === SERVICE_NAME),
+        ...sessions.filter(name => name.endsWith(DPLY_SCREEN_SUFFIX)),
+    ];
+    if (toKill.length === 0) {
+        console.log(`✅ No ${SERVICE_NAME} or *${DPLY_SCREEN_SUFFIX} tmux sessions to kill (sessions: ${sessions.join(", ") || "none"})`);
+    }
+    for (let name of toKill) {
+        console.log(`Killing tmux session ${name}...`);
+        await runPromise(`ssh ${sshRemote} "tmux kill-session -t ${name}"`);
+    }
+    if (toKill.length > 0) {
+        console.log(`✅ Killed ${toKill.length} tmux session(s): ${toKill.join(", ")}`);
+    }
+
+    console.log(`\n🛑 Machine stopped. Start it again with: ssh ${sshRemote} "~/machine-startup.sh"`);
+}
+
+main().catch(console.error).finally(() => process.exit(0));

package/src/diagnostics/logs/IndexedLogs/IndexedLogs.ts

@@ -5,15 +5,17 @@ import { BufferIndex } from "./BufferIndex";
 import { delay, runInParallel, runInSerial, runInfinitePoll, runInfinitePollCallAtStart } from "socket-function/src/batching";
 import { IndexedLogResults, Reader, SearchParams, addReadToResults, createEmptyIndexedLogResults, INDEX_EXTENSION, mergeIndexedLogResults } from "./BufferIndexHelpers";
 import { getDomain, isPublic } from "../../../config";
-import { getArchivesHome, getArchivesLocal } from "../../../-a-archives/archivesDisk";
-import { getArchivesBackblaze, getArchivesBackblazePrivateImmutable } from "../../../-a-archives/archivesBackBlaze";
+import { getArchivesHome } from "../../../-a-archives/archivesDisk";
+import { getArchives2 } from "../../../-a-archives/archives2";
 import { getMachineId, getOwnThreadId } from "sliftutils/misc/https/certs";
 import { ArchivesMemoryCacheStats, createArchivesMemoryCache } from "../../../-a-archives/archivesMemoryCache";
+import { createArchivesMemoryCache2 } from "../../../-a-archives/archivesMemoryCache2";
+import { wrapArchivesWithCache2 } from "../../../-a-archives/archiveCache2";
 import { registerShutdownHandler } from "../../periodic";
 import { measureBlock, measureFnc, measureWrap } from "socket-function/src/profiling/measure";
 import { isNode } from "typesafecss";
 import { getOwnMachineId, isNodeIdOnOwnMachineId, isOwnNodeId } from "../../../-f-node-discovery/NodeDiscovery";
-import { TimeFilePath, TimeFileTree } from "./TimeFileTree";
+import { LogArchives, TimeFilePath, TimeFileTree } from "./TimeFileTree";
 import { LogStreamer } from "./LogStreamer";
 import { moveLogsToPublic } from "./moveIndexLogsToPublic";
 import { MAX_SINGLE_FILE_DATA, MAX_COUNT_PER_FILE, DISK_FLUSH_INTERVAL, PUBLIC_MOVE_THRESHOLD, MOVING_TIMEOUT } from "./BufferIndexLogsOptimizationConstants";
@@ -83,7 +85,7 @@ export class IndexedLogs<T> {
 
     private getLocalLogs = lazy((): Archives => {
         let baseDisk = getArchivesHome(getDomain());
-        let archives = nestArchives("indexed-logs/" + this.config.name, baseDisk);
+        let archives = nestArchives("indexed-logs/" + this.config.name, baseDisk) as Archives;
         archives = createArchivesMemoryCache(archives, {
             maxSize: 1024 * 1024 * 512,
             maxCount: 1000 * 100,
@@ -94,32 +96,43 @@ export class IndexedLogs<T> {
         });
         return archives;
     });
-    private getPublicLogsBase(loadPublic: boolean): Archives {
-        let basePublic: Archives = getArchivesHome(getDomain());
-        // NOTE: The local disk is so fast that reading in 10 megabytes is nothing, And if we read in too small of a value, the overhead per read ends up making this take forever. 
-        let extraReadSize = 1024 * 1024 * 10;
+    private getPublicLogsBase(loadPublic: boolean): LogArchives {
         if (loadPublic) {
-            basePublic = getArchivesBackblaze(getDomain());
-            // NOTE: While the latency to back plays is high, now we're reading in parallel, so it shouldn't be as big of an issue. 
-            extraReadSize = 1024 * 1024 * 1;
+            return createArchivesMemoryCache2(getArchives2("final-indexed-logs/" + this.config.name), {
+                maxSize: 1024 * 1024 * 1024 * 2,
+                maxCount: 1000 * 500,
+                fullyImmutable: true,
+                // NOTE: While the latency to the remote is high, now we're reading in parallel, so it shouldn't be as big of an issue.
+                extraReadSize: 1024 * 1024 * 1,
+                stats: this.backblazeLogsStats,
+                sizeCache: this.fileSizeCache,
+            });
         }
-        let archives = nestArchives("final-indexed-logs/" + this.config.name, basePublic);
-        archives = createArchivesMemoryCache(archives, {
+        let archives = nestArchives("final-indexed-logs/" + this.config.name, getArchivesHome(getDomain()));
+        return createArchivesMemoryCache(archives, {
             maxSize: 1024 * 1024 * 1024 * 2,
             maxCount: 1000 * 500,
             fullyImmutable: true,
-            extraReadSize,
+            // NOTE: The local disk is so fast that reading in 10 megabytes is nothing, And if we read in too small of a value, the overhead per read ends up making this take forever.
+            extraReadSize: 1024 * 1024 * 10,
             stats: this.backblazeLogsStats,
             sizeCache: this.fileSizeCache,
         });
-        return archives;
     };
     public debugGetCachedLogs = cache((config: {
         type: "local" | "public";
-    }) => {
-        let usePublic = config.type === "public";
-        let archives = usePublic ? getArchivesBackblaze(getDomain()) : getArchivesHome(getDomain());
-        archives = nestArchives("final-indexed-logs/" + this.config.name, archives);
+    }): LogArchives => {
+        if (config.type === "public") {
+            let archives2 = wrapArchivesWithCache2(getArchives2("final-indexed-logs/" + this.config.name), {
+                immutable: true,
+            });
+            return createArchivesMemoryCache2(archives2, {
+                maxSize: 1024 * 1024 * 1024 * 12,
+                maxCount: 1000 * 500,
+                fullyImmutable: true,
+            });
+        }
+        let archives = nestArchives("final-indexed-logs/" + this.config.name, getArchivesHome(getDomain())) as Archives;
         archives = wrapArchivesWithCache(archives, {
             immutable: true,
         });
@@ -133,10 +146,10 @@ export class IndexedLogs<T> {
     public debugIsPublic() {
         return isPublic();
     }
-    private getPublicLogs = lazy((): Archives => {
+    private getPublicLogs = lazy((): LogArchives => {
         return this.getPublicLogsBase(isPublic());
     });
-    private getRealPublicLogs = lazy((): Archives => {
+    private getRealPublicLogs = lazy((): LogArchives => {
         return this.getPublicLogsBase(true);
     });
 

package/src/diagnostics/logs/IndexedLogs/MCPIndexedLogs.ts

@@ -5,7 +5,7 @@ import { getDomain } from "../../../config";
 import { getAllNodeIds, getOwnMachineId, isOwnNodeId } from "../../../-f-node-discovery/NodeDiscovery";
 import { NodeCapabilitiesController } from "../../../-g-core-values/NodeCapabilities";
 import { getLoggers2Async, LogDatum } from "../diskLogger";
-import { Archives } from "../../../-a-archives/archives";
+import { LogArchives } from "./TimeFileTree";
 import { TimeFilePath, TimeFileTree } from "./TimeFileTree";
 import { BufferReader, INDEX_EXTENSION, createEmptyIndexedLogResults } from "./BufferIndexHelpers";
 import { BufferIndex } from "./BufferIndex";
@@ -104,7 +104,7 @@ type Direction = "fromStart" | "fromEnd";
 type FileEntry = {
     path: TimeFilePath;
     loggerName: LoggerName;
-    archives: Archives;
+    archives: LogArchives;
 };
 
 // Mutable accumulators the file/block walk appends into, instead of returning
@@ -570,7 +570,7 @@ export class MCPIndexedLogs {
     // Caches TimeFileTree.findAllPaths by hour-aligned bucket so repeated
     // searches over similar windows reuse the slow folder walk.
     private async getCachedPaths(config: {
-        archives: Archives;
+        archives: LogArchives;
         type: "local" | "public";
         loggerName: LoggerName;
         startTime: number;

package/src/diagnostics/logs/IndexedLogs/TimeFileTree.ts

@@ -1,7 +1,16 @@
 import { timeInDay } from "socket-function/src/misc";
-import { Archives } from "../../../-a-archives/archives";
 import { getOwnThreadId, getOwnMachineId } from "../../../-f-node-discovery/NodeDiscovery";
 
+/** The subset of archive operations the log system uses, so both the old disk Archives and archives2 (IArchives) work interchangeably. */
+export type LogArchives = {
+    getDebugName(): string;
+    get(path: string, config?: { range?: { start: number; end: number; } }): Promise<Buffer | undefined>;
+    set(path: string, data: Buffer): Promise<unknown>;
+    del(path: string): Promise<void>;
+    getInfo(path: string): Promise<{ writeTime: number; size: number; } | undefined>;
+    find(prefix: string, config?: { shallow?: boolean; type: "files" | "folders" }): Promise<string[]>;
+};
+
 export type TimeFilePath = {
     fullPath: string;
 
@@ -113,7 +122,7 @@ export function decodeLogFilePath(path: string): TimeFilePath | undefined {
 
 // NOTE: This class will add its own extensions to the files, and it'll use it to detect these files. You can append your own extension and then we will ignore those files. 
 export class TimeFileTree {
-    public constructor(public archives: Archives) { }
+    public constructor(public archives: LogArchives) { }
 
     public async findAllPaths(config: {
         startTime: number;

package/src/diagnostics/logs/IndexedLogs/moveIndexLogsToPublic.ts

@@ -1,10 +1,9 @@
 import { delay } from "socket-function/src/batching";
 import { sort, keyByArray } from "socket-function/src/misc";
-import { Archives } from "../../../-a-archives/archives";
 import { getOwnThreadId } from "../../../-f-node-discovery/NodeDiscovery";
 import { BufferIndex } from "./BufferIndex";
 import { LogStreamer } from "./LogStreamer";
-import { TimeFileTree } from "./TimeFileTree";
+import { LogArchives, TimeFileTree } from "./TimeFileTree";
 import { blue, green, magenta } from "socket-function/src/formatting/logColors";
 import { formatDateTime, formatNumber, formatTime } from "socket-function/src/formatting/format";
 
@@ -17,8 +16,8 @@ export async function moveLogsToPublic(config: {
     movingTimeout: number;
     // Unsafe, but useful for testing
     forceAll: boolean;
-    localLogs: Archives;
-    publicLogs: Archives;
+    localLogs: LogArchives;
+    publicLogs: LogArchives;
     indexExtension: string;
 }) {
     let { forceAll, localLogs, publicLogs, publicMoveThreshold, maxSingleFileData, indexExtension, movingTimeout } = config;

package/src/diagnostics/logs/errorTickets/tickets.ts

@@ -2,10 +2,9 @@ import { lazy } from "socket-function/src/caching";
 import { batchFunction, runInfinitePollCallAtStart } from "socket-function/src/batching";
 import { timeInMinute } from "socket-function/src/misc";
 import { SocketFunction } from "socket-function/SocketFunction";
-import { nestArchives } from "../../../-a-archives/archives";
-import { getArchivesBackblaze } from "../../../-a-archives/archivesBackBlaze";
+import { getArchives2 } from "../../../-a-archives/archives2";
 import { archiveJSONT } from "../../../-a-archives/archivesJSONT";
-import { getDomain, isPublic } from "../../../config";
+import { isPublic } from "../../../config";
 import { getControllerNodeId } from "../../../-g-core-values/NodeCapabilities";
 import { assertIsManagementUser } from "../../managementPages";
 import { getSyncedController } from "../../../library-components/SyncedController";
@@ -14,7 +13,7 @@ import { Ticket, TicketComment, TicketPatchStatus, TicketState } from "./ticketT
 
 const TICKET_CACHE_POLL_INTERVAL = timeInMinute * 5;
 
-export const ticketsArchive = archiveJSONT<Ticket>(() => nestArchives("logs/error-tickets/", getArchivesBackblaze(getDomain())));
+export const ticketsArchive = archiveJSONT<Ticket>(() => getArchives2("logs/error-tickets/"));
 
 let ticketCache = new Map<string, Ticket>();
 let ensureWatching = lazy(async () => {

package/src/diagnostics/logs/lifeCycleAnalysis/lifeCycles.tsx

@@ -1,8 +1,6 @@
 import { lazy } from "socket-function/src/caching";
-import { nestArchives } from "../../../-a-archives/archives";
-import { getArchivesBackblaze } from "../../../-a-archives/archivesBackBlaze";
+import { getArchives2 } from "../../../-a-archives/archives2";
 import { archiveJSONT } from "../../../-a-archives/archivesJSONT";
-import { getDomain } from "../../../config";
 import { runInfinitePollCallAtStart } from "socket-function/src/batching";
 import { timeInMinute } from "socket-function/src/misc";
 import { SocketFunction } from "socket-function/SocketFunction";
@@ -56,7 +54,7 @@ export function getVariables(entry: LifeCycleEntry): { key: string, title?: stri
     return variables;
 }
 
-const lifeCycles = archiveJSONT<LifeCycle>(() => nestArchives("logs/life-cycles/", getArchivesBackblaze(getDomain())));
+const lifeCycles = archiveJSONT<LifeCycle>(() => getArchives2("logs/life-cycles/"));
 let lifeCyclesCache: LifeCycle[] = [];
 
 let ensureWatching = lazy(async () => {

package/src/storageSetup.ts

@@ -15,7 +15,7 @@ async function main() {
 
     let trustedMachineIds = await getTrustedMachineIds();
 
-    let { setTrustedMachines } = await import("sliftutils/storage/remoteStorage/storageServerState");
+    let { setTrustedMachines } = await import("sliftutils/storage/remoteStorage/serverConfig");
     await setTrustedMachines({ account: "root", machineIds: trustedMachineIds });
     console.log(`Synchronized ${trustedMachineIds.length} trusted machines`);
 

package/src/-a-archives/archivesBackBlaze.ts

@@ -1,156 +0,0 @@
-import { cache } from "socket-function/src/caching";
-import { Archives } from "./archives";
-import fs from "fs";
-import { isNode, timeInMinute } from "socket-function/src/misc";
-import { isLogBackblaze } from "../config";
-import { getBackblazePath } from "../misc/appPaths";
-import { ArchivesBackblaze as ArchivesBackblazeBase } from "sliftutils/storage/backblaze";
-import type { IArchives, ArchivesConfig } from "sliftutils/storage/IArchives";
-
-export function hasBackblazePermissions() {
-    return isNode() && fs.existsSync(getBackblazePath());
-}
-
-// The implementation lives in sliftutils (it reads credentials via getSecret, which our appSecrets.ts serves from getBackblazePath). We forward to an inner instance instead of subclassing, because our Archives interface's move/copy take a querysub Archives target (with getBaseArchives unwrapping) which is type-incompatible with the base class's IArchives signatures.
-export class ArchivesBackblaze {
-    private archives: ArchivesBackblazeBase;
-
-    public constructor(config: {
-        bucketName: string;
-        public?: boolean;
-        immutable?: boolean;
-        cacheTime?: number;
-        allowedOrigins?: string[];
-    }) {
-        this.archives = new ArchivesBackblazeBase(config);
-        if (isLogBackblaze()) {
-            this.archives.enableLogging();
-        }
-    }
-
-    public enableLogging(): void {
-        this.archives.enableLogging();
-    }
-    public getDebugName(): string {
-        return this.archives.getDebugName();
-    }
-    public async hasWriteAccess(): Promise<boolean> {
-        return this.archives.hasWriteAccess();
-    }
-    public async getConfig(): Promise<ArchivesConfig> {
-        return this.archives.getConfig();
-    }
-    public async get(fileName: string, config?: { range?: { start: number; end: number; }; retryCount?: number }): Promise<Buffer | undefined> {
-        return this.archives.get(fileName, config);
-    }
-    public async get2(fileName: string, config?: { range?: { start: number; end: number; } }): Promise<{ data: Buffer; writeTime: number; size: number } | undefined> {
-        return this.archives.get2(fileName, config);
-    }
-    public async set(fileName: string, data: Buffer, config?: { lastModified?: number }): Promise<string> {
-        return this.archives.set(fileName, data, config);
-    }
-    public async append(fileName: string, data: Buffer): Promise<void> {
-        throw new Error(`ArchivesBackblaze does not support append. Use set instead.`);
-    }
-    public async del(fileName: string): Promise<void> {
-        return this.archives.del(fileName);
-    }
-    public async setLargeFile(config: { path: string; getNextData(): Promise<Buffer | undefined>; }): Promise<void> {
-        return this.archives.setLargeFile(config);
-    }
-    public async getInfo(fileName: string): Promise<{ writeTime: number; size: number; } | undefined> {
-        return this.archives.getInfo(fileName);
-    }
-    public async find(prefix: string, config?: { shallow?: boolean; type: "files" | "folders" }): Promise<string[]> {
-        return this.archives.find(prefix, config);
-    }
-    public async findInfo(prefix: string, config?: { shallow?: boolean; type: "files" | "folders" }): Promise<{ path: string; createTime: number; size: number; }[]> {
-        return this.archives.findInfo(prefix, config);
-    }
-    public async assertPathValid(path: string): Promise<void> {
-        return this.archives.assertPathValid(path);
-    }
-
-    public async move(config: {
-        path: string;
-        target: Archives;
-        targetPath: string;
-        copyInstead?: boolean;
-    }): Promise<void> {
-        let { target, targetPath } = config;
-        let base = target.getBaseArchives?.();
-        if (base) {
-            target = base.archives;
-            targetPath = base.parentPath + targetPath;
-        }
-        // Hand the inner instance across so the base implementation's bucket-to-bucket copyFile fast path (an instanceof check on its own class) still triggers.
-        let innerTarget: IArchives = target instanceof ArchivesBackblaze
-            ? target.archives
-            : target as unknown as IArchives;
-        return this.archives.move({
-            path: config.path,
-            target: innerTarget as any,
-            targetPath,
-            copyInstead: config.copyInstead,
-        });
-    }
-
-    public async copy(config: {
-        path: string;
-        target: Archives;
-        targetPath: string;
-    }): Promise<void> {
-        return this.move({ ...config, copyInstead: true });
-    }
-
-    public async getURL(path: string): Promise<string> {
-        return this.archives.getURL(path);
-    }
-
-    public async getDownloadAuthorization(config: {
-        fileNamePrefix?: string;
-        validDurationInSeconds: number;
-        b2ContentDisposition?: string;
-        b2ContentLanguage?: string;
-        b2Expires?: string;
-        b2CacheControl?: string;
-        b2ContentEncoding?: string;
-        b2ContentType?: string;
-    }): Promise<{
-        bucketId: string;
-        fileNamePrefix: string;
-        authorizationToken: string;
-    }> {
-        return this.archives.getDownloadAuthorization(config);
-    }
-}
-
-export const getArchivesBackblaze = cache((domain: string) => {
-    return new ArchivesBackblaze({ bucketName: domain });
-});
-export const getArchivesBackblazePrivateImmutable = cache((domain: string) => {
-    return new ArchivesBackblaze({
-        bucketName: domain + "-private-immutable",
-        immutable: true
-    });
-});
-export const getArchivesBackblazePublicImmutable = cache((domain: string) => {
-    return new ArchivesBackblaze({
-        bucketName: domain + "-public-immutable",
-        public: true,
-        immutable: true,
-        allowedOrigins: [`https://${domain}`, `https://127-0-0-1.${domain}:7007`],
-    });
-});
-
-// NOTE: Cache by a minute. This might be a bad idea, but... usually whole reason for public is
-//  for cloudflare caching (as otherwise we can just access it through a server), or for large files
-//  (which should be cached anyways, and probably even use immutable caching).
-export const getArchivesBackblazePublic = cache((domain: string) => {
-    return new ArchivesBackblaze({
-        bucketName: domain + "-public",
-        public: true,
-        cacheTime: timeInMinute,
-        allowedOrigins: [`https://${domain}`, `https://127-0-0-1.${domain}:7007`],
-    });
-});

package/src/-a-archives/archivesCborT.ts

@@ -1,52 +0,0 @@
-import { lazy } from "socket-function/src/caching";
-import { Archives } from "./archives";
-import { decodeCborx, encodeCborx } from "../misc/cloneHelpers";
-import { ArchiveT } from "./archivesJSONT";
-
-export function archiveCborT<T>(archives: () => Archives): ArchiveT<T> {
-    archives = lazy(archives);
-    async function get(key: string) {
-        let buffer = await archives().get(key);
-        if (!buffer) return undefined;
-        return decodeCborx(buffer) as T;
-    }
-    async function set(key: string, value: T) {
-        await archives().set(key, encodeCborx(value));
-    }
-    async function deleteFnc(key: string) {
-        await archives().del(key);
-    }
-    async function keys() {
-        return (await archives().find("")).map(value => value.toString());
-    }
-    async function values() {
-        let keysArray = await keys();
-        let results: T[] = [];
-        await Promise.all(keysArray.map(async key => {
-            let value = await get(key);
-            if (value) {
-                results.push(value);
-            }
-        }));
-        return results;
-    }
-    async function entries(): Promise<[string, T][]> {
-        let keysArray = await keys();
-        let results: [string, T][] = [];
-        await Promise.all(keysArray.map(async key => {
-            let value = await get(key);
-            if (value) {
-                results.push([key, value]);
-            }
-        }));
-        return results;
-    }
-    async function* asyncIterator(): AsyncIterator<[string, T]> {
-        for (let [key, value] of await entries()) {
-            yield [key, value];
-        }
-    }
-    return {
-        get, set, delete: deleteFnc, keys, values, entries, [Symbol.asyncIterator]: asyncIterator
-    };
-}