Mirrors/Velocity
1
0
Fork 1
mirror of https://github.com/PaperMC/Velocity.git synced 2026-02-17 14:37:43 +01:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'dev/1.1.0' into dev/2.0.0

Browse Source 
# Conflicts:
#	build.gradle
This commit is contained in:
Andrew Steinborn
2020-10-28 20:33:57 -04:00
parent bf06134fb5 f3e1a7e01d
commit e21cd77ae7
34 changed files with 650 additions and 114 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
proxy/src/main/java/com/velocitypowered/proxy/VelocityServer.java
View File

@@ -415,8 +415,11 @@ public class VelocityServer implements ProxyServer, ForwardingAudience {
.toArray((IntFunction<CompletableFuture<Void>[]>) CompletableFuture[]::new));
playersTeardownFuture.get(10, TimeUnit.SECONDS);
} catch (TimeoutException | ExecutionException e) {
} catch (TimeoutException e) {
timedOut = true;
} catch (ExecutionException e) {
timedOut = true;
logger.error("Exception while tearing down player connections", e);
}
eventManager.fireShutdownEvent();

157
proxy/src/main/java/com/velocitypowered/proxy/command/builtin/VelocityCommand.java
View File

@@ -3,19 +3,35 @@ package com.velocitypowered.proxy.command.builtin;
import com.google.common.base.Joiner;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.util.concurrent.MoreExecutors;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import com.google.gson.JsonParseException;
import com.google.gson.JsonSyntaxException;
import com.velocitypowered.api.command.CommandSource;
import com.velocitypowered.api.command.SimpleCommand;
import com.velocitypowered.api.permission.Tristate;
import com.velocitypowered.api.plugin.PluginContainer;
import com.velocitypowered.api.plugin.PluginDescription;
import com.velocitypowered.api.proxy.ProxyServer;
import com.velocitypowered.api.proxy.server.RegisteredServer;
import com.velocitypowered.api.util.ProxyVersion;
import com.velocitypowered.proxy.VelocityServer;
import com.velocitypowered.proxy.util.InformationUtils;
import java.net.ConnectException;
import java.net.UnknownHostException;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;
import net.kyori.adventure.identity.Identity;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.TextComponent;
@@ -25,6 +41,10 @@ import net.kyori.adventure.text.format.NamedTextColor;
import net.kyori.adventure.text.format.TextDecoration;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.asynchttpclient.AsyncHttpClient;
import org.asynchttpclient.BoundRequestBuilder;
import org.asynchttpclient.ListenableFuture;
import org.asynchttpclient.Response;
import org.checkerframework.checker.nullness.qual.NonNull;
public class VelocityCommand implements SimpleCommand {
@@ -52,6 +72,7 @@ public class VelocityCommand implements SimpleCommand {
.put("version", new Info(server))
.put("plugins", new Plugins(server))
.put("reload", new Reload(server))
.put("dump", new Dump(server))
.build();
}
@@ -289,4 +310,140 @@ public class VelocityCommand implements SimpleCommand {
return source.getPermissionValue("velocity.command.plugins") == Tristate.TRUE;
}
}
private static class Dump implements SubCommand {
private static final Logger logger = LogManager.getLogger(Dump.class);
private final ProxyServer server;
private Dump(ProxyServer server) {
this.server = server;
}
@Override
public void execute(CommandSource source, String @NonNull [] args) {
if (args.length != 0) {
source.sendMessage(Identity.nil(), Component.text("/velocity dump", NamedTextColor.RED));
return;
}
Collection<RegisteredServer> allServers = ImmutableSet.copyOf(server.getAllServers());
JsonObject servers = new JsonObject();
for (RegisteredServer iter : allServers) {
servers.add(iter.getServerInfo().getName(),
InformationUtils.collectServerInfo(iter));
}
JsonArray connectOrder = new JsonArray();
List<String> attemptedConnectionOrder = ImmutableList.copyOf(
server.getConfiguration().getAttemptConnectionOrder());
for (int i = 0; i < attemptedConnectionOrder.size(); i++) {
connectOrder.add(attemptedConnectionOrder.get(i));
}
JsonObject proxyConfig = InformationUtils.collectProxyConfig(server.getConfiguration());
proxyConfig.add("servers", servers);
proxyConfig.add("connectOrder", connectOrder);
proxyConfig.add("forcedHosts",
InformationUtils.collectForcedHosts(server.getConfiguration()));
JsonObject dump = new JsonObject();
dump.add("versionInfo", InformationUtils.collectProxyInfo(server.getVersion()));
dump.add("platform", InformationUtils.collectEnvironmentInfo());
dump.add("config", proxyConfig);
dump.add("plugins", InformationUtils.collectPluginInfo(server));
source.sendMessage(Component.text().content("Uploading gathered information...").build());
AsyncHttpClient httpClient = ((VelocityServer) server).getAsyncHttpClient();
BoundRequestBuilder request =
httpClient.preparePost("https://dump.velocitypowered.com/documents");
request.setHeader("Content-Type", "text/plain");
request.addHeader("User-Agent", server.getVersion().getName() + "/"
+ server.getVersion().getVersion());
request.setBody(
InformationUtils.toHumanReadableString(dump).getBytes(StandardCharsets.UTF_8));
ListenableFuture<Response> future = request.execute();
future.addListener(() -> {
try {
Response response = future.get();
if (response.getStatusCode() != 200) {
source.sendMessage(Component.text()
.content("An error occurred while communicating with the Velocity servers. "
+ "The servers may be temporarily unavailable or there is an issue "
+ "with your network settings. You can find more information in the "
+ "log or console of your Velocity server.")
.color(NamedTextColor.RED).build());
logger.error("Invalid status code while POST-ing Velocity dump: "
+ response.getStatusCode());
logger.error("Headers: \n--------------BEGIN HEADERS--------------\n"
+ response.getHeaders().toString()
+ "\n---------------END HEADERS---------------");
return;
}
JsonObject key = InformationUtils.parseString(
response.getResponseBody(StandardCharsets.UTF_8));
if (!key.has("key")) {
throw new JsonSyntaxException("Missing Dump-Url-response");
}
String url = "https://dump.velocitypowered.com/"
+ key.get("key").getAsString() + ".json";
source.sendMessage(Component.text()
.content("Created an anonymised report containing useful information about "
+ "this proxy. If a developer requested it, you may share the "
+ "following link with them:")
.append(Component.newline())
.append(Component.text(">> " + url)
.color(NamedTextColor.GREEN)
.clickEvent(ClickEvent.openUrl(url)))
.append(Component.newline())
.append(Component.text("Note: This link is only valid for a few days")
.color(NamedTextColor.GRAY)
).build());
} catch (InterruptedException e) {
source.sendMessage(Component.text()
.content("Could not complete the request, the command was interrupted."
+ "Please refer to the proxy-log or console for more information.")
.color(NamedTextColor.RED).build());
logger.error("Failed to complete dump command, "
+ "the executor was interrupted: " + e.getMessage());
e.printStackTrace();
} catch (ExecutionException e) {
TextComponent.Builder message = Component.text()
.content("An error occurred while attempting to upload the gathered "
+ "information to the Velocity servers.")
.append(Component.newline())
.color(NamedTextColor.RED);
if (e.getCause() instanceof UnknownHostException
|| e.getCause() instanceof ConnectException) {
message.append(Component.text(
"Likely cause: Invalid system DNS settings or no internet connection"));
}
source.sendMessage(message
.append(Component.newline()
.append(Component.text(
"Error details can be found in the proxy log / console"))
).build());
logger.error("Failed to complete dump command, "
+ "the executor encountered an Exception: " + e.getCause().getMessage());
e.getCause().printStackTrace();
} catch (JsonParseException e) {
source.sendMessage(Component.text()
.content("An error occurred on the Velocity-servers and the dump could not "
+ "be completed. Please contact the Velocity staff about this problem. "
+ "If you do, provide the details about this error from the Velocity "
+ "console or server log.")
.color(NamedTextColor.RED).build());
logger.error("Invalid response from the Velocity servers: " + e.getMessage());
e.printStackTrace();
}
}, MoreExecutors.directExecutor());
}
@Override
public boolean hasPermission(final CommandSource source, final String @NonNull [] args) {
return source.getPermissionValue("velocity.command.plugins") == Tristate.TRUE;
}
}
}

