Remove unneeded threadpool (testing has shown for it to be unneeded)

This reverts commit a08ecd93b7.

pom.xml

@@ -6,7 +6,7 @@
 
     <groupId>net.limework.core</groupId>
     <artifactId>RediSkript</artifactId>
-    <version>1.1.0</version>
+    <version>1.1.2</version>
     <packaging>jar</packaging>
 	
     <build>
@@ -64,12 +64,9 @@
             <url>https://jitpack.io</url>
         </repository>
         <repository>
-            <id>PaperMC</id>
+            <id>commons-pool2</id>
-            <url>https://repo.destroystokyo.com/repository/maven-public/</url>
+            <url>https://mvnrepository.com/artifact/org.apache.commons/commons-pool2</url>
-        </repository>
+
-		<repository>
-            <id>sk89q</id>
-            <url>http://maven.sk89q.com/repo</url>
         </repository>
     </repositories>
 
@@ -86,11 +83,6 @@
             <version>1.16.2-R0.1-SNAPSHOT</version>
             <scope>provided</scope>
         </dependency>
-    <dependency>
-        <groupId>com.google.code.gson</groupId>
-        <artifactId>gson</artifactId>
-        <version>2.8.6</version>
-    </dependency>
     <dependency>
         <groupId>redis.clients</groupId>
         <artifactId>jedis</artifactId>
@@ -106,11 +98,11 @@
         <artifactId>siv-mode</artifactId>
         <version>1.4.0</version>
     </dependency>
+    <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-pool2 -->
     <dependency>
-            <groupId>org.jetbrains</groupId>
+        <groupId>org.apache.commons</groupId>
-            <artifactId>annotations</artifactId>
+        <artifactId>commons-pool2</artifactId>
-            <version>19.0.0</version>
+        <version>2.6.2</version>
-            <scope>compile</scope>
     </dependency>
     </dependencies>
 </project>

src/main/java/net/limework/core/RediSkript.java

@@ -1,37 +1,42 @@
 package net.limework.core;
+import net.limework.core.commands.ReloadRedis;
 import net.limework.core.hooks.SkriptHook;
 import net.limework.core.managers.RedisManager;
+import org.bukkit.command.PluginCommand;
 import org.bukkit.plugin.java.JavaPlugin;
 
