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         }
 202     }
 203
 204     /**
 205      * Execute ruby require statement in the ScriptEngine
 206      *
 207      * @param engine Engine to insert the require statements
 208      */
 209     public void injectRequire(ScriptEngine engine) {
 210         OptionalConfigurationElement requireConfigElement = CONFIGURATION_PARAMETERS.get(REQUIRE);
 211         if (requireConfigElement == null || !requireConfigElement.getValue().isPresent()) {
 212             return;
 213         }
 214
 215         Stream.of(requireConfigElement.getValue().get().split(",")).map(s -> s.trim()).filter(s -> !s.isEmpty())
 216                 .forEach(script -> {
 217                     final String requireStatement = String.format("require '%s'", script);
 218                     try {
 219                         logger.trace("Injecting require statement: {}", requireStatement);
 220                         engine.eval(requireStatement);
 221                     } catch (ScriptException e) {
 222                         logger.warn("Error evaluating statement {}: {}", requireStatement, e.getMessage());
 223                     }
 224                 });
 225     }
 226
 227     /**
 228      * Configure the optional elements of the Ruby Environment
 229      *
 230      * @param engine Engine in which to configure environment
 231      */
 232     public ScriptEngine configureRubyEnvironment(ScriptEngine engine) {
 233         getConfigurationElements(OptionalConfigurationElement.Type.RUBY_ENVIRONMENT).forEach(configElement -> {
 234             final String environmentSetting = String.format("ENV['%s']='%s'", configElement.mappedTo().get(),
 235                     configElement.getValue().get());
 236             try {
 237                 logger.trace("Setting Ruby environment with code: {} ", environmentSetting);
 238                 engine.eval(environmentSetting);
 239             } catch (ScriptException e) {
 240                 logger.warn("Error setting ruby environment", e);
 241             }
 242         });
 243
 244         configureRubyLib(engine);
 245         return engine;
 246     }
 247
 248     /**
 249      * Split up and insert ENV['RUBYLIB'] into Ruby's $LOAD_PATH
 250      * This needs to be called after ENV['RUBYLIB'] has been set by configureRubyEnvironment
 251      *
 252      * @param engine Engine in which to configure environment
 253      */
 254     private void configureRubyLib(ScriptEngine engine) {
 255         OptionalConfigurationElement rubyLibConfigElement = CONFIGURATION_PARAMETERS.get(RUBYLIB);
 256         if (rubyLibConfigElement == null) {
 257             return;
 258         }
 259
 260         Optional<String> rubyLib = rubyLibConfigElement.getValue();
 261         if (rubyLib.isPresent() && !rubyLib.get().trim().isEmpty()) {
 262             final String code = "$LOAD_PATH.unshift *ENV['RUBYLIB']&.split(File::PATH_SEPARATOR)" + //
 263                     "&.reject(&:empty?)" + //
 264                     "&.reject { |path| $LOAD_PATH.include?(path) }"; //
 265             try {
 266                 engine.eval(code);
 267             } catch (ScriptException exception) {
 268                 logger.warn("Error setting $LOAD_PATH from RUBYLIB='{}': {}", rubyLib.get(), exception.getMessage());
 269             }
 270         }
 271     }
 272
 273     /**
 274      * Configure system properties
 275      *
 276      * @param optionalConfigurationElements Optional system properties to configure
 277      */
 278     private void configureSystemProperties() {
 279         getConfigurationElements(OptionalConfigurationElement.Type.SYSTEM_PROPERTY).forEach(configElement -> {
 280             String systemProperty = configElement.mappedTo().get();
 281             String propertyValue = configElement.getValue().get();
 282             logger.trace("Setting system property ({}) to ({})", systemProperty, propertyValue);
 283             System.setProperty(systemProperty, propertyValue);
 284         });
 285     }
 286
 287     private Stream<OptionalConfigurationElement> getConfigurationElements(
 288             OptionalConfigurationElement.Type configurationType) {
 289         return CONFIGURATION_TYPE_MAP
 290                 .getOrDefault(configurationType, Collections.<OptionalConfigurationElement> emptyList()).stream()
 291                 .filter(element -> element.getValue().isPresent());
 292     }
 293
 294     /**
 295      * Inner static companion class for configuration elements
 296      */
 297     private static class OptionalConfigurationElement {
 298
 299         private final Optional<String> defaultValue;
 300         private final Optional<String> mappedTo;
 301         private final Type type;
 302         private Optional<String> value;
 303
 304         private OptionalConfigurationElement(Type type, @Nullable String mappedTo, @Nullable String defaultValue) {
 305             this.type = type;
 306             this.defaultValue = Optional.ofNullable(defaultValue);
 307             this.mappedTo = Optional.ofNullable(mappedTo);
 308             value = Optional.empty();
 309         }
 310
 311         private Optional<String> getValue() {
 312             return value.or(() -> defaultValue);
 313         }
 314
 315         private void setValue(String value) {
 316             this.value = Optional.of(value);
 317         }
 318
 319         private Optional<String> mappedTo() {
 320             return mappedTo;
 321         }
 322
 323         private enum Type {
 324             SYSTEM_PROPERTY,
 325             RUBY_ENVIRONMENT,
 326             GEM,
 327             REQUIRE,
 328             CHECK_UPDATE,
 329         }
 330
 331         private static class Builder {
 332             private final Type type;
 333             private @Nullable String defaultValue = null;
 334             private @Nullable String mappedTo = null;
 335
 336             private Builder(Type type) {
 337                 this.type = type;
 338             }
 339
 340             private Builder mappedTo(String mappedTo) {
 341                 this.mappedTo = mappedTo;
 342                 return this;
 343             }
 344
 345             private Builder defaultValue(String value) {
 346                 this.defaultValue = value;
 347                 return this;
 348             }
 349
 350             private OptionalConfigurationElement build() {
 351                 return new OptionalConfigurationElement(type, mappedTo, defaultValue);
 352             }
 353         }
 354     }
 355 }