@project-chip/matter.js 0.3.0 → 0.5.0

package/dist/es/protocol/interaction/InteractionServer.js

@@ -12,201 +12,226 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { InteractionServerMessenger, StatusResponseError } from "./InteractionMessenger.js";
-import { TlvSubscribeResponse } from "./InteractionProtocol.js";
-import { TlvNoArguments } from "../../tlv/TlvNoArguments.js";
-import { DeviceTypeId } from "../../datatype/DeviceTypeId.js";
-import { ClusterId } from "../../datatype/ClusterId.js";
-import { EndpointNumber } from "../../datatype/EndpointNumber.js";
-import { SubscriptionHandler } from "./SubscriptionHandler.js";
+import { TlvNoResponse } from "../../cluster/Cluster.js";
+import { AttributeServer, FabricScopedAttributeServer, } from "../../cluster/server/AttributeServer.js";
+import { asClusterServerInternal } from "../../cluster/server/ClusterServerTypes.js";
+import { tryCatchAsync } from "../../common/TryCatchHandler.js";
 import { Crypto } from "../../crypto/Crypto.js";
-import { decodeValueForSchema, normalizeAttributeData } from "./AttributeDataDecoder.js";
-import { CommandServer } from "../../cluster/server/CommandServer.js";
-import { AttributeGetterServer, AttributeServer } from "../../cluster/server/AttributeServer.js";
-import { DescriptorCluster } from "../../cluster/DescriptorCluster.js";
 import { Logger } from "../../log/Logger.js";
-import { capitalize } from "../../util/String.js";
-import { TlvVoid } from "../../tlv/TlvVoid.js";
+import { EventHandler } from "../../protocol/interaction/EventHandler.js";
+import { assertSecureSession } from "../../session/SecureSession.js";
+import { TlvNoArguments } from "../../tlv/TlvNoArguments.js";
+import { decodeAttributeValueWithSchema, normalizeAttributeData } from "./AttributeDataDecoder.js";
+import { InteractionEndpointStructure } from "./InteractionEndpointStructure.js";
+import { InteractionServerMessenger, StatusResponseError, } from "./InteractionMessenger.js";
+import { TlvSubscribeResponse, } from "./InteractionProtocol.js";
+import { SubscriptionHandler } from "./SubscriptionHandler.js";
 export const INTERACTION_PROTOCOL_ID = 0x0001;
