2020-04-27 07:34:45 +00:00
From 59e4449df98724b0bfcbad09b02ebbb6ef4a2b36 Mon Sep 17 00:00:00 2001
2018-03-08 15:08:21 +00:00
From: Minecrell <minecrell@minecrell.net>
2017-06-09 17:05:12 +00:00
Date: Fri, 9 Jun 2017 19:03:43 +0200
Subject: [PATCH] Use TerminalConsoleAppender for console improvements
Rewrite console improvements (console colors, tab completion,
persistent input line, ...) using JLine 3.x and TerminalConsoleAppender.
New features:
- Support console colors for Vanilla commands
- Add console colors for warnings and errors
- Server can now be turned off safely using CTRL + C. JLine catches
the signal and the implementation shuts down the server cleanly.
- Support console colors and persistent input line when running in
IntelliJ IDEA
Other changes:
- Server starts 1-2 seconds faster thanks to optimizations in Log4j
configuration
diff --git a/pom.xml b/pom.xml
2020-04-27 07:34:45 +00:00
index 6cc18aa360..01dcaf4f4b 100644
2017-06-09 17:05:12 +00:00
--- a/pom.xml
+++ b/pom.xml
2020-04-27 07:34:45 +00:00
@@ -44,10 +44,27 @@
2017-06-09 17:05:12 +00:00
<scope>compile</scope>
</dependency>
2018-08-26 18:11:49 +00:00
<dependency>
2017-06-09 17:05:12 +00:00
- <groupId>jline</groupId>
- <artifactId>jline</artifactId>
- <version>2.12.1</version>
- <scope>compile</scope>
+ <groupId>net.minecrell</groupId>
+ <artifactId>terminalconsoleappender</artifactId>
2019-07-24 00:25:05 +00:00
+ <version>1.2.0</version>
2017-06-09 17:05:12 +00:00
+ </dependency>
+ <dependency>
2019-07-24 00:25:05 +00:00
+ <groupId>org.jline</groupId>
+ <artifactId>jline-terminal-jansi</artifactId>
+ <version>3.12.1</version>
2017-06-09 17:05:12 +00:00
+ <scope>runtime</scope>
+ </dependency>
+ <!--
+ Required to add the missing Log4j2Plugins.dat file from log4j-core
+ which has been removed by Mojang. Without it, log4j has to classload
+ all its classes to check if they are plugins.
+ Scanning takes about 1-2 seconds so adding this speeds up the server start.
+ -->
+ <dependency>
+ <groupId>org.apache.logging.log4j</groupId>
+ <artifactId>log4j-core</artifactId>
+ <version>2.8.1</version>
+ <scope>runtime</scope>
2018-08-26 18:11:49 +00:00
</dependency>
2017-06-09 17:05:12 +00:00
<dependency>
2018-08-26 18:11:49 +00:00
<groupId>org.ow2.asm</groupId>
2020-04-27 07:34:45 +00:00
@@ -246,10 +263,18 @@
2017-06-09 17:05:12 +00:00
<transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
<resource>META-INF/services/java.sql.Driver</resource>
</transformer>
2020-04-27 07:34:45 +00:00
+ <transformer implementation="com.github.edwgiz.maven_shade_plugin.log4j2_cache_transformer.PluginsCacheFileTransformer" />
2017-06-09 17:05:12 +00:00
</transformers>
</configuration>
</execution>
</executions>
+ <dependencies>
+ <dependency>
+ <groupId>com.github.edwgiz</groupId>
+ <artifactId>maven-shade-plugin.log4j2-cachefile-transformer</artifactId>
2020-04-27 07:34:45 +00:00
+ <version>2.13.1</version>
2017-06-09 17:05:12 +00:00
+ </dependency>
+ </dependencies>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
2018-07-17 12:48:52 +00:00
diff --git a/src/main/java/com/destroystokyo/paper/console/PaperConsole.java b/src/main/java/com/destroystokyo/paper/console/PaperConsole.java
new file mode 100644
Improve mid tick chunk loading, Fix Oversleep, other improvements
Process loads outside of any canSleep check. Original intent was to
only apply those restrictions to generations but realized I had some
checks higher up the call chain.
Reworked the back off strategy to just run every 1 millisecond per world,
and to apply the per tick limit to generations only.
This guarantees that your chunk will load with at most around 1ms delay.
Additionally, fire midTick processing in a few more places, notably the
oversleep section so we can keep processing loads here too which has
a large up to 50ms window...
Speaking of oversleep, we had a bug in our implementation changes for
Timings that caused oversleep to not sleep the correct amount.
Because we now moved it into the NEXT tick instead of THIS tick, the
value of nextTick had already been increased to +50ms, resulting in
the risk of sleeping more than it should, but, more importantly, this
caused every task that was trying to NOT run during oversleep to actually
run during oversleep.
This is now fixed.
Another small tweak is to the /tps command, to no longer show the star when
TPS is right at 20.
Due to ineffeciencies in the sleep precision, TPS is commonly 20.02.
This causes the star to show up almost constantly, so now only show it if
we actually hit a real "catchup".
This commit also improves the changes to the CallbackExecutor, in that
it now is also recursion safe.
It was possible that the executor could run tasks out of desired order
if the executor task scheduled more executor tasks.
We solve this by ensuring new additions do not enter the currently iterated queue.
Each depth level will have its own queue.
Fixes #3220
2020-04-26 03:47:29 +00:00
index 0000000000..cd6e259239
2018-07-17 12:48:52 +00:00
--- /dev/null
+++ b/src/main/java/com/destroystokyo/paper/console/PaperConsole.java
@@ -0,0 +1,40 @@
+package com.destroystokyo.paper.console;
+
+import net.minecraft.server.DedicatedServer;
+import net.minecrell.terminalconsole.SimpleTerminalConsole;
+import org.bukkit.craftbukkit.command.ConsoleCommandCompleter;
+import org.jline.reader.LineReader;
+import org.jline.reader.LineReaderBuilder;
+
+public final class PaperConsole extends SimpleTerminalConsole {
+
+ private final DedicatedServer server;
+
+ public PaperConsole(DedicatedServer server) {
+ this.server = server;
+ }
+
+ @Override
+ protected LineReader buildReader(LineReaderBuilder builder) {
+ return super.buildReader(builder
+ .appName("Paper")
+ .completer(new ConsoleCommandCompleter(this.server))
+ );
+ }
+
+ @Override
+ protected boolean isRunning() {
+ return !this.server.isStopped() && this.server.isRunning();
+ }
+
+ @Override
+ protected void runCommand(String command) {
2018-07-19 19:23:18 +00:00
+ this.server.issueCommand(command, this.server.getServerCommandListener());
2018-07-17 12:48:52 +00:00
+ }
+
+ @Override
+ protected void shutdown() {
2019-05-05 23:24:37 +00:00
+ this.server.safeShutdown(false);
2018-07-17 12:48:52 +00:00
+ }
+
+}
2017-06-09 17:05:12 +00:00
diff --git a/src/main/java/com/destroystokyo/paper/console/TerminalConsoleCommandSender.java b/src/main/java/com/destroystokyo/paper/console/TerminalConsoleCommandSender.java
new file mode 100644
Improve mid tick chunk loading, Fix Oversleep, other improvements
Process loads outside of any canSleep check. Original intent was to
only apply those restrictions to generations but realized I had some
checks higher up the call chain.
Reworked the back off strategy to just run every 1 millisecond per world,
and to apply the per tick limit to generations only.
This guarantees that your chunk will load with at most around 1ms delay.
Additionally, fire midTick processing in a few more places, notably the
oversleep section so we can keep processing loads here too which has
a large up to 50ms window...
Speaking of oversleep, we had a bug in our implementation changes for
Timings that caused oversleep to not sleep the correct amount.
Because we now moved it into the NEXT tick instead of THIS tick, the
value of nextTick had already been increased to +50ms, resulting in
the risk of sleeping more than it should, but, more importantly, this
caused every task that was trying to NOT run during oversleep to actually
run during oversleep.
This is now fixed.
Another small tweak is to the /tps command, to no longer show the star when
TPS is right at 20.
Due to ineffeciencies in the sleep precision, TPS is commonly 20.02.
This causes the star to show up almost constantly, so now only show it if
we actually hit a real "catchup".
This commit also improves the changes to the CallbackExecutor, in that
it now is also recursion safe.
It was possible that the executor could run tasks out of desired order
if the executor task scheduled more executor tasks.
We solve this by ensuring new additions do not enter the currently iterated queue.
Each depth level will have its own queue.
Fixes #3220
2020-04-26 03:47:29 +00:00
index 0000000000..685deaa0e5
2017-06-09 17:05:12 +00:00
--- /dev/null
+++ b/src/main/java/com/destroystokyo/paper/console/TerminalConsoleCommandSender.java
2017-06-21 08:46:18 +00:00
@@ -0,0 +1,17 @@
2017-06-09 17:05:12 +00:00
+package com.destroystokyo.paper.console;
+
2017-06-21 08:46:18 +00:00
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
2017-06-09 17:05:12 +00:00
+import org.bukkit.craftbukkit.command.CraftConsoleCommandSender;
+
+public class TerminalConsoleCommandSender extends CraftConsoleCommandSender {
+
2017-06-21 08:46:18 +00:00
+ private static final Logger LOGGER = LogManager.getRootLogger();
+
2017-06-09 17:05:12 +00:00
+ @Override
+ public void sendRawMessage(String message) {
2017-06-21 08:46:18 +00:00
+ // TerminalConsoleAppender supports color codes directly in log messages
+ LOGGER.info(message);
2017-06-09 17:05:12 +00:00
+ }
+
+}
diff --git a/src/main/java/net/minecraft/server/DedicatedServer.java b/src/main/java/net/minecraft/server/DedicatedServer.java
Improve mid tick chunk loading, Fix Oversleep, other improvements
Process loads outside of any canSleep check. Original intent was to
only apply those restrictions to generations but realized I had some
checks higher up the call chain.
Reworked the back off strategy to just run every 1 millisecond per world,
and to apply the per tick limit to generations only.
This guarantees that your chunk will load with at most around 1ms delay.
Additionally, fire midTick processing in a few more places, notably the
oversleep section so we can keep processing loads here too which has
a large up to 50ms window...
Speaking of oversleep, we had a bug in our implementation changes for
Timings that caused oversleep to not sleep the correct amount.
Because we now moved it into the NEXT tick instead of THIS tick, the
value of nextTick had already been increased to +50ms, resulting in
the risk of sleeping more than it should, but, more importantly, this
caused every task that was trying to NOT run during oversleep to actually
run during oversleep.
This is now fixed.
Another small tweak is to the /tps command, to no longer show the star when
TPS is right at 20.
Due to ineffeciencies in the sleep precision, TPS is commonly 20.02.
This causes the star to show up almost constantly, so now only show it if
we actually hit a real "catchup".
This commit also improves the changes to the CallbackExecutor, in that
it now is also recursion safe.
It was possible that the executor could run tasks out of desired order
if the executor task scheduled more executor tasks.
We solve this by ensuring new additions do not enter the currently iterated queue.
Each depth level will have its own queue.
Fixes #3220
2020-04-26 03:47:29 +00:00
index 4b1f8c5373..d34f772fae 100644
2017-06-09 17:05:12 +00:00
--- a/src/main/java/net/minecraft/server/DedicatedServer.java
+++ b/src/main/java/net/minecraft/server/DedicatedServer.java
2020-01-24 21:30:15 +00:00
@@ -86,6 +86,9 @@ public class DedicatedServer extends MinecraftServer implements IMinecraftServer
2017-06-09 17:05:12 +00:00
if (!org.bukkit.craftbukkit.Main.useConsole) {
return;
}
2018-07-17 12:48:52 +00:00
+ // Paper start - Use TerminalConsoleAppender
2020-01-24 21:30:15 +00:00
+ new com.destroystokyo.paper.console.PaperConsole(DedicatedServer.this).start();
2018-07-17 12:48:52 +00:00
+ /*
jline.console.ConsoleReader bufferedreader = reader;
2017-06-09 17:05:12 +00:00
2020-01-28 19:43:57 +00:00
// MC-33041, SPIGOT-5538: if System.in is not valid due to javaw, then return
@@ -125,6 +128,8 @@ public class DedicatedServer extends MinecraftServer implements IMinecraftServer
2018-07-17 12:48:52 +00:00
DedicatedServer.LOGGER.error("Exception handling console input", ioexception);
}
+ */
+ // Paper end
}
};
2020-01-28 19:43:57 +00:00
@@ -136,6 +141,9 @@ public class DedicatedServer extends MinecraftServer implements IMinecraftServer
2017-06-09 17:05:12 +00:00
}
2017-06-13 08:10:22 +00:00
global.addHandler(new org.bukkit.craftbukkit.util.ForwardLogHandler());
+ // Paper start - Not needed with TerminalConsoleAppender
+ final org.apache.logging.log4j.Logger logger = LogManager.getRootLogger();
+ /*
final org.apache.logging.log4j.core.Logger logger = ((org.apache.logging.log4j.core.Logger) LogManager.getRootLogger());
for (org.apache.logging.log4j.core.Appender appender : logger.getAppenders().values()) {
if (appender instanceof org.apache.logging.log4j.core.appender.ConsoleAppender) {
2020-01-28 19:43:57 +00:00
@@ -144,6 +152,8 @@ public class DedicatedServer extends MinecraftServer implements IMinecraftServer
2017-06-13 08:10:22 +00:00
}
2019-04-27 06:26:04 +00:00
new org.bukkit.craftbukkit.util.TerminalConsoleWriterThread(System.out, this.reader).start();
2017-06-13 08:10:22 +00:00
+ */
+ // Paper end
2017-06-09 17:05:12 +00:00
System.setOut(new PrintStream(new LoggerOutputStream(logger, Level.INFO), true));
System.setErr(new PrintStream(new LoggerOutputStream(logger, Level.WARN), true));
diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
Improve mid tick chunk loading, Fix Oversleep, other improvements
Process loads outside of any canSleep check. Original intent was to
only apply those restrictions to generations but realized I had some
checks higher up the call chain.
Reworked the back off strategy to just run every 1 millisecond per world,
and to apply the per tick limit to generations only.
This guarantees that your chunk will load with at most around 1ms delay.
Additionally, fire midTick processing in a few more places, notably the
oversleep section so we can keep processing loads here too which has
a large up to 50ms window...
Speaking of oversleep, we had a bug in our implementation changes for
Timings that caused oversleep to not sleep the correct amount.
Because we now moved it into the NEXT tick instead of THIS tick, the
value of nextTick had already been increased to +50ms, resulting in
the risk of sleeping more than it should, but, more importantly, this
caused every task that was trying to NOT run during oversleep to actually
run during oversleep.
This is now fixed.
Another small tweak is to the /tps command, to no longer show the star when
TPS is right at 20.
Due to ineffeciencies in the sleep precision, TPS is commonly 20.02.
This causes the star to show up almost constantly, so now only show it if
we actually hit a real "catchup".
This commit also improves the changes to the CallbackExecutor, in that
it now is also recursion safe.
It was possible that the executor could run tasks out of desired order
if the executor task scheduled more executor tasks.
We solve this by ensuring new additions do not enter the currently iterated queue.
Each depth level will have its own queue.
Fixes #3220
2020-04-26 03:47:29 +00:00
index 8d6a089007..284793e4bf 100644
2017-06-09 17:05:12 +00:00
--- a/src/main/java/net/minecraft/server/MinecraftServer.java
+++ b/src/main/java/net/minecraft/server/MinecraftServer.java
2019-07-20 04:01:24 +00:00
@@ -57,7 +57,7 @@ import org.apache.commons.lang3.Validate;
2017-06-09 17:05:12 +00:00
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
// CraftBukkit start
-import jline.console.ConsoleReader;
2019-04-27 06:26:04 +00:00
+import joptsimple.OptionSet;
2017-06-09 17:05:12 +00:00
import org.bukkit.Bukkit;
import org.bukkit.craftbukkit.CraftServer;
2019-04-27 06:26:04 +00:00
import org.bukkit.craftbukkit.Main;
2019-12-11 23:43:22 +00:00
@@ -161,7 +161,7 @@ public abstract class MinecraftServer extends IAsyncTaskHandlerReentrant<TickTas
2017-06-09 17:05:12 +00:00
public OptionSet options;
public org.bukkit.command.ConsoleCommandSender console;
public org.bukkit.command.RemoteConsoleCommandSender remoteConsole;
- public ConsoleReader reader;
+ //public ConsoleReader reader; // Paper
public static int currentTick = 0; // Paper - Further improve tick loop
2019-04-27 06:26:04 +00:00
public java.util.Queue<Runnable> processQueue = new java.util.concurrent.ConcurrentLinkedQueue<Runnable>();
public int autosavePeriod;
2019-12-11 23:43:22 +00:00
@@ -212,7 +212,9 @@ public abstract class MinecraftServer extends IAsyncTaskHandlerReentrant<TickTas
2019-07-20 04:01:24 +00:00
this.K = s;
2017-06-09 17:05:12 +00:00
// CraftBukkit start
this.options = options;
+ // Paper start - Handled by TerminalConsoleAppender
// Try to see if we're actually running in a terminal, disable jline if not
+ /*
if (System.console() == null && System.getProperty("jline.terminal") == null) {
System.setProperty("jline.terminal", "jline.UnsupportedTerminal");
Main.useJline = false;
2019-12-11 23:43:22 +00:00
@@ -233,6 +235,8 @@ public abstract class MinecraftServer extends IAsyncTaskHandlerReentrant<TickTas
2017-06-09 17:05:12 +00:00
LOGGER.warn((String) null, ex);
}
}
+ */
+ // Paper end
Runtime.getRuntime().addShutdownHook(new org.bukkit.craftbukkit.util.ServerShutdownThread(this));
2019-04-27 06:26:04 +00:00
}
// CraftBukkit end
2020-01-22 02:02:07 +00:00
@@ -951,7 +955,7 @@ public abstract class MinecraftServer extends IAsyncTaskHandlerReentrant<TickTas
2019-12-23 02:37:47 +00:00
org.spigotmc.WatchdogThread.doStop(); // Spigot
2017-06-09 17:05:12 +00:00
// CraftBukkit start - Restore terminal to original settings
try {
- reader.getTerminal().restore();
+ net.minecrell.terminalconsole.TerminalConsoleAppender.close(); // Paper - Use TerminalConsoleAppender
} catch (Exception ignored) {
}
// CraftBukkit end
Improve mid tick chunk loading, Fix Oversleep, other improvements
Process loads outside of any canSleep check. Original intent was to
only apply those restrictions to generations but realized I had some
checks higher up the call chain.
Reworked the back off strategy to just run every 1 millisecond per world,
and to apply the per tick limit to generations only.
This guarantees that your chunk will load with at most around 1ms delay.
Additionally, fire midTick processing in a few more places, notably the
oversleep section so we can keep processing loads here too which has
a large up to 50ms window...
Speaking of oversleep, we had a bug in our implementation changes for
Timings that caused oversleep to not sleep the correct amount.
Because we now moved it into the NEXT tick instead of THIS tick, the
value of nextTick had already been increased to +50ms, resulting in
the risk of sleeping more than it should, but, more importantly, this
caused every task that was trying to NOT run during oversleep to actually
run during oversleep.
This is now fixed.
Another small tweak is to the /tps command, to no longer show the star when
TPS is right at 20.
Due to ineffeciencies in the sleep precision, TPS is commonly 20.02.
This causes the star to show up almost constantly, so now only show it if
we actually hit a real "catchup".
This commit also improves the changes to the CallbackExecutor, in that
it now is also recursion safe.
It was possible that the executor could run tasks out of desired order
if the executor task scheduled more executor tasks.
We solve this by ensuring new additions do not enter the currently iterated queue.
Each depth level will have its own queue.
Fixes #3220
2020-04-26 03:47:29 +00:00
@@ -1475,7 +1479,7 @@ public abstract class MinecraftServer extends IAsyncTaskHandlerReentrant<TickTas
2017-06-09 17:05:12 +00:00
2019-04-27 06:26:04 +00:00
@Override
2017-06-09 17:05:12 +00:00
public void sendMessage(IChatBaseComponent ichatbasecomponent) {
2018-07-18 00:08:13 +00:00
- MinecraftServer.LOGGER.info(ichatbasecomponent.getString());
+ MinecraftServer.LOGGER.info(org.bukkit.craftbukkit.util.CraftChatMessage.fromComponent(ichatbasecomponent, net.minecraft.server.EnumChatFormat.WHITE));// Paper - Log message with colors
2017-06-09 17:05:12 +00:00
}
2019-04-27 06:26:04 +00:00
public KeyPair getKeyPair() {
2017-06-09 17:05:12 +00:00
diff --git a/src/main/java/net/minecraft/server/PlayerList.java b/src/main/java/net/minecraft/server/PlayerList.java
Improve mid tick chunk loading, Fix Oversleep, other improvements
Process loads outside of any canSleep check. Original intent was to
only apply those restrictions to generations but realized I had some
checks higher up the call chain.
Reworked the back off strategy to just run every 1 millisecond per world,
and to apply the per tick limit to generations only.
This guarantees that your chunk will load with at most around 1ms delay.
Additionally, fire midTick processing in a few more places, notably the
oversleep section so we can keep processing loads here too which has
a large up to 50ms window...
Speaking of oversleep, we had a bug in our implementation changes for
Timings that caused oversleep to not sleep the correct amount.
Because we now moved it into the NEXT tick instead of THIS tick, the
value of nextTick had already been increased to +50ms, resulting in
the risk of sleeping more than it should, but, more importantly, this
caused every task that was trying to NOT run during oversleep to actually
run during oversleep.
This is now fixed.
Another small tweak is to the /tps command, to no longer show the star when
TPS is right at 20.
Due to ineffeciencies in the sleep precision, TPS is commonly 20.02.
This causes the star to show up almost constantly, so now only show it if
we actually hit a real "catchup".
This commit also improves the changes to the CallbackExecutor, in that
it now is also recursion safe.
It was possible that the executor could run tasks out of desired order
if the executor task scheduled more executor tasks.
We solve this by ensuring new additions do not enter the currently iterated queue.
Each depth level will have its own queue.
Fixes #3220
2020-04-26 03:47:29 +00:00
index 56266a7729..77f1ddc8a8 100644
2017-06-09 17:05:12 +00:00
--- a/src/main/java/net/minecraft/server/PlayerList.java
+++ b/src/main/java/net/minecraft/server/PlayerList.java
2019-04-27 06:26:04 +00:00
@@ -76,8 +76,7 @@ public abstract class PlayerList {
2017-06-09 17:05:12 +00:00
2019-04-27 06:26:04 +00:00
public PlayerList(MinecraftServer minecraftserver, int i) {
this.cserver = minecraftserver.server = new CraftServer((DedicatedServer) minecraftserver, this);
2017-06-09 17:05:12 +00:00
- minecraftserver.console = org.bukkit.craftbukkit.command.ColouredConsoleSender.getInstance();
- minecraftserver.reader.addCompleter(new org.bukkit.craftbukkit.command.ConsoleCommandCompleter(minecraftserver.server));
+ minecraftserver.console = new com.destroystokyo.paper.console.TerminalConsoleCommandSender(); // Paper
// CraftBukkit end
2019-12-11 23:43:22 +00:00
this.k = new GameProfileBanList(PlayerList.b);
2017-06-09 17:05:12 +00:00
diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
2020-04-27 07:34:45 +00:00
index 9eb4acf93c..681a84e5b3 100644
2017-06-09 17:05:12 +00:00
--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
2020-04-27 07:34:45 +00:00
@@ -42,7 +42,7 @@ import java.util.function.Consumer;
import java.util.logging.Level;
2019-04-27 06:26:04 +00:00
import java.util.logging.Logger;
import javax.imageio.ImageIO;
2017-06-09 17:05:12 +00:00
-import jline.console.ConsoleReader;
2020-04-27 07:34:45 +00:00
+//import jline.console.ConsoleReader; // Paper
2019-04-27 06:26:04 +00:00
import net.minecraft.server.Advancement;
import net.minecraft.server.ArgumentEntity;
import net.minecraft.server.Block;
2020-04-27 07:34:45 +00:00
@@ -1118,9 +1118,13 @@ public final class CraftServer implements Server {
2017-06-09 17:05:12 +00:00
return logger;
}
+ // Paper start - JLine update
+ /*
public ConsoleReader getReader() {
return console.reader;
}
+ */
+ // Paper end
@Override
public PluginCommand getPluginCommand(String name) {
diff --git a/src/main/java/org/bukkit/craftbukkit/Main.java b/src/main/java/org/bukkit/craftbukkit/Main.java
2020-04-27 07:34:45 +00:00
index f9d07e5ca7..9fdad34bb8 100644
2017-06-09 17:05:12 +00:00
--- a/src/main/java/org/bukkit/craftbukkit/Main.java
+++ b/src/main/java/org/bukkit/craftbukkit/Main.java
2019-04-27 06:26:04 +00:00
@@ -13,7 +13,7 @@ import java.util.logging.Logger;
2017-06-09 17:05:12 +00:00
import joptsimple.OptionParser;
import joptsimple.OptionSet;
import net.minecraft.server.MinecraftServer;
-import org.fusesource.jansi.AnsiConsole;
+import net.minecrell.terminalconsole.TerminalConsoleAppender; // Paper
public class Main {
public static boolean useJline = true;
2020-01-22 02:02:07 +00:00
@@ -179,6 +179,8 @@ public class Main {
2017-06-09 17:05:12 +00:00
}
try {
+ // Paper start - Handled by TerminalConsoleAppender
+ /*
// This trick bypasses Maven Shade's clever rewriting of our getProperty call when using String literals
2020-04-27 07:34:45 +00:00
String jline_UnsupportedTerminal = new String(new char[]{'j', 'l', 'i', 'n', 'e', '.', 'U', 'n', 's', 'u', 'p', 'p', 'o', 'r', 't', 'e', 'd', 'T', 'e', 'r', 'm', 'i', 'n', 'a', 'l'});
String jline_terminal = new String(new char[]{'j', 'l', 'i', 'n', 'e', '.', 't', 'e', 'r', 'm', 'i', 'n', 'a', 'l'});
@@ -196,9 +198,18 @@ public class Main {
2017-06-09 17:05:12 +00:00
// This ensures the terminal literal will always match the jline implementation
System.setProperty(jline.TerminalFactory.JLINE_TERMINAL, jline.UnsupportedTerminal.class.getName());
}
+ */
2020-04-27 07:34:45 +00:00
+
2017-06-09 17:05:12 +00:00
+ if (options.has("nojline")) {
+ System.setProperty(TerminalConsoleAppender.JLINE_OVERRIDE_PROPERTY, "false");
+ useJline = false;
+ }
+ // Paper end
if (options.has("noconsole")) {
useConsole = false;
+ useJline = false; // Paper
+ System.setProperty(TerminalConsoleAppender.JLINE_OVERRIDE_PROPERTY, "false"); // Paper
}
2020-01-22 02:02:07 +00:00
if (Main.class.getPackage().getImplementationVendor() != null && System.getProperty("IReallyKnowWhatIAmDoingISwear") == null) {
2020-04-27 07:34:45 +00:00
@@ -226,7 +237,7 @@ public class Main {
2019-10-13 21:35:54 +00:00
System.out.println("Unable to read system info");
}
// Paper end
-
+ System.setProperty( "library.jansi.version", "Paper" ); // Paper - set meaningless jansi version to prevent git builds from crashing on Windows
System.out.println("Loading libraries, please wait...");
MinecraftServer.main(options);
} catch (Throwable t) {
2017-06-09 17:05:12 +00:00
diff --git a/src/main/java/org/bukkit/craftbukkit/command/ColouredConsoleSender.java b/src/main/java/org/bukkit/craftbukkit/command/ColouredConsoleSender.java
2020-04-27 07:34:45 +00:00
index e0bd5adc19..aae615c13b 100644
2017-06-09 17:05:12 +00:00
--- a/src/main/java/org/bukkit/craftbukkit/command/ColouredConsoleSender.java
2020-04-27 07:34:45 +00:00
+++ b/src/main/java/org/bukkit/craftbukkit/command/ColouredConsoleSender.java
@@ -2,15 +2,15 @@ package org.bukkit.craftbukkit.command;
import java.util.EnumMap;
import java.util.Map;
2017-06-09 17:05:12 +00:00
-import jline.Terminal;
2020-04-27 07:34:45 +00:00
+//import jline.Terminal;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.command.ConsoleCommandSender;
import org.bukkit.craftbukkit.CraftServer;
2019-04-27 06:26:04 +00:00
-import org.fusesource.jansi.Ansi;
-import org.fusesource.jansi.Ansi.Attribute;
2020-04-27 07:34:45 +00:00
+//import org.fusesource.jansi.Ansi;
+//import org.fusesource.jansi.Ansi.Attribute;
2017-06-09 17:05:12 +00:00
-public class ColouredConsoleSender extends CraftConsoleCommandSender {
2020-04-27 07:34:45 +00:00
+public class ColouredConsoleSender /*extends CraftConsoleCommandSender */{/* // Paper - disable
private final Terminal terminal;
private final Map<ChatColor, String> replacements = new EnumMap<ChatColor, String>(ChatColor.class);
private final ChatColor[] colors = ChatColor.values();
@@ -71,5 +71,5 @@ public class ColouredConsoleSender extends CraftConsoleCommandSender {
} else {
return new ColouredConsoleSender();
}
2017-06-09 17:05:12 +00:00
- }
2020-04-27 07:34:45 +00:00
+ }*/ // Paper
}
2017-06-09 17:05:12 +00:00
diff --git a/src/main/java/org/bukkit/craftbukkit/command/ConsoleCommandCompleter.java b/src/main/java/org/bukkit/craftbukkit/command/ConsoleCommandCompleter.java
Improve mid tick chunk loading, Fix Oversleep, other improvements
Process loads outside of any canSleep check. Original intent was to
only apply those restrictions to generations but realized I had some
checks higher up the call chain.
Reworked the back off strategy to just run every 1 millisecond per world,
and to apply the per tick limit to generations only.
This guarantees that your chunk will load with at most around 1ms delay.
Additionally, fire midTick processing in a few more places, notably the
oversleep section so we can keep processing loads here too which has
a large up to 50ms window...
Speaking of oversleep, we had a bug in our implementation changes for
Timings that caused oversleep to not sleep the correct amount.
Because we now moved it into the NEXT tick instead of THIS tick, the
value of nextTick had already been increased to +50ms, resulting in
the risk of sleeping more than it should, but, more importantly, this
caused every task that was trying to NOT run during oversleep to actually
run during oversleep.
This is now fixed.
Another small tweak is to the /tps command, to no longer show the star when
TPS is right at 20.
Due to ineffeciencies in the sleep precision, TPS is commonly 20.02.
This causes the star to show up almost constantly, so now only show it if
we actually hit a real "catchup".
This commit also improves the changes to the CallbackExecutor, in that
it now is also recursion safe.
It was possible that the executor could run tasks out of desired order
if the executor task scheduled more executor tasks.
We solve this by ensuring new additions do not enter the currently iterated queue.
Each depth level will have its own queue.
Fixes #3220
2020-04-26 03:47:29 +00:00
index befcc19f9b..5510266fb1 100644
2017-06-09 17:05:12 +00:00
--- a/src/main/java/org/bukkit/craftbukkit/command/ConsoleCommandCompleter.java
+++ b/src/main/java/org/bukkit/craftbukkit/command/ConsoleCommandCompleter.java
2019-05-06 02:58:04 +00:00
@@ -4,20 +4,31 @@ import java.util.Collections;
2019-04-27 06:26:04 +00:00
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.logging.Level;
-import jline.console.completer.Completer;
2017-06-09 17:05:12 +00:00
import org.bukkit.craftbukkit.CraftServer;
import org.bukkit.craftbukkit.util.Waitable;
2019-04-27 06:26:04 +00:00
+
2017-06-09 17:05:12 +00:00
+// Paper start - JLine update
+import net.minecraft.server.DedicatedServer; // Paper
+import org.jline.reader.Candidate;
+import org.jline.reader.Completer;
+import org.jline.reader.LineReader;
+import org.jline.reader.ParsedLine;
+// Paper end
import org.bukkit.event.server.TabCompleteEvent;
public class ConsoleCommandCompleter implements Completer {
- private final CraftServer server;
+ private final DedicatedServer server; // Paper - CraftServer -> DedicatedServer
- public ConsoleCommandCompleter(CraftServer server) {
+ public ConsoleCommandCompleter(DedicatedServer server) { // Paper - CraftServer -> DedicatedServer
this.server = server;
}
+ // Paper start - Change method signature for JLine update
2019-05-06 02:58:04 +00:00
@Override
- public int complete(final String buffer, final int cursor, final List<CharSequence> candidates) {
2017-06-09 17:05:12 +00:00
+ public void complete(LineReader reader, ParsedLine line, List<Candidate> candidates) {
+ final CraftServer server = this.server.server;
+ final String buffer = line.line();
+ // Paper end
Waitable<List<String>> waitable = new Waitable<List<String>>() {
@Override
protected List<String> evaluate() {
2019-05-06 02:58:04 +00:00
@@ -29,25 +40,37 @@ public class ConsoleCommandCompleter implements Completer {
2017-06-09 17:05:12 +00:00
return tabEvent.isCancelled() ? Collections.EMPTY_LIST : tabEvent.getCompletions();
}
};
- this.server.getServer().processQueue.add(waitable);
+ server.getServer().processQueue.add(waitable); // Paper - Remove "this."
try {
List<String> offers = waitable.get();
if (offers == null) {
- return cursor;
+ return; // Paper - Method returns void
2019-04-27 06:26:04 +00:00
+ }
+
2017-06-09 17:05:12 +00:00
+ // Paper start - JLine update
+ for (String completion : offers) {
+ if (completion.isEmpty()) {
+ continue;
+ }
+
+ candidates.add(new Candidate(completion));
2019-04-27 06:26:04 +00:00
}
- candidates.addAll(offers);
2017-06-09 17:05:12 +00:00
+ // Paper end
2019-04-27 06:26:04 +00:00
2017-06-09 17:05:12 +00:00
+ // Paper start - JLine handles cursor now
+ /*
final int lastSpace = buffer.lastIndexOf(' ');
if (lastSpace == -1) {
return cursor - buffer.length();
} else {
return cursor - (buffer.length() - lastSpace - 1);
}
+ */
+ // Paper end
} catch (ExecutionException e) {
- this.server.getLogger().log(Level.WARNING, "Unhandled exception when tab completing", e);
+ server.getLogger().log(Level.WARNING, "Unhandled exception when tab completing", e); // Paper - Remove "this."
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
- return cursor;
}
}
diff --git a/src/main/java/org/bukkit/craftbukkit/util/ServerShutdownThread.java b/src/main/java/org/bukkit/craftbukkit/util/ServerShutdownThread.java
Improve mid tick chunk loading, Fix Oversleep, other improvements
Process loads outside of any canSleep check. Original intent was to
only apply those restrictions to generations but realized I had some
checks higher up the call chain.
Reworked the back off strategy to just run every 1 millisecond per world,
and to apply the per tick limit to generations only.
This guarantees that your chunk will load with at most around 1ms delay.
Additionally, fire midTick processing in a few more places, notably the
oversleep section so we can keep processing loads here too which has
a large up to 50ms window...
Speaking of oversleep, we had a bug in our implementation changes for
Timings that caused oversleep to not sleep the correct amount.
Because we now moved it into the NEXT tick instead of THIS tick, the
value of nextTick had already been increased to +50ms, resulting in
the risk of sleeping more than it should, but, more importantly, this
caused every task that was trying to NOT run during oversleep to actually
run during oversleep.
This is now fixed.
Another small tweak is to the /tps command, to no longer show the star when
TPS is right at 20.
Due to ineffeciencies in the sleep precision, TPS is commonly 20.02.
This causes the star to show up almost constantly, so now only show it if
we actually hit a real "catchup".
This commit also improves the changes to the CallbackExecutor, in that
it now is also recursion safe.
It was possible that the executor could run tasks out of desired order
if the executor task scheduled more executor tasks.
We solve this by ensuring new additions do not enter the currently iterated queue.
Each depth level will have its own queue.
Fixes #3220
2020-04-26 03:47:29 +00:00
index 70f8d42992..449e99d1b6 100644
2017-06-09 17:05:12 +00:00
--- a/src/main/java/org/bukkit/craftbukkit/util/ServerShutdownThread.java
+++ b/src/main/java/org/bukkit/craftbukkit/util/ServerShutdownThread.java
2019-04-27 06:26:04 +00:00
@@ -17,7 +17,7 @@ public class ServerShutdownThread extends Thread {
server.close();
2017-06-09 17:05:12 +00:00
} finally {
try {
- server.reader.getTerminal().restore();
+ net.minecrell.terminalconsole.TerminalConsoleAppender.close(); // Paper - Use TerminalConsoleAppender
} catch (Exception e) {
}
}
diff --git a/src/main/java/org/bukkit/craftbukkit/util/TerminalConsoleWriterThread.java b/src/main/java/org/bukkit/craftbukkit/util/TerminalConsoleWriterThread.java
2020-04-27 07:34:45 +00:00
index 99564fed7c..9a2da548b8 100644
2017-06-09 17:05:12 +00:00
--- a/src/main/java/org/bukkit/craftbukkit/util/TerminalConsoleWriterThread.java
2020-04-27 07:34:45 +00:00
+++ b/src/main/java/org/bukkit/craftbukkit/util/TerminalConsoleWriterThread.java
@@ -5,12 +5,12 @@ import java.io.IOException;
import java.io.OutputStream;
import java.util.logging.Level;
import java.util.logging.Logger;
2017-06-09 17:05:12 +00:00
-import jline.console.ConsoleReader;
2020-04-27 07:34:45 +00:00
+//import jline.console.ConsoleReader;
import org.bukkit.craftbukkit.Main;
2017-06-09 17:05:12 +00:00
-import org.fusesource.jansi.Ansi;
-import org.fusesource.jansi.Ansi.Erase;
2020-04-27 07:34:45 +00:00
+//import org.fusesource.jansi.Ansi;
+//import org.fusesource.jansi.Ansi.Erase;
2019-04-27 06:26:04 +00:00
-public class TerminalConsoleWriterThread extends Thread {
2020-04-27 07:34:45 +00:00
+public class TerminalConsoleWriterThread /*extends Thread*/ {/* // Paper - disable
private final ConsoleReader reader;
private final OutputStream output;
@@ -54,5 +54,5 @@ public class TerminalConsoleWriterThread extends Thread {
Logger.getLogger(TerminalConsoleWriterThread.class.getName()).log(Level.SEVERE, null, ex);
}
}
2017-06-09 17:05:12 +00:00
- }
2020-04-27 07:34:45 +00:00
+ }*/
}
2019-07-24 00:25:05 +00:00
diff --git a/src/main/resources/log4j2.component.properties b/src/main/resources/log4j2.component.properties
new file mode 100644
Improve mid tick chunk loading, Fix Oversleep, other improvements
Process loads outside of any canSleep check. Original intent was to
only apply those restrictions to generations but realized I had some
checks higher up the call chain.
Reworked the back off strategy to just run every 1 millisecond per world,
and to apply the per tick limit to generations only.
This guarantees that your chunk will load with at most around 1ms delay.
Additionally, fire midTick processing in a few more places, notably the
oversleep section so we can keep processing loads here too which has
a large up to 50ms window...
Speaking of oversleep, we had a bug in our implementation changes for
Timings that caused oversleep to not sleep the correct amount.
Because we now moved it into the NEXT tick instead of THIS tick, the
value of nextTick had already been increased to +50ms, resulting in
the risk of sleeping more than it should, but, more importantly, this
caused every task that was trying to NOT run during oversleep to actually
run during oversleep.
This is now fixed.
Another small tweak is to the /tps command, to no longer show the star when
TPS is right at 20.
Due to ineffeciencies in the sleep precision, TPS is commonly 20.02.
This causes the star to show up almost constantly, so now only show it if
we actually hit a real "catchup".
This commit also improves the changes to the CallbackExecutor, in that
it now is also recursion safe.
It was possible that the executor could run tasks out of desired order
if the executor task scheduled more executor tasks.
We solve this by ensuring new additions do not enter the currently iterated queue.
Each depth level will have its own queue.
Fixes #3220
2020-04-26 03:47:29 +00:00
index 0000000000..0694b21465
2019-07-24 00:25:05 +00:00
--- /dev/null
+++ b/src/main/resources/log4j2.component.properties
@@ -0,0 +1 @@
+log4j.skipJansi=true
2017-06-09 17:05:12 +00:00
diff --git a/src/main/resources/log4j2.xml b/src/main/resources/log4j2.xml
Improve mid tick chunk loading, Fix Oversleep, other improvements
Process loads outside of any canSleep check. Original intent was to
only apply those restrictions to generations but realized I had some
checks higher up the call chain.
Reworked the back off strategy to just run every 1 millisecond per world,
and to apply the per tick limit to generations only.
This guarantees that your chunk will load with at most around 1ms delay.
Additionally, fire midTick processing in a few more places, notably the
oversleep section so we can keep processing loads here too which has
a large up to 50ms window...
Speaking of oversleep, we had a bug in our implementation changes for
Timings that caused oversleep to not sleep the correct amount.
Because we now moved it into the NEXT tick instead of THIS tick, the
value of nextTick had already been increased to +50ms, resulting in
the risk of sleeping more than it should, but, more importantly, this
caused every task that was trying to NOT run during oversleep to actually
run during oversleep.
This is now fixed.
Another small tweak is to the /tps command, to no longer show the star when
TPS is right at 20.
Due to ineffeciencies in the sleep precision, TPS is commonly 20.02.
This causes the star to show up almost constantly, so now only show it if
we actually hit a real "catchup".
This commit also improves the changes to the CallbackExecutor, in that
it now is also recursion safe.
It was possible that the executor could run tasks out of desired order
if the executor task scheduled more executor tasks.
We solve this by ensuring new additions do not enter the currently iterated queue.
Each depth level will have its own queue.
Fixes #3220
2020-04-26 03:47:29 +00:00
index 722ca84968..620b9490e5 100644
2017-06-09 17:05:12 +00:00
--- a/src/main/resources/log4j2.xml
+++ b/src/main/resources/log4j2.xml
2020-01-24 23:06:37 +00:00
@@ -1,17 +1,14 @@
2017-06-09 17:05:12 +00:00
<?xml version="1.0" encoding="UTF-8"?>
2020-01-22 02:02:07 +00:00
<Configuration status="WARN" packages="com.mojang.util">
2017-06-09 17:05:12 +00:00
<Appenders>
2020-01-22 02:02:07 +00:00
- <Console name="SysOut" target="SYSTEM_OUT">
2019-04-27 06:26:04 +00:00
- <PatternLayout pattern="[%d{HH:mm:ss}] [%t/%level]: %msg%n" />
2020-01-22 02:02:07 +00:00
- </Console>
<Queue name="ServerGuiConsole">
<PatternLayout pattern="[%d{HH:mm:ss} %level]: %msg%n" />
</Queue>
2020-01-24 23:06:37 +00:00
- <Queue name="TerminalConsole">
- <PatternLayout pattern="[%d{HH:mm:ss}] [%t/%level]: %msg%n" />
- </Queue>
2017-06-09 17:05:12 +00:00
+ <TerminalConsole name="TerminalConsole">
+ <PatternLayout pattern="%highlightError{[%d{HH:mm:ss} %level]: %minecraftFormatting{%msg}%n%xEx}" />
+ </TerminalConsole>
<RollingRandomAccessFile name="File" fileName="logs/latest.log" filePattern="logs/%d{yyyy-MM-dd}-%i.log.gz">
- <PatternLayout pattern="[%d{HH:mm:ss}] [%t/%level]: %msg%n" />
+ <PatternLayout pattern="[%d{HH:mm:ss}] [%t/%level]: %minecraftFormatting{%msg}{strip}%n" />
<Policies>
<TimeBasedTriggeringPolicy />
<OnStartupTriggeringPolicy />
2020-01-24 23:06:37 +00:00
@@ -24,10 +21,9 @@
2017-06-13 08:10:22 +00:00
<filters>
<MarkerFilter marker="NETWORK_PACKETS" onMatch="DENY" onMismatch="NEUTRAL" />
</filters>
2020-01-22 02:02:07 +00:00
- <AppenderRef ref="SysOut" level="info"/>
2017-06-13 08:10:22 +00:00
<AppenderRef ref="File"/>
2020-01-22 02:02:07 +00:00
- <AppenderRef ref="ServerGuiConsole" level="info"/>
2017-06-13 08:10:22 +00:00
<AppenderRef ref="TerminalConsole" level="info"/>
2020-01-22 02:02:07 +00:00
+ <AppenderRef ref="ServerGuiConsole" level="info"/>
2017-06-13 08:10:22 +00:00
</Root>
2020-01-22 02:02:07 +00:00
</Loggers>
</Configuration>
2017-06-09 17:05:12 +00:00
--
Improve mid tick chunk loading, Fix Oversleep, other improvements
Process loads outside of any canSleep check. Original intent was to
only apply those restrictions to generations but realized I had some
checks higher up the call chain.
Reworked the back off strategy to just run every 1 millisecond per world,
and to apply the per tick limit to generations only.
This guarantees that your chunk will load with at most around 1ms delay.
Additionally, fire midTick processing in a few more places, notably the
oversleep section so we can keep processing loads here too which has
a large up to 50ms window...
Speaking of oversleep, we had a bug in our implementation changes for
Timings that caused oversleep to not sleep the correct amount.
Because we now moved it into the NEXT tick instead of THIS tick, the
value of nextTick had already been increased to +50ms, resulting in
the risk of sleeping more than it should, but, more importantly, this
caused every task that was trying to NOT run during oversleep to actually
run during oversleep.
This is now fixed.
Another small tweak is to the /tps command, to no longer show the star when
TPS is right at 20.
Due to ineffeciencies in the sleep precision, TPS is commonly 20.02.
This causes the star to show up almost constantly, so now only show it if
we actually hit a real "catchup".
This commit also improves the changes to the CallbackExecutor, in that
it now is also recursion safe.
It was possible that the executor could run tasks out of desired order
if the executor task scheduled more executor tasks.
We solve this by ensuring new additions do not enter the currently iterated queue.
Each depth level will have its own queue.
Fixes #3220
2020-04-26 03:47:29 +00:00
2.26.2
2017-06-09 17:05:12 +00:00
