added migrated 2.x add-ons

Signed-off-by: Kai Kreuzer <kai@openhab.org>

bundles/org.openhab.transform.javascript/src/main/feature/feature.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<features name="org.openhab.transform.javascript-${project.version}" xmlns="http://karaf.apache.org/xmlns/features/v1.4.0">
+	<repository>mvn:org.openhab.core.features.karaf/org.openhab.core.features.karaf.openhab-core/${ohc.version}/xml/features</repository>
+
+	<feature name="openhab-transformation-javascript" description="Javascript Transformation" version="${project.version}">
+		<feature>openhab-runtime-base</feature>
+		<bundle start-level="75">mvn:org.openhab.addons.bundles/org.openhab.transform.javascript/${project.version}</bundle>
+	</feature>
+</features>

bundles/org.openhab.transform.javascript/src/main/java/org/openhab/transform/javascript/internal/JavaScriptEngineManager.java

@@ -0,0 +1,89 @@
+/**
+ * Copyright (c) 2010-2020 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.transform.javascript.internal;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.Reader;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+import javax.script.Compilable;
+import javax.script.CompiledScript;
+import javax.script.ScriptEngine;
+import javax.script.ScriptEngineManager;
+import javax.script.ScriptException;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.openhab.core.transform.TransformationException;
+import org.osgi.service.component.annotations.Component;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Simple cache for compiled JavaScript files.
+ *
+ * @author Thomas Kordelle - pre compiled scripts
+ *
+ */
+@NonNullByDefault
+@Component(service = JavaScriptEngineManager.class)
+public class JavaScriptEngineManager {
+
+    private final Logger logger = LoggerFactory.getLogger(JavaScriptEngineManager.class);
+    private final ScriptEngineManager manager = new ScriptEngineManager();
+    /* keep memory foot print low. max 2 concurrent threads are estimated */
+    private final Map<String, CompiledScript> compiledScriptMap = new ConcurrentHashMap<>(4, 0.5f, 2);
+
+    /**
+     * Get a pre compiled script {@link CompiledScript} from cache. If it is not in the cache, then load it from
+     * storage and put a pre compiled version into the cache.
+     *
+     * @param filename name of the JavaScript file to load
+     * @return a pre compiled script {@link CompiledScript}
+     * @throws TransformationException if compile of JavaScript failed
+     */
+    protected CompiledScript getScript(final String filename) throws TransformationException {
+        synchronized (compiledScriptMap) {
+            if (compiledScriptMap.containsKey(filename)) {
+                logger.debug("Loading JavaScript {} from cache.", filename);
+                return compiledScriptMap.get(filename);
+            } else {
+                final String path = TransformationScriptWatcher.TRANSFORM_FOLDER + File.separator + filename;
+                logger.debug("Loading script {} from storage ", path);
+                try (final Reader reader = new InputStreamReader(new FileInputStream(path))) {
+                    final ScriptEngine engine = manager.getEngineByName("javascript");
+                    final CompiledScript cScript = ((Compilable) engine).compile(reader);
+                    logger.debug("Putting compiled JavaScript {} to cache.", cScript);
+                    compiledScriptMap.put(filename, cScript);
+                    return cScript;
+                } catch (IOException | ScriptException e) {
+                    throw new TransformationException("An error occurred while loading JavaScript. " + e.getMessage(),
+                            e);
+                }
+            }
+        }
+    }
+
+    /**
+     * remove a pre compiled script from cache.
+     *
+     * @param fileName name of the script file to remove
+     */
+    protected void removeFromCache(String fileName) {
+        logger.debug("Removing JavaScript {} from cache.", fileName);
+        compiledScriptMap.remove(fileName);
+    }
+}

bundles/org.openhab.transform.javascript/src/main/java/org/openhab/transform/javascript/internal/JavaScriptTransformationService.java