55
proxy/src/main/java/com/velocitypowered/proxy/config/VelocityConfiguration.java
View File

@@ -7,6 +7,7 @@ import com.electronwill.nightconfig.toml.TomlFormat;
import com.google.common.base.MoreObjects;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.gson.annotations.Expose;
import com.velocitypowered.api.proxy.config.ProxyConfig;
import com.velocitypowered.api.util.Favicon;
import com.velocitypowered.proxy.util.AddressUtil;
@@ -42,20 +43,20 @@ public class VelocityConfiguration implements ProxyConfig {
private static final Logger logger = LogManager.getLogger(VelocityConfiguration.class);
private String bind = "0.0.0.0:25577";
private String motd = "&3A Velocity Server";
private int showMaxPlayers = 500;
private boolean onlineMode = true;
private boolean preventClientProxyConnections = false;
private PlayerInfoForwarding playerInfoForwardingMode = PlayerInfoForwarding.NONE;
@Expose private String bind = "0.0.0.0:25577";
@Expose private String motd = "&3A Velocity Server";
@Expose private int showMaxPlayers = 500;
@Expose private boolean onlineMode = true;
@Expose private boolean preventClientProxyConnections = false;
@Expose private PlayerInfoForwarding playerInfoForwardingMode = PlayerInfoForwarding.NONE;
private byte[] forwardingSecret = generateRandomString(12).getBytes(StandardCharsets.UTF_8);
private boolean announceForge = false;
private boolean onlineModeKickExistingPlayers = false;
private PingPassthroughMode pingPassthrough = PingPassthroughMode.DISABLED;
@Expose private boolean announceForge = false;
@Expose private boolean onlineModeKickExistingPlayers = false;
@Expose private PingPassthroughMode pingPassthrough = PingPassthroughMode.DISABLED;
private final Servers servers;
private final ForcedHosts forcedHosts;
private final Advanced advanced;
private final Query query;
@Expose private final Advanced advanced;
@Expose private final Query query;
private final Metrics metrics;
private final Messages messages;
private net.kyori.adventure.text.@MonotonicNonNull Component motdAsComponent;
@@ -612,18 +613,18 @@ public class VelocityConfiguration implements ProxyConfig {
private static class Advanced {
private int compressionThreshold = 256;
private int compressionLevel = -1;
private int loginRatelimit = 3000;
private int connectionTimeout = 5000;
private int readTimeout = 30000;
private boolean proxyProtocol = false;
private boolean tcpFastOpen = false;
private boolean bungeePluginMessageChannel = true;
private boolean showPingRequests = false;
private boolean failoverOnUnexpectedServerDisconnect = true;
private boolean announceProxyCommands = true;
private boolean logCommandExecutions = false;
@Expose private int compressionThreshold = 256;
@Expose private int compressionLevel = -1;
@Expose private int loginRatelimit = 3000;
@Expose private int connectionTimeout = 5000;
@Expose private int readTimeout = 30000;
@Expose private boolean proxyProtocol = false;
@Expose private boolean tcpFastOpen = false;
@Expose private boolean bungeePluginMessageChannel = true;
@Expose private boolean showPingRequests = false;
@Expose private boolean failoverOnUnexpectedServerDisconnect = true;
@Expose private boolean announceProxyCommands = true;
@Expose private boolean logCommandExecutions = false;
private Advanced() {
}
@@ -715,10 +716,10 @@ public class VelocityConfiguration implements ProxyConfig {
private static class Query {
private boolean queryEnabled = false;
private int queryPort = 25577;
private String queryMap = "Velocity";
private boolean showPlugins = false;
@Expose private boolean queryEnabled = false;
@Expose private int queryPort = 25577;
@Expose private String queryMap = "Velocity";
@Expose private boolean showPlugins = false;
private Query() {
}

12
proxy/src/main/java/com/velocitypowered/proxy/connection/backend/BackendPlaySessionHandler.java
View File

@@ -149,7 +149,11 @@ public class BackendPlaySessionHandler implements MinecraftSessionHandler {
Unpooled.wrappedBuffer(copy));
playerConnection.write(copied);
}
}, playerConnection.eventLoop());
}, playerConnection.eventLoop())
.exceptionally((ex) -> {
logger.error("Exception while handling plugin message {}", packet, ex);
return null;
});
return true;
}
@@ -186,7 +190,11 @@ public class BackendPlaySessionHandler implements MinecraftSessionHandler {
server.getEventManager().fire(
new PlayerAvailableCommandsEvent(serverConn.getPlayer(), rootNode))
.thenAcceptAsync(event -> playerConnection.write(commands), playerConnection.eventLoop());
.thenAcceptAsync(event -> playerConnection.write(commands), playerConnection.eventLoop())
.exceptionally((ex) -> {
logger.error("Exception while handling available commands for {}", playerConnection, ex);
return null;
});
return true;
}

