Mirrors/Velocity
3
0
Fork 1
Mirror von https://github.com/PaperMC/Velocity.git synchronisiert 2024-11-06 00:00:47 +01:00
Code Issues Pakete Projekte Releases Wiki Aktivität

Merge branch 'dev/1.1.0' into decode-multiple

Quellcode durchsuchen 
# Conflicts:
#	proxy/src/main/java/com/velocitypowered/proxy/connection/client/ConnectedPlayer.java
Dieser Commit ist enthalten in:
Andrew Steinborn 2020-05-25 13:27:44 -04:00
Commit 62d3f61a77
3 geänderte Dateien mit 83 neuen und 64 gelöschten Zeilen
Statistiken anzeigen Patch-Datei herunterladen Vergleichs-Datei herunterladen Alle Dateien ausklappen Alle Dateien einklappen

2
proxy/src/main/java/com/velocitypowered/proxy/command/VelocityCommand.java
Datei anzeigen

@ -11,7 +11,6 @@ import com.velocitypowered.api.plugin.PluginDescription;
import com.velocitypowered.api.proxy.ProxyServer;
import com.velocitypowered.api.util.ProxyVersion;
import com.velocitypowered.proxy.VelocityServer;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;
import java.util.Locale;
@ -20,7 +19,6 @@ import java.util.stream.Collectors;
import net.kyori.text.TextComponent;
import net.kyori.text.event.ClickEvent;
import net.kyori.text.event.HoverEvent;
import net.kyori.text.event.HoverEvent.Action;
import net.kyori.text.format.TextColor;
import net.kyori.text.format.TextDecoration;
import org.apache.logging.log4j.LogManager;

52
proxy/src/main/java/com/velocitypowered/proxy/connection/client/ClientPlaySessionHandler.java
Datei anzeigen

@ -4,7 +4,7 @@ import static com.velocitypowered.api.network.ProtocolVersion.MINECRAFT_1_13;
import static com.velocitypowered.api.network.ProtocolVersion.MINECRAFT_1_8;
import static com.velocitypowered.proxy.protocol.util.PluginMessageUtil.constructChannelsPacket;
import com.velocitypowered.api.event.command.CommandExecuteEvent;
import com.velocitypowered.api.event.command.CommandExecuteEvent.CommandResult;
import com.velocitypowered.api.event.connection.PluginMessageEvent;
import com.velocitypowered.api.event.player.PlayerChatEvent;
import com.velocitypowered.api.event.player.PlayerResourcePackStatusEvent;
@ -42,6 +42,7 @@ import java.util.List;
import java.util.Optional;
import java.util.Queue;
import java.util.UUID;
import java.util.concurrent.CompletableFuture;
import net.kyori.text.TextComponent;
import net.kyori.text.format.TextColor;
import org.apache.logging.log4j.LogManager;
@ -124,30 +125,18 @@ public class ClientPlaySessionHandler implements MinecraftSessionHandler {
String msg = packet.getMessage();
if (msg.startsWith("/")) {
String originalCommand = msg.substring(1);
server.getCommandManager().callCommandEvent(player, msg.substring(1))
.thenAcceptAsync(event -> {
CommandExecuteEvent.CommandResult commandResult = event.getResult();
Optional<String> eventCommand = event.getResult().getCommand();
String command = eventCommand.orElse(event.getCommand());
if (commandResult.isForwardToServer()) {
smc.write(Chat.createServerbound("/" + command));
return;
}
if (commandResult.isAllowed()) {
try {
if (!server.getCommandManager().executeImmediately(player, command)) {
smc.write(Chat.createServerbound("/" + command));
}
} catch (Exception e) {
logger.info("Exception occurred while running command for {}", player.getUsername(),
e);
.thenComposeAsync(event -> processCommandExecuteResult(originalCommand,
event.getResult()))
.exceptionally(e -> {
logger.info("Exception occurred while running command for {}",
player.getUsername(), e);
player.sendMessage(
TextComponent.of("An error occurred while running this command.",
TextColor.RED));
}
}
}, smc.eventLoop());
return null;
});
} else {
PlayerChatEvent event = new PlayerChatEvent(player, msg);
server.getEventManager().fire(event)
@ -481,6 +470,27 @@ public class ClientPlaySessionHandler implements MinecraftSessionHandler {
}, player.getConnection().eventLoop());
}
private CompletableFuture<Void> processCommandExecuteResult(String originalCommand,
CommandResult result) {
if (result == CommandResult.denied()) {
return CompletableFuture.completedFuture(null);
}
MinecraftConnection smc = player.ensureAndGetCurrentServer().ensureConnected();
String commandToRun = result.getCommand().orElse(originalCommand);
if (result.isForwardToServer()) {
return CompletableFuture.runAsync(() -> smc.write(Chat.createServerbound("/"
+ commandToRun)), smc.eventLoop());
} else {
return server.getCommandManager().executeImmediatelyAsync(player, commandToRun)
.thenAcceptAsync(hasRun -> {
if (!hasRun) {
smc.write(Chat.createServerbound("/" + commandToRun));
}
}, smc.eventLoop());
}
}
/**
* Immediately send any queued messages to the server.
*/

69
proxy/src/main/java/com/velocitypowered/proxy/connection/client/ConnectedPlayer.java
Datei anzeigen

