[rules] Add support for pre-compilation of conditions and actions (#4289

)

* ScriptConditionHandler/ScriptActionHandler: Add support for pre-compilation of scripts

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

bundles/org.openhab.core.automation.module.script/src/main/java/org/openhab/core/automation/module/script/internal/handler/AbstractScriptModuleHandler.java

@@ -18,10 +18,14 @@
 import java.util.Optional;
 import java.util.UUID;
 
+import javax.script.Compilable;
+import javax.script.CompiledScript;
 import javax.script.ScriptContext;
 import javax.script.ScriptEngine;
+import javax.script.ScriptException;
 
 import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
 import org.openhab.core.automation.Module;
 import org.openhab.core.automation.handler.BaseModuleHandler;
 import org.openhab.core.automation.module.script.ScriptEngineContainer;
@@ -35,6 +39,7 @@
  *
  * @author Kai Kreuzer - Initial contribution
  * @author Simon Merschjohann - Initial contribution
+ * @author Florian Hotze - Add support for script pre-compilation
  *
  * @param <T> the type of module the concrete handler can handle
  */
@@ -54,6 +59,7 @@ public abstract class AbstractScriptModuleHandler<T extends Module> extends Base
  private final String engineIdentifier;
 
  private Optional<ScriptEngine> scriptEngine = Optional.empty();
+ private Optional<CompiledScript> compiledScript = Optional.empty();
  private final String type;
  protected final String script;
 
@@ -80,6 +86,34 @@ private static String getValidConfigParameter(String parameter, Configuration co
  }
  }
 
+ /**
+ * Creates the {@link ScriptEngine} and compiles the script if the {@link ScriptEngine} implements
+ * {@link Compilable}.
+ */
+ protected void compileScript() throws ScriptException {
+ if (compiledScript.isPresent()) {
+ return;
+ }
+ if (!scriptEngineManager.isSupported(this.type)) {
+ logger.debug(
+ "ScriptEngine for language '{}' could not be found, skipping compilation of script for identifier: {}",
+ type, engineIdentifier);
+ return;
+ }
+ Optional<ScriptEngine> engine = getScriptEngine();
+ if (engine.isPresent()) {
+ ScriptEngine scriptEngine = engine.get();
+ if (scriptEngine instanceof Compilable) {
+ logger.debug("Pre-compiling script of rule with UID '{}'", ruleUID);
+ compiledScript = Optional.ofNullable(((Compilable) scriptEngine).compile(script));
+ } else {
+ logger.error(
+ "Script engine of rule with UID '{}' does not implement Compilable but claims to support pre-compilation",
+ module.getId());
+ }
+ }
+ }
+
  @Override
  public void dispose() {
  scriptEngineManager.removeEngine(engineIdentifier);
@@ -169,4 +203,26 @@ protected void resetExecutionContext(ScriptEngine engine, Map<String, ?> context
  executionContext.removeAttribute(key, ScriptContext.ENGINE_SCOPE);
  }
  }
+
+ /**
+ * Evaluates the passed script with the ScriptEngine.
+ *
+ * @param engine the script engine that is used
+ * @param script the script to evaluate
+ * @return the value returned from the execution of the script
+ */
+ protected @Nullable Object eval(ScriptEngine engine, String script) {
+ try {
+ if (compiledScript.isPresent()) {
+ logger.debug("Executing pre-compiled script of rule with UID '{}'", ruleUID);
+ return compiledScript.get().eval(engine.getContext());
+ }
+ logger.debug("Executing script of rule with UID '{}'", ruleUID);
+ return engine.eval(script);
+ } catch (ScriptException e) {
+ logger.error("Script execution of rule with UID '{}' failed: {}", ruleUID, e.getMessage(),
+ logger.isDebugEnabled() ? e : null);
+ return null;
+ }
+ }
 }

bundles/org.openhab.core.automation.module.script/src/main/java/org/openhab/core/automation/module/script/internal/handler/ScriptActionHandler.java

@@ -31,6 +31,7 @@
  *
  * @author Kai Kreuzer - Initial contribution
  * @author Simon Merschjohann - Initial contribution
