querysub 0.437.0 → 0.439.0

package/src/0-path-value-core/PathValueController.ts

@@ -99,11 +99,9 @@ export class PathValueControllerBase {
     }) {
         let changes = config.pathValues;
         let { nodeId, initialTriggers } = config;
-        let allowSource = await isNodeTrusted(nodeId) || getNodeIdIP(nodeId) === "127.0.0.1";
         let buffers = await pathValueSerializer.serialize(changes, {
             noLocks: true,
             compress: getCompressNetwork(),
-            stripSource: !allowSource,
         });
         this.logSendValues({ nodeId, pathValues: changes, initialTriggers, });
         return await PathValueController.nodes[nodeId].sendData({

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

@@ -1,12 +1,15 @@
 import { sha256 } from "js-sha256";
 import { getArchives } from "../../-a-archives/archives";
 import { getAllNodeIds, getOwnThreadId } from "../../-f-node-discovery/NodeDiscovery";
-import { pathValueArchives } from "../pathValueArchives";
+import { archives, pathValueArchives } from "../pathValueArchives";
 import { ignoreErrors, logErrors, timeoutToUndefinedSilent } from "../../errors";
 import { green, magenta } from "socket-function/src/formatting/logColors";
 import { devDebugbreak, isPublic } from "../../config";
 import { sort } from "socket-function/src/misc";
 import { lazy } from "socket-function/src/caching";
+import { decodeCborx, encodeCborx } from "../../misc/cloneHelpers";
+import { runInParallel } from "socket-function/src/batching";
+import { formatNumber } from "socket-function/src/formatting/format";
 
 const snapshots = lazy(() => getArchives("snapshots"));
 
@@ -140,6 +143,39 @@ async function getSnapshotBase(snapshotFile: string | "live") {
     };
 }
 
+export interface ArchiveSnapshotPayloadFile {
+    path: string;
+    data: Buffer;
+}
+
+export async function downloadSnapshot(snapshotFile: string | "live"): Promise<Buffer> {
+    let { files } = await getSnapshotBase(snapshotFile);
+    let buffers = await pathValueArchives.getRawValueFiles(files, { includeRecycleBin: true });
+    let payload: ArchiveSnapshotPayloadFile[] = [];
+    for (let i = 0; i < files.length; i++) {
+        let data = buffers[i];
+        if (!data) continue;
+        payload.push({ path: files[i], data });
+    }
+    return encodeCborx(payload);
+}
+
+export async function uploadSnapshot(buffer: Buffer): Promise<ArchiveSnapshotOverview> {
+    let payload = decodeCborx<ArchiveSnapshotPayloadFile[]>(buffer);
+    let liveArchives = archives();
+    async function uploadFile(path: string, data: Buffer) {
+        let existing = await liveArchives.getInfo(path);
+        if (existing) return;
+        console.log(`Creating missing file (${formatNumber(data.length)}B): ${path}`);
+        await liveArchives.set(path, Buffer.from(data));
+    }
+    let parallel = runInParallel({
+        parallelCount: 32,
+    }, uploadFile);
+    await Promise.all(payload.map(file => parallel(file.path, file.data)));
+    return await saveSnapshot({ files: payload.map(x => x.path) });
+}
+
 // EXTREME DANGEROUS! Should only be done when all servers are down (except one, which
 //  is run on a developers machine). Worse case scenario, where everything is broken,
 //  and you need to just go back to a previous state.

package/src/0-path-value-core/pathValueCore.ts

@@ -394,6 +394,18 @@ export function debugPathValue(pathValue: PathValue, write?: boolean): string {
 export function debugTime(time: Time): string {
     return `${time.time}[${time.version}]@${time.creatorId.toString().slice(4, 12)}`;
 }
+export function parseDebugTime(debugTime: string): {
+    time: number;
+    version: number;
+    creatorIdPart: string;
+} {
+    let parts = debugTime.split(/[\[\]\@]/g);
+    return {
+        time: +(parts[0]),
+        version: +(parts[1]),
+        creatorIdPart: parts[2],
+    };
+}
 
 
 let getCompressNetworkBase = () => false;