Merge pull request #1201 from qivicon/esh-should-work-on-CP2-with-portablebase64

esh should work on cp2 with portablebase64

bundles/core/org.eclipse.smarthome.core.test/src/test/groovy/org/eclipse/smarthome/core/internal/PortableBase64Test.groovy

@@ -0,0 +1,203 @@
+/**
+ * Copyright (c) 2016 Deutsche Telekom AG and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.smarthome.core.internal
+
+import static org.hamcrest.CoreMatchers.*
+import static org.hamcrest.MatcherAssert.assertThat
+import static org.junit.Assert.fail
+
+import java.io.UnsupportedEncodingException
+
+import org.junit.Before
+import org.junit.Ignore
+import org.junit.Test
+
+/**
+ * @author Jochen Hiller - Initial contribution
+ * @author Miki Jankov - Adding new tests and fixing existing ones
+ */
+public class PortableBase64Test {
+
+    private static boolean isJava8OrNewer = true
+
+    @Before
+    public void testInitialize() {
+        try {
+            Class.forName("java.util.Base64", false, PortableBase64.class.getClassLoader())
+        } catch (ClassNotFoundException ex) {
+            // not found, so we run on JavaSE 7 or older
+            isJava8OrNewer = false
+        }
+        PortableBase64.initialize()
+    }
+
+    @Test
+    public void testGetStaticClasses() {
+        PortableBase64.Decoder decoder = PortableBase64.getDecoder()
+        assertThat(decoder, is(not(nullValue())))
+
+        PortableBase64.Encoder encoder = PortableBase64.getEncoder()
+        assertThat(encoder, is(not(nullValue())))
+    }
+
+    @Test
+    public void testDecode() {
+        // see https://tools.ietf.org/html/rfc4648#section-10
+        FROM_BASE64("", "")
+        FROM_BASE64("Zg==", "f")
+        FROM_BASE64("Zm8=", "fo")
+        FROM_BASE64("Zm9v", "foo")
+        FROM_BASE64("Zm9vYg==", "foob")
+        FROM_BASE64("Zm9vYmE=", "fooba")
+        FROM_BASE64("Zm9vYmFy", "foobar")
+    }
+
+    @Test
+    public void testEncode() {
+        // see https://tools.ietf.org/html/rfc4648#section-10
+        TO_BASE64("", "")
+        TO_BASE64("f", "Zg==")
+        TO_BASE64("fo", "Zm8=")
+        TO_BASE64("foo", "Zm9v")
+        TO_BASE64("foob", "Zm9vYg==")
+        TO_BASE64("fooba", "Zm9vYmE=")
+        TO_BASE64("foobar", "Zm9vYmFy")
+    }
+
+    @Test(expected = java.lang.IllegalArgumentException.class)
+    public void testDecodeInvalidCharacterDot() {
+        PortableBase64.getDecoder().decode("......")
+    }
+
+    @Test(expected = java.lang.IllegalArgumentException.class)
+    public void testDecodeInvalidCharacterDash() {
+        PortableBase64.getDecoder().decode("---")
+    }
+
+    @Test(expected = java.lang.IllegalStateException.class)
+    public void testEncodeWhenClassNotInitialized() {
+        PortableBase64.isInitialized = false
+        PortableBase64.getEncoder().encode("".bytes)
+    }
+
+    @Test(expected = java.lang.IllegalStateException.class)
+    public void testDecodeWhenClassNotInitialized() {
+        PortableBase64.isInitialized = false
+        PortableBase64.getDecoder().decode("")
+    }
+
+    /** JavaSE 7 does NOT throw an IllegalArgumentException. */
+    @Test
+    public void testDecodeInvalidPaddingStart1() {
+        try {
+            PortableBase64.getDecoder().decode("=A==")
+            if (isJava8OrNewer) {
+                fail("IllegalArgumentException expected in JavaSE 8")
+            }
+        } catch (Exception ex) {
+            if (!isJava8OrNewer) {
+                fail("No exception expected in JavaSE 7")
+            }
+        }
+    }
+
+    /** JavaSE 7 does NOT throw an IllegalArgumentException. */
+    @Test
+    public void testDecodeInvalidPaddingStart2() {
+        try {
+            PortableBase64.getDecoder().decode("====")
+            if (isJava8OrNewer) {
+                fail("IllegalArgumentException expected in JavaSE 8")
+            }
+        } catch (Exception ex) {
+            if (!isJava8OrNewer) {
+                fail("No exception expected in JavaSE 7")
+            }
+        }
+    }
+
+    /** JavaSE 7 does NOT throw an IllegalArgumentException. */
+    @Test
+    public void testDecodeInvalidPaddingMiddle() {
+        try {
+            PortableBase64.getDecoder().decode("Zg=a")
+            if (isJava8OrNewer) {
+                fail("IllegalArgumentException expected in JavaSE 8")
+            }
+        } catch (Exception ex) {
+            if (!isJava8OrNewer) {
+                fail("No exception expected in JavaSE 7")
+            }
+        }
+    }
+
+    /**
+     * TODO we can not easily compare this by native calls as this would
+     */
+    @Test
+    public void testPerformancePortableBase64() {
+        long tStart = System.nanoTime()
+        int N = 10000000
+        for (int i = 0; i < N; i++) {
+            PortableBase64.getEncoder().encode("foobar".getBytes())
+            PortableBase64.getDecoder().decode("Zm9vYmFy")
+        }
+        long tEnd = System.nanoTime()
+        System.out.println("testPerformancePortableBase64 took " + (tEnd - tStart) / 1000 / 1000 + " ms for " + N
+                + " iterations on " + System.getProperty("java.version") + ".")
+    }
+
+    @Test
+    public void testPerformanceJavaSE7() {
+        long tStart = System.nanoTime()
+        int N = 10000000
+        for (int i = 0; i < N; i++) {
+            javax.xml.bind.DatatypeConverter.printBase64Binary("foobar".getBytes())
+            javax.xml.bind.DatatypeConverter.parseBase64Binary("Zm9vYmFy")
+        }
+        long tEnd = System.nanoTime()
+        System.out.println("testPerformanceJavaSE7 " + (tEnd - tStart) / 1000 / 1000 + " ms for " + N
+                + " iterations on " + System.getProperty("java.version") + ".")
+    }
+
+    /**
+     * If you want to run the test on JavaSE 8, remove @Ignore, enable the code below and import java.util.Base64 and
+     * compile for Java 8.
+     */
+    @Test
+    @Ignore
+    public void testPerformanceJavaSE8() {
+        long tStart = System.nanoTime()
+        int N = 10000000
+        for (int i = 0; i < N; i++) {
+            // enable this code to run performance tests on JavaSE 8.
+            // Base64.getEncoder().encode("foobar".getBytes());
+            // Base64.getDecoder().decode("Zm9vYmFy");
+        }
+        long tEnd = System.nanoTime()
+        System.out.println("testPerformanceJavaSE7 " + (tEnd - tStart) / 1000 / 1000 + " ms for " + N
+                + " iterations on " + System.getProperty("java.version") + ".")
+    }
+
+    private void FROM_BASE64(String base64, String output) {
+        try {
+            PortableBase64.Decoder decoder = PortableBase64.getDecoder()
+            byte[] decodedAsByteArray = decoder.decode(base64)
+            String decodedAsString = new String(decodedAsByteArray, "UTF-8")
+            assertThat(output, is(equalTo(decodedAsString)))
+        } catch (UnsupportedEncodingException ex) {
+            fail("Should never happen")
+        }
+    }
+
+    private void TO_BASE64(String input, String res) {
+        PortableBase64.Encoder encoder = PortableBase64.getEncoder()
+        String base64 = encoder.encode(input.getBytes())
+        assertThat(res, is(equalTo(base64)))
+    }
+}

