@matter/node 0.17.7 → 0.17.8-alpha.0-20260801-92169d0aa

package/src/behavior/system/subscriptions/SubscriptionsServer.ts

@@ -7,16 +7,27 @@
 import { InteractionServer, PeerSubscription } from "#node/server/InteractionServer.js";
 import { ServerSubscription } from "#node/server/ServerSubscription.js";
 import {
+    causedBy,
     ChannelType,
     deepCopy,
     Logger,
     MatterAggregateError,
     MatterError,
     MaybePromise,
+    NetworkError,
+    NoResponseTimeoutError,
     Seconds,
 } from "@matter/general";
 import { DatatypeModel, FieldElement } from "@matter/model";
-import { GroupSession, PeerAddress, PeerAddressMap, PeerAddressSet, PeerSet, Subscription } from "@matter/protocol";
+import {
+    GroupSession,
+    PeerAddress,
+    PeerAddressMap,
+    PeerAddressSet,
+    PeerSet,
+    Subscription,
+    TransientPeerCommunicationError,
+} from "@matter/protocol";
 import { Status, StatusResponseError } from "@matter/types";
 import { Behavior } from "../../Behavior.js";
 import { SessionsBehavior } from "../sessions/SessionsBehavior.js";
@@ -162,7 +173,7 @@ export class SubscriptionsServer extends Behavior {
     }
 
     #subscriptionCancelled(subscription: Subscription): MaybePromise {
-        if (subscription.isCanceledByPeer && this.state.persistenceEnabled !== false) {
+        if (subscription.isTerminated && this.state.persistenceEnabled !== false) {
             const { subscriptionId: id } = subscription;
             const subscriptionIndex = this.state.subscriptions.findIndex(({ subscriptionId }) => id === subscriptionId);
             if (subscriptionIndex !== -1) {
@@ -273,7 +284,16 @@ export class SubscriptionsServer extends Behavior {
                                         : sre.message
                                     : error,
                             );
+                            if (
+                                causedBy(error, TransientPeerCommunicationError, NoResponseTimeoutError, NetworkError)
+                            ) {
+                                // Report sends do not declare peer loss, so nothing else stops this loop from
+                                // spending a full MRP window on each of the peer's remaining subscriptions
+                                break;
+                            }
                             if (isInvalidSubscription) {
+                                // The peer dropped its state for us; too unlikely another of its subscriptions
+                                // survived to spend an initial report finding out
                                 break;
                             }
                             continue;

package/src/node/server/InteractionServer.ts

@@ -79,6 +79,9 @@ const logger = Logger.get("InteractionServer");
 const MAX_READ_PATHS = 10_000;
 const MAX_SUBSCRIBE_PATHS = 10_000;
 
+// A controller decides for itself when its sessions are gone; a report we cannot push does not prove they are
+const SUBSCRIPTION_EXCHANGE_OPTIONS: MessageExchange.Options = { suppressPeerLoss: true };
+
 export interface PeerSubscription {
     subscriptionId: number;
     peerAddress: PeerAddress;
@@ -745,8 +748,16 @@ export class InteractionServer implements ProtocolHandler, InteractionRecipient
     #initiateSubscriptionExchange(addressOrSession: PeerAddress | Session, protocolId: number) {
         const exchange =
             addressOrSession instanceof Session
-                ? this.#context.exchangeManager.initiateExchangeForSession(addressOrSession, protocolId)
-                : this.#context.exchangeManager.initiateExchange(addressOrSession, protocolId);
+                ? this.#context.exchangeManager.initiateExchangeForSession(
+                      addressOrSession,
+                      protocolId,
+                      SUBSCRIPTION_EXCHANGE_OPTIONS,
+                  )
+                : this.#context.exchangeManager.initiateExchange(
+                      addressOrSession,
+                      protocolId,
+                      SUBSCRIPTION_EXCHANGE_OPTIONS,
+                  );
 
         // Count subscription report messages we push and the acks we receive in response
         this.#countExchangeMessages(exchange);
@@ -813,47 +824,50 @@ export class InteractionServer implements ProtocolHandler, InteractionRecipient
         }: PeerSubscription,
         session: NodeSession,
     ) {
-        const exchange = this.#context.exchangeManager.initiateExchange(session.peerAddress, INTERACTION_PROTOCOL_ID);
+        const exchange = this.#initiateSubscriptionExchange(session, INTERACTION_PROTOCOL_ID);
+        const messenger = new InteractionServerMessenger(exchange);
 
-        logger.info(
-            `Reestablish subscription`,
-            Mark.OUTBOUND,
-            exchange.via,
-            Diagnostic.dict({
-                ...Subscription.diagnosticOf(subscriptionId),
-                isFabricFiltered,
-                maxInterval: Duration.format(maxInterval),
-                sendInterval: Duration.format(sendInterval),
-            }),
-        );
+        let subscription: ServerSubscription | undefined;
+        try {
+            logger.info(
+                `Reestablish subscription`,
+                Mark.OUTBOUND,
+                exchange.via,
+                Diagnostic.dict({
+                    ...Subscription.diagnosticOf(subscriptionId),
+                    isFabricFiltered,
+                    maxInterval: Duration.format(maxInterval),
+                    sendInterval: Duration.format(sendInterval),
+                }),
+            );
 
-        const context: ServerSubscriptionContext = {
-            session,
-            node: this.#node,
-            initiateExchange: (addressOrSession, protocolId) =>
-                this.#initiateSubscriptionExchange(addressOrSession, protocolId),
-        };
+            const context: ServerSubscriptionContext = {
+                session,
+                node: this.#node,
+                initiateExchange: (addressOrSession, protocolId) =>
+                    this.#initiateSubscriptionExchange(addressOrSession, protocolId),
+            };
 
-        const subscription = new ServerSubscription({
-            id: subscriptionId,
-            context,
-            request: {
-                attributeRequests,
-                eventRequests,
-                isFabricFiltered,
-                minIntervalFloorSeconds: Seconds.of(minIntervalFloor),
-                maxIntervalCeilingSeconds: Seconds.of(maxIntervalCeiling),
-            },
-            subscriptionOptions: this.#subscriptionConfig,
-            useAsMaxInterval: maxInterval,
-            useAsSendInterval: sendInterval,
-        });
+            subscription = new ServerSubscription({
+                id: subscriptionId,
+                context,
+                request: {
+                    attributeRequests,
+                    eventRequests,
+                    isFabricFiltered,
+                    minIntervalFloorSeconds: Seconds.of(minIntervalFloor),
+                    maxIntervalCeilingSeconds: Seconds.of(maxIntervalCeiling),
+                },
+                subscriptionOptions: this.#subscriptionConfig,
+                useAsMaxInterval: maxInterval,
+                useAsSendInterval: sendInterval,
+            });
+
+            const readContext = this.#prepareOnlineContext(exchange, undefined, isFabricFiltered);
 
-        const readContext = this.#prepareOnlineContext(exchange, undefined, isFabricFiltered);
-        try {
             // Send initial data report to prime the subscription with initial data
             await subscription.sendInitialReport(
-                new InteractionServerMessenger(exchange),
+                messenger,
                 readContext,
                 true, // Do not send status responses because we simulate that the subscription is still established
             );
@@ -873,8 +887,15 @@ export class InteractionServer implements ProtocolHandler, InteractionRecipient
                 );
             }
         } catch (error) {
-            await subscription.close(); // Cleanup
+            await subscription?.close(); // Cleanup
             throw error;
+        } finally {
+            // Reports use their own exchanges; leaving this one open blocks the session from ever closing gracefully
+            try {
+                await messenger.close();
+            } catch (error) {
+                logger.warn("Error closing subscription re-establishment exchange", error);
+            }
         }
         return subscription;
     }