-import java.util.Objects;
-
 public class RediSkript extends JavaPlugin {
 
     //Redis manager
     private RedisManager rm;
 
-
+    public void startRedis(boolean reload) {
+        if (reload) { reloadConfig(); }
+        rm = new RedisManager(this);
+        rm.start();
+    }
     @Override
     public void onEnable() {
         saveDefaultConfig();
-        rm = new RedisManager(this);
-        Objects.requireNonNull(getServer().getPluginCommand("reloadredis")).setExecutor(rm);
         if (getServer().getPluginManager().getPlugin("Skript") != null) {
+            startRedis(false);
+
+            PluginCommand command = getServer().getPluginCommand("reloadredis");
+            assert command != null;
+            command.setExecutor(new ReloadRedis(this));
+
             new SkriptHook(this);
         } else {
             getLogger().info("Skript wasn't found.");
         }
-        rm.start();
-
-
-
-
     }
 
     @Override
     public void onDisable() {
+        if (rm != null) {
             rm.shutdown();
         }
+    }
 
 
     public RedisManager getRm() {

src/main/java/net/limework/core/commands/ReloadRedis.java

@@ -0,0 +1,30 @@
+package net.limework.core.commands;
+
+import net.limework.core.RediSkript;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class ReloadRedis implements CommandExecutor {
+    private RediSkript plugin;
+    public ReloadRedis(RediSkript plugin) {
+        this.plugin = plugin;
+    }
+    @Override
+    public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
+        if (sender instanceof Player) {
+            //not using bungee TextComponent because it is not present in 1.8.8
+            sender.sendMessage((ChatColor.translateAlternateColorCodes('&'
+                    , "&2[&aRediSkript&a] &cThis command can only be executed in console.")));
+            return true;
+        }
+        plugin.getRm().reload();
+        //not sending to sender, because this command can only be executed via console
+        Bukkit.getLogger().info(ChatColor.translateAlternateColorCodes('&', "&2[&aRediSkript&a] &eReloaded via command! Note this command is not stable, it should only be used in urgent cases where you absolutely need to change config details without restarting the server."));
+
+        return false;
+    }
+}

src/main/java/net/limework/core/events/RedisMessageEvent.java

@@ -9,11 +9,13 @@ public class RedisMessageEvent extends Event {
 
     private String channelName;
     private String message;
+    private long date;
 
-    public RedisMessageEvent(String channelName , String message) {
+    public RedisMessageEvent(String channelName , String message, long date) {
         super(true);
         this.channelName = channelName;
         this.message = message;
+        this.date = date;
     }
 
 
@@ -34,6 +36,8 @@ public class RedisMessageEvent extends Event {
         return channelName;
     }
 
+    public long getDate() { return date;}
+
     public String getMessage() {
         return message;
     }

src/main/java/net/limework/core/hooks/SkriptHook.java

@@ -4,12 +4,14 @@ import ch.njol.skript.Skript;
 import ch.njol.skript.SkriptAddon;
 import ch.njol.skript.lang.ExpressionType;
 import ch.njol.skript.registrations.EventValues;
+import ch.njol.skript.util.Date;
 import ch.njol.skript.util.Getter;
 import net.limework.core.RediSkript;
 import net.limework.core.events.RedisMessageEvent;
 import net.limework.core.skript.elements.EvtRedis;
 import net.limework.core.skript.elements.ExprChannel;
 import net.limework.core.skript.elements.ExprMessage;
+import net.limework.core.skript.elements.ExprMessageDate;
 
 import java.io.IOException;
 
@@ -35,12 +37,15 @@ public class SkriptHook {
                     return e.getMessage();
                 }
             }, 0);
+            Skript.registerExpression(ExprMessageDate.class, Date.class, ExpressionType.SIMPLE, "redis message date");
+            EventValues.registerEventValue(RedisMessageEvent.class, Date.class, new Getter<Date, RedisMessageEvent>() {
+                @Override
+                public Date get(RedisMessageEvent e) {
+                    return new Date(e.getDate());
+                }
+            }, 0);
         } catch (IOException e) {
             e.printStackTrace();
         }
     }
-
-    public SkriptAddon getAddon() {
-        return addon;
-    }
 }

src/main/java/net/limework/core/managers/RedisManager.java

@@ -1,16 +1,11 @@
 package net.limework.core.managers;
 
 import net.limework.core.RediSkript;
-import net.limework.data.Encryption;
 import net.limework.core.events.RedisMessageEvent;
-import net.md_5.bungee.api.chat.TextComponent;
+import net.limework.data.Encryption;
 import org.bukkit.Bukkit;
 import org.bukkit.ChatColor;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
 import org.bukkit.configuration.Configuration;
-import org.bukkit.entity.Player;
 import org.cryptomator.siv.UnauthenticCiphertextException;
 import org.json.JSONObject;
 import redis.clients.jedis.BinaryJedis;
@@ -25,21 +20,18 @@ import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.atomic.AtomicBoolean;
 
