@peerbit/shared-log 16.0.30 → 16.0.32

package/dist/src/sync/simple.js

@@ -39,7 +39,7 @@ import { Entry, Log } from "@peerbit/log";
 import { CONVERGENCE_MESSAGE_PRIORITY, SilentDelivery, } from "@peerbit/stream-interface";
 import { EntryWithRefs, createExchangeHeadsMessages, createRawExchangeHeadsMessages, } from "../exchange-heads.js";
 import { TransportMessage } from "../message.js";
-import { DispatchLifecycleRegistry } from "./dispatch-lifecycle.js";
+import { DispatchLifecycleRegistry, isSyncDispatchCancellation, } from "./dispatch-lifecycle.js";
 import { PendingSyncStore, QUEUED_SYNC_ALIAS_REFRESH_PENDING, } from "./pending-sync-store.js";
 import { emitSyncProfileDuration, syncProfileStart } from "./profile.js";
 import { SyncPeerSlotRegistry, } from "./sync-peer-state.js";
@@ -702,13 +702,14 @@ export class SimpleSyncronizer {
     filterRecentlySentExchangeHeads(hashes, peer) {
         const peerHash = peer.hashcode();
         const now = Date.now();
+        const stamp = { timestamp: now };
         let recentlySent = this.recentlySentExchangeHeads.get(peerHash);
         if (!recentlySent) {
             recentlySent = new Map();
             this.recentlySentExchangeHeads.set(peerHash, recentlySent);
         }
-        for (const [hash, timestamp] of recentlySent) {
-            if (now - timestamp > EXCHANGE_HEAD_RESPONSE_DEDUPE_TTL_MS) {
+        for (const [hash, previous] of recentlySent) {
+            if (now - previous.timestamp > EXCHANGE_HEAD_RESPONSE_DEDUPE_TTL_MS) {
                 recentlySent.delete(hash);
             }
         }
@@ -725,22 +726,25 @@ export class SimpleSyncronizer {
             if (this.isEntryRecentlyKnownByPeer?.(hash, peerHash, RECENT_KNOWN_EXCHANGE_HEAD_SUPPRESSION_MS)) {
                 continue;
             }
-            recentlySent.set(hash, now);
+            recentlySent.set(hash, stamp);
             out.push(hash);
         }
-        return out;
-    }
-    forgetRecentlySentExchangeHeads(hashes, peer) {
-        const recentlySent = this.recentlySentExchangeHeads.get(peer.hashcode());
-        if (!recentlySent) {
-            return;
-        }
-        for (const hash of hashes) {
-            recentlySent.delete(hash);
-        }
-        if (recentlySent.size === 0) {
-            this.recentlySentExchangeHeads.delete(peer.hashcode());
-        }
+        return {
+            hashes: out,
+            rollback: () => {
+                // A cancelled predecessor may settle after a fresh receive shipped
+                // the same hash. Only undo this exact attempt's dedupe ownership.
+                for (const hash of out) {
+                    if (recentlySent.get(hash) === stamp) {
+                        recentlySent.delete(hash);
+                    }
+                }
+                if (recentlySent.size === 0 &&
+                    this.recentlySentExchangeHeads.get(peerHash) === recentlySent) {
+                    this.recentlySentExchangeHeads.delete(peerHash);
+                }
+            },
+        };
     }
     getOrCreateSyncDispatchTargetEpoch(target) {
         let epoch = this.syncDispatchTargetEpochs.get(target);
@@ -774,7 +778,10 @@ export class SimpleSyncronizer {
             const currentEpoch = this.syncDispatchTargetEpochs.get(target);
             const epoch = expectedEpoch ??
                 currentEpoch ??
-                (options?.createTargetEpochs === false
+                (options?.createTargetEpochs === false ||
+                    this.closed === true ||
+                    callerSignal?.aborted === true ||
+                    ownershipLifecycleController.signal.aborted
                     ? undefined
                     : this.getOrCreateSyncDispatchTargetEpoch(target));
             if (!epoch) {
@@ -1916,7 +1923,11 @@ export class SimpleSyncronizer {
                 requestedCount: trackedHashes.length,
                 requestedTotalCount: allHashes.length,
                 attempts: 0,
-                targetEpoch: this.getOrCreateSyncDispatchTargetEpoch(target),
+                // Rejected late repairs only need result metadata. Do not create a
+                // retained dispatch epoch after the terminal admission fence.
+                targetEpoch: this.closed
+                    ? { id: 0 }
+                    : this.getOrCreateSyncDispatchTargetEpoch(target),
             });
         }
         const session = {
@@ -1930,6 +1941,10 @@ export class SimpleSyncronizer {
             deferred,
             cancelled: false,
         };
+        if (this.closed) {
+            deferred.resolve(this.buildRepairSessionResult(session, false));
+            return { id, done: deferred.promise, cancel: () => { } };
+        }
         if (allHashes.length === 0 || targets.length === 0) {
             deferred.resolve(this.buildRepairSessionResult(session, true));
             return {
@@ -2033,8 +2048,8 @@ export class SimpleSyncronizer {
                             }
                             catch (error) {
                                 reservation.release();
-                                if (!this.isSyncDispatchLifecycleActive(lifecycle) ||
-                                    !this.isSyncDispatchLifecycleActive(lifecycle, target)) {
+                                if (isSyncDispatchCancellation(error, this.getSyncDispatchSignal(lifecycle, target), !this.isSyncDispatchLifecycleActive(lifecycle) ||
+                                    !this.isSyncDispatchLifecycleActive(lifecycle, target))) {
                                     break;
                                 }
                                 throw error;
@@ -2083,7 +2098,7 @@ export class SimpleSyncronizer {
                 sentMessages = await this.sendRawExchangeHeads(hashes, [to.hashcode()], { signal });
             }
             catch (error) {
-                if (signal?.aborted) {
+                if (isSyncDispatchCancellation(error, signal)) {
                     return { messages: 0, fused: true };
                 }
                 throw error;
@@ -2108,7 +2123,7 @@ export class SimpleSyncronizer {
                 messages += 1;
             }
             catch (error) {
-                if (signal?.aborted) {
+                if (isSyncDispatchCancellation(error, signal)) {
                     break;
                 }
                 throw error;
@@ -2125,7 +2140,7 @@ export class SimpleSyncronizer {
      * exact advertised hash set.
      */
     async shipAuthorizedMaybeSyncResponse(properties) {
-        const hashes = this.filterRecentlySentExchangeHeads(properties.hashes, properties.from);
+        const { hashes, rollback } = this.filterRecentlySentExchangeHeads(properties.hashes, properties.from);
         try {
             const shipped = await this.shipExchangeHeads(hashes, properties.from, canReceiveRawExchangeHeads(properties.response), properties.signal);
             return {
@@ -2134,12 +2149,12 @@ export class SimpleSyncronizer {
             };
         }
         catch (error) {
-            this.forgetRecentlySentExchangeHeads(hashes, properties.from);
+            rollback();
             throw error;
         }
         finally {
             if (properties.signal.aborted) {
-                this.forgetRecentlySentExchangeHeads(hashes, properties.from);
+                rollback();
             }
         }
     }
@@ -2154,18 +2169,21 @@ export class SimpleSyncronizer {
         let entries = 0;
         let firstError;
         for (const lease of properties.leases) {
+            const signal = properties.signal
+                ? AbortSignal.any([lease.signal, properties.signal])
+                : lease.signal;
             let fulfilled = false;
             try {
                 const shipped = await this.shipAuthorizedMaybeSyncResponse({
                     hashes: lease.hashes,
                     from: properties.from,
                     response: properties.response,
-                    signal: lease.signal,
+                    signal,
                 });
                 messages += shipped.messages;
                 fused ||= shipped.fused;
                 entries += shipped.entries;
-                fulfilled = !lease.signal.aborted;
+                fulfilled = !signal.aborted;
             }
             catch (error) {
                 firstError ??= error;
@@ -2191,10 +2209,17 @@ export class SimpleSyncronizer {
         }
         return { messages, fused, entries };
     }
-    async onMessage(msg, context) {
+    async onMessage(msg, context, options) {
+        if (options?.signal?.aborted) {
+            return (msg instanceof RequestMaybeSync ||
+                msg instanceof ResponseMaybeSync ||
+                msg instanceof ResponseMaybeSyncCapabilities ||
+                msg instanceof RequestMaybeSyncCoordinate ||
+                msg instanceof RequestMaybeSyncCoordinateCapabilities);
+        }
         const from = context.from;
         if (msg instanceof RequestMaybeSync) {
-            await this.queueSync(msg.hashes, from);
+            await this.queueSync(msg.hashes, from, options);
             return true;
         }
         else if (msg instanceof ResponseMaybeSync ||
@@ -2209,6 +2234,7 @@ export class SimpleSyncronizer {
                 leases: pending,
                 from,
                 response: msg,
+                signal: options?.signal,
             });
             return true;
         }
@@ -2224,7 +2250,7 @@ export class SimpleSyncronizer {
                 return true;
             }
             const { release: releaseLookup, row: slotRow } = lookupPermit;
-            const lifecycle = this.captureSyncDispatchLifecycle([target]);
+            const lifecycle = this.captureSyncDispatchLifecycle([target], options?.signal);
             let lifecycleFinished = false;
             const finishLifecycle = () => {
                 if (lifecycleFinished) {
@@ -2274,12 +2300,22 @@ export class SimpleSyncronizer {
                 let hashesToSend = [];
                 let messages = 0;
                 let fused = false;
+                let rollback;
+                const signal = this.getSyncDispatchSignal(lifecycle, target);
                 try {
-                    hashesToSend = this.filterRecentlySentExchangeHeads(hashes, from);
+                    ({ hashes: hashesToSend, rollback } =
+                        this.filterRecentlySentExchangeHeads(hashes, from));
                     // dont set priority 1 here because this will block other messages that should higher priority
-                    ({ messages, fused } = await this.shipExchangeHeads(hashesToSend, context.from, canReceiveRawExchangeHeads(msg), this.getSyncDispatchSignal(lifecycle, target)));
+                    ({ messages, fused } = await this.shipExchangeHeads(hashesToSend, context.from, canReceiveRawExchangeHeads(msg), signal));
+                }
+                catch (error) {
+                    rollback?.();
+                    throw error;
                 }
                 finally {
+                    if (signal.aborted) {
+                        rollback?.();
+                    }
                     releaseResponse();
                     if (profile) {
                         emitSyncProfileDuration(profile, exchangeStartedAt, {
@@ -2468,7 +2504,7 @@ export class SimpleSyncronizer {
         this.pendingSync.clearPendingSyncExpiryTimerIfIdle();
     }
     async queueSync(keys, from, options) {
-        if (this.closed === true || keys.length === 0) {
+        if (this.closed === true || options?.signal?.aborted || keys.length === 0) {
             return;
         }
         // A delayed timer must not let expired claims or admission reservations
@@ -2486,6 +2522,7 @@ export class SimpleSyncronizer {
         const targetEpoch = this.getOrCreateSyncDispatchTargetEpoch(fromHash);
         const ownershipLifecycleController = this.syncDispatchLifecycleController;
         const isCapturedLifecycleActive = () => this.closed !== true &&
+            options?.signal?.aborted !== true &&
             this.syncDispatchLifecycleController === ownershipLifecycleController &&
             !ownershipLifecycleController.signal.aborted &&
             this.syncDispatchTargetEpochs.get(fromHash) === targetEpoch;
@@ -2555,6 +2592,7 @@ export class SimpleSyncronizer {
         const dispatchableExistingRequestHashes = this.filterDispatchablePendingSyncClaims(existingRequestHashes, fromHash, targetEpoch);
         const existingRequest = dispatchableExistingRequestHashes.length > 0
             ? this.requestSync(dispatchableExistingRequestHashes, [fromHash], {
+                signal: options?.signal,
                 ownershipLifecycleController,
                 targetEpochs: new Map([[fromHash, targetEpoch]]),
                 createTargetEpochs: false,
@@ -2565,107 +2603,115 @@ export class SimpleSyncronizer {
         // when a later lifecycle check returns before joining it.
         void existingRequest?.catch(() => { });
         const resolveKnownStartedAt = syncProfileStart(profile);
-        try {
-            const knownKeys = options?.skipCheck === true || keysToCheck.length === 0
-                ? undefined
-                : await this.resolveKnownSyncKeys(keysToCheck);
-            if (!isCapturedLifecycleActive()) {
-                return;
-            }
-            if (profile) {
-                emitSyncProfileDuration(profile, resolveKnownStartedAt, {
-                    name: "simple.queueSync.resolveKnown",
-                    entries: keysToCheck.length,
-                    count: knownKeys?.keys.size ?? 0,
-                    details: {
-                        checkedCoordinates: knownKeys?.checkedCoordinates === true,
-                        checkedHashes: knownKeys?.checkedHashes === true,
-                        skipCheck: options?.skipCheck === true,
-                    },
-                });
-            }
-            if (keysToCheck.length > 0) {
-                // A resolver/index lookup may have populated coordinateToHash while
-                // it yielded. Refresh another fixed-size slice, never the full queue.
-                this.refreshQueuedSyncCoordinateAliases();
-            }
-            const loopStartedAt = syncProfileStart(profile);
-            for (let index = 0; index < keysToCheck.length; index += 1) {
-                const key = keysToCheck[index];
-                const identity = identitiesToCheck[index];
+        const planning = (async () => {
+            try {
+                const knownKeys = options?.skipCheck === true || keysToCheck.length === 0
+                    ? undefined
+                    : await this.resolveKnownSyncKeys(keysToCheck);
                 if (!isCapturedLifecycleActive()) {
                     return;
                 }
-                const queuedKeyResult = this.getQueuedSyncKeyForAdmission(key);
-                if (queuedKeyResult === QUEUED_SYNC_ALIAS_REFRESH_PENDING) {
-                    const consumption = this.consumePendingSyncAdmission(admission, identity);
-                    if (consumption === "invalid") {
+                if (profile) {
+                    emitSyncProfileDuration(profile, resolveKnownStartedAt, {
+                        name: "simple.queueSync.resolveKnown",
+                        entries: keysToCheck.length,
+                        count: knownKeys?.keys.size ?? 0,
+                        details: {
+                            checkedCoordinates: knownKeys?.checkedCoordinates === true,
+                            checkedHashes: knownKeys?.checkedHashes === true,
+                            skipCheck: options?.skipCheck === true,
+                        },
+                    });
+                }
+                if (keysToCheck.length > 0) {
+                    // A resolver/index lookup may have populated coordinateToHash while
+                    // it yielded. Refresh another fixed-size slice, never the full queue.
+                    this.refreshQueuedSyncCoordinateAliases();
+                }
+                const loopStartedAt = syncProfileStart(profile);
+                for (let index = 0; index < keysToCheck.length; index += 1) {
+                    const key = keysToCheck[index];
+                    const identity = identitiesToCheck[index];
+                    if (!isCapturedLifecycleActive()) {
                         return;
                     }
-                    continue;
-                }
-                const coordinateOrHash = queuedKeyResult ?? key;
-                const inFlight = this.syncInFlightQueue.get(coordinateOrHash);
-                if (inFlight) {
-                    if (!this.hasPendingSyncClaim(coordinateOrHash, fromHash)) {
+                    const queuedKeyResult = this.getQueuedSyncKeyForAdmission(key);
+                    if (queuedKeyResult === QUEUED_SYNC_ALIAS_REFRESH_PENDING) {
                         const consumption = this.consumePendingSyncAdmission(admission, identity);
                         if (consumption === "invalid") {
                             return;
                         }
-                        if (consumption === "settled") {
+                        continue;
+                    }
+                    const coordinateOrHash = queuedKeyResult ?? key;
+                    const inFlight = this.syncInFlightQueue.get(coordinateOrHash);
+                    if (inFlight) {
+                        if (!this.hasPendingSyncClaim(coordinateOrHash, fromHash)) {
+                            const consumption = this.consumePendingSyncAdmission(admission, identity);
+                            if (consumption === "invalid") {
+                                return;
+                            }
+                            if (consumption === "settled") {
+                                continue;
+                            }
+                            this.movePendingSyncKeyExpiryEarlier(coordinateOrHash, admission.expiresAt);
+                            const added = this.addPendingSyncClaim(coordinateOrHash, from, admission.expiresAt);
+                            if (added) {
+                                requestHashes.push(coordinateOrHash);
+                            }
+                        }
+                    }
+                    else {
+                        const has = options?.skipCheck !== true &&
+                            (await this.checkHasCoordinateOrHash(coordinateOrHash, knownKeys));
+                        if (!isCapturedLifecycleActive()) {
+                            return;
+                        }
+                        if (has) {
+                            this.clearPendingSyncAdmissionIdentity(identity);
                             continue;
                         }
-                        this.movePendingSyncKeyExpiryEarlier(coordinateOrHash, admission.expiresAt);
-                        const added = this.addPendingSyncClaim(coordinateOrHash, from, admission.expiresAt);
-                        if (added) {
-                            requestHashes.push(coordinateOrHash);
+                        const consumption = this.consumePendingSyncAdmission(admission, identity);
+                        if (consumption === "invalid") {
+                            return;
                         }
+                        if (consumption === "settled") {
+                            continue;
+                        }
+                        // Track the initial sender so we can retry if the first request is lost.
+                        this.addPendingSyncClaim(coordinateOrHash, from, admission.expiresAt);
+                        requestHashes.push(coordinateOrHash); // request immediately (first time we have seen this hash)
                     }
                 }
-                else {
-                    const has = options?.skipCheck !== true &&
-                        (await this.checkHasCoordinateOrHash(coordinateOrHash, knownKeys));
-                    if (!isCapturedLifecycleActive()) {
-                        return;
-                    }
-                    if (has) {
-                        this.clearPendingSyncAdmissionIdentity(identity);
-                        continue;
-                    }
-                    const consumption = this.consumePendingSyncAdmission(admission, identity);
-                    if (consumption === "invalid") {
-                        return;
-                    }
-                    if (consumption === "settled") {
-                        continue;
-                    }
-                    // Track the initial sender so we can retry if the first request is lost.
-                    this.addPendingSyncClaim(coordinateOrHash, from, admission.expiresAt);
-                    requestHashes.push(coordinateOrHash); // request immediately (first time we have seen this hash)
+                if (profile) {
+                    emitSyncProfileDuration(profile, loopStartedAt, {
+                        name: "simple.queueSync.plan",
+                        entries: keysToCheck.length,
+                        count: requestHashes.length,
+                        targets: 1,
+                    });
                 }
+                // Persistent admission work is complete. Do not let an unrelated
+                // blocked transport send retain unused quota.
+                this.releasePendingSyncAdmission(admission);
+                const dispatchableRequestHashes = this.filterDispatchablePendingSyncClaims(requestHashes, fromHash, targetEpoch);
+                dispatchableRequestHashes.length > 0 &&
+                    (await this.requestSync(dispatchableRequestHashes, [fromHash], {
+                        signal: options?.signal,
+                        ownershipLifecycleController,
+                        targetEpochs: new Map([[fromHash, targetEpoch]]),
+                        createTargetEpochs: false,
+                    }));
             }
-            if (profile) {
-                emitSyncProfileDuration(profile, loopStartedAt, {
-                    name: "simple.queueSync.plan",
-                    entries: keysToCheck.length,
-                    count: requestHashes.length,
-                    targets: 1,
-                });
+            finally {
+                this.releasePendingSyncAdmission(admission);
             }
-            // Persistent admission work is complete. Do not let an unrelated
-            // blocked transport send retain unused quota.
-            this.releasePendingSyncAdmission(admission);
-            const dispatchableRequestHashes = this.filterDispatchablePendingSyncClaims(requestHashes, fromHash, targetEpoch);
-            dispatchableRequestHashes.length > 0 &&
-                (await this.requestSync(dispatchableRequestHashes, [fromHash], {
-                    ownershipLifecycleController,
-                    targetEpochs: new Map([[fromHash, targetEpoch]]),
-                    createTargetEpochs: false,
-                }));
-            await existingRequest;
-        }
-        finally {
-            this.releasePendingSyncAdmission(admission);
+        })();
+        // Admission quota covers the finished lookup only. The eager dispatch
+        // retains its own physical lifecycle, and every receive exit joins it.
+        const results = await Promise.allSettled([planning, existingRequest]);
+        const errors = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+        try {
             if (profile) {
                 emitSyncProfileDuration(profile, startedAt, {
                     name: "simple.queueSync",
@@ -2679,13 +2725,23 @@ export class SimpleSyncronizer {
                 });
             }
         }
+        catch (error) {
+            errors.push(error);
+        }
+        if (errors.length === 1)
+            throw errors[0];
+        if (errors.length > 1) {
+            throw new AggregateError(errors, "sync lookup and eager response failed", {
+                cause: errors[0],
+            });
+        }
     }
     async requestSync(hashes, to, options) {
         const targets = [...new Set(to)];
         if (hashes.length === 0 || targets.length === 0) {
             return;
         }
-        const lifecycle = this.captureSyncDispatchLifecycle(targets, undefined, {
+        const lifecycle = this.captureSyncDispatchLifecycle(targets, options?.signal, {
             ownershipLifecycleController: options?.ownershipLifecycleController,
             targetEpochs: options?.targetEpochs,
             createTargetEpochs: options?.createTargetEpochs,
@@ -2745,7 +2801,7 @@ export class SimpleSyncronizer {
                             coordinateMessages += 1;
                         }
                         catch (error) {
-                            if (!this.isSyncDispatchLifecycleActive(lifecycle, target)) {
+                            if (isSyncDispatchCancellation(error, this.getSyncDispatchSignal(lifecycle, target), !this.isSyncDispatchLifecycleActive(lifecycle, target))) {
                                 break;
                             }
                             throw error;
@@ -2778,7 +2834,7 @@ export class SimpleSyncronizer {
                             stringMessages += 1;
                         }
                         catch (error) {
-                            if (!this.isSyncDispatchLifecycleActive(lifecycle, target)) {
+                            if (isSyncDispatchCancellation(error, this.getSyncDispatchSignal(lifecycle, target), !this.isSyncDispatchLifecycleActive(lifecycle, target))) {
                                 break;
                             }
                             throw error;
@@ -3026,9 +3082,12 @@ export class SimpleSyncronizer {
             // Defensive observation for failures outside the loop's best-effort body.
         });
     }
-    async close() {
+    beginClose() {
         this.closed = true;
         this.syncDispatchLifecycleController.abort();
+    }
+    async close() {
+        this.beginClose();
         this.syncDispatchTargetEpochs.clear();
         this.clearPendingSyncAdmissions();
         this.syncInFlightRetryIterator = undefined;