Proxy addition phase 1

RediSkript-bukkit/pom.xml

@@ -0,0 +1,110 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>RediSkript</artifactId>
+        <groupId>net.limework</groupId>
+        <version>1.4.0-SNAPSHOT</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>RediSkript-bukkit</artifactId>
+
+    <repositories>
+        <repository>
+            <id>spigot-repo</id>
+            <url>https://hub.spigotmc.org/nexus/content/repositories/snapshots/org/spigotmc/spigot-api/</url>
+        </repository>
+        <repository>
+            <id>jitpack.io</id>
+            <url>https://jitpack.io</url>
+        </repository>
+        <repository>
+            <id>commons-pool2</id>
+            <url>https://mvnrepository.com/artifact/org.apache.commons/commons-pool2</url>
+        </repository>
+        <repository>
+            <id>PaperMC</id>
+            <url>https://repo.destroystokyo.com/repository/maven-public/</url>
+        </repository>
+        <repository>
+            <id>sk89q</id>
+            <url>http://maven.sk89q.com/repo</url>
+        </repository>
+    </repositories>
+
+
+
+    <build>
+        <resources>
+            <resource>
+                <directory>src/main/resources</directory>
+                <filtering>true</filtering>
+            </resource>
+        </resources>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.6.1</version>
+                <configuration>
+                    <source>1.8</source>
+                    <target>1.8</target>
+                    <encoding>UTF-8</encoding>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-shade-plugin</artifactId>
+                <version>3.2.3</version>
+                <configuration>
+                    <createDependencyReducedPom>false</createDependencyReducedPom>
+                </configuration>
+                <executions>
+                    <execution>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>shade</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-jar-plugin</artifactId>
+                <version>3.2.0</version>
+                <configuration>
+                    <outputDirectory>../target</outputDirectory>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.github.SkriptLang</groupId>
+            <artifactId>Skript</artifactId>
+            <version>2.5.3</version>
+            <type>jar</type>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.spigotmc</groupId>
+            <artifactId>spigot-api</artifactId>
+            <version>1.16.5-R0.1-SNAPSHOT</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>redis.clients</groupId>
+            <artifactId>jedis</artifactId>
+            <version>3.5.1</version>
+        </dependency>
+        <dependency>
+            <groupId>net.limework</groupId>
+            <artifactId>RediSkript-core</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+    </dependencies>
+
+</project>

RediSkript-bukkit/src/main/java/META-INF/MANIFEST.MF

@@ -0,0 +1,3 @@
+Manifest-Version: 1.0
+Main-Class: net.limework.rediskript.RediSkript
+

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

@@ -0,0 +1,92 @@
+package net.limework.rediskript;
+
+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.commands.CommandReloadRedis;
+import net.limework.rediskript.events.RedisMessageEvent;
+import net.limework.rediskript.managers.RedisController;
+import net.limework.rediskript.skript.elements.*;
+import org.bukkit.ChatColor;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import java.io.IOException;
+
+public class RediSkript extends JavaPlugin {
+
+    private RedisController redisController;
+
+    public void reloadRedis() {
+        reloadConfig();
+        redisController.shutdown();
+        redisController = new RedisController(this);
+    }
+
+    public void sendLogs(String message) {
+        getLogger().info(
+                ChatColor.translateAlternateColorCodes('&', "&b" + message)
+        );
+    }
+    public void sendErrorLogs(String message) {
+        getLogger().severe(
+                ChatColor.translateAlternateColorCodes('&', "&c" + message)
+        );
+    }
+
+    public void registerSyntax() {
+        SkriptAddon addon = Skript.registerAddon(this);
+        try {
+            addon.loadClasses("net.limework.rediskript.skript", "elements");
+            Skript.registerEvent("redis message", EvtRedis.class, RedisMessageEvent.class, "redis message");
+            Skript.registerExpression(ExprVariableInChannel.class, Object.class, ExpressionType.PROPERTY, "variable[s] %strings% in [redis] [channel] %string%");
+
+            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();
+        }
+    }
+
+    @Override
+    public void onEnable() {
+        saveDefaultConfig();
+        redisController = new RedisController(this);
+        getServer().getPluginCommand("reloadredis").setExecutor(new CommandReloadRedis(this));
+        registerSyntax();
+    }
+
+    @Override
+    public void onDisable() {
+        if (redisController != null) {
+            redisController.shutdown();
+        }
+        getServer().getPluginCommand("reloadredis").setExecutor(null);
+
+    }
+
+    public RedisController getRC() {
+        return redisController;
+    }
+}