@ -1,5 +1,8 @@
package com.velocitypowered.proxy.connection.client;
import static com.velocitypowered.proxy.connection.util.ConnectionRequestResults.plainResult;
import static java.util.concurrent.CompletableFuture.completedFuture;
import com.google.common.base.Preconditions;
import com.google.gson.JsonObject;
import com.velocitypowered.api.event.connection.DisconnectEvent;
@ -33,7 +36,6 @@ import com.velocitypowered.proxy.connection.MinecraftConnectionAssociation;
import com.velocitypowered.proxy.connection.backend.VelocityServerConnection;
import com.velocitypowered.proxy.connection.forge.legacy.LegacyForgeConstants;
import com.velocitypowered.proxy.connection.util.ConnectionMessages;
import com.velocitypowered.proxy.connection.util.ConnectionRequestResults;
import com.velocitypowered.proxy.connection.util.ConnectionRequestResults.Impl;
import com.velocitypowered.proxy.protocol.StateRegistry;
import com.velocitypowered.proxy.protocol.packet.Chat;
@ -711,8 +713,8 @@ public class ConnectedPlayer implements MinecraftConnectionAssociation, Player {
}
private Optional<ConnectionRequestBuilder.Status> checkServer(RegisteredServer server) {
Preconditions
.checkState(server instanceof VelocityRegisteredServer, "Not a valid Velocity server.");
Preconditions.checkArgument(server instanceof VelocityRegisteredServer,
"Not a valid Velocity server.");
if (connectionInFlight != null || (connectedServer != null
&& !connectedServer.hasCompletedJoin())) {
return Optional.of(ConnectionRequestBuilder.Status.CONNECTION_IN_PROGRESS);
@ -723,49 +725,58 @@ public class ConnectedPlayer implements MinecraftConnectionAssociation, Player {
return Optional.empty();
}
private CompletableFuture<Impl> internalConnect() {
Optional<ConnectionRequestBuilder.Status> initialCheck = checkServer(toConnect);
if (initialCheck.isPresent()) {
return CompletableFuture
.completedFuture(ConnectionRequestResults.plainResult(initialCheck.get(), toConnect));
private CompletableFuture<Optional<Status>> getInitialStatus() {
return CompletableFuture.supplyAsync(() -> checkServer(toConnect), connection.eventLoop());
}
// Otherwise, initiate the connection.
ServerPreConnectEvent event = new ServerPreConnectEvent(ConnectedPlayer.this, toConnect);
private CompletableFuture<Impl> internalConnect() {
return this.getInitialStatus()
.thenCompose(initialCheck -> {
if (initialCheck.isPresent()) {
return completedFuture(plainResult(initialCheck.get(), toConnect));
}
ServerPreConnectEvent event = new ServerPreConnectEvent(ConnectedPlayer.this,
toConnect);
return server.getEventManager().fire(event)
.thenComposeAsync(newEvent -> {
Optional<RegisteredServer> connectTo = newEvent.getResult().getServer();
if (!connectTo.isPresent()) {
return CompletableFuture.completedFuture(
ConnectionRequestResults
.plainResult(ConnectionRequestBuilder.Status.CONNECTION_CANCELLED, toConnect)
Optional<RegisteredServer> newDest = newEvent.getResult().getServer();
if (!newDest.isPresent()) {
return completedFuture(
plainResult(ConnectionRequestBuilder.Status.CONNECTION_CANCELLED, toConnect)
);
}
RegisteredServer rs = connectTo.get();
Optional<ConnectionRequestBuilder.Status> lastCheck = checkServer(rs);
if (lastCheck.isPresent()) {
return CompletableFuture
.completedFuture(ConnectionRequestResults.plainResult(lastCheck.get(), rs));
RegisteredServer realDestination = newDest.get();
Optional<ConnectionRequestBuilder.Status> check = checkServer(realDestination);
if (check.isPresent()) {
return completedFuture(plainResult(check.get(), realDestination));
}
VelocityRegisteredServer vrs = (VelocityRegisteredServer) rs;
VelocityServerConnection con = new VelocityServerConnection(vrs, ConnectedPlayer.this,
server);
VelocityRegisteredServer vrs = (VelocityRegisteredServer) realDestination;
VelocityServerConnection con = new VelocityServerConnection(vrs,
ConnectedPlayer.this, server);
connectionInFlight = con;
return con.connect();
return con.connect().whenCompleteAsync((result, throwable) ->
this.cleanupIfRequired(con), connection.eventLoop());
}, connection.eventLoop());
});
}
private void cleanupIfRequired(VelocityServerConnection establishedConnection) {
if (establishedConnection == connectionInFlight) {
resetInFlightConnection();
}
}
@Override
public CompletableFuture<Result> connect() {
return this.internalConnect()
.whenCompleteAsync((status, throwable) -> {
if (status != null && !status.isSafe()) {
// If it's not safe to continue the connection we need to shut it down.
handleConnectionException(status.getAttemptedConnection(), throwable, true);
} else if ((status != null && !status.isSuccessful())) {
resetInFlightConnection();
if (status != null && !status.isSuccessful()) {
if (!status.isSafe()) {
handleConnectionException(status.getAttemptedConnection(), throwable, false);
}
}
}, connection.eventLoop())
.thenApply(x -> x);