@@ -0,0 +1,86 @@
+/**
+ * Copyright (c) 2010-2020 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.transform.javascript.internal;
+
+import javax.script.Bindings;
+import javax.script.CompiledScript;
+import javax.script.ScriptException;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
+import org.openhab.core.transform.TransformationException;
+import org.openhab.core.transform.TransformationService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.Reference;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * The implementation of {@link TransformationService} which transforms the
+ * input by Java Script.
+ *
+ * @author Pauli Anttila - Initial contribution
+ * @author Thomas Kordelle - pre compiled scripts
+ */
+@NonNullByDefault
+@Component(immediate = true, property = { "smarthome.transform=JS" })
+public class JavaScriptTransformationService implements TransformationService {
+
+    private Logger logger = LoggerFactory.getLogger(JavaScriptTransformationService.class);
+    private @NonNullByDefault({}) JavaScriptEngineManager manager;
+
+    @Reference
+    public void setJavaScriptEngineManager(JavaScriptEngineManager manager) {
+        this.manager = manager;
+    }
+
+    public void unsetJavaScriptEngineManager(JavaScriptEngineManager manager) {
+        this.manager = null;
+    }
+
+    /**
+     * Transforms the input <code>source</code> by Java Script. It expects the
+     * transformation rule to be read from a file which is stored under the
+     * 'configurations/transform' folder. To organize the various
+     * transformations one should use subfolders.
+     *
+     * @param filename the name of the file which contains the Java script
+     *            transformation rule. Transformation service inject input
+     *            (source) to 'input' variable.
+     * @param source the input to transform
+     */
+    @Override
+    public @Nullable String transform(String filename, String source) throws TransformationException {
+        if (filename == null || source == null) {
+            throw new TransformationException("the given parameters 'filename' and 'source' must not be null");
+        }
+
+        final long startTime = System.currentTimeMillis();
+        logger.debug("about to transform '{}' by the JavaScript '{}'", source, filename);
+
+        String result = "";
+
+        try {
+            final CompiledScript cScript = manager.getScript(filename);
+            final Bindings bindings = cScript.getEngine().createBindings();
+            bindings.put("input", source);
+            result = String.valueOf(cScript.eval(bindings));
+            return result;
+        } catch (ScriptException e) {
+            throw new TransformationException("An error occurred while executing script. " + e.getMessage(), e);
+        } finally {
+            logger.trace("JavaScript execution elapsed {} ms. Result: {}", System.currentTimeMillis() - startTime,
+                    result);
+        }
+    }
+}

bundles/org.openhab.transform.javascript/src/main/java/org/openhab/transform/javascript/internal/TransformationScriptWatcher.java

