@matter/protocol 0.12.4-alpha.0-20250224-e0964a795 → 0.12.4-alpha.0-20250224-46934b522

package/src/interaction/Subscription.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { Logger } from "#general";
+import { InternalError, Logger, Observable } from "#general";
 import { type SecureSession } from "#session/SecureSession.js";
 import { TlvAttributePath, TlvDataVersionFilter, TlvEventFilter, TlvEventPath, TypeFromSchema } from "#types";
 
@@ -29,15 +29,13 @@ export abstract class Subscription {
     #isClosed?: boolean;
     #isCanceledByPeer?: boolean;
     #criteria: SubscriptionCriteria;
+    #cancelled = Observable<[subscription: Subscription]>();
+    #maxIntervalMs?: number;
 
     constructor(session: SecureSession, id: SubscriptionId, criteria: SubscriptionCriteria) {
         this.#session = session;
         this.#id = id;
         this.#criteria = criteria;
-
-        // TODO Do not add to session but to node/peer
-        this.#session.subscriptions.add(this);
-        logger.debug(`Added subscription ${this.#id} to ${this.#session.name}`);
     }
 
     get id() {
@@ -60,6 +58,28 @@ export abstract class Subscription {
         return this.#session;
     }
 
+    get cancelled() {
+        return this.#cancelled;
+    }
+
+    get maxIntervalMs(): number {
+        if (this.#maxIntervalMs === undefined) {
+            throw new InternalError("Subscription MaxIntervalMs accessed before it was set");
+        }
+        return this.#maxIntervalMs;
+    }
+
+    set maxIntervalMs(value: number) {
+        if (this.#maxIntervalMs !== undefined) {
+            throw new InternalError("Subscription MaxIntervalMs set twice. This should never happen.");
+        }
+        this.#maxIntervalMs = value;
+    }
+
+    get maxInterval(): number {
+        return Math.ceil(this.maxIntervalMs / 1000);
+    }
+
     /**
      * Update session state.  This probably is meaningless except in a server context.
      */
@@ -77,7 +97,7 @@ export abstract class Subscription {
     }
 
     /** Close the subscription with the option to gracefully flush outstanding data. */
-    abstract close(graceful: boolean): Promise<void>;
+    abstract close(graceful: boolean, cancelledByPeer?: boolean): Promise<void>;
 
     /**
      * Destroy the subscription. Unsubscribe from all attributes and events and stop all timers.
@@ -86,5 +106,13 @@ export abstract class Subscription {
         this.#isClosed = true;
         this.#session.subscriptions.delete(this);
         logger.debug(`Removed subscription ${this.id} from ${this.#session.name}`);
+
+        this.#cancelled.emit(this);
+    }
+
+    protected activate() {
+        // TODO Do not add to session but to node/peer
+        this.#session.subscriptions.add(this);
+        logger.debug(`Added subscription ${this.#id} to ${this.#session.name}`);
     }
 }

package/src/peer/ControllerCommissioner.ts

@@ -407,15 +407,14 @@ export class ControllerCommissioner {
                 }
 
                 // Look for the device broadcast over MDNS and do CASE pairing
-                return await this.#context.clients.connect(
-                    address,
-                    {
+                return await this.#context.clients.connect(address, {
+                    discoveryOptions: {
                         discoveryType: NodeDiscoveryType.TimedDiscovery,
                         timeoutSeconds: 120,
                         discoveryData,
                     },
-                    true,
-                ); // Wait maximum 120s to find the operational device for commissioning process
+                    allowUnknownPeer: true,
+                }); // Wait maximum 120s to find the operational device for commissioning process
             },
         );
 

package/src/peer/PeerAddress.ts

@@ -86,3 +86,17 @@ export class PeerAddressMap<T> extends Map<PeerAddress, T> {
         return super.get(PeerAddress(key));
     }
 }
+
+export class PeerAddressSet extends Set<PeerAddress> {
+    override add(value: PeerAddress) {
+        return super.add(PeerAddress(value));
+    }
+
+    override has(value: PeerAddress) {
+        return super.has(PeerAddress(value));
+    }
+
+    override delete(value: PeerAddress) {
+        return super.delete(PeerAddress(value));
+    }
+}

package/src/peer/PeerSet.ts

@@ -144,6 +144,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
 
         this.#sessions.resubmissionStarted.on(this.#handleResubmissionStarted.bind(this));
 
+        /** A channel was added by ourselves */
         this.#channels.added.on((address, msgChannel) => {
             if (isIpNetworkChannel(msgChannel.channel)) {
                 // Update the channel address if it has one
@@ -230,7 +231,15 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
     /**
      * Ensure there is a channel to the designated peer.
      */
-    async ensureConnection(address: PeerAddress, discoveryOptions: DiscoveryOptions, allowUnknownPeer = false) {
+    async ensureConnection(
+        address: PeerAddress,
+        options: {
+            discoveryOptions: DiscoveryOptions;
+            allowUnknownPeer?: boolean;
+            operationalAddress?: ServerAddressIp;
+        },
+    ) {
+        const { discoveryOptions, allowUnknownPeer, operationalAddress } = options;
         if (!this.#peersByAddress.has(address) && !allowUnknownPeer) {
             throw new UnknownNodeError(`Cannot connect to unknown device ${PeerAddress(address)}`);
         }
@@ -246,7 +255,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
             const { promise, resolver, rejecter } = createPromise<MessageChannel>();
             this.#runningPeerReconnections.set(address, { promise, rejecter });
 
-            this.#resume(address, discoveryOptions)
+            this.#resume(address, discoveryOptions, operationalAddress)
                 .then(channel => {
                     this.#runningPeerReconnections.delete(address);
                     resolver(channel);
@@ -268,7 +277,9 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
         return new ReconnectableExchangeProvider(this.#exchanges, this.#channels, address, async () => {
             if (!initiallyConnected && !this.#channels.hasChannel(address)) {
                 // We got an uninitialized node, so do the first connection as usual
-                await this.ensureConnection(address, { discoveryType: NodeDiscoveryType.None });
+                await this.ensureConnection(address, {
+                    discoveryOptions: { discoveryType: NodeDiscoveryType.None },
+                });
                 initiallyConnected = true; // We only do this connection once, rest is handled in following code
                 if (this.#channels.hasChannel(address)) {
                     return;
@@ -366,18 +377,22 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
      * device is discovered again using its operational instance details.
      * It returns the operational MessageChannel on success.
      */
-    async #resume(address: PeerAddress, discoveryOptions?: DiscoveryOptions) {
+    async #resume(address: PeerAddress, discoveryOptions?: DiscoveryOptions, tryOperationalAddress?: ServerAddressIp) {
         const { discoveryType } = discoveryOptions ?? {};
+
         const operationalAddress =
-            discoveryType === NodeDiscoveryType.None
+            tryOperationalAddress ??
+            (discoveryType === NodeDiscoveryType.None
                 ? this.#getLastOperationalAddress(address)
-                : this.#knownOperationalAddressFor(address);
+                : this.#knownOperationalAddressFor(address));
+
         try {
             return await this.#connectOrDiscoverNode(address, operationalAddress, discoveryOptions);
         } catch (error) {
             if (
                 (error instanceof DiscoveryError || error instanceof NoResponseTimeoutError) &&
-                this.#peersByAddress.has(address)
+                this.#peersByAddress.has(address) &&
+                tryOperationalAddress === undefined
             ) {
                 logger.info(`Resume failed, remove all sessions for ${PeerAddress(address)}`);
                 // We remove all sessions, this also informs the PairedNode class
@@ -432,7 +447,13 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
             operationalAddress !== undefined &&
             (runningDiscoveryType === NodeDiscoveryType.None || requestedDiscoveryType === NodeDiscoveryType.None)
         ) {
-            const directReconnection = await this.#reconnectKnownAddress(address, operationalAddress, discoveryData);
+            const directReconnection = await this.#reconnectKnownAddress(
+                address,
+                operationalAddress,
+                discoveryData,
+                // When we use a timeout for discovery also use this for reconnecting to the node
+                timeoutSeconds ? timeoutSeconds * 1000 : undefined,
+            );
             if (directReconnection !== undefined) {
                 return directReconnection;
             }
@@ -567,6 +588,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
         address = PeerAddress(address);
 
         const { ip, port } = operationalAddress;
+        const startTime = Time.nowMs();
         try {
             logger.debug(
                 `Resuming connection to ${PeerAddress(address)} at ${ip}:${port}${
@@ -585,7 +607,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
                     error,
                 );
                 // We remove all sessions, this also informs the PairedNode class
-                await this.#sessions.removeAllSessionsForNode(address);
+                await this.#sessions.removeAllSessionsForNode(address, false, startTime);
                 return undefined;
             } else {
                 throw error;

package/src/securechannel/SecureChannelMessenger.ts

@@ -43,6 +43,10 @@ export class SecureChannelMessenger {
         this.#defaultExpectedProcessingTimeMs = defaultExpectedProcessingTimeMs;
     }
 
+    get channel() {
+        return this.exchange.channel;
+    }
+
     async nextMessage(
         expectedMessageType: number,
         expectedProcessingTimeMs = this.#defaultExpectedProcessingTimeMs,

package/src/session/SecureSession.ts

@@ -292,11 +292,12 @@ export class SecureSession extends Session {
         return this.#fabric;
     }
 
-    async clearSubscriptions(flushSubscriptions = false) {
+    async clearSubscriptions(flushSubscriptions = false, cancelledByPeer = false) {
         const subscriptions = [...this.#subscriptions]; // get all values because subscriptions will remove themselves when cancelled
         for (const subscription of subscriptions) {
-            await subscription.close(flushSubscriptions);
+            await subscription.close(flushSubscriptions, cancelledByPeer);
         }
+        return subscriptions.length;
     }
 
     /** Ends a session. Outstanding subscription data will be flushed before the session is destroyed. */

package/src/session/Session.ts

@@ -62,6 +62,7 @@ export abstract class Session {
     abstract get closingAfterExchangeFinished(): boolean;
     #manager?: SessionManager;
     timestamp = Time.nowMs();
+    readonly createdAt = Time.nowMs();
     activeTimestamp = 0;
     protected readonly idleIntervalMs: number;
     protected readonly activeIntervalMs: number;

package/src/session/SessionManager.ts

@@ -378,11 +378,12 @@ export class SessionManager {
         });
     }
 
-    async removeAllSessionsForNode(address: PeerAddress, sendClose = false) {
+    async removeAllSessionsForNode(address: PeerAddress, sendClose = false, closeBeforeCreatedTimestamp?: number) {
         await this.#construction;
 
         for (const session of this.#sessions) {
             if (!session.isSecure) continue;
+            if (closeBeforeCreatedTimestamp !== undefined && session.createdAt >= closeBeforeCreatedTimestamp) continue;
             const secureSession = session;
             if (secureSession.peerIs(address)) {
                 await secureSession.destroy(sendClose, false);
@@ -564,17 +565,12 @@ export class SessionManager {
     }
 
     /** Clears all subscriptions for a given node and returns how many were cleared. */
-    async clearSubscriptionsForNode(fabricIndex: FabricIndex, nodeId: NodeId, flushSubscriptions?: boolean) {
+    async clearSubscriptionsForNode(peerAddress: PeerAddress, flushSubscriptions?: boolean) {
         let clearedCount = 0;
         for (const session of this.#sessions) {
-            if (session.fabric?.fabricIndex !== fabricIndex) {
-                continue;
+            if (PeerAddress.is(session.peerAddress, peerAddress)) {
+                clearedCount += await session.clearSubscriptions(flushSubscriptions, true);
             }
-            if (session.peerNodeId !== nodeId) {
-                continue;
-            }
-            await session.clearSubscriptions(flushSubscriptions);
-            clearedCount++;
         }
         return clearedCount;
     }