added version checker + fixed redis connection and added useSSL

LightningDesign · LightningDesign · commit 7227d9b75559 · 2025-03-02T09:39:24.000+01:00
diff --git a/build.gradle.kts b/build.gradle.kts
@@ -7,7 +7,7 @@ plugins {
 }
 
 group = "io.lightstudios.core"
-version = "0.4.5"
+version = "0.4.6"
 
 repositories {
     mavenCentral()
diff --git a/src/main/java/io/lightstudios/core/LightCore.java b/src/main/java/io/lightstudios/core/LightCore.java
@@ -12,6 +12,7 @@
 import io.lightstudios.core.database.model.ConnectionProperties;
 import io.lightstudios.core.database.model.DatabaseCredentials;
 import io.lightstudios.core.economy.EconomyManager;
+import io.lightstudios.core.github.VersionChecker;
 import io.lightstudios.core.inventory.events.MenuEvent;
 import io.lightstudios.core.items.LightItem;
 import io.lightstudios.core.items.events.UpdateLightItem;
@@ -33,7 +34,6 @@
 import io.lightstudios.core.util.files.configs.CoreSettings;
 import io.lightstudios.core.util.interfaces.LightCommand;
 import io.lightstudios.core.world.WorldManager;
-import io.lightstudios.core.world.events.BlockPlacedByPlayer;
 import lombok.Getter;
 import org.bstats.bukkit.Metrics;
 import org.bukkit.Bukkit;
@@ -65,6 +65,7 @@ public class LightCore extends JavaPlugin {
     private HookManager hookManager;
     private EconomyManager economyManager;
     private WorldManager worldManager;
+    private VersionChecker versionChecker;
 
     private FileManager coreFile;
     private FileManager messageFile;
@@ -129,6 +130,12 @@ public void onEnable() {
         // automatically checks for LightCoins as economy plugin or use the default vault economy as provider
         // used in all of my plugins
         this.economyManager = new EconomyManager();
+        // GitHub version checker for all my “Light” plugin series
+
+        if(this.settings.checkForUpdates()) {
+            this.versionChecker = new VersionChecker();
+        }
+
 
         // on success loading the core module
         this.lightCoreEnabled = true;
@@ -319,6 +326,18 @@ public void registerCommands() {
     public void reloadCore() {
         generateCoreFiles();
         this.consolePrinter.printInfo("Reloaded the core files.");
+
+        if (!this.settings.checkForUpdates()) {
+            if (this.versionChecker != null) {
+                this.versionChecker.getScheduler().shutdown();
+            }
+            this.versionChecker = null;
+        } else {
+            if(this.versionChecker == null) {
+                this.consolePrinter.printInfo("Enable version checker after reload.");
+                this.versionChecker = new VersionChecker();
+            }
+        }
     }
 
     private void enableRedisConnection() {
@@ -328,7 +347,8 @@ private void enableRedisConnection() {
             this.redisManager = new RedisManager(
                     settings.redisHost(),
                     settings.redisPort(),
-                    settings.redisPassword()
+                    settings.redisPassword(),
+                    settings.redisUseSSL()
             );
             this.isRedis = true;
             return;
@@ -342,7 +362,7 @@ public void readCoreItems() {
 
         List<File> files = itemFiles.getYamlFiles();
         if(files.isEmpty()) {
-            getConsolePrinter().printError(List.of(
+            getConsolePrinter().printWarning(List.of(
                     "No item files found in the items folder.",
                     "Skipping this part ..."));
             return;
diff --git a/src/main/java/io/lightstudios/core/github/GithubVersionManager.java b/src/main/java/io/lightstudios/core/github/GithubVersionManager.java
@@ -0,0 +1,67 @@
+package io.lightstudios.core.github;
+
+import io.lightstudios.core.LightCore;
+import org.jetbrains.annotations.NotNull;
+import org.json.JSONObject;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.net.HttpURLConnection;
+import java.net.URI;
+import java.net.URL;
+import java.util.concurrent.CompletableFuture;
+
+public class GithubVersionManager {
+
+    private final String GITHUB_API_URL;
+    private final String currentVersion;
+
+    /**
+     * Create a new GithubVersionManager instance with the plugin name and the current version.
+     * @param pluginName the name of the plugin (Case sensitive)
+     * @param currentVersion the current version of the plugin
+     */
+    public GithubVersionManager(String pluginName, String currentVersion) {
+        this.currentVersion = currentVersion;
+        this.GITHUB_API_URL = "https://api.github.com/repos/lightPlugins/" + pluginName + "/releases/latest";
+    }
+
+    public CompletableFuture<String> getLatestVersionAsync() {
+        return CompletableFuture.supplyAsync(() -> {
+            try {
+                URI uri = new URI(GITHUB_API_URL);
+                URL url = uri.toURL();
+                JSONObject jsonResponse = getJsonObject(url);
+                return jsonResponse.getString("tag_name");
+            } catch (Exception e) {
+                LightCore.instance.getConsolePrinter().printError("Could not check for plugin updates: " + e.getMessage());
+                return null;
+            }
+        });
+    }
+
+    private @NotNull JSONObject getJsonObject(URL url) throws IOException {
+        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
+        connection.setRequestMethod("GET");
+        BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
+        StringBuilder response = new StringBuilder();
+        String inputLine;
+        while ((inputLine = in.readLine()) != null) {
+            response.append(inputLine);
+        }
+        in.close();
+        return new JSONObject(response.toString());
+    }
+
+    public CompletableFuture<UpdateCheckResult> isUpdateAvailableAsync() {
+        return getLatestVersionAsync().thenApply(latestVersion -> {
+            boolean updateAvailable = latestVersion != null && !latestVersion.equals(currentVersion);
+            return new UpdateCheckResult(updateAvailable, latestVersion);
+        });
+    }
+
+    public record UpdateCheckResult(boolean updateAvailable, String latestVersion) {
+
+    }
+}
diff --git a/src/main/java/io/lightstudios/core/github/VersionChecker.java b/src/main/java/io/lightstudios/core/github/VersionChecker.java
@@ -0,0 +1,81 @@
+package io.lightstudios.core.github;
+
+import io.lightstudios.core.LightCore;
+import io.lightstudios.core.github.checks.CheckLightCoins;
+import io.lightstudios.core.github.checks.CheckLightCore;
+import lombok.Getter;
+
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+
+@Getter
+public class VersionChecker {
+
+    private final CheckLightCore checkLightCore;
+    private final CheckLightCoins checkLightCoins;
+    private final ScheduledExecutorService scheduler;
+
+    public VersionChecker() {
+        this.checkLightCore = new CheckLightCore();
+        this.checkLightCoins = new CheckLightCoins();
+        this.scheduler = Executors.newScheduledThreadPool(1);
+        scheduleUpdateChecks();
+    }
+
+    private void scheduleUpdateChecks() {
+        scheduler.scheduleAtFixedRate(this::checkForUpdates, 0, 2, TimeUnit.HOURS);
+    }
+
+    private void checkForUpdates() {
+        LightCore.instance.getLogger().info("Checking for plugin updates...");
+
+        CompletableFuture<GithubVersionManager.UpdateCheckResult> lightCore =
+                this.checkLightCore.getVersionManager().isUpdateAvailableAsync();
+        CompletableFuture<GithubVersionManager.UpdateCheckResult> lightCoins =
+                this.checkLightCoins.getVersionManager().isUpdateAvailableAsync();
+
+        // check for lightCore updates
+        lightCore.thenAccept(result -> {
+            if (result.updateAvailable()) {
+                LightCore.instance.getConsolePrinter().printInfo(List.of(
+                        "An update is available for " + this.checkLightCore.getPluginName() + "!",
+                        "Latest version: " + result.latestVersion(),
+                        "Your version: " + this.checkLightCore.getCurrentVersion(),
+                        "Download it here: https://github.com/lightPlugins/lightCore/releases"
+                ));
+            } else {
+                LightCore.instance.getConsolePrinter().printInfo(this.checkLightCore.getPluginName() + " is up to date!");
+            }
+        }).exceptionally(ex -> {
+            LightCore.instance.getConsolePrinter().printError(List.of(
+                    "Failed to check for updates for " + this.checkLightCore.getPluginName() + "!",
+                    "Error: " + ex.getMessage()
+            ));
+            return null;
+        });
+
+        // check for lightCoins updates
+        lightCoins.thenAccept(result -> {
+            if (result.updateAvailable()) {
+                LightCore.instance.getConsolePrinter().printInfo(List.of(
+                        "An update is available for " + this.checkLightCoins.getPluginName() + "!",
+                        "Latest version: " + result.latestVersion(),
+                        "Your version: " + this.checkLightCoins.getCurrentVersion(),
+                        "Download it here: https://www.spigotmc.org/resources/83862"
+                ));
+            } else {
+                LightCore.instance.getConsolePrinter().printInfo(this.checkLightCoins.getPluginName() + " is up to date!");
+            }
+        }).exceptionally(ex -> {
+            LightCore.instance.getConsolePrinter().printError(List.of(
+                    "Failed to check for updates for " + this.checkLightCoins.getPluginName() + "!",
+                    "Error: " + ex.getMessage()
+            ));
+            return null;
+        });
+    }
+
+}
diff --git a/src/main/java/io/lightstudios/core/github/checks/CheckLightCoins.java b/src/main/java/io/lightstudios/core/github/checks/CheckLightCoins.java
@@ -0,0 +1,25 @@
+package io.lightstudios.core.github.checks;
+
+import io.lightstudios.coins.LightCoins;
+import io.lightstudios.core.LightCore;
+import io.lightstudios.core.github.GithubVersionManager;
+import lombok.Getter;
+
+@Getter
+public class CheckLightCoins {
+
+    private final String currentVersion;
+    private final String pluginName = "lightCoins";
+    private final GithubVersionManager versionManager;
+
+    public CheckLightCoins() {
+        if (LightCore.instance.getHookManager().isExistLightCoins()) {
+            LightCoins lightCoins = LightCoins.instance;
+            this.currentVersion = lightCoins.getDescription().getVersion();
+            this.versionManager = new GithubVersionManager(pluginName, currentVersion);
+        } else {
+            this.currentVersion = null;
+            this.versionManager = null;
+        }
+    }
+}
diff --git a/src/main/java/io/lightstudios/core/github/checks/CheckLightCore.java b/src/main/java/io/lightstudios/core/github/checks/CheckLightCore.java
@@ -0,0 +1,17 @@
+package io.lightstudios.core.github.checks;
+import io.lightstudios.core.LightCore;
+import io.lightstudios.core.github.GithubVersionManager;
+import lombok.Getter;
+
+@Getter
+public class CheckLightCore {
+
+    private final String currentVersion;
+    private final GithubVersionManager versionManager;
+    private final String pluginName = "lightCore";
+
+    public CheckLightCore() {
+        this.currentVersion = LightCore.instance.getDescription().getVersion();
+        this.versionManager = new GithubVersionManager(pluginName, currentVersion);
+    }
+}
diff --git a/src/main/java/io/lightstudios/core/redis/RedisManager.java b/src/main/java/io/lightstudios/core/redis/RedisManager.java
@@ -4,36 +4,49 @@
 import lombok.Getter;
 import redis.clients.jedis.Jedis;
 import redis.clients.jedis.JedisPool;
-import redis.clients.jedis.JedisPooled;
+import redis.clients.jedis.JedisPoolConfig;
 
-import java.net.URI;
-import java.net.URISyntaxException;
+import java.util.List;
 
 @Getter
 public class RedisManager {
 
-    private final JedisPool jedisPool;
+    private JedisPool jedisPool = null;
 
     /**
      * Create a new RedisManager instance with redis credentials
      * from the core config.
      * @param host the host of the Redis server
      * @param port the port of the Redis server
      * @param password the password of the Redis server
+     * @param useSSL if the Redis server uses SSL
      */
-    public RedisManager(String host, int port, String password) {
+    public RedisManager(String host, int port, String password, boolean useSSL) {
         try {
-            this.jedisPool = new JedisPool("localhost", 6379);
+            JedisPoolConfig poolConfig = new JedisPoolConfig();
+            if (password == null || password.isEmpty()) {
+                this.jedisPool = new JedisPool(poolConfig, host, port, 0, null, useSSL);
+            } else {
+                this.jedisPool = new JedisPool(poolConfig, host, port, 0, password, useSSL);
+            }
         } catch (Exception e) {
-            throw new RuntimeException("Invalid Redis URI", e);
+            LightCore.instance.getConsolePrinter().printError(List.of(
+                    "Could not connect Redis server on " + host + ":" + port + ". ",
+                    "Please check your credentials in the core.yml from LightCore.",
+                    "Error: " + e.getMessage()
+            ));
+            return;
         }
 
         // test the connection to the Redis server
         if (testConnection()) {
-            LightCore.instance.getConsolePrinter().printInfo("Connected successfully to the provided Redis server.");
+            LightCore.instance.getConsolePrinter().printInfo("Connection to Redis server on " + host + ":" + port + " was successful!");
         } else {
-            throw new RuntimeException("Could not connect to the provided Redis server with params: "
-                    + host + ":" + port + " and password: " + password);
+            LightCore.instance.getConsolePrinter().printError(List.of(
+                    "Could not connect Redis server on " + host + ":" + port + ". ",
+                    "Please check your credentials in the core.yml from LightCore.",
+                    "Error: &4Test connection failed!"
+            ));
         }
     }
 
@@ -46,7 +59,13 @@ private boolean testConnection() {
             String response = jedis.ping();
             return "PONG".equals(response);
         } catch (Exception e) {
-            throw new RuntimeException("Could not connect to the provided Redis server", e);
+            LightCore.instance.getConsolePrinter().printError(List.of(
+                    "Could not receive a PONG result from your Redis server!",
+                    "Please check your credentials in the core.yml from LightCore",
+                    "or check if your Redis server is running correctly.",
+                    "Error: " + e.getMessage()
+            ));
+            return false;
         }
     }
 
@@ -56,6 +75,7 @@ private boolean testConnection() {
     public void close() {
         if (jedisPool != null) {
             jedisPool.close();
+            LightCore.instance.getConsolePrinter().printInfo("Redis connection closed!");
         }
     }
 }
diff --git a/src/main/java/io/lightstudios/core/util/ConsolePrinter.java b/src/main/java/io/lightstudios/core/util/ConsolePrinter.java
@@ -26,6 +26,18 @@ public void printInfo(List<String> messages) {
         sendEmptyLine();
     }
 
+    public void printWarning(String message) {
+        Bukkit.getConsoleSender().sendMessage(prefix + "§8[§6WARNING§8] §e" + message);
+    }
+
+    public void printWarning(List<String> messages) {
+        sendEmptyLine();
+        for (String message : messages) {
+            Bukkit.getConsoleSender().sendMessage(prefix + "§8[§6WARNING§8] §e" + message);
+        }
+        sendEmptyLine();
+    }
+
     public void printError(String message) {
         Bukkit.getConsoleSender().sendMessage(prefix + "§8[§4ERROR§8] §c" + message);
     }
diff --git a/src/main/java/io/lightstudios/core/util/files/configs/CoreSettings.java b/src/main/java/io/lightstudios/core/util/files/configs/CoreSettings.java
@@ -44,8 +44,11 @@ public String syncType() {
     public String redisHost() { return config.getString("server-synchronisation.redis.host"); }
     public int redisPort() { return config.getInt("server-synchronisation.redis.port"); }
     public String redisPassword() { return config.getString("server-synchronisation.redis.password"); }
+    public boolean redisUseSSL() { return config.getBoolean("server-synchronisation.redis.useSSL"); }
     public String serverName() { return config.getString("server-synchronisation.server-name"); }
 
+    public boolean checkForUpdates() { return config.getBoolean("checkForUpdates"); }
+
     //protections
     public boolean protectionCommandCooldownEnable() { return config.getBoolean("protections.commandCooldown.enable"); }
     public long protectionCommandCooldownTime() { return config.getLong("protections.commandCooldown.cooldown"); }
diff --git a/src/main/resources/core.yml b/src/main/resources/core.yml
diff --git a/src/main/resources/plugin.yml b/src/main/resources/plugin.yml

Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ plugins {`
`7`	`7`	`}`
`8`	`8`
`9`	`9`	`group = "io.lightstudios.core"`
`10`		`-version = "0.4.5"`
	`10`	`+version = "0.4.6"`
`11`	`11`
`12`	`12`	`repositories {`
`13`	`13`	`mavenCentral()`