RediSkript-bukkit/src/main/java/net/limework/rediskript/commands/CommandReloadRedis.java

@@ -0,0 +1,39 @@
+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;
+import org.bukkit.scheduler.BukkitRunnable;
+
+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&2] &cThis command can only be executed in console.")));
+            return true;
+        }
+
+        //reload redis asynchronously to not lag the main thread (was doing a few seconds lagspike at most)
+        new BukkitRunnable() {
+            @Override
+            public void run() {
+                plugin.reloadRedis();
+            }
+        }.runTaskAsynchronously(plugin);
+
+        //not sending to sender, because this command can only be executed via console
+        Bukkit.getLogger().info(ChatColor.translateAlternateColorCodes('&', "&eReloaded channels, encryption and login details!"));
+
+        return false;
+    }
+}

RediSkript-bukkit/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;
+    }
+}

RediSkript-bukkit/src/main/java/net/limework/rediskript/managers/RedisController.java

@@ -0,0 +1,260 @@
+package net.limework.rediskript.managers;
+
+import ch.njol.skript.registrations.Classes;
+import ch.njol.skript.variables.Variables;
+import net.limework.rediskript.RediSkript;
+import net.limework.rediskript.data.Encryption;
+import net.limework.rediskript.events.RedisMessageEvent;
+import org.bukkit.Bukkit;
+import org.bukkit.configuration.Configuration;
+import org.bukkit.scheduler.BukkitTask;
+import org.cryptomator.siv.UnauthenticCiphertextException;
+import org.json.JSONArray;
+import org.json.JSONObject;
+import redis.clients.jedis.*;
+import redis.clients.jedis.exceptions.JedisConnectionException;
+
+import javax.crypto.IllegalBlockSizeException;
+import java.nio.charset.StandardCharsets;
+import java.util.Base64;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public class RedisController extends BinaryJedisPubSub implements Runnable {
+
+
+    //Jedis Pool to be used by every another class.
+    private final JedisPool jedisPool;
+
+    //this seems useless unless tls is OFF!
+    private final Encryption encryption;
+
+    private byte[][] channelsInByte;
+
+    private final AtomicBoolean isConnectionBroken;
+    private final AtomicBoolean isConnecting;
+    private final RediSkript plugin;
+    private final BukkitTask ConnectionTask;
+
+
+    public RedisController(RediSkript plugin) {
+        this.plugin = plugin;
+        Configuration config = plugin.getConfig();
+        JedisPoolConfig JConfig = new JedisPoolConfig();
+        int maxConnections = config.getInt("Redis.MaxConnections");
+
+        //do not allow less than 2 max connections as that causes issues
+        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"));
+        encryption = new Encryption(config.getBoolean("Redis.EncryptMessages"),
+                config.getString("Redis.EncryptionKe"),
+                config.getString("Redis.MacKey"));
+        setupChannels(config);
+        isConnectionBroken = new AtomicBoolean(true);
+        isConnecting = new AtomicBoolean(false);
+        //Start the main task on async thread
+        ConnectionTask = plugin.getServer().getScheduler().runTaskTimerAsynchronously(plugin, this, 0, 20 * 5);
+    }
+
+    @Override
+    public void run() {
+        if (!isConnectionBroken.get() || isConnecting.get()) {
+            return;
+        }
+        plugin.sendLogs("Connecting to Redis server...");
+        isConnecting.set(true);
+        try (Jedis jedis = jedisPool.getResource()) {
+            isConnectionBroken.set(false);
+            plugin.sendLogs("&aConnection to Redis server has established! Success!");
+            jedis.subscribe(this, channelsInByte);
+        } catch (Exception e) {
+            isConnecting.set(false);
+            isConnectionBroken.set(true);
+            plugin.sendErrorLogs("Connection to Redis server has failed! Please check your details in the configuration.");
+            e.printStackTrace();
+        }
+    }
+
+    public void shutdown() {
+        ConnectionTask.cancel();
+        if (this.isSubscribed()) {
+            try {
+                this.unsubscribe();
+            } catch (Exception e) {
+                plugin.sendErrorLogs("Something went wrong during unsubscribing...");
+                e.printStackTrace();
+            }
+        }
+        jedisPool.close();
+    }
+
+    @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);
+                    if (j.get("Type").equals("Skript")) {
+                        JSONArray messages = j.getJSONArray("Messages");
+                        RedisMessageEvent event;
+                        for (int i = 0; i < messages.length(); i++) {
+                            event = new RedisMessageEvent(channelString, messages.get(i).toString(), j.getLong("Date"));
+                            //if plugin is disabling, don't call events anymore
+                            if (plugin.isEnabled()) {
+                                RedisMessageEvent finalEvent = event;
+                                Bukkit.getScheduler().runTask(plugin, () -> plugin.getServer().getPluginManager().callEvent(finalEvent));
+                            }
+                        }
+                    } else if (j.get("Type").equals("SkriptVariables")) {
+
+                        //Transfer variables between servers
+
+                        JSONArray variableNames = j.getJSONArray("Names");
+                        Object inputValue;
+                        String changeValue = null;
+                        JSONArray variableValues = null;
+                        if (!j.isNull("Values")) {
+                            variableValues = j.getJSONArray("Values");
+                        }
+                        for (int i = 0; i < variableNames.length(); i++) {
+
+                            if (j.isNull("Values")) {
+                                //only check for SET here, because null has to be ignored in all other cases
+
+                                if (j.getString("Operation").equals("SET")) {
+                                    Variables.setVariable(variableNames.get(i).toString(), null, null, false);
+                                }
+
+                            } else {
+                                if (!variableValues.isNull(i)) {
+                                    changeValue = variableValues.get(i).toString();
+                                }
+                                String[] inputs = changeValue.split("\\^", 2);
+                                inputValue = Classes.deserialize(inputs[0], Base64.getDecoder().decode(inputs[1]));
+                                switch (j.getString("Operation")) {
+                                    case "ADD":
+                                        //I will add this once someone tells me how to remove from Skript variable
+                                        //because using SET operation has issues with inconvertible types (Double and Long)
+                                        //variable = (Variable) Variables.getVariable(variableNames.get(i).toString(), null, false);
+                                        // variable.change(null, (Object[]) inputValue, Changer.ChangeMode.REMOVE);
+                                    case "REMOVE":
+                                        //I will add this once someone tells me how to remove from Skript variable
+                                        //because using SET operation has issues with inconvertible types (Double and Long)
+                                        //variable = (Variable) Variables.getVariable(variableNames.get(i).toString(), null, false);
+                                        // variable.change(null, (Object[]) inputValue, Changer.ChangeMode.REMOVE);
+                                        break;
+                                    case "SET":
+                                        String variableName = variableNames.get(i).toString();
+                                        
+                                        //this is needed, because setting a {variable::*} causes weird behavior, like
+                                        //1st set operation is no data, 2nd has data, etc.
+                                        //if you set it to null before action, it works correctly
+
+                                        if (variableName.charAt(variableName.length()-1) == '*') {
+                                            Variables.setVariable(variableName, null, null, false);
+                                       }
+                                        Variables.setVariable(variableNames.get(i).toString(), inputValue, null, false);
+
+                                }
+                            }
+                        }
+                    }
+                }
+            } catch (Exception e) {
+                plugin.sendErrorLogs("&cI got a message that was empty from channel " + channelString + " please check your code that you used to send the message. Message content:");
+                plugin.sendErrorLogs(receivedMessage);
+                e.printStackTrace();
+            }
+        }
+
+    public void sendMessage(String[] message, String channel) {
+        JSONObject json = new JSONObject();
+        json.put("Messages", new JSONArray(message));
+        json.put("Type", "Skript");
+        json.put("Date", System.currentTimeMillis()); //for unique string every time & PING calculations
+        finishSendMessage(json, channel);
+    }
+
+    public void sendVariables(String[] variableNames, String[] variableValues, String channel, String operation) {
+        JSONObject json = new JSONObject();
+        json.put("Names", new JSONArray(variableNames));
+        if (variableValues != null) {
+            json.put("Values", new JSONArray(variableValues));
+        }
+
+        json.put("Type", "SkriptVariables");
+        json.put("Date", System.currentTimeMillis()); //for unique string every time & PING calculations
+        json.put("Operation", operation);
+        finishSendMessage(json, channel);
+    }
+
+    public void finishSendMessage(JSONObject json, String channel) {
+        try {
+            byte[] message;
+            if (encryption.isEncryptionEnabled()) {
+                message = encryption.encrypt(json.toString());
+            } else {
+                message = json.toString().getBytes(StandardCharsets.UTF_8);
+            }
+
+            //sending a redis message blocks main thread if there's no more connections available
+            //so to avoid issues, it's best to do it always on separate thread
+            if (plugin.isEnabled()) {
+                plugin.getServer().getScheduler().runTaskAsynchronously(plugin, () -> {
+                    try (BinaryJedis j = jedisPool.getResource()) {
+                        j.publish(channel.getBytes(StandardCharsets.UTF_8), message);
+                    } catch (Exception e) {
+                        plugin.sendErrorLogs("Error sending redis message!");
+                        e.printStackTrace();
+                        }
+                });
+            } else {
+                //execute sending of redis message on the main thread if plugin is disabling
+                //so it can still process the sending
+                try (BinaryJedis j = jedisPool.getResource()) {
+                    j.publish(channel.getBytes(StandardCharsets.UTF_8), message);
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+
+            }
+        } catch (JedisConnectionException exception) {
+            exception.printStackTrace();
+        }
+    }
+
+    private void setupChannels(Configuration config) {
+        List<String> channels = config.getStringList("Channels");
+        channelsInByte = new byte[channels.size()][1];
+        for (int x = 0; x < channels.size(); x++) {
+            channelsInByte[x] = channels.get(x).getBytes(StandardCharsets.UTF_8);
+        }
+    }
+
+    public Boolean isRedisConnectionOffline() {
+        return isConnectionBroken.get();
+    }
+}

