Merge pull request #1214 from JKRhb/coap-observe

relu91 · web-flow · commit 6901b5a4a65a · 2024-01-14T18:53:35.000+01:00
fix(coap-server): add missing cov:observe subprotocol
diff --git a/packages/binding-coap/src/coap-server.ts b/packages/binding-coap/src/coap-server.ts
@@ -32,14 +32,17 @@ import { Server, createServer, registerFormat, IncomingMessage, OutgoingMessage
 import slugify from "slugify";
 import { Readable } from "stream";
 import { MdnsIntroducer } from "./mdns-introducer";
-import { PropertyElement, DataSchema } from "wot-thing-description-types";
+import { PropertyElement, DataSchema, ActionElement, EventElement } from "wot-thing-description-types";
 import { CoapServerConfig } from "./coap";
 import { DataSchemaValue } from "wot-typescript-definitions";
+import { filterPropertyObserveOperations, getPropertyOpValues } from "./util";
 
 const { debug, warn, info, error } = createLoggers("binding-coap", "coap-server");
 
 type CoreLinkFormatParameters = Map<string, string[] | number[]>;
 
+type AffordanceElement = PropertyElement | ActionElement | EventElement;
+
 // TODO: Move to core?
 type AugmentedInteractionOptions = WoT.InteractionOptions & { formIndex: number };
 
@@ -228,21 +231,45 @@ export default class CoapServer implements ProtocolServer {
         return opValues;
     }
 
+    private addFormToAffordance(form: TD.Form, affordance: AffordanceElement): void {
+        const affordanceForms = affordance.forms;
+        if (affordanceForms == null) {
+            affordance.forms = [form];
+        } else {
+            affordanceForms.push(form);
+        }
+    }
+
     private fillInPropertyBindingData(thing: ExposedThing, base: string, offeredMediaType: string) {
         for (const [propertyName, property] of Object.entries(thing.properties)) {
-            const opValues = ProtocolHelpers.getPropertyOpValues(property);
-            const form = this.createAffordanceForm(
-                base,
-                this.PROPERTY_DIR,
-                offeredMediaType,
-                opValues,
-                thing.uriVariables,
-                propertyName,
-                property.uriVariables
-            );
+            const [readWriteOpValues, observeOpValues] = getPropertyOpValues(property);
+            for (const formOpValues of [observeOpValues, readWriteOpValues]) {
+                if (formOpValues.length === 0) {
+                    continue;
+                }
+
+                let subprotocol: string | undefined;
+
+                const observeOpValues = filterPropertyObserveOperations(formOpValues);
+
+                if (observeOpValues.length > 0) {
+                    subprotocol = "cov:observe";
+                }
+
+                const form = this.createAffordanceForm(
+                    base,
+                    this.PROPERTY_DIR,
+                    offeredMediaType,
+                    formOpValues,
+                    thing.uriVariables,
+                    propertyName,
+                    property.uriVariables,
+                    subprotocol
+                );
 
-            property.forms.push(form);
-            this.logHrefAssignment(form, "Property", propertyName);
+                this.addFormToAffordance(form, property);
+                this.logHrefAssignment(form, "Property", propertyName);
+            }
         }
     }
 
@@ -258,7 +285,7 @@ export default class CoapServer implements ProtocolServer {
                 action.uriVariables
             );
 
-            action.forms.push(form);
+            this.addFormToAffordance(form, action);
             this.logHrefAssignment(form, "Action", actionName);
         }
     }
@@ -272,10 +299,11 @@ export default class CoapServer implements ProtocolServer {
                 ["subscribeevent", "unsubscribeevent"],
                 thing.uriVariables,
                 eventName,
-                event.uriVariables
+                event.uriVariables,
+                "cov:observe"
             );
 
-            event.forms.push(form);
+            this.addFormToAffordance(form, event);
             this.logHrefAssignment(form, "Event", eventName);
         }
     }
