Skip to content

armgit / core

Public Imported from GitHub
0

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

Switched rule engine to DefaultEngine instead of InferenceEngine (#767)

Rich Turner0ab9266d8798
diff --git a/manager/src/main/java/org/openremote/manager/rules/RulesBuilder.java b/manager/src/main/java/org/openremote/manager/rules/RulesBuilder.java
index 4d2c6ec33..9561756e6 100644
--- a/manager/src/main/java/org/openremote/manager/rules/RulesBuilder.java
+++ b/manager/src/main/java/org/openremote/manager/rules/RulesBuilder.java
@@ -95,11 +95,16 @@ public class RulesBuilder {
public Rule[] build() {
List<Rule> rules = new ArrayList<>();
+
+ // Maintain rule order by adjusting priority for each rule within the ruleset
+ int priority = 0;
+
for (Builder builder : builders) {
+ priority++;
Rule rule = new RuleBuilder()
.name(builder.name)
.description(builder.description)
- .priority(builder.priority)
+ .priority(priority)
.when(facts -> {
Object result;
try {
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 483c6657b..e118c17f8 100644
--- a/manager/src/main/java/org/openremote/manager/rules/RulesEngine.java
+++ b/manager/src/main/java/org/openremote/manager/rules/RulesEngine.java
@@ -19,25 +19,28 @@
*/
package org.openremote.manager.rules;
+import org.jeasy.rules.api.Facts;
+import org.jeasy.rules.api.Rule;
+import org.jeasy.rules.api.RuleListener;
import org.jeasy.rules.api.RulesEngineParameters;
-import org.jeasy.rules.core.InferenceRulesEngine;
-import org.openremote.model.PersistenceEvent;
+import org.jeasy.rules.core.AbstractRulesEngine;
+import org.jeasy.rules.core.DefaultRulesEngine;
import org.openremote.container.timer.TimerService;
import org.openremote.manager.asset.AssetProcessingService;
import org.openremote.manager.asset.AssetStorageService;
import org.openremote.manager.datapoint.AssetDatapointService;
+import org.openremote.manager.datapoint.AssetPredictedDatapointService;
import org.openremote.manager.event.ClientEventService;
import org.openremote.manager.notification.NotificationService;
-import org.openremote.manager.datapoint.AssetPredictedDatapointService;
import org.openremote.manager.rules.facade.*;
import org.openremote.manager.security.ManagerIdentityService;
+import org.openremote.model.PersistenceEvent;
import org.openremote.model.asset.Asset;
import org.openremote.model.query.filter.GeofencePredicate;
import org.openremote.model.query.filter.LocationAttributePredicate;
import org.openremote.model.rules.*;
import org.openremote.model.syslog.SyslogCategory;
import org.openremote.model.util.TextUtil;
-import org.openremote.model.util.TimeUtil;
import java.util.*;
import java.util.concurrent.ScheduledExecutorService;
@@ -116,7 +119,7 @@ public class RulesEngine<T extends Ruleset> {
final protected Map<Long, RulesetDeployment> deployments = new LinkedHashMap<>();
final protected RulesFacts facts;
- final protected InferenceRulesEngine engine;
+ final protected AbstractRulesEngine engine;
protected boolean running;
protected long lastFireTimestamp;
@@ -157,11 +160,36 @@ public class RulesEngine<T extends Ruleset> {
this.assetLocationPredicatesConsumer = assetLocationPredicatesConsumer;
this.facts = new RulesFacts(timerService, assetStorageService, assetsFacade, this, RULES_LOG);
- engine = new InferenceRulesEngine(
+ engine = new DefaultRulesEngine(
// Skip any other rules after the first failed rule (exception thrown in condition or action)
new RulesEngineParameters(false, true, false, RulesEngineParameters.DEFAULT_RULE_PRIORITY_THRESHOLD)
);
engine.registerRuleListener(facts);
+
+ // Add listener to rethrow runtime exceptions which are otherwise swallowed by the DefaultRulesEngine
+ engine.registerRuleListener(new RuleListener() {
+ @Override
+ public void onEvaluationError(Rule rule, Facts facts, Exception exception) {
+ RuntimeException ex;
+ if (exception instanceof RuntimeException) {
+ ex = (RuntimeException) exception;
+ } else {
+ ex = new RuntimeException(exception);
+ }
+ throw ex;
+ }
+
+ @Override
+ public void onFailure(Rule rule, Facts facts, Exception exception) {
+ RuntimeException ex;
+ if (exception instanceof RuntimeException) {
+ ex = (RuntimeException) exception;
+ } else {
+ ex = new RuntimeException(exception);
+ }
+ throw ex;
+ }
+ });
}
public RulesEngineId<T> getId() {
diff --git a/test/src/test/groovy/org/openremote/test/rules/BasicRulesDeploymentTest.groovy b/test/src/test/groovy/org/openremote/test/rules/BasicRulesDeploymentTest.groovy
index 396ed17e8..de8805b13 100644
--- a/test/src/test/groovy/org/openremote/test/rules/BasicRulesDeploymentTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/rules/BasicRulesDeploymentTest.groovy
@@ -1,5 +1,6 @@
package org.openremote.test.rules
+import org.openremote.manager.rules.RulesEngine
import org.openremote.manager.rules.RulesFacts
import org.openremote.manager.rules.RulesLoopException
import org.openremote.manager.rules.RulesService
@@ -184,8 +185,8 @@ class BasicRulesDeploymentTest extends Specification implements ManagerContainer
}
when: "a realm is disabled"
- def realmBuildingEngine = rulesService.realmEngines.get(keycloakTestSetup.realmBuilding.name)
- def apartment3Engine = rulesService.assetEngines.get(managerTestSetup.apartment3Id)
+ RulesEngine realmBuildingEngine = rulesService.realmEngines.get(keycloakTestSetup.realmBuilding.name)
+ RulesEngine apartment3Engine = rulesService.assetEngines.get(managerTestSetup.apartment3Id)
def realmBuilding = keycloakTestSetup.realmBuilding
realmBuilding.setEnabled(false)
identityService.getIdentityProvider().updateRealm(realmBuilding)
@@ -250,55 +251,27 @@ class BasicRulesDeploymentTest extends Specification implements ManagerContainer
assert !realmBuildingEngine.isError()
}
- when: "a new realm rule definition is added to Building"
- ruleset = new RealmRuleset(
- keycloakTestSetup.realmBuilding.name,
- "Looping error",
- GROOVY,
- getClass().getResource("/org/openremote/test/failure/RulesFailureLoop.groovy").text)
- ruleset.getMeta().add(new MetaItem<>(Ruleset.CONTINUE_ON_ERROR, true))
- ruleset = rulesetStorageService.merge(ruleset)
+ when: "a realm is deleted"
+ identityService.getIdentityProvider().deleteRealm(realmBuilding.getName())
- then: "the realms A rule engine should have an error"
+ then: "the realms rule engine should stop and all asset rule engines in this realm should also stop"
conditions.eventually {
- realmBuildingEngine = rulesService.realmEngines.get(keycloakTestSetup.realmBuilding.name)
- assert realmBuildingEngine != null
+ assert rulesService.realmEngines.get(keycloakTestSetup.realmBuilding.name) == null
assert !realmBuildingEngine.isRunning()
- assert realmBuildingEngine.deployments.size() == 4
- assert realmBuildingEngine.deployments[ruleset.id].status == LOOP_ERROR
- assert realmBuildingEngine.deployments[ruleset.id].error instanceof RulesLoopException
- assert realmBuildingEngine.deployments[ruleset.id].error.message == "Possible rules loop detected, exceeded max trigger count of " + RulesFacts.MAX_RULES_TRIGGERED_PER_EXECUTION + " for rule: Condition loops"
- assert realmBuildingEngine.isError()
- assert realmBuildingEngine.getError() instanceof RuntimeException
+ assert rulesService.assetEngines.get(managerTestSetup.apartment3Id) == null
+ assert !apartment3Engine.isRunning()
}
-//TODO: Reinstate the realm delete test once realm delete mechanism is finalised
-// when: "a realm is deleted"
-// identityService.deleteRealm(accessToken, realmBuilding.getName())
-//
-// then: "the realms rule engine should stop and all asset rule engines in this realm should also stop"
-// conditions.eventually {
-// assert realmBuildingEngine.isRunning() == false
-// assert realmBuildingEngine.allRulesets.length == 0
-// assert rulesService.realmEngines.get(keycloakTestSetup.realmBuildingRealm.id) == null
-// assert smartHomeEngine.isRunning() == false
-// assert smartHomeEngine.allRulesets.length == 0
-// assert rulesService.assetEngines.get(managerTestSetup.smartBuildingId) == null
-// assert apartment3Engine.isRunning() == false
-// assert apartment3Engine.allRulesets.length == 0
-// assert rulesService.assetEngines.get(managerTestSetup.apartment3Id) == null
-// }
-//
-// and: "other rule engines should be unaffected"
-// conditions.eventually {
-// assert rulesService.realmEngines.size() == 2
-// assert rulesService.assetEngines.size() == 0
-// def masterEngine = rulesService.realmEngines.get(Constants.MASTER_REALM)
-// def realmCity = rulesService.realmEngines.get(keycloakTestSetup.realmBRealm.id)
-// assert masterEngine != null
-// assert masterEngine.isRunning()
-// assert realmCity != null
-// assert realmCity.isRunning()
-// }
+ and: "other rule engines should be unaffected"
+ conditions.eventually {
+ assert rulesService.realmEngines.size() == 2
+ assert rulesService.assetEngines.size() == 0
+ def masterEngine = rulesService.realmEngines.get(MASTER_REALM)
+ def realmCity = rulesService.realmEngines.get(keycloakTestSetup.realmCity.name)
+ assert masterEngine != null
+ assert masterEngine.isRunning()
+ assert realmCity != null
+ assert realmCity.isRunning()
+ }
}
}
diff --git a/test/src/test/groovy/org/openremote/test/rules/ChildAssetControlRulesTest.groovy b/test/src/test/groovy/org/openremote/test/rules/ChildAssetControlRulesTest.groovy
new file mode 100644
index 000000000..ac624cbb2
--- /dev/null
+++ b/test/src/test/groovy/org/openremote/test/rules/ChildAssetControlRulesTest.groovy
@@ -0,0 +1,98 @@
+package org.openremote.test.rules
+
+import org.openremote.container.util.UniqueIdentifierGenerator
+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.GroupAsset
+import org.openremote.model.asset.impl.LightAsset
+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.value.MetaItemType
+import org.openremote.test.ManagerContainerTrait
+import spock.lang.Specification
+import spock.util.concurrent.PollingConditions
+
+class ChildAssetControlRulesTest extends Specification implements ManagerContainerTrait {
+
+ def "Child asset control rule test"() {
+
+ given: "the container environment 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: "a light asset and child light assets are added"
+ def parentAsset = new LightAsset("Lights")
+ .setId(UniqueIdentifierGenerator.generateId("GroupAssetLights"))
+ .setRealm(Constants.MASTER_REALM)
+ .addAttributes(
+ new Attribute<?>(LightAsset.ON_OFF).addMeta(new MetaItem<>(MetaItemType.RULE_STATE)),
+ new Attribute<>(LightAsset.BRIGHTNESS).addMeta(new MetaItem<>(MetaItemType.RULE_STATE)),
+ new Attribute<>(LightAsset.COLOUR_RGB).addMeta(new MetaItem<>(MetaItemType.RULE_STATE)),
+ new Attribute<>(LightAsset.COLOUR_TEMPERATURE).addMeta(new MetaItem<>(MetaItemType.RULE_STATE))
+ )
+ parentAsset = assetStorageService.merge(parentAsset)
+
+ for (int i=1; i<=100; i++) {
+ def lightAsset = new LightAsset("Light ${i}")
+ .setId(UniqueIdentifierGenerator.generateId("Light ${i}"))
+ .setParent(parentAsset)
+
+ lightAsset.getAttribute(LightAsset.ON_OFF).ifPresentOrElse(attr -> {attr.addMeta(new MetaItem<>(MetaItemType.RULE_STATE))}, null)
+ lightAsset.getAttribute(LightAsset.BRIGHTNESS).ifPresentOrElse(attr -> {attr.addMeta(new MetaItem<>(MetaItemType.RULE_STATE))}, null)
+ lightAsset.getAttribute(LightAsset.COLOUR_RGB).ifPresentOrElse(attr -> {attr.addMeta(new MetaItem<>(MetaItemType.RULE_STATE))}, null)
+ lightAsset.getAttribute(LightAsset.COLOUR_TEMPERATURE).ifPresentOrElse(attr -> {attr.addMeta(new MetaItem<>(MetaItemType.RULE_STATE))}, null)
+ assetStorageService.merge(lightAsset)
+ }
+
+ and: "the child asset control ruleset is added"
+ Ruleset ruleset = new RealmRuleset(
+ Constants.MASTER_REALM,
+ "Child asset control",
+ Ruleset.Lang.GROOVY,
+ getClass().getResource("/org/openremote/test/rules/ChildAssetControl.groovy").text)
+ ruleset = rulesetStorageService.merge(ruleset)
+
+ 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()
+ assert engine.assetStates.count { it.id == parentAsset.id} == 4
+ assert engine.lastFireTimestamp > ruleset.createdOn.getTime()
+ assert engine.deployments.get(ruleset.id) != null
+ }
+
+ when: "The on/off attribute of the parent asset is written to"
+ assetProcessingService.sendAttributeEvent(
+ new AttributeEvent(parentAsset.id, LightAsset.ON_OFF, true)
+ )
+
+ then: "the parent asset attribute should be updated"
+ conditions.eventually {
+ parentAsset = assetStorageService.find(parentAsset.id, true) as LightAsset
+ assert parentAsset.getAttribute(LightAsset.ON_OFF).flatMap{it.value}.orElse(false)
+ }
+
+ and: "all child lights on/off attributes should now show the same value"
+ conditions.eventually {
+ for (int i=1; i<=100; i++) {
+ def light = assetStorageService.find(UniqueIdentifierGenerator.generateId("Light ${i}"), true) as LightAsset
+ assert light.getOnOff().orElse(false)
+ assert light.getAttribute(LightAsset.ON_OFF).flatMap { it.getTimestamp()}.orElse(0) == parentAsset.getAttribute(LightAsset.ON_OFF).flatMap { it.getTimestamp()}.orElse(-1)
+ }
+ }
+ }
+
+}
diff --git a/test/src/test/groovy/org/openremote/test/rules/RulesExecutionFailureTest.groovy b/test/src/test/groovy/org/openremote/test/rules/RulesExecutionFailureTest.groovy
index ef924a573..0b05a5cda 100644
--- a/test/src/test/groovy/org/openremote/test/rules/RulesExecutionFailureTest.groovy
+++ b/test/src/test/groovy/org/openremote/test/rules/RulesExecutionFailureTest.groovy
@@ -1,5 +1,6 @@
package org.openremote.test.rules
+import org.junit.Ignore
import org.openremote.manager.rules.*
import org.openremote.manager.setup.SetupService
import org.openremote.test.setup.ManagerTestSetup
@@ -122,41 +123,42 @@ class RulesExecutionFailureTest extends Specification implements ManagerContaine
TemporaryFact.GUARANTEED_MIN_EXPIRATION_MILLIS = expirationMillis
}
- def "Rule condition loops"() {
-
- given: "the container environment is started"
- def expirationMillis = TemporaryFact.GUARANTEED_MIN_EXPIRATION_MILLIS
- TemporaryFact.GUARANTEED_MIN_EXPIRATION_MILLIS = 500
- def conditions = new PollingConditions(timeout: 20, delay: 0.2)
- def container = startContainer(defaultConfig(), defaultServices())
- def managerTestSetup = container.getService(SetupService.class).getTaskOfType(ManagerTestSetup.class)
- def rulesService = container.getService(RulesService.class)
- def rulesetStorageService = container.getService(RulesetStorageService.class)
- RulesEngine apartment2Engine
-
- and: "some rules"
- Ruleset ruleset = new AssetRuleset(
- managerTestSetup.apartment2Id,
- "Failure Ruleset",
- Ruleset.Lang.GROOVY,
- getClass().getResource("/org/openremote/test/failure/RulesFailureLoop.groovy").text)
- ruleset.getMeta().addOrReplace(new MetaItem<>(Ruleset.CONTINUE_ON_ERROR, true))
- ruleset = rulesetStorageService.merge(ruleset)
-
- expect: "the rule engine should have an error (first firing after initial asset state insert)"
- conditions.eventually {
- apartment2Engine = rulesService.assetEngines.get(managerTestSetup.apartment2Id)
- assert apartment2Engine != null
- assert apartment2Engine.deployments[ruleset.id].status == RulesetStatus.LOOP_ERROR
- assert apartment2Engine.deployments[ruleset.id].error instanceof RulesLoopException
- assert apartment2Engine.deployments[ruleset.id].error.message == "Possible rules loop detected, exceeded max trigger count of " + RulesFacts.MAX_RULES_TRIGGERED_PER_EXECUTION + " for rule: Condition loops"
- assert apartment2Engine.isError()
- assert apartment2Engine.getError() instanceof RuntimeException
- assert apartment2Engine.getError().message.startsWith("Ruleset deployments have errors, failed compilation: 0, failed execution: 1")
- assert apartment2Engine.facts.triggerCount == 0 // Ensure trigger count is reset after execution
- }
-
- cleanup: "the static rules time variable is reset"
- TemporaryFact.GUARANTEED_MIN_EXPIRATION_MILLIS = expirationMillis
- }
+// Switched rule engine to DefaultEngine rather than InferenceEngine so loops cannot occur now
+// def "Rule condition loops"() {
+//
+// given: "the container environment is started"
+// def expirationMillis = TemporaryFact.GUARANTEED_MIN_EXPIRATION_MILLIS
+// TemporaryFact.GUARANTEED_MIN_EXPIRATION_MILLIS = 500
+// def conditions = new PollingConditions(timeout: 20, delay: 0.2)
+// def container = startContainer(defaultConfig(), defaultServices())
+// def managerTestSetup = container.getService(SetupService.class).getTaskOfType(ManagerTestSetup.class)
+// def rulesService = container.getService(RulesService.class)
+// def rulesetStorageService = container.getService(RulesetStorageService.class)
+// RulesEngine apartment2Engine
+//
+// and: "some rules"
+// Ruleset ruleset = new AssetRuleset(
+// managerTestSetup.apartment2Id,
+// "Failure Ruleset",
+// Ruleset.Lang.GROOVY,
+// getClass().getResource("/org/openremote/test/failure/RulesFailureLoop.groovy").text)
+// ruleset.getMeta().addOrReplace(new MetaItem<>(Ruleset.CONTINUE_ON_ERROR, true))
+// ruleset = rulesetStorageService.merge(ruleset)
+//
+// expect: "the rule engine should have an error (first firing after initial asset state insert)"
+// conditions.eventually {
+// apartment2Engine = rulesService.assetEngines.get(managerTestSetup.apartment2Id)
+// assert apartment2Engine != null
+// assert apartment2Engine.deployments[ruleset.id].status == RulesetStatus.LOOP_ERROR
+// assert apartment2Engine.deployments[ruleset.id].error instanceof RulesLoopException
+// assert apartment2Engine.deployments[ruleset.id].error.message == "Possible rules loop detected, exceeded max trigger count of " + RulesFacts.MAX_RULES_TRIGGERED_PER_EXECUTION + " for rule: Condition loops"
+// assert apartment2Engine.isError()
+// assert apartment2Engine.getError() instanceof RuntimeException
+// assert apartment2Engine.getError().message.startsWith("Ruleset deployments have errors, failed compilation: 0, failed execution: 1")
+// assert apartment2Engine.facts.triggerCount == 0 // Ensure trigger count is reset after execution
+// }
+//
+// cleanup: "the static rules time variable is reset"
+// TemporaryFact.GUARANTEED_MIN_EXPIRATION_MILLIS = expirationMillis
+// }
}
diff --git a/test/src/test/resources/org/openremote/test/rules/ChildAssetControl.groovy b/test/src/test/resources/org/openremote/test/rules/ChildAssetControl.groovy
new file mode 100644
index 000000000..833a2fae1
--- /dev/null
+++ b/test/src/test/resources/org/openremote/test/rules/ChildAssetControl.groovy
@@ -0,0 +1,89 @@
+/*
+* An example rule for writing to child asset attributes by writing to the parent asset attributes; just specify the
+* parent asset ID below. The parent and child attributes must have the RULE_STATE configuration items set.
+*/
+
+package org.openremote.test.rules
+
+import org.openremote.manager.rules.RulesBuilder
+import org.openremote.model.attribute.AttributeEvent
+import org.openremote.model.query.AssetQuery
+import org.openremote.model.rules.AssetState
+import org.openremote.model.rules.Assets
+import org.openremote.model.rules.Notifications
+import org.openremote.model.rules.Users
+
+import java.util.logging.Logger
+
+Logger LOG = binding.LOG
+RulesBuilder rules = binding.rules
+Users users = binding.users
+Notifications notifications = binding.notifications
+Assets assets = binding.assets
+
+// Put the asset ID of the parent whose children should be controlled in here
+String parentAssetId = "3amk07u2gMoRlfzThYfwgT"
+
+rules.add()
+ .name("Control children by controlling attributes on the parent asset itself")
+ .when(
+ { facts ->
+
+ List<AssetState<?>> changes = []
+
+ def childUpdates = facts.matchAssetState(
+ new AssetQuery().ids(parentAssetId)
+ ).filter { state ->
+ def changed = false
+
+ // Get previous state from facts
+ def previous = facts.matchFirst(state.id + state.name) as Optional<AssetState<?>>
+
+ if (previous.isEmpty()) {
+ // Store initial state to avoid triggering on first run
+ changes.add(state)
+ } else if (state.timestamp > previous.map { it.timestamp }.orElse(0)) {
+ // State has been updated (value may be the same but still push this to the children)
+ changed = true
+ changes.add(state)
+ }
+
+ return changed
+ }.flatMap { changedState ->
+ // Create attribute event for each child asset
+ LOG.info("Parent asset attribute changed: " + changedState)
+
+ // Get all child assets, create attribute events and bind these for the then trigger
+ facts.matchAssetState(new AssetQuery().parents(parentAssetId).attributeName(changedState.name))
+ .filter(childState -> childState.type == changedState.type)
+ .map{childState -> new AttributeEvent(childState.id, childState.name, changedState.value, changedState.timestamp)}
+ }.toList()
+
+ if (!changes.isEmpty()) {
+ facts.bind("changes", changes)
+
+ if (!childUpdates.isEmpty()) {
+ facts.bind("updates", childUpdates)
+ LOG.info("Child asset update count: " + childUpdates.size())
+ }
+ }
+
+ // Trigger the rule action if we have one or more changes to process
+ return !changes.isEmpty()
+ })
+ .then(
+ { facts ->
+ def changes = facts.bound("changes") as List<AssetState<?>>
+ def updates = facts.bound("updates") as List<AttributeEvent>
+
+ // Create fact for state of attribute
+ changes.forEach {state ->
+ facts.put(state.id + state.name, state)
+ }
+
+ if (updates != null) {
+ updates.forEach {
+ assets.dispatch(it)
+ }
+ }
+ })