10
proxy/src/main/java/com/velocitypowered/proxy/connection/backend/BungeeCordMessageResponder.java
View File

@@ -30,7 +30,7 @@ import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
@SuppressFBWarnings(value = "OS_OPEN_STREAM", justification = "Most methods in this class open "
+ "instances of ByteBufDataOutput backed by heap-allocated ByteBufs. Closing them does "
+ "nothing.")
class BungeeCordMessageResponder {
public class BungeeCordMessageResponder {
private static final MinecraftChannelIdentifier MODERN_CHANNEL = MinecraftChannelIdentifier
.create("bungeecord", "main");
@@ -45,6 +45,11 @@ class BungeeCordMessageResponder {
this.player = player;
}
public static boolean isBungeeCordMessage(PluginMessage message) {
return MODERN_CHANNEL.getId().equals(message.getChannel()) && !LEGACY_CHANNEL.getId()
.equals(message.getChannel());
}
private void processConnect(ByteBufDataInput in) {
String serverName = in.readUTF();
proxy.getServer(serverName).ifPresent(server -> player.createConnectionRequest(server)
@@ -332,8 +337,7 @@ class BungeeCordMessageResponder {
return false;
}
if (!MODERN_CHANNEL.getId().equals(message.getChannel()) && !LEGACY_CHANNEL.getId()
.equals(message.getChannel())) {
if (!isBungeeCordMessage(message)) {
return false;
}

39
proxy/src/main/java/com/velocitypowered/proxy/connection/client/ClientPlaySessionHandler.java
View File

@@ -16,6 +16,7 @@ import com.velocitypowered.proxy.VelocityServer;
import com.velocitypowered.proxy.connection.MinecraftConnection;
import com.velocitypowered.proxy.connection.MinecraftSessionHandler;
import com.velocitypowered.proxy.connection.backend.BackendConnectionPhases;
import com.velocitypowered.proxy.connection.backend.BungeeCordMessageResponder;
import com.velocitypowered.proxy.connection.backend.VelocityServerConnection;
import com.velocitypowered.proxy.protocol.MinecraftPacket;
import com.velocitypowered.proxy.protocol.StateRegistry;
@@ -157,7 +158,11 @@ public class ClientPlaySessionHandler implements MinecraftSessionHandler {
smc.write(packet);
}
}
}, smc.eventLoop());
}, smc.eventLoop())
.exceptionally((ex) -> {
logger.error("Exception while handling player chat for {}", player, ex);
return null;
});
}
return true;
}
@@ -190,6 +195,8 @@ public class ClientPlaySessionHandler implements MinecraftSessionHandler {
} else if (PluginMessageUtil.isMcBrand(packet)) {
backendConn.write(PluginMessageUtil
.rewriteMinecraftBrand(packet, server.getVersion(), player.getProtocolVersion()));
} else if (BungeeCordMessageResponder.isBungeeCordMessage(packet)) {
return true;
} else {
if (serverConn.getPhase() == BackendConnectionPhases.IN_TRANSITION) {
// We must bypass the currently-connected server when forwarding Forge packets.
@@ -225,7 +232,12 @@ public class ClientPlaySessionHandler implements MinecraftSessionHandler {
Unpooled.wrappedBuffer(copy));
backendConn.write(message);
}
}, backendConn.eventLoop());
}, backendConn.eventLoop())
.exceptionally((ex) -> {
logger.error("Exception while handling plugin message packet for {}",
player, ex);
return null;
});
}
}
}
@@ -423,7 +435,12 @@ public class ClientPlaySessionHandler implements MinecraftSessionHandler {
resp.getOffers().addAll(offers);
player.getConnection().write(resp);
}
}, player.getConnection().eventLoop());
}, player.getConnection().eventLoop())
.exceptionally((ex) -> {
logger.error("Exception while handling command tab completion for player {} executing {}",
player, command, ex);
return null;
});
return true; // Sorry, handler; we're just gonna have to lie to you here.
}
@@ -475,7 +492,13 @@ public class ClientPlaySessionHandler implements MinecraftSessionHandler {
player.getUsername(),
command, e);
}
}, player.getConnection().eventLoop());
}, player.getConnection().eventLoop())
.exceptionally((ex) -> {
logger.error(
"Exception while finishing command tab completion, with request {} and response {}",
request, response, ex);
return null;
});
}
private void finishRegularTabComplete(TabCompleteRequest request, TabCompleteResponse response) {
@@ -490,7 +513,13 @@ public class ClientPlaySessionHandler implements MinecraftSessionHandler {
response.getOffers().add(new Offer(s));
}
player.getConnection().write(response);
}, player.getConnection().eventLoop());
}, player.getConnection().eventLoop())
.exceptionally((ex) -> {
logger.error(
"Exception while finishing regular tab completion, with request {} and response{}",
request, response, ex);
return null;
});
}
private CompletableFuture<Void> processCommandExecuteResult(String originalCommand,

8
proxy/src/main/java/com/velocitypowered/proxy/connection/client/ConnectedPlayer.java
View File

@@ -637,7 +637,13 @@ public class ConnectedPlayer implements MinecraftConnectionAssociation, Player {
}
DisconnectEvent event = new DisconnectEvent(this, status);
server.getEventManager().fire(event).thenRun(() -> this.teardownFuture.complete(null));
server.getEventManager().fire(event).whenComplete((val, ex) -> {
if (ex == null) {
this.teardownFuture.complete(null);
} else {
this.teardownFuture.completeExceptionally(ex);
}
});
}
public CompletableFuture<Void> getTeardownFuture() {

3
proxy/src/main/java/com/velocitypowered/proxy/connection/client/InitialConnectSessionHandler.java
View File

@@ -1,6 +1,7 @@
package com.velocitypowered.proxy.connection.client;
import com.velocitypowered.proxy.connection.MinecraftSessionHandler;
import com.velocitypowered.proxy.connection.backend.BungeeCordMessageResponder;
import com.velocitypowered.proxy.connection.backend.VelocityServerConnection;
import com.velocitypowered.proxy.protocol.packet.PluginMessage;
import com.velocitypowered.proxy.protocol.util.PluginMessageUtil;
@@ -25,6 +26,8 @@ public class InitialConnectSessionHandler implements MinecraftSessionHandler {
player.getKnownChannels().addAll(PluginMessageUtil.getChannels(packet));
} else if (PluginMessageUtil.isUnregister(packet)) {
player.getKnownChannels().removeAll(PluginMessageUtil.getChannels(packet));
} else if (BungeeCordMessageResponder.isBungeeCordMessage(packet)) {
return true;
}
serverConn.ensureConnected().write(packet.retain());
}