-public class RedisManager extends BinaryJedisPubSub implements Runnable, CommandExecutor {
+public class RedisManager extends BinaryJedisPubSub implements Runnable {
 
     private RediSkript plugin;
 
     private JedisPool jedisPool;
     private ExecutorService RedisService;
 
-    private AtomicBoolean isKilled = new AtomicBoolean();
-
 
     //sub
     private BinaryJedis subscribeJedis;
     private List<String> channels;
     private AtomicBoolean isShuttingDown = new AtomicBoolean(false);
-    private AtomicBoolean isRedisOnline = new AtomicBoolean();
     private Encryption encryption;
 
 
@@ -47,8 +39,11 @@ public class RedisManager extends BinaryJedisPubSub implements Runnable, Command
         this.plugin = plugin;
         Configuration config = this.plugin.getConfig();
         JedisPoolConfig JConfig = new JedisPoolConfig();
-        JConfig.setMaxTotal(config.getInt("Redis.MaxConnections"));
+        int maxConnections = config.getInt("Redis.MaxConnections");
-        JConfig.setMaxIdle(config.getInt("Redis.MaxConnections"));
+        if (maxConnections < 2) { maxConnections = 2; }
+
+        JConfig.setMaxTotal(maxConnections);
+        JConfig.setMaxIdle(maxConnections);
         JConfig.setMinIdle(1);
         JConfig.setBlockWhenExhausted(true);
         this.jedisPool = new JedisPool(JConfig,
@@ -56,8 +51,8 @@ public class RedisManager extends BinaryJedisPubSub implements Runnable, Command
                 config.getInt("Redis.Port"),
                 config.getInt("Redis.TimeOut"),
                 config.getString("Redis.Password"),
-                config.getBoolean("Redis.useSSL"));
+                config.getBoolean("Redis.useTLS"));
-        RedisService = Executors.newFixedThreadPool(config.getInt("Redis.Threads"));
+        RedisService = Executors.newSingleThreadExecutor();
         try {
             this.subscribeJedis = this.jedisPool.getResource();
         } catch (Exception ignored) {
@@ -74,16 +69,13 @@ public class RedisManager extends BinaryJedisPubSub implements Runnable, Command
     @Override
     public void run() {
         while (!isShuttingDown.get()) {
-            isKilled.set(false);
             try {
-                message("&e[Jedis] &cConnecting to redis...........");
+                plugin.getLogger().info(ChatColor.translateAlternateColorCodes('&', "&2[&aRediSkript&a] &cConnecting to redis..."));
                 if (!this.subscribeJedis.isConnected()) this.subscribeJedis = this.jedisPool.getResource();
-                isRedisOnline.set(true);
+                plugin.getLogger().info(ChatColor.translateAlternateColorCodes('&', "&2[&aRediSkript&a] &aRedis connected!"));
-                message("&e[Jedis] &aRedis Connected");
                 int byteArr2dSize = 1;
                 byte[][] channelsInByte = new byte[channels.size()][byteArr2dSize];
                 boolean reInitializeByteArray;
-
                 // Loop that reInitialize array IF array size is not enough
                 do {
                     reInitializeByteArray = false;
@@ -101,31 +93,26 @@ public class RedisManager extends BinaryJedisPubSub implements Runnable, Command
                 } while (reInitializeByteArray);
                 this.subscribeJedis.subscribe(this, channelsInByte);
 
+
             } catch (Exception e) {
-                message("&e[Jedis] &cConnection to redis has failed! &ereconnecting...");
+                plugin.getLogger().warning(ChatColor.translateAlternateColorCodes('&', "&2[&aRediSkript&a] &cConnection to redis has failed! &ereconnecting..."));
                 if (this.subscribeJedis != null) {
                     this.subscribeJedis.close();
                 }
-                isRedisOnline.set(false);
             }
             try {
                 Thread.sleep(1000);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
-            if (isKilled.get()) break;
         }
     }
 
-    private void message(String message) {
-        plugin.getLogger().info(ChatColor.translateAlternateColorCodes('&', message));
-    }
-
     @Override
     public void onMessage(byte[] channel, byte[] message) {
         String channelString = new String(channel, StandardCharsets.UTF_8);
-        try {
         String receivedMessage = null;
+        try {
             //if encryption is enabled, decrypt the message, else just convert binary to string
             if (this.encryption.isEncryptionEnabled()) {
                 try {
@@ -142,11 +129,14 @@ public class RedisManager extends BinaryJedisPubSub implements Runnable, Command
             if (receivedMessage != null) {
                 JSONObject j = new JSONObject(receivedMessage);
                 //System.out.println("Message got from channel: "+channel +" and the Message: " +json.toString());
-                plugin.getServer().getPluginManager().callEvent(new RedisMessageEvent(channelString, j.getString("Message")));
+                RedisMessageEvent event = new RedisMessageEvent(channelString, j.getString("Message"), j.getLong("Date"));
+
+                plugin.getServer().getPluginManager().callEvent(event);
             }
         } catch (Exception e) {
             e.printStackTrace();
-            Bukkit.getLogger().warning(ChatColor.translateAlternateColorCodes('&', "&2[&aRedisk&a] &cI got a message that was empty from channel " + channelString + " please check your code that you used to send the message. ^ ignore the error."));
+            Bukkit.getLogger().warning(ChatColor.translateAlternateColorCodes('&', "&2[&aRediSkript&a] &cI got a message that was empty from channel " + channelString + " please check your code that you used to send the message. Message content:"));
+            Bukkit.getLogger().warning(receivedMessage);
         }
 
     }
@@ -156,53 +146,21 @@ public class RedisManager extends BinaryJedisPubSub implements Runnable, Command
         if (this.subscribeJedis != null) {
             this.unsubscribe();
             this.subscribeJedis.close();
+            this.jedisPool.getResource().close();
         }
         this.RedisService.shutdown();
 
     }
-
+    public void reload() {
-    public boolean IsRedisOnline() {
+        this.shutdown();
-        return isRedisOnline.get();
+        plugin.startRedis(true);
     }
 
     public JedisPool getJedisPool() {
         return jedisPool;
     }
 
-    public ExecutorService getRedisService() {
-        return RedisService;
-    }
-
-    public AtomicBoolean getIsShuttingDown() {
-        return isShuttingDown;
-    }
-
-    public AtomicBoolean getIsRedisOnline() {
-        return isRedisOnline;
-    }
-
     public Encryption getEncryption() {
         return encryption;
     }
-
-    // the /reloadredis command
-    @Override
-    public boolean onCommand(CommandSender sender, Command cmd, String lable, String[] args) {
-        if (sender instanceof Player) {
-            sender.sendMessage(TextComponent.fromLegacyText(ChatColor.translateAlternateColorCodes('&'
-                    , "&cYou cannot execute this command.")));
-            return true;
-        }
-        isKilled.set(true);
-        try {
-            if (this.subscribeJedis != null) {
-                this.unsubscribe();
-                this.subscribeJedis.close();
-            }
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-        start();
-        return false;
-    }
 }

src/main/java/net/limework/core/skript/elements/EffSendMessage.java

@@ -6,6 +6,7 @@ import ch.njol.skript.lang.Expression;
 import ch.njol.skript.lang.SkriptParser;
 import ch.njol.util.Kleenean;
 import net.limework.core.RediSkript;
+import net.limework.core.managers.RedisManager;
 import org.bukkit.Bukkit;
 import org.bukkit.ChatColor;
 import org.bukkit.event.Event;
@@ -16,7 +17,7 @@ import java.nio.charset.StandardCharsets;
 
 public class EffSendMessage extends Effect {
     static {
-        Skript.registerEffect(EffSendMessage.class, "send redis message to channel %string% with message %string%");
+        Skript.registerEffect(EffSendMessage.class, "send redis message %string% to [channel] %string%");
     }
 
 
@@ -26,42 +27,50 @@ public class EffSendMessage extends Effect {
 
     @Override
     protected void execute(Event event) {
+
         RediSkript plugin = (RediSkript) Bukkit.getPluginManager().getPlugin("RediSkript");
+
         String message = this.message.getSingle(event);
         String channel = this.channel.getSingle(event);
-        if (message == null) {//checks if message equals null if true does not execute.
+
-            Bukkit.getLogger().warning(ChatColor.translateAlternateColorCodes('&', "&2[&aGBot&a] &cMessage Was empty Please check your code."));
+        if (message == null) {
+            Bukkit.getLogger().warning(ChatColor.translateAlternateColorCodes('&', "&2[&aRediSkript&a] &cRedis message was empty. Please check your code."));
+            return;
+        }
+        if (channel == null) {
+            Bukkit.getLogger().warning(ChatColor.translateAlternateColorCodes('&', "&2[&aRediSkript&a] &cChannel was empty. Please check your code."));
             return;
         }
         assert plugin != null;
-        plugin.getRm().getRedisService().execute(() -> {
+        RedisManager manager = plugin.getRm();
-            BinaryJedis j = plugin.getRm().getJedisPool().getResource();
+        //manager.getRedisService().execute(() -> {
+            BinaryJedis j = manager.getJedisPool().getResource();
             JSONObject json = new JSONObject();
             json.put("Message", message);
             json.put("Type", "Skript");
             json.put("Date", System.currentTimeMillis()); //for unique string every time & PING calculations
             byte[] msg;
-            if (plugin.getRm().getEncryption().isEncryptionEnabled()) {
+            if (manager.getEncryption().isEncryptionEnabled()) {
-                msg = plugin.getRm().getEncryption().encrypt(json.toString());
+                msg = manager.getEncryption().encrypt(json.toString());
             } else {
                 msg = json.toString().getBytes(StandardCharsets.UTF_8);
             }
             j.publish(channel.getBytes(StandardCharsets.UTF_8), msg);
             j.close();
-        });
+        //});
 
     }
 
     @Override
     public String toString(Event event, boolean b) {
-        return "send redis message to channel " + channel.getSingle(event) + " with message " + message.getSingle(event);
+        return "send redis message " + message.getSingle(event) + " to channel " + channel.getSingle(event);
     }
 
     @SuppressWarnings("unchecked")
     @Override
     public boolean init(Expression<?>[] expressions, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parser) {
-        this.channel = (Expression<String>) expressions[0];
+        this.message = (Expression<String>) expressions[0];
-        this.message = (Expression<String>) expressions[1];
+        this.channel = (Expression<String>) expressions[1];
         return true;
     }
 

src/main/java/net/limework/core/skript/elements/EvtRedis.java

@@ -2,6 +2,7 @@ package net.limework.core.skript.elements;
 import ch.njol.skript.lang.Literal;
 import ch.njol.skript.lang.SkriptEvent;
 import ch.njol.skript.lang.SkriptParser;
+import net.limework.core.events.RedisMessageEvent;
 import org.bukkit.event.Event;
 
 public class EvtRedis extends SkriptEvent {
@@ -13,11 +14,14 @@ public class EvtRedis extends SkriptEvent {
 
     @Override
     public boolean check(Event event) {
+        if (!(event instanceof RedisMessageEvent)) {
+            return false;
+        }
         return true;
     }
 
     @Override
-    public String toString(Event event, boolean b) {
+    public String toString(Event event, boolean debug) {
         return "redis message";
     }
 }

src/main/java/net/limework/core/skript/elements/ExprChannel.java

@@ -1,9 +1,12 @@
 package net.limework.core.skript.elements;
 
 
+import ch.njol.skript.ScriptLoader;
+import ch.njol.skript.Skript;
 import ch.njol.skript.lang.Expression;
 import ch.njol.skript.lang.SkriptParser;
 import ch.njol.skript.lang.util.SimpleExpression;
+import ch.njol.skript.log.ErrorQuality;
 import ch.njol.util.Kleenean;
 import net.limework.core.events.RedisMessageEvent;
 import org.bukkit.event.Event;
@@ -27,7 +30,11 @@ public class ExprChannel extends SimpleExpression<String> {
     }
 
     @Override
-    public boolean init(Expression<?>[] expressions, int i, Kleenean kleenean, SkriptParser.ParseResult parseResult) {
+    public boolean init(final Expression<?>[] expressions, final int matchedPattern, final Kleenean isDelayed, final SkriptParser.ParseResult parseResult) {
+        if (!ScriptLoader.isCurrentEvent(RedisMessageEvent.class)) {
+            Skript.error("Cannot use 'redis channel' outside of a redis message event", ErrorQuality.SEMANTIC_ERROR);
+            return false;
+        }
         return true;
     }
 

src/main/java/net/limework/core/skript/elements/ExprMessage.java

@@ -1,9 +1,12 @@
 package net.limework.core.skript.elements;
 
 
+import ch.njol.skript.ScriptLoader;
+import ch.njol.skript.Skript;
 import ch.njol.skript.lang.Expression;
 import ch.njol.skript.lang.SkriptParser;
 import ch.njol.skript.lang.util.SimpleExpression;
+import ch.njol.skript.log.ErrorQuality;
 import ch.njol.util.Kleenean;
 import net.limework.core.events.RedisMessageEvent;
 import org.bukkit.event.Event;
@@ -22,12 +25,16 @@ public class ExprMessage extends SimpleExpression<String> {
     }
 
     @Override
-    public String toString(Event event, boolean b) {
+    public String toString(Event event, boolean debug) {
         return "redis message";
     }
 
     @Override
-    public boolean init(Expression<?>[] expressions, int i, Kleenean kleenean, SkriptParser.ParseResult parseResult) {
+    public boolean init(final Expression<?>[] expressions, final int matchedPattern, final Kleenean isDelayed, final SkriptParser.ParseResult parseResult) {
+        if (!ScriptLoader.isCurrentEvent(RedisMessageEvent.class)) {
+            Skript.error("Cannot use 'redis message' outside of a redis message event", ErrorQuality.SEMANTIC_ERROR);
+            return false;
+        }
         return true;
     }
 

src/main/java/net/limework/core/skript/elements/ExprMessageDate.java

@@ -0,0 +1,49 @@
+package net.limework.core.skript.elements;
+
+
+import ch.njol.skript.ScriptLoader;
+import ch.njol.skript.Skript;
+import ch.njol.skript.lang.Expression;
+import ch.njol.skript.lang.SkriptParser;
+import ch.njol.skript.lang.util.SimpleExpression;
+import ch.njol.skript.log.ErrorQuality;
+import ch.njol.skript.util.Date;
+import ch.njol.util.Kleenean;
+import net.limework.core.events.RedisMessageEvent;
+import org.bukkit.event.Event;
+
+public class ExprMessageDate extends SimpleExpression<Date> {
+
+
+    @Override
+    public boolean isSingle() {
+        return true;
+    }
+
+    @Override
+    public Class<? extends Date> getReturnType() {
+        return Date.class;
+    }
+
+    @Override
+    public String toString(Event event, boolean b) {
+        return "redis message date";
+    }
+
+    @Override
+    public boolean init(final Expression<?>[] expressions, final int matchedPattern, final Kleenean isDelayed, final SkriptParser.ParseResult parseResult) {
+        if (!ScriptLoader.isCurrentEvent(RedisMessageEvent.class)) {
+            Skript.error("Cannot use 'redis message date' outside of a redis message event", ErrorQuality.SEMANTIC_ERROR);
+            return false;
+        }
+        return true;
+    }
+    @Override
+    protected Date[] get(Event e) {
+        if (e instanceof RedisMessageEvent){
+            long date = ((RedisMessageEvent) e).getDate();
+            return new Date[]{new Date(date)};
+        }
+        return null;
+    }
+}

src/main/resources/config.yml

@@ -3,17 +3,19 @@ Redis:
   #it is also recommended to firewall your redis server with iptables so it can only be accessed by specific IP addresses
   Password: "yHy0d2zdBlRmaSPj3CiBwEv5V3XxBTLTrCsGW7ntBnzhfxPxXJS6Q1aTtR6DSfAtCZr2VxWnsungXHTcF94a4bsWEpGAvjL9XMU"
   Host: "127.0.0.1"
-  MaxConnections: 20
+  #must be 2 or higher, if you set to lower, the addon will automatically use 2 as a minimum
-  Threads: 10
+  MaxConnections: 2
   #the default Redis port
   Port: 6379
   #time out in milliseconds, how long it should take before it decides that it is unable to connect when sending a message
   #90000 = 90 seconds
   TimeOut: 90000
-  #also known as TLS, only use this if you're running Redis 6.0.6 or higher, older versions will not work correctly
+  #also known as SSL, only use this if you're running Redis 6.0.6 or higher, older versions will not work correctly
-  useSSL: false
+  #it encrypts your traffic and makes data exchange between distant servers completely secure
-  #may be useful if you cannot use SSL due to use of older version of Redis
+  useTLS: false
+  #may be useful if you cannot use TLS due to use of older version of Redis
   #however this will not encrypt the initial authentication password, only the messages sent
+  #it uses AES-128 SIV encryption which is secure enough for this
   EncryptMessages: true
   EncryptionKey: "16CHARACTERS KEY"
   MacKey: "16CHARACTERS KEY"

src/main/resources/plugin.yml

@@ -3,9 +3,8 @@ name: RediSkript
 version: ${project.version}
 authors: [Govindas, ham1255, DaemonicKing]
 api-version: 1.13
-softdepend:
+depend:
   - Skript
 commands:
   reloadredis:
-    description: "Restart redis connection"
+    description: "Reload redis configuration & restart the connection."
-    permission: "admin.use"