-const logger = Logger.get("InteractionProtocol");
-export class ClusterServer {
-    constructor(clusterDef, features, attributesInitialValues, handlers) {
-        this.attributes = {};
-        this.commands = new Array();
-        this.clusterStorage = null;
-        this.attributeStorageListeners = new Map();
-        const { id, name, attributes: attributeDefs, commands: commandDefs } = clusterDef;
-        this.id = id;
-        this.name = name;
-        // Create attributes
-        attributesInitialValues = Object.assign(Object.assign({}, attributesInitialValues), { clusterRevision: clusterDef.revision, featureMap: features });
-        for (const name in attributesInitialValues) {
-            const { id, schema, writable, persistent } = attributeDefs[name];
-            const validator = typeof schema.validate === 'function' ? schema.validate.bind(schema) : undefined;
-            const getter = handlers[`get${capitalize(name)}`];
-            if (getter === undefined) {
-                this.attributes[name] = new AttributeServer(id, name, schema, validator !== null && validator !== void 0 ? validator : (() => { }), writable, attributesInitialValues[name]);
-            }
-            else {
-                this.attributes[name] = new AttributeGetterServer(id, name, schema, validator !== null && validator !== void 0 ? validator : (() => { }), writable, attributesInitialValues[name], getter);
-            }
-            if (persistent) {
-                const listener = (value, version) => this.attributeStorageListener(name, version, value);
-                this.attributeStorageListeners.set(id, listener);
-                this.attributes[name].addMatterListener(listener);
-            }
-        }
-        // Create commands
-        for (const name in commandDefs) {
-            const handler = handlers[name];
-            if (handler === undefined)
-                continue;
-            const { requestId, requestSchema, responseId, responseSchema } = commandDefs[name];
-            this.commands.push(new CommandServer(requestId, responseId, name, requestSchema, responseSchema, (request, session, message) => handler({ request, attributes: this.attributes, session, message })));
-        }
-    }
-    setStorage(storageContext) {
-        this.clusterStorage = storageContext;
-        for (const name in this.attributes) {
-            const attribute = this.attributes[name];
-            if (!this.attributeStorageListeners.has(attribute.id))
-                return;
-            if (!storageContext.has(attribute.name))
-                return;
-            try {
-                const data = storageContext.get(attribute.name);
-                logger.debug(`Restoring attribute ${attribute.name} (${attribute.id}) in cluster ${this.name} (${this.id})`);
-                attribute.init(data.value, data.version);
-            }
-            catch (error) {
-                logger.warn(`Failed to restore attribute ${attribute.name} (${attribute.id}) in cluster ${this.name} (${this.id})`, error);
-            }
-        }
-    }
-    attributeStorageListener(attributeName, version, value) {
-        if (!this.clusterStorage)
-            return;
-        logger.debug(`Storing attribute ${attributeName} in cluster ${this.name} (${this.id})`);
-        this.clusterStorage.set(attributeName, { version, value });
-    }
+const logger = Logger.get("InteractionServer");
+export function genericElementPathToId(endpointId, clusterId, elementId) {
+    return `${endpointId}/${clusterId}/${elementId}`;
 }
 export function commandPathToId({ endpointId, clusterId, commandId }) {
-    return `${endpointId}/${clusterId}/${commandId}`;
+    return genericElementPathToId(endpointId, clusterId, commandId);
 }
 export function attributePathToId({ endpointId, clusterId, attributeId }) {
-    return `${endpointId}/${clusterId}/${attributeId}`;
+    return genericElementPathToId(endpointId, clusterId, attributeId);
 }
-function toHex(value) {
-    return value === undefined ? "*" : `0x${value.toString(16)}`;
+export function eventPathToId({ endpointId, clusterId, eventId }) {
+    return genericElementPathToId(endpointId, clusterId, eventId);
+}
+export function clusterPathToId({ nodeId, endpointId, clusterId }) {
+    return `${nodeId}/${endpointId}/${clusterId}`;
 }
 export class InteractionServer {
-    constructor(storageManager) {
-        this.storageManager = storageManager;
-        this.endpoints = new Map();
-        this.attributes = new Map();
-        this.attributePaths = new Array();
-        this.commands = new Map();
-        this.commandPaths = new Array();
+    constructor(storage, options) {
+        this.storage = storage;
+        this.options = options;
+        this.endpointStructure = new InteractionEndpointStructure();
         this.nextSubscriptionId = Crypto.getRandomUInt32();
+        this.eventHandler = new EventHandler(this.storage);
+        this.subscriptionMap = new Map();
+        this.isClosing = false;
     }
     getId() {
         return INTERACTION_PROTOCOL_ID;
     }
-    addEndpoint(endpointId, device, clusters) {
-        // Add the descriptor cluster
-        const descriptorCluster = new ClusterServer(DescriptorCluster, {}, {
-            deviceTypeList: [{ revision: 1, deviceType: new DeviceTypeId(device.code) }],
-            serverList: [],
-            clientList: [],
-            partsList: [],
-        }, {});
-        clusters.push(descriptorCluster);
-        descriptorCluster.attributes.serverList.setLocal(clusters.map(({ id }) => new ClusterId(id)));
-        const clusterEndpointNumber = new EndpointNumber(endpointId);
-        const clusterMap = new Map();
-        clusters.forEach(cluster => {
-            const { id: clusterId, attributes, commands } = cluster;
-            cluster.setStorage(this.storageManager.createContext(`Cluster-${clusterEndpointNumber.number}-${clusterId}`));
-            clusterMap.set(clusterId, cluster);
-            // Add attributes
-            for (const name in attributes) {
-                const attribute = attributes[name];
-                const path = { endpointId, clusterId, attributeId: attribute.id };
-                this.attributes.set(attributePathToId(path), attribute);
-                this.attributePaths.push(path);
+    setRootEndpoint(endpoint) {
+        // Reset all data
+        this.endpointStructure.initializeFromEndpoint(endpoint);
+        for (const endpoint of this.endpointStructure.endpoints.values()) {
+            for (const cluster of endpoint.getAllClusterServers()) {
+                const clusterServer = asClusterServerInternal(cluster);
+                clusterServer._setStorage(this.storage.createContext(`Cluster-${endpoint.id}-${cluster.id}`));
+                clusterServer._registerEventHandler(this.eventHandler);
             }
-            // Add commands
-            commands.forEach(command => {
-                const path = { endpointId, clusterId, commandId: command.invokeId };
-                this.commands.set(commandPathToId(path), command);
-                this.commandPaths.push(path);
-            });
-        });
-        // Add part list if the endpoint is not root
-        if (endpointId !== 0) {
-            const rootPartsListAttribute = this.attributes.get(attributePathToId({ endpointId: 0, clusterId: DescriptorCluster.id, attributeId: DescriptorCluster.attributes.partsList.id }));
-            if (rootPartsListAttribute === undefined)
-                throw new Error("The root endpoint should be added first!");
-            rootPartsListAttribute.setLocal([...rootPartsListAttribute.getLocal(), clusterEndpointNumber]);
         }
-        this.endpoints.set(endpointId, Object.assign(Object.assign({}, device), { clusters: clusterMap }));
-        return this;
+        for (const subscription of this.subscriptionMap.values()) {
+            subscription.updateSubscription();
+        }
+        return;
     }
     onNewExchange(exchange) {
         return __awaiter(this, void 0, void 0, function* () {
+            if (this.isClosing)
+                return; // We are closing, ignore anything newly incoming
             yield new InteractionServerMessenger(exchange).handleRequest(readRequest => this.handleReadRequest(exchange, readRequest), writeRequest => this.handleWriteRequest(exchange, writeRequest), (subscribeRequest, messenger) => this.handleSubscribeRequest(exchange, subscribeRequest, messenger), (invokeRequest, message) => this.handleInvokeRequest(exchange, invokeRequest, message), timedRequest => this.handleTimedRequest(exchange, timedRequest));
         });
     }
-    handleReadRequest(exchange, { attributeRequests: attributePaths, isFabricFiltered }) {
-        if (attributePaths === undefined) {
-            throw new StatusResponseError("Only Read requests with attributeRequests are supported right now", 143 /* StatusCode.UnsupportedRead */);
+    handleReadRequest(exchange, { attributeRequests, dataVersionFilters, eventRequests, eventFilters, isFabricFiltered }) {
+        var _a, _b, _c;
+        if (attributeRequests === undefined && eventRequests === undefined) {
+            throw new StatusResponseError("Only Read requests with attributeRequests or eventRequests are supported right now", 143 /* StatusCode.UnsupportedRead */);
+        }
+        logger.debug(`Received read request from ${exchange.channel.name}: attributes:${(_a = attributeRequests === null || attributeRequests === void 0 ? void 0 : attributeRequests.map(path => this.endpointStructure.resolveAttributeName(path)).join(", ")) !== null && _a !== void 0 ? _a : "none"}, events:${(_b = eventRequests === null || eventRequests === void 0 ? void 0 : eventRequests.map(path => this.endpointStructure.resolveEventName(path)).join(", ")) !== null && _b !== void 0 ? _b : "none"} isFabricFiltered=${isFabricFiltered}`);
+        // TODO UnsupportedNode
+        const dataVersionFilterMap = new Map((_c = dataVersionFilters === null || dataVersionFilters === void 0 ? void 0 : dataVersionFilters.map(({ path, dataVersion }) => [clusterPathToId(path), dataVersion])) !== null && _c !== void 0 ? _c : []);
+        if (dataVersionFilterMap.size > 0) {
+            logger.debug(`DataVersionFilters: ${Array.from(dataVersionFilterMap.entries())
+                .map(([path, version]) => `${path}=${version}`)
+                .join(", ")}`);
         }
-        logger.debug(`Received read request from ${exchange.channel.getName()}: ${attributePaths.map(path => this.resolveAttributeName(path)).join(", ")}, isFabricFiltered=${isFabricFiltered}`);
-        // UnsupportedNode/UnsupportedEndpoint/UnsupportedCluster/UnsupportedAttribute/UnsupportedRead
-        const attributeReports = attributePaths.flatMap((path) => {
-            const attributes = this.getAttributes([path]);
+        const attributeReports = attributeRequests === null || attributeRequests === void 0 ? void 0 : attributeRequests.flatMap((path) => {
+            const attributes = this.endpointStructure.getAttributes([path]);
             if (attributes.length === 0) {
-                logger.debug(`Read from ${exchange.channel.getName()}: ${this.resolveAttributeName(path)} unsupported path`);
-                return [{ attributeStatus: { path, status: { status: 134 /* StatusCode.UnsupportedAttribute */ } } }]; // TODO: Find correct status code
+                const { endpointId, clusterId, attributeId } = path;
+                if (endpointId === undefined || clusterId === undefined || attributeId === undefined) {
+                    // Wildcard path: Just leave out values
+                    logger.debug(`Read from ${exchange.channel.name}: ${this.endpointStructure.resolveAttributeName(path)}: ignore non-existing attribute`);
+                }
+                else {
+                    // Else return correct status
+                    let status = 134 /* StatusCode.UnsupportedAttribute */;
+                    if (!this.endpointStructure.hasEndpoint(endpointId)) {
+                        status = 127 /* StatusCode.UnsupportedEndpoint */;
+                    }
+                    else if (!this.endpointStructure.hasClusterServer(endpointId, clusterId)) {
+                        status = 195 /* StatusCode.UnsupportedCluster */;
+                    }
+                    logger.debug(`Read attribute from ${exchange.channel.name}: ${this.endpointStructure.resolveAttributeName(path)}: unsupported path: Status=${status}`);
+                    return [{ attributeStatus: { path, status: { status } } }];
+                }
             }
-            return attributes.map(({ path, attribute }) => {
-                const { value, version } = attribute.getWithVersion(exchange.session); // TODO check ACL
-                logger.debug(`Read from ${exchange.channel.getName()}: ${this.resolveAttributeName(path)}=${Logger.toJSON(value)} (version=${version})`);
-                return { attributeData: { path, data: attribute.schema.encodeTlv(value), dataVersion: version } };
+            return attributes.flatMap(({ path, attribute }) => {
+                const { value, version } = attribute.getWithVersion(exchange.session, isFabricFiltered);
+                const { nodeId, endpointId, clusterId } = path;
+                const versionFilterValue = endpointId !== undefined && clusterId !== undefined
+                    ? dataVersionFilterMap.get(clusterPathToId({ nodeId, endpointId, clusterId }))
+                    : undefined;
+                if (versionFilterValue !== undefined && versionFilterValue === version) {
+                    logger.debug(`Read attribute from ${exchange.channel.name}: ${this.endpointStructure.resolveAttributeName(path)}=${Logger.toJSON(value)} (version=${version}) ignored because of dataVersionFilter`);
+                    return [];
+                }
+                logger.debug(`Read attribute from ${exchange.channel.name}: ${this.endpointStructure.resolveAttributeName(path)}=${Logger.toJSON(value)} (version=${version})`);
+                return [{ attributeData: { path, data: attribute.schema.encodeTlv(value), dataVersion: version } }];
             });
         });
+        const eventReports = eventRequests === null || eventRequests === void 0 ? void 0 : eventRequests.flatMap((path) => {
+            const events = this.endpointStructure.getEvents([path]);
+            if (events.length === 0) {
+                logger.debug(`Read event from ${exchange.channel.name}: ${this.endpointStructure.resolveEventName(path)}: unsupported path`);
+                return [{ eventStatus: { path, status: { status: 199 /* StatusCode.UnsupportedEvent */ } } }]; // TODO: Find correct status code
+            }
+            return events
+                .flatMap(({ path, event }) => {
+                const matchingEvents = this.eventHandler.getEvents(path, eventFilters);
+                logger.debug(`Read event from ${exchange.channel.name}:  ${this.endpointStructure.resolveEventName(path)}=${Logger.toJSON(matchingEvents)}`);
+                return matchingEvents.map(eventData => ({
+                    eventData: {
+                        path,
+                        eventNumber: eventData.eventNumber,
+                        priority: eventData.priority,
+                        epochTimestamp: eventData.epochTimestamp,
+                        data: event.schema.encodeTlv(eventData.data),
+                    },
+                }));
+            })
+                .sort((a, b) => a.eventData.eventNumber - b.eventData.eventNumber);
+        });
         return {
             interactionModelRevision: 1,
             suppressResponse: false,
-            attributeReports
+            attributeReports,
+            eventReports,
         };
     }
     handleWriteRequest(exchange, { suppressResponse, writeRequests }) {
-        logger.debug(`Received write request from ${exchange.channel.getName()}: ${writeRequests.map(req => this.resolveAttributeName(req.path)).join(", ")}, suppressResponse=${suppressResponse}`);
+        logger.debug(`Received write request from ${exchange.channel.name}: ${writeRequests
+            .map(req => this.endpointStructure.resolveAttributeName(req.path))
+            .join(", ")}, suppressResponse=${suppressResponse}`);
         // TODO consider TimedRequest constraints
         const writeData = normalizeAttributeData(writeRequests, true);
         const writeResults = writeData.flatMap((values) => {
             const { path, dataVersion } = values[0];
-            const attributes = this.getAttributes([path], true);
+            const attributes = this.endpointStructure.getAttributes([path], true);
+            const { endpointId, clusterId, attributeId } = path;
             if (attributes.length === 0) {
-                return [{ path, statusCode: 136 /* StatusCode.UnsupportedWrite */ }]; // TODO: Find correct status code
+                // No attribute found
+                // TODO: Also check nodeId
+                if (endpointId === undefined || clusterId === undefined || attributeId === undefined) {
+                    // Wildcard path: Just ignore
+                    logger.debug(`Write from ${exchange.channel.name}: ${this.endpointStructure.resolveAttributeName(path)}: ignore non-existing attribute`);
+                }
+                else {
+                    // Else return correct status
+                    let statusCode = 134 /* StatusCode.UnsupportedAttribute */;
+                    if (this.endpointStructure.hasAttribute(endpointId, clusterId, attributeId)) {
+                        // If attribute exists but was not returned above, it is not writeable
+                        statusCode = 136 /* StatusCode.UnsupportedWrite */;
+                    }
+                    else if (!this.endpointStructure.hasEndpoint(endpointId)) {
+                        statusCode = 127 /* StatusCode.UnsupportedEndpoint */;
+                    }
+                    else if (!this.endpointStructure.hasClusterServer(endpointId, clusterId)) {
+                        statusCode = 195 /* StatusCode.UnsupportedCluster */;
+                    }
+                    else {
+                        // check if concrete path and just "not writable"
+                        const allAttributes = this.endpointStructure.getAttributes([path]);
+                        if (allAttributes.length > 0) {
+                            statusCode = 136 /* StatusCode.UnsupportedWrite */;
+                        }
+                    }
+                    logger.debug(`Write from ${exchange.channel.name}: ${this.endpointStructure.resolveAttributeName(path)} not allowed: Status=${statusCode}`);
+                    return [{ path, statusCode }];
+                }
+            }
+            else if (attributes.length === 1 &&
+                endpointId !== undefined &&
+                clusterId !== undefined &&
+                attributeId !== undefined) {
+                // Concrete path
+                if (dataVersion !== undefined) {
+                    const cluster = this.endpointStructure.getClusterServer(endpointId, clusterId);
+                    if (cluster !== undefined && dataVersion !== cluster.clusterDataVersion) {
+                        return [{ path, statusCode: 146 /* StatusCode.DataVersionMismatch */ }];
+                    }
+                }
             }
             return attributes.map(({ path, attribute }) => {
-                // TODO add checks or dataVersion
+                // TODO add checks for timed writes, fabric scoped writes
                 // TODO add ACL checks
                 const { schema, defaultValue } = attribute;
                 try {
-                    const value = decodeValueForSchema(schema, values, defaultValue);
-                    logger.debug(`Handle write request from ${exchange.channel.getName()} resolved to: ${this.resolveAttributeName(path)}=${Logger.toJSON(value)} (Version=${dataVersion})`);
+                    const value = decodeAttributeValueWithSchema(schema, values, defaultValue);
+                    logger.debug(`Handle write request from ${exchange.channel.name} resolved to: ${this.endpointStructure.resolveAttributeName(path)}=${Logger.toJSON(value)} (Version=${dataVersion})`);
+                    if (!(attribute instanceof AttributeServer) &&
+                        !(attribute instanceof FabricScopedAttributeServer)) {
+                        throw new StatusResponseError("Fixed attributes cannot be written", 136 /* StatusCode.UnsupportedWrite */);
+                    }
                     attribute.set(value, exchange.session);
                 }
                 catch (error) {
-                    if (attributes.length === 1) { // For Multi-Attribute-Writes we ignore errors
-                        logger.error(`Error while handling write request from ${exchange.channel.getName()} to ${this.resolveAttributeName(path)}: ${error.message}`);
+                    if (attributes.length === 1) {
+                        // For Multi-Attribute-Writes we ignore errors
+                        logger.error(`Error while handling write request from ${exchange.channel.name} to ${this.endpointStructure.resolveAttributeName(path)}: ${error.message}`);
+                        if (error instanceof StatusResponseError) {
+                            return { path, statusCode: error.code };
+                        }
                         return { path, statusCode: 135 /* StatusCode.ConstraintError */ };
                     }
                     else {
-                        logger.debug(`While handling write request from ${exchange.channel.getName()} to ${this.resolveAttributeName(path)} ignored: ${error.message}`);
+                        logger.debug(`While handling write request from ${exchange.channel.name} to ${this.endpointStructure.resolveAttributeName(path)} ignored: ${error.message}`);
                     }
                 }
                 return { path, statusCode: 0 /* StatusCode.Success */ };
@@ -215,148 +240,169 @@ export class InteractionServer {
         });
         // TODO respect suppressResponse, potentially also needs adjustment in InteractionMessenger class!
         const errorResults = writeResults.filter(({ statusCode }) => statusCode !== 0 /* StatusCode.Success */);
-        logger.debug(`Write request from ${exchange.channel.getName()} done ${errorResults.length ? `with following errors: ${errorResults.map(({ path, statusCode }) => `${this.resolveAttributeName(path)}=${Logger.toJSON(statusCode)}`).join(", ")}` : "without errors"}`);
+        logger.debug(`Write request from ${exchange.channel.name} done ${errorResults.length
+            ? `with following errors: ${errorResults
+                .map(({ path, statusCode }) => `${this.endpointStructure.resolveAttributeName(path)}=${Logger.toJSON(statusCode)}`)
+                .join(", ")}`
+            : "without errors"}`);
         return {
             interactionModelRevision: 1,
             writeResponses: writeResults.map(({ path, statusCode }) => ({ path, status: { status: statusCode } })),
         };
     }
-    handleSubscribeRequest(exchange, { minIntervalFloorSeconds, maxIntervalCeilingSeconds, attributeRequests, eventRequests, keepSubscriptions }, messenger) {
+    handleSubscribeRequest(exchange, { minIntervalFloorSeconds, maxIntervalCeilingSeconds, attributeRequests, dataVersionFilters, eventRequests, eventFilters, keepSubscriptions, isFabricFiltered, }, messenger) {
+        var _a, _b, _c, _d, _e;
         return __awaiter(this, void 0, void 0, function* () {
-            logger.debug(`Received subscribe request from ${exchange.channel.getName()}`);
-            if (!exchange.session.isSecure())
-                throw new Error("Subscriptions are only implemented on secure sessions");
+            logger.debug(`Received subscribe request from ${exchange.channel.name} (keepSubscriptions=${keepSubscriptions}, isFabricFiltered=${isFabricFiltered})`);
+            // TODO dataversionFilters
+            assertSecureSession(exchange.session, "Subscriptions are only implemented on secure sessions");
             const session = exchange.session;
             const fabric = session.getFabric();
             if (fabric === undefined)
-                throw new Error("Subscriptions are only implemented after a fabric has been assigned");
-            if ((!Array.isArray(attributeRequests) || attributeRequests.length === 0) && (!Array.isArray(eventRequests) || eventRequests.length === 0)) {
+                throw new StatusResponseError("Subscriptions are only implemented after a fabric has been assigned", 128 /* StatusCode.InvalidAction */);
+            if ((!Array.isArray(attributeRequests) || attributeRequests.length === 0) &&
+                (!Array.isArray(eventRequests) || eventRequests.length === 0)) {
                 throw new StatusResponseError("No attributes or events requested", 128 /* StatusCode.InvalidAction */);
             }
-            if (!keepSubscriptions) {
-                session.clearSubscriptions();
+            logger.debug(`Subscribe to attributes:${(_a = attributeRequests === null || attributeRequests === void 0 ? void 0 : attributeRequests.map(path => this.endpointStructure.resolveAttributeName(path)).join(", ")) !== null && _a !== void 0 ? _a : "none"}, events:${(_b = eventRequests === null || eventRequests === void 0 ? void 0 : eventRequests.map(path => this.endpointStructure.resolveEventName(path)).join(", ")) !== null && _b !== void 0 ? _b : "none"}`);
+            if (dataVersionFilters !== undefined && dataVersionFilters.length > 0) {
+                logger.debug(`DataVersionFilters: ${dataVersionFilters
+                    .map(({ path: { nodeId, endpointId, clusterId }, dataVersion }) => `${clusterPathToId({ nodeId, endpointId, clusterId })}=${dataVersion}`)
+                    .join(", ")}`);
             }
-            // TODO add eventsRequest and other missing supports
-            if (attributeRequests !== undefined) {
-                logger.debug(`Subscribe to ${attributeRequests.map(path => this.resolveAttributeName(path)).join(", ")}`);
-                if (attributeRequests.length === 0)
-                    throw new Error("Unsupported subscription request with empty attribute list");
-                if (minIntervalFloorSeconds < 0)
-                    throw new Error("minIntervalFloorSeconds should be greater or equal to 0");
-                if (maxIntervalCeilingSeconds < 0)
-                    throw new Error("maxIntervalCeilingSeconds should be greater or equal to 1");
-                if (maxIntervalCeilingSeconds < minIntervalFloorSeconds)
-                    throw new Error("maxIntervalCeilingSeconds should be greater or equal to minIntervalFloorSeconds");
-                const attributes = this.getAttributes(attributeRequests);
-                if (!attributes.length) {
-                    throw new StatusResponseError("Attributes not found", 134 /* StatusCode.UnsupportedAttribute */);
-                }
-                // TODO: Interpret specs:
-                // The publisher SHALL compute an appropriate value for the MaxInterval field in the action. This SHALL respect the following constraint: MinIntervalFloor ≤ MaxInterval ≤ MAX(SUBSCRIPTION_MAX_INTERVAL_PUBLISHER_LIMIT=60mn, MaxIntervalCeiling)
-                if (this.nextSubscriptionId === 0xFFFFFFFF)
-                    this.nextSubscriptionId = 0;
-                const subscriptionId = this.nextSubscriptionId++;
-                const subscriptionHandler = new SubscriptionHandler(subscriptionId, session.getContext(), fabric, session.getPeerNodeId(), attributes, minIntervalFloorSeconds, maxIntervalCeilingSeconds);
-                session.addSubscription(subscriptionHandler);
+            if (eventFilters !== undefined && eventFilters.length > 0)
+                logger.debug(`Event filters: ${eventFilters.map(filter => `${filter.nodeId}/${filter.eventMin}`).join(", ")}`);
+            if (minIntervalFloorSeconds < 0) {
+                throw new StatusResponseError("minIntervalFloorSeconds should be greater or equal to 0", 128 /* StatusCode.InvalidAction */);
+            }
+            if (maxIntervalCeilingSeconds < 0) {
+                throw new StatusResponseError("maxIntervalCeilingSeconds should be greater or equal to 1", 128 /* StatusCode.InvalidAction */);
+            }
+            if (maxIntervalCeilingSeconds < minIntervalFloorSeconds) {
+                throw new StatusResponseError("maxIntervalCeilingSeconds should be greater or equal to minIntervalFloorSeconds", 128 /* StatusCode.InvalidAction */);
+            }
+            // TODO: Interpret specs:
+            // The publisher SHALL compute an appropriate value for the MaxInterval field in the action. This SHALL respect the following constraint: MinIntervalFloor ≤ MaxInterval ≤ MAX(SUBSCRIPTION_MAX_INTERVAL_PUBLISHER_LIMIT=60mn, MaxIntervalCeiling)
+            if (this.nextSubscriptionId === 0xffffffff)
+                this.nextSubscriptionId = 0;
+            const subscriptionId = this.nextSubscriptionId++;
+            const subscriptionHandler = new SubscriptionHandler(subscriptionId, session, this.endpointStructure, attributeRequests, dataVersionFilters, eventRequests, eventFilters, this.eventHandler, isFabricFiltered, minIntervalFloorSeconds, maxIntervalCeilingSeconds, (_c = this.options) === null || _c === void 0 ? void 0 : _c.subscriptionMaxIntervalSeconds, (_d = this.options) === null || _d === void 0 ? void 0 : _d.subscriptionMinIntervalSeconds, (_e = this.options) === null || _e === void 0 ? void 0 : _e.subscriptionRandomizationWindowSeconds, () => this.subscriptionMap.delete(subscriptionId));
+            try {
                 // Send initial data report to prime the subscription with initial data
-                yield subscriptionHandler.sendInitialReport(messenger, session);
-                const maxInterval = subscriptionHandler.getMaxInterval();
-                logger.info(`Created subscription ${subscriptionId} for Session ${session.getId()} with ${attributes.length} attributes. Updates: ${minIntervalFloorSeconds} - ${maxIntervalCeilingSeconds} => ${maxInterval} seconds`);
-                // Then send the subscription response
-                yield messenger.send(4 /* MessageType.SubscribeResponse */, TlvSubscribeResponse.encode({ subscriptionId, maxInterval, interactionModelRevision: 1 }));
-                subscriptionHandler.activateSendingUpdates();
+                yield subscriptionHandler.sendInitialReport(messenger);
             }
+            catch (error) {
+                logger.error(`Subscription ${subscriptionId} for Session ${session.getId()}: Error while sending initial data reports: ${error.message}`);
+                yield subscriptionHandler.cancel(); // Cleanup
+                if (error instanceof StatusResponseError) {
+                    logger.info(`Sending status response ${error.code} for interaction error: ${error}`);
+                    yield messenger.sendStatus(error.code);
+                }
+                return; // Make sure to not bubble up the exception
+            }
+            if (!keepSubscriptions) {
+                logger.debug(`Clear subscriptions for Session ${session.name} because keepSubscriptions=false`);
+                yield session.clearSubscriptions(true);
+            }
+            const maxInterval = subscriptionHandler.getMaxInterval();
+            logger.info(`Successfully created subscription ${subscriptionId} for Session ${session.getId()}. Updates: ${minIntervalFloorSeconds} - ${maxIntervalCeilingSeconds} => ${maxInterval} seconds (sendInterval = ${subscriptionHandler.getSendInterval()} seconds)`);
+            // Then send the subscription response
+            yield messenger.send(4 /* MessageType.SubscribeResponse */, TlvSubscribeResponse.encode({ subscriptionId, maxInterval, interactionModelRevision: 1 }));
+            this.subscriptionMap.set(subscriptionId, subscriptionHandler);
+            session.addSubscription(subscriptionHandler);
+            subscriptionHandler.activateSendingUpdates();
         });
     }
     handleInvokeRequest(exchange, { invokeRequests }, message) {
         return __awaiter(this, void 0, void 0, function* () {
-            logger.debug(`Received invoke request from ${exchange.channel.getName()}: ${invokeRequests.map(({ commandPath: { endpointId, clusterId, commandId } }) => `${toHex(endpointId)}/${toHex(clusterId)}/${toHex(commandId)}`).join(", ")}`);
-            const results = new Array();
-            yield Promise.all(invokeRequests.map(({ commandPath, commandFields }) => __awaiter(this, void 0, void 0, function* () {
-                if (commandPath.endpointId === undefined) {
-                    logger.error("Wildcard command invokes not yet supported!");
-                    results.push({ code: 129 /* StatusCode.UnsupportedCommand */, commandPath, response: TlvVoid.encodeTlv(), responseId: 0 });
-                    return;
+            logger.debug(`Received invoke request from ${exchange.channel.name}: ${invokeRequests
+                .map(({ commandPath: { endpointId, clusterId, commandId } }) => this.endpointStructure.resolveCommandName({ endpointId, clusterId, commandId }))
+                .join(", ")}`);
+            const invokeResponses = [];
+            yield Promise.all(invokeRequests.flatMap(({ commandPath, commandFields }) => __awaiter(this, void 0, void 0, function* () {
+                const commands = this.endpointStructure.getCommands([commandPath]);
+                // TODO also check ACL and Timed, Fabric scoping constrains
+                if (commands.length === 0) {
+                    // TODO Also check nodeId
+                    const { endpointId, clusterId, commandId } = commandPath;
+                    if (endpointId === undefined || clusterId === undefined || commandId === undefined) {
+                        // Wildcard path: Just ignore
+                        logger.debug(`Invoke from ${exchange.channel.name}: ${this.endpointStructure.resolveCommandName(commandPath)} ignore non-existing attribute`);
+                    }
+                    else {
+                        // Else return correct status
+                        let status = 129 /* StatusCode.UnsupportedCommand */;
+                        if (!this.endpointStructure.hasEndpoint(endpointId)) {
+                            status = 127 /* StatusCode.UnsupportedEndpoint */;
+                        }
+                        else if (!this.endpointStructure.hasClusterServer(endpointId, clusterId)) {
+                            status = 195 /* StatusCode.UnsupportedCluster */;
+                        }
+                        logger.debug(`Invoke from ${exchange.channel.name}: ${this.endpointStructure.resolveCommandName(commandPath)} unsupported path: Status=${status}`);
+                        invokeResponses.push({ status: { commandPath, status: { status } } });
+                        return;
+                    }
                 }
-                const command = this.commands.get(commandPathToId(commandPath));
-                if (command === undefined)
-                    return;
-                // If no arguments are provided in the invoke data (because optional field), we use our type as replacement
-                if (commandFields === undefined) {
-                    commandFields = TlvNoArguments.encodeTlv(commandFields);
+                for (const { command, path } of commands) {
+                    const { endpointId } = path;
+                    if (endpointId === undefined) {
+                        // Should never happen
+                        logger.error(`Invoke from ${exchange.channel.name}: ${this.endpointStructure.resolveCommandName(path)} invalid path because empty endpoint!`);
+                        invokeResponses.push({
+                            status: { commandPath: path, status: { status: 127 /* StatusCode.UnsupportedEndpoint */ } },
+                        });
+                        continue;
+                    }
+                    const endpoint = this.endpointStructure.getEndpoint(endpointId);
+                    if (endpoint === undefined) {
+                        // Should never happen
+                        logger.error(`Invoke from ${exchange.channel.name}: ${this.endpointStructure.resolveCommandName(path)} invalid path because endpoint not found!`);
+                        invokeResponses.push({
+                            status: { commandPath: path, status: { status: 127 /* StatusCode.UnsupportedEndpoint */ } },
+                        });
+                        continue;
+                    }
+                    const result = yield tryCatchAsync(() => __awaiter(this, void 0, void 0, function* () {
+                        return yield command.invoke(exchange.session, commandFields !== null && commandFields !== void 0 ? commandFields : TlvNoArguments.encodeTlv(commandFields), message, endpoint);
+                    }), StatusResponseError, (error) => __awaiter(this, void 0, void 0, function* () {
+                        return ({
+                            code: error.code,
+                            responseId: command.responseId,
+                            response: TlvNoResponse.encodeTlv(),
+                        });
+                    }));
+                    const { code, responseId, response } = result;
+                    if (response.length === 0) {
+                        invokeResponses.push({ status: { commandPath: path, status: { status: code } } });
+                    }
+                    else {
+                        invokeResponses.push({
+                            command: {
+                                commandPath: Object.assign(Object.assign({}, path), { commandId: responseId }),
+                                commandFields: response,
+                            },
+                        });
+                    }
                 }
-                const result = yield command.invoke(exchange.session, commandFields, message);
-                results.push(Object.assign(Object.assign({}, result), { commandPath }));
             })));
             return {
                 suppressResponse: false,
                 interactionModelRevision: 1,
-                invokeResponses: results.map(({ commandPath, responseId, code, response }) => {
-                    if (response.length === 0) {
-                        return { status: { commandPath, status: { status: code } } };
-                    }
-                    else {
-                        return { command: { commandPath: Object.assign(Object.assign({}, commandPath), { commandId: responseId }), commandFields: response } };
-                    }
-                }),
+                invokeResponses,
             };
         });
     }
     handleTimedRequest(exchange, { timeout }) {
-        logger.debug(`Received timed request (${timeout}) from ${exchange.channel.getName()}`);
+        logger.debug(`Received timed request (${timeout}) from ${exchange.channel.name}`);
         // TODO: implement this
     }
-    resolveAttributeName({ endpointId, clusterId, attributeId }) {
-        var _a;
-        if (endpointId === undefined) {
-            return `*/${toHex(clusterId)}/${toHex(attributeId)}`;
-        }
-        const endpoint = this.endpoints.get(endpointId);
-        if (endpoint === undefined) {
-            return `unknown(${toHex(endpointId)})/${toHex(clusterId)}/${toHex(attributeId)}`;
-        }
-        const endpointName = `${endpoint.name}(${toHex(endpointId)})`;
-        if (clusterId === undefined) {
-            return `${endpointName}/*/${toHex(attributeId)}`;
-        }
-        const cluster = endpoint.clusters.get(clusterId);
-        if (cluster === undefined) {
-            return `${endpointName}/unknown(${toHex(clusterId)})/${toHex(attributeId)}`;
-        }
-        const clusterName = `${cluster.name}(${toHex(clusterId)})`;
-        if (attributeId === undefined) {
-            return `${endpointName}/${clusterName}/*`;
-        }
-        const attribute = this.attributes.get(attributePathToId({ endpointId, clusterId, attributeId }));
-        const attributeName = `${(_a = attribute === null || attribute === void 0 ? void 0 : attribute.name) !== null && _a !== void 0 ? _a : "unknown"}(${toHex(attributeId)})`;
-        return `${endpointName}/${clusterName}/${attributeName}`;
-    }
-    getAttributes(filters, onlyWritable = false) {
-        const result = new Array();
-        filters.forEach(({ endpointId, clusterId, attributeId }) => {
-            if (endpointId !== undefined && clusterId !== undefined && attributeId !== undefined) {
-                const path = { endpointId, clusterId, attributeId };
-                const attribute = this.attributes.get(attributePathToId(path));
-                if (attribute === undefined)
-                    return;
-                if (onlyWritable && !attribute.isWritable)
-                    return;
-                result.push({ path, attribute });
-            }
-            else {
-                this.attributePaths.filter(path => (endpointId === undefined || endpointId === path.endpointId)
-                    && (clusterId === undefined || clusterId === path.clusterId)
-                    && (attributeId === undefined || attributeId === path.attributeId))
-                    .forEach(path => {
-                    const attribute = this.attributes.get(attributePathToId(path));
-                    if (attribute === undefined)
-                        return;
-                    if (onlyWritable && !attribute.isWritable)
-                        return;
-                    result.push({ path, attribute });
-                });
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.isClosing = true;
+            for (const subscription of this.subscriptionMap.values()) {
+                yield subscription.cancel(true);
             }
         });
-        return result;
     }
 }
+//# sourceMappingURL=InteractionServer.js.map