RediSkript-bukkit/src/main/java/net/limework/rediskript/skript/elements/EffSendMessage.java

@@ -0,0 +1,54 @@
+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 org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.event.Event;
+
+public class EffSendMessage extends Effect {
+    static {
+        Skript.registerEffect(EffSendMessage.class, "send redis message[s] %strings% 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.getAll(event);
+        String channel = this.channel.getSingle(event);
+        if (message[0] == 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;
+        }
+        plugin.getRC().sendMessage(message, channel);
+    }
+
+    @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;
+    }
+
+}

RediSkript-bukkit/src/main/java/net/limework/rediskript/skript/elements/EvtRedis.java

@@ -0,0 +1,24 @@
+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) {
+        return (event instanceof RedisMessageEvent);
+    }
+
+    @Override
+    public String toString(Event event, boolean debug) {
+        return "redis message";
+    }
+}

RediSkript-bukkit/src/main/java/net/limework/rediskript/skript/elements/ExprChannel.java

@@ -0,0 +1,47 @@
+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;
+    }
+}

RediSkript-bukkit/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;
+    }
+}

RediSkript-bukkit/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;
+    }
+}

RediSkript-bukkit/src/main/java/net/limework/rediskript/skript/elements/ExprVariableInChannel.java

@@ -0,0 +1,81 @@
+package net.limework.rediskript.skript.elements;
+
+import ch.njol.skript.classes.Changer;
+import ch.njol.skript.lang.Expression;
+import ch.njol.skript.lang.SkriptParser;
+import ch.njol.skript.lang.util.SimpleExpression;
+import ch.njol.skript.registrations.Classes;
+import ch.njol.skript.variables.SerializedVariable;
+import ch.njol.util.Kleenean;
+import ch.njol.util.coll.CollectionUtils;
+import net.limework.rediskript.RediSkript;
+import org.bukkit.Bukkit;
+import org.bukkit.event.Event;
+
+import java.util.Base64;
+
+public class ExprVariableInChannel extends SimpleExpression<Object> {
+    private Expression<String> name;
+    private Expression<String> channel;
+    @Override
+    public boolean init(Expression<?>[] expressions, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parser) {
+        name = (Expression<String>) expressions[0];
+        channel = (Expression<String>) expressions[1];
+        return true;
+
+    }
+
+    @Override
+    protected Object[] get(Event event) {
+        return null;
+    }
+
+    @Override
+    public boolean isSingle() {
+        return true;
+    }
+
+    @Override
+    public Class<? extends Object> getReturnType() {
+        return Object.class;
+    }
+
+    @Override
+    public String toString(Event event, boolean debug) {
+        return "variable " + name.toString(event,debug) + " in redis channel " + channel.toString(event, debug);
+    }
+    @Override
+    public void change(Event e, Object[] changer, Changer.ChangeMode mode) {
+        RediSkript plugin = RediSkript.getPlugin(RediSkript.class);
+        switch (mode) {
+            case ADD:
+            case SET:
+            case REMOVE:
+                SerializedVariable.Value serialized;
+                String encoded;
+                String[] values = new String[changer.length+1];
+                for( int i = 0; i < changer.length; i++) {
+                    if (changer[i] != null) {
+                        serialized = Classes.serialize(changer[i]);
+                        encoded = Base64.getEncoder().encodeToString(serialized.data);
+                        encoded = serialized.type + "^" + encoded;
+                        values[i] = encoded;
+                    }
+                }
+                String operation = mode.toString();
+                plugin.getRC().sendVariables(name.getAll(e), values, channel.getSingle(e), operation);
+                break;
+            case DELETE:
+                plugin.getRC().sendVariables(name.getAll(e), null, channel.getSingle(e), "SET");
+                break;
+        }
+    }
+    @Override
+    public Class<?>[] acceptChange(Changer.ChangeMode mode) {
+        //if (mode == Changer.ChangeMode.DELETE || mode == Changer.ChangeMode.SET || mode == Changer.ChangeMode.ADD || mode == Changer.ChangeMode.REMOVE)
+        if (mode == Changer.ChangeMode.DELETE || mode == Changer.ChangeMode.SET)
+            return CollectionUtils.array(Object.class);
+
+        return null;
+    }
+}

