@matter/protocol 0.12.2-alpha.0-20250128-09631d531 → 0.12.2-alpha.0-20250201-eb5d40a2f

package/src/interaction/InteractionServer.ts

@@ -48,9 +48,10 @@ import {
     decodeListAttributeValueWithSchema,
     expandPathsInAttributeData,
 } from "./AttributeDataDecoder.js";
-import { AttributeReportPayload, DataReportPayload, EventReportPayload } from "./AttributeDataEncoder.js";
+import { DataReportPayloadIterator, EventReportPayload } from "./AttributeDataEncoder.js";
 import { InteractionEndpointStructure } from "./InteractionEndpointStructure.js";
 import {
+    DataReport,
     InteractionRecipient,
     InteractionServerMessenger,
     InvokeRequest,
@@ -262,45 +263,129 @@ export class InteractionServer implements ProtocolHandler, InteractionRecipient
         await new InteractionServerMessenger(exchange).handleRequest(this);
     }
 
-    async handleReadRequest(
+    async #collectEventDataForRead(
+        { eventRequests, eventFilters, isFabricFiltered }: ReadRequest,
         exchange: MessageExchange,
-        {
-            attributeRequests,
-            dataVersionFilters,
-            eventRequests,
-            eventFilters,
-            isFabricFiltered,
-            interactionModelRevision,
-        }: ReadRequest,
         message: Message,
-    ): Promise<DataReportPayload> {
-        logger.debug(
-            `Received read request from ${exchange.channel.name}: attributes:${
-                attributeRequests?.map(path => this.#endpointStructure.resolveAttributeName(path)).join(", ") ?? "none"
-            }, events:${
-                eventRequests?.map(path => this.#endpointStructure.resolveEventName(path)).join(", ") ?? "none"
-            } isFabricFiltered=${isFabricFiltered}`,
-        );
+    ) {
+        let eventReportsPayload: undefined | EventReportPayload[];
+        if (eventRequests) {
+            eventReportsPayload = [];
+            for (const requestPath of eventRequests) {
+                validateReadEventPath(requestPath);
 
-        if (interactionModelRevision > Specification.INTERACTION_MODEL_REVISION) {
-            logger.debug(
-                `Interaction model revision of sender ${interactionModelRevision} is higher than supported ${Specification.INTERACTION_MODEL_REVISION}.`,
-            );
-        }
-        if (attributeRequests === undefined && eventRequests === undefined) {
-            throw new StatusResponseError(
-                "Only Read requests with attributeRequests or eventRequests are supported right now",
-                StatusCode.UnsupportedRead,
-            );
-        }
+                const events = this.#endpointStructure.getEvents([requestPath]);
 
-        if (message.packetHeader.sessionType !== SessionType.Unicast) {
-            throw new StatusResponseError(
-                "Subscriptions are only allowed on unicast sessions",
-                StatusCode.InvalidAction,
-            );
+                // Requested event path not found in any cluster server on any endpoint
+                if (events.length === 0) {
+                    if (isConcreteEventPath(requestPath)) {
+                        const { endpointId, clusterId, eventId } = requestPath;
+                        try {
+                            this.#endpointStructure.validateConcreteEventPath(endpointId, clusterId, eventId);
+                            throw new InternalError(
+                                "validateConcreteEventPath should throw StatusResponseError but did not.",
+                            );
+                        } catch (e) {
+                            StatusResponseError.accept(e);
+
+                            logger.debug(
+                                `Read event from ${
+                                    exchange.channel.name
+                                }: ${this.#endpointStructure.resolveEventName(requestPath)}: unsupported path: Status=${
+                                    e.code
+                                }`,
+                            );
+                            eventReportsPayload?.push({
+                                hasFabricSensitiveData: false,
+                                eventStatus: { path: requestPath, status: { status: e.code } },
+                            });
+                        }
+                    }
+                    // Wildcard path: Just leave out values
+                    logger.debug(
+                        `Read event from ${exchange.channel.name}: ${this.#endpointStructure.resolveEventName(
+                            requestPath,
+                        )}: ignore non-existing event`,
+                    );
+                    continue;
+                }
+
+                const reportsForPath = new Array<EventReportPayload>();
+                for (const { path, event } of events) {
+                    try {
+                        const matchingEvents = await this.readEvent(
+                            path,
+                            eventFilters,
+                            event,
+                            exchange,
+                            isFabricFiltered,
+                            message,
+                        );
+                        logger.debug(
+                            `Read event from ${exchange.channel.name}: ${this.#endpointStructure.resolveEventName(
+                                path,
+                            )}=${Logger.toJSON(matchingEvents)}`,
+                        );
+                        const { schema } = event;
+                        reportsForPath.push(
+                            ...matchingEvents.map(({ number, priority, epochTimestamp, payload }) => ({
+                                hasFabricSensitiveData: event.hasFabricSensitiveData,
+                                eventData: {
+                                    path,
+                                    eventNumber: number,
+                                    priority,
+                                    epochTimestamp,
+                                    payload,
+                                    schema,
+                                },
+                            })),
+                        );
+                    } catch (error) {
+                        logger.error(
+                            `Error while reading event from ${
+                                exchange.channel.name
+                            } to ${this.#endpointStructure.resolveEventName(path)}:`,
+                            error,
+                        );
+
+                        StatusResponseError.accept(error);
+
+                        // Add StatusResponseErrors, but only when the initial path was concrete, else error are ignored
+                        if (isConcreteEventPath(requestPath)) {
+                            eventReportsPayload?.push({
+                                hasFabricSensitiveData: false,
+                                eventStatus: { path, status: { status: error.code } },
+                            });
+                        }
+                    }
+                }
+                eventReportsPayload.push(
+                    ...reportsForPath.sort((a, b) => {
+                        const eventNumberA = a.eventData?.eventNumber ?? EventNumber(0);
+                        const eventNumberB = b.eventData?.eventNumber ?? EventNumber(0);
+                        if (eventNumberA > eventNumberB) {
+                            return 1;
+                        } else if (eventNumberA < eventNumberB) {
+                            return -1;
+                        } else {
+                            return 0;
+                        }
+                    }),
+                );
+            }
         }
+        return eventReportsPayload;
+    }
 
+    /**
+     * Returns an iterator that yields the data reports and events data for the given read request.
+     */
+    *#iterateReadAttributesPaths(
+        { attributeRequests, dataVersionFilters, isFabricFiltered }: ReadRequest,
+        eventReportsPayload: EventReportPayload[] | undefined,
+        exchange: MessageExchange,
+        message: Message,
+    ) {
         const dataVersionFilterMap = new Map<string, number>(
             dataVersionFilters?.map(({ path, dataVersion }) => [clusterPathToId(path), dataVersion]) ?? [],
         );
@@ -312,7 +397,6 @@ export class InteractionServer implements ProtocolHandler, InteractionRecipient
             );
         }
 