package/src/node/server/ServerSubscription.ts

@@ -10,6 +10,7 @@ import { IcdManagementServer } from "#behaviors/icd-management";
 import type { ServerNode } from "#node/ServerNode.js";
 import {
     AsyncObservable,
+    causedBy,
     ClosedError,
     Diagnostic,
     Duration,
@@ -42,6 +43,7 @@ import {
     ReadResult,
     SessionClosedError,
     Subscription,
+    TransientPeerCommunicationError,
 } from "@matter/protocol";
 import {
     AttributeId,
@@ -130,7 +132,7 @@ export class ServerSubscription implements Subscription {
 
     #id: SubscriptionId;
     #isClosed = false;
-    #isCanceledByPeer = false;
+    #isTerminated = false;
     #request: Omit<SubscribeRequest, "interactionModelRevision" | "keepSubscriptions">;
     #cancelled = AsyncObservable<[subscription: Subscription]>();
     #maxInterval?: Duration;
@@ -206,8 +208,8 @@ export class ServerSubscription implements Subscription {
         return this.#context.session;
     }
 
-    get isCanceledByPeer() {
-        return this.#isCanceledByPeer;
+    get isTerminated() {
+        return this.#isTerminated;
     }
 
     get request() {
@@ -245,7 +247,8 @@ export class ServerSubscription implements Subscription {
     }
 
     async handlePeerCancel() {
-        this.#isCanceledByPeer = true;
+        logger.notice(`Subscription ${this.idStr} cancelled by peer`);
+        this.#isTerminated = true;
         // Force-close any in-flight send exchange so MRP retransmissions stop immediately.
         // Use try/finally so this.close() always runs even if the exchange close throws.
         try {
@@ -508,7 +511,7 @@ export class ServerSubscription implements Subscription {
                     this.#sendUpdateErrorCounter = 0;
                 }
             } catch (error) {
-                if (this.#isClosed || this.#isCanceledByPeer) {
+                if (this.#isClosed || this.#isTerminated) {
                     // No need to care about resubmissions when the server is closing or peer cancelled us
                     return;
                 }
@@ -535,20 +538,24 @@ export class ServerSubscription implements Subscription {
                         this.#outstandingEventsMinNumber = eventsMinNumber; // newer number are always higher, so we can just set it
                     }
                 } else {
-                    logger.info(
-                        `Sending update failed 3 times in a row, canceling subscription ${this.idStr} and let controller subscribe again.`,
+                    logger.notice(
+                        `Giving up on subscription ${this.idStr} after 3 failed updates; the controller must subscribe again`,
                     );
                     this.#sendNextUpdateImmediately = false;
                     if (
-                        error instanceof NoResponseTimeoutError ||
-                        error instanceof NetworkError ||
-                        error instanceof SessionClosedError
+                        causedBy(
+                            error,
+                            TransientPeerCommunicationError,
+                            NoResponseTimeoutError,
+                            NetworkError,
+                            SessionClosedError,
+                        )
                     ) {
-                        // Let's consider this subscription as dead and wait for a reconnect.  We handle as if the
-                        // controller cancelled
-                        using _messaging = updating?.join("canceling");
-                        this.#isCanceledByPeer = true;
-                        await this.#cancel();
+                        // The session is left alone: failing to push reports says nothing about whether the
+                        // controller can still reach us, and recovery is its call regardless
+                        using _messaging = updating?.join("abandoning");
+                        this.#isTerminated = true;
+                        await this.#closeFromUpdate();
                         break;
                     } else {
                         throw error;
@@ -693,12 +700,12 @@ export class ServerSubscription implements Subscription {
         });
     }
 
-    async #flush(flushViaSession?: Session) {
+    async #flush(flushViaSession?: Session, currentExchange?: MessageExchange) {
         this.#sendDelayTimer.stop();
         if (this.#outstandingAttributeUpdates !== undefined || this.#outstandingEventsMinNumber !== undefined) {
             logger.debug(`Flushing subscription ${this.idStr}${this.#isClosed ? " (for closing)" : ""}`);
             this.#triggerSendUpdate(true, flushViaSession);
-            if (this.#currentUpdatePromise) {
+            if (this.#currentUpdatePromise && !this.#isSendingOn(currentExchange)) {
                 using _waiting = this.#lifetime?.join("waiting on flush");
                 await this.#currentUpdatePromise;
             }
@@ -708,21 +715,35 @@ export class ServerSubscription implements Subscription {
     /**
      * Closes the subscription and flushes all outstanding data updates if requested.
      */
-    async close(flushViaSession?: Session) {
+    async close(flushViaSession?: Session, currentExchange?: MessageExchange) {
         if (this.#isClosed) {
             return;
         }
         this.#isClosed = true;
 
-        await this.#cancel(flushViaSession);
+        await this.#cancel(flushViaSession, currentExchange);
 
-        if (this.#currentUpdatePromise) {
+        if (this.#currentUpdatePromise && !this.#isSendingOn(currentExchange)) {
             using _waiting = this.#lifetime?.closing()?.join("waiting on update");
             await this.#currentUpdatePromise;
         }
     }
 
-    async #cancel(flushViaSession?: Session) {
+    /** Close from within the update loop, which {@link close} would wait on -- it is our own caller. */
+    async #closeFromUpdate() {
+        if (this.#isClosed) {
+            return;
+        }
+        this.#isClosed = true;
+        await this.#cancel();
+    }
+
+    /** Whether our in-flight update is sending on this exchange, making it this close's own caller. */
+    #isSendingOn(currentExchange?: MessageExchange) {
+        return currentExchange !== undefined && currentExchange === this.#currentSendExchange;
+    }
+
+    async #cancel(flushViaSession?: Session, currentExchange?: MessageExchange) {
         const closing = this.#lifetime?.closing();
 
         this.#sendUpdatesActivated = false;
@@ -731,7 +752,7 @@ export class ServerSubscription implements Subscription {
 
         if (flushViaSession !== undefined) {
             using _flushing = closing?.join("flushing");
-            await this.#flush(flushViaSession);
+            await this.#flush(flushViaSession, currentExchange);
         }
 
         this.#updateTimer.stop();
@@ -845,19 +866,20 @@ export class ServerSubscription implements Subscription {
             }
         } catch (error) {
             if (StatusResponseError.is(error, Status.InvalidSubscription, Status.Failure)) {
-                logger.notice(`Subscription ${this.idStr} cancelled by peer`);
-                this.#isCanceledByPeer = true;
+                logger.notice(`Subscription ${this.idStr} reported invalid by peer`);
+                this.#isTerminated = true;
             } else {
                 StatusResponseError.accept(error);
                 logger.info(`Subscription ${this.idStr} update failed:`, error);
             }
 
             using _canceling = lifetime?.join("canceling");
-            await this.#cancel();
+            await this.#closeFromUpdate();
         } finally {
-            this.#currentSendExchange = undefined;
             using _closing = lifetime?.join("closing messenger");
+            // Reset only after the close: it can still send, and #isSendingOn must recognise this exchange until then
             await messenger.close();
+            this.#currentSendExchange = undefined;
         }
         return true;
     }