RediSkript-bukkit/src/main/resources/config.yml

@@ -0,0 +1,44 @@
+Redis:
+  #a secure password that cannot be cracked, please change it!
+  #it is also recommended to firewall your redis server with iptables so it can only be accessed by specific IP addresses
+  Password: "yHy0d2zdBlRmaSPj3CiBwEv5V3XxBTLTrCsGW7ntBnzhfxPxXJS6Q1aTtR6DSfAtCZr2VxWnsungXHTcF94a4bsWEpGAvjL9XMU"
+  #hostname of your redis server, you can use free redis hosting (search for it online) if you do not have the ability to host your own redis server
+  #redis server is very lightweight, takes under 30 MB of RAM usually
+  Host: "127.0.0.1"
+  #must be 2 or higher, if you set to lower, the addon will automatically use 2 as a minimum
+  #do not edit MaxConnections if you do not know what you're doing
+  #it is only useful to increase this number to account for PING between distant servers and when you are sending a lot of messages constantly
+  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
+  #9000 = 9 seconds
+  TimeOut: 9000
+  #also known as SSL, only use this if you're running Redis 6.0.6 or higher, older versions will not work correctly
+  #it encrypts your traffic and makes data exchange between distant servers secure
+  useTLS: false
+  #EncryptMessages may be useful if you cannot use TLS due to use of older version of Redis or if you're paranoid about privacy and want to double encrypt your messages
+  #however this will not encrypt the initial authentication password, only the messages sent (use TLS for initial authentication password encryption)
+
+  #the encryption configuration must be the same across all servers in order to communicate
+
+  #use 16 characters long key for AES-128 encryption
+  #32 characters long key for AES-256 encryption
+  #AES-128 is faster, but less secure (but it is not crackable by today's technology as of 2020, may be crackable by quantum computers)
+  #the AES implementation used in RediSkript uses SIV mode, which makes the same key resistant to cracking for a big count of messages without the need of changing the key very often
+  EncryptMessages: true
+  #EncryptionKey and MacKey must be different
+  EncryptionKey: "16CHARACTERS KEY"
+  MacKey: "16CHARACTERS KEY"
+
+
+#the channels from which this server can receive messages
+#you can always send messages to all channels!
+#you can add as many channels as you wish!
+
+#ideal setup is having one global channel and having one channel that represents server name, so you know who to send messages to
+#then a few other utility channels up to your needs
+Channels:
+  - "global"
+  - "servername"
+  - "Channel3"

RediSkript-bukkit/src/main/resources/plugin.yml

@@ -0,0 +1,9 @@
+main: net.limework.rediskript.RediSkript
+name: ${project.name}
+version: ${project.version}
+authors: [Govindas, ham1255, DaemonicKing, limework.net]
+api-version: 1.13
+depend: [Skript]
+commands:
+  reloadredis:
+    description: "Reload redis configuration & restart the connection."