bundles/core/org.eclipse.smarthome.core/META-INF/MANIFEST.MF

@@ -31,7 +31,7 @@ Bundle-License: http://www.eclipse.org/legal/epl-v10.html
 Import-Package: com.google.common.base,
  com.google.common.collect,
  com.google.gson,
- javax.xml.bind,
+ javax.xml.bind;resolution:=optional,
  org.apache.commons.lang,
  org.eclipse.smarthome.core.binding,
  org.eclipse.smarthome.core.binding.dto,

bundles/core/org.eclipse.smarthome.core/src/main/java/org/eclipse/smarthome/core/internal/CoreActivator.java

@@ -27,6 +27,7 @@ public class CoreActivator implements BundleActivator {
     @Override
     public void start(BundleContext bc) throws Exception {
         context = bc;
+        PortableBase64.initialize();
         logger.debug("Core bundle has been started.");
     }
 

bundles/core/org.eclipse.smarthome.core/src/main/java/org/eclipse/smarthome/core/internal/PortableBase64.java

@@ -0,0 +1,226 @@
+/**
+ * Copyright (c) 2016 Deutsche Telekom AG and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.smarthome.core.internal;
+
+import java.lang.reflect.Method;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * The class PortableBase64 will provide Base64 encode and decode functionality in a portable way for JavaSE 7 and
+ * JavaSE 8. Its design is based on the new java.util.Base64 class from JavaSE 8.
+ *
+ * The implementation checks for Java version. It will call either an included class from javax.xml.bind or use the new
+ * Base64 class from JavaSE 8. This has been chosen to avoid a compile dependency to Java 8.
+ *
+ * For JavaSE 7 it will use the class javax.xml.bind.DatatypeConverter for
+ * Base64 functionality. It will get the encode and decode methods to be able to call this methods later via reflection.
+ *
+ * For JavaSE 8 it will use the built-in class java.util.Base64, get the instances for encoder and decoder and will use
+ * them for calling.
+ *
+ * @author Jochen Hiller - Initial contribution
+ * @author Miki Jankov - Adding error checks
+ *
+ */
+public class PortableBase64 {
+
+    /**
+     * The encoder instance will be needed for JavaSE 8 as the encode method is an instance method. For JavaSE 7 this is
+     * null as it is a static method.
+     */
+    private static Object encoderInstance;
+
+    /**
+     * The encode method will expect a signature of:
+     *
+     * <pre>
+     * String encodeMethod(byte[] b);
+     * </pre>
+     */
+    private static Method encodeMethod;
+
+    /**
+     * The decoder instance will be needed for JavaSE 8 as the decode method is an instance method. For JavaSE 7 this is
+     * null as it is a static method.
+     */
+    private static Object decoderInstance;
+
+    /**
+     * The decode method will expect a signature of:
+     *
+     * <pre>
+     * byte[] decodeMethod(String s);
+     * </pre>
+     */
+    private static Method decodeMethod;
+
+    /**
+     * A flag to show if initialization was already performed
+     */
+    private static volatile boolean isInitialized = false;
+
+    // static helpers to initialize
+
+    public static void initialize() {
+        if (isInitialized) {
+            logInfo("PortableBase64 class already initialized");
+            return;
+        }
+
+        // just try to get Java 8(or newer) class
+        boolean isJava8OrNewer = true;
+        try {
+            Class.forName("java.util.Base64", false, PortableBase64.class.getClassLoader());
+        } catch (ClassNotFoundException ex) {
+            // not found, so we run on JavaSE 7 or older
+            isJava8OrNewer = false;
+        }
+        logInfo("PortableBase64 class is running on JavaSE " + (isJava8OrNewer ? ">=8" : "<=7"));
+
+        try {
+            if (isJava8OrNewer) {
+                initializeJava8();
+            } else {
+                initializeJava7();
+            }
+            // make one test call for encode and decode to be sure that it is working
+            // see https://tools.ietf.org/html/rfc4648#section-10 for samples
+            String encodedAsString = (String) encodeMethod.invoke(encoderInstance, "foobar".getBytes("UTF-8"));
+            if (!"Zm9vYmFy".equals(encodedAsString)) {
+                throw new IllegalAccessError("encode does not work as expected");
+            }
+            byte[] decodedAsByteArray = (byte[]) decodeMethod.invoke(decoderInstance, "Zm9vYmFy");
+            String decodedAsString = new String(decodedAsByteArray, "UTF-8");
+            if (!"foobar".equals(decodedAsString)) {
+                throw new IllegalAccessError("decode does not work as expected");
+            }
+            PortableBase64.isInitialized = true;
+        } catch (Exception ex) {
+            logError(
+                    "Could not initialize PortableBase64 class- Check your Java environment to run on Java 7 or 8 or later.",
+                    ex);
+            encodeMethod = null;
+            decodeMethod = null;
+            // TODO fallback to an internal implementation? E.g. for JavaSE 6/5/4...
+        }
+    }
+
+    /**
+     * Initialization for JavaSE 7 using javax.xml.bind.DatatypeConverter class.
+     */
+    private static void initializeJava7() throws Exception {
+        // now we know that the class DataTypeConverter is available
+        Class<?> datatypeConverterClass = Class.forName("javax.xml.bind.DatatypeConverter", false,
+                PortableBase64.class.getClassLoader());
+        // preserve static methods for later use
+        encodeMethod = datatypeConverterClass.getMethod("printBase64Binary", new Class[] { byte[].class });
+        decodeMethod = datatypeConverterClass.getMethod("parseBase64Binary", new Class[] { String.class });
+    }
+
+    /**
+     * Initialization for JavaSE 8 using java.util.Base64 class.
+     */
+    private static void initializeJava8() throws Exception {
+        Class<?> baseClass = Class.forName("java.util.Base64", false, PortableBase64.class.getClassLoader());
+
+        // search for inner classes
+        Class<?>[] innerClasses = baseClass.getDeclaredClasses();
+        Class<?> encoderClass = null;
+        Class<?> decoderClass = null;
+        for (int i = 0; i < innerClasses.length; i++) {
+            Class<?> c = innerClasses[i];
+            if (c.getName().equals("java.util.Base64$Encoder")) {
+                encoderClass = c;
+            } else if (c.getName().equals("java.util.Base64$Decoder")) {
+                decoderClass = c;
+            } else {
+                // ignore, we do not need
+            }
+        }
+        // check if we found the classes
+        if (encoderClass == null) {
+            throw new IllegalAccessError("Could not find encoderClass java.util.Base64$Encoder");
+        }
+        if (decoderClass == null) {
+            throw new IllegalAccessError("Could not find decoderClass java.util.Base64$Decoder");
+        }
+
+        // preserve the instances of encoder and decoder
+        PortableBase64.encoderInstance = baseClass.getMethod("getEncoder", new Class[] {}).invoke(null,
+                (Object[]) null);
+        PortableBase64.decoderInstance = baseClass.getMethod("getDecoder", new Class[] {}).invoke(null,
+                (Object[]) null);
+        // preserve method on instances for later use
+        encodeMethod = encoderClass.getMethod("encodeToString", new Class[] { byte[].class });
+        decodeMethod = decoderClass.getMethod("decode", new Class[] { String.class });
+    }
+
+    private static void logError(String msg, Exception ex) {
+        Logger l = LoggerFactory.getLogger(PortableBase64.class);
+        l.error(msg, ex);
+    }
+
+    private static void logInfo(String msg) {
+        Logger l = LoggerFactory.getLogger(PortableBase64.class);
+        l.info(msg);
+    }
+
+    // PortablBase64 implementation
+
+    private static Encoder basicEncoder = new Encoder();
+    private static Decoder basicDecoder = new Decoder();
+
+    public static Encoder getEncoder() {
+        return basicEncoder;
+    }
+
+    public static Decoder getDecoder() {
+        return basicDecoder;
+    }
+
+    public static class Encoder {
+        public String encode(byte[] base64) {
+            try {
+                if (!isInitialized)
+                    throw new IllegalStateException("PortableBase64 is not initialized");
+                Object res = encodeMethod.invoke(encoderInstance, base64);
+                return (String) res;
+            } catch (IllegalStateException ise) {
+                throw ise;
+            } catch (Exception ex) {
+                PortableBase64.logError("PortableBase64 - Could not encode", ex);
+                throw new IllegalArgumentException(ex.getMessage());
+            }
+        }
+    }
+
+    public static class Decoder {
+        public byte[] decode(String s) {
+            try {
+                if (!isInitialized)
+                    throw new IllegalStateException("PortableBase64 is not initialized");
+                Object res = decodeMethod.invoke(decoderInstance, s);
+                byte[] b = (byte[]) res;
+                // System.out.println("'" + new String(b) + "'");
+                if ((b.length == 0) && (s.length() > 0)) {
+                    throw new IllegalArgumentException("decode returned empty result");
+                }
+                return b;
+            } catch (IllegalStateException ise) {
+                throw ise;
+            } catch (IllegalArgumentException ex) {
+                throw ex;
+            } catch (Exception ex) {
+                PortableBase64.logError("PortableBase64 - Could not decode", ex);
+                throw new IllegalArgumentException(ex.getMessage());
+            }
+        }
+    }
+}

bundles/core/org.eclipse.smarthome.core/src/main/java/org/eclipse/smarthome/core/library/types/RawType.java

@@ -9,8 +9,7 @@ package org.eclipse.smarthome.core.library.types;
 
 import java.util.Arrays;
 
-import javax.xml.bind.DatatypeConverter;
+import org.eclipse.smarthome.core.internal.PortableBase64;
-
 import org.eclipse.smarthome.core.types.PrimitiveType;
 import org.eclipse.smarthome.core.types.State;
 
@@ -38,12 +37,12 @@ public class RawType implements PrimitiveType, State {
     }
 
     public static RawType valueOf(String value) {
-        return new RawType(DatatypeConverter.parseBase64Binary(value));
+        return new RawType(PortableBase64.getDecoder().decode(value));
     }
 
     @Override
     public String toString() {
-        return DatatypeConverter.printBase64Binary(bytes);
+        return PortableBase64.getEncoder().encode(bytes);
     }
 
     @Override