100% open-source IoT Platform - Integrate your devices, add intelligence, build custom apps
Java asset-managementbuildingdashboarddataplatformdevice-managementedge-computingenergyenergy-managementenergy-monitorfleet-managementfleet-telematicsiotiot-applicationiot-platformmodbusmqttmqtt-brokerota-updaterules-enginesmartcity
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.javaindex 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.javaindex 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.groovyindex 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.RulesEngineimport org.openremote.manager.rules.RulesFactsimport org.openremote.manager.rules.RulesLoopExceptionimport 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.realmBuildingrealmBuilding.setEnabled(false)identityService.getIdentityProvider().updateRealm(realmBuilding)@@ -250,55 +251,27 @@ class BasicRulesDeploymentTest extends Specification implements ManagerContainerassert !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) == nullassert !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.groovynew file mode 100644index 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.groovyindex 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.Ignoreimport org.openremote.manager.rules.*import org.openremote.manager.setup.SetupServiceimport org.openremote.test.setup.ManagerTestSetup@@ -122,41 +123,42 @@ class RulesExecutionFailureTest extends Specification implements ManagerContaineTemporaryFact.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.groovynew file mode 100644index 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)+ }+ }+ })