querysub 0.488.0 → 0.489.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.488.0",
+  "version": "0.489.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",

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

@@ -21,6 +21,7 @@ import { Time } from "./pathValueCore";
 import { encodeCborx, decodeCborx } from "../misc/cloneHelpers";
 import { debugGetAllCallFactories } from "socket-function/src/nodeCache";
 import { delay } from "socket-function/src/batching";
+import { isDefined } from "../misc";
 export { pathValueCommitter };
 
 let pathValueSendCount = 0;
@@ -103,12 +104,14 @@ export class PathValueControllerBase {
         pathValues: PathValue[];
         initialTriggers?: { values: Set<string>; parentPaths: Set<string> },
         reason: string;
+        // Locks are normally stripped because watchers don't need them, but a receiving authority needs the locks to compute the valid state itself — without them it can only adopt our valid state and can never recompute.
+        keepLocks?: boolean;
     }) {
         let changes = config.pathValues;
         let { nodeId, initialTriggers } = config;
         pathValueSendCount += changes.length;
         let buffers = await pathValueSerializer.serialize(changes, {
-            noLocks: true,
+            noLocks: !config.keepLocks,
             compress: getCompressNetwork(),
         });
         this.logSendValues({ nodeId, pathValues: changes, initialTriggers, reason: config.reason });
@@ -182,6 +185,9 @@ export class PathValueControllerBase {
             }
         }
 
+        // Note which values are genuinely new to us BEFORE ingesting. We only re-share new values with the other authorities below; if we already had a value we already shared it when we first received it, so re-sharing is redundant and can clobber a newer value with an older copy.
+        let valuesNewToUs = config.initialCreation && values.filter(value => !authorityStorage.getValueExactMaybeRejected(value.path, value.time)) || [];
+
         try {
             let initialTriggers = config.initialTriggers || { values: new Set(), parentPaths: new Set() };
             await pathValueCommitter.ingestRemoteValuesAndValidStates({
@@ -194,9 +200,10 @@ export class PathValueControllerBase {
         }
 
 
-        if (config.initialCreation) {
-            // NOTE: This will mean that all of the authorities for a value will write it to disk. So it will be written to disk multiple times. This should be fine, and it might be a good idea for redundancy, etc. And eventually, they will get compressed to one value, so it's not inefficient.
-            await PathValueControllerBase.authorityShareValues({ pathValues: values });
+        if (config.initialCreation && valuesNewToUs.length > 0) {
+            // Always shared the latest. If we don't have it, maybe something with ingestion delayed, we should still share it so we don't lose the value. If we haven't even ingested it, then it is our latest version of the value.
+            valuesNewToUs = valuesNewToUs.map(value => authorityStorage.getValueExactMaybeRejected(value.path, value.time) || value);
+            await PathValueControllerBase.authorityShareValues({ pathValues: valuesNewToUs });
         }
     }
 
@@ -211,6 +218,7 @@ export class PathValueControllerBase {
                     nodeId: otherAuthority,
                     pathValues: values,
                     reason: "authorityShareValues",
+                    keepLocks: true,
                 }), () => new Error(`Timeout forwarding shared values (${values.length} values) to authority ${otherAuthority}`));
             } catch (error: any) {
                 console.error(error.message, { otherAuthority, count: values.length });