Merge pull request #32 from eficode/remote-javalibcore-update

Remote javalibcore update

Author: sampeson

pom.xml

@@ -392,7 +392,7 @@
         <dependency>
             <groupId>org.robotframework</groupId>
             <artifactId>javalib-core</artifactId>
-            <version>1.2.1</version>
+            <version>2.0.3</version>
         </dependency>
         <dependency>
             <groupId>org.robotframework</groupId>
@@ -409,11 +409,11 @@
             <artifactId>guava</artifactId>
             <version>28.1-jre</version>
         </dependency>
-        <dependency>
-            <groupId>com.github.ombre42</groupId>
-            <artifactId>jrobotremoteserver</artifactId>
-            <version>3.0</version>
-        </dependency>
+		<dependency>
+			<groupId>org.robotframework</groupId>
+			<artifactId>jrobotremoteserver</artifactId>
+			<version>4.0.0</version>
+		</dependency>
         <dependency>
             <groupId>org.apache.commons</groupId>
             <artifactId>commons-lang3</artifactId>

src/main/java/JavaFXLibrary.java

@@ -37,7 +37,6 @@
 import org.python.google.common.base.Throwables;
 import org.robotframework.javalib.annotation.Autowired;
 import org.robotframework.javalib.library.AnnotationLibrary;
-import org.robotframework.remoteserver.RemoteServer;
 
 import javax.script.ScriptEngine;
 import javax.script.ScriptEngineManager;