22
proxy/src/main/java/com/velocitypowered/proxy/connection/client/LoginSessionHandler.java
View File

@@ -183,7 +183,11 @@ public class LoginSessionHandler implements MinecraftSessionHandler {
} else {
initializePlayer(GameProfile.forOfflinePlayer(login.getUsername()), false);
}
}, mcConnection.eventLoop());
}, mcConnection.eventLoop())
.exceptionally((ex) -> {
logger.error("Exception in pre-login stage", ex);
return null;
});
}
private EncryptionRequest generateEncryptionRequest() {
@@ -202,6 +206,7 @@ public class LoginSessionHandler implements MinecraftSessionHandler {
server.getConfiguration().getPlayerInfoForwardingMode());
GameProfileRequestEvent profileRequestEvent = new GameProfileRequestEvent(inbound, profile,
onlineMode);
final GameProfile finalProfile = profile;
server.getEventManager().fire(profileRequestEvent).thenCompose(profileEvent -> {
if (mcConnection.isClosed()) {
@@ -229,6 +234,9 @@ public class LoginSessionHandler implements MinecraftSessionHandler {
completeLoginProtocolPhaseAndInitialize(player);
}
}, mcConnection.eventLoop());
}).exceptionally((ex) -> {
logger.error("Exception during connection of {}", finalProfile, ex);
return null;
});
}
@@ -274,7 +282,11 @@ public class LoginSessionHandler implements MinecraftSessionHandler {
server.getEventManager().fire(new PostLoginEvent(player))
.thenRun(() -> connectToInitialServer(player));
}
}, mcConnection.eventLoop());
}, mcConnection.eventLoop())
.exceptionally((ex) -> {
logger.error("Exception while completing login initialisation phase for {}", player, ex);
return null;
});
}
private void connectToInitialServer(ConnectedPlayer player) {
@@ -291,7 +303,11 @@ public class LoginSessionHandler implements MinecraftSessionHandler {
return;
}
player.createConnectionRequest(toTry.get()).fireAndForget();
}, mcConnection.eventLoop());
}, mcConnection.eventLoop())
.exceptionally((ex) -> {
logger.error("Exception while connecting {} to initial server", player, ex);
return null;
});
}
@Override