-        const attributeReportsPayload = new Array<AttributeReportPayload>();
         for (const requestPath of attributeRequests ?? []) {
             validateReadAttributesPath(requestPath);
 
@@ -338,10 +422,10 @@ export class InteractionServer implements ProtocolHandler, InteractionRecipient
                                 e.code
                             }`,
                         );
-                        attributeReportsPayload.push({
+                        yield {
                             hasFabricSensitiveData: false,
                             attributeStatus: { path: requestPath, status: { status: e.code } },
-                        });
+                        };
                     }
                 }
 
@@ -369,14 +453,8 @@ export class InteractionServer implements ProtocolHandler, InteractionRecipient
 
                     let value, version;
                     try {
-                        ({ value, version } = await this.readAttribute(
-                            path,
-                            attribute,
-                            exchange,
-                            isFabricFiltered,
-                            message,
-                            this.#endpointStructure.getEndpoint(endpointId)!,
-                        ));
+                        // TODO Optimize read later here too to optimize context usage
+                        ({ value, version } = this.readAttribute(path, attribute, exchange, isFabricFiltered, message));
                     } catch (e) {
                         NoAssociatedFabricError.accept(e);
 
@@ -416,10 +494,10 @@ export class InteractionServer implements ProtocolHandler, InteractionRecipient
                     );
 
                     const { schema } = attribute;
-                    attributeReportsPayload.push({
+                    yield {
                         hasFabricSensitiveData: attribute.hasFabricSensitiveData,
                         attributeData: { path, dataVersion: version, payload: value, schema },
-                    });
+                    };
                 } catch (error) {
                     logger.error(
                         `Error while reading attribute from ${
@@ -432,144 +510,125 @@ export class InteractionServer implements ProtocolHandler, InteractionRecipient
 
                     // Add StatusResponseErrors, but only when the initial path was concrete, else error are ignored
                     if (isConcreteAttributePath(requestPath)) {
-                        attributeReportsPayload.push({
+                        yield {
                             hasFabricSensitiveData: false,
                             attributeStatus: { path, status: { status: error.code } },
-                        });
+                        };
                     }
                 }
             }
         }
 
