Jline3 and other console improvements

pom.xml

@@ -65,9 +65,9 @@
       <version>1.17.1</version>
     </dependency>
     <dependency>
-      <groupId>jline</groupId>
+      <groupId>org.jline</groupId>
       <artifactId>jline</artifactId>
-      <version>2.14.6</version>
+      <version>3.7.1</version>
     </dependency>
     <dependency>
       <groupId>co.aikar</groupId>
@@ -173,7 +173,6 @@
     <finalName>glowstone</finalName>
 
     <directory>${project.basedir}/target</directory>
-
     <resources>
       <resource>
         <directory>${project.basedir}/src/main/resources</directory>

src/main/java/net/glowstone/GlowServer.java

@@ -244,7 +244,7 @@ public class GlowServer implements Server {
     /**
      * The console manager of this server.
      */
-    private final ConsoleManager consoleManager = new ConsoleManager(this);
+    private ConsoleManager consoleManager = new ConsoleManager(this);
     /**
      * The services manager of this server.
      */
@@ -582,9 +582,6 @@ private static ServerConfig parseArguments(String... args) {
                 case "-o":
                     parameters.put(Key.ONLINE_MODE, Boolean.valueOf(args[++i]));
                     break;
-                case "--jline":
-                    parameters.put(Key.USE_JLINE, Boolean.valueOf(args[++i]));
-                    break;
                 case "--plugins-dir":
                 case "-P":
                     parameters.put(Key.PLUGIN_FOLDER, args[++i]);
@@ -638,7 +635,7 @@ public void run() {
      */
     public void start() {
         // Determine console mode and start reading input
-        consoleManager.startConsole(config.getBoolean(Key.USE_JLINE));
+        consoleManager.start();
         consoleManager.startFile(config.getString(Key.LOG_FILE));
 
         if (getProxySupport()) {

src/main/java/net/glowstone/i18n/LogRecordableLocalizedString.java

@@ -0,0 +1,14 @@
+package net.glowstone.i18n;
+
+import java.util.logging.LogRecord;
+
+public interface LogRecordableLocalizedString extends LoggableLocalizedString {
+
+    LogRecord record();
+
+    LogRecord record(Object... args);
+
+    LogRecord record(Throwable ex);
+
+    LogRecord record(Throwable ex, Object... args);
+}

src/main/java/net/glowstone/i18n/LoggableLocalizedStringImpl.java → src/main/java/net/glowstone/i18n/LoggedLocalizedString.java

@@ -2,23 +2,24 @@
 
 import java.util.ResourceBundle;
 import java.util.logging.Level;
+import java.util.logging.LogRecord;
 import java.util.logging.Logger;
 import net.glowstone.GlowServer;
 
-class LoggableLocalizedStringImpl extends LocalizedStringImpl
-    implements LoggableLocalizedString {
+public class LoggedLocalizedString extends LocalizedStringImpl
+    implements LoggableLocalizedString, LogRecordableLocalizedString {
 
     private final Level logLevel;
 
     private final Logger logger;
 
-    LoggableLocalizedStringImpl(String key, Level logLevel) {
+    LoggedLocalizedString(String key, Level logLevel) {
         super(key);
         this.logLevel = logLevel;
         this.logger = GlowServer.logger;
     }
 
-    LoggableLocalizedStringImpl(String key, Level logLevel,
+    LoggedLocalizedString(String key, Level logLevel,
                                 ResourceBundle resourceBundle,
                                 Logger logger) {
         super(key, resourceBundle);
@@ -45,4 +46,24 @@ public void log(Throwable ex) {
     public void log(Throwable ex, Object... args) {
         logger.log(logLevel, get(args), ex);
     }
+
+    @Override
+    public LogRecord record() {
+        return new LogRecord(logLevel, get());
+    }
+
+    @Override
+    public LogRecord record(Object... args) {
+        return new LogRecord(logLevel, get(args));
+    }
+
+    @Override
+    public LogRecord record(Throwable ex) {
+        return new LogRecord(logLevel, get(ex));
+    }
+
+    @Override
+    public LogRecord record(Throwable ex, Object... args) {
+        return new LogRecord(logLevel, get(ex, args));
+    }
 }

src/main/java/net/glowstone/util/compiler/EvalTask.java

@@ -0,0 +1,185 @@
+package net.glowstone.util.compiler;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.logging.Level;
+import javax.tools.FileObject;
+import javax.tools.ForwardingJavaFileManager;
+import javax.tools.JavaCompiler;
+import javax.tools.JavaFileObject;
+import javax.tools.SimpleJavaFileObject;
+import javax.tools.StandardJavaFileManager;
+import javax.tools.ToolProvider;
+import net.glowstone.GlowServer;
+import net.glowstone.ServerProvider;
+import net.glowstone.util.ReflectionProcessor;
+import org.bukkit.ChatColor;
+
+/**
+ * A task for which a source string must be compiled and ran to complete.
+ */
+public class EvalTask implements Runnable {
+
+    private final boolean output;
+    private final String source;
+    private static Object lastOutput = null;
+    final Map<String, byte[]> classData = new HashMap<>();
+    private MapClassLoader classLoader;
+    JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
+
+    /**
+     * Create a new EvalTask.
+     *
+     * @param command The statement to evaluate.
+     * @param output Whether the statement returns an object.
+     */
+    public EvalTask(String command, boolean output) {
+        this.output = output;
+        String evaluatedCommand;
+        if (output) {
+            evaluatedCommand = command.substring(1);
+        } else {
+            evaluatedCommand = command;
+        }
+        if (compiler == null) {
+            GlowServer.logger.info("Glowstone is not running with a JDK and REPL is falling"
+                + "back to basic parsing using reflection.");
+            source = evaluatedCommand;
+        } else {
+            source = "import org.bukkit.*;\n"
+                + "import net.glowstone.*;\n"
+                + "public class REPLShell {\n"
+                + (output ? "public static Object run(Object last) {\n"
+                    : "public static void run(Object last) {\n") + evaluatedCommand + "\n}\n}\n";
+        }
+    }
+
+    /**
+     * Compiles and runs the source associated with this evaluation task.
+     */
+    @Override
+    public void run() {
+        if (compiler == null) {
+            ReflectionProcessor processor = new ReflectionProcessor(source,
+                ServerProvider.getServer());
+            Object result = processor.process();
+            GlowServer.logger.info(
+                ChatColor.GOLD + "Eval returned: " + (result == null ? ChatColor.RED
+                    + "<no value>"
+                    : ChatColor.AQUA + result.toString()));
+            return;
+        }
+        classLoader = new MapClassLoader();
+        ClassDataFileManager classDataFileManager = new ClassDataFileManager(compiler
+            .getStandardFileManager(null, null, null));
+
+        List<JavaFileObject> compilationUnit = new ArrayList<>();
+        compilationUnit.add(new JavaSource("REPLShell", source));
+
+        JavaCompiler.CompilationTask task = compiler.getTask(null, classDataFileManager,
+            null, null, null, compilationUnit);
+        if (task.call()) {
+            try {
+                Object returned = MethodInvocationUtils
+                    .invokeStaticMethod(getCompiledClass("REPLShell"), "run",
+                        lastOutput);
+                if (output) {
+                    lastOutput = returned;
+                    GlowServer.logger.info(" -> " + returned);
+                } else {
+                    GlowServer.logger.info(" -> <no value>");
+                }
+            } catch (Exception e) {
+                GlowServer.logger.log(Level.SEVERE, "Error in running REPL shell! ", e);
+            }
+        }
+    }
+
+    /**
+     * Find a class compiled in this tasks' class loader.
+     *
+     * @param name The name of the class to find.
+     * @return The class.
+     */
+    public Class<?> getCompiledClass(String name) {
+        return classLoader.findClass(name);
+    }
+
+    private class JavaSource extends SimpleJavaFileObject {
+
+        private final String source;
+
+        JavaSource(String name, String source) {
+            super(URI.create("string:///" + name + ".java"), Kind.SOURCE);
+            this.source = source;
+        }
+
+        @Override
+        public CharSequence getCharContent(boolean ignoreEncodingErrors) throws IOException {
+            return source;
+        }
+    }
+
+    private class MapClassLoader extends ClassLoader {
+
+        @Override
+        protected Class<?> findClass(String name) {
+            return defineClass(name, classData.get(name), 0, classData.get(name).length);
+        }
+    }
+
+    public class JavaClass extends SimpleJavaFileObject {
+
+        private final String name;
+
+        public JavaClass(String name) {
+            super(URI.create("string:///" + name + ".java"), Kind.CLASS);
+            this.name = name;
+        }
+
+        @Override
+        public OutputStream openOutputStream() throws IOException {
+            return new ClassDataOutputStream(name);
+        }
+    }
+
+    public class ClassDataFileManager extends ForwardingJavaFileManager<StandardJavaFileManager> {
+
+        public ClassDataFileManager(StandardJavaFileManager fileManager) {
+            super(fileManager);
+        }
+
+        @Override
+        public JavaFileObject getJavaFileForOutput(Location location, String className,
+            JavaFileObject.Kind kind, FileObject sibling) throws IOException {
+            return new JavaClass(className);
+        }
+    }
+
+    public class ClassDataOutputStream extends OutputStream {
+
+        private final String name;
+        private final ByteArrayOutputStream bytes;
+
+        public ClassDataOutputStream(String name) {
+            this.name = name;
+            bytes = new ByteArrayOutputStream();
+        }
+
+        @Override
+        public void write(int b) throws IOException {
+            bytes.write(b);
+        }
+
+        @Override
+        public void close() throws IOException {
+            classData.put(name, bytes.toByteArray());
+        }
+    }
+}

src/main/java/net/glowstone/util/compiler/MethodInvocationUtils.java

@@ -0,0 +1,57 @@
+package net.glowstone.util.compiler;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+
+public class MethodInvocationUtils {
+
+    /**
+     * Invokes a specified static method belonging to a class.
+     *
+     * @param c The class.
+     * @param methodName The method to find in the class.
+     * @param args The arguments of the method.
+     * @return The result of invoking the method.
+     */
+    public static Object invokeStaticMethod(Class<?> c, String methodName, Object... args) {
+        Method m = findFirstMatchingStaticMethod(c, methodName, args);
+        if (m == null) {
+            throw new RuntimeException("Could not find method " + methodName);
+        }
+        try {
+            return m.invoke(null, args);
+        } catch (IllegalAccessException | IllegalArgumentException | SecurityException
+            | InvocationTargetException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private static Method findFirstMatchingStaticMethod(Class<?> c, String methodName,
+        Object... args) {
+        Method[] methods = c.getDeclaredMethods();
+        for (Method m : methods) {
+            if (m.getName().equals(methodName) && Modifier.isStatic(m.getModifiers())) {
+                Class<?>[] parameterTypes = m.getParameterTypes();
+                if (areAssignable(parameterTypes, args)) {
+                    return m;
+                }
+            }
+        }
+        return null;
+    }
+
+    private static boolean areAssignable(Class<?>[] types, Object... args) {
+        if (types.length != args.length) {
+            return false;
+        }
+        for (int i = 0; i < types.length; i++) {
+            Object arg = args[i];
+            Class<?> type = types[i];
+            if (arg != null && !type.isAssignableFrom(arg.getClass())) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

src/main/java/net/glowstone/util/config/ServerConfig.java

@@ -404,7 +404,6 @@ public enum Key {
         ALLOW_CLIENT_MODS("server.allow-client-mods", true, Boolean.class::isInstance),
 
         // console
-        USE_JLINE("console.use-jline", true, Boolean.class::isInstance),
         CONSOLE_PROMPT("console.prompt", "> ", String.class::isInstance),
         CONSOLE_DATE("console.date-format", "HH:mm:ss", String.class::isInstance),
         CONSOLE_LOG_DATE("console.log-date-format", "yyyy/MM/dd HH:mm:ss",

src/main/resources/logback.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<configuration>
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
+        </encoder>
+    </appender>
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT"/>
+    </root>
+
+    <logger name="io.netty" level="WARN"/>
+</configuration>