TakeV/Paper
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
Paper/Spigot-Server-Patches/0486-Load-Chunks-for-Login-Asynchronously.patch

255 lines
14 KiB
Diff
Raw Normal View History

Optimize Network Manager to not need synchronization Removes synchronization from sending packets Makes normal packet sends no longer need to be wrapped and queued like it use to work. Adds more packet queue immunities on top of keep alive to let the following scenarios go out without delay: - Keep Alive - Chat - Kick - All of the packets during the Player Joined World event Hoping that latter one helps join timeout issues more too for slow connections. Removes processing packet queue off of main thread - for the few cases where it is allowed, order is not necessary nor should it even be happening concurrently in first place (handshaking/login/status) Ensures packets sent asynchronously are dispatched on main thread This helps ensure safety for ProtocolLib as packet listeners are commonly accessing world state. This will allow you to schedule a packet to be sent async, but itll be dispatched sync for packet listeners to process. This should solve some deadlock risks This may provide a decent performance improvement because thread synchronization incurs a cache reset so by avoiding ever entering a synchronized block, we get to avoid that, and packet sending is a really hot activity.
2020-05-06 09:22:03 +00:00
From 0a30b7a3e4a74081cc67dd17291ecfacee643fcb Mon Sep 17 00:00:00 2001
Load Chunks for Login Asynchronously No longer will trigger Synchronous Chunk Loads when a player logs in to the server. Will delay PlayerJoinEvent until the chunk has been loaded. Should have massive performance benefits for larger servers with lots of players logging in and out.
2020-04-19 08:32:04 +00:00
From: Aikar <aikar@aikar.co>
Date: Sun, 19 Apr 2020 04:28:29 -0400
Subject: [PATCH] Load Chunks for Login Asynchronously
Fix some issues with async login as well another source of sync loads
2020-04-22 06:52:17 +00:00
diff --git a/src/main/java/net/minecraft/server/Entity.java b/src/main/java/net/minecraft/server/Entity.java
Optimize Network Manager to not need synchronization Removes synchronization from sending packets Makes normal packet sends no longer need to be wrapped and queued like it use to work. Adds more packet queue immunities on top of keep alive to let the following scenarios go out without delay: - Keep Alive - Chat - Kick - All of the packets during the Player Joined World event Hoping that latter one helps join timeout issues more too for slow connections. Removes processing packet queue off of main thread - for the few cases where it is allowed, order is not necessary nor should it even be happening concurrently in first place (handshaking/login/status) Ensures packets sent asynchronously are dispatched on main thread This helps ensure safety for ProtocolLib as packet listeners are commonly accessing world state. This will allow you to schedule a packet to be sent async, but itll be dispatched sync for packet listeners to process. This should solve some deadlock risks This may provide a decent performance improvement because thread synchronization incurs a cache reset so by avoiding ever entering a synchronized block, we get to avoid that, and packet sending is a really hot activity.
2020-05-06 09:22:03 +00:00
index 324fd07bcee..01330045c0f 100644
Fix some issues with async login as well another source of sync loads
2020-04-22 06:52:17 +00:00
--- a/src/main/java/net/minecraft/server/Entity.java
+++ b/src/main/java/net/minecraft/server/Entity.java
@@ -1382,7 +1382,7 @@ public abstract class Entity implements INamableTileEntity, ICommandListener, Ke
this.pitch = MathHelper.a(f1, -90.0F, 90.0F) % 360.0F;
this.lastYaw = this.yaw;
this.lastPitch = this.pitch;
- world.getChunkAt((int) Math.floor(this.locX) >> 4, (int) Math.floor(this.locZ) >> 4); // CraftBukkit
+ if (valid) world.getChunkAt((int) Math.floor(this.locX) >> 4, (int) Math.floor(this.locZ) >> 4); // CraftBukkit // Paper
}
public void setPositionRotation(BlockPosition blockposition, float f, float f1) {
Improvements to async login Bump chunk priority to ensure chunks load fast Handle case where client disconnects before they even fire PlayerJoinEvent - no longer call PlayerQuitEvent or print quit message. - don't save the player data file if never joined. Nothing has changed. CraftBukkit has a bug here that if you do save it, you will lose any horse that the player logged off on because the horse hasn't been resummoned yet.
2020-04-22 09:40:06 +00:00
diff --git a/src/main/java/net/minecraft/server/EntityPlayer.java b/src/main/java/net/minecraft/server/EntityPlayer.java
Optimize Network Manager to not need synchronization Removes synchronization from sending packets Makes normal packet sends no longer need to be wrapped and queued like it use to work. Adds more packet queue immunities on top of keep alive to let the following scenarios go out without delay: - Keep Alive - Chat - Kick - All of the packets during the Player Joined World event Hoping that latter one helps join timeout issues more too for slow connections. Removes processing packet queue off of main thread - for the few cases where it is allowed, order is not necessary nor should it even be happening concurrently in first place (handshaking/login/status) Ensures packets sent asynchronously are dispatched on main thread This helps ensure safety for ProtocolLib as packet listeners are commonly accessing world state. This will allow you to schedule a packet to be sent async, but itll be dispatched sync for packet listeners to process. This should solve some deadlock risks This may provide a decent performance improvement because thread synchronization incurs a cache reset so by avoiding ever entering a synchronized block, we get to avoid that, and packet sending is a really hot activity.
2020-05-06 09:22:03 +00:00
index 45df816980c..48bbaec4b64 100644
Improvements to async login Bump chunk priority to ensure chunks load fast Handle case where client disconnects before they even fire PlayerJoinEvent - no longer call PlayerQuitEvent or print quit message. - don't save the player data file if never joined. Nothing has changed. CraftBukkit has a bug here that if you do save it, you will lose any horse that the player logged off on because the horse hasn't been resummoned yet.
2020-04-22 09:40:06 +00:00
--- a/src/main/java/net/minecraft/server/EntityPlayer.java
+++ b/src/main/java/net/minecraft/server/EntityPlayer.java
Improve Async Login so pending connections dont get exposed We still keep vanilla process of waiting for existing session to be removed before logging in by storing a separate map of pending. also fire the callback using executor incase further recursion causes any trouble
2020-04-24 09:33:33 +00:00
@@ -43,6 +43,7 @@ public class EntityPlayer extends EntityHuman implements ICrafting {
private static final Logger LOGGER = LogManager.getLogger();
public String locale = null; // CraftBukkit - lowercase // Paper - default to null
public PlayerConnection playerConnection;
+ public NetworkManager networkManager; // Paper
public final MinecraftServer server;
public final PlayerInteractManager playerInteractManager;
public final Deque<Integer> removeQueue = new ArrayDeque<>(); // Paper
Use distance map to optimise entity tracker / Misc Utils Use the distance map to find candidate players for tracking. This also ports a few utility changes from Tuinity
2020-05-06 07:44:47 +00:00
@@ -101,6 +102,7 @@ public class EntityPlayer extends EntityHuman implements ICrafting {
Improvements to async login Bump chunk priority to ensure chunks load fast Handle case where client disconnects before they even fire PlayerJoinEvent - no longer call PlayerQuitEvent or print quit message. - don't save the player data file if never joined. Nothing has changed. CraftBukkit has a bug here that if you do save it, you will lose any horse that the player logged off on because the horse hasn't been resummoned yet.
2020-04-22 09:40:06 +00:00
public boolean joining = true;
public boolean sentListPacket = false;
public boolean supressTrackerForLogin = false; // Paper
+ public boolean didPlayerJoinEvent = false; // Paper
public Integer clientViewDistance;
// CraftBukkit end
public PlayerNaturallySpawnCreaturesEvent playerNaturallySpawnedEvent; // Paper
Improve Async Login so pending connections dont get exposed We still keep vanilla process of waiting for existing session to be removed before logging in by storing a separate map of pending. also fire the callback using executor incase further recursion causes any trouble
2020-04-24 09:33:33 +00:00
diff --git a/src/main/java/net/minecraft/server/LoginListener.java b/src/main/java/net/minecraft/server/LoginListener.java
Optimize Network Manager to not need synchronization Removes synchronization from sending packets Makes normal packet sends no longer need to be wrapped and queued like it use to work. Adds more packet queue immunities on top of keep alive to let the following scenarios go out without delay: - Keep Alive - Chat - Kick - All of the packets during the Player Joined World event Hoping that latter one helps join timeout issues more too for slow connections. Removes processing packet queue off of main thread - for the few cases where it is allowed, order is not necessary nor should it even be happening concurrently in first place (handshaking/login/status) Ensures packets sent asynchronously are dispatched on main thread This helps ensure safety for ProtocolLib as packet listeners are commonly accessing world state. This will allow you to schedule a packet to be sent async, but itll be dispatched sync for packet listeners to process. This should solve some deadlock risks This may provide a decent performance improvement because thread synchronization incurs a cache reset so by avoiding ever entering a synchronized block, we get to avoid that, and packet sending is a really hot activity.
2020-05-06 09:22:03 +00:00
index f1222fcb2bd..28f48f22522 100644
Improve Async Login so pending connections dont get exposed We still keep vanilla process of waiting for existing session to be removed before logging in by storing a separate map of pending. also fire the callback using executor incase further recursion causes any trouble
2020-04-24 09:33:33 +00:00
--- a/src/main/java/net/minecraft/server/LoginListener.java
+++ b/src/main/java/net/minecraft/server/LoginListener.java
@@ -66,7 +66,7 @@ public class LoginListener implements PacketLoginInListener {
}
// Paper end
} else if (this.g == LoginListener.EnumProtocolState.DELAY_ACCEPT) {
- EntityPlayer entityplayer = this.server.getPlayerList().a(this.i.getId());
+ EntityPlayer entityplayer = this.server.getPlayerList().getActivePlayer(this.i.getId()); // Paper
if (entityplayer == null) {
this.g = LoginListener.EnumProtocolState.READY_TO_ACCEPT;
@@ -165,7 +165,7 @@ public class LoginListener implements PacketLoginInListener {
}
this.networkManager.sendPacket(new PacketLoginOutSuccess(this.i));
- EntityPlayer entityplayer = this.server.getPlayerList().a(this.i.getId());
+ EntityPlayer entityplayer = this.server.getPlayerList().getActivePlayer(this.i.getId()); // Paper
if (entityplayer != null) {
this.g = LoginListener.EnumProtocolState.DELAY_ACCEPT;
Fix some issues with async login as well another source of sync loads
2020-04-22 06:52:17 +00:00
diff --git a/src/main/java/net/minecraft/server/PlayerConnection.java b/src/main/java/net/minecraft/server/PlayerConnection.java
Optimize Network Manager to not need synchronization Removes synchronization from sending packets Makes normal packet sends no longer need to be wrapped and queued like it use to work. Adds more packet queue immunities on top of keep alive to let the following scenarios go out without delay: - Keep Alive - Chat - Kick - All of the packets during the Player Joined World event Hoping that latter one helps join timeout issues more too for slow connections. Removes processing packet queue off of main thread - for the few cases where it is allowed, order is not necessary nor should it even be happening concurrently in first place (handshaking/login/status) Ensures packets sent asynchronously are dispatched on main thread This helps ensure safety for ProtocolLib as packet listeners are commonly accessing world state. This will allow you to schedule a packet to be sent async, but itll be dispatched sync for packet listeners to process. This should solve some deadlock risks This may provide a decent performance improvement because thread synchronization incurs a cache reset so by avoiding ever entering a synchronized block, we get to avoid that, and packet sending is a really hot activity.
2020-05-06 09:22:03 +00:00
index 2e81f3a1d93..8800a8fcf9a 100644
Fix some issues with async login as well another source of sync loads
2020-04-22 06:52:17 +00:00
--- a/src/main/java/net/minecraft/server/PlayerConnection.java
+++ b/src/main/java/net/minecraft/server/PlayerConnection.java
Improve Async Login to avoid firing in middle of Entity Ticking If a sync load was triggered, it would process pending join events, causing them to be added to the world in the middle of the entity ticking process. This caused their add to be queued instead of immediate, causing "Illegal Tracking" errors. This schedules it to fire at the players next Connection Tick, which is exactly where this entire process use to run anyways. Also added missing tab complete and syntax for syncloadinfo debug command
2020-04-29 08:14:47 +00:00
@@ -69,6 +69,7 @@ public class PlayerConnection implements PacketListenerPlayIn {
private static final Logger LOGGER = LogManager.getLogger();
public final NetworkManager networkManager;
private final MinecraftServer minecraftServer;
+ Runnable playerJoinReady; // Paper
public EntityPlayer player;
private int e;
private long lastKeepAlive = SystemUtils.getMonotonicMillis(); private void setLastPing(long lastPing) { this.lastKeepAlive = lastPing;}; private long getLastPing() { return this.lastKeepAlive;}; // Paper - OBFHELPER
@@ -142,6 +143,17 @@ public class PlayerConnection implements PacketListenerPlayIn {
Fix some issues with async login as well another source of sync loads
2020-04-22 06:52:17 +00:00
// CraftBukkit end
public void tick() {
Improve Async Login to avoid firing in middle of Entity Ticking If a sync load was triggered, it would process pending join events, causing them to be added to the world in the middle of the entity ticking process. This caused their add to be queued instead of immediate, causing "Illegal Tracking" errors. This schedules it to fire at the players next Connection Tick, which is exactly where this entire process use to run anyways. Also added missing tab complete and syntax for syncloadinfo debug command
2020-04-29 08:14:47 +00:00
+ // Paper start - login async
+ Runnable playerJoinReady = this.playerJoinReady;
+ if (playerJoinReady != null) {
+ this.playerJoinReady = null;
+ playerJoinReady.run();
+ }
+ // Don't tick if not valid (dead), otherwise we load chunks below
+ if (!this.player.valid) {
+ return;
+ }
+ // Paper end
Fix some issues with async login as well another source of sync loads
2020-04-22 06:52:17 +00:00
this.syncPosition();
this.player.lastX = this.player.locX();
this.player.lastY = this.player.locY();
Load Chunks for Login Asynchronously No longer will trigger Synchronous Chunk Loads when a player logs in to the server. Will delay PlayerJoinEvent until the chunk has been loaded. Should have massive performance benefits for larger servers with lots of players logging in and out.
2020-04-19 08:32:04 +00:00
diff --git a/src/main/java/net/minecraft/server/PlayerList.java b/src/main/java/net/minecraft/server/PlayerList.java
Optimize Network Manager to not need synchronization Removes synchronization from sending packets Makes normal packet sends no longer need to be wrapped and queued like it use to work. Adds more packet queue immunities on top of keep alive to let the following scenarios go out without delay: - Keep Alive - Chat - Kick - All of the packets during the Player Joined World event Hoping that latter one helps join timeout issues more too for slow connections. Removes processing packet queue off of main thread - for the few cases where it is allowed, order is not necessary nor should it even be happening concurrently in first place (handshaking/login/status) Ensures packets sent asynchronously are dispatched on main thread This helps ensure safety for ProtocolLib as packet listeners are commonly accessing world state. This will allow you to schedule a packet to be sent async, but itll be dispatched sync for packet listeners to process. This should solve some deadlock risks This may provide a decent performance improvement because thread synchronization incurs a cache reset so by avoiding ever entering a synchronized block, we get to avoid that, and packet sending is a really hot activity.
2020-05-06 09:22:03 +00:00
index 6a4e4f93eb3..61c7f5f9528 100644
Load Chunks for Login Asynchronously No longer will trigger Synchronous Chunk Loads when a player logs in to the server. Will delay PlayerJoinEvent until the chunk has been loaded. Should have massive performance benefits for larger servers with lots of players logging in and out.
2020-04-19 08:32:04 +00:00
--- a/src/main/java/net/minecraft/server/PlayerList.java
+++ b/src/main/java/net/minecraft/server/PlayerList.java
Improve Async Login so pending connections dont get exposed We still keep vanilla process of waiting for existing session to be removed before logging in by storing a separate map of pending. also fire the callback using executor incase further recursion causes any trouble
2020-04-24 09:33:33 +00:00
@@ -52,11 +52,12 @@ public abstract class PlayerList {
private static final SimpleDateFormat g = new SimpleDateFormat("yyyy-MM-dd 'at' HH:mm:ss z");
private final MinecraftServer server;
public final List<EntityPlayer> players = new java.util.concurrent.CopyOnWriteArrayList(); // CraftBukkit - ArrayList -> CopyOnWriteArrayList: Iterator safety
- private final Map<UUID, EntityPlayer> j = Maps.newHashMap();
+ private final Map<UUID, EntityPlayer> j = Maps.newHashMap();Map<UUID, EntityPlayer> getUUIDMap() { return j; } // Paper - OBFHELPER
private final GameProfileBanList k;
private final IpBanList l;
private final OpList operators;
private final WhiteList whitelist;
+ private final Map<UUID, EntityPlayer> pendingPlayers = Maps.newHashMap(); // Paper
// CraftBukkit start
// private final Map<UUID, ServerStatisticManager> o;
// private final Map<UUID, AdvancementDataPlayer> p;
@@ -94,6 +95,11 @@ public abstract class PlayerList {
}
public void a(NetworkManager networkmanager, EntityPlayer entityplayer) {
+ EntityPlayer prev = pendingPlayers.put(entityplayer.getUniqueID(), entityplayer);// Paper
+ if (prev != null) {
+ disconnectPendingPlayer(prev);
+ }
+ entityplayer.networkManager = networkmanager; // Paper
entityplayer.loginTime = System.currentTimeMillis(); // Paper
GameProfile gameprofile = entityplayer.getProfile();
UserCache usercache = this.server.getUserCache();
@@ -107,7 +113,7 @@ public abstract class PlayerList {
if (nbttagcompound != null && nbttagcompound.hasKey("bukkit")) {
NBTTagCompound bukkit = nbttagcompound.getCompound("bukkit");
s = bukkit.hasKeyOfType("lastKnownName", 8) ? bukkit.getString("lastKnownName") : s;
- }
+ }String lastKnownName = s; // Paper
if (nbttagcompound == null) entityplayer.moveToSpawn(worldserver); // Paper - only move to spawn on first login, otherwise, stay where you are....
// CraftBukkit end
Optimize Network Manager to not need synchronization Removes synchronization from sending packets Makes normal packet sends no longer need to be wrapped and queued like it use to work. Adds more packet queue immunities on top of keep alive to let the following scenarios go out without delay: - Keep Alive - Chat - Kick - All of the packets during the Player Joined World event Hoping that latter one helps join timeout issues more too for slow connections. Removes processing packet queue off of main thread - for the few cases where it is allowed, order is not necessary nor should it even be happening concurrently in first place (handshaking/login/status) Ensures packets sent asynchronously are dispatched on main thread This helps ensure safety for ProtocolLib as packet listeners are commonly accessing world state. This will allow you to schedule a packet to be sent async, but itll be dispatched sync for packet listeners to process. This should solve some deadlock risks This may provide a decent performance improvement because thread synchronization incurs a cache reset so by avoiding ever entering a synchronized block, we get to avoid that, and packet sending is a really hot activity.
2020-05-06 09:22:03 +00:00
@@ -160,6 +166,50 @@ public abstract class PlayerList {
Improve Async Login so pending connections dont get exposed We still keep vanilla process of waiting for existing session to be removed before logging in by storing a separate map of pending. also fire the callback using executor incase further recursion causes any trouble
2020-04-24 09:33:33 +00:00
entityplayer.B().a(entityplayer);
this.sendScoreboard(worldserver.getScoreboard(), entityplayer);
this.server.invalidatePingSample();
Load Chunks for Login Asynchronously No longer will trigger Synchronous Chunk Loads when a player logs in to the server. Will delay PlayerJoinEvent until the chunk has been loaded. Should have massive performance benefits for larger servers with lots of players logging in and out.
2020-04-19 08:32:04 +00:00
+ // Paper start - async load spawn in chunk
+ WorldServer finalWorldserver = worldserver;
Improvements to async login Bump chunk priority to ensure chunks load fast Handle case where client disconnects before they even fire PlayerJoinEvent - no longer call PlayerQuitEvent or print quit message. - don't save the player data file if never joined. Nothing has changed. CraftBukkit has a bug here that if you do save it, you will lose any horse that the player logged off on because the horse hasn't been resummoned yet.
2020-04-22 09:40:06 +00:00
+ int chunkX = loc.getBlockX() >> 4;
+ int chunkZ = loc.getBlockZ() >> 4;
+ worldserver.getChunkProvider().getTickingChunkAsync(chunkX, chunkZ, (chunk -> { // use ticking - as it has at least 1 neighbours loaded
Improve Async Login to avoid firing in middle of Entity Ticking If a sync load was triggered, it would process pending join events, causing them to be added to the world in the middle of the entity ticking process. This caused their add to be queued instead of immediate, causing "Illegal Tracking" errors. This schedules it to fire at the players next Connection Tick, which is exactly where this entire process use to run anyways. Also added missing tab complete and syntax for syncloadinfo debug command
2020-04-29 08:14:47 +00:00
+ playerconnection.playerJoinReady = () -> {
+ postChunkLoadJoin(
+ entityplayer, finalWorldserver, networkmanager, playerconnection,
+ nbttagcompound, networkmanager.getSocketAddress().toString(), lastKnownName
+ );
+ };
Load Chunks for Login Asynchronously No longer will trigger Synchronous Chunk Loads when a player logs in to the server. Will delay PlayerJoinEvent until the chunk has been loaded. Should have massive performance benefits for larger servers with lots of players logging in and out.
2020-04-19 08:32:04 +00:00
+ }));
Improvements to async login Bump chunk priority to ensure chunks load fast Handle case where client disconnects before they even fire PlayerJoinEvent - no longer call PlayerQuitEvent or print quit message. - don't save the player data file if never joined. Nothing has changed. CraftBukkit has a bug here that if you do save it, you will lose any horse that the player logged off on because the horse hasn't been resummoned yet.
2020-04-22 09:40:06 +00:00
+ // boost the priorities
+ worldserver.asyncChunkTaskManager.raisePriority(chunkX, chunkZ, com.destroystokyo.paper.io.PrioritizedTaskQueue.HIGHEST_PRIORITY);
+ for (int cx = -1; cx <= 1; cx++) {
+ for (int cz = -1; cz <= 1; cz++) {
+ if (cx == 0 && cz == 0) continue;
+ // we have to directly request it otherwise the task won't be started yet to boost priority
Improve Async Login so pending connections dont get exposed We still keep vanilla process of waiting for existing session to be removed before logging in by storing a separate map of pending. also fire the callback using executor incase further recursion causes any trouble
2020-04-24 09:33:33 +00:00
+ worldserver.getChunkProvider().getFullChunkAsync(chunkX + cx, chunkZ + cz, null);
Improvements to async login Bump chunk priority to ensure chunks load fast Handle case where client disconnects before they even fire PlayerJoinEvent - no longer call PlayerQuitEvent or print quit message. - don't save the player data file if never joined. Nothing has changed. CraftBukkit has a bug here that if you do save it, you will lose any horse that the player logged off on because the horse hasn't been resummoned yet.
2020-04-22 09:40:06 +00:00
+ worldserver.asyncChunkTaskManager.raisePriority(chunkX + cx, chunkZ + cz, com.destroystokyo.paper.io.PrioritizedTaskQueue.HIGHEST_PRIORITY);
+ }
+ }
Improve Async Login so pending connections dont get exposed We still keep vanilla process of waiting for existing session to be removed before logging in by storing a separate map of pending. also fire the callback using executor incase further recursion causes any trouble
2020-04-24 09:33:33 +00:00
+ }
Improvements to async login Bump chunk priority to ensure chunks load fast Handle case where client disconnects before they even fire PlayerJoinEvent - no longer call PlayerQuitEvent or print quit message. - don't save the player data file if never joined. Nothing has changed. CraftBukkit has a bug here that if you do save it, you will lose any horse that the player logged off on because the horse hasn't been resummoned yet.
2020-04-22 09:40:06 +00:00
+
Improve Async Login so pending connections dont get exposed We still keep vanilla process of waiting for existing session to be removed before logging in by storing a separate map of pending. also fire the callback using executor incase further recursion causes any trouble
2020-04-24 09:33:33 +00:00
+ EntityPlayer getActivePlayer(UUID uuid) {
+ EntityPlayer player = this.getUUIDMap().get(uuid);
+ return player != null ? player : pendingPlayers.get(uuid);
Load Chunks for Login Asynchronously No longer will trigger Synchronous Chunk Loads when a player logs in to the server. Will delay PlayerJoinEvent until the chunk has been loaded. Should have massive performance benefits for larger servers with lots of players logging in and out.
2020-04-19 08:32:04 +00:00
+ }
Improve Async Login so pending connections dont get exposed We still keep vanilla process of waiting for existing session to be removed before logging in by storing a separate map of pending. also fire the callback using executor incase further recursion causes any trouble
2020-04-24 09:33:33 +00:00
+
+ void disconnectPendingPlayer(EntityPlayer entityplayer) {
+ ChatMessage msg = new ChatMessage("multiplayer.disconnect.duplicate_login", new Object[0]);
+ entityplayer.networkManager.sendPacket(new PacketPlayOutKickDisconnect(msg), (future) -> {
+ entityplayer.networkManager.close(msg);
+ entityplayer.networkManager = null;
+ });
+ }
+
+ private void postChunkLoadJoin(EntityPlayer entityplayer, WorldServer worldserver, NetworkManager networkmanager, PlayerConnection playerconnection, NBTTagCompound nbttagcompound, String s1, String s) {
+ pendingPlayers.remove(entityplayer.getUniqueID(), entityplayer);
+ if (!networkmanager.isConnected()) {
Fix some issues with async login as well another source of sync loads
2020-04-22 06:52:17 +00:00
+ return;
+ }
Improvements to async login Bump chunk priority to ensure chunks load fast Handle case where client disconnects before they even fire PlayerJoinEvent - no longer call PlayerQuitEvent or print quit message. - don't save the player data file if never joined. Nothing has changed. CraftBukkit has a bug here that if you do save it, you will lose any horse that the player logged off on because the horse hasn't been resummoned yet.
2020-04-22 09:40:06 +00:00
+ entityplayer.didPlayerJoinEvent = true;
Load Chunks for Login Asynchronously No longer will trigger Synchronous Chunk Loads when a player logs in to the server. Will delay PlayerJoinEvent until the chunk has been loaded. Should have massive performance benefits for larger servers with lots of players logging in and out.
2020-04-19 08:32:04 +00:00
+ // Paper end
Improve Async Login so pending connections dont get exposed We still keep vanilla process of waiting for existing session to be removed before logging in by storing a separate map of pending. also fire the callback using executor incase further recursion causes any trouble
2020-04-24 09:33:33 +00:00
ChatMessage chatmessage;
Fix some issues with async login as well another source of sync loads
2020-04-22 06:52:17 +00:00
Improve Async Login so pending connections dont get exposed We still keep vanilla process of waiting for existing session to be removed before logging in by storing a separate map of pending. also fire the callback using executor incase further recursion causes any trouble
2020-04-24 09:33:33 +00:00
if (entityplayer.getProfile().getName().equalsIgnoreCase(s)) {
Optimize Network Manager to not need synchronization Removes synchronization from sending packets Makes normal packet sends no longer need to be wrapped and queued like it use to work. Adds more packet queue immunities on top of keep alive to let the following scenarios go out without delay: - Keep Alive - Chat - Kick - All of the packets during the Player Joined World event Hoping that latter one helps join timeout issues more too for slow connections. Removes processing packet queue off of main thread - for the few cases where it is allowed, order is not necessary nor should it even be happening concurrently in first place (handshaking/login/status) Ensures packets sent asynchronously are dispatched on main thread This helps ensure safety for ProtocolLib as packet listeners are commonly accessing world state. This will allow you to schedule a packet to be sent async, but itll be dispatched sync for packet listeners to process. This should solve some deadlock risks This may provide a decent performance improvement because thread synchronization incurs a cache reset so by avoiding ever entering a synchronized block, we get to avoid that, and packet sending is a really hot activity.
2020-05-06 09:22:03 +00:00
@@ -218,7 +268,6 @@ public abstract class PlayerList {
Improve Async Login to avoid firing in middle of Entity Ticking If a sync load was triggered, it would process pending join events, causing them to be added to the world in the middle of the entity ticking process. This caused their add to be queued instead of immediate, causing "Illegal Tracking" errors. This schedules it to fire at the players next Connection Tick, which is exactly where this entire process use to run anyways. Also added missing tab complete and syntax for syncloadinfo debug command
2020-04-29 08:14:47 +00:00
}
entityplayer.sentListPacket = true;
entityplayer.supressTrackerForLogin = false; // Paper
- ((WorldServer)entityplayer.world).getChunkProvider().playerChunkMap.addEntity(entityplayer); // Paper - track entity now
// CraftBukkit end
entityplayer.playerConnection.sendPacket(new PacketPlayOutEntityMetadata(entityplayer.getId(), entityplayer.datawatcher, true)); // CraftBukkit - BungeeCord#2321, send complete data to self on spawn
Optimize Network Manager to not need synchronization Removes synchronization from sending packets Makes normal packet sends no longer need to be wrapped and queued like it use to work. Adds more packet queue immunities on top of keep alive to let the following scenarios go out without delay: - Keep Alive - Chat - Kick - All of the packets during the Player Joined World event Hoping that latter one helps join timeout issues more too for slow connections. Removes processing packet queue off of main thread - for the few cases where it is allowed, order is not necessary nor should it even be happening concurrently in first place (handshaking/login/status) Ensures packets sent asynchronously are dispatched on main thread This helps ensure safety for ProtocolLib as packet listeners are commonly accessing world state. This will allow you to schedule a packet to be sent async, but itll be dispatched sync for packet listeners to process. This should solve some deadlock risks This may provide a decent performance improvement because thread synchronization incurs a cache reset so by avoiding ever entering a synchronized block, we get to avoid that, and packet sending is a really hot activity.
2020-05-06 09:22:03 +00:00
@@ -245,6 +294,7 @@ public abstract class PlayerList {
Improve Async Login to avoid firing in middle of Entity Ticking If a sync load was triggered, it would process pending join events, causing them to be added to the world in the middle of the entity ticking process. This caused their add to be queued instead of immediate, causing "Illegal Tracking" errors. This schedules it to fire at the players next Connection Tick, which is exactly where this entire process use to run anyways. Also added missing tab complete and syntax for syncloadinfo debug command
2020-04-29 08:14:47 +00:00
}
// Paper start - move vehicle into method so it can be called above - short circuit around that code
+ ((WorldServer)entityplayer.world).getChunkProvider().playerChunkMap.addEntity(entityplayer); // track entity now
onPlayerJoinFinish(entityplayer, worldserver, s1);
}
private void mountSavedVehicle(EntityPlayer entityplayer, WorldServer worldserver, NBTTagCompound nbttagcompound) {
Optimize Network Manager to not need synchronization Removes synchronization from sending packets Makes normal packet sends no longer need to be wrapped and queued like it use to work. Adds more packet queue immunities on top of keep alive to let the following scenarios go out without delay: - Keep Alive - Chat - Kick - All of the packets during the Player Joined World event Hoping that latter one helps join timeout issues more too for slow connections. Removes processing packet queue off of main thread - for the few cases where it is allowed, order is not necessary nor should it even be happening concurrently in first place (handshaking/login/status) Ensures packets sent asynchronously are dispatched on main thread This helps ensure safety for ProtocolLib as packet listeners are commonly accessing world state. This will allow you to schedule a packet to be sent async, but itll be dispatched sync for packet listeners to process. This should solve some deadlock risks This may provide a decent performance improvement because thread synchronization incurs a cache reset so by avoiding ever entering a synchronized block, we get to avoid that, and packet sending is a really hot activity.
2020-05-06 09:22:03 +00:00
@@ -390,6 +440,7 @@ public abstract class PlayerList {
Improvements to async login Bump chunk priority to ensure chunks load fast Handle case where client disconnects before they even fire PlayerJoinEvent - no longer call PlayerQuitEvent or print quit message. - don't save the player data file if never joined. Nothing has changed. CraftBukkit has a bug here that if you do save it, you will lose any horse that the player logged off on because the horse hasn't been resummoned yet.
2020-04-22 09:40:06 +00:00
protected void savePlayerFile(EntityPlayer entityplayer) {
if (!entityplayer.getBukkitEntity().isPersistent()) return; // CraftBukkit
+ if (!entityplayer.didPlayerJoinEvent) return; // Paper - If we never fired PJE, we disconnected during login. Data has not changed, and additionally, our saved vehicle is not loaded! If we save now, we will lose our vehicle (CraftBukkit bug)
this.playerFileData.save(entityplayer);
ServerStatisticManager serverstatisticmanager = (ServerStatisticManager) entityplayer.getStatisticManager(); // CraftBukkit
Optimize Network Manager to not need synchronization Removes synchronization from sending packets Makes normal packet sends no longer need to be wrapped and queued like it use to work. Adds more packet queue immunities on top of keep alive to let the following scenarios go out without delay: - Keep Alive - Chat - Kick - All of the packets during the Player Joined World event Hoping that latter one helps join timeout issues more too for slow connections. Removes processing packet queue off of main thread - for the few cases where it is allowed, order is not necessary nor should it even be happening concurrently in first place (handshaking/login/status) Ensures packets sent asynchronously are dispatched on main thread This helps ensure safety for ProtocolLib as packet listeners are commonly accessing world state. This will allow you to schedule a packet to be sent async, but itll be dispatched sync for packet listeners to process. This should solve some deadlock risks This may provide a decent performance improvement because thread synchronization incurs a cache reset so by avoiding ever entering a synchronized block, we get to avoid that, and packet sending is a really hot activity.
2020-05-06 09:22:03 +00:00
@@ -414,7 +465,7 @@ public abstract class PlayerList {
Improvements to async login Bump chunk priority to ensure chunks load fast Handle case where client disconnects before they even fire PlayerJoinEvent - no longer call PlayerQuitEvent or print quit message. - don't save the player data file if never joined. Nothing has changed. CraftBukkit has a bug here that if you do save it, you will lose any horse that the player logged off on because the horse hasn't been resummoned yet.
2020-04-22 09:40:06 +00:00
org.bukkit.craftbukkit.event.CraftEventFactory.handleInventoryCloseEvent(entityplayer, org.bukkit.event.inventory.InventoryCloseEvent.Reason.DISCONNECT); // Paper
PlayerQuitEvent playerQuitEvent = new PlayerQuitEvent(cserver.getPlayer(entityplayer), "\u00A7e" + entityplayer.getName() + " left the game");
- cserver.getPluginManager().callEvent(playerQuitEvent);
+ if (entityplayer.didPlayerJoinEvent) cserver.getPluginManager().callEvent(playerQuitEvent); // Paper - if we disconnected before join ever fired, don't fire quit
entityplayer.getBukkitEntity().disconnect(playerQuitEvent.getQuitMessage());
if (server.isMainThread()) entityplayer.playerTick();// SPIGOT-924 // Paper - don't tick during emergency shutdowns (Watchdog)
Optimize Network Manager to not need synchronization Removes synchronization from sending packets Makes normal packet sends no longer need to be wrapped and queued like it use to work. Adds more packet queue immunities on top of keep alive to let the following scenarios go out without delay: - Keep Alive - Chat - Kick - All of the packets during the Player Joined World event Hoping that latter one helps join timeout issues more too for slow connections. Removes processing packet queue off of main thread - for the few cases where it is allowed, order is not necessary nor should it even be happening concurrently in first place (handshaking/login/status) Ensures packets sent asynchronously are dispatched on main thread This helps ensure safety for ProtocolLib as packet listeners are commonly accessing world state. This will allow you to schedule a packet to be sent async, but itll be dispatched sync for packet listeners to process. This should solve some deadlock risks This may provide a decent performance improvement because thread synchronization incurs a cache reset so by avoiding ever entering a synchronized block, we get to avoid that, and packet sending is a really hot activity.
2020-05-06 09:22:03 +00:00
@@ -466,6 +517,13 @@ public abstract class PlayerList {
Improve Async Login so pending connections dont get exposed We still keep vanilla process of waiting for existing session to be removed before logging in by storing a separate map of pending. also fire the callback using executor incase further recursion causes any trouble
2020-04-24 09:33:33 +00:00
// this.p.remove(uuid);
// CraftBukkit end
}
+ // Paper start
+ entityplayer1 = pendingPlayers.get(uuid);
+ if (entityplayer1 == entityplayer) {
+ pendingPlayers.remove(uuid);
+ }
+ entityplayer.networkManager = null;
+ // Paper end
// CraftBukkit start
// this.sendAll(new PacketPlayOutPlayerInfo(EnumPlayerInfoAction.REMOVE_PLAYER, new EntityPlayer[]{entityplayer}));
Optimize Network Manager to not need synchronization Removes synchronization from sending packets Makes normal packet sends no longer need to be wrapped and queued like it use to work. Adds more packet queue immunities on top of keep alive to let the following scenarios go out without delay: - Keep Alive - Chat - Kick - All of the packets during the Player Joined World event Hoping that latter one helps join timeout issues more too for slow connections. Removes processing packet queue off of main thread - for the few cases where it is allowed, order is not necessary nor should it even be happening concurrently in first place (handshaking/login/status) Ensures packets sent asynchronously are dispatched on main thread This helps ensure safety for ProtocolLib as packet listeners are commonly accessing world state. This will allow you to schedule a packet to be sent async, but itll be dispatched sync for packet listeners to process. This should solve some deadlock risks This may provide a decent performance improvement because thread synchronization incurs a cache reset so by avoiding ever entering a synchronized block, we get to avoid that, and packet sending is a really hot activity.
2020-05-06 09:22:03 +00:00
@@ -483,7 +541,7 @@ public abstract class PlayerList {
Improvements to async login Bump chunk priority to ensure chunks load fast Handle case where client disconnects before they even fire PlayerJoinEvent - no longer call PlayerQuitEvent or print quit message. - don't save the player data file if never joined. Nothing has changed. CraftBukkit has a bug here that if you do save it, you will lose any horse that the player logged off on because the horse hasn't been resummoned yet.
2020-04-22 09:40:06 +00:00
cserver.getScoreboardManager().removePlayer(entityplayer.getBukkitEntity());
// CraftBukkit end
- return playerQuitEvent.getQuitMessage(); // CraftBukkit
+ return entityplayer.didPlayerJoinEvent ? playerQuitEvent.getQuitMessage() : null; // CraftBukkit // Paper - don't print quit if we never printed join
}
// CraftBukkit start - Whole method, SocketAddress to LoginListener, added hostname to signature, return EntityPlayer
Optimize Network Manager to not need synchronization Removes synchronization from sending packets Makes normal packet sends no longer need to be wrapped and queued like it use to work. Adds more packet queue immunities on top of keep alive to let the following scenarios go out without delay: - Keep Alive - Chat - Kick - All of the packets during the Player Joined World event Hoping that latter one helps join timeout issues more too for slow connections. Removes processing packet queue off of main thread - for the few cases where it is allowed, order is not necessary nor should it even be happening concurrently in first place (handshaking/login/status) Ensures packets sent asynchronously are dispatched on main thread This helps ensure safety for ProtocolLib as packet listeners are commonly accessing world state. This will allow you to schedule a packet to be sent async, but itll be dispatched sync for packet listeners to process. This should solve some deadlock risks This may provide a decent performance improvement because thread synchronization incurs a cache reset so by avoiding ever entering a synchronized block, we get to avoid that, and packet sending is a really hot activity.
2020-05-06 09:22:03 +00:00
@@ -502,6 +560,13 @@ public abstract class PlayerList {
Improve Async Login so pending connections dont get exposed We still keep vanilla process of waiting for existing session to be removed before logging in by storing a separate map of pending. also fire the callback using executor incase further recursion causes any trouble
2020-04-24 09:33:33 +00:00
list.add(entityplayer);
}
}
+ // Paper start - check pending players too
+ entityplayer = pendingPlayers.get(uuid);
+ if (entityplayer != null) {
+ this.pendingPlayers.remove(uuid);
+ disconnectPendingPlayer(entityplayer);
+ }
+ // Paper end
Iterator iterator = list.iterator();
Load Chunks for Login Asynchronously No longer will trigger Synchronous Chunk Loads when a player logs in to the server. Will delay PlayerJoinEvent until the chunk has been loaded. Should have massive performance benefits for larger servers with lots of players logging in and out.
2020-04-19 08:32:04 +00:00
--
Optimize Network Manager to not need synchronization Removes synchronization from sending packets Makes normal packet sends no longer need to be wrapped and queued like it use to work. Adds more packet queue immunities on top of keep alive to let the following scenarios go out without delay: - Keep Alive - Chat - Kick - All of the packets during the Player Joined World event Hoping that latter one helps join timeout issues more too for slow connections. Removes processing packet queue off of main thread - for the few cases where it is allowed, order is not necessary nor should it even be happening concurrently in first place (handshaking/login/status) Ensures packets sent asynchronously are dispatched on main thread This helps ensure safety for ProtocolLib as packet listeners are commonly accessing world state. This will allow you to schedule a packet to be sent async, but itll be dispatched sync for packet listeners to process. This should solve some deadlock risks This may provide a decent performance improvement because thread synchronization incurs a cache reset so by avoiding ever entering a synchronized block, we get to avoid that, and packet sending is a really hot activity.
2020-05-06 09:22:03 +00:00
2.26.2
Load Chunks for Login Asynchronously No longer will trigger Synchronous Chunk Loads when a player logs in to the server. Will delay PlayerJoinEvent until the chunk has been loaded. Should have massive performance benefits for larger servers with lots of players logging in and out.
2020-04-19 08:32:04 +00:00
Reference in a new issue Copy permalink