-        let eventReportsPayload: undefined | EventReportPayload[];
-        if (eventRequests) {
-            eventReportsPayload = [];
-            for (const requestPath of eventRequests) {
-                validateReadEventPath(requestPath);
-
-                const events = this.#endpointStructure.getEvents([requestPath]);
-
-                // Requested event path not found in any cluster server on any endpoint
-                if (events.length === 0) {
-                    if (isConcreteEventPath(requestPath)) {
-                        const { endpointId, clusterId, eventId } = requestPath;
-                        try {
-                            this.#endpointStructure.validateConcreteEventPath(endpointId, clusterId, eventId);
-                            throw new InternalError(
-                                "validateConcreteEventPath should throw StatusResponseError but did not.",
-                            );
-                        } catch (e) {
-                            StatusResponseError.accept(e);
-
-                            logger.debug(
-                                `Read event from ${
-                                    exchange.channel.name
-                                }: ${this.#endpointStructure.resolveEventName(requestPath)}: unsupported path: Status=${
-                                    e.code
-                                }`,
-                            );
-                            eventReportsPayload?.push({
-                                hasFabricSensitiveData: false,
-                                eventStatus: { path: requestPath, status: { status: e.code } },
-                            });
-                        }
-                    }
-                    // Wildcard path: Just leave out values
-                    logger.debug(
-                        `Read event from ${exchange.channel.name}: ${this.#endpointStructure.resolveEventName(
-                            requestPath,
-                        )}: ignore non-existing event`,
-                    );
-                    continue;
-                }
+        if (eventReportsPayload !== undefined) {
+            for (const eventReport of eventReportsPayload) {
+                yield eventReport;
+            }
+        }
+    }
 
-                const reportsForPath = new Array<EventReportPayload>();
-                for (const { path, event } of events) {
-                    try {
-                        const { endpointId } = path;
-                        const matchingEvents = await this.readEvent(
-                            path,
-                            eventFilters,
-                            event,
-                            exchange,
-                            isFabricFiltered,
-                            message,
-                            this.#endpointStructure.getEndpoint(endpointId)!,
-                        );
-                        logger.debug(
-                            `Read event from ${exchange.channel.name}: ${this.#endpointStructure.resolveEventName(
-                                path,
-                            )}=${Logger.toJSON(matchingEvents)}`,
-                        );
-                        const { schema } = event;
-                        reportsForPath.push(
-                            ...matchingEvents.map(({ number, priority, epochTimestamp, payload }) => ({
-                                hasFabricSensitiveData: event.hasFabricSensitiveData,
-                                eventData: {
-                                    path,
-                                    eventNumber: number,
-                                    priority,
-                                    epochTimestamp,
-                                    payload,
-                                    schema,
-                                },
-                            })),
-                        );
-                    } catch (error) {
-                        logger.error(
-                            `Error while reading event from ${
-                                exchange.channel.name
-                            } to ${this.#endpointStructure.resolveEventName(path)}:`,
-                            error,
-                        );
+    async handleReadRequest(
+        exchange: MessageExchange,
+        readRequest: ReadRequest,
+        message: Message,
+    ): Promise<{ dataReport: DataReport; payload: DataReportPayloadIterator }> {
+        const { attributeRequests, eventRequests, isFabricFiltered, interactionModelRevision } = readRequest;
+        logger.debug(
+            `Received read request from ${exchange.channel.name}: attributes:${
+                attributeRequests?.map(path => this.#endpointStructure.resolveAttributeName(path)).join(", ") ?? "none"
+            }, events:${
+                eventRequests?.map(path => this.#endpointStructure.resolveEventName(path)).join(", ") ?? "none"
+            } isFabricFiltered=${isFabricFiltered}`,
+        );
 
-                        StatusResponseError.accept(error);
+        if (interactionModelRevision > Specification.INTERACTION_MODEL_REVISION) {
+            logger.debug(
+                `Interaction model revision of sender ${interactionModelRevision} is higher than supported ${Specification.INTERACTION_MODEL_REVISION}.`,
+            );
+        }
+        if (attributeRequests === undefined && eventRequests === undefined) {
+            throw new StatusResponseError(
+                "Only Read requests with attributeRequests or eventRequests are supported right now",
+                StatusCode.UnsupportedRead,
+            );
+        }
 
-                        // Add StatusResponseErrors, but only when the initial path was concrete, else error are ignored
-                        if (isConcreteEventPath(requestPath)) {
-                            eventReportsPayload?.push({
-                                hasFabricSensitiveData: false,
-                                eventStatus: { path, status: { status: error.code } },
-                            });
-                        }
-                    }
-                }
-                eventReportsPayload.push(
-                    ...reportsForPath.sort((a, b) => {
-                        const eventNumberA = a.eventData?.eventNumber ?? EventNumber(0);
-                        const eventNumberB = b.eventData?.eventNumber ?? EventNumber(0);
-                        if (eventNumberA > eventNumberB) {
-                            return 1;
-                        } else if (eventNumberA < eventNumberB) {
-                            return -1;
-                        } else {
-                            return 0;
-                        }
-                    }),
-                );
-            }
+        if (message.packetHeader.sessionType !== SessionType.Unicast) {
+            throw new StatusResponseError(
+                "Subscriptions are only allowed on unicast sessions",
+                StatusCode.InvalidAction,
+            );
         }
 
         return {
-            interactionModelRevision: Specification.INTERACTION_MODEL_REVISION,
-            suppressResponse: true,
-            attributeReportsPayload,
-            eventReportsPayload,
+            dataReport: {
+                interactionModelRevision: Specification.INTERACTION_MODEL_REVISION,
+                suppressResponse: true,
+            },
+            payload: this.#iterateReadAttributesPaths(
+                readRequest,
+                await this.#collectEventDataForRead(readRequest, exchange, message),
+                exchange,
+                message,
+            ),
         };
     }
 