@@ -90,12 +89,81 @@ public static String loadRobotLibraryVersion() {
     @Autowired
     protected RunOnFailure runOnFailure;
 
+    @Override
+    public Object runKeyword(String keywordName, List args, Map kwargs) {
+
+        if (kwargs == null) {
+            kwargs = new HashMap();
+        }
+
+        List finalArgs;
+        Map finalKwargs;
+
+        // JavalibCore changes arguments of Call Method keywords to Strings after this check, so they need to handle their own objectMapping
+        if (!(keywordName.equals("callObjectMethod") || keywordName.equals("callObjectMethodInFxApplicationThread"))) {
+            finalArgs = HelperFunctions.useMappedObjects(args);
+            finalKwargs = HelperFunctions.useMappedObjects(kwargs);
+        } else {
+            finalArgs = args;
+            finalKwargs = kwargs;
+        }
+
+
+        AtomicReference<Object> retval = new AtomicReference<>();
+        AtomicReference<RuntimeException> retExcep = new AtomicReference<>();
+
+        try {
+            RobotLog.ignoreDuplicates();
+            // timeout + 500 ms so that underlying timeout has a chance to expire first
+            waitFor(getWaitUntilTimeout(TimeUnit.MILLISECONDS) + 500, TimeUnit.MILLISECONDS, () -> {
+
+                try {
+                    retval.set(super.runKeyword(keywordName, finalArgs, finalKwargs));
+                    return true;
+
+                } catch (JavaFXLibraryTimeoutException jfxte){
+                    // timeout already expired, catch exception and jump out
+                    retExcep.set(jfxte);
+                    throw jfxte;
+
+                } catch (RuntimeException e){
+                    // catch exception and continue trying
+                    retExcep.set(e);
+                    return false;
+                }
+            });
+        } catch (TimeoutException te) {
+            RobotLog.reset();
+            RuntimeException e = retExcep.get();
+            runOnFailure.runOnFailure();
+
+            if (e.getCause() instanceof JavaFXLibraryFatalException) {
+                RobotLog.trace("JavaFXLibrary: Caught JavaFXLibrary FATAL exception: \n" + Throwables.getStackTraceAsString(e));
+                throw e;
+            } else if (e.getCause() instanceof JavaFXLibraryNonFatalException) {
+                RobotLog.trace("JavaFXLibrary: Caught JavaFXLibrary NON-FATAL exception: \n" + Throwables.getStackTraceAsString(e));
+                throw e;
+            } else {
+                RobotLog.trace("JavaFXLibrary: Caught JavaFXLibrary RUNTIME exception: \n" + Throwables.getStackTraceAsString(e));
+                throw e;
+            }
+        } catch (JavaFXLibraryTimeoutException jfxte) {
+            RobotLog.reset();
+            RobotLog.trace("JavaFXLibrary: Caught JavaFXLibrary TIMEOUT exception: \n" + Throwables.getStackTraceAsString(jfxte));
+            throw jfxte;
+        }
+        RobotLog.reset();
+        return retval.get();
+    }
+
     // overriding the run method to catch the control in case of failure, so that desired runOnFailureKeyword
     // can be executed in controlled manner.
     @Override
-    public Object runKeyword(String keywordName, Object[] args) {
+    public Object runKeyword(String keywordName, List args) {
+        // TODO: Check if this is ever called anymore
+        RobotLog.info("runKeyword called with args ONLY");
 
-        Object[] finalArgs;
+        List finalArgs;
         // JavalibCore changes arguments of Call Method keywords to Strings after this check, so they need to handle their own objectMapping
         if (!(keywordName.equals("callObjectMethod") || keywordName.equals("callObjectMethodInFxApplicationThread")))
             finalArgs = HelperFunctions.useMappedObjects(args);
@@ -190,22 +258,23 @@ public static JavaFXLibrary getLibraryInstance() throws ScriptException {
     }
 
     public static void main(String[] args) throws Exception {
-        JavaFXLibraryRemoteServer.configureLogging();
-        System.out.println("---------------------------= JavaFXLibrary =---------------------------- ");
-        RemoteServer server = new JavaFXLibraryRemoteServer();
-        server.putLibrary("/RPC2", new JavaFXLibrary());
         int port = 8270;
         InetAddress ipAddr = InetAddress.getLocalHost();
 
         try {
-            if (args.length > 0)
+            JavaFXLibraryRemoteServer.configureLogging();
+            System.out.println("----------------------------= JavaFXLibrary =-----------------------------");
+            if (args.length > 0) {
                 port = Integer.parseInt(args[0]);
-            else
+            }
+            else {
                 System.out.println("RemoteServer for JavaFXLibrary will be started at default port of: " + port + ".\n" +
                         "If you wish to use another port, restart the library and give port number\n" +
                         "as an argument.");
+            }
 
-            server.setPort(port);
+            JavaFXLibraryRemoteServer server = new JavaFXLibraryRemoteServer(port);
+            server.putLibrary("/RPC2", new JavaFXLibrary());
             server.start();
             System.out.println("\n    JavaFXLibrary " + ROBOT_LIBRARY_VERSION + " is now available at: " +
                     ipAddr.getHostAddress() + ":" + port + "\n");
@@ -219,6 +288,9 @@ public static void main(String[] args) throws Exception {
         } catch (BindException be) {
             System.out.println("\n        Error! " + be.getMessage() + ": " + ipAddr.getHostAddress() + ":" + port + "\n");
             System.exit(1);
+        } catch (IOException ioe) {
+            System.out.println("\n        Error! " + ioe.getMessage() + ": " + ipAddr.getHostAddress() + ":" + port + "\n");
+            System.exit(1);
         }
     }
 }

src/main/java/JavaFXLibraryRemoteServer.java

@@ -17,25 +17,27 @@
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
-import org.apache.log4j.BasicConfigurator;
-import org.apache.log4j.Level;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.core.config.Configurator;
+import org.apache.logging.log4j.core.config.DefaultConfiguration;
 import org.robotframework.remoteserver.RemoteServer;
 import org.robotframework.remoteserver.logging.Jetty2Log4J;
 
 public class JavaFXLibraryRemoteServer extends RemoteServer {
 
+    public JavaFXLibraryRemoteServer(int port) {
+        super(port);
+    }
+
     private static Log log = LogFactory.getLog(RemoteServer.class);
 
     public static void configureLogging() {
-        Logger root = Logger.getRootLogger();
-        root.removeAllAppenders();
-        BasicConfigurator.configure();
-        root.setLevel(Level.FATAL);
+        Configurator.initialize(new DefaultConfiguration());
+        Configurator.setRootLevel(Level.FATAL);
         org.eclipse.jetty.util.log.Log.setLog(new Jetty2Log4J());
         LogFactory.releaseAll();
         LogFactory.getFactory().setAttribute("org.apache.commons.logging.Log",
                 "org.apache.commons.logging.impl.Log4JLogger");
         log = LogFactory.getLog(RemoteServer.class);
     }
-}
+}