cojson 0.12.1 → 0.13.2

package/src/coValueState.ts

@@ -176,11 +176,12 @@ export class CoValueState {
   async loadFromPeers(peers: PeerState[]) {
     const state = this.state;
 
-    if (state.type !== "unknown" && state.type !== "unavailable") {
+    if (state.type === "loading" || state.type === "available") {
       return;
     }
 
     if (peers.length === 0) {
+      this.moveToState(new CoValueUnavailableState());
       return;
     }
 
@@ -192,7 +193,11 @@ export class CoValueState {
 
       // If we are in the loading state we move to a new loading state
       // to reset all the loading promises
-      if (this.state.type === "loading" || this.state.type === "unknown") {
+      if (
+        this.state.type === "loading" ||
+        this.state.type === "unknown" ||
+        this.state.type === "unavailable"
+      ) {
         this.moveToState(
           new CoValueLoadingState(peersWithoutErrors.map((p) => p.id)),
         );
@@ -308,6 +313,19 @@ async function loadCoValueFromPeers(
     }
 
     if (coValueEntry.state.type === "loading") {
+      const { promise, resolve } = createResolvablePromise<void>();
+
+      /**
+       * Use a very long timeout for storage peers, because under pressure
+       * they may take a long time to consume the messages queue
+       *
+       * TODO: Track errors on storage and do not rely on timeout
+       */
+      const timeoutDuration =
+        peer.role === "storage"
+          ? CO_VALUE_LOADING_CONFIG.TIMEOUT * 10
+          : CO_VALUE_LOADING_CONFIG.TIMEOUT;
+
       const timeout = setTimeout(() => {
         if (coValueEntry.state.type === "loading") {
           logger.warn("Failed to load coValue from peer", {
@@ -319,9 +337,10 @@ async function loadCoValueFromPeers(
             type: "not-found-in-peer",
             peerId: peer.id,
           });
+          resolve();
         }
-      }, CO_VALUE_LOADING_CONFIG.TIMEOUT);
-      await coValueEntry.state.waitForPeer(peer.id);
+      }, timeoutDuration);
+      await Promise.race([promise, coValueEntry.state.waitForPeer(peer.id)]);
       clearTimeout(timeout);
     }
   }

package/src/crypto/crypto.ts

@@ -1,4 +1,3 @@
-import { randomBytes } from "@noble/ciphers/webcrypto/utils";
 import { base58 } from "@scure/base";
 import { RawAccountID } from "../coValues/account.js";
 import { AgentID, RawCoID, TransactionID } from "../ids.js";
@@ -7,6 +6,10 @@ import { Stringified, parseJSON, stableStringify } from "../jsonStringify.js";
 import { JsonValue } from "../jsonValue.js";
 import { logger } from "../logger.js";
 
+function randomBytes(bytesLength = 32): Uint8Array {
+  return crypto.getRandomValues(new Uint8Array(bytesLength));
+}
+
 export type SignerSecret = `signerSecret_z${string}`;
 export type SignerID = `signer_z${string}`;
 export type Signature = `signature_z${string}`;

package/src/priority.ts

@@ -7,7 +7,7 @@ import { type CoValueHeader } from "./coValueCore.js";
  * The priority value is handled as weight in the weighed round robin algorithm
  * used to determine the order in which messages are sent.
  *
- * Follows the HTTP urgency range and order:
+ * Loosely follows the HTTP urgency range and order, but limited to 3 values:
  *  - https://www.rfc-editor.org/rfc/rfc9218.html#name-urgency
  */
 export const CO_VALUE_PRIORITY = {
@@ -16,7 +16,7 @@ export const CO_VALUE_PRIORITY = {
   LOW: 6,
 } as const;
 
-export type CoValuePriority = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7;
+export type CoValuePriority = 0 | 3 | 6;
 
 export function getPriorityFromHeader(
   header: CoValueHeader | undefined | boolean,

package/src/sync.ts

@@ -23,10 +23,6 @@ export function emptyKnownState(id: RawCoID): CoValueKnownState {
   };
 }
 
-function getErrorMessage(e: unknown) {
-  return e instanceof Error ? e.message : "Unknown error";
-}
-
 export type SyncMessage =
   | LoadMessage
   | KnownStateMessage
@@ -415,7 +411,20 @@ export class SyncManager {
           entry.loadFromPeers([peer]).catch((e) => {
             logger.error("Error loading coValue in handleLoad", { err: e });
           });
+        } else {
+          // We don't have any eligible peers to load the coValue from
+          // so we send a known state back to the sender to let it know
+          // that the coValue is unavailable
+          this.trySendToPeer(peer, {
+            action: "known",
+            id: msg.id,
+            header: false,
+            sessions: {},
+          }).catch((e) => {
+            logger.error("Error sending known state back", { err: e });
+          });
         }
+
         return;
       } else {
         this.local.loadCoValueCore(msg.id, peer.id).catch((e) => {
@@ -460,6 +469,13 @@ export class SyncManager {
             err: e,
           });
         });
+    } else if (entry.state.type === "unavailable") {
+      this.trySendToPeer(peer, {
+        action: "known",
+        id: msg.id,
+        header: false,
+        sessions: {},
+      });
     }
 
     if (entry.state.type === "available") {
@@ -604,39 +620,12 @@ export class SyncManager {
         continue;
       }
 
-      const before = performance.now();
-      // eslint-disable-next-line neverthrow/must-use-result
       const result = coValue.tryAddTransactions(
         sessionID,
         newTransactions,
         undefined,
         newContentForSession.lastSignature,
       );
-      const after = performance.now();
-      if (after - before > 80) {
-        const totalTxLength = newTransactions
-          .map((t) =>
-            t.privacy === "private"
-              ? t.encryptedChanges.length
-              : t.changes.length,
-          )
-          .reduce((a, b) => a + b, 0);
-        logger.debug(
-          `Adding incoming transactions took ${(after - before).toFixed(
-            2,
-          )}ms for ${totalTxLength} bytes = bandwidth: ${(
-            (1000 * totalTxLength) / (after - before) / (1024 * 1024)
-          ).toFixed(2)} MB/s`,
-        );
-      }
-
-      // const theirTotalnTxs = Object.values(
-      //     peer.optimisticKnownStates[msg.id]?.sessions || {},
-      // ).reduce((sum, nTxs) => sum + nTxs, 0);
-      // const ourTotalnTxs = [...coValue.sessionLogs.values()].reduce(
-      //     (sum, session) => sum + session.transactions.length,
-      //     0,
-      // );
 
       if (result.isErr()) {
         logger.error("Failed to add transactions", {
@@ -735,16 +724,10 @@ export class SyncManager {
   }
 
   async actuallySyncCoValue(coValue: CoValueCore) {
-    // let blockingSince = performance.now();
     for (const peer of this.peersInPriorityOrder()) {
       if (peer.closed) continue;
       if (peer.erroredCoValues.has(coValue.id)) continue;
-      // if (performance.now() - blockingSince > 5) {
-      //     await new Promise<void>((resolve) => {
-      //         setTimeout(resolve, 0);
-      //     });
-      //     blockingSince = performance.now();
-      // }
+
       if (peer.optimisticKnownStates.has(coValue.id)) {
         await this.tellUntoldKnownStateIncludingDependencies(coValue.id, peer);
         await this.sendNewContentIncludingDependencies(coValue.id, peer);

package/src/tests/PriorityBasedMessageQueue.test.ts

@@ -7,9 +7,9 @@ import {
   tearDownTestMetricReader,
 } from "./testUtils.js";
 
-function setup() {
+function setup(attrs?: Record<string, string | number>) {
   const metricReader = createTestMetricReader();
-  const queue = new PriorityBasedMessageQueue(CO_VALUE_PRIORITY.MEDIUM);
+  const queue = new PriorityBasedMessageQueue(CO_VALUE_PRIORITY.MEDIUM, attrs);
   return { queue, metricReader };
 }
 
@@ -18,10 +18,133 @@ describe("PriorityBasedMessageQueue", () => {
     tearDownTestMetricReader();
   });
 
+  describe("meteredQueue", () => {
+    test("should corretly count pushes", async () => {
+      const { queue, metricReader } = setup();
+      const message: SyncMessage = {
+        action: "load",
+        id: "co_ztest-id",
+        header: false,
+        sessions: {},
+      };
+
+      expect(
+        await metricReader.getMetricValue("jazz.messagequeue.pushed", {
+          priority: CO_VALUE_PRIORITY.MEDIUM,
+        }),
+      ).toBe(0);
+
+      void queue.push(message);
+      expect(
+        await metricReader.getMetricValue("jazz.messagequeue.pushed", {
+          priority: CO_VALUE_PRIORITY.MEDIUM,
+        }),
+      ).toBe(1);
+
+      void queue.push(message);
+      expect(
+        await metricReader.getMetricValue("jazz.messagequeue.pushed", {
+          priority: CO_VALUE_PRIORITY.MEDIUM,
+        }),
+      ).toBe(2);
+    });
+
+    test("should corretly count pulls", async () => {
+      const { queue, metricReader } = setup();
+      const message: SyncMessage = {
+        action: "load",
+        id: "co_ztest-id",
+        header: false,
+        sessions: {},
+      };
+
+      expect(
+        await metricReader.getMetricValue("jazz.messagequeue.pulled", {
+          priority: CO_VALUE_PRIORITY.MEDIUM,
+        }),
+      ).toBe(0);
+
+      void queue.push(message);
+      expect(
+        await metricReader.getMetricValue("jazz.messagequeue.pulled", {
+          priority: CO_VALUE_PRIORITY.MEDIUM,
+        }),
+      ).toBe(0);
+
+      void queue.pull();
+
+      expect(
+        await metricReader.getMetricValue("jazz.messagequeue.pulled", {
+          priority: CO_VALUE_PRIORITY.MEDIUM,
+        }),
+      ).toBe(1);
+
+      // We only have one item in the queue, so this should not change the metric value
+      void queue.pull();
+      expect(
+        await metricReader.getMetricValue("jazz.messagequeue.pulled", {
+          priority: CO_VALUE_PRIORITY.MEDIUM,
+        }),
+      ).toBe(1);
+    });
+
+    test("should corretly set custom attributes to the metrics", async () => {
+      const { queue, metricReader } = setup({ role: "server" });
+      const message: SyncMessage = {
+        action: "load",
+        id: "co_ztest-id",
+        header: false,
+        sessions: {},
+      };
+
+      expect(
+        await metricReader.getMetricValue("jazz.messagequeue.pushed", {
+          priority: CO_VALUE_PRIORITY.MEDIUM,
+          role: "server",
+        }),
+      ).toBe(0);
+      expect(
+        await metricReader.getMetricValue("jazz.messagequeue.pushed", {
+          priority: CO_VALUE_PRIORITY.MEDIUM,
+          role: "client",
+        }),
+      ).toBeUndefined();
+
+      void queue.push(message);
+      expect(
+        await metricReader.getMetricValue("jazz.messagequeue.pushed", {
+          priority: CO_VALUE_PRIORITY.MEDIUM,
+          role: "server",
+        }),
+      ).toBe(1);
+      expect(
+        await metricReader.getMetricValue("jazz.messagequeue.pulled", {
+          priority: CO_VALUE_PRIORITY.MEDIUM,
+          role: "server",
+        }),
+      ).toBe(0);
+
+      void queue.pull();
+
+      expect(
+        await metricReader.getMetricValue("jazz.messagequeue.pushed", {
+          priority: CO_VALUE_PRIORITY.MEDIUM,
+          role: "server",
+        }),
+      ).toBe(1);
+      expect(
+        await metricReader.getMetricValue("jazz.messagequeue.pulled", {
+          priority: CO_VALUE_PRIORITY.MEDIUM,
+          role: "server",
+        }),
+      ).toBe(1);
+    });
+  });
+
   test("should initialize with correct properties", () => {
     const { queue } = setup();
     expect(queue["defaultPriority"]).toBe(CO_VALUE_PRIORITY.MEDIUM);
-    expect(queue["queues"].length).toBe(8);
+    expect(queue["queues"].length).toBe(3);
     expect(queue["queues"].every((q) => !q.length)).toBe(true);
   });
 
@@ -52,7 +175,7 @@ describe("PriorityBasedMessageQueue", () => {
   });
 
   test("should pull messages in priority order", async () => {
-    const { queue, metricReader } = setup();
+    const { queue } = setup();
     const lowPriorityMsg: SyncMessage = {
       action: "content",
       id: "co_zlow",
@@ -73,42 +196,12 @@ describe("PriorityBasedMessageQueue", () => {
     };
 
     void queue.push(lowPriorityMsg);
-    expect(
-      await metricReader.getMetricValue("jazz.messagequeue.size", {
-        priority: lowPriorityMsg.priority,
-      }),
-    ).toBe(1);
     void queue.push(mediumPriorityMsg);
-    expect(
-      await metricReader.getMetricValue("jazz.messagequeue.size", {
-        priority: mediumPriorityMsg.priority,
-      }),
-    ).toBe(1);
     void queue.push(highPriorityMsg);
-    expect(
-      await metricReader.getMetricValue("jazz.messagequeue.size", {
-        priority: highPriorityMsg.priority,
-      }),
-    ).toBe(1);
 
     expect(queue.pull()?.msg).toEqual(highPriorityMsg);
-    expect(
-      await metricReader.getMetricValue("jazz.messagequeue.size", {
-        priority: highPriorityMsg.priority,
-      }),
-    ).toBe(0);
     expect(queue.pull()?.msg).toEqual(mediumPriorityMsg);
-    expect(
-      await metricReader.getMetricValue("jazz.messagequeue.size", {
-        priority: mediumPriorityMsg.priority,
-      }),
-    ).toBe(0);
     expect(queue.pull()?.msg).toEqual(lowPriorityMsg);
-    expect(
-      await metricReader.getMetricValue("jazz.messagequeue.size", {
-        priority: lowPriorityMsg.priority,
-      }),
-    ).toBe(0);
   });
 
   test("should return undefined when pulling from empty queue", () => {

package/src/tests/sync.test.ts

@@ -956,27 +956,6 @@ test.skip("When a peer's incoming/readable stream closes, we remove the peer", a
     */
 });
 
-test("If we start loading a coValue before connecting to a peer that has it, it will load it once we connect", async () => {
-  const { node: node1 } = await createConnectedTestNode();
-
-  const group = node1.createGroup();
-
-  const map = group.createMap();
-  map.set("hello", "world", "trusting");
-
-  const node2 = createTestNode();
-
-  const mapOnNode2Promise = loadCoValueOrFail(node2, map.id);
-
-  expect(node2.coValuesStore.get(map.core.id).state.type).toEqual("unknown");
-
-  connectNodeToSyncServer(node2);
-
-  const mapOnNode2 = await mapOnNode2Promise;
-
-  expect(mapOnNode2.get("hello")).toEqual("world");
-});
-
 test("should keep the peer state when the peer closes", async () => {
   const client = createTestNode();
 
@@ -1726,6 +1705,45 @@ describe("loadCoValueCore with retry", () => {
     await expect(promise1).resolves.not.toBe("unavailable");
     await expect(promise2).resolves.not.toBe("unavailable");
   });
+
+  test("should load unavailable coValues after they are synced", async () => {
+    const bob = createTestNode();
+    const alice = createTestNode();
+
+    // Create a group and map on anotherClient
+    const group = alice.createGroup();
+    const map = group.createMap();
+    map.set("key1", "value1", "trusting");
+
+    // Start loading before syncing
+    const result = await bob.loadCoValueCore(map.id);
+
+    expect(result).toBe("unavailable");
+
+    connectTwoPeers(alice, bob, "server", "server");
+
+    const result2 = await bob.loadCoValueCore(map.id);
+
+    expect(result2).not.toBe("unavailable");
+  });
+
+  test("should successfully mark a coValue as unavailable if the server does not have it", async () => {
+    const bob = createTestNode();
+    const alice = createTestNode();
+    const charlie = createTestNode();
+
+    connectTwoPeers(bob, charlie, "client", "server");
+
+    // Create a group and map on anotherClient
+    const group = alice.createGroup();
+    const map = group.createMap();
+    map.set("key1", "value1", "trusting");
+
+    // Start loading before syncing
+    const result = await bob.loadCoValueCore(map.id);
+
+    expect(result).toBe("unavailable");
+  });
 });
 
 describe("waitForSyncWithPeer", () => {
@@ -1894,6 +1912,8 @@ describe("sync protocol", () => {
     const map = group.createMap();
     map.set("hello", "world", "trusting");
 
+    await map.core.waitForSync();
+
     const mapOnJazzCloud = await loadCoValueOrFail(jazzCloud, map.id);
     expect(mapOnJazzCloud.get("hello")).toEqual("world");
 
@@ -2038,6 +2058,29 @@ describe("sync protocol", () => {
           },
         },
       },
+      {
+        from: "server",
+        msg: {
+          action: "known",
+          header: true,
+          id: map.id,
+          sessions: {
+            [client.currentSessionID]: 1,
+          },
+        },
+      },
+      {
+        from: "server",
+        msg: {
+          action: "known",
+          asDependencyOf: undefined,
+          header: true,
+          id: map.id,
+          sessions: {
+            [client.currentSessionID]: 1,
+          },
+        },
+      },
     ]);
   });
 });