-    protected async readAttribute(
+    protected readAttribute(
         _path: AttributePath,
         attribute: AnyAttributeServer<any>,
         exchange: MessageExchange,
         isFabricFiltered: boolean,
         message: Message,
-        _endpoint: EndpointInterface,
         offline = false,
     ) {
         return attribute.getWithVersion(exchange.session, isFabricFiltered, offline ? undefined : message);
     }
 
+    /**
+     * Reads the attributes for the given endpoint.
+     * This can currently only be used for subscriptions because errors are ignored!
+     */
+    protected readEndpointAttributesForSubscription(
+        _endpointId: EndpointNumber,
+        attributes: { path: AttributePath; attribute: AnyAttributeServer<any> }[],
+        exchange: MessageExchange,
+        isFabricFiltered: boolean,
+        message: Message,
+        offline = false,
+    ) {
+        const result = new Array<{
+            path: AttributePath;
+            attribute: AnyAttributeServer<unknown>;
+            value: any;
+            version: number;
+        }>();
+        for (const { path, attribute } of attributes) {
+            try {
+                const { version, value } = this.readAttribute(
+                    path,
+                    attribute,
+                    exchange,
+                    isFabricFiltered,
+                    message,
+                    offline,
+                );
+                result.push({ path, value, version, attribute });
+            } catch (error) {
+                if (StatusResponseError.is(error, StatusCode.UnsupportedAccess)) {
+                    logger.warn(
+                        `Permission denied reading attribute ${this.#endpointStructure.resolveAttributeName(path)}`,
+                    );
+                } else {
+                    logger.warn(
+                        `Error reading attribute ${this.#endpointStructure.resolveAttributeName(path)}:`,
+                        error,
+                    );
+                }
+            }
+        }
+        return result;
+    }
+
     protected async readEvent(
         _path: EventPath,
         eventFilters: TypeFromSchema<typeof TlvEventFilter>[] | undefined,
@@ -577,7 +636,6 @@ export class InteractionServer implements ProtocolHandler, InteractionRecipient
         exchange: MessageExchange,
         isFabricFiltered: boolean,
         message: Message,
-        _endpoint: EndpointInterface,
     ) {
         return event.get(exchange.session, isFabricFiltered, message, eventFilters);
     }
@@ -773,16 +831,7 @@ export class InteractionServer implements ProtocolHandler, InteractionRecipient
                             : decodeListAttributeValueWithSchema(
                                   schema as ArraySchema<any>,
                                   [writeRequest],
-                                  (
-                                      await this.readAttribute(
-                                          path,
-                                          attribute,
-                                          exchange,
-                                          true,
-                                          message,
-                                          this.#endpointStructure.getEndpoint(endpointId)!,
-                                      )
-                                  ).value ?? defaultValue,
+                                  this.readAttribute(path, attribute, exchange, true, message).value ?? defaultValue,
                               );
                     logger.debug(
                         `Handle write request from ${
@@ -1028,26 +1077,13 @@ export class InteractionServer implements ProtocolHandler, InteractionRecipient
             structure: this.#endpointStructure,
 
             readAttribute: (path, attribute, offline) =>
-                this.readAttribute(
-                    path,
-                    attribute,
-                    exchange,
-                    isFabricFiltered,
-                    message,
-                    this.#endpointStructure.getEndpoint(path.endpointId)!,
-                    offline,
-                ),
+                this.readAttribute(path, attribute, exchange, isFabricFiltered, message, offline),
+
+            readEndpointAttributesForSubscription: (endpointId, attributes) =>
+                this.readEndpointAttributesForSubscription(endpointId, attributes, exchange, isFabricFiltered, message),
 
             readEvent: (path, event, eventFilters) =>
-                this.readEvent(
-                    path,
-                    eventFilters,
-                    event,
-                    exchange,
-                    isFabricFiltered,
-                    message,
-                    this.#endpointStructure.getEndpoint(path.endpointId)!,
-                ),
+                this.readEvent(path, eventFilters, event, exchange, isFabricFiltered, message),
 
             initiateExchange: (address: PeerAddress, protocolId) => this.#context.initiateExchange(address, protocolId),
         };