+ * @author Florian Hotze - Add support for script pre-compilation
  */
 @NonNullByDefault
 public class ScriptActionHandler extends AbstractScriptModuleHandler<Action> implements ActionHandler {
@@ -61,6 +62,11 @@ public void dispose() {
  super.dispose();
  }
 
+ @Override
+ public void compile() throws ScriptException {
+ super.compileScript();
+ }
+
  @Override
  public @Nullable Map<String, Object> execute(final Map<String, Object> context) {
  Map<String, Object> resultMap = new HashMap<>();
@@ -71,13 +77,8 @@ public void dispose() {
 
  getScriptEngine().ifPresent(scriptEngine -> {
  setExecutionContext(scriptEngine, context);
- try {
- Object result = scriptEngine.eval(script);
- resultMap.put("result", result);
- } catch (ScriptException e) {
- logger.error("Script execution of rule with UID '{}' failed: {}", ruleUID, e.getMessage(),
- logger.isDebugEnabled() ? e : null);
- }
+ Object result = eval(scriptEngine, script);
+ resultMap.put("result", result);
  resetExecutionContext(scriptEngine, context);
  });
 

bundles/org.openhab.core.automation.module.script/src/main/java/org/openhab/core/automation/module/script/internal/handler/ScriptConditionHandler.java

@@ -30,6 +30,7 @@
  *
  * @author Kai Kreuzer - Initial contribution
  * @author Simon Merschjohann - Initial contribution
+ * @author Florian Hotze - Add support for script pre-compilation
  */
 @NonNullByDefault
 public class ScriptConditionHandler extends AbstractScriptModuleHandler<Condition> implements ConditionHandler {
@@ -42,6 +43,11 @@ public ScriptConditionHandler(Condition module, String ruleUID, ScriptEngineMana
  super(module, ruleUID, scriptEngineManager);
  }
 
+ @Override
+ public void compile() throws ScriptException {
+ super.compileScript();
+ }
+
  @Override
  public boolean isSatisfied(final Map<String, Object> context) {
  boolean result = false;
@@ -55,18 +61,14 @@ public boolean isSatisfied(final Map<String, Object> context) {
  if (engine.isPresent()) {
  ScriptEngine scriptEngine = engine.get();
  setExecutionContext(scriptEngine, context);
- try {
- Object returnVal = scriptEngine.eval(script);
- if (returnVal instanceof Boolean boolean1) {
- result = boolean1;
- } else {
- logger.error("Script of rule with UID '{}' did not return a boolean value, but '{}'", ruleUID,
- returnVal);
- }
- } catch (ScriptException e) {
- logger.error("Script execution of rule with UID '{}' failed: {}", ruleUID, e.getMessage(),
- logger.isDebugEnabled() ? e : null);
+ Object returnVal = eval(scriptEngine, script);
+ if (returnVal instanceof Boolean boolean1) {
+ result = boolean1;
+ } else {
+ logger.error("Script of rule with UID '{}' did not return a boolean value, but '{}'", ruleUID,
+ returnVal);
  }
+ resetExecutionContext(scriptEngine, context);
  }
 
  return result;

bundles/org.openhab.core.automation/src/main/java/org/openhab/core/automation/handler/ActionHandler.java

@@ -31,6 +31,14 @@
  */
 @NonNullByDefault
 public interface ActionHandler extends ModuleHandler {
+ /**
+ * Called to compile an {@link Action} of the {@link Rule} when the rule is initialized.
+ *
+ * @throws Exception if the compilation fails
+ */
+ default void compile() throws Exception {
+ // Do nothing by default
+ }
 
  /**
  * Called to execute an {@link Action} of the {@link Rule} when it is needed.

bundles/org.openhab.core.automation/src/main/java/org/openhab/core/automation/handler/ConditionHandler.java

@@ -29,6 +29,14 @@
  */
 @NonNullByDefault
 public interface ConditionHandler extends ModuleHandler {
+ /**
+ * Called to compile the {@link Condition} when the {@link Rule} is initialized.
+ *
+ * @throws Exception if the compilation fails
+ */
+ default void compile() throws Exception {
+ // Do nothing by default
+ }
 
  /**
  * Checks if the Condition is satisfied in the given {@code context}.

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() //