Skip to content

armgit / core

Public Imported from GitHub
0

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

Fix: Multiple rule engine fires can occur at the same time (#1957)

Eric Bariauxc2536956cd16
diff --git a/manager/src/main/java/org/openremote/manager/rules/RulesEngine.java b/manager/src/main/java/org/openremote/manager/rules/RulesEngine.java
index f8e95eb73..ad4c832f9 100644
--- a/manager/src/main/java/org/openremote/manager/rules/RulesEngine.java
+++ b/manager/src/main/java/org/openremote/manager/rules/RulesEngine.java
@@ -424,12 +424,12 @@ public class RulesEngine<T extends Ruleset> {
LOG.finest("Scheduling rules firing in " + fireTimeMillis + "ms");
fireTimer = scheduledExecutorService.schedule(
() -> {
- fireTimer = null;
if (!running) {
return;
}
// Process rules for all deployments
fireAllDeployments();
+ fireTimer = null;
scheduleFire(false);
},
fireTimeMillis,
diff --git a/test/src/test/groovy/org/openremote/test/rules/RulesEngineFiringTest.groovy b/test/src/test/groovy/org/openremote/test/rules/RulesEngineFiringTest.groovy
new file mode 100644
index 000000000..5c82855f6
--- /dev/null
+++ b/test/src/test/groovy/org/openremote/test/rules/RulesEngineFiringTest.groovy
@@ -0,0 +1,98 @@
+package org.openremote.test.rules
+
+import jakarta.persistence.EntityManager
+import org.openremote.manager.asset.AssetProcessingService
+import org.openremote.manager.asset.AssetStorageService
+import org.openremote.manager.rules.RulesEngine
+import org.openremote.manager.rules.RulesService
+import org.openremote.manager.rules.RulesetStorageService
+import org.openremote.model.Constants
+import org.openremote.model.asset.impl.ThingAsset
+import org.openremote.model.attribute.Attribute
+import org.openremote.model.attribute.AttributeEvent
+import org.openremote.model.attribute.MetaItem
+import org.openremote.model.rules.RealmRuleset
+import org.openremote.model.rules.Ruleset
+import org.openremote.model.util.UniqueIdentifierGenerator
+import org.openremote.model.value.MetaItemType
+import org.openremote.model.value.ValueType
+import org.openremote.test.ManagerContainerTrait
+import spock.lang.Specification
+import spock.util.concurrent.PollingConditions
+
+import java.util.concurrent.atomic.AtomicBoolean
+
+import static org.openremote.model.rules.Ruleset.Lang.GROOVY
+
+class RulesEngineFiringTest extends Specification implements ManagerContainerTrait {
+
+ /*
+ * See https://github.com/openremote/openremote/issues/1953
+ * When rules evaluation takes longer than the firing period AND an attribute event occurs during that time,
+ * the rules engine would fire even if rules where still being evaluated.
+ */
+ @SuppressWarnings("GroovyAccessibility")
+ def "Check rules engine are not running in parallel"() {
+ given: "the container is started"
+ def conditions = new PollingConditions(timeout: 10, delay: 0.2)
+ def container = startContainer(defaultConfig(), defaultServices())
+ def rulesService = container.getService(RulesService.class)
+ def assetStorageService = container.getService(AssetStorageService.class)
+ def assetProcessingService = container.getService(AssetProcessingService.class)
+ def rulesetStorageService = container.getService(RulesetStorageService.class)
+ RulesEngine engine = null
+
+ and: "some rulesets with a long running rule"
+ Ruleset ruleset = new RealmRuleset(
+ Constants.MASTER_REALM,
+ "Parallel Engine check rules",
+ GROOVY,
+ getClass().getResource("/org/openremote/test/rules/ParallelEngineCheck.groovy").text)
+ Long masterRulesetId = rulesetStorageService.merge(ruleset).id
+
+ and: "assets are added"
+ def counterAsset = new ThingAsset("CounterAsset")
+ .setId(UniqueIdentifierGenerator.generateId("CounterAsset"))
+ .setRealm(Constants.MASTER_REALM)
+ .addAttributes(
+ new Attribute<>("count", ValueType.INTEGER, null).addMeta(new MetaItem<>(MetaItemType.RULE_STATE)),
+ )
+ counterAsset = assetStorageService.merge(counterAsset)
+
+ expect: "the rule engines to become available and be running"
+ conditions.eventually {
+ engine = rulesService.realmEngines.get(Constants.MASTER_REALM)
+ assert engine != null
+ assert engine.isRunning()
+ }
+
+ when: "a mock rules engine is created"
+ // We want to stop rules evaluation while doing this setup, otherwise our count of attribute event change is biased
+ rulesService.stop(container)
+ RulesEngine mockRulesEngine = Spy(engine)
+ AtomicBoolean rulesExecuting = new AtomicBoolean(false)
+ AtomicBoolean parallelExecutionOccurred = new AtomicBoolean(false)
+ mockRulesEngine.fireAllDeployments() >> {
+ if (rulesExecuting.getAndSet(true)) {
+ parallelExecutionOccurred.set(true)
+ }
+ callRealMethod()
+ rulesExecuting.set(false)
+ }
+ rulesService.realmEngines.put(Constants.MASTER_REALM, mockRulesEngine)
+ rulesService.start(container)
+
+ and: "An attribute has changed value"
+ def receivedEvents = new ArrayList<AttributeEvent>()
+ assetProcessingService.addEventInterceptor { EntityManager em, AttributeEvent event ->
+ receivedEvents.add(event)
+ false
+ }
+
+ then: "A new attribute event is sent"
+ conditions.eventually {
+ assert receivedEvents.size() == 4
+ }
+ assert !parallelExecutionOccurred.get(): "Rules engine triggered while rules are still executing"
+ }
+}
diff --git a/test/src/test/resources/org/openremote/test/rules/ParallelEngineCheck.groovy b/test/src/test/resources/org/openremote/test/rules/ParallelEngineCheck.groovy
new file mode 100644
index 000000000..7023554c4
--- /dev/null
+++ b/test/src/test/resources/org/openremote/test/rules/ParallelEngineCheck.groovy
@@ -0,0 +1,28 @@
+package org.openremote.setup.integration.rules
+
+import org.openremote.manager.rules.RulesBuilder
+import org.openremote.model.attribute.AttributeEvent
+import org.openremote.model.query.AssetQuery
+import org.openremote.model.rules.Assets
+
+RulesBuilder rules = binding.rules
+Assets assets = binding.assets
+
+rules.add()
+ .name("Long running rule")
+ .when(
+ {facts ->
+ List<AttributeEvent> updates = Collections.synchronizedList(new ArrayList<>())
+ facts.matchFirstAssetState(new AssetQuery().names("CounterAsset")).ifPresent { attr ->
+ updates.add(new AttributeEvent(attr.id, attr.name, attr.value.orElse(0) + 1))
+ }
+ facts.bind("updates", updates)
+ return true
+ })
+ .then(
+ { facts ->
+ def updates = facts.bound("updates") as List<AttributeEvent>
+ updates.forEach { event ->
+ assets.dispatch(event) }
+ Thread.sleep(600)
+ })