Limework/RediSkript
2
1
Fork 1
Code Issues 2 Pull Requests Projects Releases 13 Wiki Activity

not tested But rewritten the Plugin

Browse Source
This commit is contained in:
ham1255 2020-06-28 18:40:53 +04:00
parent 7a51aef643
commit d9c323bc25
10 changed files with 192 additions and 165 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
src/main/java/net/limework/Data/Encryption.java Normal file
View File

@ -0,0 +1,37 @@
package net.limework.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(), macKey.getBytes(), message), StandardCharsets.UTF_8);
}
public byte[] encrypt(String message) {
return AES_SIV.encrypt(encryptionKey.getBytes(), macKey.getBytes(), message.getBytes());
}
}

75
src/main/java/net/limework/core/LimeworkSpigotCore.java Normal file
View File

@ -0,0 +1,75 @@
package net.limework.core;
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.Getter;
import net.limework.core.Managers.RedisManager;
import net.limework.core.Skript.elements.EvtRedis;
import net.limework.core.Skript.elements.ExprChannel;
import net.limework.core.events.RedisMessageEvent;
import org.bukkit.plugin.java.JavaPlugin;
import java.io.IOException;
public class LimeworkSpigotCore extends JavaPlugin {
//Redis manager
private RedisManager rm;
//Skript
private SkriptAddon addon;
@Override
public void onEnable() {
saveDefaultConfig();
rm = new RedisManager(this);
loadSkript();
rm.start();
}
@Override
public void onDisable() {
}
private void loadSkript() {
addon = Skript.registerAddon(this);
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(net.limework.skLimework.elements.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);
} catch (IOException e) {
e.printStackTrace();
}
}
public RedisManager getRm() {
return rm;
}
public SkriptAddon getAddon() {
return addon;
}
}

87
src/main/java/net/limework/skLimework/Events/RedisSub.java → src/main/java/net/limework/core/Managers/RedisManager.java
View File

