Feature: per-server info forwarding mode

api/src/main/java/com/velocitypowered/api/proxy/config/BackendServerConfig.java

@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2018-2021 Velocity Contributors
+ *
+ * The Velocity API is licensed under the terms of the MIT License. For more details,
+ * reference the LICENSE file in the api top-level directory.
+ */
+
+package com.velocitypowered.api.proxy.config;
+
+import com.velocitypowered.api.proxy.server.ServerInfoForwardingMode;
+
+/**
+ * Exposes server configuration information that plugins may use.
+ */
+public interface BackendServerConfig {
+
+  /**
+   * Get the address of the backend server.
+   *
+   * @return the address formatted as address:port
+   */
+  String getAddress();
+
+  /**
+   * Get the info forwarding mode of the server<br><br>
+   * <b>What's this?</b><br>
+   * The server can use a different mode to obtain and forward player info.<br>
+   * For instance, if you are running a 1.12 (or lower version) server on a velocity proxy with MODERN player info forwarding
+   * the server doesn't support MODERN forwarding. So you need to set LEGACY forwarding mode for that server
+   * and velocity will use ONLY FOR THAT SERVER the legacy forwarding mode.<br><br>
+   * <i><b>TIP:</b> If you need to set this value when creating dynamic servers in your plugins you can do that by adding
+   * the ServerInfoForwardingMode value as the last parameter while creating a new server info.</i>
+   *
+   * @return the server info forwarding mode
+   */
+
+  ServerInfoForwardingMode getForwardingMode();
+
+  /**
+   * Set the address of the backend server.
+   */
+  void setAddress(String address);
+
+  /**
+   * Set the forwarding mode of the backend server.
+   */
+  void setForwardingMode(ServerInfoForwardingMode forwardingMode);
+
+}

api/src/main/java/com/velocitypowered/api/proxy/config/ProxyConfig.java

