some refactoring, make classes more well-sorted

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

@@ -0,0 +1,49 @@
+package net.limework.rediskript;
+import net.limework.rediskript.commands.CommandReloadRedis;
+import net.limework.rediskript.skript.SkriptHook;
+import net.limework.rediskript.managers.RedisManager;
+import org.bukkit.command.PluginCommand;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.plugin.java.JavaPlugin;
+
+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();
+        if (getServer().getPluginManager().getPlugin("Skript") != null) {
+            startRedis(false);
+
+            PluginCommand command = getServer().getPluginCommand("reloadredis");
+            assert command != null;
+            command.setExecutor(new CommandReloadRedis(this));
+
+            new SkriptHook(this);
+        } else {
+            getLogger().info("Skript wasn't found.");
+        }
+    }
+
+    @Override
+    //using HIGHEST event priority so it shuts down last and code can still execute well in "on script unload" and "on skript unload" events
+    @EventHandler(priority = EventPriority.HIGHEST)
+    public void onDisable() {
+        if (rm != null) {
+            rm.shutdown();
+        }
+    }
+
+
+    public RedisManager getRm() {
+        return rm;
+    }
+}

src/main/java/net/limework/rediskript/commands/CommandReloadRedis.java

@@ -0,0 +1,30 @@
+package net.limework.rediskript.commands;
+
+import net.limework.rediskript.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 CommandReloadRedis implements CommandExecutor {
+    private RediSkript plugin;
+    public CommandReloadRedis(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/rediskript/data/Encryption.java

@@ -0,0 +1,37 @@
+package net.limework.rediskript.data;
+
+import org.bukkit.configuration.Configuration;
+import org.cryptomator.siv.SivMode;
+import org.cryptomator.siv.UnauthenticCiphertextException;
+
+import javax.crypto.IllegalBlockSizeException;
+import java.nio.charset.StandardCharsets;
+
+public class Encryption {
+
+    private boolean encryptionEnabled;
+    private String encryptionKey;
+    private String macKey;
+    private final SivMode AES_SIV = new SivMode();
+
+    public Encryption(Configuration config){
+        encryptionEnabled = config.getBoolean("Redis.EncryptMessages");
+        if (encryptionEnabled) {
+            // AES-128 encryption
+            encryptionKey = config.getString("Redis.EncryptionKey");
+            macKey = config.getString("Redis.MacKey");
+        }
+    }
+
+    public boolean isEncryptionEnabled() { return encryptionEnabled; }
+
+    public String decrypt(byte[] message) throws UnauthenticCiphertextException, IllegalBlockSizeException {
+        return new String(AES_SIV.decrypt(encryptionKey.getBytes(StandardCharsets.UTF_8), macKey.getBytes(StandardCharsets.UTF_8), message), StandardCharsets.UTF_8);
+    }
+
+    public byte[] encrypt(String message) {
+        return AES_SIV.encrypt(encryptionKey.getBytes(StandardCharsets.UTF_8), macKey.getBytes(StandardCharsets.UTF_8), message.getBytes(StandardCharsets.UTF_8));
+    }
+
+
+}

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

@@ -0,0 +1,44 @@
+package net.limework.rediskript.events;
+
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+@SuppressWarnings("unused")
+public class RedisMessageEvent extends Event {
+    private final static HandlerList HANDLERS = new HandlerList();
+
+    private String channelName;
+    private String message;
+    private long date;
+
+    public RedisMessageEvent(String channelName , String message, long date) {
+        super(false);
+        this.channelName = channelName;
+        this.message = message;
+        this.date = date;
+    }
+
+
+    @Override
+    public String getEventName() {
+        return super.getEventName();
+    }
+
+    @Override
+    public HandlerList getHandlers() {
+        return HANDLERS;
+    }
+    public static HandlerList getHandlerList() {
+        return HANDLERS;
+    }
+
+    public String getChannelName() {
+        return channelName;
+    }
+
+    public long getDate() { return date;}
+
+    public String getMessage() {
+        return message;
+    }
+}

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

@@ -0,0 +1,166 @@
+package net.limework.rediskript.managers;
+
+import net.limework.rediskript.RediSkript;
+import net.limework.rediskript.events.RedisMessageEvent;
+import net.limework.rediskript.data.Encryption;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.configuration.Configuration;
+import org.cryptomator.siv.UnauthenticCiphertextException;
+import org.json.JSONObject;
+import redis.clients.jedis.BinaryJedis;
+import redis.clients.jedis.BinaryJedisPubSub;
+import redis.clients.jedis.JedisPool;
+import redis.clients.jedis.JedisPoolConfig;
+
+import javax.crypto.IllegalBlockSizeException;
+import java.nio.charset.StandardCharsets;
+import java.util.List;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public class RedisManager extends BinaryJedisPubSub implements Runnable {
+
+    private RediSkript plugin;
+
+    private JedisPool jedisPool;
+    private ExecutorService RedisService;
+
+
+    //sub
+    private BinaryJedis subscribeJedis;
+    private List<String> channels;
+    private AtomicBoolean isShuttingDown = new AtomicBoolean(false);
+    private Encryption encryption;
+
+
+    public RedisManager(RediSkript plugin) {
+        this.plugin = plugin;
+        Configuration config = this.plugin.getConfig();
+        JedisPoolConfig JConfig = new JedisPoolConfig();
+        int maxConnections = 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,
+                config.getString("Redis.Host"),
+                config.getInt("Redis.Port"),
+                config.getInt("Redis.TimeOut"),
+                config.getString("Redis.Password"),
+                config.getBoolean("Redis.useTLS"));
+        RedisService = Executors.newSingleThreadExecutor();
+        try {
+            this.subscribeJedis = this.jedisPool.getResource();
+        } catch (Exception ignored) {
+        }
+        this.channels = config.getStringList("Channels");
+        encryption = new Encryption(config);
+
+    }
+
+    public void start() {
+        this.RedisService.execute(this);
+    }
+
+    @Override
+    public void run() {
+        while (!isShuttingDown.get()) {
+            try {
+                plugin.getLogger().info(ChatColor.translateAlternateColorCodes('&', "&2[&aRediSkript&a] &cConnecting to redis..."));
+                if (!this.subscribeJedis.isConnected()) this.subscribeJedis = this.jedisPool.getResource();
+                plugin.getLogger().info(ChatColor.translateAlternateColorCodes('&', "&2[&aRediSkript&a] &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;
+                    try {
+                        /* Data Initialization for channelsInByte array from List<String> channels */
+                        for (int x = 0; x < channels.size(); x++) {
+                            channelsInByte[x] = channels.get(x).getBytes(StandardCharsets.UTF_8);
+                        }
+                    } catch (ArrayIndexOutOfBoundsException ex) {
+                        reInitializeByteArray = true;
+                        /* Increase the current 2d array size to increase 1 and reinitialize the array*/
+                        byteArr2dSize += 1;
+                        channelsInByte = new byte[channels.size()][byteArr2dSize];
+                    }
+                } while (reInitializeByteArray);
+                this.subscribeJedis.subscribe(this, channelsInByte);
+
+
+            } catch (Exception e) {
+                plugin.getLogger().warning(ChatColor.translateAlternateColorCodes('&', "&2[&aRediSkript&a] &cConnection to redis has failed! &ereconnecting..."));
+                if (this.subscribeJedis != null) {
+                    this.subscribeJedis.close();
+                }
+            }
+            try {
+                Thread.sleep(1000);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    @Override
+    public void onMessage(byte[] channel, byte[] message) {
+        String channelString = new String(channel, StandardCharsets.UTF_8);
+        String receivedMessage = null;
+        try {
+            //if encryption is enabled, decrypt the message, else just convert binary to string
+            if (this.encryption.isEncryptionEnabled()) {
+                try {
+                    receivedMessage = encryption.decrypt(message);
+                } catch (UnauthenticCiphertextException | IllegalBlockSizeException e) {
+                    e.printStackTrace();
+                }
+
+            } else {
+                //encryption is disabled, so let's just get the string
+                receivedMessage = new String(message, StandardCharsets.UTF_8);
+            }
+
+            if (receivedMessage != null) {
+                JSONObject j = new JSONObject(receivedMessage);
+                //System.out.println("Message got from channel: "+channel +" and the Message: " +json.toString());
+                RedisMessageEvent event = new RedisMessageEvent(channelString, j.getString("Message"), j.getLong("Date"));
+                Bukkit.getScheduler().runTask(plugin, () -> plugin.getServer().getPluginManager().callEvent(event));
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+            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);
+        }
+
+    }
+
+    public void shutdown() {
+        this.isShuttingDown.set(true);
+        if (this.subscribeJedis != null) {
+            this.unsubscribe();
+            this.subscribeJedis.close();
+            this.subscribeJedis.getClient().close();
+            this.jedisPool.getResource().close();
+        }
+        this.RedisService.shutdown();
+
+    }
+    public void reload() {
+        this.shutdown();
+        plugin.startRedis(true);
+    }
+
+    public JedisPool getJedisPool() {
+        return jedisPool;
+    }
+
+    public Encryption getEncryption() {
+        return encryption;
+    }
+}

src/main/java/net/limework/rediskript/skript/SkriptHook.java

@@ -0,0 +1,51 @@
+package net.limework.rediskript.skript;
+
+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.rediskript.RediSkript;
+import net.limework.rediskript.events.RedisMessageEvent;
+import net.limework.rediskript.skript.elements.EvtRedis;
+import net.limework.rediskript.skript.elements.ExprChannel;
+import net.limework.rediskript.skript.elements.ExprMessage;
+import net.limework.rediskript.skript.elements.ExprMessageDate;
+
+import java.io.IOException;
+
+public class SkriptHook {
+
+    private SkriptAddon addon;
+    public SkriptHook(RediSkript plugin) {
+        addon = Skript.registerAddon(plugin);
+        try {
+            addon.loadClasses("net.limework.core.skript", "elements");
+            Skript.registerEvent("redis message", EvtRedis.class, RedisMessageEvent.class, "redis message");
+            Skript.registerExpression(ExprChannel.class, String.class, ExpressionType.SIMPLE, "redis channel");
+            EventValues.registerEventValue(RedisMessageEvent.class, String.class, new Getter<String, RedisMessageEvent>() {
+                @Override
+                public String get(RedisMessageEvent e) {
+                    return e.getChannelName();
+                }
+            }, 0);
+            Skript.registerExpression(ExprMessage.class, String.class, ExpressionType.SIMPLE, "redis message");
+            EventValues.registerEventValue(RedisMessageEvent.class, String.class, new Getter<String, RedisMessageEvent>() {
+                @Override
+                public String get(RedisMessageEvent e) {
+                    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();
+        }
+    }
+}

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

@@ -0,0 +1,82 @@
+package net.limework.rediskript.skript.elements;
+
+import ch.njol.skript.Skript;
+import ch.njol.skript.lang.Effect;
+import ch.njol.skript.lang.Expression;
+import ch.njol.skript.lang.SkriptParser;
+import ch.njol.util.Kleenean;
+import net.limework.rediskript.RediSkript;
+import net.limework.rediskript.managers.RedisManager;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.event.Event;
+import org.json.JSONObject;
+import redis.clients.jedis.BinaryJedis;
+import redis.clients.jedis.exceptions.JedisConnectionException;
+
+import java.nio.charset.StandardCharsets;
+
+public class EffSendMessage extends Effect {
+    static {
+        Skript.registerEffect(EffSendMessage.class, "send redis message %string% to [channel] %string%");
+    }
+
+
+    private Expression<String> channel;
+    private Expression<String> message;
+
+
+    @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) {
+            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;
+        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;
+        RedisManager manager = plugin.getRm();
+
+        if (manager.getEncryption().isEncryptionEnabled()) {
+            msg = manager.getEncryption().encrypt(json.toString());
+        } else {
+            msg = json.toString().getBytes(StandardCharsets.UTF_8);
+        }
+        try {
+            BinaryJedis j = manager.getJedisPool().getResource();
+
+            j.publish(channel.getBytes(StandardCharsets.UTF_8), msg);
+            j.close();
+        } catch (JedisConnectionException exception) {
+            exception.printStackTrace();
+        }
+
+    }
+
+    @Override
+    public String toString(Event event, boolean debug) {
+        return "send redis message " + message.toString(event, debug) + " to channel " + channel.toString(event, debug);
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public boolean init(final Expression<?>[] expressions, final int matchedPattern, final Kleenean isDelayed, final SkriptParser.ParseResult parser) {
+        this.message = (Expression<String>) expressions[0];
+        this.channel = (Expression<String>) expressions[1];
+        return true;
+    }
+
+}

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

@@ -0,0 +1,27 @@
+package net.limework.rediskript.skript.elements;
+import ch.njol.skript.lang.Literal;
+import ch.njol.skript.lang.SkriptEvent;
+import ch.njol.skript.lang.SkriptParser;
+import net.limework.rediskript.events.RedisMessageEvent;
+import org.bukkit.event.Event;
+
+public class EvtRedis extends SkriptEvent {
+
+    @Override
+    public boolean init(final Literal<?>[] literals, final int i, final SkriptParser.ParseResult parseResult) {
+        return true;
+    }
+
+    @Override
+    public boolean check(Event event) {
+        if (!(event instanceof RedisMessageEvent)) {
+            return false;
+        }
+        return true;
+    }
+
+    @Override
+    public String toString(Event event, boolean debug) {
+        return "redis message";
+    }
+}

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

@@ -0,0 +1,49 @@
+package net.limework.rediskript.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.rediskript.events.RedisMessageEvent;
+import org.bukkit.event.Event;
+
+public class ExprChannel extends SimpleExpression<String> {
+
+
+    @Override
+    public boolean isSingle() {
+        return true;
+    }
+
+    @Override
+    public Class<? extends String> getReturnType() {
+        return String.class;
+    }
+
+    @Override
+    public String toString(Event event, boolean b) {
+        return "redis channel";
+    }
+
+    @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 channel' outside of a redis message event", ErrorQuality.SEMANTIC_ERROR);
+            return false;
+        }
+        return true;
+    }
+
+
+    @Override
+    protected String[] get(Event e) {
+        if (e instanceof RedisMessageEvent){
+            return new String[]{((RedisMessageEvent) e).getChannelName()};
+        }
+        return null;
+    }
+}

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

@@ -0,0 +1,49 @@
+package net.limework.rediskript.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.rediskript.events.RedisMessageEvent;
+import org.bukkit.event.Event;
+
+public class ExprMessage extends SimpleExpression<String> {
+
+
+    @Override
+    public boolean isSingle() {
+        return true;
+    }
+
+    @Override
+    public Class<? extends String> getReturnType() {
+        return String.class;
+    }
+
+    @Override
+    public String toString(Event event, boolean debug) {
+        return "redis message";
+    }
+
+    @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' outside of a redis message event", ErrorQuality.SEMANTIC_ERROR);
+            return false;
+        }
+        return true;
+    }
+
+
+    @Override
+    protected String[] get(Event e) {
+        if (e instanceof RedisMessageEvent){
+            return new String[]{((RedisMessageEvent) e).getMessage()};
+        }
+        return null;
+    }
+}

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

@@ -0,0 +1,49 @@
+package net.limework.rediskript.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.rediskript.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;
+    }
+}