16
proxy/src/main/java/com/velocitypowered/proxy/connection/client/StatusSessionHandler.java
View File

@@ -120,6 +120,10 @@ public class StatusSessionHandler implements MinecraftSessionHandler {
continue;
}
if (response.getDescriptionComponent() == null) {
continue;
}
return new ServerPing(
fallback.getVersion(),
fallback.getPlayers().orElse(null),
@@ -163,7 +167,11 @@ public class StatusSessionHandler implements MinecraftSessionHandler {
.thenCompose(ping -> server.getEventManager().fire(new ProxyPingEvent(inbound, ping)))
.thenAcceptAsync(event -> connection.closeWith(
LegacyDisconnect.fromServerPing(event.getPing(), packet.getVersion())),
connection.eventLoop());
connection.eventLoop())
.exceptionally((ex) -> {
logger.error("Exception while handling legacy ping {}", packet, ex);
return null;
});
return true;
}
@@ -189,7 +197,11 @@ public class StatusSessionHandler implements MinecraftSessionHandler {
.toJson(event.getPing(), json);
connection.write(new StatusResponse(json));
},
connection.eventLoop());
connection.eventLoop())
.exceptionally((ex) -> {
logger.error("Exception while handling status request {}", packet, ex);
return null;
});
return true;
}

