git.basschouten.com Git - openhab-addons.git/blob

   1 /**
   2  * Copyright (c) 2010-2022 Contributors to the openHAB project
   3  *
   4  * See the NOTICE file(s) distributed with this work for additional
   5  * information.
   6  *
   7  * This program and the accompanying materials are made available under the
   8  * terms of the Eclipse Public License 2.0 which is available at
   9  * http://www.eclipse.org/legal/epl-2.0
  10  *
  11  * SPDX-License-Identifier: EPL-2.0
  12  */
  13 package org.openhab.automation.jrubyscripting.internal;
  14
  15 import java.io.File;
  16 import java.nio.file.Path;
  17 import java.nio.file.Paths;
  18 import java.util.Collections;
  19 import java.util.List;
  20 import java.util.Map;
  21 import java.util.Optional;
  22 import java.util.stream.Collectors;
  23 import java.util.stream.Stream;
  24
  25 import javax.script.ScriptEngine;
  26 import javax.script.ScriptEngineFactory;
  27 import javax.script.ScriptException;
  28
  29 import org.eclipse.jdt.annotation.NonNullByDefault;
  30 import org.eclipse.jdt.annotation.Nullable;
  31 import org.openhab.core.OpenHAB;
  32 import org.slf4j.Logger;
  33 import org.slf4j.LoggerFactory;
  34
  35 /**
  36  * Processes JRuby Configuration Parameters.
  37  *
  38  * @author Brian O'Connell - Initial contribution
  39  * @author Jimmy Tanagra - Add $LOAD_PATH, require injection
  40  */
  41 @NonNullByDefault
  42 public class JRubyScriptEngineConfiguration {
  43
  44     private final Logger logger = LoggerFactory.getLogger(JRubyScriptEngineConfiguration.class);
  45
  46     private static final Path DEFAULT_GEM_HOME = Paths.get(OpenHAB.getConfigFolder(), "scripts", "lib", "ruby",
  47             "gem_home");
  48
  49     private static final Path DEFAULT_RUBYLIB = Paths.get(OpenHAB.getConfigFolder(), "automation", "lib", "ruby");
  50
  51     private static final String GEM_HOME = "gem_home";
  52     private static final String RUBYLIB = "rubylib";
  53     private static final String GEMS = "gems";
  54     private static final String REQUIRE = "require";
  55     private static final String CHECK_UPDATE = "check_update";
  56
  57     // Map of configuration parameters
  58     private static final Map<String, OptionalConfigurationElement> CONFIGURATION_PARAMETERS = Map.ofEntries(
  59             Map.entry("local_context",
  60                     new OptionalConfigurationElement.Builder(OptionalConfigurationElement.Type.SYSTEM_PROPERTY)
  61                             .mappedTo("org.jruby.embed.localcontext.scope").defaultValue("singlethread").build()),
  62
  63             Map.entry("local_variable",
  64                     new OptionalConfigurationElement.Builder(OptionalConfigurationElement.Type.SYSTEM_PROPERTY)
  65                             .mappedTo("org.jruby.embed.localvariable.behavior").defaultValue("transient").build()),
  66
  67             Map.entry(GEM_HOME,
  68                     new OptionalConfigurationElement.Builder(OptionalConfigurationElement.Type.RUBY_ENVIRONMENT)
  69                             .mappedTo("GEM_HOME").defaultValue(DEFAULT_GEM_HOME.toString()).build()),
  70
  71             Map.entry(RUBYLIB,
  72                     new OptionalConfigurationElement.Builder(OptionalConfigurationElement.Type.RUBY_ENVIRONMENT)
  73                             .mappedTo("RUBYLIB").defaultValue(DEFAULT_RUBYLIB.toString()).build()),
  74
  75             Map.entry(GEMS, new OptionalConfigurationElement.Builder(OptionalConfigurationElement.Type.GEM).build()),
  76
  77             Map.entry(REQUIRE,
  78                     new OptionalConfigurationElement.Builder(OptionalConfigurationElement.Type.REQUIRE).build()),
  79
  80             Map.entry(CHECK_UPDATE,
  81                     new OptionalConfigurationElement.Builder(OptionalConfigurationElement.Type.CHECK_UPDATE).build()));
  82
  83     private static final Map<OptionalConfigurationElement.Type, List<OptionalConfigurationElement>> CONFIGURATION_TYPE_MAP = CONFIGURATION_PARAMETERS
  84             .values().stream().collect(Collectors.groupingBy(v -> v.type));
  85
  86     /**
  87      * Update configuration
  88      *
  89      * @param config Configuration parameters to apply to ScriptEngine
  90      * @param factory ScriptEngineFactory to configure
  91      */
  92     void update(Map<String, Object> config, ScriptEngineFactory factory) {
  93         logger.trace("JRuby Script Engine Configuration: {}", config);
  94         config.forEach(this::processConfigValue);
  95         configureScriptEngine(factory);
  96     }
  97
  98     /**
  99      * Apply configuration key/value to known configuration parameters
 100      *
 101      * @param key Configuration key
 102      * @param value Configuration value
 103      */
 104     private void processConfigValue(String key, Object value) {
 105         OptionalConfigurationElement configurationElement = CONFIGURATION_PARAMETERS.get(key);
 106         if (configurationElement != null) {
 107             configurationElement.setValue(value.toString());
 108         } else {
 109             logger.debug("Ignoring unexpected configuration key: {}", key);
 110         }
 111     }
 112
 113     /**
 114      * Configure the ScriptEngine
 115      *
 116      * @param factory Script Engine to configure
 117      */
 118     void configureScriptEngine(ScriptEngineFactory factory) {
 119         configureSystemProperties();
 120
 121         ScriptEngine engine = factory.getScriptEngine();
 122         configureRubyEnvironment(engine);
 123         configureGems(engine);
 124     }
 125
 126     /**
 127      * Makes Gem home directory if it does not exist
 128      */
 129     private void ensureGemHomeExists() {
 130         OptionalConfigurationElement gemHomeConfigElement = CONFIGURATION_PARAMETERS.get(GEM_HOME);
 131         if (gemHomeConfigElement == null) {
 132             return;
 133         }
 134         Optional<String> gemHome = gemHomeConfigElement.getValue();
 135         if (gemHome.isPresent()) {
 136             File gemHomeDirectory = new File(gemHome.get());
 137             if (!gemHomeDirectory.exists()) {
 138                 logger.debug("gem_home directory does not exist, creating");
 139                 if (!gemHomeDirectory.mkdirs()) {
 140                     logger.warn("Error creating gem_home directory");
 141                 }
 142             }
 143         } else {
 144             logger.debug("Gem install requested without gem_home specified, not ensuring gem_home path exists");
 145         }
 146     }
 147
 148     /**
 149      * Install a gems in ScriptEngine
 150      *
 151      * @param engine Engine to install gems
 152      */
 153     private synchronized void configureGems(ScriptEngine engine) {
 154         ensureGemHomeExists();
 155
 156         OptionalConfigurationElement gemsConfigElement = CONFIGURATION_PARAMETERS.get(GEMS);
 157         if (gemsConfigElement == null || !gemsConfigElement.getValue().isPresent()) {
 158             return;
 159         }
 160         boolean checkUpdate = true;
 161         OptionalConfigurationElement updateConfigElement = CONFIGURATION_PARAMETERS.get(CHECK_UPDATE);
 162         if (updateConfigElement != null && updateConfigElement.getValue().isPresent()) {
 163             checkUpdate = updateConfigElement.getValue().get().equals("true");
 164         }
 165
 166         String[] gems = gemsConfigElement.getValue().get().split(",");
 167         String gemCommand = "require 'bundler/inline'\nrequire 'openssl'\n\ngemfile(" + checkUpdate + ") do\n"
 168                 + "  source 'https://rubygems.org/'\n";
 169         int validGems = 0;
 170         for (String gem : gems) {
 171             gem = gem.trim();
 172             String version = "";
 173             if (gem.contains("=")) {
 174                 String[] gemParts = gem.split("=");
 175                 gem = gemParts[0].trim();
 176                 version = gemParts[1].trim();
 177             }
 178
 179             if (gem.isEmpty()) {
 180                 continue;
 181             }
 182
 183             gemCommand += "  gem '" + gem + "'";
 184             if (!version.isEmpty()) {
 185                 gemCommand += ", '" + version + "'";
 186             }
 187             gemCommand += ", require: false\n";
 188             validGems += 1;
 189         }
 190         if (validGems == 0) {
 191             return;
 192         }
 193         gemCommand += "end\n";
 194
 195         try {
 196             logger.debug("Installing Gems");
 197             logger.trace("Gem install code:\n{}", gemCommand);
 198             engine.eval(gemCommand);
 199         } catch (ScriptException e) {
 200             logger.warn("Error installing Gems: {}", e.getMessage());
 201         } catch (BootstrapMethodError e) {
 202             logger.warn("Error while checking/installing gems: {}. You may need to restart OpenHAB", e.getMessage());
 203             logger.debug("Error in configureGems", e);
 204         }
 205     }
 206
 207     /**
 208      * Execute ruby require statement in the ScriptEngine
 209      *
 210      * @param engine Engine to insert the require statements
 211      */
 212     public void injectRequire(ScriptEngine engine) {
 213         OptionalConfigurationElement requireConfigElement = CONFIGURATION_PARAMETERS.get(REQUIRE);
 214         if (requireConfigElement == null || !requireConfigElement.getValue().isPresent()) {
 215             return;
 216         }
 217
 218         Stream.of(requireConfigElement.getValue().get().split(",")).map(s -> s.trim()).filter(s -> !s.isEmpty())
 219                 .forEach(script -> {
 220                     final String requireStatement = String.format("require '%s'", script);
 221                     try {
 222                         logger.trace("Injecting require statement: {}", requireStatement);
 223                         engine.eval(requireStatement);
 224                     } catch (ScriptException e) {
 225                         logger.warn("Error evaluating statement {}: {}", requireStatement, e.getMessage());
 226                     }
 227                 });
 228     }
 229
 230     /**
 231      * Configure the optional elements of the Ruby Environment
 232      *
 233      * @param engine Engine in which to configure environment
 234      */
 235     public ScriptEngine configureRubyEnvironment(ScriptEngine engine) {
 236         getConfigurationElements(OptionalConfigurationElement.Type.RUBY_ENVIRONMENT).forEach(configElement -> {
 237             final String environmentSetting = String.format("ENV['%s']='%s'", configElement.mappedTo().get(),
 238                     configElement.getValue().get());
 239             try {
 240                 logger.trace("Setting Ruby environment with code: {} ", environmentSetting);
 241                 engine.eval(environmentSetting);
 242             } catch (ScriptException e) {
 243                 logger.warn("Error setting ruby environment", e);
 244             }
 245         });
 246
 247         configureRubyLib(engine);
 248         return engine;
 249     }
 250
 251     /**
 252      * Split up and insert ENV['RUBYLIB'] into Ruby's $LOAD_PATH
 253      * This needs to be called after ENV['RUBYLIB'] has been set by configureRubyEnvironment
 254      *
 255      * @param engine Engine in which to configure environment
 256      */
 257     private void configureRubyLib(ScriptEngine engine) {
 258         OptionalConfigurationElement rubyLibConfigElement = CONFIGURATION_PARAMETERS.get(RUBYLIB);
 259         if (rubyLibConfigElement == null) {
 260             return;
 261         }
 262
 263         Optional<String> rubyLib = rubyLibConfigElement.getValue();
 264         if (rubyLib.isPresent() && !rubyLib.get().trim().isEmpty()) {
 265             final String code = "$LOAD_PATH.unshift *ENV['RUBYLIB']&.split(File::PATH_SEPARATOR)" + //
 266                     "&.reject(&:empty?)" + //
 267                     "&.reject { |path| $LOAD_PATH.include?(path) }"; //
 268             try {
 269                 engine.eval(code);
 270             } catch (ScriptException exception) {
 271                 logger.warn("Error setting $LOAD_PATH from RUBYLIB='{}': {}", rubyLib.get(), exception.getMessage());
 272             }
 273         }
 274     }
 275
 276     /**
 277      * Configure system properties
 278      *
 279      * @param optionalConfigurationElements Optional system properties to configure
 280      */
 281     private void configureSystemProperties() {
 282         getConfigurationElements(OptionalConfigurationElement.Type.SYSTEM_PROPERTY).forEach(configElement -> {
 283             String systemProperty = configElement.mappedTo().get();
 284             String propertyValue = configElement.getValue().get();
 285             logger.trace("Setting system property ({}) to ({})", systemProperty, propertyValue);
 286             System.setProperty(systemProperty, propertyValue);
 287         });
 288     }
 289
 290     private Stream<OptionalConfigurationElement> getConfigurationElements(
 291             OptionalConfigurationElement.Type configurationType) {
 292         return CONFIGURATION_TYPE_MAP
 293                 .getOrDefault(configurationType, Collections.<OptionalConfigurationElement> emptyList()).stream()
 294                 .filter(element -> element.getValue().isPresent());
 295     }
 296
 297     /**
 298      * Inner static companion class for configuration elements
 299      */
 300     private static class OptionalConfigurationElement {
 301
 302         private final Optional<String> defaultValue;
 303         private final Optional<String> mappedTo;
 304         private final Type type;
 305         private Optional<String> value;
 306
 307         private OptionalConfigurationElement(Type type, @Nullable String mappedTo, @Nullable String defaultValue) {
 308             this.type = type;
 309             this.defaultValue = Optional.ofNullable(defaultValue);
 310             this.mappedTo = Optional.ofNullable(mappedTo);
 311             value = Optional.empty();
 312         }
 313
 314         private Optional<String> getValue() {
 315             return value.or(() -> defaultValue);
 316         }
 317
 318         private void setValue(String value) {
 319             this.value = Optional.of(value);
 320         }
 321
 322         private Optional<String> mappedTo() {
 323             return mappedTo;
 324         }
 325
 326         private enum Type {
 327             SYSTEM_PROPERTY,
 328             RUBY_ENVIRONMENT,
 329             GEM,
 330             REQUIRE,
 331             CHECK_UPDATE,
 332         }
 333
 334         private static class Builder {
 335             private final Type type;
 336             private @Nullable String defaultValue = null;
 337             private @Nullable String mappedTo = null;
 338
 339             private Builder(Type type) {
 340                 this.type = type;
 341             }
 342
 343             private Builder mappedTo(String mappedTo) {
 344                 this.mappedTo = mappedTo;
 345                 return this;
 346             }
 347
 348             private Builder defaultValue(String value) {
 349                 this.defaultValue = value;
 350                 return this;
 351             }
 352
 353             private OptionalConfigurationElement build() {
 354                 return new OptionalConfigurationElement(type, mappedTo, defaultValue);
 355             }
 356         }
 357     }
 358 }