@@ -86,6 +86,16 @@ public interface ProxyConfig {
    */
   Map<String, String> getServers();
 
+  /**
+   * Get a Map of all servers registered in <code>velocity.toml</code>. This method does
+   * <strong>not</strong> return all the servers currently in memory, although in most cases it
+   * does. For a view of all registered servers, see {@link ProxyServer#getAllServers()}.
+   *
+   * @return registered servers map with, instead of the only address, the Backend Server Object for each
+   *     of them which contains the address of the server and its info forwarding mode.
+   */
+  Map<String, BackendServerConfig> getBackendServers();
+
   /**
    * Get the order of servers that players will be connected to.
    *

api/src/main/java/com/velocitypowered/api/proxy/server/ServerInfo.java

@@ -21,6 +21,21 @@ public final class ServerInfo implements Comparable<ServerInfo> {
   private final String name;
   private final InetSocketAddress address;
 
+  private final ServerInfoForwardingMode forwardingMode;
+
+  /**
+   * Creates a new ServerInfo object.
+   *
+   * @param name the name for the server
+   * @param address the address of the server to connect to
+   * @param forwardingMode the server info forwarding mode
+   */
+  public ServerInfo(String name, InetSocketAddress address, ServerInfoForwardingMode forwardingMode) {
+    this.name = Preconditions.checkNotNull(name, "name");
+    this.address = Preconditions.checkNotNull(address, "address");
+    this.forwardingMode = Preconditions.checkNotNull(forwardingMode, "forwardingMode");
+  }
+
   /**
    * Creates a new ServerInfo object.
    *
@@ -30,6 +45,7 @@ public final class ServerInfo implements Comparable<ServerInfo> {
   public ServerInfo(String name, InetSocketAddress address) {
     this.name = Preconditions.checkNotNull(name, "name");
     this.address = Preconditions.checkNotNull(address, "address");
+    this.forwardingMode = ServerInfoForwardingMode.FOLLOWUP;
   }
 
   public final String getName() {
@@ -40,6 +56,15 @@ public final InetSocketAddress getAddress() {
     return address;
   }
 
+  /**
+   * Get what mode will the backend server use to communicate with velocity.
+   *
+   * @return FOLLOWUP mode if the server uses the same mode as set in the main config else one of the available modes
+   */
+  public final ServerInfoForwardingMode getServerInfoForwardingMode() {
+    return forwardingMode;
+  }
+
   @Override
   public String toString() {
     return "ServerInfo{"

api/src/main/java/com/velocitypowered/api/proxy/server/ServerInfoForwardingMode.java

@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2018-2021 Velocity Contributors
+ *
+ * The Velocity API is licensed under the terms of the MIT License. For more details,
+ * reference the LICENSE file in the api top-level directory.
+ */
+
+package com.velocitypowered.api.proxy.server;
+
+/**
+ * Supported server info forwarding methods.
+ */
+public enum ServerInfoForwardingMode {
+    /**
+     * This type will follow the value of the player-info-forwarding-mode in the velocity configuration.
+     */
+    FOLLOWUP,
+    MODERN,
+    BUNGEEGUARD,
+    LEGACY,
+    NONE
+}
+

proxy/src/main/java/com/velocitypowered/proxy/ProxyOptions.java

@@ -18,6 +18,7 @@
 package com.velocitypowered.proxy;
 
 import com.velocitypowered.api.proxy.server.ServerInfo;
+import com.velocitypowered.api.proxy.server.ServerInfoForwardingMode;
 import com.velocitypowered.proxy.util.AddressUtil;
 import java.io.IOException;
 import java.net.InetSocketAddress;
@@ -105,17 +106,23 @@ private static class ServerInfoConverter implements ValueConverter<ServerInfo> {
 
     @Override
     public ServerInfo convert(String s) {
-      String[] split = s.split(":", 2);
-      if (split.length < 2) {
-        throw new ValueConversionException("Invalid server format. Use <name>:<address>");
+      String[] split = s.split(":", 3);
+      if (split.length < 3) {
+        throw new ValueConversionException("Invalid server format. Use <name>:<address>:<forwardingmode>");
       }
       InetSocketAddress address;
+      ServerInfoForwardingMode mode;
       try {
         address = AddressUtil.parseAddress(split[1]);
       } catch (IllegalStateException e) {
         throw new ValueConversionException("Invalid hostname for server flag with name: " + split[0]);
       }
-      return new ServerInfo(split[0], address);
+      try {
+        mode = ServerInfoForwardingMode.valueOf(split[2]);
+      } catch (IllegalStateException e) {
+        throw new ValueConversionException("Invalid forwarding mode for server flag with name: " + split[0]);
+      }
+      return new ServerInfo(split[0], address, mode);
     }
 
     @Override

proxy/src/main/java/com/velocitypowered/proxy/VelocityServer.java

@@ -33,6 +33,7 @@
 import com.velocitypowered.api.plugin.PluginManager;
 import com.velocitypowered.api.proxy.Player;
 import com.velocitypowered.api.proxy.ProxyServer;
+import com.velocitypowered.api.proxy.config.BackendServerConfig;
 import com.velocitypowered.api.proxy.player.ResourcePackInfo;
 import com.velocitypowered.api.proxy.server.RegisteredServer;
 import com.velocitypowered.api.proxy.server.ServerInfo;
@@ -297,8 +298,12 @@ void start() {
     }
 
     if (!options.isIgnoreConfigServers()) {
-      for (Map.Entry<String, String> entry : configuration.getServers().entrySet()) {
-        servers.register(new ServerInfo(entry.getKey(), AddressUtil.parseAddress(entry.getValue())));
+      for (Map.Entry<String, BackendServerConfig> entry : configuration.getBackendServers().entrySet()) {
+        servers.register(new ServerInfo(
+                entry.getKey(),
+                AddressUtil.parseAddress(entry.getValue().getAddress()),
+                entry.getValue().getForwardingMode())
+        );
       }
     }
 
@@ -489,8 +494,12 @@ public boolean reloadConfiguration() throws IOException {
     // Re-register servers. If a server is being replaced, make sure to note what players need to
     // move back to a fallback server.
     Collection<ConnectedPlayer> evacuate = new ArrayList<>();
-    for (Map.Entry<String, String> entry : newConfiguration.getServers().entrySet()) {
-      ServerInfo newInfo = new ServerInfo(entry.getKey(), AddressUtil.parseAddress(entry.getValue()));
+    for (Map.Entry<String, BackendServerConfig> entry : newConfiguration.getBackendServers().entrySet()) {
+      ServerInfo newInfo = new ServerInfo(
+              entry.getKey(),
+              AddressUtil.parseAddress(entry.getValue().getAddress()),
+              entry.getValue().getForwardingMode()
+      );
       Optional<RegisteredServer> rs = servers.getServer(entry.getKey());
       if (rs.isEmpty()) {
         servers.register(newInfo);

proxy/src/main/java/com/velocitypowered/proxy/config/VelocityConfiguration.java

@@ -24,13 +24,16 @@
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.gson.annotations.Expose;
+import com.velocitypowered.api.proxy.config.BackendServerConfig;
 import com.velocitypowered.api.proxy.config.ProxyConfig;
+import com.velocitypowered.api.proxy.server.ServerInfoForwardingMode;
 import com.velocitypowered.api.util.Favicon;
 import com.velocitypowered.proxy.config.migration.ConfigurationMigration;
 import com.velocitypowered.proxy.config.migration.ForwardingMigration;
 import com.velocitypowered.proxy.config.migration.KeyAuthenticationMigration;
 import com.velocitypowered.proxy.config.migration.MotdMigration;
 import com.velocitypowered.proxy.config.migration.TransferIntegrationMigration;
+import com.velocitypowered.proxy.config.server.BackendServerConfigImpl;
 import com.velocitypowered.proxy.util.AddressUtil;
 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
 import java.io.IOException;
@@ -175,9 +178,9 @@ public boolean validate() {
       logger.warn("You don't have any servers configured.");
     }
 
-    for (Map.Entry<String, String> entry : servers.getServers().entrySet()) {
+    for (Map.Entry<String, BackendServerConfig> entry : servers.getBackendServers().entrySet()) {
       try {
-        AddressUtil.parseAddress(entry.getValue());
+        AddressUtil.parseAddress(entry.getValue().getAddress());
       } catch (IllegalArgumentException e) {
         logger.error("Server {} does not have a valid IP address.", entry.getKey(), e);
         valid = false;
@@ -315,6 +318,11 @@ public Map<String, String> getServers() {
     return servers.getServers();
   }
 
+  @Override
+  public Map<String, BackendServerConfig> getBackendServers() {
+    return servers.getBackendServers();
+  }
+
   @Override
   public List<String> getAttemptConnectionOrder() {
     return servers.getAttemptConnectionOrder();
@@ -611,10 +619,10 @@ public boolean isOnlineModeKickExistingPlayers() {
 
   private static class Servers {
 
-    private Map<String, String> servers = ImmutableMap.of(
-        "lobby", "127.0.0.1:30066",
-        "factions", "127.0.0.1:30067",
-        "minigames", "127.0.0.1:30068"
+    private Map<String, BackendServerConfig> servers = ImmutableMap.of(
+        "lobby", new BackendServerConfigImpl("127.0.0.1:30066"),
+        "factions", new BackendServerConfigImpl("127.0.0.1:30067", ServerInfoForwardingMode.MODERN),
+        "minigames", new BackendServerConfigImpl("127.0.0.1:30068", ServerInfoForwardingMode.LEGACY)
     );
     private List<String> attemptConnectionOrder = ImmutableList.of("lobby");
 
@@ -623,14 +631,31 @@ private Servers() {
 
     private Servers(CommentedConfig config) {
       if (config != null) {
-        Map<String, String> servers = new HashMap<>();
+        Map<String, BackendServerConfig> servers = new HashMap<>();
         for (UnmodifiableConfig.Entry entry : config.entrySet()) {
-          if (entry.getValue() instanceof String) {
-            servers.put(cleanServerName(entry.getKey()), entry.getValue());
+          if (entry.getValue() instanceof com.electronwill.nightconfig.core.CommentedConfig c) {
+            String address = null;
+            ServerInfoForwardingMode forwardingMode = ServerInfoForwardingMode.FOLLOWUP;
+            for (UnmodifiableConfig.Entry entry2 : c.entrySet()) {
+              if (entry2.getKey().equalsIgnoreCase("address")) {
+                address = entry2.getValue();
+              }
+              if (entry2.getKey().equalsIgnoreCase("forwarding-mode")) {
+                forwardingMode = ServerInfoForwardingMode.valueOf(ServerInfoForwardingMode.class, entry2.getValue());
+              }
+            }
+            if (address == null) {
+              throw new IllegalArgumentException(
+                      "Server entry " + entry.getKey() + " is missing address!");
+            }
+            servers.put(cleanServerName(entry.getKey()), new BackendServerConfigImpl(address, forwardingMode));
+            //support for old server config system (forwarding mode will be followup)
+          } else if (entry.getValue() instanceof String v) {
+            servers.put(cleanServerName(entry.getKey()), new BackendServerConfigImpl(v));
           } else {
             if (!entry.getKey().equalsIgnoreCase("try")) {
               throw new IllegalArgumentException(
-                  "Server entry " + entry.getKey() + " is not a string!");
+                  "Server entry " + entry.getKey() + " is not a server!");
             }
           }
         }
@@ -639,16 +664,22 @@ private Servers(CommentedConfig config) {
       }
     }
 
-    private Servers(Map<String, String> servers, List<String> attemptConnectionOrder) {
+    private Servers(Map<String, BackendServerConfig> servers, List<String> attemptConnectionOrder) {
       this.servers = servers;
       this.attemptConnectionOrder = attemptConnectionOrder;
     }
 
     private Map<String, String> getServers() {
+      Map<String, String> serverAddresses = new HashMap<>();
+      servers.forEach((k, v) -> serverAddresses.put(k, v.getAddress()));
+      return serverAddresses;
+    }
+
+    private Map<String, BackendServerConfig> getBackendServers() {
       return servers;
     }
 
-    public void setServers(Map<String, String> servers) {
+    public void setServers(Map<String, BackendServerConfig> servers) {
       this.servers = servers;
     }