Upstream
/
SubServers-2
mirror of https://github.com/ME1312/SubServers-2.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
SubServers-2/SubServers.Bungee/src/net/ME1312/SubServers/Bungee/SubProxy.java

1125 lines
71 KiB
Java
Raw Normal View History

SubServers 2 Beta 4
2016-12-24 05:55:17 +01:00
package net.ME1312.SubServers.Bungee;
Optimize imports
2020-11-16 21:34:59 +01:00
import net.ME1312.Galaxi.Library.Config.YAMLConfig;
import net.ME1312.Galaxi.Library.Config.YAMLSection;
Update GalaxiEngine
2020-11-14 08:07:25 +01:00
import net.ME1312.Galaxi.Library.Container.Container;
Begin rewrite for SubData 2
2019-04-18 16:02:09 +02:00
import net.ME1312.Galaxi.Library.Map.ObjectMap;
import net.ME1312.Galaxi.Library.UniversalFile;
import net.ME1312.Galaxi.Library.Util;
Optimize imports
2020-11-16 21:34:59 +01:00
import net.ME1312.Galaxi.Library.Version.Version;
import net.ME1312.SubData.Server.ClientHandler;
Begin rewrite for SubData 2
2019-04-18 16:02:09 +02:00
import net.ME1312.SubData.Server.Encryption.AES;
#50 #46 Selecting Multiple Servers This commit includes the following major changes and additions: -> New Command & Permission Formatting -> RemotePlayer API -> SubData with Blocks
2020-06-12 07:45:49 +02:00
import net.ME1312.SubData.Server.Encryption.DHE;
Begin rewrite for SubData 2
2019-04-18 16:02:09 +02:00
import net.ME1312.SubData.Server.Encryption.RSA;
Optimize imports
2020-11-16 21:34:59 +01:00
import net.ME1312.SubData.Server.SubDataClient;
import net.ME1312.SubData.Server.SubDataServer;
import net.ME1312.SubServers.Bungee.Event.SubRemoveProxyEvent;
import net.ME1312.SubServers.Bungee.Event.SubStoppedEvent;
Preserve YAML element order
2017-11-22 22:58:33 +01:00
import net.ME1312.SubServers.Bungee.Host.*;
#50 #46 Selecting Multiple Servers This commit includes the following major changes and additions: -> New Command & Permission Formatting -> RemotePlayer API -> SubData with Blocks
2020-06-12 07:45:49 +02:00
import net.ME1312.SubServers.Bungee.Library.Compatibility.LegacyServerMap;
Add support for GalaxiBungee
2019-05-17 00:36:41 +02:00
import net.ME1312.SubServers.Bungee.Library.Compatibility.Logger;
#50 #46 Selecting Multiple Servers This commit includes the following major changes and additions: -> New Command & Permission Formatting -> RemotePlayer API -> SubData with Blocks
2020-06-12 07:45:49 +02:00
import net.ME1312.SubServers.Bungee.Library.ConfigUpdater;
SubServers 2 Beta 4
2016-12-24 05:55:17 +01:00
import net.ME1312.SubServers.Bungee.Library.Exception.InvalidHostException;
import net.ME1312.SubServers.Bungee.Library.Exception.InvalidServerException;
Rewrite SmartFallback's Fallback process
2020-12-05 05:30:36 +01:00
import net.ME1312.SubServers.Bungee.Library.Fallback.FallbackState;
Optimize imports
2020-11-16 21:34:59 +01:00
import net.ME1312.SubServers.Bungee.Library.Fallback.SmartFallback;
import net.ME1312.SubServers.Bungee.Library.Metrics;
Favor new connections over the old ones This is a change to the rules that govern what happens when the same UUID connects to the same network more than once. It is now more BungeeCord like in nature.
2020-08-19 21:24:05 +02:00
import net.ME1312.SubServers.Bungee.Network.Packet.PacketExDisconnectPlayer;
Optimize imports
2020-11-16 21:34:59 +01:00
import net.ME1312.SubServers.Bungee.Network.Packet.PacketExSyncPlayer;
SubServers.Sync.Velocity #64 (Preview) And automatic external server definitions
2021-07-09 07:46:10 +02:00
import net.ME1312.SubServers.Bungee.Network.Packet.PacketLinkServer;
Begin rewrite for SubData 2
2019-04-18 16:02:09 +02:00
import net.ME1312.SubServers.Bungee.Network.Packet.PacketOutExReload;
import net.ME1312.SubServers.Bungee.Network.SubProtocol;
Optimize imports
2020-11-16 21:34:59 +01:00
import com.dosse.upnp.UPnP;
import com.google.common.collect.Range;
import com.google.gson.Gson;
Modify pings for DNS-Forward servers
2020-07-04 01:05:02 +02:00
import net.md_5.bungee.BungeeServerInfo;
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
import net.md_5.bungee.UserConnection;
Begin rewrite for SubData 2
2019-04-18 16:02:09 +02:00
import net.md_5.bungee.api.ChatColor;
Secure the compatibility plugin This commit moves the loadable section of the compatibility plugin to an anonymous class to prevent misuse of that section of code.
2021-02-15 06:28:06 +01:00
import net.md_5.bungee.api.ProxyServer;
Add warnings for connecting to known offline servers #39
2019-02-27 20:05:05 +01:00
import net.md_5.bungee.api.ServerPing;
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
import net.md_5.bungee.api.chat.BaseComponent;
Add warnings for connecting to known offline servers #39
2019-02-27 20:05:05 +01:00
import net.md_5.bungee.api.chat.TextComponent;
Add UPnP Forwarding Option
2018-10-08 01:25:08 +02:00
import net.md_5.bungee.api.config.ListenerInfo;
SubServers.Bungee
2016-12-05 04:21:04 +01:00
import net.md_5.bungee.api.config.ServerInfo;
Misc fixes regarding the last few commits
2020-08-22 00:33:09 +02:00
import net.md_5.bungee.api.connection.ProxiedPlayer;
Add warnings for connecting to known offline servers #39
2019-02-27 20:05:05 +01:00
import net.md_5.bungee.api.event.*;
SubServers, Host, & Client v2.12.1a
2017-08-15 11:58:48 +02:00
import net.md_5.bungee.api.plugin.Listener;
Secure the compatibility plugin This commit moves the loadable section of the compatibility plugin to an anonymous class to prevent misuse of that section of code.
2021-02-15 06:28:06 +01:00
import net.md_5.bungee.api.plugin.Plugin;
import net.md_5.bungee.api.plugin.PluginDescription;
Rework SubServers.Bungee's app lifecycle SubServers.Bungee now puts code in 2 new places to better load/unload it's data. When supported, this should give it better compatabilty with ordanary plugins. Also, it no longer has to 'shutdown' to handle /greload. Isn't that neat?
2021-02-07 05:53:03 +01:00
import net.md_5.bungee.api.plugin.PluginManager;
Modify pings for DNS-Forward servers
2020-07-04 01:05:02 +02:00
import net.md_5.bungee.connection.InitialHandler;
SubServers, Host, & Client v2.12.1a
2017-08-15 11:58:48 +02:00
import net.md_5.bungee.event.EventHandler;
Better legacy API emulation
2021-03-13 17:51:32 +01:00
import net.md_5.bungee.util.CaseInsensitiveMap;
SubServers.Bungee
2016-12-05 04:21:04 +01:00
import java.io.*;
Start SubServers.Host & SubAPI Null Checks This marks the beginning of SubServers.Host. As of now it is just a simple plugin loading API, but it is planned to become a way to host servers on other machines. Also, SubAPI now checks to make sure variables aren't null in many places.
2017-01-30 21:22:36 +01:00
import java.lang.reflect.InvocationTargetException;
Host & Server objects are now signed (prevents desyncs across apps)
2017-12-10 01:30:06 +01:00
import java.math.BigInteger;
SubServers.Bungee
2016-12-05 04:21:04 +01:00
import java.net.InetAddress;
Update Javadoc
2017-04-16 19:02:14 +02:00
import java.net.InetSocketAddress;
SubServers, Host & Client v2.12.1c/2.12.1b/2.12.1b
2017-08-18 11:58:06 +02:00
import java.net.URL;
import java.nio.charset.Charset;
SubServers.Bungee
2016-12-05 04:21:04 +01:00
import java.nio.file.Files;
Begin rewrite for SubData 2
2019-04-18 16:02:09 +02:00
import java.security.SecureRandom;
SubServers, Host, & Client v2.11.2m/2.11.2c/2.11.2h
2017-05-30 21:38:51 +02:00
import java.text.DecimalFormat;
SubServers.Bungee
2016-12-05 04:21:04 +01:00
import java.util.*;
SubServers Release v2.11.2c
2017-01-01 20:34:46 +01:00
import java.util.concurrent.TimeUnit;
SubServers.Bungee
2016-12-05 04:21:04 +01:00
/**
* Main Plugin Class
*/
BungeeCommon API
2020-11-14 04:41:56 +01:00
public final class SubProxy extends BungeeCommon implements Listener {
#50 #46 Selecting Multiple Servers This commit includes the following major changes and additions: -> New Command & Permission Formatting -> RemotePlayer API -> SubData with Blocks
2020-06-12 07:45:49 +02:00
final LinkedHashMap<String, LinkedHashMap<String, String>> exLang = new LinkedHashMap<String, LinkedHashMap<String, String>>();
final HashMap<String, Class<? extends Host>> hostDrivers = new HashMap<String, Class<? extends Host>>();
Register SubServers.Sync Proxies to name for API access
2018-01-22 16:01:33 +01:00
public final HashMap<String, Proxy> proxies = new HashMap<String, Proxy>();
SubServers.Bungee
2016-12-05 04:21:04 +01:00
public final HashMap<String, Host> hosts = new HashMap<String, Host>();
Update Javadoc
2017-04-16 19:02:14 +02:00
public final HashMap<String, Server> exServers = new HashMap<String, Server>();
private final HashMap<String, ServerInfo> legServers = new HashMap<String, ServerInfo>();
Ditch RedisBungee. Long live the RemotePlayer API RedisBungee has been abandoned by it's developers. So we're abanding it too. SubServers.Sync will now finally pick up the slack and sync basic player information between proxies over their SubData connection.
2020-07-25 07:20:59 +02:00
public final HashMap<UUID, Server> rPlayerLinkS = new HashMap<UUID, Server>();
public final HashMap<UUID, Proxy> rPlayerLinkP = new HashMap<UUID, Proxy>();
public final HashMap<UUID, RemotePlayer> rPlayers = new HashMap<UUID, RemotePlayer>();
Rewrite SmartFallback's Fallback process
2020-12-05 05:30:36 +01:00
private final HashMap<UUID, FallbackState> fallback = new HashMap<UUID, FallbackState>();
SubServers.Bungee
2016-12-05 04:21:04 +01:00
API Additions & Launch Changes
2017-01-08 03:30:03 +01:00
public final PrintStream out;
SubServers.Bungee Beta 1 The first beta release of SubServers.Bungee
2016-12-15 22:04:39 +01:00
public final UniversalFile dir = new UniversalFile(new File(System.getProperty("user.dir")));
SubServers.Bungee
2016-12-05 04:21:04 +01:00
public YAMLConfig config;
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
public YAMLConfig servers;
private YAMLConfig bungee;
public YAMLConfig lang;
Make the compatibility plugin loadable Some BungeeCord API calls require an actual plugin object. This is a problem. Fortunately, the 2020 builds of BungeeCord provide a protected constructor that is actually usable by SubServers, so we implemented it.
2020-11-11 08:35:02 +01:00
public final Plugin plugin;
/sub reload can now perform soft reloads /sub reload - can now perform soft reloads /greload - still performs hard resets Soft Reloads mean that SubServers will load new data from the config and attempt to merge it with what is already in memory. This is good if you need to make some quick changes, since it will only stop servers if a major change has been made to them. However, this has the potential to cause issues, which is why the Hard Reset will continue to be tied to bungeecord command.
2017-12-09 09:43:29 +01:00
public final SubAPI api = new SubAPI(this);
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
public SubProtocol subprotocol;
SubServers.Bungee Beta 1 The first beta release of SubServers.Bungee
2016-12-15 22:04:39 +01:00
public SubDataServer subdata = null;
SubServers, Host, & Client v2.12.1a
2017-08-15 11:58:48 +02:00
public SubServer sudo = null;
Feature creep commit This commit has 3 new features in it: -> Internal Templates -> The new Purpur Template -> Changes to External Logging
2021-06-25 05:06:53 +02:00
public static final Version version = Version.fromString("2.17.1a");
SubServers.Bungee
2016-12-05 04:21:04 +01:00
Ditch RedisBungee. Long live the RemotePlayer API RedisBungee has been abandoned by it's developers. So we're abanding it too. SubServers.Sync will now finally pick up the slack and sync basic player information between proxies over their SubData connection.
2020-07-25 07:20:59 +02:00
public final Proxy mProxy;
Misc changes
2018-07-19 21:34:58 +02:00
public boolean canSudo = false;
Keep BungeeCord versioning intact when patched
2018-05-24 20:52:47 +02:00
public final boolean isPatched;
Host & Server objects are now signed (prevents desyncs across apps)
2017-12-10 01:30:06 +01:00
public long resetDate = 0;
Secure the compatibility plugin This commit moves the loadable section of the compatibility plugin to an anonymous class to prevent misuse of that section of code.
2021-02-15 06:28:06 +01:00
private boolean pluginDeployed = false;
Update Javadoc
2017-04-16 19:02:14 +02:00
private boolean running = false;
Fix shutdown detection
2021-04-23 06:36:54 +02:00
private boolean ready = false;
Re-Add local templates to SubServers.Host Local templates are now stored in `/Templates` Template cache files are still stored in `/Cache/Templates` Remote templates are now stored in `/Cache/Remote/Templates`
2020-06-20 03:00:50 +02:00
private boolean reloading = false;
SubServers, Host & Client v2.12.1c/2.12.1b/2.12.1b
2017-08-18 11:58:06 +02:00
private boolean posted = false;
Move autorun queue to a more appropriate location This restores plugins' ability to listen for server start events
2021-02-07 07:19:55 +01:00
private LinkedList<String> autorun = null;
Rewrite Launch & PluginLoader for SubServers.Host This commit changes the way SubServers.Host launches itself and loads it's plugins. Overall loading plugins this way is more efficient, faster, and can cause less problems than before. Plugins will still use the package.xml & @SubPlugin annotation system to be loaded. Also, there are some changes to the logger that better support async logging.
2018-01-21 21:45:27 +01:00
private static BigInteger lastSignature = BigInteger.valueOf(-1);
SubServers.Bungee
2016-12-05 04:21:04 +01:00
Correct config loading issue This solves a 'file in use' error on windows
2017-12-15 01:50:39 +01:00
@SuppressWarnings("unchecked")
#50 #46 Selecting Multiple Servers This commit includes the following major changes and additions: -> New Command & Permission Formatting -> RemotePlayer API -> SubData with Blocks
2020-06-12 07:45:49 +02:00
SubProxy(PrintStream out, boolean isPatched) throws Exception {
BungeeCommon API
2020-11-14 04:41:56 +01:00
super(SubAPI::getInstance);
Keep BungeeCord versioning intact when patched
2018-05-24 20:52:47 +02:00
this.isPatched = isPatched;
Add support for GalaxiBungee
2019-05-17 00:36:41 +02:00
Logger.get("SubServers").info("Loading SubServers.Bungee v" + version.toString() + " Libraries (for Minecraft " + api.getGameVersion()[api.getGameVersion().length - 1] + ")");
Allow targeting multiple RemotePlayers
2021-06-15 06:09:51 +02:00
Util.isException(() -> new RemotePlayer(null)); // runs <clinit>
API Additions & Launch Changes
2017-01-08 03:30:03 +01:00
Start SubServers.Host & SubAPI Null Checks This marks the beginning of SubServers.Host. As of now it is just a simple plugin loading API, but it is planned to become a way to host servers on other machines. Also, SubAPI now checks to make sure variables aren't null in many places.
2017-01-30 21:22:36 +01:00
this.out = out;
SubServers 2 Beta 4
2016-12-24 05:55:17 +01:00
if (!(new UniversalFile(dir, "config.yml").exists())) {
Add a grace period on rogue SubServer detection Async subdata shenanigans made rogue SubServer detection a little inacurrate. Specifically in regards to the last commit. This is the fix to that
2019-08-30 21:44:54 +02:00
Util.copyFromJar(SubProxy.class.getClassLoader(), "net/ME1312/SubServers/Bungee/Library/Files/bungee.yml", new UniversalFile(dir, "config.yml").getPath());
SubServers 2 Beta 4
2016-12-24 05:55:17 +01:00
YAMLConfig tmp = new YAMLConfig(new UniversalFile("config.yml"));
tmp.get().set("stats", UUID.randomUUID().toString());
tmp.save();
Add support for GalaxiBungee
2019-05-17 00:36:41 +02:00
Logger.get("SubServers").info("Created ./config.yml");
SubServers 2 Beta 4
2016-12-24 05:55:17 +01:00
}
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
bungee = new YAMLConfig(new UniversalFile(dir, "config.yml"));
/sub reload can now perform soft reloads /sub reload - can now perform soft reloads /greload - still performs hard resets Soft Reloads mean that SubServers will load new data from the config and attempt to merge it with what is already in memory. This is good if you need to make some quick changes, since it will only stop servers if a major change has been made to them. However, this has the potential to cause issues, which is why the Hard Reset will continue to be tied to bungeecord command.
2017-12-09 09:43:29 +01:00
SubServers.Bungee
2016-12-05 04:21:04 +01:00
UniversalFile dir = new UniversalFile(this.dir, "SubServers");
dir.mkdir();
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
ConfigUpdater.updateConfig(new UniversalFile(dir, "config.yml"));
Update Javadoc
2017-04-16 19:02:14 +02:00
config = new YAMLConfig(new UniversalFile(dir, "config.yml"));
SubServers.Bungee
2016-12-05 04:21:04 +01:00
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
ConfigUpdater.updateServers(new UniversalFile(dir, "servers.yml"));
servers = new YAMLConfig(new UniversalFile(dir, "servers.yml"));
SubServers.Bungee
2016-12-05 04:21:04 +01:00
Implement several new packet types
2019-05-09 22:17:15 +02:00
ConfigUpdater.updateLang(new UniversalFile(dir, "lang.yml"));
lang = new YAMLConfig(new UniversalFile(dir, "lang.yml"));
Don't recreate default templates
2017-07-30 02:41:02 +02:00
if (!(new UniversalFile(dir, "Templates").exists())) {
new UniversalFile(dir, "Templates").mkdirs();
Add a grace period on rogue SubServer detection Async subdata shenanigans made rogue SubServer detection a little inacurrate. Specifically in regards to the last commit. This is the fix to that
2019-08-30 21:44:54 +02:00
Util.unzip(SubProxy.class.getResourceAsStream("/net/ME1312/SubServers/Bungee/Library/Files/Templates/vanilla.zip"), new UniversalFile(dir, "Templates"));
Add support for GalaxiBungee
2019-05-17 00:36:41 +02:00
Logger.get("SubServers").info("Created ./SubServers/Templates/Vanilla");
Don't recreate default templates
2017-07-30 02:41:02 +02:00
Add a grace period on rogue SubServer detection Async subdata shenanigans made rogue SubServer detection a little inacurrate. Specifically in regards to the last commit. This is the fix to that
2019-08-30 21:44:54 +02:00
Util.unzip(SubProxy.class.getResourceAsStream("/net/ME1312/SubServers/Bungee/Library/Files/Templates/spigot.zip"), new UniversalFile(dir, "Templates"));
Add support for GalaxiBungee
2019-05-17 00:36:41 +02:00
Logger.get("SubServers").info("Created ./SubServers/Templates/Spigot");
Don't recreate default templates
2017-07-30 02:41:02 +02:00
Add a default Paper template
2019-12-18 06:08:59 +01:00
Util.unzip(SubProxy.class.getResourceAsStream("/net/ME1312/SubServers/Bungee/Library/Files/Templates/paper.zip"), new UniversalFile(dir, "Templates"));
Logger.get("SubServers").info("Created ./SubServers/Templates/Paper");
Feature creep commit This commit has 3 new features in it: -> Internal Templates -> The new Purpur Template -> Changes to External Logging
2021-06-25 05:06:53 +02:00
Util.unzip(SubProxy.class.getResourceAsStream("/net/ME1312/SubServers/Bungee/Library/Files/Templates/purpur.zip"), new UniversalFile(dir, "Templates"));
Logger.get("SubServers").info("Created ./SubServers/Templates/Purpur");
Add a grace period on rogue SubServer detection Async subdata shenanigans made rogue SubServer detection a little inacurrate. Specifically in regards to the last commit. This is the fix to that
2019-08-30 21:44:54 +02:00
Util.unzip(SubProxy.class.getResourceAsStream("/net/ME1312/SubServers/Bungee/Library/Files/Templates/forge.zip"), new UniversalFile(dir, "Templates"));
Add support for GalaxiBungee
2019-05-17 00:36:41 +02:00
Logger.get("SubServers").info("Created ./SubServers/Templates/Forge");
Seperate Sponge from Forge The sponge template now builds SpongeVanilla, and a new template called `Forge` will continue to build SpongeForge
2018-07-26 19:34:31 +02:00
Add a grace period on rogue SubServer detection Async subdata shenanigans made rogue SubServer detection a little inacurrate. Specifically in regards to the last commit. This is the fix to that
2019-08-30 21:44:54 +02:00
Util.unzip(SubProxy.class.getResourceAsStream("/net/ME1312/SubServers/Bungee/Library/Files/Templates/sponge.zip"), new UniversalFile(dir, "Templates"));
Add support for GalaxiBungee
2019-05-17 00:36:41 +02:00
Logger.get("SubServers").info("Created ./SubServers/Templates/Sponge");
Don't recreate default templates
2017-07-30 02:41:02 +02:00
} else {
SubCreator File Replacements SubCreator has several new build options for updating and making replacements in files
2020-06-13 23:53:18 +02:00
long stamp = Math.round(Math.random() * 100000);
Don't update templates that are lacking a `Version` property
2020-06-21 05:46:16 +02:00
Version version = new Version("2.16a+");
if (new UniversalFile(dir, "Templates:Vanilla:template.yml").exists() && ((new YAMLConfig(new UniversalFile(dir, "Templates:Vanilla:template.yml"))).get().getVersion("Version", version)).compareTo(version) != 0) {
SubCreator File Replacements SubCreator has several new build options for updating and making replacements in files
2020-06-13 23:53:18 +02:00
Files.move(new UniversalFile(dir, "Templates:Vanilla").toPath(), new UniversalFile(dir, "Templates:Vanilla." + stamp + ".x").toPath());
Add a grace period on rogue SubServer detection Async subdata shenanigans made rogue SubServer detection a little inacurrate. Specifically in regards to the last commit. This is the fix to that
2019-08-30 21:44:54 +02:00
Util.unzip(SubProxy.class.getResourceAsStream("/net/ME1312/SubServers/Bungee/Library/Files/Templates/vanilla.zip"), new UniversalFile(dir, "Templates"));
Add support for GalaxiBungee
2019-05-17 00:36:41 +02:00
Logger.get("SubServers").info("Updated ./SubServers/Templates/Vanilla");
Don't recreate default templates
2017-07-30 02:41:02 +02:00
}
Don't update templates that are lacking a `Version` property
2020-06-21 05:46:16 +02:00
if (new UniversalFile(dir, "Templates:Spigot:template.yml").exists() && ((new YAMLConfig(new UniversalFile(dir, "Templates:Spigot:template.yml"))).get().getVersion("Version", version)).compareTo(version) != 0) {
SubCreator File Replacements SubCreator has several new build options for updating and making replacements in files
2020-06-13 23:53:18 +02:00
Files.move(new UniversalFile(dir, "Templates:Spigot").toPath(), new UniversalFile(dir, "Templates:Spigot." + stamp + ".x").toPath());
Add a grace period on rogue SubServer detection Async subdata shenanigans made rogue SubServer detection a little inacurrate. Specifically in regards to the last commit. This is the fix to that
2019-08-30 21:44:54 +02:00
Util.unzip(SubProxy.class.getResourceAsStream("/net/ME1312/SubServers/Bungee/Library/Files/Templates/spigot.zip"), new UniversalFile(dir, "Templates"));
Add support for GalaxiBungee
2019-05-17 00:36:41 +02:00
Logger.get("SubServers").info("Updated ./SubServers/Templates/Spigot");
Don't recreate default templates
2017-07-30 02:41:02 +02:00
}
Don't update templates that are lacking a `Version` property
2020-06-21 05:46:16 +02:00
if (new UniversalFile(dir, "Templates:Paper:template.yml").exists() && ((new YAMLConfig(new UniversalFile(dir, "Templates:Paper:template.yml"))).get().getVersion("Version", version)).compareTo(version) != 0) {
SubCreator File Replacements SubCreator has several new build options for updating and making replacements in files
2020-06-13 23:53:18 +02:00
Files.move(new UniversalFile(dir, "Templates:Paper").toPath(), new UniversalFile(dir, "Templates:Paper." + stamp + ".x").toPath());
Util.unzip(SubProxy.class.getResourceAsStream("/net/ME1312/SubServers/Bungee/Library/Files/Templates/paper.zip"), new UniversalFile(dir, "Templates"));
Add a default Paper template
2019-12-18 06:08:59 +01:00
Logger.get("SubServers").info("Updated ./SubServers/Templates/Paper");
}
Feature creep commit This commit has 3 new features in it: -> Internal Templates -> The new Purpur Template -> Changes to External Logging
2021-06-25 05:06:53 +02:00
if (new UniversalFile(dir, "Templates:Purpur:template.yml").exists() && ((new YAMLConfig(new UniversalFile(dir, "Templates:Purpur:template.yml"))).get().getVersion("Version", version)).compareTo(version) != 0) {
Files.move(new UniversalFile(dir, "Templates:Purpur").toPath(), new UniversalFile(dir, "Templates:Purpur." + stamp + ".x").toPath());
Util.unzip(SubProxy.class.getResourceAsStream("/net/ME1312/SubServers/Bungee/Library/Files/Templates/purpur.zip"), new UniversalFile(dir, "Templates"));
Logger.get("SubServers").info("Updated ./SubServers/Templates/Purpur");
}
Don't update templates that are lacking a `Version` property
2020-06-21 05:46:16 +02:00
if (new UniversalFile(dir, "Templates:Forge:template.yml").exists() && ((new YAMLConfig(new UniversalFile(dir, "Templates:Forge:template.yml"))).get().getVersion("Version", version)).compareTo(version) != 0) {
SubCreator File Replacements SubCreator has several new build options for updating and making replacements in files
2020-06-13 23:53:18 +02:00
Files.move(new UniversalFile(dir, "Templates:Forge").toPath(), new UniversalFile(dir, "Templates:Forge." + stamp + ".x").toPath());
Add a grace period on rogue SubServer detection Async subdata shenanigans made rogue SubServer detection a little inacurrate. Specifically in regards to the last commit. This is the fix to that
2019-08-30 21:44:54 +02:00
Util.unzip(SubProxy.class.getResourceAsStream("/net/ME1312/SubServers/Bungee/Library/Files/Templates/forge.zip"), new UniversalFile(dir, "Templates"));
Add support for GalaxiBungee
2019-05-17 00:36:41 +02:00
Logger.get("SubServers").info("Updated ./SubServers/Templates/Forge");
Seperate Sponge from Forge The sponge template now builds SpongeVanilla, and a new template called `Forge` will continue to build SpongeForge
2018-07-26 19:34:31 +02:00
}
Don't update templates that are lacking a `Version` property
2020-06-21 05:46:16 +02:00
if (new UniversalFile(dir, "Templates:Sponge:template.yml").exists() && ((new YAMLConfig(new UniversalFile(dir, "Templates:Sponge:template.yml"))).get().getVersion("Version", version)).compareTo(version) != 0) {
SubCreator File Replacements SubCreator has several new build options for updating and making replacements in files
2020-06-13 23:53:18 +02:00
Files.move(new UniversalFile(dir, "Templates:Sponge").toPath(), new UniversalFile(dir, "Templates:Sponge." + stamp + ".x").toPath());
Add a grace period on rogue SubServer detection Async subdata shenanigans made rogue SubServer detection a little inacurrate. Specifically in regards to the last commit. This is the fix to that
2019-08-30 21:44:54 +02:00
Util.unzip(SubProxy.class.getResourceAsStream("/net/ME1312/SubServers/Bungee/Library/Files/Templates/sponge.zip"), new UniversalFile(dir, "Templates"));
Add support for GalaxiBungee
2019-05-17 00:36:41 +02:00
Logger.get("SubServers").info("Updated ./SubServers/Templates/Sponge");
Don't recreate default templates
2017-07-30 02:41:02 +02:00
}
SubServers Release v2.11.2c
2017-01-01 20:34:46 +01:00
}
Clean the Recently Deleted directory periodically
2019-04-26 05:24:10 +02:00
Runnable clean = () -> {
try {
if (new UniversalFile(dir, "Recently Deleted").exists()) {
int f = new UniversalFile(dir, "Recently Deleted").listFiles().length;
for (File file : new UniversalFile(dir, "Recently Deleted").listFiles()) {
try {
if (file.isDirectory()) {
if (new UniversalFile(dir, "Recently Deleted:" + file.getName() + ":info.json").exists()) {
FileReader reader = new FileReader(new UniversalFile(dir, "Recently Deleted:" + file.getName() + ":info.json"));
YAMLSection info = new YAMLSection(new Gson().fromJson(Util.readAll(reader), Map.class));
reader.close();
if (info.contains("Timestamp")) {
if (TimeUnit.MILLISECONDS.toDays(Calendar.getInstance().getTime().getTime() - info.getLong("Timestamp")) >= 7) {
Util.deleteDirectory(file);
f--;
Add support for GalaxiBungee
2019-05-17 00:36:41 +02:00
Logger.get("SubServers").info("Removed ./SubServers/Recently Deleted/" + file.getName());
Clean the Recently Deleted directory periodically
2019-04-26 05:24:10 +02:00
}
} else {
Util.deleteDirectory(file);
f--;
Add support for GalaxiBungee
2019-05-17 00:36:41 +02:00
Logger.get("SubServers").info("Removed ./SubServers/Recently Deleted/" + file.getName());
Clean the Recently Deleted directory periodically
2019-04-26 05:24:10 +02:00
}
} else {
SubServers Release v2.11.2c
2017-01-01 20:34:46 +01:00
Util.deleteDirectory(file);
f--;
Add support for GalaxiBungee
2019-05-17 00:36:41 +02:00
Logger.get("SubServers").info("Removed ./SubServers/Recently Deleted/" + file.getName());
SubServers Release v2.11.2c
2017-01-01 20:34:46 +01:00
}
} else {
Clean the Recently Deleted directory periodically
2019-04-26 05:24:10 +02:00
Files.delete(file.toPath());
SubServers Release v2.11.2c
2017-01-01 20:34:46 +01:00
f--;
Add support for GalaxiBungee
2019-05-17 00:36:41 +02:00
Logger.get("SubServers").info("Removed ./SubServers/Recently Deleted/" + file.getName());
SubServers Release v2.11.2c
2017-01-01 20:34:46 +01:00
}
Clean the Recently Deleted directory periodically
2019-04-26 05:24:10 +02:00
} catch (Exception e) {
Update SubData
2020-11-07 17:35:25 +01:00
Logger.get("SubServers").info("Problem scanning ./SubServers/Recently Deleted/" + file.getName());
Clean the Recently Deleted directory periodically
2019-04-26 05:24:10 +02:00
e.printStackTrace();
Files.delete(file.toPath());
SubServers Release v2.11.2c
2017-01-01 20:34:46 +01:00
}
}
Clean the Recently Deleted directory periodically
2019-04-26 05:24:10 +02:00
if (f <= 0) {
Files.delete(new UniversalFile(dir, "Recently Deleted").toPath());
}
SubServers Release v2.11.2c
2017-01-01 20:34:46 +01:00
}
Clean the Recently Deleted directory periodically
2019-04-26 05:24:10 +02:00
} catch (Exception e) {
e.printStackTrace();
SubServers Release v2.11.2c
2017-01-01 20:34:46 +01:00
}
Clean the Recently Deleted directory periodically
2019-04-26 05:24:10 +02:00
};
clean.run();
new Timer("SubServers.Bungee::Recycle_Cleaner").scheduleAtFixedRate(new TimerTask() {
@Override
public void run() {
clean.run();
SubServers Release v2.11.2c
2017-01-01 20:34:46 +01:00
}
Clean the Recently Deleted directory periodically
2019-04-26 05:24:10 +02:00
}, TimeUnit.DAYS.toMillis(7), TimeUnit.DAYS.toMillis(7));
SubServers Release v2.11.2c
2017-01-01 20:34:46 +01:00
Ditch RedisBungee. Long live the RemotePlayer API RedisBungee has been abandoned by it's developers. So we're abanding it too. SubServers.Sync will now finally pick up the slack and sync basic player information between proxies over their SubData connection.
2020-07-25 07:20:59 +02:00
mProxy = new Proxy("(master)");
#50 #46 Selecting Multiple Servers This commit includes the following major changes and additions: -> New Command & Permission Formatting -> RemotePlayer API -> SubData with Blocks
2020-06-12 07:45:49 +02:00
api.addHostDriver(net.ME1312.SubServers.Bungee.Host.Internal.InternalHost.class, "virtual");
SubServers, Host, Sync & Client v2.12.1d/2.12.1c/2.12.1a/2.12.1c
2017-08-22 15:02:23 +02:00
api.addHostDriver(net.ME1312.SubServers.Bungee.Host.External.ExternalHost.class, "network");
SubServers.Bungee
2016-12-05 04:21:04 +01:00
Secure the compatibility plugin This commit moves the loadable section of the compatibility plugin to an anonymous class to prevent misuse of that section of code.
2021-02-15 06:28:06 +01:00
{
PluginDescription description = new PluginDescription();
description.setName("SubServers-Bungee");
description.setMain(net.ME1312.SubServers.Bungee.Library.Compatibility.Plugin.class.getCanonicalName());
description.setFile(Util.getDespiteException(() -> new File(SubProxy.class.getProtectionDomain().getCodeSource().getLocation().toURI()), null));
description.setVersion(version.toString());
description.setAuthor("ME1312");
Plugin plugin = null;
String stage = "access";
try {
plugin = new Plugin(this, description) {
@Override
public void onEnable() {
try {
pluginDeployed = true;
reload();
} catch (Throwable e) {
e.printStackTrace();
}
}
@Override
public void onDisable() {
try {
shutdown();
} catch (Throwable e) {
e.printStackTrace();
}
}
};
Make the compatibility plugin loadable Some BungeeCord API calls require an actual plugin object. This is a problem. Fortunately, the 2020 builds of BungeeCord provide a protected constructor that is actually usable by SubServers, so we implemented it.
2020-11-11 08:35:02 +01:00
Secure the compatibility plugin This commit moves the loadable section of the compatibility plugin to an anonymous class to prevent misuse of that section of code.
2021-02-15 06:28:06 +01:00
if (plugin.getDescription() == null) {
stage = "initialize";
Util.reflect(Plugin.class.getDeclaredMethod("init", ProxyServer.class, PluginDescription.class), plugin, this, description);
}
stage = "deploy";
Util.<Map<String, Plugin>>reflect(PluginManager.class.getDeclaredField("plugins"), getPluginManager()).put(null, plugin);
} catch (Throwable e) {
Logger.get("SubServers").warning("Could not " + stage + " plugin emulation");
} finally {
this.plugin = plugin;
}
}
Make the compatibility plugin loadable Some BungeeCord API calls require an actual plugin object. This is a problem. Fortunately, the 2020 builds of BungeeCord provide a protected constructor that is actually usable by SubServers, so we implemented it.
2020-11-11 08:35:02 +01:00
getPluginManager().registerListener(plugin, this);
API Additions & Launch Changes
2017-01-08 03:30:03 +01:00
Add support for GalaxiBungee
2019-05-17 00:36:41 +02:00
Logger.get("SubServers").info("Pre-Parsing Config...");
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
for (String name : servers.get().getMap("Servers").getKeys()) {
SubServers, Host & Client v2.12.1c/2.12.1b/2.12.1b
2017-08-18 11:58:06 +02:00
try {
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
if (Util.getCaseInsensitively(config.get().getMap("Hosts").get(), servers.get().getMap("Servers").getMap(name).getString("Host")) == null) throw new InvalidServerException("There is no host with this name: " + servers.get().getMap("Servers").getMap(name).getString("Host"));
#50 #46 Selecting Multiple Servers This commit includes the following major changes and additions: -> New Command & Permission Formatting -> RemotePlayer API -> SubData with Blocks
2020-06-12 07:45:49 +02:00
legServers.put(name, constructServerInfo(name, new InetSocketAddress(InetAddress.getByName((String) ((Map<String, ?>) Util.getCaseInsensitively(config.get().getMap("Hosts").get(), servers.get().getMap("Servers").getMap(name).getString("Host"))).get("Address")), servers.get().getMap("Servers").getMap(name).getInt("Port")),
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
ChatColor.translateAlternateColorCodes('&', servers.get().getMap("Servers").getMap(name).getString("Motd")), servers.get().getMap("Servers").getMap(name).getBoolean("Restricted")));
SubServers, Host & Client v2.12.1c/2.12.1b/2.12.1b
2017-08-18 11:58:06 +02:00
} catch (Exception e) {
e.printStackTrace();
}
Update Javadoc
2017-04-16 19:02:14 +02:00
}
SubServers v2.12.1b
2017-08-17 01:29:02 +02:00
BungeeCommon API
2020-11-14 04:41:56 +01:00
SmartFallback.addInspector((player, server) -> {
double confidence = 0;
if (server instanceof Server) {
if (!((Server) server).isHidden()) confidence++;
if (!((Server) server).isRestricted()) confidence++;
if (((Server) server).getSubData()[0] != null) confidence++;
if (player != null) {
if (((Server) server).canAccess(player)) confidence++;
}
} if (server instanceof SubServer) {
if (!((SubServer) server).isRunning()) return null;
}
return confidence;
});
Add more features to Smart Fallback
2020-07-03 23:14:59 +02:00
if (config.get().getMap("Settings").getMap("Smart-Fallback", new ObjectMap<>()).getBoolean("Enabled", true))
BungeeCommon API
2020-11-14 04:41:56 +01:00
setReconnectHandler(new SmartFallback(config.get().getMap("Settings").getMap("Smart-Fallback", new ObjectMap<>())));
Some more compatibility changes
2020-06-26 01:47:30 +02:00
Begin rewrite for SubData 2
2019-04-18 16:02:09 +02:00
subprotocol = SubProtocol.get();
#50 #46 Selecting Multiple Servers This commit includes the following major changes and additions: -> New Command & Permission Formatting -> RemotePlayer API -> SubData with Blocks
2020-06-12 07:45:49 +02:00
subprotocol.registerCipher("DHE", DHE.get(128));
subprotocol.registerCipher("DHE-128", DHE.get(128));
subprotocol.registerCipher("DHE-192", DHE.get(192));
subprotocol.registerCipher("DHE-256", DHE.get(256));
Add support for GalaxiBungee
2019-05-17 00:36:41 +02:00
Logger.get("SubServers").info("Loading BungeeCord Libraries...");
SubServers.Bungee
2016-12-05 04:21:04 +01:00
}
/sub reload can now perform soft reloads /sub reload - can now perform soft reloads /greload - still performs hard resets Soft Reloads mean that SubServers will load new data from the config and attempt to merge it with what is already in memory. This is good if you need to make some quick changes, since it will only stop servers if a major change has been made to them. However, this has the potential to cause issues, which is why the Hard Reset will continue to be tied to bungeecord command.
2017-12-09 09:43:29 +01:00
/**
* Load data from the config (will attempt to merge with current configuration)
*
* @throws IOException
*/
public void reload() throws IOException {
List<String> ukeys = new ArrayList<String>();
long begin = Calendar.getInstance().getTime().getTime();
Optimizations for developers
2021-06-06 04:44:33 +02:00
boolean status = ready;
if (!status) resetDate = begin;
Re-Add local templates to SubServers.Host Local templates are now stored in `/Templates` Template cache files are still stored in `/Cache/Templates` Remote templates are now stored in `/Cache/Remote/Templates`
2020-06-20 03:00:50 +02:00
reloading = true;
/sub reload can now perform soft reloads /sub reload - can now perform soft reloads /greload - still performs hard resets Soft Reloads mean that SubServers will load new data from the config and attempt to merge it with what is already in memory. This is good if you need to make some quick changes, since it will only stop servers if a major change has been made to them. However, this has the potential to cause issues, which is why the Hard Reset will continue to be tied to bungeecord command.
2017-12-09 09:43:29 +01:00
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
ConfigUpdater.updateConfig(new UniversalFile(dir, "SubServers:config.yml"));
ConfigUpdater.updateServers(new UniversalFile(dir, "SubServers:servers.yml"));
ConfigUpdater.updateLang(new UniversalFile(dir, "SubServers:lang.yml"));
/sub reload can now perform soft reloads /sub reload - can now perform soft reloads /greload - still performs hard resets Soft Reloads mean that SubServers will load new data from the config and attempt to merge it with what is already in memory. This is good if you need to make some quick changes, since it will only stop servers if a major change has been made to them. However, this has the potential to cause issues, which is why the Hard Reset will continue to be tied to bungeecord command.
2017-12-09 09:43:29 +01:00
YAMLSection prevconfig = config.get();
config.reload();
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
servers.reload();
lang.reload();
for (String key : lang.get().getMap("Lang").getKeys())
api.setLang("SubServers", key, ChatColor.translateAlternateColorCodes('&', lang.get().getMap("Lang").getString(key)));
/sub reload can now perform soft reloads /sub reload - can now perform soft reloads /greload - still performs hard resets Soft Reloads mean that SubServers will load new data from the config and attempt to merge it with what is already in memory. This is good if you need to make some quick changes, since it will only stop servers if a major change has been made to them. However, this has the potential to cause issues, which is why the Hard Reset will continue to be tied to bungeecord command.
2017-12-09 09:43:29 +01:00
Add a grace period on rogue SubServer detection Async subdata shenanigans made rogue SubServer detection a little inacurrate. Specifically in regards to the last commit. This is the fix to that
2019-08-30 21:44:54 +02:00
if (subdata != null && ( // SubData Server must be reset
Begin rewrite for SubData 2
2019-04-18 16:02:09 +02:00
!config.get().getMap("Settings").getMap("SubData").getRawString("Address", "127.0.0.1:4391").equals(prevconfig.getMap("Settings").getMap("SubData").getRawString("Address", "127.0.0.1:4391")) ||
!config.get().getMap("Settings").getMap("SubData").getRawString("Encryption", "NONE").equals(prevconfig.getMap("Settings").getMap("SubData").getRawString("Encryption", "NONE"))
Add a grace period on rogue SubServer detection Async subdata shenanigans made rogue SubServer detection a little inacurrate. Specifically in regards to the last commit. This is the fix to that
2019-08-30 21:44:54 +02:00
)) {
Optimizations for developers
2021-06-06 04:44:33 +02:00
SubDataServer subdata = this.subdata;
Add a grace period on rogue SubServer detection Async subdata shenanigans made rogue SubServer detection a little inacurrate. Specifically in regards to the last commit. This is the fix to that
2019-08-30 21:44:54 +02:00
subdata.close();
Util.isException(subdata::waitFor);
/sub reload can now perform soft reloads /sub reload - can now perform soft reloads /greload - still performs hard resets Soft Reloads mean that SubServers will load new data from the config and attempt to merge it with what is already in memory. This is good if you need to make some quick changes, since it will only stop servers if a major change has been made to them. However, this has the potential to cause issues, which is why the Hard Reset will continue to be tied to bungeecord command.
2017-12-09 09:43:29 +01:00
}
SubServers.Bungee
2016-12-05 04:21:04 +01:00
SubServers.Sync.Velocity #64 (Preview) And automatic external server definitions
2021-07-09 07:46:10 +02:00
PacketLinkServer.strict = config.get().getMap("Settings").getBoolean("Strict-Server-Linking", true);
BungeeCommon API
2020-11-14 04:41:56 +01:00
SmartFallback.dns_forward = config.get().getMap("Settings").getMap("Smart-Fallback", new ObjectMap<>()).getBoolean("DNS-Forward", false);
/sub reload can now perform soft reloads /sub reload - can now perform soft reloads /greload - still performs hard resets Soft Reloads mean that SubServers will load new data from the config and attempt to merge it with what is already in memory. This is good if you need to make some quick changes, since it will only stop servers if a major change has been made to them. However, this has the potential to cause issues, which is why the Hard Reset will continue to be tied to bungeecord command.
2017-12-09 09:43:29 +01:00
int hosts = 0;
Add support for GalaxiBungee
2019-05-17 00:36:41 +02:00
Logger.get("SubServers").info(((status)?"Rel":"L")+"oading Hosts...");
Begin rewrite for SubData 2
2019-04-18 16:02:09 +02:00
for (String name : config.get().getMap("Hosts").getKeys()) {
/sub reload can now perform soft reloads /sub reload - can now perform soft reloads /greload - still performs hard resets Soft Reloads mean that SubServers will load new data from the config and attempt to merge it with what is already in memory. This is good if you need to make some quick changes, since it will only stop servers if a major change has been made to them. However, this has the potential to cause issues, which is why the Hard Reset will continue to be tied to bungeecord command.
2017-12-09 09:43:29 +01:00
if (!ukeys.contains(name.toLowerCase())) try {
Don't fire edit events for temporary modifications
2021-06-06 07:28:22 +02:00
boolean add = false;
/sub reload can now perform soft reloads /sub reload - can now perform soft reloads /greload - still performs hard resets Soft Reloads mean that SubServers will load new data from the config and attempt to merge it with what is already in memory. This is good if you need to make some quick changes, since it will only stop servers if a major change has been made to them. However, this has the potential to cause issues, which is why the Hard Reset will continue to be tied to bungeecord command.
2017-12-09 09:43:29 +01:00
Host host = this.hosts.get(name.toLowerCase());
Don't fire edit events for temporary modifications
2021-06-06 07:28:22 +02:00
Class<? extends Host> driver = hostDrivers.get(config.get().getMap("Hosts").getMap(name).getRawString("Driver").toUpperCase().replace('-', '_').replace(' ', '_'));
if (driver == null) throw new InvalidHostException("Invalid Driver for host: " + name);
Host & Server objects are now signed (prevents desyncs across apps)
2017-12-10 01:30:06 +01:00
if (host == null || // Host must be reset
Begin rewrite for SubData 2
2019-04-18 16:02:09 +02:00
!hostDrivers.get(config.get().getMap("Hosts").getMap(name).getRawString("Driver").toUpperCase().replace('-', '_').replace(' ', '_')).equals(host.getClass()) ||
!config.get().getMap("Hosts").getMap(name).getRawString("Address").equals(host.getAddress().getHostAddress()) ||
!config.get().getMap("Hosts").getMap(name).getRawString("Directory").equals(host.getPath()) ||
!config.get().getMap("Hosts").getMap(name).getRawString("Git-Bash").equals(host.getCreator().getBashDirectory())
/sub reload can now perform soft reloads /sub reload - can now perform soft reloads /greload - still performs hard resets Soft Reloads mean that SubServers will load new data from the config and attempt to merge it with what is already in memory. This is good if you need to make some quick changes, since it will only stop servers if a major change has been made to them. However, this has the potential to cause issues, which is why the Hard Reset will continue to be tied to bungeecord command.
2017-12-09 09:43:29 +01:00
) {
if (host != null) api.forceRemoveHost(name);
Don't fire edit events for temporary modifications
2021-06-06 07:28:22 +02:00
add = true;
host = constructHost(driver, name, config.get().getMap("Hosts").getMap(name).getBoolean("Enabled"),
Begin rewrite for SubData 2
2019-04-18 16:02:09 +02:00
Range.closed(Integer.parseInt(config.get().getMap("Hosts").getMap(name).getRawString("Port-Range", "25500-25559").split("-")[0]), Integer.parseInt(config.get().getMap("Hosts").getMap(name).getRawString("Port-Range", "25500-25559").split("-")[1])),
config.get().getMap("Hosts").getMap(name).getBoolean("Log-Creator", true), InetAddress.getByName(config.get().getMap("Hosts").getMap(name).getRawString("Address")),
config.get().getMap("Hosts").getMap(name).getRawString("Directory"), config.get().getMap("Hosts").getMap(name).getRawString("Git-Bash"));
Host & Server objects are now signed (prevents desyncs across apps)
2017-12-10 01:30:06 +01:00
} else { // Host wasn't reset, so check for these changes
Begin rewrite for SubData 2
2019-04-18 16:02:09 +02:00
if (config.get().getMap("Hosts").getMap(name).getBoolean("Enabled") != host.isEnabled())
host.setEnabled(config.get().getMap("Hosts").getMap(name).getBoolean("Enabled"));
if (!config.get().getMap("Hosts").getMap(name).getRawString("Port-Range", "25500-25559").equals(prevconfig.getMap("Hosts", new ObjectMap<String>()).getMap(name, new ObjectMap<String>()).getRawString("Port-Range", "25500-25559")))
host.getCreator().setPortRange(Range.closed(Integer.parseInt(config.get().getMap("Hosts").getMap(name).getRawString("Port-Range", "25500-25559").split("-")[0]), Integer.parseInt(config.get().getMap("Hosts").getMap(name).getRawString("Port-Range", "25500-25559").split("-")[1])));
if (config.get().getMap("Hosts").getMap(name).getBoolean("Log-Creator", true) != host.getCreator().isLogging())
host.getCreator().setLogging(config.get().getMap("Hosts").getMap(name).getBoolean("Log-Creator", true));
#50 #46 Selecting Multiple Servers This commit includes the following major changes and additions: -> New Command & Permission Formatting -> RemotePlayer API -> SubData with Blocks
2020-06-12 07:45:49 +02:00
host.getCreator().reload();
Host & Server objects are now signed (prevents desyncs across apps)
2017-12-10 01:30:06 +01:00
} // Check for other changes
Fix unnecessary .edit() of display names during reload
2019-06-18 01:30:30 +02:00
if (config.get().getMap("Hosts").getMap(name).getKeys().contains("Display") && ((config.get().getMap("Hosts").getMap(name).getString("Display").length() == 0 && !host.getName().equals(host.getDisplayName())) || (config.get().getMap("Hosts").getMap(name).getString("Display").length() > 0 && !config.get().getMap("Hosts").getMap(name).getString("Display").equals(host.getDisplayName()))))
Begin rewrite for SubData 2
2019-04-18 16:02:09 +02:00
host.setDisplayName(config.get().getMap("Hosts").getMap(name).getString("Display"));
if (config.get().getMap("Hosts").getMap(name).getKeys().contains("Extra"))
for (String extra : config.get().getMap("Hosts").getMap(name).getMap("Extra").getKeys()) host.addExtra(extra, config.get().getMap("Hosts").getMap(name).getMap("Extra").getObject(extra));
Don't fire edit events for temporary modifications
2021-06-06 07:28:22 +02:00
if (add)
api.addHost(host);
/sub reload can now perform soft reloads /sub reload - can now perform soft reloads /greload - still performs hard resets Soft Reloads mean that SubServers will load new data from the config and attempt to merge it with what is already in memory. This is good if you need to make some quick changes, since it will only stop servers if a major change has been made to them. However, this has the potential to cause issues, which is why the Hard Reset will continue to be tied to bungeecord command.
2017-12-09 09:43:29 +01:00
ukeys.add(name.toLowerCase());
hosts++;
} catch (Exception e) {
e.printStackTrace();
SubServers.Bungee
2016-12-05 04:21:04 +01:00
}
/sub reload can now perform soft reloads /sub reload - can now perform soft reloads /greload - still performs hard resets Soft Reloads mean that SubServers will load new data from the config and attempt to merge it with what is already in memory. This is good if you need to make some quick changes, since it will only stop servers if a major change has been made to them. However, this has the potential to cause issues, which is why the Hard Reset will continue to be tied to bungeecord command.
2017-12-09 09:43:29 +01:00
}
ukeys.clear();
int servers = 0;
Add support for GalaxiBungee
2019-05-17 00:36:41 +02:00
Logger.get("SubServers").info(((status)?"Rel":"L")+"oading Servers...");
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
bungee.reload();
for (String name : bungee.get().getMap("servers").getKeys()) {
/sub reload can now perform soft reloads /sub reload - can now perform soft reloads /greload - still performs hard resets Soft Reloads mean that SubServers will load new data from the config and attempt to merge it with what is already in memory. This is good if you need to make some quick changes, since it will only stop servers if a major change has been made to them. However, this has the potential to cause issues, which is why the Hard Reset will continue to be tied to bungeecord command.
2017-12-09 09:43:29 +01:00
if (!ukeys.contains(name.toLowerCase())) try {
Don't fire edit events for temporary modifications
2021-06-06 07:28:22 +02:00
boolean add = false;
/sub reload can now perform soft reloads /sub reload - can now perform soft reloads /greload - still performs hard resets Soft Reloads mean that SubServers will load new data from the config and attempt to merge it with what is already in memory. This is good if you need to make some quick changes, since it will only stop servers if a major change has been made to them. However, this has the potential to cause issues, which is why the Hard Reset will continue to be tied to bungeecord command.
2017-12-09 09:43:29 +01:00
Server server = api.getServer(name);
if (server == null || !(server instanceof SubServer)) {
Host & Server objects are now signed (prevents desyncs across apps)
2017-12-10 01:30:06 +01:00
if (server == null || // Server must be reset
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
bungee.get().getMap("servers").getMap(name).getRawString("address").equals(server.getAddress().getAddress().getHostAddress() + ':' + server.getAddress().getPort())
/sub reload can now perform soft reloads /sub reload - can now perform soft reloads /greload - still performs hard resets Soft Reloads mean that SubServers will load new data from the config and attempt to merge it with what is already in memory. This is good if you need to make some quick changes, since it will only stop servers if a major change has been made to them. However, this has the potential to cause issues, which is why the Hard Reset will continue to be tied to bungeecord command.
2017-12-09 09:43:29 +01:00
) {
if (server != null) api.forceRemoveServer(name);
Don't fire edit events for temporary modifications
2021-06-06 07:28:22 +02:00
add = true;
server = ServerImpl.construct(name, new InetSocketAddress(InetAddress.getByName(bungee.get().getMap("servers").getMap(name).getRawString("address").split(":")[0]),
Integer.parseInt(bungee.get().getMap("servers").getMap(name).getRawString("address").split(":")[1])), ChatColor.translateAlternateColorCodes('&', bungee.get().getMap("servers").getMap(name).getString("motd")),
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
bungee.get().getMap("servers").getMap(name).getBoolean("hidden", false), bungee.get().getMap("servers").getMap(name).getBoolean("restricted"));
Host & Server objects are now signed (prevents desyncs across apps)
2017-12-10 01:30:06 +01:00
} else { // Server wasn't reset, so check for these changes
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
if (!ChatColor.translateAlternateColorCodes('&', bungee.get().getMap("servers").getMap(name).getString("motd")).equals(server.getMotd()))
server.setMotd(ChatColor.translateAlternateColorCodes('&', bungee.get().getMap("servers").getMap(name).getString("motd")));
if (bungee.get().getMap("servers").getMap(name).getBoolean("hidden", false) != server.isHidden())
server.setHidden(bungee.get().getMap("servers").getMap(name).getBoolean("hidden", false));
if (bungee.get().getMap("servers").getMap(name).getBoolean("restricted") != server.isRestricted())
server.setRestricted(bungee.get().getMap("servers").getMap(name).getBoolean("restricted"));
Host & Server objects are now signed (prevents desyncs across apps)
2017-12-10 01:30:06 +01:00
} // Check for other changes
Fix unnecessary .edit() of display names during reload
2019-06-18 01:30:30 +02:00
if (bungee.get().getMap("servers").getMap(name).getKeys().contains("display") && ((bungee.get().getMap("servers").getMap(name).getRawString("display").length() == 0 && !server.getName().equals(server.getDisplayName())) || (bungee.get().getMap("servers").getMap(name).getRawString("display").length() > 0 && !bungee.get().getMap("servers").getMap(name).getRawString("display").equals(server.getDisplayName()))))
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
server.setDisplayName(bungee.get().getMap("servers").getMap(name).getString("display"));
if (bungee.get().getMap("servers").getMap(name).getKeys().contains("group")) {
/sub reload can now perform soft reloads /sub reload - can now perform soft reloads /greload - still performs hard resets Soft Reloads mean that SubServers will load new data from the config and attempt to merge it with what is already in memory. This is good if you need to make some quick changes, since it will only stop servers if a major change has been made to them. However, this has the potential to cause issues, which is why the Hard Reset will continue to be tied to bungeecord command.
2017-12-09 09:43:29 +01:00
for (String group : server.getGroups()) server.removeGroup(group);
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
for (String group : bungee.get().getMap("servers").getMap(name).getStringList("group")) server.addGroup(group);
/sub reload can now perform soft reloads /sub reload - can now perform soft reloads /greload - still performs hard resets Soft Reloads mean that SubServers will load new data from the config and attempt to merge it with what is already in memory. This is good if you need to make some quick changes, since it will only stop servers if a major change has been made to them. However, this has the potential to cause issues, which is why the Hard Reset will continue to be tied to bungeecord command.
2017-12-09 09:43:29 +01:00
}
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
if (bungee.get().getMap("servers").getMap(name).getKeys().contains("extra"))
Begin rewrite for SubData 2
2019-04-18 16:02:09 +02:00
for (String extra : config.get().getMap("servers").getMap(name).getMap("extra").getKeys()) server.addExtra(extra, config.get().getMap("servers").getMap(name).getMap("extra").getObject(extra));
Implement Multi-Channel SubData
2019-05-10 04:43:34 +02:00
if (server.getSubData()[0] != null)
((SubDataClient) server.getSubData()[0]).sendPacket(new PacketOutExReload(null));
Don't fire edit events for temporary modifications
2021-06-06 07:28:22 +02:00
if (add)
api.addServer(server);
/sub reload can now perform soft reloads /sub reload - can now perform soft reloads /greload - still performs hard resets Soft Reloads mean that SubServers will load new data from the config and attempt to merge it with what is already in memory. This is good if you need to make some quick changes, since it will only stop servers if a major change has been made to them. However, this has the potential to cause issues, which is why the Hard Reset will continue to be tied to bungeecord command.
2017-12-09 09:43:29 +01:00
ukeys.add(name.toLowerCase());
SubServers.Bungee
2016-12-05 04:21:04 +01:00
servers++;
}
/sub reload can now perform soft reloads /sub reload - can now perform soft reloads /greload - still performs hard resets Soft Reloads mean that SubServers will load new data from the config and attempt to merge it with what is already in memory. This is good if you need to make some quick changes, since it will only stop servers if a major change has been made to them. However, this has the potential to cause issues, which is why the Hard Reset will continue to be tied to bungeecord command.
2017-12-09 09:43:29 +01:00
} catch (Exception e) {
e.printStackTrace();
SubServers.Bungee
2016-12-05 04:21:04 +01:00
}
/sub reload can now perform soft reloads /sub reload - can now perform soft reloads /greload - still performs hard resets Soft Reloads mean that SubServers will load new data from the config and attempt to merge it with what is already in memory. This is good if you need to make some quick changes, since it will only stop servers if a major change has been made to them. However, this has the potential to cause issues, which is why the Hard Reset will continue to be tied to bungeecord command.
2017-12-09 09:43:29 +01:00
}
ukeys.clear();
SubServers.Bungee
2016-12-05 04:21:04 +01:00
/sub reload can now perform soft reloads /sub reload - can now perform soft reloads /greload - still performs hard resets Soft Reloads mean that SubServers will load new data from the config and attempt to merge it with what is already in memory. This is good if you need to make some quick changes, since it will only stop servers if a major change has been made to them. However, this has the potential to cause issues, which is why the Hard Reset will continue to be tied to bungeecord command.
2017-12-09 09:43:29 +01:00
int subservers = 0;
Add support for GalaxiBungee
2019-05-17 00:36:41 +02:00
Logger.get("SubServers").info(((status)?"Rel":"L")+"oading SubServers...");
Move autorun queue to a more appropriate location This restores plugins' ability to listen for server start events
2021-02-07 07:19:55 +01:00
autorun = new LinkedList<String>();
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
for (String name : this.servers.get().getMap("Servers").getKeys()) {
/sub reload can now perform soft reloads /sub reload - can now perform soft reloads /greload - still performs hard resets Soft Reloads mean that SubServers will load new data from the config and attempt to merge it with what is already in memory. This is good if you need to make some quick changes, since it will only stop servers if a major change has been made to them. However, this has the potential to cause issues, which is why the Hard Reset will continue to be tied to bungeecord command.
2017-12-09 09:43:29 +01:00
if (!ukeys.contains(name.toLowerCase())) try {
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
if (!this.hosts.keySet().contains(this.servers.get().getMap("Servers").getMap(name).getString("Host").toLowerCase())) throw new InvalidServerException("There is no host with this name: " + this.servers.get().getMap("Servers").getMap(name).getString("Host"));
/sub reload can now perform soft reloads /sub reload - can now perform soft reloads /greload - still performs hard resets Soft Reloads mean that SubServers will load new data from the config and attempt to merge it with what is already in memory. This is good if you need to make some quick changes, since it will only stop servers if a major change has been made to them. However, this has the potential to cause issues, which is why the Hard Reset will continue to be tied to bungeecord command.
2017-12-09 09:43:29 +01:00
if (exServers.keySet().contains(name.toLowerCase())) {
exServers.remove(name.toLowerCase());
servers--;
SubServers, Host, & Client Beta v2.12b;2/2.12c;2/2.12b;2 Servers can now be incompatable with each other.
2017-07-21 22:45:41 +02:00
}
Don't fire edit events for temporary modifications
2021-06-06 07:28:22 +02:00
boolean add = false;
/sub reload can now perform soft reloads /sub reload - can now perform soft reloads /greload - still performs hard resets Soft Reloads mean that SubServers will load new data from the config and attempt to merge it with what is already in memory. This is good if you need to make some quick changes, since it will only stop servers if a major change has been made to them. However, this has the potential to cause issues, which is why the Hard Reset will continue to be tied to bungeecord command.
2017-12-09 09:43:29 +01:00
SubServer server = api.getSubServer(name);
if (server != null && server.isEditable()) { // Server can edit() (May be reset depending on change severity)
Begin rewrite for SubData 2
2019-04-18 16:02:09 +02:00
ObjectMap<String> edits = new ObjectMap<String>();
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
if (this.servers.get().getMap("Servers").getMap(name).getBoolean("Enabled") != server.isEnabled())
edits.set("enabled", this.servers.get().getMap("Servers").getMap(name).getBoolean("Enabled"));
Fix unnecessary .edit() of display names during reload
2019-06-18 01:30:30 +02:00
if (this.servers.get().getMap("Servers").getMap(name).getKeys().contains("Display") && ((this.servers.get().getMap("Servers").getMap(name).getRawString("Display").length() == 0 && !server.getName().equals(server.getDisplayName())) || (this.servers.get().getMap("Servers").getMap(name).getRawString("Display").length() > 0 && !this.servers.get().getMap("Servers").getMap(name).getRawString("Display").equals(server.getDisplayName()))))
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
edits.set("display", this.servers.get().getMap("Servers").getMap(name).getRawString("Display"));
if (!this.servers.get().getMap("Servers").getMap(name).getString("Host").equalsIgnoreCase(server.getHost().getName()))
edits.set("host", this.servers.get().getMap("Servers").getMap(name).getRawString("Host"));
Add the Update command And several related UI changes to SubServers.Client
2019-06-17 05:13:48 +02:00
if (this.servers.get().getMap("Servers").getMap(name).getKeys().contains("Template") && ((this.servers.get().getMap("Servers").getMap(name).getRawString("Template").length() == 0 && server.getTemplate() != null) || (this.servers.get().getMap("Servers").getMap(name).getRawString("Template").length() > 0 && server.getTemplate() == null) || (server.getTemplate() != null && !this.servers.get().getMap("Servers").getMap(name).getString("Template").equalsIgnoreCase(server.getTemplate().getName()))))
edits.set("template", this.servers.get().getMap("Servers").getMap(name).getString("Template"));
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
if (!this.servers.get().getMap("Servers").getMap(name).getStringList("Group").equals(server.getGroups()))
edits.set("group", this.servers.get().getMap("Servers").getMap(name).getRawStringList("Group"));
if (this.servers.get().getMap("Servers").getMap(name).getInt("Port") != server.getAddress().getPort())
edits.set("port", this.servers.get().getMap("Servers").getMap(name).getInt("Port"));
if (!(ChatColor.translateAlternateColorCodes('&', this.servers.get().getMap("Servers").getMap(name).getString("Motd")).equals(server.getMotd())))
edits.set("motd", this.servers.get().getMap("Servers").getMap(name).getRawString("Motd"));
if (this.servers.get().getMap("Servers").getMap(name).getBoolean("Log") != server.isLogging())
edits.set("log", this.servers.get().getMap("Servers").getMap(name).getBoolean("Log"));
if (!this.servers.get().getMap("Servers").getMap(name).getRawString("Directory").equals(server.getPath()))
edits.set("dir", this.servers.get().getMap("Servers").getMap(name).getRawString("Directory"));
if (!this.servers.get().getMap("Servers").getMap(name).getRawString("Executable").equals(server.getExecutable()))
edits.set("exec", this.servers.get().getMap("Servers").getMap(name).getRawString("Executable"));
if (!this.servers.get().getMap("Servers").getMap(name).getRawString("Stop-Command").equals(server.getStopCommand()))
edits.set("stop-cmd", this.servers.get().getMap("Servers").getMap(name).getRawString("Stop-Command"));
SubServer.StopAction action = Util.getDespiteException(() -> SubServer.StopAction.valueOf(this.servers.get().getMap("Servers").getMap(name).getRawString("Stop-Action", "NONE").toUpperCase().replace('-', '_').replace(' ', '_')), null);
Replace Auto-Restart and Temporary Flags with Stop Actions Stop Actions will is the replacement for both the Auto Restart and Temporary flags. To define that the server should restart on stop, use the RESTART keyword. To get the same result that you would get using the temporary flag, use the REMOVE_SERVER keyword. Additionally, there is now a DELETE_SERVER keyword. This keyword does the same thing as the REMOVE_SERVER keyword, except it deletes the directory on the server ran from. If you would like nothing special to happen when the server stops, use the NONE keyword.
2018-08-30 03:55:59 +02:00
if (action != null && action != server.getStopAction())
edits.set("stop-action", action.toString());
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
if (this.servers.get().getMap("Servers").getMap(name).getBoolean("Restricted") != server.isRestricted())
edits.set("restricted", this.servers.get().getMap("Servers").getMap(name).getBoolean("Restricted"));
if (this.servers.get().getMap("Servers").getMap(name).getBoolean("Hidden") != server.isHidden())
edits.set("hidden", this.servers.get().getMap("Servers").getMap(name).getBoolean("Hidden"));
/sub reload can now perform soft reloads /sub reload - can now perform soft reloads /greload - still performs hard resets Soft Reloads mean that SubServers will load new data from the config and attempt to merge it with what is already in memory. This is good if you need to make some quick changes, since it will only stop servers if a major change has been made to them. However, this has the potential to cause issues, which is why the Hard Reset will continue to be tied to bungeecord command.
2017-12-09 09:43:29 +01:00
if (edits.getKeys().size() > 0) {
Add a post-connect subdata event
2019-06-18 02:20:46 +02:00
server.edit(edits);
/sub reload can now perform soft reloads /sub reload - can now perform soft reloads /greload - still performs hard resets Soft Reloads mean that SubServers will load new data from the config and attempt to merge it with what is already in memory. This is good if you need to make some quick changes, since it will only stop servers if a major change has been made to them. However, this has the potential to cause issues, which is why the Hard Reset will continue to be tied to bungeecord command.
2017-12-09 09:43:29 +01:00
server = api.getSubServer(name);
Send off reload packet only when api.ready
2018-08-10 21:58:17 +02:00
}
/sub reload can now perform soft reloads /sub reload - can now perform soft reloads /greload - still performs hard resets Soft Reloads mean that SubServers will load new data from the config and attempt to merge it with what is already in memory. This is good if you need to make some quick changes, since it will only stop servers if a major change has been made to them. However, this has the potential to cause issues, which is why the Hard Reset will continue to be tied to bungeecord command.
2017-12-09 09:43:29 +01:00
} else { // Server cannot edit()
if (server == null || // Server must be reset
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
!this.servers.get().getMap("Servers").getMap(name).getString("Host").equalsIgnoreCase(server.getHost().getName()) ||
this.servers.get().getMap("Servers").getMap(name).getInt("Port") != server.getAddress().getPort() ||
!this.servers.get().getMap("Servers").getMap(name).getRawString("Directory").equals(server.getPath()) ||
!this.servers.get().getMap("Servers").getMap(name).getRawString("Executable").equals(server.getExecutable())
/sub reload can now perform soft reloads /sub reload - can now perform soft reloads /greload - still performs hard resets Soft Reloads mean that SubServers will load new data from the config and attempt to merge it with what is already in memory. This is good if you need to make some quick changes, since it will only stop servers if a major change has been made to them. However, this has the potential to cause issues, which is why the Hard Reset will continue to be tied to bungeecord command.
2017-12-09 09:43:29 +01:00
) {
if (server != null) server.getHost().forceRemoveSubServer(name);
Don't fire edit events for temporary modifications
2021-06-06 07:28:22 +02:00
add = true;
server = this.hosts.get(this.servers.get().getMap("Servers").getMap(name).getString("Host").toLowerCase()).constructSubServer(name, this.servers.get().getMap("Servers").getMap(name).getBoolean("Enabled"),
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
this.servers.get().getMap("Servers").getMap(name).getInt("Port"), ChatColor.translateAlternateColorCodes('&', this.servers.get().getMap("Servers").getMap(name).getString("Motd")), this.servers.get().getMap("Servers").getMap(name).getBoolean("Log"),
this.servers.get().getMap("Servers").getMap(name).getRawString("Directory"), this.servers.get().getMap("Servers").getMap(name).getRawString("Executable"), this.servers.get().getMap("Servers").getMap(name).getRawString("Stop-Command"),
this.servers.get().getMap("Servers").getMap(name).getBoolean("Hidden"), this.servers.get().getMap("Servers").getMap(name).getBoolean("Restricted"));
/sub reload can now perform soft reloads /sub reload - can now perform soft reloads /greload - still performs hard resets Soft Reloads mean that SubServers will load new data from the config and attempt to merge it with what is already in memory. This is good if you need to make some quick changes, since it will only stop servers if a major change has been made to them. However, this has the potential to cause issues, which is why the Hard Reset will continue to be tied to bungeecord command.
2017-12-09 09:43:29 +01:00
} else { // Server doesn't need to reset
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
if (this.servers.get().getMap("Servers").getMap(name).getBoolean("Enabled") != server.isEnabled())
server.setEnabled(this.servers.get().getMap("Servers").getMap(name).getBoolean("Enabled"));
if (!ChatColor.translateAlternateColorCodes('&', this.servers.get().getMap("Servers").getMap(name).getString("Motd")).equals(server.getMotd()))
server.setMotd(ChatColor.translateAlternateColorCodes('&', this.servers.get().getMap("Servers").getMap(name).getString("Motd")));
if (this.servers.get().getMap("Servers").getMap(name).getBoolean("Log") != server.isLogging())
server.setLogging(this.servers.get().getMap("Servers").getMap(name).getBoolean("Log"));
if (!this.servers.get().getMap("Servers").getMap(name).getRawString("Stop-Command").equals(server.getStopCommand()))
server.setStopCommand(this.servers.get().getMap("Servers").getMap(name).getRawString("Stop-Command"));
if (this.servers.get().getMap("Servers").getMap(name).getBoolean("Restricted") != server.isRestricted())
server.setRestricted(this.servers.get().getMap("Servers").getMap(name).getBoolean("Restricted"));
if (this.servers.get().getMap("Servers").getMap(name).getBoolean("Hidden") != server.isHidden())
server.setHidden(this.servers.get().getMap("Servers").getMap(name).getBoolean("Hidden"));
/sub reload can now perform soft reloads /sub reload - can now perform soft reloads /greload - still performs hard resets Soft Reloads mean that SubServers will load new data from the config and attempt to merge it with what is already in memory. This is good if you need to make some quick changes, since it will only stop servers if a major change has been made to them. However, this has the potential to cause issues, which is why the Hard Reset will continue to be tied to bungeecord command.
2017-12-09 09:43:29 +01:00
} // Apply these changes regardless of reset
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
SubServer.StopAction action = Util.getDespiteException(() -> SubServer.StopAction.valueOf(this.servers.get().getMap("Servers").getMap(name).getRawString("Stop-Action", "NONE").toUpperCase().replace('-', '_').replace(' ', '_')), null);
Replace Auto-Restart and Temporary Flags with Stop Actions Stop Actions will is the replacement for both the Auto Restart and Temporary flags. To define that the server should restart on stop, use the RESTART keyword. To get the same result that you would get using the temporary flag, use the REMOVE_SERVER keyword. Additionally, there is now a DELETE_SERVER keyword. This keyword does the same thing as the REMOVE_SERVER keyword, except it deletes the directory on the server ran from. If you would like nothing special to happen when the server stops, use the NONE keyword.
2018-08-30 03:55:59 +02:00
if (action != null && action != server.getStopAction())
server.setStopAction(action);
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
if (!status && this.servers.get().getMap("Servers").getMap(name).getBoolean("Run-On-Launch"))
Make `Name` field optional for SubServers.Client SubServers.Bungee can now link servers to subdata clients via connection address and port number. Since this still has the chance to fail, the `Name` field will appear if no servers were found this way, and will be used the same as before. SubCreator made servers will still have the `Name` value present and filled out for assurance.
2018-01-29 07:04:36 +01:00
autorun.add(name.toLowerCase());
Fix unnecessary .edit() of display names during reload
2019-06-18 01:30:30 +02:00
if (this.servers.get().getMap("Servers").getMap(name).getKeys().contains("Display") && ((this.servers.get().getMap("Servers").getMap(name).getRawString("Display").length() == 0 && !server.getName().equals(server.getDisplayName())) || (this.servers.get().getMap("Servers").getMap(name).getRawString("Display").length() > 0 && !this.servers.get().getMap("Servers").getMap(name).getRawString("Display").equals(server.getDisplayName()))))
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
server.setDisplayName(this.servers.get().getMap("Servers").getMap(name).getRawString("Display"));
Add the Update command And several related UI changes to SubServers.Client
2019-06-17 05:13:48 +02:00
if (this.servers.get().getMap("Servers").getMap(name).getKeys().contains("Template") && ((this.servers.get().getMap("Servers").getMap(name).getRawString("Template").length() == 0 && server.getTemplate() != null) || (this.servers.get().getMap("Servers").getMap(name).getRawString("Template").length() > 0 && server.getTemplate() == null) || (server.getTemplate() != null && !this.servers.get().getMap("Servers").getMap(name).getString("Template").equalsIgnoreCase(server.getTemplate().getName()))))
Re-Add local templates to SubServers.Host Local templates are now stored in `/Templates` Template cache files are still stored in `/Cache/Templates` Remote templates are now stored in `/Cache/Remote/Templates`
2020-06-20 03:00:50 +02:00
server.setTemplate(this.servers.get().getMap("Servers").getMap(name).getRawString("Template"));
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
if (this.servers.get().getMap("Servers").getMap(name).getKeys().contains("Group")) {
/sub reload can now perform soft reloads /sub reload - can now perform soft reloads /greload - still performs hard resets Soft Reloads mean that SubServers will load new data from the config and attempt to merge it with what is already in memory. This is good if you need to make some quick changes, since it will only stop servers if a major change has been made to them. However, this has the potential to cause issues, which is why the Hard Reset will continue to be tied to bungeecord command.
2017-12-09 09:43:29 +01:00
for (String group : server.getGroups()) server.removeGroup(group);
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
for (String group : this.servers.get().getMap("Servers").getMap(name).getStringList("Group")) server.addGroup(group);
/sub reload can now perform soft reloads /sub reload - can now perform soft reloads /greload - still performs hard resets Soft Reloads mean that SubServers will load new data from the config and attempt to merge it with what is already in memory. This is good if you need to make some quick changes, since it will only stop servers if a major change has been made to them. However, this has the potential to cause issues, which is why the Hard Reset will continue to be tied to bungeecord command.
2017-12-09 09:43:29 +01:00
}
} // Apply these changes regardless of edit/reset
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
if (this.servers.get().getMap("Servers").getMap(name).getKeys().contains("Extra")) for (String extra : this.servers.get().getMap("Servers").getMap(name).getMap("Extra").getKeys()) server.addExtra(extra, this.servers.get().getMap("Servers").getMap(name).getMap("Extra").getObject(extra));
Don't fire edit events for temporary modifications
2021-06-06 07:28:22 +02:00
if (add) server.getHost().addSubServer(server);
/sub reload can now perform soft reloads /sub reload - can now perform soft reloads /greload - still performs hard resets Soft Reloads mean that SubServers will load new data from the config and attempt to merge it with what is already in memory. This is good if you need to make some quick changes, since it will only stop servers if a major change has been made to them. However, this has the potential to cause issues, which is why the Hard Reset will continue to be tied to bungeecord command.
2017-12-09 09:43:29 +01:00
ukeys.add(name.toLowerCase());
subservers++;
} catch (Exception e) {
e.printStackTrace();
SubServers, Host, & Client Beta v2.12b;2/2.12c;2/2.12b;2 Servers can now be incompatable with each other.
2017-07-21 22:45:41 +02:00
}
/sub reload can now perform soft reloads /sub reload - can now perform soft reloads /greload - still performs hard resets Soft Reloads mean that SubServers will load new data from the config and attempt to merge it with what is already in memory. This is good if you need to make some quick changes, since it will only stop servers if a major change has been made to them. However, this has the potential to cause issues, which is why the Hard Reset will continue to be tied to bungeecord command.
2017-12-09 09:43:29 +01:00
}
for (String name : ukeys) {
SubServer server = api.getSubServer(name);
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
for (String oname : this.servers.get().getMap("Servers").getMap(server.getName()).getRawStringList("Incompatible", new ArrayList<>())) {
/sub reload can now perform soft reloads /sub reload - can now perform soft reloads /greload - still performs hard resets Soft Reloads mean that SubServers will load new data from the config and attempt to merge it with what is already in memory. This is good if you need to make some quick changes, since it will only stop servers if a major change has been made to them. However, this has the potential to cause issues, which is why the Hard Reset will continue to be tied to bungeecord command.
2017-12-09 09:43:29 +01:00
SubServer oserver = api.getSubServer(oname);
if (oserver != null && server.isCompatible(oserver)) server.toggleCompatibility(oserver);
}
}
ukeys.clear();
Move autorun queue to a more appropriate location This restores plugins' ability to listen for server start events
2021-02-07 07:19:55 +01:00
if (!posted) Runtime.getRuntime().addShutdownHook(new Thread(this::shutdown, "SubServers.Bungee::System_Shutdown"));
Fix shutdown detection
2021-04-23 06:36:54 +02:00
running = ready = true;
/sub reload can now perform soft reloads /sub reload - can now perform soft reloads /greload - still performs hard resets Soft Reloads mean that SubServers will load new data from the config and attempt to merge it with what is already in memory. This is good if you need to make some quick changes, since it will only stop servers if a major change has been made to them. However, this has the potential to cause issues, which is why the Hard Reset will continue to be tied to bungeecord command.
2017-12-09 09:43:29 +01:00
legServers.clear();
Optimizations for developers
2021-06-06 04:44:33 +02:00
int plugins = 0;
if (status) {
List<Runnable> listeners = api.reloadListeners;
if (listeners.size() > 0) {
Logger.get("SubServers").info("Reloading SubAPI Plugins...");
for (Runnable obj : listeners) {
try {
obj.run();
plugins++;
} catch (Throwable e) {
new InvocationTargetException(e, "Problem " + ((status)?"reloading":"enabling") + " plugin").printStackTrace();
}
}
}
for (Host host : api.getHosts().values()) if (host instanceof ClientHandler && ((ClientHandler) host).getSubData()[0] != null) ((SubDataClient) ((ClientHandler) host).getSubData()[0]).sendPacket(new PacketOutExReload(null));
for (Server server : api.getServers().values()) if (server.getSubData()[0] != null) ((SubDataClient) server.getSubData()[0]).sendPacket(new PacketOutExReload(null));
}
reloading = false;
Logger.get("SubServers").info(((plugins > 0)?plugins+" Plugin"+((plugins == 1)?"":"s")+", ":"") + hosts + " Host"+((hosts == 1)?"":"s")+", " + servers + " Server"+((servers == 1)?"":"s")+", and " + subservers + " SubServer"+((subservers == 1)?"":"s")+" "+((status)?"re":"")+"loaded in " + new DecimalFormat("0.000").format((Calendar.getInstance().getTime().getTime() - begin) / 1000D) + "s");
if (status) startDataListeners();
}
private void startDataListeners() throws IOException {
Add a grace period on rogue SubServer detection Async subdata shenanigans made rogue SubServer detection a little inacurrate. Specifically in regards to the last commit. This is the fix to that
2019-08-30 21:44:54 +02:00
if (subdata == null) {
subprotocol.unregisterCipher("AES");
subprotocol.unregisterCipher("AES-128");
subprotocol.unregisterCipher("AES-192");
subprotocol.unregisterCipher("AES-256");
subprotocol.unregisterCipher("RSA");
#50 #46 Selecting Multiple Servers This commit includes the following major changes and additions: -> New Command & Permission Formatting -> RemotePlayer API -> SubData with Blocks
2020-06-12 07:45:49 +02:00
subprotocol.setTimeout(TimeUnit.SECONDS.toMillis(config.get().getMap("Settings").getMap("SubData").getInt("Timeout", 30)));
Add a grace period on rogue SubServer detection Async subdata shenanigans made rogue SubServer detection a little inacurrate. Specifically in regards to the last commit. This is the fix to that
2019-08-30 21:44:54 +02:00
String cipher = config.get().getMap("Settings").getMap("SubData").getRawString("Encryption", "NULL");
String[] ciphers = (cipher.contains("/"))?cipher.split("/"):new String[]{cipher};
#50 #46 Selecting Multiple Servers This commit includes the following major changes and additions: -> New Command & Permission Formatting -> RemotePlayer API -> SubData with Blocks
2020-06-12 07:45:49 +02:00
Add a grace period on rogue SubServer detection Async subdata shenanigans made rogue SubServer detection a little inacurrate. Specifically in regards to the last commit. This is the fix to that
2019-08-30 21:44:54 +02:00
if (ciphers[0].equals("AES") || ciphers[0].equals("AES-128") || ciphers[0].equals("AES-192") || ciphers[0].equals("AES-256")) {
if (config.get().getMap("Settings").getMap("SubData").getRawString("Password", "").length() == 0) {
byte[] bytes = new byte[32];
new SecureRandom().nextBytes(bytes);
String random = Base64.getUrlEncoder().withoutPadding().encodeToString(bytes);
if (random.length() > bytes.length) random = random.substring(0, bytes.length);
config.get().getMap("Settings").getMap("SubData").set("Password", random);
config.save();
}
subprotocol.registerCipher("AES", new AES(128, config.get().getMap("Settings").getMap("SubData").getRawString("Password")));
subprotocol.registerCipher("AES-128", new AES(128, config.get().getMap("Settings").getMap("SubData").getRawString("Password")));
subprotocol.registerCipher("AES-192", new AES(192, config.get().getMap("Settings").getMap("SubData").getRawString("Password")));
subprotocol.registerCipher("AES-256", new AES(256, config.get().getMap("Settings").getMap("SubData").getRawString("Password")));
Logger.get("SubData").info("Encrypting SubData with AES:");
#50 #46 Selecting Multiple Servers This commit includes the following major changes and additions: -> New Command & Permission Formatting -> RemotePlayer API -> SubData with Blocks
2020-06-12 07:45:49 +02:00
Logger.get("SubData").info("Use the password field in config.yml to allow clients to connect");
} else if (ciphers[0].equals("DHE") || ciphers[0].equals("DHE-128") || ciphers[0].equals("DHE-192") || ciphers[0].equals("DHE-256")) {
Logger.get("SubData").info("Encrypting SubData with DHE/AES:");
Logger.get("SubData").info("SubData will negotiate what password to use automatically using the Diffie-Hellman Exchange");
Add a grace period on rogue SubServer detection Async subdata shenanigans made rogue SubServer detection a little inacurrate. Specifically in regards to the last commit. This is the fix to that
2019-08-30 21:44:54 +02:00
} else if (ciphers[0].equals("RSA") || ciphers[0].equals("RSA-2048") || ciphers[0].equals("RSA-3072") || ciphers[0].equals("RSA-4096")) {
try {
int length = (ciphers[0].contains("-"))?Integer.parseInt(ciphers[0].split("-")[1]):2048;
if (!(new UniversalFile("SubServers:Cache").exists())) new UniversalFile("SubServers:Cache").mkdirs();
subprotocol.registerCipher("RSA", new RSA(length, new UniversalFile("SubServers:Cache:private.rsa.key"), new UniversalFile("SubServers:subdata.rsa.key")));
cipher = "RSA" + cipher.substring(ciphers[0].length());
Logger.get("SubData").info("Encrypting SubData with RSA:");
Logger.get("SubData").info("Copy your subdata.rsa.key to clients to allow them to connect");
} catch (Exception e) {
e.printStackTrace();
}
}
Logger.get("SubData").info("");
Add some debug messages
2021-04-13 23:32:41 +02:00
subdata = subprotocol.open((config.get().getMap("Settings").getMap("SubData").getRawString("Address", "127.0.0.1:4391").split(":")[0].equals("0.0.0.0"))?
null:InetAddress.getByName(config.get().getMap("Settings").getMap("SubData").getRawString("Address", "127.0.0.1:4391").split(":")[0]),
Add a grace period on rogue SubServer detection Async subdata shenanigans made rogue SubServer detection a little inacurrate. Specifically in regards to the last commit. This is the fix to that
2019-08-30 21:44:54 +02:00
Integer.parseInt(config.get().getMap("Settings").getMap("SubData").getRawString("Address", "127.0.0.1:4391").split(":")[1]), cipher);
Optimizations for developers
2021-06-06 04:44:33 +02:00
}
// Add new entries to Allowed-Connections
Allow client apps to startup without a SubData connection active They won't be all that useful like that, but... ¯\_(ツ)_/¯
2019-08-31 19:26:37 +02:00
for (String s : config.get().getMap("Settings").getMap("SubData").getStringList("Whitelist", new ArrayList<String>())) {
Add a grace period on rogue SubServer detection Async subdata shenanigans made rogue SubServer detection a little inacurrate. Specifically in regards to the last commit. This is the fix to that
2019-08-30 21:44:54 +02:00
try {
subdata.whitelist(s);
} catch (Exception e) {
e.printStackTrace();
}
}
Move autorun queue to a more appropriate location This restores plugins' ability to listen for server start events
2021-02-07 07:19:55 +01:00
}
Add an option to space out auto-starting servers
2019-01-30 04:05:59 +01:00
Move autorun queue to a more appropriate location This restores plugins' ability to listen for server start events
2021-02-07 07:19:55 +01:00
@Override
public void startListeners() {
try {
Fix shutdown detection
2021-04-23 06:36:54 +02:00
if (posted || !ready) reload();
Move autorun queue to a more appropriate location This restores plugins' ability to listen for server start events
2021-02-07 07:19:55 +01:00
if (UPnP.isUPnPAvailable()) {
if (config.get().getMap("Settings").getMap("UPnP", new ObjectMap<String>()).getBoolean("Forward-Proxy", true)) for (ListenerInfo listener : getConfig().getListeners()) {
UPnP.openPortTCP(listener.getHost().getPort());
}
} else {
getLogger().warning("UPnP service is unavailable. SubServers can't port-forward for you from this device.");
}
Optimizations for developers
2021-06-06 04:44:33 +02:00
startDataListeners();
Move autorun queue to a more appropriate location This restores plugins' ability to listen for server start events
2021-02-07 07:19:55 +01:00
super.startListeners();
if (autorun != null && autorun.size() > 0) {
final long begin = resetDate;
final long scd = TimeUnit.SECONDS.toMillis(this.servers.get().getMap("Settings").getLong("Run-On-Launch-Timeout", 0L));
for (Host host : api.getHosts().values()) {
List<String> ar = new LinkedList<String>();
for (String name : autorun) if (host.getSubServer(name) != null) ar.add(name);
if (ar.size() > 0) new Thread(() -> {
try {
Fix shutdown detection
2021-04-23 06:36:54 +02:00
while (ready && begin == resetDate && !host.isAvailable()) {
Move autorun queue to a more appropriate location This restores plugins' ability to listen for server start events
2021-02-07 07:19:55 +01:00
Thread.sleep(250);
}
long init = Calendar.getInstance().getTime().getTime();
Fix shutdown detection
2021-04-23 06:36:54 +02:00
while (ready && begin == resetDate && ar.size() > 0) {
Move autorun queue to a more appropriate location This restores plugins' ability to listen for server start events
2021-02-07 07:19:55 +01:00
SubServer server = host.getSubServer(ar.get(0));
ar.remove(0);
if (server != null && !server.isRunning()) {
server.start();
if (ar.size() > 0 && scd > 0) {
long sleep = Calendar.getInstance().getTime().getTime();
Fix shutdown detection
2021-04-23 06:36:54 +02:00
while (ready && begin == resetDate && server.getSubData()[0] == null && Calendar.getInstance().getTime().getTime() - sleep < scd) {
Move autorun queue to a more appropriate location This restores plugins' ability to listen for server start events
2021-02-07 07:19:55 +01:00
Thread.sleep(250);
}
}
Add an option to space out auto-starting servers
2019-01-30 04:05:59 +01:00
}
}
Fix shutdown detection
2021-04-23 06:36:54 +02:00
if (ready && begin == resetDate && Calendar.getInstance().getTime().getTime() - init >= 5000)
Move autorun queue to a more appropriate location This restores plugins' ability to listen for server start events
2021-02-07 07:19:55 +01:00
Logger.get("SubServers").info("The auto-start queue for " + host.getName() + " has been finished");
} catch (Exception e) {
e.printStackTrace();
Add an option to space out auto-starting servers
2019-01-30 04:05:59 +01:00
}
Move autorun queue to a more appropriate location This restores plugins' ability to listen for server start events
2021-02-07 07:19:55 +01:00
}, "SubServers.Bungee::Automatic_Server_Starter(" + host.getName() + ")").start();
Add an option to space out auto-starting servers
2019-01-30 04:05:59 +01:00
}
Move autorun queue to a more appropriate location This restores plugins' ability to listen for server start events
2021-02-07 07:19:55 +01:00
}
autorun = null;
if (!posted) {
posted = true;
post();
}
} catch (IOException e) {
e.printStackTrace();
Add an option to space out auto-starting servers
2019-01-30 04:05:59 +01:00
}
SubServers.Bungee
2016-12-05 04:21:04 +01:00
}
SubServers, Host & Client v2.12.1c/2.12.1b/2.12.1b
2017-08-18 11:58:06 +02:00
private void post() {
Allow command overrides to be disabled seperately This also leaves room for disabling overrides in other features in the future.
2020-08-19 02:03:59 +02:00
if (!config.get().getMap("Settings").getRawStringList("Disabled-Overrides", Collections.emptyList()).contains("/server"))
Corrections to legacy formatting
2021-03-08 18:02:28 +01:00
getPluginManager().registerCommand(plugin, new SubCommand.BungeeServer(this, "server"));
Allow command overrides to be disabled seperately This also leaves room for disabling overrides in other features in the future.
2020-08-19 02:03:59 +02:00
if (!config.get().getMap("Settings").getRawStringList("Disabled-Overrides", Collections.emptyList()).contains("/glist"))
Make the compatibility plugin loadable Some BungeeCord API calls require an actual plugin object. This is a problem. Fortunately, the 2020 builds of BungeeCord provide a protected constructor that is actually usable by SubServers, so we implemented it.
2020-11-11 08:35:02 +01:00
getPluginManager().registerCommand(plugin, new SubCommand.BungeeList(this, "glist"));
Allow command overrides to be disabled seperately This also leaves room for disabling overrides in other features in the future.
2020-08-19 02:03:59 +02:00
Corrections to legacy formatting
2021-03-08 18:02:28 +01:00
getPluginManager().registerCommand(plugin, new SubCommand(this, "subservers"));
getPluginManager().registerCommand(plugin, new SubCommand(this, "subserver"));
getPluginManager().registerCommand(plugin, new SubCommand(this, "sub"));
Add Proper RedisBungee Support
2017-12-08 08:35:50 +01:00
Add more features to Smart Fallback
2020-07-03 23:14:59 +02:00
if (getReconnectHandler() != null && getReconnectHandler().getClass().equals(SmartFallback.class))
BungeeCommon API
2020-11-14 04:41:56 +01:00
setReconnectHandler(new SmartFallback(config.get().getMap("Settings").getMap("Smart-Fallback", new ObjectMap<>()))); // Re-initialize Smart Fallback
Add more features to Smart Fallback
2020-07-03 23:14:59 +02:00
SubServers, Host & Client v2.12.1c/2.12.1b/2.12.1b
2017-08-18 11:58:06 +02:00
new Metrics(this);
Name SubServers threads This change does not apply to SubServers.Client because those apps use the platform's native scheduler instead of threads
2019-01-06 07:58:13 +01:00
new Timer("SubServers.Bungee::Routine_Update_Check").schedule(new TimerTask() {
Fix the update notification
2018-07-27 21:36:51 +02:00
@SuppressWarnings("unchecked")
SubServers, Host & Client v2.12.1c/2.12.1b/2.12.1b
2017-08-18 11:58:06 +02:00
@Override
public void run() {
try {
Begin rewrite for SubData 2
2019-04-18 16:02:09 +02:00
ObjectMap<String> tags = new ObjectMap<String>(new Gson().fromJson("{\"tags\":" + Util.readAll(new BufferedReader(new InputStreamReader(new URL("https://api.github.com/repos/ME1312/SubServers-2/git/refs/tags").openStream(), Charset.forName("UTF-8")))) + '}', Map.class));
Fix changes from the last commit
2018-07-29 05:02:47 +02:00
List<Version> versions = new LinkedList<Version>();
SubServers, Host & Client v2.12.1c/2.12.1b/2.12.1b
2017-08-18 11:58:06 +02:00
Version updversion = version;
Rewrite what compares layered versions
2018-03-14 22:50:15 +01:00
int updcount = 0;
Begin rewrite for SubData 2
2019-04-18 16:02:09 +02:00
for (ObjectMap<String> tag : tags.getMapList("tags")) versions.add(Version.fromString(tag.getString("ref").substring(10)));
Fix changes from the last commit
2018-07-29 05:02:47 +02:00
Collections.sort(versions);
for (Version version : versions) {
if (version.compareTo(updversion) > 0) {
Fix the update notification
2018-07-27 21:36:51 +02:00
updversion = version;
updcount++;
SubServers, Host & Client v2.12.1c/2.12.1b/2.12.1b
2017-08-18 11:58:06 +02:00
}
}
Add support for GalaxiBungee
2019-05-17 00:36:41 +02:00
if (updcount > 0) Logger.get("SubServers").info("SubServers.Bungee v" + updversion + " is available. You are " + updcount + " version" + ((updcount == 1)?"":"s") + " behind.");
SubServers, Host & Client v2.12.1c/2.12.1b/2.12.1b
2017-08-18 11:58:06 +02:00
} catch (Exception e) {}
}
}, 0, TimeUnit.DAYS.toMillis(2));
Add an error checking thread for player sync
2020-08-23 02:01:58 +02:00
Update SubData
2020-11-07 17:35:25 +01:00
int rpec_i = config.get().getMap("Settings").getInt("RPEC-Check-Interval", 300);
int rpec_s = rpec_i - new Random().nextInt((rpec_i / 3) + 1);
Add an error checking thread for player sync
2020-08-23 02:01:58 +02:00
new Timer("SubServers.Bungee::RemotePlayer_Error_Checking").schedule(new TimerTask() {
@Override
public void run() {
synchronized (rPlayers) {
ArrayList<RemotePlayer> add = new ArrayList<RemotePlayer>();
for (ProxiedPlayer player : getPlayers()) {
if (!rPlayers.containsKey(player.getUniqueId())) { // Add players that don't exist
RemotePlayer p = new RemotePlayer(player);
rPlayerLinkP.put(player.getUniqueId(), p.getProxy());
rPlayers.put(player.getUniqueId(), p);
if (p.getServer() != null) rPlayerLinkS.put(player.getUniqueId(), p.getServer());
add.add(p);
}
}
ArrayList<RemotePlayer> remove = new ArrayList<RemotePlayer>();
for (UUID player : Util.getBackwards(rPlayerLinkP, mProxy)) { // Remove players that shouldn't exist
if (getPlayer(player) == null) {
remove.add(rPlayers.get(player));
rPlayerLinkS.remove(player);
rPlayerLinkP.remove(player);
rPlayers.remove(player);
}
}
LinkedList<PacketExSyncPlayer> packets = new LinkedList<PacketExSyncPlayer>(); // Compile change data for external proxies
if (add.size() > 0) packets.add(new PacketExSyncPlayer(mProxy.getName(), true, add.toArray(new RemotePlayer[0])));
if (remove.size() > 0) packets.add(new PacketExSyncPlayer(mProxy.getName(), false, remove.toArray(new RemotePlayer[0])));
if (packets.size() > 0) {
PacketExSyncPlayer[] packet = packets.toArray(new PacketExSyncPlayer[0]);
for (Proxy proxy : SubAPI.getInstance().getProxies().values()) if (proxy.getSubData()[0] != null) {
((SubDataClient) proxy.getSubData()[0]).sendPacket(packet);
}
}
}
}
Update SubData
2020-11-07 17:35:25 +01:00
}, TimeUnit.SECONDS.toMillis(rpec_s), TimeUnit.SECONDS.toMillis(rpec_i));
SubServers, Host & Client v2.12.1c/2.12.1b/2.12.1b
2017-08-18 11:58:06 +02:00
}
Host & Server objects are now signed (prevents desyncs across apps)
2017-12-10 01:30:06 +01:00
@Override
public void stopListeners() {
Fix shutdown detection
2021-04-23 06:36:54 +02:00
if (ready) {
Secure the compatibility plugin This commit moves the loadable section of the compatibility plugin to an anonymous class to prevent misuse of that section of code.
2021-02-15 06:28:06 +01:00
if (pluginDeployed) {
Keep the console reader alive during shutdown
2021-02-07 09:09:39 +01:00
shutdown = !super.isRunning;
super.isRunning = true;
}
Rework SubServers.Bungee's app lifecycle SubServers.Bungee now puts code in 2 new places to better load/unload it's data. When supported, this should give it better compatabilty with ordanary plugins. Also, it no longer has to 'shutdown' to handle /greload. Isn't that neat?
2021-02-07 05:53:03 +01:00
ListenerInfo[] listeners = getConfig().getListeners().toArray(new ListenerInfo[0]);
super.stopListeners();
Add UPnP Forwarding Option
2018-10-08 01:25:08 +02:00
Rework SubServers.Bungee's app lifecycle SubServers.Bungee now puts code in 2 new places to better load/unload it's data. When supported, this should give it better compatabilty with ordanary plugins. Also, it no longer has to 'shutdown' to handle /greload. Isn't that neat?
2021-02-07 05:53:03 +01:00
if (UPnP.isUPnPAvailable()) {
for (ListenerInfo listener : listeners) {
if (UPnP.isMappedTCP(listener.getHost().getPort())) UPnP.closePortTCP(listener.getHost().getPort());
}
Add UPnP Forwarding Option
2018-10-08 01:25:08 +02:00
}
Host & Server objects are now signed (prevents desyncs across apps)
2017-12-10 01:30:06 +01:00
}
Move autorun queue to a more appropriate location This restores plugins' ability to listen for server start events
2021-02-07 07:19:55 +01:00
}
Keep the console reader alive during shutdown
2021-02-07 09:09:39 +01:00
private boolean shutdown = false;
Move autorun queue to a more appropriate location This restores plugins' ability to listen for server start events
2021-02-07 07:19:55 +01:00
protected void shutdown() {
Fix shutdown detection
2021-04-23 06:36:54 +02:00
if (ready) {
Move autorun queue to a more appropriate location This restores plugins' ability to listen for server start events
2021-02-07 07:19:55 +01:00
legServers.clear();
legServers.putAll(getServersCopy());
Fix shutdown detection
2021-04-23 06:36:54 +02:00
ready = false;
Move autorun queue to a more appropriate location This restores plugins' ability to listen for server start events
2021-02-07 07:19:55 +01:00
Rework SubServers.Bungee's app lifecycle SubServers.Bungee now puts code in 2 new places to better load/unload it's data. When supported, this should give it better compatabilty with ordanary plugins. Also, it no longer has to 'shutdown' to handle /greload. Isn't that neat?
2021-02-07 05:53:03 +01:00
Logger.get("SubServers").info("Stopping hosted servers");
String[] hosts = this.hosts.keySet().toArray(new String[0]);
Fix shutdown detection
2021-04-23 06:36:54 +02:00
if (shutdown || !super.isRunning) running = false;
Rework SubServers.Bungee's app lifecycle SubServers.Bungee now puts code in 2 new places to better load/unload it's data. When supported, this should give it better compatabilty with ordanary plugins. Also, it no longer has to 'shutdown' to handle /greload. Isn't that neat?
2021-02-07 05:53:03 +01:00
for (String host : hosts) {
api.forceRemoveHost(host);
}
Host & Server objects are now signed (prevents desyncs across apps)
2017-12-10 01:30:06 +01:00
Rework SubServers.Bungee's app lifecycle SubServers.Bungee now puts code in 2 new places to better load/unload it's data. When supported, this should give it better compatabilty with ordanary plugins. Also, it no longer has to 'shutdown' to handle /greload. Isn't that neat?
2021-02-07 05:53:03 +01:00
Logger.get("SubServers").info("Removing dynamic data");
exServers.clear();
this.hosts.clear();
Host & Server objects are now signed (prevents desyncs across apps)
2017-12-10 01:30:06 +01:00
Rework SubServers.Bungee's app lifecycle SubServers.Bungee now puts code in 2 new places to better load/unload it's data. When supported, this should give it better compatabilty with ordanary plugins. Also, it no longer has to 'shutdown' to handle /greload. Isn't that neat?
2021-02-07 05:53:03 +01:00
String[] proxies = this.proxies.keySet().toArray(new String[0]);
for (String proxy : proxies) {
getPluginManager().callEvent(new SubRemoveProxyEvent(this.proxies.get(proxy)));
}
this.proxies.clear();
rPlayerLinkS.clear();
rPlayerLinkP.clear();
rPlayers.clear();
Add UPnP Forwarding Option
2018-10-08 01:25:08 +02:00
Optimizations for developers
2021-06-06 04:44:33 +02:00
if (subdata != null) try {
SubDataServer subdata = this.subdata;
Rework SubServers.Bungee's app lifecycle SubServers.Bungee now puts code in 2 new places to better load/unload it's data. When supported, this should give it better compatabilty with ordanary plugins. Also, it no longer has to 'shutdown' to handle /greload. Isn't that neat?
2021-02-07 05:53:03 +01:00
subdata.close();
Optimizations for developers
2021-06-06 04:44:33 +02:00
subdata.waitFor();
Rework SubServers.Bungee's app lifecycle SubServers.Bungee now puts code in 2 new places to better load/unload it's data. When supported, this should give it better compatabilty with ordanary plugins. Also, it no longer has to 'shutdown' to handle /greload. Isn't that neat?
2021-02-07 05:53:03 +01:00
} catch (InterruptedException | IOException e) {}
Keep the console reader alive during shutdown
2021-02-07 09:09:39 +01:00
if (shutdown) super.isRunning = false;
Add UPnP Forwarding Option
2018-10-08 01:25:08 +02:00
}
Host & Server objects are now signed (prevents desyncs across apps)
2017-12-10 01:30:06 +01:00
}
Implement the proposed TabValidator API This is how SubServers will implement the Validator API that I suggested. I had to make some assumptions though (like how I don't expect BungeeCord's api to have a setTabValidator() method).
2017-12-13 18:29:50 +01:00
String getNewSignature() {
BigInteger number = (lastSignature = lastSignature.add(BigInteger.ONE));
Rewrite Launch & PluginLoader for SubServers.Host This commit changes the way SubServers.Host launches itself and loads it's plugins. Overall loading plugins this way is more efficient, faster, and can cause less problems than before. Plugins will still use the package.xml & @SubPlugin annotation system to be loaded. Also, there are some changes to the logger that better support async logging.
2018-01-21 21:45:27 +01:00
final String DIGITS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_";
Allow PacketIn to accept multiple oncoming packet versions
2018-01-13 22:22:13 +01:00
final BigInteger BASE = BigInteger.valueOf(DIGITS.length());
Implement the proposed TabValidator API This is how SubServers will implement the Validator API that I suggested. I had to make some assumptions though (like how I don't expect BungeeCord's api to have a setTabValidator() method).
2017-12-13 18:29:50 +01:00
StringBuilder result = new StringBuilder();
Allow PacketIn to accept multiple oncoming packet versions
2018-01-13 22:22:13 +01:00
while (number.compareTo(BigInteger.ZERO) > 0) { // number > 0
Implement the proposed TabValidator API This is how SubServers will implement the Validator API that I suggested. I had to make some assumptions though (like how I don't expect BungeeCord's api to have a setTabValidator() method).
2017-12-13 18:29:50 +01:00
BigInteger[] divmod = number.divideAndRemainder(BASE);
number = divmod[0];
int digit = divmod[1].intValue();
result.insert(0, DIGITS.charAt(digit));
}
return (result.length() == 0) ? DIGITS.substring(0, 1) : result.toString();
Host & Server objects are now signed (prevents desyncs across apps)
2017-12-10 01:30:06 +01:00
}
Don't fire edit events for temporary modifications
2021-06-06 07:28:22 +02:00
Host constructHost(Class<? extends Host> driver, String name, boolean enabled, Range<Integer> ports, boolean log, InetAddress address, String directory, String gitBash) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
if (Util.isNull(driver, name, enabled, ports, log, address, directory, gitBash)) throw new NullPointerException();
return driver.getConstructor(SubProxy.class, String.class, boolean.class, Range.class, boolean.class, InetAddress.class, String.class, String.class).newInstance(this, name, enabled, ports, log, address, directory, gitBash);
}
Assume 1.13 Material enum values // Correct Patched Signatures
2017-12-07 23:51:06 +01:00
/**
* Further override BungeeCord's signature when patched into the same jar
*
* @return Software Name
*/
@Override
public String getName() {
Use single-threaded I/O for StopAction
2020-08-14 00:26:22 +02:00
return (isPatched)?"SubServers.Bungee":super.getName();
Assume 1.13 Material enum values // Correct Patched Signatures
2017-12-07 23:51:06 +01:00
}
/**
Keep BungeeCord versioning intact when patched
2018-05-24 20:52:47 +02:00
* Get the name from BungeeCord's original signature (for determining which fork is being used)
Assume 1.13 Material enum values // Correct Patched Signatures
2017-12-07 23:51:06 +01:00
*
Keep BungeeCord versioning intact when patched
2018-05-24 20:52:47 +02:00
* @return BungeeCord Software Name
Assume 1.13 Material enum values // Correct Patched Signatures
2017-12-07 23:51:06 +01:00
*/
BungeeCommon API
2020-11-14 04:41:56 +01:00
@Override
Keep BungeeCord versioning intact when patched
2018-05-24 20:52:47 +02:00
public String getBungeeName() {
return super.getName();
Assume 1.13 Material enum values // Correct Patched Signatures
2017-12-07 23:51:06 +01:00
}
SubServers.Bungee
2016-12-05 04:21:04 +01:00
/**
SubServers.Bungee Beta 1 The first beta release of SubServers.Bungee
2016-12-15 22:04:39 +01:00
* Emulate BungeeCord's getServers()
SubServers.Bungee
2016-12-05 04:21:04 +01:00
*
* @return Server Map
*/
@Override
public Map<String, ServerInfo> getServers() {
#50 #46 Selecting Multiple Servers This commit includes the following major changes and additions: -> New Command & Permission Formatting -> RemotePlayer API -> SubData with Blocks
2020-06-12 07:45:49 +02:00
return new LegacyServerMap(getServersCopy());
}
/**
* Emulate Waterfall's getServersCopy()
*
* @return Server Map Copy
*/
BungeeCommon API
2020-11-14 04:41:56 +01:00
@Override
#50 #46 Selecting Multiple Servers This commit includes the following major changes and additions: -> New Command & Permission Formatting -> RemotePlayer API -> SubData with Blocks
2020-06-12 07:45:49 +02:00
public Map<String, ServerInfo> getServersCopy() {
Better legacy API emulation
2021-03-13 17:51:32 +01:00
Map<String, ServerInfo> servers = new CaseInsensitiveMap<ServerInfo>();
Fix shutdown detection
2021-04-23 06:36:54 +02:00
if (!ready) {
SubServers, Host, & Client Beta v2.12b;2/2.12c;2/2.12b;2 Servers can now be incompatable with each other.
2017-07-21 22:45:41 +02:00
servers.putAll(super.getServers());
SubServers v2.12.1b
2017-08-17 01:29:02 +02:00
servers.putAll(legServers);
API Additions & Launch Changes
2017-01-08 03:30:03 +01:00
} else {
for (ServerInfo server : exServers.values()) servers.put(server.getName(), server);
for (Host host : this.hosts.values()) {
for (ServerInfo server : host.getSubServers().values()) servers.put(server.getName(), server);
}
SubServers.Bungee
2016-12-05 04:21:04 +01:00
}
Update Javadoc
2017-04-16 19:02:14 +02:00
return servers;
SubServers.Bungee
2016-12-05 04:21:04 +01:00
}
Correct getServerInfo() on Waterfall
2020-01-25 19:30:16 +01:00
/**
* Force BungeeCord's implementation of getServerInfo()
*
* @return ServerInfo
*/
@Override
public ServerInfo getServerInfo(String name) {
Allow targeting multiple RemotePlayers
2021-06-15 06:09:51 +02:00
if (!ready) {
return getServersCopy().get(name);
} else {
return api.getServer(name);
}
Correct getServerInfo() on Waterfall
2020-01-25 19:30:16 +01:00
}
Allow plugins to modify the result of ping_passthrough
2020-07-04 02:23:27 +02:00
@EventHandler(priority = Byte.MIN_VALUE)
public void ping_passthrough(ProxyPingEvent e) {
Disallow the same UUID to make multiple connections to a multi-proxy network
2020-08-13 02:18:55 +02:00
boolean dynamic;
Modify pings for DNS-Forward servers
2020-07-04 01:05:02 +02:00
ServerInfo override;
Disallow the same UUID to make multiple connections to a multi-proxy network
2020-08-13 02:18:55 +02:00
if ((dynamic = SmartFallback.getForcedHost(e.getConnection()) == null) && getReconnectHandler() instanceof SmartFallback && (override = SmartFallback.getDNS(e.getConnection())) != null) {
Allow plugins to modify the result of ping_passthrough
2020-07-04 02:23:27 +02:00
if (!(override instanceof SubServer) || ((SubServer) override).isRunning()) {
Modify pings for DNS-Forward servers
2020-07-04 01:05:02 +02:00
if (!e.getConnection().getListener().isPingPassthrough()) {
SubServers.Sync.Velocity #64 (Preview) And automatic external server definitions
2021-07-09 07:46:10 +02:00
e.setResponse(new ServerPing(e.getResponse().getVersion(), e.getResponse().getPlayers(), new TextComponent(override.getMotd()), e.getResponse().getFaviconObject()));
Modify pings for DNS-Forward servers
2020-07-04 01:05:02 +02:00
} else {
Update GalaxiEngine
2020-11-14 08:07:25 +01:00
Container<Boolean> lock = new Container<>(true);
Make the compatibility plugin loadable Some BungeeCord API calls require an actual plugin object. This is a problem. Fortunately, the 2020 builds of BungeeCord provide a protected constructor that is actually usable by SubServers, so we implemented it.
2020-11-11 08:35:02 +01:00
boolean mode = plugin != null;
if (mode) e.registerIntent(plugin);
Modify pings for DNS-Forward servers
2020-07-04 01:05:02 +02:00
((BungeeServerInfo) override).ping((ping, error) -> {
if (error != null) {
SubServers.Sync.Velocity #64 (Preview) And automatic external server definitions
2021-07-09 07:46:10 +02:00
e.setResponse(new ServerPing(e.getResponse().getVersion(), e.getResponse().getPlayers(), new TextComponent(getTranslation("ping_cannot_connect")), e.getResponse().getFaviconObject()));
Modify pings for DNS-Forward servers
2020-07-04 01:05:02 +02:00
} else e.setResponse(ping);
lock.value = false;
Make the compatibility plugin loadable Some BungeeCord API calls require an actual plugin object. This is a problem. Fortunately, the 2020 builds of BungeeCord provide a protected constructor that is actually usable by SubServers, so we implemented it.
2020-11-11 08:35:02 +01:00
if (mode) e.completeIntent(plugin);
Modify pings for DNS-Forward servers
2020-07-04 01:05:02 +02:00
}, ((InitialHandler) e.getConnection()).getHandshake().getProtocolVersion());
Make the compatibility plugin loadable Some BungeeCord API calls require an actual plugin object. This is a problem. Fortunately, the 2020 builds of BungeeCord provide a protected constructor that is actually usable by SubServers, so we implemented it.
2020-11-11 08:35:02 +01:00
if (!mode) while (lock.value) Util.isException(() -> Thread.sleep(4));
Modify pings for DNS-Forward servers
2020-07-04 01:05:02 +02:00
}
}
Disallow the same UUID to make multiple connections to a multi-proxy network
2020-08-13 02:18:55 +02:00
} else if (dynamic) {
e.getResponse().getPlayers().setOnline(rPlayers.size());
Allow plugins to modify the result of ping_passthrough
2020-07-04 02:23:27 +02:00
}
}
@EventHandler(priority = Byte.MAX_VALUE)
public void ping(ProxyPingEvent e) {
ServerInfo override;
Disallow the same UUID to make multiple connections to a multi-proxy network
2020-08-13 02:18:55 +02:00
if ((override = SmartFallback.getForcedHost(e.getConnection())) != null || (override = SmartFallback.getDNS(e.getConnection())) != null) {
Allow plugins to modify the result of ping_passthrough
2020-07-04 02:23:27 +02:00
if (override instanceof SubServer && !((SubServer) override).isRunning()) {
SubServers.Sync.Velocity #64 (Preview) And automatic external server definitions
2021-07-09 07:46:10 +02:00
e.setResponse(new ServerPing(e.getResponse().getVersion(), e.getResponse().getPlayers(), new TextComponent(api.getLang("SubServers", "Bungee.Ping.Offline")), e.getResponse().getFaviconObject()));
Allow plugins to modify the result of ping_passthrough
2020-07-04 02:23:27 +02:00
}
Modify pings for DNS-Forward servers
2020-07-04 01:05:02 +02:00
} else {
int offline = 0;
for (String name : e.getConnection().getListener().getServerPriority()) {
ServerInfo server = api.getServer(name.toLowerCase());
if (server == null) server = getServerInfo(name);
if (server == null || (server instanceof SubServer && !((SubServer) server).isRunning())) offline++;
}
Add warnings for connecting to known offline servers #39
2019-02-27 20:05:05 +01:00
Modify pings for DNS-Forward servers
2020-07-04 01:05:02 +02:00
if (offline >= e.getConnection().getListener().getServerPriority().size()) {
SubServers.Sync.Velocity #64 (Preview) And automatic external server definitions
2021-07-09 07:46:10 +02:00
e.setResponse(new ServerPing(e.getResponse().getVersion(), e.getResponse().getPlayers(), new TextComponent(api.getLang("SubServers", "Bungee.Ping.Offline")), e.getResponse().getFaviconObject()));
Modify pings for DNS-Forward servers
2020-07-04 01:05:02 +02:00
}
Add warnings for connecting to known offline servers #39
2019-02-27 20:05:05 +01:00
}
}
Disallow the same UUID to make multiple connections to a multi-proxy network
2020-08-13 02:18:55 +02:00
@EventHandler(priority = Byte.MIN_VALUE)
public void login(LoginEvent e) {
Override fallback servers when using `Reconnect`
2020-08-29 12:57:38 +02:00
super.getLogger().info("UUID of player " + e.getConnection().getName() + " is " + e.getConnection().getUniqueId());
Disallow the same UUID to make multiple connections to a multi-proxy network
2020-08-13 02:18:55 +02:00
if (rPlayers.containsKey(e.getConnection().getUniqueId())) {
Add an error checking thread for player sync
2020-08-23 02:01:58 +02:00
Logger.get("SubServers").warning(e.getConnection().getName() + " connected, but already had a database entry");
Favor new connections over the old ones This is a change to the rules that govern what happens when the same UUID connects to the same network more than once. It is now more BungeeCord like in nature.
2020-08-19 21:24:05 +02:00
RemotePlayer player = rPlayers.get(e.getConnection().getUniqueId());
if (player.getProxy() == null || player.getProxy().isMaster()) {
Misc fixes regarding the last few commits
2020-08-22 00:33:09 +02:00
ProxiedPlayer p = getPlayer(player.getUniqueId());
if (p != null) p.disconnect(new TextComponent(getTranslation("already_connected_proxy")));
Allow a subserver's template to be changed
2020-08-20 03:15:55 +02:00
} else if (player.getProxy().getSubData()[0] != null) {
Allow targeting multiple RemotePlayers
2021-06-15 06:09:51 +02:00
((SubDataClient) player.getProxy().getSubData()[0]).sendPacket(new PacketExDisconnectPlayer(Collections.singletonList(player.getUniqueId()), getTranslation("already_connected_proxy")));
Favor new connections over the old ones This is a change to the rules that govern what happens when the same UUID connects to the same network more than once. It is now more BungeeCord like in nature.
2020-08-19 21:24:05 +02:00
}
Disallow the same UUID to make multiple connections to a multi-proxy network
2020-08-13 02:18:55 +02:00
}
}
SubServers, Host & Client v2.12.1c/2.12.1b/2.12.1b
2017-08-18 11:58:06 +02:00
@EventHandler(priority = Byte.MAX_VALUE)
Add warnings for connecting to known offline servers #39
2019-02-27 20:05:05 +01:00
public void validate(ServerConnectEvent e) {
Override fallback servers when using `Reconnect`
2020-08-29 12:57:38 +02:00
if (e.getPlayer().isConnected()) {
Map<String, ServerInfo> servers = new TreeMap<String, ServerInfo>(api.getServers());
if (servers.keySet().contains(e.getTarget().getName().toLowerCase()) && e.getTarget() != servers.get(e.getTarget().getName().toLowerCase())) {
e.setTarget(servers.get(e.getTarget().getName().toLowerCase()));
} else {
servers = getServersCopy();
if (servers.keySet().contains(e.getTarget().getName()) && e.getTarget() != servers.get(e.getTarget().getName())) {
e.setTarget(servers.get(e.getTarget().getName()));
}
SubServers, Host & Client v2.12.1c/2.12.1b/2.12.1b
2017-08-18 11:58:06 +02:00
}
Correct default access rules for restricted servers
2018-11-21 22:52:03 +01:00
Override fallback servers when using `Reconnect`
2020-08-29 12:57:38 +02:00
if (!e.getTarget().canAccess(e.getPlayer())) {
Rewrite SmartFallback's Fallback process
2020-12-05 05:30:36 +01:00
if (e.getPlayer().getServer() == null || fallback.containsKey(e.getPlayer().getUniqueId())) {
if (!fallback.containsKey(e.getPlayer().getUniqueId()) || fallback.get(e.getPlayer().getUniqueId()).names.contains(e.getTarget().getName())) {
Override fallback servers when using `Reconnect`
2020-08-29 12:57:38 +02:00
ServerKickEvent kick = new ServerKickEvent(e.getPlayer(), e.getTarget(), new BaseComponent[]{
SubServers.Sync.Velocity #64 (Preview) And automatic external server definitions
2021-07-09 07:46:10 +02:00
new TextComponent(api.getLang("SubServers", "Bungee.Restricted"))
Override fallback servers when using `Reconnect`
2020-08-29 12:57:38 +02:00
}, null, ServerKickEvent.State.CONNECTING);
fallback(kick);
if (!kick.isCancelled()) e.getPlayer().disconnect(kick.getKickReasonComponent());
if (e.getPlayer().getServer() != null) e.setCancelled(true);
}
} else {
SubServers.Sync.Velocity #64 (Preview) And automatic external server definitions
2021-07-09 07:46:10 +02:00
e.getPlayer().sendMessage(api.getLang("SubServers", "Bungee.Restricted"));
Override fallback servers when using `Reconnect`
2020-08-29 12:57:38 +02:00
e.setCancelled(true);
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
}
Rewrite SmartFallback's Fallback process
2020-12-05 05:30:36 +01:00
} else if (e.getPlayer().getServer() != null && !fallback.containsKey(e.getPlayer().getUniqueId()) && e.getTarget() instanceof SubServer && !((SubServer) e.getTarget()).isRunning()) {
Override fallback servers when using `Reconnect`
2020-08-29 12:57:38 +02:00
e.getPlayer().sendMessage(api.getLang("SubServers", "Bungee.Server.Offline"));
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
e.setCancelled(true);
}
Rewrite SmartFallback's Fallback process
2020-12-05 05:30:36 +01:00
if (fallback.containsKey(e.getPlayer().getUniqueId())) {
FallbackState state = fallback.get(e.getPlayer().getUniqueId());
if (state.names.contains(e.getTarget().getName())) {
state.remove(e.getTarget().getName());
Override fallback servers when using `Reconnect`
2020-08-29 12:57:38 +02:00
} else if (e.getPlayer().getServer() != null) {
Rewrite SmartFallback's Fallback process
2020-12-05 05:30:36 +01:00
fallback.remove(e.getPlayer().getUniqueId());
Override fallback servers when using `Reconnect`
2020-08-29 12:57:38 +02:00
}
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
}
Override fallback servers when using `Reconnect`
2020-08-29 12:57:38 +02:00
} else {
e.setCancelled(true);
Correct default access rules for restricted servers
2018-11-21 22:52:03 +01:00
}
SubServers, Host & Client v2.12.1c/2.12.1b/2.12.1b
2017-08-18 11:58:06 +02:00
}
Ditch RedisBungee. Long live the RemotePlayer API RedisBungee has been abandoned by it's developers. So we're abanding it too. SubServers.Sync will now finally pick up the slack and sync basic player information between proxies over their SubData connection.
2020-07-25 07:20:59 +02:00
@SuppressWarnings("deprecation")
@EventHandler(priority = Byte.MAX_VALUE)
Disallow the same UUID to make multiple connections to a multi-proxy network
2020-08-13 02:18:55 +02:00
public void connected(ServerConnectedEvent e) {
Override fallback servers when using `Reconnect`
2020-08-29 12:57:38 +02:00
if (e.getPlayer().isConnected()) {
synchronized (rPlayers) {
Add action methods to RemotePlayer
2021-06-14 03:31:59 +02:00
RemotePlayer player = new RemotePlayer(e.getPlayer(), e.getServer().getInfo());
Override fallback servers when using `Reconnect`
2020-08-29 12:57:38 +02:00
rPlayerLinkP.put(player.getUniqueId(), player.getProxy());
rPlayers.put(player.getUniqueId(), player);
if (player.getServer() != null) rPlayerLinkS.put(player.getUniqueId(), player.getServer());
for (Proxy proxy : SubAPI.getInstance().getProxies().values()) if (proxy.getSubData()[0] != null) {
((SubDataClient) proxy.getSubData()[0]).sendPacket(new PacketExSyncPlayer(mProxy.getName(), true, player));
}
Favor new connections over the old ones This is a change to the rules that govern what happens when the same UUID connects to the same network more than once. It is now more BungeeCord like in nature.
2020-08-19 21:24:05 +02:00
}
Ditch RedisBungee. Long live the RemotePlayer API RedisBungee has been abandoned by it's developers. So we're abanding it too. SubServers.Sync will now finally pick up the slack and sync basic player information between proxies over their SubData connection.
2020-07-25 07:20:59 +02:00
Disallow the same UUID to make multiple connections to a multi-proxy network
2020-08-13 02:18:55 +02:00
Rewrite SmartFallback's Fallback process
2020-12-05 05:30:36 +01:00
if (fallback.containsKey(e.getPlayer().getUniqueId())) {
fallback.get(e.getPlayer().getUniqueId()).done(() -> {
if (e.getPlayer().getServer() != null && !((UserConnection) e.getPlayer()).isDimensionChange() && e.getPlayer().getServer().getInfo().getName().equals(e.getServer().getInfo().getName())) {
fallback.remove(e.getPlayer().getUniqueId());
e.getPlayer().sendMessage(api.getLang("SubServers", "Bungee.Feature.Smart-Fallback.Result").replace("$str$", (e.getServer().getInfo() instanceof Server)?((Server) e.getServer().getInfo()).getDisplayName():e.getServer().getInfo().getName()));
Override fallback servers when using `Reconnect`
2020-08-29 12:57:38 +02:00
}
Rewrite SmartFallback's Fallback process
2020-12-05 05:30:36 +01:00
}, getConfig().getServerConnectTimeout() + 500);
Update SubData
2020-11-23 06:25:00 +01:00
}
Override fallback servers when using `Reconnect`
2020-08-29 12:57:38 +02:00
}
Ditch RedisBungee. Long live the RemotePlayer API RedisBungee has been abandoned by it's developers. So we're abanding it too. SubServers.Sync will now finally pick up the slack and sync basic player information between proxies over their SubData connection.
2020-07-25 07:20:59 +02:00
}
Re-Add fallback functionality
2018-10-04 01:18:16 +02:00
@SuppressWarnings("deprecation")
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
@EventHandler(priority = Byte.MAX_VALUE)
Re-Add fallback functionality
2018-10-04 01:18:16 +02:00
public void fallback(ServerKickEvent e) {
Override fallback servers when using `Reconnect`
2020-08-29 12:57:38 +02:00
if (e.getPlayer().isConnected() && e.getPlayer() instanceof UserConnection && config.get().getMap("Settings").getMap("Smart-Fallback", new ObjectMap<>()).getBoolean("Fallback", true)) {
Rewrite SmartFallback's Fallback process
2020-12-05 05:30:36 +01:00
FallbackState state;
boolean init = !fallback.containsKey(e.getPlayer().getUniqueId());
if (init) {
Map<String, ServerInfo> map = SmartFallback.getFallbackServers(e.getPlayer().getPendingConnection().getListener(), e.getPlayer());
map.remove(e.getKickedFrom().getName());
state = new FallbackState(e.getPlayer().getUniqueId(), map, e.getKickReasonComponent());
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
} else {
Rewrite SmartFallback's Fallback process
2020-12-05 05:30:36 +01:00
state = fallback.get(e.getPlayer().getUniqueId());
e.setKickReasonComponent(state.reason);
LinkedList<ServerInfo> tmp = new LinkedList<>(state.servers);
for (ServerInfo server : tmp) if (server.getName().equals(e.getKickedFrom().getName()))
state.remove(server);
Re-Add fallback functionality
2018-10-04 01:18:16 +02:00
}
Choose fallback based on confidence score The fallback server chosen when a server goes down is now chosen based on SubServers' confidence that the server can recieve the player in question. If there is a tie, the first server to achieve a high score is chosen. Servers meeting these requirements will get the highest score currently possible: -> Fallback servers should not be white-listed (`Restricted: false`) -> Fallback servers should be visible (`Hidden: false`) -> Fallback subservers should be running -> SubServers trusts that fallback servers connected to SubData are online
2018-10-14 09:26:23 +02:00
Rewrite SmartFallback's Fallback process
2020-12-05 05:30:36 +01:00
if (!state.servers.isEmpty()) {
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
e.setCancelled(true);
e.getPlayer().sendMessage(api.getLang("SubServers", "Bungee.Feature.Smart-Fallback").replace("$str$", (e.getKickedFrom() instanceof Server)?((Server) e.getKickedFrom()).getDisplayName():e.getKickedFrom().getName()).replace("$msg$", e.getKickReason()));
Rewrite SmartFallback's Fallback process
2020-12-05 05:30:36 +01:00
if (init) fallback.put(e.getPlayer().getUniqueId(), state);
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
Rewrite SmartFallback's Fallback process
2020-12-05 05:30:36 +01:00
e.setCancelServer(state.servers.getFirst());
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
}
Re-Add fallback functionality
2018-10-04 01:18:16 +02:00
}
}
Disallow the same UUID to make multiple connections to a multi-proxy network
2020-08-13 02:18:55 +02:00
Override fallback servers when using `Reconnect`
2020-08-29 12:57:38 +02:00
@EventHandler(priority = Byte.MAX_VALUE)
Make the compatibility plugin loadable Some BungeeCord API calls require an actual plugin object. This is a problem. Fortunately, the 2020 builds of BungeeCord provide a protected constructor that is actually usable by SubServers, so we implemented it.
2020-11-11 08:35:02 +01:00
public void disconnected(PlayerDisconnectEvent e) {
More debug messages
2020-08-24 18:04:21 +02:00
UUID id = e.getPlayer().getUniqueId();
Rewrite SmartFallback's Fallback process
2020-12-05 05:30:36 +01:00
fallback.remove(id);
More debug messages
2020-08-24 18:04:21 +02:00
SubCommand.players.remove(id);
Ditch RedisBungee. Long live the RemotePlayer API RedisBungee has been abandoned by it's developers. So we're abanding it too. SubServers.Sync will now finally pick up the slack and sync basic player information between proxies over their SubData connection.
2020-07-25 07:20:59 +02:00
Favor new connections over the old ones This is a change to the rules that govern what happens when the same UUID connects to the same network more than once. It is now more BungeeCord like in nature.
2020-08-19 21:24:05 +02:00
synchronized (rPlayers) {
More debug messages
2020-08-24 18:04:21 +02:00
if (rPlayers.containsKey(id) && (!rPlayerLinkP.containsKey(id) || rPlayerLinkP.get(id).isMaster())) {
RemotePlayer player = rPlayers.get(id);
rPlayerLinkS.remove(id);
rPlayerLinkP.remove(id);
rPlayers.remove(id);
Add an error checking thread for player sync
2020-08-23 02:01:58 +02:00
for (Proxy proxy : SubAPI.getInstance().getProxies().values()) if (proxy.getSubData()[0] != null) {
((SubDataClient) proxy.getSubData()[0]).sendPacket(new PacketExSyncPlayer(mProxy.getName(), false, player));
}
Ditch RedisBungee. Long live the RemotePlayer API RedisBungee has been abandoned by it's developers. So we're abanding it too. SubServers.Sync will now finally pick up the slack and sync basic player information between proxies over their SubData connection.
2020-07-25 07:20:59 +02:00
}
}
Config Updater & Smart Fallback Update
2019-04-29 17:05:06 +02:00
}
Re-Add fallback functionality
2018-10-04 01:18:16 +02:00
SubServers, Host & Client v2.12.1c/2.12.1b/2.12.1b
2017-08-18 11:58:06 +02:00
@EventHandler(priority = Byte.MIN_VALUE)
Add warnings for connecting to known offline servers #39
2019-02-27 20:05:05 +01:00
public void unsudo(SubStoppedEvent e) {
SubServers, Host, & Client v2.12.1a
2017-08-15 11:58:48 +02:00
if (sudo == e.getServer()) {
sudo = null;
Add support for GalaxiBungee
2019-05-17 00:36:41 +02:00
Logger.get("SubServers").info("Reverting to the BungeeCord Console");
SubServers, Host, & Client v2.12.1a
2017-08-15 11:58:48 +02:00
}
}
SubServers.Bungee
2016-12-05 04:21:04 +01:00
}