@@ -287,7 +315,8 @@ export default class CoapServer implements ProtocolServer {
         opValues: string | string[],
         thingUriVariables: PropertyElement["uriVariables"],
         affordanceName?: string,
-        affordanceUriVariables?: PropertyElement["uriVariables"]
+        affordanceUriVariables?: PropertyElement["uriVariables"],
+        subprotocol?: string
     ): TD.Form {
         const affordanceNamePattern = Helpers.updateInteractionNameWithUriVariablePattern(
             affordanceName ?? "",
@@ -303,6 +332,7 @@ export default class CoapServer implements ProtocolServer {
 
         const form = new TD.Form(href, offeredMediaType);
         form.op = opValues;
+        form.subprotocol = subprotocol;
 
         return form;
     }
diff --git a/packages/binding-coap/src/util.ts b/packages/binding-coap/src/util.ts
@@ -0,0 +1,81 @@
+/********************************************************************************
+ * Copyright (c) 2018 Contributors to the Eclipse Foundation
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information regarding copyright ownership.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0, or the W3C Software Notice and
+ * Document License (2015-05-13) which is available at
+ * https://www.w3.org/Consortium/Legal/2015/copyright-software-and-document.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR W3C-20150513
+ ********************************************************************************/
+
+import { ProtocolHelpers } from "@node-wot/core";
+import { PropertyElement } from "wot-thing-description-types";
+
+const observeOpFilter = ["observeproperty", "unobserveproperty"];
+const readWriteOpFilter = ["readproperty", "writeproperty"];
+const eventOpFilter = ["subscribeevent", "unsubscribeevent"];
+
+function filterOpValues(opValues: string[], filterValues: string[]) {
+    return opValues.filter((opValue) => filterValues.includes(opValue));
+}
+
+/**
+ * Convenience function to filter out the `op` values "observeproperty" and
+ * "unobserveproperty" from a string array.
+ *
+ * @param opValues The `op` values to be filtered.
+ * @returns A filtered array that might be empty.
+ */
+export function filterPropertyObserveOperations(opValues: string[]) {
+    return filterOpValues(opValues, observeOpFilter);
+}
+
+/**
+ * Convenience function to filter out the `op` values "readproperty" and
+ * "writeproperty" from a string array.
+ *
+ * @param opValues The `op` values to be filtered.
+ * @returns A filtered array that might be empty.
+ */
+export function filterPropertyReadWriteOperations(opValues: string[]) {
+    return filterOpValues(opValues, readWriteOpFilter);
+}
+
+/**
+ * Convenience function to filter out the `op` values "subscribeevent" and
+ * "unsubscribeevent" from a string array.
+ *
+ * @param opValues The `op` values to be filtered.
+ * @returns A filtered array that might be empty.
+ */
+export function filterEventOperations(opValues: string[]) {
+    return filterOpValues(opValues, eventOpFilter);
+}
+
+/**
+ * Function to (potentially) generate two arrays of `op` values: One with the
+ * values "readproperty" and "writeproperty", and one with
+ * "observerproperty" and "unobserveproperty".
+ *
+ * This CoAP-specific distinction is made to be able to generate
+ * separate forms for the observe-related operations, where the addition
+ * of a `subprotocol` field with a value of `cov:observe` has to be added.
+ *
+ * @param property The property for which the forms are going to be
+ *                 generated.
+ * @returns A tuple consisting of two op value arrays (one for read and
+ *          write operations, one for observe-related operations).
+ */
+export function getPropertyOpValues(property: PropertyElement) {
+    const opValues = ProtocolHelpers.getPropertyOpValues(property);
+
+    const readWriteOpValues = filterPropertyReadWriteOperations(opValues);
+    const observeOpValues = filterPropertyObserveOperations(opValues);
+
+    return [readWriteOpValues, observeOpValues];
+}
diff --git a/packages/binding-coap/test/coap-server-test.ts b/packages/binding-coap/test/coap-server-test.ts
@@ -20,12 +20,13 @@ import Servient, { ExposedThing, Content } from "@node-wot/core";
 
 import { suite, test } from "@testdeck/mocha";
 import { expect, should } from "chai";
-import { DataSchemaValue, InteractionInput, InteractionOptions } from "wot-typescript-definitions";
+import { DataSchemaValue, InteractionInput, InteractionOptions, ThingDescription } from "wot-typescript-definitions";
 import * as TD from "@node-wot/td-tools";
 import CoapServer from "../src/coap-server";
 import { CoapClient } from "../src/coap";
 import { Readable } from "stream";
 import { IncomingMessage, registerFormat, request } from "coap";
+import { filterEventOperations, filterPropertyObserveOperations, filterPropertyReadWriteOperations } from "../src/util";
 
 // should must be called to augment all variables
 should();
@@ -634,4 +635,91 @@ class CoapServerTest {
 
         await coapServer.stop();
     }
+
+    @test async "should add the cov:observe subprotocol value to obervable properties and events "() {
+        const coapServer = new CoapServer({ port: 5683 });
+        const servient = new Servient();
+        servient.addServer(coapServer);
+
+        await coapServer.start(servient);
+
+        const covObserveThing = new ExposedThing(servient, {
+            title: "Test",
+            properties: {
+                observableProperty: {
+                    observable: true,
+                },
+                nonObservableProperty: {},
+            },
+            events: {
+                testEvent: {},
+            },
+        });
+
+        await coapServer.expose(covObserveThing);
+
+        await new Promise<void>((resolve) => {
+            const req = request({
+                host: "localhost",
+                pathname: "test",
+                port: 5683,
+                method: "GET",
+            });
+            req.on("response", (res: IncomingMessage) => {
+                const payload = res.payload.toString();
+                const td = JSON.parse(payload) as ThingDescription;
+
+                for (const property of Object.values(td.properties!)) {
+                    let observeOpValueFormCount = 0;
+                    for (const form of property.forms) {
+                        const opValues = form.op!;
+                        expect(opValues.length).to.be.greaterThan(0);
+
+                        const observeOpValueCount = filterPropertyObserveOperations(opValues as Array<string>).length;
+                        const observeOpValuePresent = observeOpValueCount > 0;
+
+                        if (observeOpValuePresent) {
+                            observeOpValueFormCount++;
+                            expect(form.subprotocol).to.eql("cov:observe");
+                        }
+
+                        const readWriteOpValueCount = filterPropertyReadWriteOperations(
+                            opValues as Array<string>
+                        ).length;
+                        const readWriteOpValuePresent = readWriteOpValueCount > 0;
+
+                        // eslint-disable-next-line no-unused-expressions
+                        expect(observeOpValuePresent && readWriteOpValuePresent).to.not.be.true;
+
+                        if (property.observable !== true) {
+                            expect(observeOpValueCount).to.eql(0);
+                        }
+                    }
+
+                    if (property.observable === true) {
+                        expect(observeOpValueFormCount).to.be.greaterThan(0);
+                    }
+                }
+
+                for (const event of Object.values(td.events!)) {
+                    for (const form of event.forms) {
+                        const opValues = form.op!;
+                        expect(opValues.length > 0);
+
+                        const eventOpValueCount = filterEventOperations(opValues as Array<string>).length;
+                        const eventOpValueCountPresent = eventOpValueCount > 0;
+
+                        expect(eventOpValueCountPresent);
+
+                        expect(form.subprotocol === "cov:observe");
+                    }
+                }
+
+                resolve();
+            });
+            req.end();
+        });
+
+        await coapServer.stop();
+    }
 }
