From 45854f1693f5950ff595909a10bfd47c4755764a Mon Sep 17 00:00:00 2001 From: lax1dude Date: Thu, 30 May 2024 14:47:31 -0700 Subject: [PATCH] added velocity support, needs testing --- .../EaglerMOTDConnectionVelocity.java | 188 +++++++++++++++ .../velocity/EaglerMOTDListenerVelocity.java | 52 ++++ .../velocity/EaglerMOTDPluginVelocity.java | 228 ++++++++++++++++++ .../velocity/EaglerMOTDPluginVersion.java | 26 ++ .../EaglerMOTDQueryHandlerVelocity.java | 58 +++++ .../command/CommandMOTDReloadVelocity.java | 74 ++++++ 6 files changed, 626 insertions(+) create mode 100644 src/main/java/net/lax1dude/eaglercraft/v1_8/plugin/eaglermotd/velocity/EaglerMOTDConnectionVelocity.java create mode 100644 src/main/java/net/lax1dude/eaglercraft/v1_8/plugin/eaglermotd/velocity/EaglerMOTDListenerVelocity.java create mode 100644 src/main/java/net/lax1dude/eaglercraft/v1_8/plugin/eaglermotd/velocity/EaglerMOTDPluginVelocity.java create mode 100644 src/main/java/net/lax1dude/eaglercraft/v1_8/plugin/eaglermotd/velocity/EaglerMOTDPluginVersion.java create mode 100644 src/main/java/net/lax1dude/eaglercraft/v1_8/plugin/eaglermotd/velocity/EaglerMOTDQueryHandlerVelocity.java create mode 100644 src/main/java/net/lax1dude/eaglercraft/v1_8/plugin/eaglermotd/velocity/command/CommandMOTDReloadVelocity.java diff --git a/src/main/java/net/lax1dude/eaglercraft/v1_8/plugin/eaglermotd/velocity/EaglerMOTDConnectionVelocity.java b/src/main/java/net/lax1dude/eaglercraft/v1_8/plugin/eaglermotd/velocity/EaglerMOTDConnectionVelocity.java new file mode 100644 index 0000000..5bce7b2 --- /dev/null +++ b/src/main/java/net/lax1dude/eaglercraft/v1_8/plugin/eaglermotd/velocity/EaglerMOTDConnectionVelocity.java @@ -0,0 +1,188 @@ +package net.lax1dude.eaglercraft.v1_8.plugin.eaglermotd.velocity; + +import java.net.InetAddress; +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import com.velocitypowered.api.proxy.Player; + +import net.lax1dude.eaglercraft.v1_8.plugin.eaglermotd.EaglerMOTDConnectionAdapter; +import net.lax1dude.eaglercraft.v1_8.plugin.eaglermotd.EaglerMOTDUtils; +import net.lax1dude.eaglercraft.v1_8.plugin.gateway_velocity.api.query.MOTDConnection; +import net.lax1dude.eaglercraft.v1_8.plugin.gateway_velocity.config.EaglerListenerConfig; + +/** + * Copyright (c) 2024 lax1dude. All Rights Reserved. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + */ +public class EaglerMOTDConnectionVelocity implements EaglerMOTDConnectionAdapter { + + private final MOTDConnection con; + private String listenerString = null; + + public EaglerMOTDConnectionVelocity(MOTDConnection con) { + this.con = con; + } + + @Override + public boolean isClosed() { + return con.isClosed(); + } + + @Override + public void close() { + con.close(); + } + + @Override + public String getAccept() { + return con.getAccept(); + } + + @Override + public InetAddress getAddress() { + return con.getAddress(); + } + + @Override + public String getListener() { + if(listenerString == null) { + EaglerListenerConfig config = con.getListener(); + if(config.getAddress() != null) { + this.listenerString = EaglerMOTDUtils.makeListenerString(config.getAddress()); + }else if(config.getAddressV6() != null) { + this.listenerString = EaglerMOTDUtils.makeListenerString(config.getAddressV6()); + }else { + throw new RuntimeException("Listener does not have an address!?"); + } + } + return listenerString; + } + + @Override + public long getConnectionTimestamp() { + return con.getConnectionTimestamp(); + } + + @Override + public long getConnectionAge() { + return con.getConnectionAge(); + } + + @Override + public void sendToUser() { + con.sendToUser(); + } + + @Override + public String getLine1() { + return con.getLine1(); + } + + @Override + public String getLine2() { + return con.getLine2(); + } + + @Override + public List getPlayerList() { + return con.getPlayerList(); + } + + @Override + public int[] getBitmap() { + return con.getBitmap(); + } + + @Override + public int getOnlinePlayers() { + return con.getOnlinePlayers(); + } + + @Override + public int getMaxPlayers() { + return con.getMaxPlayers(); + } + + @Override + public String getSubType() { + return con.getSubType(); + } + + @Override + public void setLine1(String p) { + con.setLine1(p); + } + + @Override + public void setLine2(String p) { + con.setLine2(p); + } + + @Override + public void setPlayerList(List p) { + con.setPlayerList(p); + } + + @Override + public void setPlayerList(String... p) { + con.setPlayerList(p); + } + + @Override + public void setBitmap(int[] p) { + con.setBitmap(p); + } + + @Override + public void setOnlinePlayers(int i) { + con.setOnlinePlayers(i); + } + + @Override + public void setMaxPlayers(int i) { + con.setMaxPlayers(i); + } + + @Override + public void setKeepAlive(boolean b) { + con.setKeepAlive(b); + } + + @Override + public int getDefaultMaxPlayers() { + return con.getListener().getMaxPlayer(); + } + + @Override + public int getDefaultOnlinePlayers() { + return 0; + } + + @Override + public List getDefaultOnlinePlayersList(int maxLen) { + Collection ppl = EaglerMOTDPluginVelocity.proxy().getAllPlayers(); + List players = new ArrayList(Math.min(ppl.size(), maxLen + 1)); + for(Player pp : ppl) { + players.add(pp.getUsername()); + if(players.size() >= maxLen) { + players.add("\u00A77\u00A7o(" + (ppl.size() - players.size()) + " more)"); + break; + } + } + return players; + } + +} diff --git a/src/main/java/net/lax1dude/eaglercraft/v1_8/plugin/eaglermotd/velocity/EaglerMOTDListenerVelocity.java b/src/main/java/net/lax1dude/eaglercraft/v1_8/plugin/eaglermotd/velocity/EaglerMOTDListenerVelocity.java new file mode 100644 index 0000000..ffc403b --- /dev/null +++ b/src/main/java/net/lax1dude/eaglercraft/v1_8/plugin/eaglermotd/velocity/EaglerMOTDListenerVelocity.java @@ -0,0 +1,52 @@ +package net.lax1dude.eaglercraft.v1_8.plugin.eaglermotd.velocity; + +import com.velocitypowered.api.event.Subscribe; + +import net.lax1dude.eaglercraft.v1_8.plugin.eaglermotd.EaglerMOTDConnectionUpdater; +import net.lax1dude.eaglercraft.v1_8.plugin.gateway_velocity.api.event.EaglercraftMOTDEvent; + +/** + * Copyright (c) 2024 lax1dude. All Rights Reserved. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + */ +public class EaglerMOTDListenerVelocity { + + private final EaglerMOTDPluginVelocity plugin; + + public EaglerMOTDListenerVelocity(EaglerMOTDPluginVelocity plugin) { + this.plugin = plugin; + } + + @Subscribe + public void handleMOTDEvent(EaglercraftMOTDEvent evt) { + if(!evt.getAccept().equalsIgnoreCase("motd") && !evt.getAccept().equalsIgnoreCase("motd.noicon")) { + return; + } + EaglerMOTDConnectionUpdater con = new EaglerMOTDConnectionUpdater(plugin.conf, + EaglerMOTDPluginVelocity.getListenerName(evt.getListener()), evt.getListener().getMaxPlayer(), + new EaglerMOTDConnectionVelocity(evt.getConnection())); + if(con.execute()) { + synchronized(plugin.motdConnections) { + if(plugin.conf.max_total_sockets > 0) { + while(plugin.motdConnections.size() >= plugin.conf.max_total_sockets) { + EaglerMOTDConnectionUpdater c = plugin.motdConnections.remove(plugin.motdConnections.size() - 1); + c.close(); + } + } + plugin.motdConnections.add(0, con); + } + } + } + +} diff --git a/src/main/java/net/lax1dude/eaglercraft/v1_8/plugin/eaglermotd/velocity/EaglerMOTDPluginVelocity.java b/src/main/java/net/lax1dude/eaglercraft/v1_8/plugin/eaglermotd/velocity/EaglerMOTDPluginVelocity.java new file mode 100644 index 0000000..bf1cf65 --- /dev/null +++ b/src/main/java/net/lax1dude/eaglercraft/v1_8/plugin/eaglermotd/velocity/EaglerMOTDPluginVelocity.java @@ -0,0 +1,228 @@ +package net.lax1dude.eaglercraft.v1_8.plugin.eaglermotd.velocity; + +import java.io.File; +import java.io.IOException; +import java.net.Inet6Address; +import java.net.InetAddress; +import java.net.InetSocketAddress; +import java.nio.file.Path; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Iterator; +import java.util.LinkedList; +import java.util.List; +import java.util.Timer; +import java.util.TimerTask; + +import org.slf4j.Logger; + +import com.google.inject.Inject; +import com.velocitypowered.api.command.CommandManager; +import com.velocitypowered.api.event.Subscribe; +import com.velocitypowered.api.event.proxy.ProxyInitializeEvent; +import com.velocitypowered.api.event.proxy.ProxyShutdownEvent; +import com.velocitypowered.api.plugin.Dependency; +import com.velocitypowered.api.plugin.Plugin; +import com.velocitypowered.api.plugin.annotation.DataDirectory; +import com.velocitypowered.api.proxy.ProxyServer; + +import net.lax1dude.eaglercraft.v1_8.plugin.eaglermotd.EaglerMOTDConfiguration; +import net.lax1dude.eaglercraft.v1_8.plugin.eaglermotd.EaglerMOTDConnectionUpdater; +import net.lax1dude.eaglercraft.v1_8.plugin.eaglermotd.EaglerMOTDLoggerAdapter; +import net.lax1dude.eaglercraft.v1_8.plugin.eaglermotd.velocity.command.CommandMOTDReloadVelocity; +import net.lax1dude.eaglercraft.v1_8.plugin.gateway_velocity.EaglerXVelocity; +import net.lax1dude.eaglercraft.v1_8.plugin.gateway_velocity.EaglerXVelocityVersion; +import net.lax1dude.eaglercraft.v1_8.plugin.gateway_velocity.api.query.EaglerQueryHandler; +import net.lax1dude.eaglercraft.v1_8.plugin.gateway_velocity.command.EaglerCommand; +import net.lax1dude.eaglercraft.v1_8.plugin.gateway_velocity.config.EaglerListenerConfig; + +/** + * Copyright (c) 2024 lax1dude. All Rights Reserved. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + */ +@Plugin( + id = EaglerMOTDPluginVersion.ID, + name = EaglerMOTDPluginVersion.NAME, + description = EaglerMOTDPluginVersion.DESCRIPTION, + version = EaglerMOTDPluginVersion.VERSION, + authors = { + EaglerMOTDPluginVersion.AUTHOR + }, + dependencies = { + @Dependency( + id = EaglerXVelocityVersion.PLUGIN_ID, + optional = false + ) + } +) +public class EaglerMOTDPluginVelocity { + + private static EaglerMOTDPluginVelocity instance = null; + private final ProxyServer proxy; + private final Logger logger; + private final Path dataDirAsPath; + private final File dataDir; + + public final EaglerMOTDConfiguration conf = new EaglerMOTDConfiguration(); + public final List motdConnections = new LinkedList(); + public final EaglerMOTDLoggerAdapter loggerAdapter; + private Timer tickTimer = null; + private final List installedQueries = new ArrayList(); + + @Inject + public EaglerMOTDPluginVelocity(ProxyServer proxyIn, Logger loggerIn, @DataDirectory Path dataDirIn) { + instance = this; + proxy = proxyIn; + logger = loggerIn; + dataDirAsPath = dataDirIn; + dataDir = dataDirIn.toFile(); + loggerAdapter = new EaglerMOTDLoggerAdapter() { + @Override + public void info(String msg) { + EaglerMOTDPluginVelocity.this.logger.info(msg); + } + + @Override + public void warn(String msg) { + EaglerMOTDPluginVelocity.this.logger.warn(msg); + } + + @Override + public void error(String msg) { + EaglerMOTDPluginVelocity.this.logger.error(msg); + } + }; + } + + public void reloadConfig() { + if(!dataDir.isDirectory() && !dataDir.mkdirs()) { + throw new RuntimeException("Could not create config folder!"); + } + + try { + conf.reload(dataDir, loggerAdapter, getListenerNames()); + }catch(IOException ex) { + throw new RuntimeException("Could not reload config!", ex); + } + } + + public void installQueryHandlers() { + for(String str : conf.queryTypes.keySet()) { + EaglerQueryHandler.registerQueryType(str, EaglerMOTDQueryHandlerVelocity.class); + installedQueries.add(str); + } + } + + public void removeQueryHandlers() { + for(String str : installedQueries) { + EaglerQueryHandler.unregisterQueryType(str); + } + installedQueries.clear(); + } + + public Collection getListenerNames() { + Collection figs = EaglerXVelocity.getEagler().getConfig().getServerListeners(); + Collection ret = new ArrayList(figs.size()); + for(EaglerListenerConfig el : figs) { + ret.add(getListenerName(el)); + } + return ret; + } + + public static String getListenerName(EaglerListenerConfig listenerConf) { + InetSocketAddress sockAddr = listenerConf.getAddress(); + if(sockAddr == null) { + sockAddr = listenerConf.getAddressV6(); + if(sockAddr == null) { + throw new RuntimeException("Listener doesn't have an address: " + listenerConf); + } + } + InetAddress addr = sockAddr.getAddress(); + if(addr instanceof Inet6Address) { + return "[" + addr.getHostAddress() + "]:" + sockAddr.getPort(); + }else { + return addr.getHostAddress() + ":" + sockAddr.getPort(); + } + } + + @Subscribe + public void onProxyInit(ProxyInitializeEvent e) { + reloadConfig(); + proxy.getEventManager().register(this, new EaglerMOTDListenerVelocity(this)); + registerCommand(new CommandMOTDReloadVelocity(this)); + installQueryHandlers(); + if(tickTimer == null) { + tickTimer = new Timer("MOTD Tick Timer"); + tickTimer.scheduleAtFixedRate(new TimerTask() { + @Override + public void run() { + synchronized(motdConnections) { + Iterator itr = motdConnections.iterator(); + while(itr.hasNext()) { + EaglerMOTDConnectionUpdater c = itr.next(); + try { + if(!c.tick()) { + itr.remove(); + } + }catch(Throwable t) { + EaglerMOTDPluginVelocity.this.getLogger().error("Error ticking MOTD '" + (c.currentMessage == null ? "null" : c.currentMessage.name) + "' on listener " + c.listenerName, t); + c.close(); + itr.remove(); + } + } + } + } + + }, 0, 50l); + } + } + + @Subscribe + public void onProxyShutdown(ProxyShutdownEvent e) { + removeQueryHandlers(); + if(tickTimer != null) { + tickTimer.cancel(); + tickTimer = null; + } + } + + private void registerCommand(EaglerCommand cmd) { + CommandManager cmdManager = proxy.getCommandManager(); + cmdManager.register(cmdManager.metaBuilder(cmd.name).aliases(cmd.alias).plugin(this).build(), cmd); + } + + public ProxyServer getProxy() { + return proxy; + } + + public Logger getLogger() { + return logger; + } + + public File getDataFolder() { + return dataDir; + } + + public static EaglerMOTDPluginVelocity getPlugin() { + return instance; + } + + public static ProxyServer proxy() { + return instance.proxy; + } + + public static Logger logger() { + return instance.logger; + } +} diff --git a/src/main/java/net/lax1dude/eaglercraft/v1_8/plugin/eaglermotd/velocity/EaglerMOTDPluginVersion.java b/src/main/java/net/lax1dude/eaglercraft/v1_8/plugin/eaglermotd/velocity/EaglerMOTDPluginVersion.java new file mode 100644 index 0000000..aa7aecc --- /dev/null +++ b/src/main/java/net/lax1dude/eaglercraft/v1_8/plugin/eaglermotd/velocity/EaglerMOTDPluginVersion.java @@ -0,0 +1,26 @@ +package net.lax1dude.eaglercraft.v1_8.plugin.eaglermotd.velocity; + +/** + * Copyright (c) 2024 lax1dude. All Rights Reserved. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + */ +public class EaglerMOTDPluginVersion { + + public static final String ID = "eaglermotd"; + public static final String NAME = "EaglerMOTD"; + public static final String DESCRIPTION = "Plugin to add an animated MOTDs to your EaglercraftXVelocity server"; + public static final String VERSION = "1.1.0"; + public static final String AUTHOR = "lax1dude"; + +} diff --git a/src/main/java/net/lax1dude/eaglercraft/v1_8/plugin/eaglermotd/velocity/EaglerMOTDQueryHandlerVelocity.java b/src/main/java/net/lax1dude/eaglercraft/v1_8/plugin/eaglermotd/velocity/EaglerMOTDQueryHandlerVelocity.java new file mode 100644 index 0000000..87219cc --- /dev/null +++ b/src/main/java/net/lax1dude/eaglercraft/v1_8/plugin/eaglermotd/velocity/EaglerMOTDQueryHandlerVelocity.java @@ -0,0 +1,58 @@ +package net.lax1dude.eaglercraft.v1_8.plugin.eaglermotd.velocity; + +import com.google.gson.JsonObject; + +import net.lax1dude.eaglercraft.v1_8.plugin.eaglermotd.EaglerMOTDQueryResponseAdapter; +import net.lax1dude.eaglercraft.v1_8.plugin.eaglermotd.QueryType; +import net.lax1dude.eaglercraft.v1_8.plugin.gateway_velocity.api.query.EaglerQuerySimpleHandler; + +/** + * Copyright (c) 2024 lax1dude. All Rights Reserved. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + */ +public class EaglerMOTDQueryHandlerVelocity extends EaglerQuerySimpleHandler implements EaglerMOTDQueryResponseAdapter { + + @Override + protected void begin(String queryType) { + if(this.isClosed()) { + return; + } + try { + QueryType queryHandler = EaglerMOTDPluginVelocity.getPlugin().conf.queryTypes.get(queryType.toLowerCase()); + if(queryHandler != null) { + queryHandler.doQuery(this); + } + }catch(Throwable t) { + EaglerMOTDPluginVelocity.logger().error("Failed to handle query type \"" + queryType + "\"!", t); + }finally { + this.close(); + } + } + + @Override + public void stringResponse(String type, String str) { + this.sendStringResponse(type, str); + } + + @Override + public void jsonResponse(String type, JsonObject json) { + this.sendJsonResponse(type, json); + } + + @Override + public void sendBinary(byte[] bin) { + this.sendBinaryResponse(bin); + } + +} diff --git a/src/main/java/net/lax1dude/eaglercraft/v1_8/plugin/eaglermotd/velocity/command/CommandMOTDReloadVelocity.java b/src/main/java/net/lax1dude/eaglercraft/v1_8/plugin/eaglermotd/velocity/command/CommandMOTDReloadVelocity.java new file mode 100644 index 0000000..a6bdd93 --- /dev/null +++ b/src/main/java/net/lax1dude/eaglercraft/v1_8/plugin/eaglermotd/velocity/command/CommandMOTDReloadVelocity.java @@ -0,0 +1,74 @@ +package net.lax1dude.eaglercraft.v1_8.plugin.eaglermotd.velocity.command; + +import com.velocitypowered.api.command.CommandSource; +import com.velocitypowered.api.proxy.ConsoleCommandSource; + +import net.kyori.adventure.text.Component; +import net.kyori.adventure.text.format.NamedTextColor; +import net.lax1dude.eaglercraft.v1_8.plugin.eaglermotd.EaglerMOTDLoggerAdapter; +import net.lax1dude.eaglercraft.v1_8.plugin.eaglermotd.velocity.EaglerMOTDPluginVelocity; +import net.lax1dude.eaglercraft.v1_8.plugin.gateway_velocity.command.EaglerCommand; + +/** + * Copyright (c) 2024 lax1dude. All Rights Reserved. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + */ +public class CommandMOTDReloadVelocity extends EaglerCommand { + + private final EaglerMOTDPluginVelocity plugin; + + public CommandMOTDReloadVelocity(EaglerMOTDPluginVelocity plugin) { + super("motd-reload", "eaglermotd.command.reload"); + this.plugin = plugin; + } + + @Override + public void execute(CommandSource arg0, String[] arg1) { + try { + plugin.removeQueryHandlers(); + plugin.conf.reload(plugin.getDataFolder(), new EaglerMOTDLoggerAdapter() { + @Override + public void info(String msg) { + CommandMOTDReloadVelocity.this.plugin.getLogger().info(msg); + if(!(arg0 instanceof ConsoleCommandSource)) { + arg0.sendMessage(Component.text("[EaglerMOTD] " + msg, NamedTextColor.GREEN)); + } + } + + @Override + public void warn(String msg) { + CommandMOTDReloadVelocity.this.plugin.getLogger().warn(msg); + if(!(arg0 instanceof ConsoleCommandSource)) { + arg0.sendMessage(Component.text("[EaglerMOTD] " + msg, NamedTextColor.YELLOW)); + } + } + + @Override + public void error(String msg) { + CommandMOTDReloadVelocity.this.plugin.getLogger().error(msg); + if(!(arg0 instanceof ConsoleCommandSource)) { + arg0.sendMessage(Component.text("[EaglerMOTD] " + msg, NamedTextColor.RED)); + } + } + }, plugin.getListenerNames()); + plugin.installQueryHandlers(); + }catch(Throwable ex) { + if(!(arg0 instanceof ConsoleCommandSource)) { + arg0.sendMessage(Component.text("[EaglerMOTD] Failed to reload! " + ex.toString(), NamedTextColor.RED)); + } + plugin.getLogger().error("Exception thrown while reloading config!", ex); + } + } + +}