RuleEngineImpl: Implement compilation of rules on start-up and when activating a rule

Signed-off-by: Florian Hotze <[email protected]>

Author: florian-h05

bundles/org.openhab.core.automation/src/main/java/org/openhab/core/automation/internal/RuleEngineImpl.java

@@ -110,6 +110,7 @@
  * @author Benedikt Niehues - change behavior for unregistering ModuleHandler
  * @author Markus Rathgeb - use a managed rule
  * @author Ana Dimova - new reference syntax: list[index], map["key"], bean.field
+ * @author Florian Hotze - add support for script condition/action compilation
  */
 @Component(immediate = true, service = { RuleManager.class })
 @NonNullByDefault
@@ -819,6 +820,8 @@ public synchronized void setEnabled(String uid, boolean enable) {
      * <ul>
      * <li>Set the module handlers. If there are errors, set the rule status (handler error) and return with error
      * indication.
+     * <li>Compile the conditions and actions. If there are errors, set the rule status (handler error) and return with
+     * indication.
      * <li>Register the rule. Set the rule status and return with success indication.
      * </ul>
      *
@@ -845,6 +848,11 @@ private boolean activateRule(final WrappedRule rule) {
             return false;
         }
 
+        // Compile the conditions and actions and so check if they are valid.
+        if (!compileRule(rule)) {
+            return false;
+        }
+
         // Register the rule and set idle status.
         register(rule);
         setStatus(ruleUID, new RuleStatusInfo(RuleStatus.IDLE));
@@ -862,6 +870,58 @@ private boolean activateRule(final WrappedRule rule) {
         return true;
     }
 
+    /**
+     * Compile the conditions and actions of the given rule.
+     * If there are errors, set the rule status (handler error) and return with indication.
+     *
+     * @param rule the rule whose conditions and actions should be compiled
+     * @return true if compilation succeeded, otherwise false
+     */
+    private boolean compileRule(final WrappedRule rule) {
+        try {
+            compileConditions(rule);
+            compileActions(rule);
+            return true;
+        } catch (Throwable t) {
+            setStatus(rule.getUID(), new RuleStatusInfo(RuleStatus.UNINITIALIZED,
+                    RuleStatusDetail.HANDLER_INITIALIZING_ERROR, t.getMessage()));
+            unregister(rule);
+            return false;
+        }
+    }
+
+    /**
+     * Compile the conditions and actions of the given rule.
+     * If there are errors, set the rule status (handler error).
+     *
+     * @param ruleUID the UID of the rule whose conditions and actions should be compiled
+     */
+    private void compileRule(String ruleUID) {
+        final WrappedRule rule = getManagedRule(ruleUID);
+        if (rule == null) {
+            logger.warn("Failed to compile rule '{}': Invalid Rule UID", ruleUID);
+            return;
+        }
+        synchronized (this) {
+            final RuleStatus ruleStatus = getRuleStatus(ruleUID);
+            if (ruleStatus != null && ruleStatus != RuleStatus.IDLE) {
+                logger.error("Failed to compile rule ‘{}' with status '{}'", ruleUID, ruleStatus.name());
+                return;
+            }
+            // change state to INITIALIZING
+            setStatus(ruleUID, new RuleStatusInfo(RuleStatus.INITIALIZING));
+        }
+        if (!compileRule(rule)) {
+            return;
+        }
+        // change state to IDLE only if the rule has not been DISABLED.
+        synchronized (this) {
+            if (getRuleStatus(ruleUID) == RuleStatus.INITIALIZING) {
+                setStatus(ruleUID, new RuleStatusInfo(RuleStatus.IDLE));
+            }
+        }
+    }
+
     @Override
     public @Nullable RuleStatusInfo getStatusInfo(String ruleUID) {
         final WrappedRule rule = managedRules.get(ruleUID);
@@ -1134,6 +1194,32 @@ private Map<String, Object> getContext(String ruleUID, @Nullable Set<Connection>
         return context;
     }
 
+    /**
+     * This method compiles conditions of the {@link Rule} when they exist.
+     * It is called when the rule is initialized.
+     *
+     * @param rule compiled rule.
+     */
+    private void compileConditions(WrappedRule rule) {
+        final Collection<WrappedCondition> conditions = rule.getConditions();
+        if (conditions.isEmpty()) {
+            return;
+        }
+        for (WrappedCondition wrappedCondition : conditions) {
+            final Condition condition = wrappedCondition.unwrap();
+            ConditionHandler cHandler = wrappedCondition.getModuleHandler();
+            if (cHandler != null) {
+                try {
+                    cHandler.compile();
+                } catch (Throwable t) {
+                    String errMessage = "Failed to pre-compile condition: " + condition.getId() + "(" + t.getMessage()
+                            + ")";
+                    throw new RuntimeException(errMessage, t);
+                }
+            }
+        }
+    }
+
     /**
      * This method checks if all rule's condition are satisfied or not.
      *
@@ -1163,6 +1249,31 @@ private boolean calculateConditions(WrappedRule rule) {
         return true;
     }
 
+    /**
+     * This method compiles actions of the {@link Rule} when they exist.
+     * It is called when the rule is initialized.
+     *
+     * @param rule compiled rule.
+     */
+    private void compileActions(WrappedRule rule) {
+        final Collection<WrappedAction> actions = rule.getActions();
+        if (actions.isEmpty()) {
+            return;
+        }
+        for (WrappedAction wrappedAction : actions) {
+            final Action action = wrappedAction.unwrap();
+            ActionHandler aHandler = wrappedAction.getModuleHandler();
+            if (aHandler != null) {
+                try {
+                    aHandler.compile();
+                } catch (Throwable t) {
+                    String errMessage = "Failed to pre-compile action: " + action.getId() + "(" + t.getMessage() + ")";
+                    throw new RuntimeException(errMessage, t);
+                }
+            }
+        }
+    }
+
     /**
      * This method evaluates actions of the {@link Rule} and set their {@link Output}s when they exist.
      *
@@ -1435,14 +1546,28 @@ public String getOutputName() {
 
     @Override
     public void onReadyMarkerAdded(ReadyMarker readyMarker) {
-        executeRulesWithStartLevel();
+        compileRules();
     }
 
     @Override
     public void onReadyMarkerRemoved(ReadyMarker readyMarker) {
         started = false;
     }
 
+    /**
+     * This method compiles the conditions and actions of all rules. It is called when the rule engine is started.
+     * By compiling when the rule engine is started, we make sure all conditions and actions are compiled, even if their
+     * handlers weren't available when the rule was added to the rule engine.
+     */
+    private void compileRules() {
+        getScheduledExecutor().submit(() -> {
+            ruleRegistry.getAll().forEach(r -> {
+                compileRule(r.getUID());
+            });
+            executeRulesWithStartLevel();
+        });
+    }
+
     private void executeRulesWithStartLevel() {
         getScheduledExecutor().submit(() -> {
             ruleRegistry.getAll().stream() //