8
proxy/src/main/java/com/velocitypowered/proxy/plugin/VelocityEventManager.java
View File

@@ -113,12 +113,10 @@ public class VelocityEventManager implements EventManager {
return CompletableFuture.completedFuture(event);
}
CompletableFuture<E> eventFuture = new CompletableFuture<>();
service.execute(() -> {
return CompletableFuture.supplyAsync(() -> {
fireEvent(event);
eventFuture.complete(event);
});
return eventFuture;
return event;
}, service);
}
@Override

8
proxy/src/main/java/com/velocitypowered/proxy/protocol/netty/GS4QueryHandler.java
View File

@@ -30,6 +30,7 @@ import java.util.Optional;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import net.kyori.adventure.text.serializer.plain.PlainComponentSerializer;
import org.apache.logging.log4j.LogManager;
public class GS4QueryHandler extends SimpleChannelInboundHandler<DatagramPacket> {
@@ -163,7 +164,12 @@ public class GS4QueryHandler extends SimpleChannelInboundHandler<DatagramPacket>
// Send the response
DatagramPacket responsePacket = new DatagramPacket(queryResponse, msg.sender());
ctx.writeAndFlush(responsePacket, ctx.voidPromise());
}, ctx.channel().eventLoop());
}, ctx.channel().eventLoop())
.exceptionally((ex) -> {
LogManager.getLogger(getClass()).error(
"Exception while writing GS4 response for query from {}", senderAddress, ex);
return null;
});
break;
}
default:

240
proxy/src/main/java/com/velocitypowered/proxy/util/InformationUtils.java Normal file
View File

@@ -0,0 +1,240 @@
package com.velocitypowered.proxy.util;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import com.velocitypowered.api.plugin.PluginContainer;
import com.velocitypowered.api.plugin.PluginDescription;
import com.velocitypowered.api.plugin.meta.PluginDependency;
import com.velocitypowered.api.proxy.ProxyServer;
import com.velocitypowered.api.proxy.config.ProxyConfig;
import com.velocitypowered.api.proxy.server.RegisteredServer;
import com.velocitypowered.api.util.ProxyVersion;
import java.net.Inet4Address;
import java.net.Inet6Address;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.util.List;
import java.util.Map;
public enum InformationUtils {
;
/**
* Retrieves a {@link JsonArray} containing basic information about all
* running plugins on the {@link ProxyServer} instance.
*
* @param proxy the proxy instance to retrieve from
* @return {@link JsonArray} containing zero or more {@link JsonObject}
*/
public static JsonArray collectPluginInfo(ProxyServer proxy) {
List<PluginContainer> allPlugins = ImmutableList.copyOf(
proxy.getPluginManager().getPlugins());
JsonArray plugins = new JsonArray();
for (PluginContainer plugin : allPlugins) {
PluginDescription desc = plugin.getDescription();
JsonObject current = new JsonObject();
current.addProperty("id", desc.getId());
if (desc.getName().isPresent()) {
current.addProperty("name", desc.getName().get());
}
if (desc.getVersion().isPresent()) {
current.addProperty("version", desc.getVersion().get());
}
if (!desc.getAuthors().isEmpty()) {
JsonArray authorsArray = new JsonArray();
for (String author : desc.getAuthors()) {
authorsArray.add(author);
}
current.add("authors", authorsArray);
}
if (desc.getDescription().isPresent()) {
current.addProperty("description", desc.getDescription().get());
}
if (desc.getUrl().isPresent()) {
current.addProperty("url", desc.getUrl().get());
}
if (!desc.getDependencies().isEmpty()) {
JsonArray dependencies = new JsonArray();
for (PluginDependency dependency : desc.getDependencies()) {
dependencies.add(dependency.getId());
}
current.add("dependencies", dependencies);
}
plugins.add(current);
}
return plugins;
}
/**
* Creates a {@link JsonObject} containing information about the
* current environment the project is run under.
*
* @return {@link JsonObject} containing environment info
*/
public static JsonObject collectEnvironmentInfo() {
JsonObject envInfo = new JsonObject();
envInfo.addProperty("operatingSystemType", System.getProperty("os.name"));
envInfo.addProperty("operatingSystemVersion", System.getProperty("os.version"));
envInfo.addProperty("operatingSystemArchitecture", System.getProperty("os.arch"));
envInfo.addProperty("javaVersion", System.getProperty("java.version"));
envInfo.addProperty("javaVendor", System.getProperty("java.vendor"));
return envInfo;
}
/**
* Creates a {@link JsonObject} containing information about the
* forced hosts of the {@link ProxyConfig} instance.
*
* @return {@link JsonArray} containing forced hosts
*/
public static JsonObject collectForcedHosts(ProxyConfig config) {
JsonObject forcedHosts = new JsonObject();
Map<String, List<String>> allForcedHosts = ImmutableMap.copyOf(
config.getForcedHosts());
for (Map.Entry<String, List<String>> entry : allForcedHosts.entrySet()) {
JsonArray host = new JsonArray();
for (int i = 0; i < entry.getValue().size(); i++) {
host.add(entry.getValue().get(i));
}
forcedHosts.add(entry.getKey(), host);
}
return forcedHosts;
}
/**
* Anonymises or redacts a given {@link InetAddress}
* public address bits.
*
* @param address The address to redact
* @return {@link String} address with public parts redacted
*/
public static String anonymizeInetAddress(InetAddress address) {
if (address instanceof Inet4Address) {
Inet4Address v4 = (Inet4Address) address;
if (v4.isAnyLocalAddress() || v4.isLoopbackAddress()
|| v4.isLinkLocalAddress()
|| v4.isSiteLocalAddress()) {
return address.getHostAddress();
} else {
byte[] addr = v4.getAddress();
return (addr[0] & 0xff) + "." + (addr[1] & 0xff) + ".XXX.XXX";
}
} else if (address instanceof Inet6Address) {
Inet6Address v6 = (Inet6Address) address;
if (v6.isAnyLocalAddress() || v6.isLoopbackAddress()
|| v6.isSiteLocalAddress()
|| v6.isSiteLocalAddress()) {
return address.getHostAddress();
} else {
String[] bits = v6.getHostAddress().split(":");
String ret = "";
boolean flag = false;
for (int iter = 0; iter < bits.length; iter++) {
if (flag) {
ret += ":X";
continue;
}
if (!bits[iter].equals("0")) {
if (iter == 0) {
ret = bits[iter];
} else {
ret = "::" + bits[iter];
}
flag = true;
}
}
return ret;
}
} else {
return address.getHostAddress();
}
}
/**
* Creates a {@link JsonObject} containing most relevant
* information of the {@link RegisteredServer} for diagnosis.
*
* @param server the server to evaluate
* @return {@link JsonObject} containing server and diagnostic info
*/
public static JsonObject collectServerInfo(RegisteredServer server) {
JsonObject info = new JsonObject();
info.addProperty("currentPlayers", server.getPlayersConnected().size());
InetSocketAddress iaddr = server.getServerInfo().getAddress();
if (iaddr.isUnresolved()) {
// Greetings form Netty 4aa10db9
info.addProperty("host", iaddr.getHostString());
} else {
info.addProperty("host", anonymizeInetAddress(iaddr.getAddress()));
}
info.addProperty("port", iaddr.getPort());
return info;
}
/**
* Creates a {@link JsonObject} containing information about the
* current environment the project is run under.
*
* @param version the proxy instance to retrieve from
* @return {@link JsonObject} containing environment info
*/
public static JsonObject collectProxyInfo(ProxyVersion version) {
return (JsonObject) serializeObject(version, false);
}
/**
* Creates a {@link JsonObject} containing most relevant
* information of the {@link ProxyConfig} for diagnosis.
*
* @param config the config instance to retrieve from
* @return {@link JsonObject} containing select config values
*/
public static JsonObject collectProxyConfig(ProxyConfig config) {
return (JsonObject) serializeObject(config, true);
}
/**
* Creates a human-readable String from a {@link JsonElement}.
*
* @param json the {@link JsonElement} object
* @return the human-readable String
*/
public static String toHumanReadableString(JsonElement json) {
return GSON_WITHOUT_EXCLUDES.toJson(json);
}
/**
* Creates a {@link JsonObject} from a String.
*
* @param toParse the String to parse
* @return {@link JsonObject} object
*/
public static JsonObject parseString(String toParse) {
return GSON_WITHOUT_EXCLUDES.fromJson(toParse, JsonObject.class);
}
private static JsonElement serializeObject(Object toSerialize, boolean withExcludes) {
return JsonParser.parseString(
withExcludes ? GSON_WITH_EXCLUDES.toJson(toSerialize) :
GSON_WITHOUT_EXCLUDES.toJson(toSerialize));
}
private static final Gson GSON_WITH_EXCLUDES = new GsonBuilder()
.setPrettyPrinting()
.excludeFieldsWithoutExposeAnnotation()
.create();
private static final Gson GSON_WITHOUT_EXCLUDES = new GsonBuilder()
.setPrettyPrinting()
.create();
}