@@ -0,0 +1,87 @@
+/**
+ * Copyright (c) 2010-2020 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.transform.javascript.internal;
+
+import static java.nio.file.StandardWatchEventKinds.*;
+
+import java.io.File;
+import java.nio.file.Path;
+import java.nio.file.WatchEvent;
+import java.nio.file.WatchEvent.Kind;
+
+import org.openhab.core.config.core.ConfigConstants;
+import org.openhab.core.service.AbstractWatchService;
+import org.openhab.core.transform.TransformationService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.Reference;
+
+/**
+ * The {@link TransformationScriptWatcher} watches the transformation directory for files. If a deleted/modified file is
+ * detected, the script is passed to the {@link JavaScriptEngineManager}.
+ *
+ * @author Thomas Kordelle - pre compiled scripts
+ *
+ */
+@Component()
+public class TransformationScriptWatcher extends AbstractWatchService {
+
+    public static final String TRANSFORM_FOLDER = ConfigConstants.getConfigFolder() + File.separator
+            + TransformationService.TRANSFORM_FOLDER_NAME;
+
+    private JavaScriptEngineManager manager;
+
+    public TransformationScriptWatcher() {
+        super(TRANSFORM_FOLDER);
+    }
+
+    @Reference
+    public void setJavaScriptEngineManager(JavaScriptEngineManager manager) {
+        this.manager = manager;
+    }
+
+    public void unsetJavaScriptEngineManager(JavaScriptEngineManager manager) {
+        this.manager = null;
+    }
+
+    @Override
+    public void activate() {
+        super.activate();
+    }
+
+    @Override
+    protected boolean watchSubDirectories() {
+        return true;
+    }
+
+    @Override
+    protected Kind<?>[] getWatchEventKinds(Path directory) {
+        return new Kind<?>[] { ENTRY_DELETE, ENTRY_MODIFY };
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    protected void processWatchEvent(WatchEvent<?> event, Kind<?> kind, Path path) {
+        logger.debug("New watch event {} for path {}.", kind, path);
+
+        if (kind == OVERFLOW) {
+            return;
+        }
+
+        final WatchEvent<Path> ev = (WatchEvent<Path>) event;
+        final Path filename = ev.context();
+
+        logger.debug("Reloading javascript file {}.", filename);
+
+        manager.removeFromCache(filename.toString());
+    }
+}

bundles/org.openhab.transform.javascript/src/main/java/org/openhab/transform/javascript/internal/profiles/JavascriptTransformationProfile.java

@@ -0,0 +1,131 @@
+/**
+ * Copyright (c) 2010-2020 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.transform.javascript.internal.profiles;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.openhab.core.library.types.StringType;
+import org.openhab.core.thing.profiles.ProfileCallback;
+import org.openhab.core.thing.profiles.ProfileContext;
+import org.openhab.core.thing.profiles.ProfileTypeUID;
+import org.openhab.core.thing.profiles.StateProfile;
+import org.openhab.core.transform.TransformationException;
+import org.openhab.core.transform.TransformationHelper;
+import org.openhab.core.transform.TransformationService;
+import org.openhab.core.types.Command;
+import org.openhab.core.types.State;
+import org.openhab.core.types.Type;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Profile to offer the JavascriptTransformationservice on a ItemChannelLink
+ *
+ * @author Stefan Triller - initial contribution
+ *
+ */
+@NonNullByDefault
+public class JavascriptTransformationProfile implements StateProfile {
+
+    public static final ProfileTypeUID PROFILE_TYPE_UID = new ProfileTypeUID(
+            TransformationService.TRANSFORM_PROFILE_SCOPE, "JS");
+
+    private final Logger logger = LoggerFactory.getLogger(JavascriptTransformationProfile.class);
+
+    private final TransformationService service;
+    private final ProfileCallback callback;
+
+    private static final String FUNCTION_PARAM = "function";
+    private static final String SOURCE_FORMAT_PARAM = "sourceFormat";
+
+    @NonNullByDefault({})
+    private final String function;
+    @NonNullByDefault({})
+    private final String sourceFormat;
+
+    public JavascriptTransformationProfile(ProfileCallback callback, ProfileContext context,
+            TransformationService service) {
+        this.service = service;
+        this.callback = callback;
+
+        Object paramFunction = context.getConfiguration().get(FUNCTION_PARAM);
+        Object paramSource = context.getConfiguration().get(SOURCE_FORMAT_PARAM);
+
+        logger.debug("Profile configured with '{}'='{}', '{}'={}", FUNCTION_PARAM, paramFunction, SOURCE_FORMAT_PARAM,
+                paramSource);
+        // SOURCE_FORMAT_PARAM is an advanced parameter and we assume "%s" if it is not set
+        if (paramSource == null) {
+            paramSource = "%s";
+        }
+        if (paramFunction instanceof String && paramSource instanceof String) {
+            function = (String) paramFunction;
+            sourceFormat = (String) paramSource;
+        } else {
+            logger.error("Parameter '{}' and '{}' have to be Strings. Profile will be inactive.", FUNCTION_PARAM,
+                    SOURCE_FORMAT_PARAM);
+            function = null;
+            sourceFormat = null;
+        }
+    }
+
+    @Override
+    public ProfileTypeUID getProfileTypeUID() {
+        return PROFILE_TYPE_UID;
+    }
+
+    @Override
+    public void onStateUpdateFromItem(State state) {
+        callback.handleUpdate(state);
+    }
+
+    @Override
+    public void onCommandFromItem(Command command) {
+        callback.handleCommand(command);
+    }
+
+    @Override
+    public void onCommandFromHandler(Command command) {
+        if (function == null || sourceFormat == null) {
+            logger.warn(
+                    "Please specify a function and a source format for this Profile in the '{}', and '{}' parameters. Returning the original command now.",
+                    FUNCTION_PARAM, SOURCE_FORMAT_PARAM);
+            callback.sendCommand(command);
+            return;
+        }
+        callback.sendCommand((Command) transformState(command));
+    }
+
+    @Override
+    public void onStateUpdateFromHandler(State state) {
+        if (function == null || sourceFormat == null) {
+            logger.warn(
+                    "Please specify a function and a source format for this Profile in the '{}' and '{}' parameters. Returning the original state now.",
+                    FUNCTION_PARAM, SOURCE_FORMAT_PARAM);
+            callback.sendUpdate(state);
+            return;
+        }
+        callback.sendUpdate((State) transformState(state));
+    }
+
+    private Type transformState(Type state) {
+        String result = state.toFullString();
+        try {
+            result = TransformationHelper.transform(service, function, sourceFormat, state.toFullString());
+        } catch (TransformationException e) {
+            logger.warn("Could not transform state '{}' with function '{}' and format '{}'", state, function,
+                    sourceFormat);
+        }
+        StringType resultType = new StringType(result);
+        logger.debug("Transformed '{}' into '{}'", state, resultType);
+        return resultType;
+    }
+}

bundles/org.openhab.transform.javascript/src/main/java/org/openhab/transform/javascript/internal/profiles/JavascriptTransformationProfileFactory.java

@@ -0,0 +1,71 @@
+/**
+ * Copyright (c) 2010-2020 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.transform.javascript.internal.profiles;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Locale;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
+import org.openhab.core.thing.profiles.Profile;
+import org.openhab.core.thing.profiles.ProfileCallback;
+import org.openhab.core.thing.profiles.ProfileContext;
+import org.openhab.core.thing.profiles.ProfileFactory;
+import org.openhab.core.thing.profiles.ProfileType;
+import org.openhab.core.thing.profiles.ProfileTypeBuilder;
+import org.openhab.core.thing.profiles.ProfileTypeProvider;
+import org.openhab.core.thing.profiles.ProfileTypeUID;
+import org.openhab.core.transform.TransformationService;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.Reference;
+
+/**
+ * Profilefactory that creates the transformation profile for the javascript transformation service
+ *
+ * @author Stefan Triller - initial contribution
+ *
+ */
+@NonNullByDefault
+@Component(service = { ProfileFactory.class, ProfileTypeProvider.class })
+public class JavascriptTransformationProfileFactory implements ProfileFactory, ProfileTypeProvider {
+
+    @NonNullByDefault({})
+    private TransformationService service;
+
+    @Override
+    public Collection<ProfileType> getProfileTypes(@Nullable Locale locale) {
+        return Arrays.asList(ProfileTypeBuilder.newState(JavascriptTransformationProfile.PROFILE_TYPE_UID,
+                JavascriptTransformationProfile.PROFILE_TYPE_UID.getId()).build());
+    }
+
+    @Override
+    public @Nullable Profile createProfile(ProfileTypeUID profileTypeUID, ProfileCallback callback,
+            ProfileContext profileContext) {
+        return new JavascriptTransformationProfile(callback, profileContext, service);
+    }
+
+    @Override
+    public Collection<ProfileTypeUID> getSupportedProfileTypeUIDs() {
+        return Arrays.asList(JavascriptTransformationProfile.PROFILE_TYPE_UID);
+    }
+
+    @Reference(target = "(smarthome.transform=JS)")
+    public void addTransformationService(TransformationService service) {
+        this.service = service;
+    }
+
+    public void removeTransformationService(TransformationService service) {
+        this.service = null;
+    }
+}

bundles/org.openhab.transform.javascript/src/main/resources/OH-INF/config/javascriptProfile.xml

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<config-description:config-descriptions
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xmlns:config-description="https://openhab.org/schemas/config-description/v1.0.0"
+	xsi:schemaLocation="https://openhab.org/schemas/config-description/v1.0.0 https://openhab.org/schemas/config-description-1.0.0.xsd">
+
+	<config-description uri="profile:transform:JS">
+		<parameter name="function" type="text" required="true">
+			<label>JavaScript Filename</label>
+			<description>Filename of the JavaScript in the transform folder. The state will be available in the variable
+				\"input\".</description>
+		</parameter>
+		<parameter name="sourceFormat" type="text" required="false">
+			<label>State Formatter</label>
+			<description>How to format the state on the channel before transforming it, i.e. %s or %.1f °C (default is %s)</description>
+			<advanced>true</advanced>
+		</parameter>
+	</config-description>
+</config-description:config-descriptions>

bundles/org.openhab.transform.javascript/src/main/resources/readme.txt

@@ -0,0 +1 @@
+Bundle resources go in here!