Add multiple instances support, improve event handling

Author: MrApik

pom.xml

@@ -6,7 +6,7 @@
 
     <groupId>org.example</groupId>
     <artifactId>ForestRedisAPI</artifactId>
-    <version>1.0.6</version>
+    <version>1.0.7</version>
 
     <properties>
         <maven.compiler.source>11</maven.compiler.source>

src/main/java/cz/foresttech/forestredis/shared/IForestRedisPlugin.java

@@ -26,7 +26,7 @@ public interface IForestRedisPlugin {
     /**
      * Calls the corresponding events when message was received
      *
-     * @param channel   Channel which received the message
+     * @param channel               Channel which received the message
      * @param messageTransferObject {@link MessageTransferObject} which was received
      */
     void onMessageReceived(String channel, MessageTransferObject messageTransferObject);
@@ -36,7 +36,7 @@ public interface IForestRedisPlugin {
     /**
      * Returns logger object
      *
-     * @return  Logger instance of the current implementation
+     * @return Logger instance of the current implementation
      */
     Logger logger();
 
@@ -45,7 +45,7 @@ public interface IForestRedisPlugin {
     /**
      * Returns the {@link IConfigurationAdapter} implementation
      *
-     * @return  Implementation of {@link IConfigurationAdapter}
+     * @return Implementation of {@link IConfigurationAdapter}
      */
     default IConfigurationAdapter getConfigAdapter() {
         return null;
@@ -86,18 +86,30 @@ default void load() {
                 configAdapter.getBoolean("redis.ssl", false)
         );
 
-        // Initialize RedisManager object
-        RedisManager.init(this, serverIdentifier, redisConfiguration);
 
         // Setup the RedisManager
         List<String> channels = configAdapter.getStringList("channels");
-        if (channels.isEmpty()) {
-            RedisManager.getAPI().setup();
+
+        // Initialize RedisManager object
+        if (RedisManager.getAPI() == null) {
+            RedisManager.init(this, serverIdentifier, redisConfiguration);
+            if (channels.isEmpty()) {
+                RedisManager.getAPI().setup();
+                return;
+            }
+
+            String[] channelsArray = channels.toArray(new String[0]);
+            RedisManager.getAPI().setup(channelsArray);
             return;
         }
 
-        String[] channelsArray = channels.toArray(new String[0]);
-        RedisManager.getAPI().setup(channelsArray);
+        // Reload the RedisManager if already initialized
+        RedisManager.getAPI().reload(serverIdentifier, redisConfiguration, true);
+        if (!channels.isEmpty()) {
+            String[] channelsArray = channels.toArray(new String[0]);
+            RedisManager.getAPI().subscribe(channelsArray);
+        }
+
     }
 
     /*----------------------------------------------------------------------------------------------------------*/

src/main/java/cz/foresttech/forestredis/shared/RedisManager.java

@@ -4,9 +4,7 @@
 import cz.foresttech.forestredis.shared.models.RedisConfiguration;
 import redis.clients.jedis.*;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
+import java.util.*;
 
 /**
  * Class for maintaining and handling connection to Redis server.
@@ -17,7 +15,7 @@
 public class RedisManager {
 
     /**
-     * Singleton instance
+     * Main instance
      */
     private static RedisManager api;
 
@@ -29,17 +27,17 @@ public class RedisManager {
     /**
      * Configuration object to store credentials
      */
-    private final RedisConfiguration redisConfiguration;
+    private RedisConfiguration redisConfiguration;
 
     /**
      * Current server's identifier. Shall be unique across your network.
      */
-    private final String serverIdentifier;
+    private String serverIdentifier;
 
     /**
-     * List of subscribed channels
+     * Set of subscribed channels
      */
-    private final List<String> channels;
+    private final HashSet<String> channels;
 
     /**
      * List of current subscriptions
@@ -66,7 +64,7 @@ public class RedisManager {
      * @param serverIdentifier   Identifier of the server (e.g. 'Bungee01'). Shall be unique to prevent bugs
      * @param redisConfiguration {@link RedisConfiguration} object with Redis server credentials
      */
-    private RedisManager(IForestRedisPlugin plugin, String serverIdentifier, RedisConfiguration redisConfiguration) {
+    public RedisManager(IForestRedisPlugin plugin, String serverIdentifier, RedisConfiguration redisConfiguration) {
         this.plugin = plugin;
         this.closing = false;
 
@@ -75,7 +73,37 @@ private RedisManager(IForestRedisPlugin plugin, String serverIdentifier, RedisCo
 
         this.subscriptions = new ArrayList<>();
 
-        this.channels = new ArrayList<>();
+        this.channels = new HashSet<>();
+    }
+
+    /*----------------------------------------------------------------------------------------------------------*/
+
+    /**
+     * Reloads the manager while keeping already subscribed channels if set.
+     *
+     * @param serverIdentifier  New server identifier (if null, already using server id will be used)
+     * @param redisConfiguration    New RedisConfiguration (if null, already using configuration will be used)
+     * @param keepChannels  Keep already subscribed channels
+     */
+    public void reload(String serverIdentifier, RedisConfiguration redisConfiguration, boolean keepChannels) {
+        this.close();
+        this.closing = false;
+
+        if (serverIdentifier != null) {
+            this.serverIdentifier = serverIdentifier;
+        }
+        if (redisConfiguration != null) {
+            this.redisConfiguration = redisConfiguration;
+        }
+
+        if (keepChannels) {
+            String[] channels = this.channels.toArray(String[]::new);
+            this.channels.clear();
+            this.setup(channels);
+            return;
+        }
+
+        this.setup();
     }
 
     /*----------------------------------------------------------------------------------------------------------*/
@@ -108,7 +136,7 @@ public boolean setup(String... channels) {
 
         // If channels were provided, add them to the list and subscribe to them
         if (channels != null && channels.length > 0) {
-            this.channels.addAll(List.of(channels));
+            this.channels.addAll(Set.of(channels));
 
             Subscription subscription = new Subscription(this.channels.toArray(new String[0]));
             this.plugin.runAsync(subscription);
@@ -137,14 +165,14 @@ public void unsubscribe(String... channels) {
         try {
             for (Subscription sub : this.subscriptions) {
                 sub.unsubscribe(channels);
-                this.plugin.logger().info("Successfully unsubscribed channels: " + Arrays.toString(channels) + "!");
             }
+            this.plugin.logger().info("Successfully unsubscribed channels: " + Arrays.toString(channels) + "!");
         } catch (Exception ex) {
             this.plugin.logger().warning("An error occurred while unsubscribing channels: " + Arrays.toString(channels) + "!");
             return;
         }
 
-        this.channels.removeAll(List.of(channels));
+        this.channels.removeAll(Set.of(channels));
     }
 
     /*----------------------------------------------------------------------------------------------------------*/
@@ -165,7 +193,7 @@ public boolean subscribe(String... channels) {
             return false;
         }
 
-        List<String> actualChannelsToAdd = new ArrayList<>();
+        Set<String> actualChannelsToAdd = new HashSet<>();
 
         for (String channel : channels) {
             if (this.channels.contains(channel) && channel != null) {
@@ -271,6 +299,8 @@ public void close() {
             }
         }
 
+        this.subscriptions.clear();
+
         if (this.jedisPool == null) {
             return;
         }
@@ -308,7 +338,7 @@ public boolean isSubscribed(String channel) {
      *
      * @return List of all subscribed channels (case-sensitive)
      */
-    public List<String> getSubscribedChannels() {
+    public Set<String> getSubscribedChannels() {
         return channels;
     }
 
@@ -386,7 +416,7 @@ public void onMessage(String channel, String message) {
     /*----------------------------------------------------------------------------------------------------------*/
 
     /**
-     * Initialization method for creating {@link RedisManager} singleton instance. This won't start any
+     * Initialization method for creating {@link RedisManager} main instance. This won't start any
      * connection or subscription.
      *
      * @param plugin             Origin plugin which tries to obtain the instance
@@ -400,10 +430,10 @@ public static void init(IForestRedisPlugin plugin, String serverIdentifier, Redi
     /*----------------------------------------------------------------------------------------------------------*/
 
     /**
-     * Gets the singleton instance of {@link RedisManager} object. This is the only
+     * Gets the main instance of {@link RedisManager} object. This is the only
      * recommended approach to access the API methods.
      *
-     * @return Singleton instance of {@link RedisManager}
+     * @return Main instance of {@link RedisManager}
      */
     public static RedisManager getAPI() {
         return api;

src/main/java/cz/foresttech/forestredis/spigot/ForestRedisSpigot.java

@@ -42,8 +42,12 @@ public void runAsync(Runnable task) {
 
     @Override
     public void onMessageReceived(String channel, MessageTransferObject messageTransferObject) {
-        Bukkit.getPluginManager().callEvent(new AsyncRedisMessageReceivedEvent(channel, messageTransferObject));
-        Bukkit.getScheduler().runTask(this, () -> Bukkit.getPluginManager().callEvent(new RedisMessageReceivedEvent(channel, messageTransferObject)));
+        AsyncRedisMessageReceivedEvent asyncRedisMessageReceivedEvent = new AsyncRedisMessageReceivedEvent(channel, messageTransferObject);
+        Bukkit.getPluginManager().callEvent(asyncRedisMessageReceivedEvent);
+
+        if (asyncRedisMessageReceivedEvent.isCancelled()) {
+            Bukkit.getScheduler().runTask(this, () -> Bukkit.getPluginManager().callEvent(new RedisMessageReceivedEvent(asyncRedisMessageReceivedEvent.getChannel(), asyncRedisMessageReceivedEvent.getMessageTransferObject())));
+        }
     }
 
     @Override
@@ -61,7 +65,7 @@ public IConfigurationAdapter getConfigAdapter() {
     /**
      * Obtains the instance of the plugin
      *
-     * @return  Instance of {@link ForestRedisSpigot}
+     * @return Instance of {@link ForestRedisSpigot}
      */
     public static ForestRedisSpigot getInstance() {
         return instance;

src/main/java/cz/foresttech/forestredis/spigot/events/AsyncRedisMessageReceivedEvent.java

@@ -3,24 +3,29 @@
 import cz.foresttech.forestredis.shared.events.IRedisMessageReceivedEvent;
 import cz.foresttech.forestredis.shared.models.MessageTransferObject;
 import cz.foresttech.forestredis.shared.RedisManager;
+import org.bukkit.event.Cancellable;
 import org.bukkit.event.Event;
 import org.bukkit.event.HandlerList;
 
 /**
  * Asynchronous Spigot Event class used when message was received from subscribed channel.
+ * <p>
+ * Data can be changed, so sync Spigot Event will be triggered with updated data
  */
-public class AsyncRedisMessageReceivedEvent extends Event implements IRedisMessageReceivedEvent {
+public class AsyncRedisMessageReceivedEvent extends Event implements IRedisMessageReceivedEvent, Cancellable {
     private static final HandlerList HANDLERS = new HandlerList();
 
+    private boolean cancelled;
+
     /**
      * Name of the channel the message came from
      */
-    private final String channel;
+    private String channel;
 
     /**
      * MessageTransferObject containing message's data
      */
-    private final MessageTransferObject messageTransferObject;
+    private MessageTransferObject messageTransferObject;
 
     /**
      * Constructs the instance of the Event
@@ -30,10 +35,23 @@ public class AsyncRedisMessageReceivedEvent extends Event implements IRedisMessa
      */
     public AsyncRedisMessageReceivedEvent(String channel, MessageTransferObject messageTransferObject) {
         super(true);
+        this.cancelled = false;
+        this.channel = channel;
+        this.messageTransferObject = messageTransferObject;
+    }
+
+    public void setChannel(String channel) {
         this.channel = channel;
+    }
+
+    public void setMessageTransferObject(MessageTransferObject messageTransferObject) {
         this.messageTransferObject = messageTransferObject;
     }
 
+    public MessageTransferObject getMessageTransferObject() {
+        return messageTransferObject;
+    }
+
     @Override
     public String getSenderIdentifier() {
         return this.messageTransferObject.getSenderIdentifier();
@@ -72,4 +90,14 @@ public HandlerList getHandlers() {
     public static HandlerList getHandlerList() {
         return HANDLERS;
     }
+
+    @Override
+    public boolean isCancelled() {
+        return cancelled;
+    }
+
+    @Override
+    public void setCancelled(boolean cancelled) {
+        this.cancelled = cancelled;
+    }
 }