Skip to content

armgit / core

Public Imported from GitHub
0

100% open-source IoT Platform - Integrate your devices, add intelligence, build custom apps

Fix batch dispatch of multiple attribute events to the same asset (#3477)

Eric Bariaux78a8d8aeab69
diff --git a/manager/build.gradle b/manager/build.gradle
index 4c3d6d3d2..7ae6cc236 100644
--- a/manager/build.gradle
+++ b/manager/build.gradle
@@ -79,7 +79,7 @@ dependencies {
sourceSets {
test {
- groovy.srcDirs = ['test/src/groovy']
+ groovy.srcDirs = ['src/test/groovy', 'test/src/groovy']
}
}
diff --git a/manager/src/main/java/org/openremote/manager/rules/facade/AssetsFacade.java b/manager/src/main/java/org/openremote/manager/rules/facade/AssetsFacade.java
index 04c7cb842..848399e92 100644
--- a/manager/src/main/java/org/openremote/manager/rules/facade/AssetsFacade.java
+++ b/manager/src/main/java/org/openremote/manager/rules/facade/AssetsFacade.java
@@ -107,8 +107,9 @@ public class AssetsFacade<T extends Ruleset> extends Assets {
public AssetsFacade<T> dispatch(AttributeEvent... events) {
if (events == null || events.length == 0) return this;
- // Check if the asset ID of every event can be found with the default security of this facade
- String[] ids = Arrays.stream(events).map(AttributeEvent::getId).toArray(String[]::new);
+ // Validate each distinct target asset while retaining every event for dispatch below.
+ String[] ids =
+ Arrays.stream(events).map(AttributeEvent::getId).distinct().toArray(String[]::new);
AssetQuery query = new AssetQuery().ids(ids);
long count = this.getResults(query).count();
diff --git a/manager/src/test/groovy/org/openremote/manager/rules/facade/AssetsFacadeTest.groovy b/manager/src/test/groovy/org/openremote/manager/rules/facade/AssetsFacadeTest.groovy
new file mode 100644
index 000000000..b1c3055a9
--- /dev/null
+++ b/manager/src/test/groovy/org/openremote/manager/rules/facade/AssetsFacadeTest.groovy
@@ -0,0 +1,149 @@
+/*
+ * Copyright 2026, OpenRemote Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+package org.openremote.manager.rules.facade
+
+import org.openremote.manager.asset.AssetStorageService
+import org.openremote.manager.rules.RulesEngineId
+import org.openremote.model.asset.impl.ThingAsset
+import org.openremote.model.attribute.AttributeEvent
+import org.openremote.model.query.AssetQuery
+import org.openremote.model.query.filter.PathPredicate
+import spock.lang.Specification
+
+class AssetsFacadeTest extends Specification {
+
+ def "#scope scope dispatches every event in order for #batchCase"() {
+ given: "two assets accessible to the rule engine"
+ def root = Stub(ThingAsset) {
+ getId() >> "root"
+ getPath() >> (["root"] as String[])
+ }
+ def child = Stub(ThingAsset) {
+ getId() >> "child"
+ }
+ def availableAssets = [root, child]
+ List<AssetQuery> queries = []
+ List<PathPredicate> requiredPaths = []
+ def lookup = { AssetQuery query, PathPredicate requiredPath ->
+ queries.add(query)
+ requiredPaths.add(requiredPath)
+ // An asset-ID query returns each matching asset once, even for repeated IDs.
+ availableAssets.findAll { query.ids.contains(it.id) }
+ }
+ def storage = Stub(AssetStorageService) {
+ find("root", true) >> root
+ findAll(_ as AssetQuery) >> { AssetQuery query -> lookup(query, null) }
+ findAll(_ as AssetQuery, _ as PathPredicate) >> { AssetQuery query, PathPredicate requiredPath ->
+ lookup(query, requiredPath)
+ }
+ }
+ def engineId = scope == "global" ? new RulesEngineId() :
+ scope == "realm" ? new RulesEngineId("building") : new RulesEngineId("building", "root")
+ List<AttributeEvent> forwarded = []
+ def facade = new AssetsFacade(engineId, storage, { AttributeEvent event ->
+ forwarded.add(event)
+ })
+ def events = targetIds.withIndex().collect { String id, int index ->
+ new AttributeEvent(id, "attribute${index}", index)
+ }
+
+ when: "one call dispatches updates to different attributes on the permitted targets"
+ facade.dispatch(events as AttributeEvent[])
+
+ then: "target lookup retains the engine scope"
+ queries.size() == 1
+ queries[0].ids.toSet() == targetIds.toSet()
+ queries[0].realm?.name == (scope == "global" ? null : "building")
+ queries[0].paths == null
+ requiredPaths.collect { it?.path?.toList() } == [scope == "asset" ? ["root"] : null]
+
+ and: "every original event is forwarded exactly once, in the supplied order"
+ forwarded.size() == events.size()
+ events.indices.every { forwarded[it].is(events[it]) }
+
+ where:
+ [scope, batchCase, targetIds] << ["global", "realm", "asset"].collectMany { scope ->
+ [
+ ["a single event", ["root"]],
+ ["distinct targets", ["root", "child"]],
+ ["two events for one target", ["root", "root"]],
+ ["mixed repeated and distinct targets", ["root", "child", "root"]]
+ ].collect { row -> [scope] + row }
+ }
+ }
+
+ def "#scope scope rejects the whole batch for #rejectedTarget with repeated permitted targets: #repeated"() {
+ given: "the scoped asset lookup excludes a missing or inaccessible target"
+ def root = Stub(ThingAsset) {
+ getId() >> "root"
+ getPath() >> (["root"] as String[])
+ }
+ def child = Stub(ThingAsset) {
+ getId() >> "child"
+ }
+ List<AssetQuery> queries = []
+ List<PathPredicate> requiredPaths = []
+ def lookup = { AssetQuery query, PathPredicate requiredPath ->
+ queries.add(query)
+ requiredPaths.add(requiredPath)
+ // Model a partial result from the scoped lookup: only permitted assets were found.
+ [root, child].findAll { query.ids.contains(it.id) }
+ }
+ def storage = Stub(AssetStorageService) {
+ find("root", true) >> root
+ findAll(_ as AssetQuery) >> { AssetQuery query -> lookup(query, null) }
+ findAll(_ as AssetQuery, _ as PathPredicate) >> { AssetQuery query, PathPredicate requiredPath ->
+ lookup(query, requiredPath)
+ }
+ }
+ def engineId = scope == "global" ? new RulesEngineId() :
+ scope == "realm" ? new RulesEngineId("building") : new RulesEngineId("building", "root")
+ List<AttributeEvent> forwarded = []
+ def facade = new AssetsFacade(engineId, storage, { AttributeEvent event ->
+ forwarded.add(event)
+ })
+ def targetIds = (repeated ? ["root", "child", "root"] : ["root", "child"]) + [rejectedTarget]
+ def events = targetIds.withIndex().collect { String id, int index ->
+ new AttributeEvent(id, "attribute${index}", index)
+ }
+
+ when: "the rejected target is last, after events for permitted assets"
+ facade.dispatch(events as AttributeEvent[])
+
+ then: "the lookup includes every target and retains the engine scope"
+ queries.size() == 1
+ queries[0].ids.toSet() == targetIds.toSet()
+ queries[0].realm?.name == (scope == "global" ? null : "building")
+ queries[0].paths == null
+ requiredPaths.collect { it?.path?.toList() } == [scope == "asset" ? ["root"] : null]
+
+ and: "no events are forwarded, including those for permitted assets"
+ forwarded.empty
+
+ where:
+ [scope, rejectedTarget, repeated] << [
+ ["global", "missing"],
+ ["realm", "missing"],
+ ["realm", "foreign-realm"],
+ ["asset", "missing"],
+ ["asset", "foreign-realm"],
+ ["asset", "outside-subtree"]
+ ].collectMany { row -> [false, true].collect { repeated -> row + [repeated] } }
+ }
+}