@ -1,31 +1,64 @@
package net.limework.skLimework.Events;
package net.limework.core.Managers;
import net.limework.skLimework.AddonPlugin;
import net.limework.Data.Encryption;
import net.limework.core.LimeworkSpigotCore;
import net.limework.core.events.RedisMessageEvent;
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.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{
public class RedisSub extends BinaryJedisPubSub implements Runnable {
private LimeworkSpigotCore plugin;
private AddonPlugin plugin;
private BinaryJedis j;
private JedisPool jedisPool;
private ExecutorService RedisService;
//sub
private BinaryJedis subscribeJedis;
private List<String> channels;
private AtomicBoolean isShuttingDown = new AtomicBoolean(false);
private AtomicBoolean isRedisOnline = new AtomicBoolean();
private Encryption encryption;
public RedisSub(AddonPlugin plugin, BinaryJedis j, List<String> channels) {
public RedisManager(LimeworkSpigotCore plugin) {
this.plugin = plugin;
this.j = j;
this.channels = channels;
Configuration config = this.plugin.getConfig();
JedisPoolConfig JConfig = new JedisPoolConfig();
JConfig.setMaxTotal(config.getInt("Redis.MaxConnections"));
JConfig.setMaxIdle(config.getInt("Redis.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.useSSL"));
RedisService = Executors.newFixedThreadPool(config.getInt("Redis.Threads"));
this.subscribeJedis = this.jedisPool.getResource();
this.channels = config.getStringList("Channels");
encryption = new Encryption(config);
}
public void start(){
this.RedisService.execute(this);
}
@Override
@ -33,7 +66,7 @@ public class RedisSub extends BinaryJedisPubSub implements Runnable {
while (!isShuttingDown.get()) {
try {
message("&e[Jedis] &cConnecting to redis...........");
if (!this.j.isConnected()) this.j = plugin.getJedisPool().getResource();
if (!this.subscribeJedis.isConnected()) this.subscribeJedis = this.jedisPool.getResource();
isRedisOnline.set(true);
message("&e[Jedis] &aRedis Connected");
int byteArr2dSize = 1;
@ -55,11 +88,11 @@ public class RedisSub extends BinaryJedisPubSub implements Runnable {
channelsInByte = new byte[channels.size()][byteArr2dSize];
}
} while (reInitializeByteArray);
this.j.subscribe(this, channelsInByte);
this.subscribeJedis.subscribe(this, channelsInByte);
} catch (Exception e) {
message("&e[Jedis] &cConnection to redis has failed! &ereconnecting...");
this.j.close();
this.subscribeJedis.close();
isRedisOnline.set(false);
}
try {
@ -76,20 +109,18 @@ public class RedisSub extends BinaryJedisPubSub implements Runnable {
@Override
public void onMessage(byte[] channel, byte[] message) {
AddonPlugin plugin = (AddonPlugin) Bukkit.getPluginManager().getPlugin("SKLimework");
String channelString = new String(channel);
try {
String decrypted = null;
try {
assert plugin != null;
decrypted = plugin.decrypt(message);
decrypted = encryption.decrypt(message);
} catch (UnauthenticCiphertextException | IllegalBlockSizeException e) {
e.printStackTrace();
}
assert decrypted != null;
JSONObject j = new JSONObject(decrypted);
//System.out.println("Message got from channel: "+channel +" and the Message: " +json.toString());
plugin.getServer().getPluginManager().callEvent(new onRedisMessage(channelString, j.getString("Message")));
plugin.getServer().getPluginManager().callEvent(new RedisMessageEvent(channelString, j.getString("Message")));
} catch (Exception e) {
e.printStackTrace();
Bukkit.getLogger().warning(ChatColor.translateAlternateColorCodes('&', "&2[&aGBot&a] &cI Got a Message that Was empty from channel " + channel + " Please check your code that you used to send the message. ^ ignore the error."));
@ -100,11 +131,31 @@ public class RedisSub extends BinaryJedisPubSub implements Runnable {
public void shutdown() {
this.isShuttingDown.set(true);
this.unsubscribe();
j.close();
this.RedisService.shutdown();
subscribeJedis.close();
}
public boolean IsRedisOnline() {
return isRedisOnline.get();
}
}
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;
}
}

0
src/main/java/net/limework/skLimework/elements/EffSendMessage.java → src/main/java/net/limework/core/Skript/elements/EffSendMessage.java
View File

9
src/main/java/net/limework/skLimework/elements/EvtRedis.java → src/main/java/net/limework/core/Skript/elements/EvtRedis.java
View File

@ -1,13 +1,8 @@
package net.limework.skLimework.elements;
import ch.njol.skript.Skript;
import ch.njol.skript.lang.ExpressionType;
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 ch.njol.skript.registrations.EventValues;
import ch.njol.skript.util.Getter;
import net.limework.skLimework.Events.onRedisMessage;
import org.bukkit.event.Event;
public class EvtRedis extends SkriptEvent {

8
src/main/java/net/limework/skLimework/elements/ExprChannel.java → src/main/java/net/limework/core/Skript/elements/ExprChannel.java
View File

@ -1,11 +1,11 @@
package net.limework.skLimework.elements;
package net.limework.core.Skript.elements;
import ch.njol.skript.lang.Expression;
import ch.njol.skript.lang.SkriptParser;
import ch.njol.skript.lang.util.SimpleExpression;
import ch.njol.util.Kleenean;
import net.limework.skLimework.Events.onRedisMessage;
import net.limework.core.events.RedisMessageEvent;
import org.bukkit.event.Event;
public class ExprChannel extends SimpleExpression<String> {
@ -34,8 +34,8 @@ public class ExprChannel extends SimpleExpression<String> {
@Override
protected String[] get(Event e) {
if (e instanceof onRedisMessage){
return new String[]{((onRedisMessage) e).getChannelName()};
if (e instanceof RedisMessageEvent){
return new String[]{((RedisMessageEvent) e).getChannelName()};
}
return null;
}

0
src/main/java/net/limework/skLimework/elements/ExprMessage.java → src/main/java/net/limework/core/Skript/elements/ExprMessage.java
View File

8
src/main/java/net/limework/skLimework/Events/onRedisMessage.java → src/main/java/net/limework/core/events/RedisMessageEvent.java
View File

@ -1,18 +1,18 @@
package net.limework.skLimework.Events;
package net.limework.core.events;
import net.limework.skLimework.AddonPlugin;
import org.bukkit.Bukkit;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
public class onRedisMessage extends Event {
@SuppressWarnings("unused")
public class RedisMessageEvent extends Event {
private final static HandlerList HANDLERS = new HandlerList();
private String channelName;
private String message;
onRedisMessage(String channelName , String message) {
public RedisMessageEvent(String channelName , String message) {
super(true);
this.channelName = channelName;
AddonPlugin instance = (AddonPlugin) Bukkit.getPluginManager().getPlugin("SKLimework");

131
src/main/java/net/limework/skLimework/AddonPlugin.java
View File

@ -1,131 +0,0 @@
package net.limework.skLimework;
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.Getter;
import net.limework.skLimework.Events.RedisSub;
import net.limework.skLimework.Events.onRedisMessage;
import net.limework.skLimework.elements.EvtRedis;
import net.limework.skLimework.elements.ExprChannel;
import net.limework.skLimework.elements.ExprMessage;
import org.bukkit.Bukkit;
import org.bukkit.configuration.file.FileConfiguration;
import org.bukkit.plugin.java.JavaPlugin;
import org.cryptomator.siv.SivMode;
import org.cryptomator.siv.UnauthenticCiphertextException;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.spec.SecretKeySpec;
import java.beans.Expression;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.nio.charset.StandardCharsets;
import java.security.InvalidKeyException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.Base64;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
public class AddonPlugin extends JavaPlugin {
private AddonPlugin instance;
private SkriptAddon addon;
private JedisPool jedisPool;
private RedisSub redisSub;
private ExecutorService service;
private boolean encryptionEnabled;
private String encryptionKey;
private String macKey;
private final SivMode AES_SIV = new SivMode();
@Override
public void onEnable(){
instance = this;
this.saveDefaultConfig();
FileConfiguration config = this.getConfig();
encryptionEnabled = config.getBoolean("Redis.EncryptMessages");
if (encryptionEnabled) {
// AES-128 encryption
encryptionKey = config.getString("Redis.EncryptionKey");
macKey = config.getString("Redis.MacKey");
}
addon = Skript.registerAddon(this);
try { addon.loadClasses("net.limework.skLimework", "elements");
Skript.registerEvent("redis message", EvtRedis.class, onRedisMessage.class, "redis message");
Skript.registerExpression(ExprChannel.class, String.class, ExpressionType.SIMPLE, "redis channel");
EventValues.registerEventValue(onRedisMessage.class, String.class, new Getter<String, onRedisMessage>() {
@Override
public String get(onRedisMessage e) {
return e.getChannelName();
}
}, 0);
Skript.registerExpression(ExprMessage.class, String.class, ExpressionType.SIMPLE, "redis message");
EventValues.registerEventValue(onRedisMessage.class, String.class, new Getter<String, onRedisMessage>() {
@Override
public String get(onRedisMessage e) {
return e.getMessage();
}
}, 0);
} catch (IOException e) { e.printStackTrace(); }
JedisPoolConfig jconfig = new JedisPoolConfig();
jconfig.setMaxTotal(this.getConfig().getInt("Redis.MaxConnections"));
jconfig.setMaxIdle(this.getConfig().getInt("Redis.MaxConnections"));
jconfig.setMinIdle(1);
jedisPool = new JedisPool(jconfig,
this.getConfig().getString("Redis.Host"),
this.getConfig().getInt("Redis.Port") ,
this.getConfig().getInt("Redis.TimeOut"),
this.getConfig().getString("Redis.Password"),
this.getConfig().getBoolean("Redis.useSSL"));
redisSub = new RedisSub(this, jedisPool.getResource(), this.getConfig().getStringList("Channels"));
service = Executors.newFixedThreadPool(this.getConfig().getInt("Redis.Threads"));
service.execute(redisSub);
Bukkit.getLogger().info("[Govindas limework Addon] was enabled!");
}
@Override
public void onDisable(){
redisSub.shutdown();
service.shutdown();
jedisPool.close();
}
public AddonPlugin getInstance() {
return instance;
}
public SkriptAddon getAddonInstance() {
return addon;
}
public ExecutorService getJedisExecutionService() {
return service;
}
public JedisPool getJedisPool() { return jedisPool; }
public boolean isEncryptionEnabled() { return encryptionEnabled; }
public String decrypt(byte[] message) throws UnauthenticCiphertextException, IllegalBlockSizeException {
return new String(AES_SIV.decrypt(encryptionKey.getBytes(), macKey.getBytes(), message), StandardCharsets.UTF_8);
}
public byte[] encrypt(String message) {
return AES_SIV.encrypt(encryptionKey.getBytes(), macKey.getBytes(), message.getBytes());
}
}

2
src/main/resources/config.yml
View File

@ -5,7 +5,7 @@ Redis:
Threads: 10
Port: 6379
TimeOut: 40000
useSSL: true
useSSL: FALSE
#useful if SSL is disabled
EncryptMessages: false
EncryptionKey: "16CHARACTERS KEY"