2013-09-29 20:16:47 +00:00
|
|
|
/**
|
|
|
|
* Copyright © 2013 tuxed <write@imaginarycode.com>
|
|
|
|
* This work is free. You can redistribute it and/or modify it under the
|
|
|
|
* terms of the Do What The Fuck You Want To Public License, Version 2,
|
|
|
|
* as published by Sam Hocevar. See http://www.wtfpl.net/ for more details.
|
|
|
|
*/
|
|
|
|
package com.imaginarycode.minecraft.redisbungee;
|
|
|
|
|
2013-11-16 02:56:59 +00:00
|
|
|
import com.google.common.collect.ImmutableList;
|
|
|
|
import com.google.common.collect.ImmutableSet;
|
2013-11-14 00:28:53 +00:00
|
|
|
import com.google.common.io.ByteStreams;
|
2013-09-29 20:16:47 +00:00
|
|
|
import net.md_5.bungee.api.ServerPing;
|
|
|
|
import net.md_5.bungee.api.config.ServerInfo;
|
|
|
|
import net.md_5.bungee.api.connection.ProxiedPlayer;
|
|
|
|
import net.md_5.bungee.api.event.PlayerDisconnectEvent;
|
|
|
|
import net.md_5.bungee.api.event.PostLoginEvent;
|
|
|
|
import net.md_5.bungee.api.event.ProxyPingEvent;
|
|
|
|
import net.md_5.bungee.api.event.ServerConnectedEvent;
|
|
|
|
import net.md_5.bungee.api.plugin.Listener;
|
|
|
|
import net.md_5.bungee.api.plugin.Plugin;
|
|
|
|
import net.md_5.bungee.event.EventHandler;
|
|
|
|
import org.yaml.snakeyaml.Yaml;
|
|
|
|
import redis.clients.jedis.Jedis;
|
|
|
|
import redis.clients.jedis.JedisPool;
|
|
|
|
import redis.clients.jedis.JedisPoolConfig;
|
2013-11-15 22:05:29 +00:00
|
|
|
import redis.clients.jedis.JedisPubSub;
|
|
|
|
import redis.clients.jedis.exceptions.JedisException;
|
2013-09-29 20:16:47 +00:00
|
|
|
|
|
|
|
import java.io.*;
|
2013-10-15 00:40:32 +00:00
|
|
|
import java.util.*;
|
2013-09-29 20:16:47 +00:00
|
|
|
import java.util.concurrent.TimeUnit;
|
|
|
|
|
2013-11-15 22:05:29 +00:00
|
|
|
/**
|
|
|
|
* The RedisBungee plugin.
|
|
|
|
* <p/>
|
|
|
|
* The only function of interest is {@link #getApi()}, which exposes some functions in this class.
|
|
|
|
*/
|
2013-09-29 20:16:47 +00:00
|
|
|
public class RedisBungee extends Plugin implements Listener {
|
2013-11-14 00:28:53 +00:00
|
|
|
private static final ServerPing.PlayerInfo[] EMPTY_PLAYERINFO = new ServerPing.PlayerInfo[]{};
|
2013-11-15 22:05:29 +00:00
|
|
|
private RedisBungeeCommandSender commandSender = new RedisBungeeCommandSender();
|
2013-11-15 22:55:57 +00:00
|
|
|
private static RedisBungeeConfiguration configuration = new RedisBungeeConfiguration();
|
2013-11-15 22:05:29 +00:00
|
|
|
private JedisPool pool;
|
|
|
|
private RedisBungee plugin;
|
|
|
|
private static RedisBungeeAPI api;
|
2013-11-15 22:55:57 +00:00
|
|
|
private PubSubListener psl = null;
|
2013-10-15 00:40:32 +00:00
|
|
|
|
2013-10-13 19:44:20 +00:00
|
|
|
/**
|
2013-11-15 22:05:29 +00:00
|
|
|
* Fetch the {@link RedisBungeeAPI} object created on plugin start.
|
2013-10-13 19:44:20 +00:00
|
|
|
*
|
2013-11-15 22:05:29 +00:00
|
|
|
* @return the {@link RedisBungeeAPI} object
|
2013-10-13 19:44:20 +00:00
|
|
|
*/
|
2013-11-15 22:05:29 +00:00
|
|
|
public static RedisBungeeAPI getApi() {
|
|
|
|
return api;
|
|
|
|
}
|
|
|
|
|
2013-11-15 22:55:57 +00:00
|
|
|
protected static RedisBungeeConfiguration getConfiguration() {
|
|
|
|
return configuration;
|
|
|
|
}
|
|
|
|
|
2013-11-15 22:05:29 +00:00
|
|
|
public int getCount() {
|
2013-10-29 23:10:16 +00:00
|
|
|
Jedis rsc = pool.getResource();
|
|
|
|
int c = 0;
|
|
|
|
try {
|
|
|
|
c = plugin.getProxy().getOnlineCount();
|
2013-11-15 22:55:57 +00:00
|
|
|
for (String i : getConfiguration().getLinkedServers()) {
|
|
|
|
if (i.equals(configuration.getServerId())) continue;
|
2013-10-29 23:10:16 +00:00
|
|
|
if (rsc.exists("server:" + i + ":playerCount"))
|
|
|
|
c += Integer.valueOf(rsc.get("server:" + i + ":playerCount"));
|
|
|
|
}
|
|
|
|
} finally {
|
|
|
|
pool.returnResource(rsc);
|
|
|
|
}
|
|
|
|
return c;
|
2013-10-15 00:40:32 +00:00
|
|
|
}
|
|
|
|
|
2013-11-15 22:05:29 +00:00
|
|
|
public Set<String> getPlayers() {
|
2013-11-14 00:28:53 +00:00
|
|
|
Set<String> players = new HashSet<>();
|
2013-09-29 20:16:47 +00:00
|
|
|
for (ProxiedPlayer pp : plugin.getProxy().getPlayers()) {
|
|
|
|
players.add(pp.getName());
|
|
|
|
}
|
|
|
|
if (pool != null) {
|
|
|
|
Jedis rsc = pool.getResource();
|
|
|
|
try {
|
2013-11-15 22:55:57 +00:00
|
|
|
for (String i : getConfiguration().getLinkedServers()) {
|
|
|
|
if (i.equals(configuration.getServerId())) continue;
|
2013-11-16 02:56:59 +00:00
|
|
|
players.addAll(rsc.smembers("server:" + i + ":usersOnline"));
|
2013-09-29 20:16:47 +00:00
|
|
|
}
|
|
|
|
} finally {
|
|
|
|
pool.returnResource(rsc);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ImmutableSet.copyOf(players);
|
|
|
|
}
|
|
|
|
|
2013-11-15 22:05:29 +00:00
|
|
|
public ServerInfo getServerFor(String name) {
|
2013-09-29 20:16:47 +00:00
|
|
|
ServerInfo server = null;
|
|
|
|
if (plugin.getProxy().getPlayer(name) != null) return plugin.getProxy().getPlayer(name).getServer().getInfo();
|
|
|
|
if (pool != null) {
|
|
|
|
Jedis tmpRsc = pool.getResource();
|
|
|
|
try {
|
|
|
|
if (tmpRsc.hexists("player:" + name, "server"))
|
|
|
|
server = plugin.getProxy().getServerInfo(tmpRsc.hget("player:" + name, "server"));
|
|
|
|
} finally {
|
|
|
|
pool.returnResource(tmpRsc);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return server;
|
|
|
|
}
|
|
|
|
|
2013-11-15 22:05:29 +00:00
|
|
|
private long getUnixTimestamp() {
|
2013-09-29 20:16:47 +00:00
|
|
|
return TimeUnit.SECONDS.convert(System.currentTimeMillis(), TimeUnit.MILLISECONDS);
|
|
|
|
}
|
|
|
|
|
2013-11-15 22:05:29 +00:00
|
|
|
public long getLastOnline(String name) {
|
2013-11-14 01:25:09 +00:00
|
|
|
long time = -1L;
|
|
|
|
if (plugin.getProxy().getPlayer(name) != null) return 0;
|
2013-09-29 20:16:47 +00:00
|
|
|
if (pool != null) {
|
|
|
|
Jedis tmpRsc = pool.getResource();
|
|
|
|
try {
|
|
|
|
if (tmpRsc.hexists("player:" + name, "online"))
|
|
|
|
time = Long.valueOf(tmpRsc.hget("player:" + name, "online"));
|
|
|
|
} finally {
|
|
|
|
pool.returnResource(tmpRsc);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return time;
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onEnable() {
|
|
|
|
plugin = this;
|
|
|
|
try {
|
|
|
|
loadConfig();
|
|
|
|
} catch (IOException e) {
|
|
|
|
e.printStackTrace();
|
|
|
|
}
|
|
|
|
if (pool != null) {
|
|
|
|
Jedis tmpRsc = pool.getResource();
|
|
|
|
try {
|
2013-11-15 22:55:57 +00:00
|
|
|
tmpRsc.set("server:" + configuration.getServerId() + ":playerCount", "0"); // reset
|
2013-11-16 03:05:49 +00:00
|
|
|
Set<String> smembers = tmpRsc.smembers("server:" + configuration.getServerId() + ":usersOnline");
|
|
|
|
if (smembers.size() > 0)
|
|
|
|
tmpRsc.srem("server:" + configuration.getServerId() + ":usersOnline", smembers.toArray(new String[smembers.size()]));
|
2013-09-29 20:16:47 +00:00
|
|
|
} finally {
|
|
|
|
pool.returnResource(tmpRsc);
|
|
|
|
}
|
2013-10-31 23:07:37 +00:00
|
|
|
getProxy().getScheduler().schedule(this, new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
Jedis rsc = pool.getResource();
|
|
|
|
try {
|
2013-11-15 22:55:57 +00:00
|
|
|
rsc.set("server:" + configuration.getServerId() + ":playerCount", String.valueOf(getProxy().getOnlineCount()));
|
2013-10-31 23:07:37 +00:00
|
|
|
} finally {
|
|
|
|
pool.returnResource(rsc);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}, 1, 3, TimeUnit.SECONDS);
|
2013-11-15 22:55:57 +00:00
|
|
|
getProxy().getPluginManager().registerCommand(this, new RedisBungeeCommands.GlistCommand());
|
|
|
|
getProxy().getPluginManager().registerCommand(this, new RedisBungeeCommands.FindCommand());
|
|
|
|
getProxy().getPluginManager().registerCommand(this, new RedisBungeeCommands.LastSeenCommand());
|
2013-09-29 20:16:47 +00:00
|
|
|
getProxy().getPluginManager().registerListener(this, this);
|
2013-11-15 22:05:29 +00:00
|
|
|
api = new RedisBungeeAPI(this);
|
|
|
|
psl = new PubSubListener();
|
2013-11-15 22:55:57 +00:00
|
|
|
getProxy().getScheduler().runAsync(this, psl);
|
2013-09-29 20:16:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onDisable() {
|
2013-10-18 21:14:58 +00:00
|
|
|
if (pool != null) {
|
2013-11-15 22:05:29 +00:00
|
|
|
// Poison the PubSub listener
|
|
|
|
psl.poison();
|
|
|
|
getProxy().getScheduler().cancel(this);
|
2013-10-18 21:14:58 +00:00
|
|
|
Jedis tmpRsc = pool.getResource();
|
|
|
|
try {
|
2013-11-15 22:55:57 +00:00
|
|
|
tmpRsc.set("server:" + configuration.getServerId() + ":playerCount", "0"); // reset
|
2013-11-16 03:05:49 +00:00
|
|
|
Set<String> smembers = tmpRsc.smembers("server:" + configuration.getServerId() + ":usersOnline");
|
|
|
|
if (smembers.size() > 0)
|
|
|
|
tmpRsc.srem("server:" + configuration.getServerId() + ":usersOnline", smembers.toArray(new String[smembers.size()]));
|
2013-11-15 22:05:29 +00:00
|
|
|
} catch (JedisException | ClassCastException ignored) {
|
2013-10-18 21:14:58 +00:00
|
|
|
} finally {
|
|
|
|
pool.returnResource(tmpRsc);
|
|
|
|
}
|
2013-10-19 22:25:38 +00:00
|
|
|
pool.destroy();
|
2013-10-18 21:14:58 +00:00
|
|
|
}
|
2013-09-29 20:16:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
private void loadConfig() throws IOException {
|
|
|
|
if (!getDataFolder().exists()) {
|
|
|
|
getDataFolder().mkdir();
|
|
|
|
}
|
|
|
|
|
2013-10-19 22:25:38 +00:00
|
|
|
File file = new File(getDataFolder(), "config.yml");
|
|
|
|
|
|
|
|
if (!file.exists()) {
|
|
|
|
file.createNewFile();
|
|
|
|
try (InputStream in = getResourceAsStream("example_config.yml");
|
|
|
|
OutputStream out = new FileOutputStream(file)) {
|
2013-11-14 00:28:53 +00:00
|
|
|
ByteStreams.copy(in, out);
|
2013-09-29 20:16:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Yaml yaml = new Yaml();
|
2013-11-08 23:19:01 +00:00
|
|
|
Map<?, ?> rawYaml;
|
2013-10-19 22:25:38 +00:00
|
|
|
|
|
|
|
try (InputStream in = new FileInputStream(file)) {
|
2013-11-02 02:08:48 +00:00
|
|
|
rawYaml = (Map) yaml.load(in);
|
2013-10-19 22:25:38 +00:00
|
|
|
}
|
2013-09-29 20:16:47 +00:00
|
|
|
|
2013-10-15 00:40:32 +00:00
|
|
|
String redisServer = "localhost";
|
|
|
|
try {
|
|
|
|
redisServer = ((String) rawYaml.get("redis-server"));
|
|
|
|
} catch (NullPointerException ignored) {
|
|
|
|
}
|
|
|
|
try {
|
2013-11-15 22:55:57 +00:00
|
|
|
configuration.setServerId((String) rawYaml.get("server-id"));
|
2013-10-15 00:40:32 +00:00
|
|
|
} catch (NullPointerException ignored) {
|
|
|
|
}
|
|
|
|
try {
|
2013-11-15 22:55:57 +00:00
|
|
|
configuration.setCanonicalGlist((Boolean) rawYaml.get("canonical-glist"));
|
2013-10-15 00:40:32 +00:00
|
|
|
} catch (NullPointerException ignored) {
|
|
|
|
}
|
2013-11-16 02:56:59 +00:00
|
|
|
try {
|
|
|
|
configuration.setPlayerListInPing(((Boolean) rawYaml.get("player-list-in-ping")));
|
|
|
|
} catch (NullPointerException ignored) {
|
|
|
|
}
|
2013-09-29 20:16:47 +00:00
|
|
|
List<?> tmp = (List<?>) rawYaml.get("linked-servers");
|
2013-10-15 00:40:32 +00:00
|
|
|
|
2013-11-15 22:55:57 +00:00
|
|
|
List<String> servers = new ArrayList<>();
|
2013-09-29 20:16:47 +00:00
|
|
|
if (tmp != null)
|
|
|
|
for (Object i : tmp) {
|
|
|
|
if (i instanceof String) {
|
|
|
|
servers.add((String) i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-11-15 22:55:57 +00:00
|
|
|
configuration.setLinkedServers(ImmutableList.copyOf(servers));
|
|
|
|
|
2013-09-29 20:16:47 +00:00
|
|
|
if (redisServer != null) {
|
|
|
|
if (!redisServer.equals("")) {
|
|
|
|
pool = new JedisPool(new JedisPoolConfig(), redisServer);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@EventHandler
|
|
|
|
public void onPlayerConnect(final PostLoginEvent event) {
|
2013-11-16 02:56:59 +00:00
|
|
|
getProxy().getScheduler().runAsync(this, new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
if (pool != null) {
|
|
|
|
Jedis rsc = pool.getResource();
|
|
|
|
try {
|
|
|
|
rsc.sadd("server:" + configuration.getServerId() + ":usersOnline", event.getPlayer().getName());
|
|
|
|
rsc.hset("player:" + event.getPlayer().getName(), "online", "0");
|
|
|
|
} finally {
|
|
|
|
pool.returnResource(rsc);
|
|
|
|
}
|
|
|
|
// I used to have a task that eagerly waited for the user to be connected.
|
|
|
|
// Well, upon further inspection of BungeeCord's source code, this turned
|
|
|
|
// out to not be needed at all, since ServerConnectedEvent is called anyway.
|
|
|
|
}
|
2013-09-29 20:16:47 +00:00
|
|
|
}
|
2013-11-16 02:56:59 +00:00
|
|
|
});
|
2013-09-29 20:16:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
@EventHandler
|
2013-11-16 02:56:59 +00:00
|
|
|
public void onPlayerDisconnect(final PlayerDisconnectEvent event) {
|
|
|
|
getProxy().getScheduler().runAsync(this, new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
if (pool != null) {
|
|
|
|
Jedis rsc = pool.getResource();
|
|
|
|
try {
|
|
|
|
rsc.srem("server:" + configuration.getServerId() + ":usersOnline", event.getPlayer().getName());
|
|
|
|
rsc.hset("player:" + event.getPlayer().getName(), "online", String.valueOf(getUnixTimestamp()));
|
|
|
|
rsc.hdel("player:" + event.getPlayer().getName(), "server");
|
|
|
|
} finally {
|
|
|
|
pool.returnResource(rsc);
|
|
|
|
}
|
|
|
|
}
|
2013-09-29 20:16:47 +00:00
|
|
|
}
|
2013-11-16 02:56:59 +00:00
|
|
|
});
|
2013-09-29 20:16:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
@EventHandler
|
2013-11-16 02:56:59 +00:00
|
|
|
public void onServerChange(final ServerConnectedEvent event) {
|
|
|
|
getProxy().getScheduler().runAsync(this, new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
if (pool != null) {
|
|
|
|
Jedis rsc = pool.getResource();
|
|
|
|
try {
|
|
|
|
rsc.hset("player:" + event.getPlayer().getName(), "server", event.getServer().getInfo().getName());
|
|
|
|
} finally {
|
|
|
|
pool.returnResource(rsc);
|
|
|
|
}
|
|
|
|
}
|
2013-09-29 20:16:47 +00:00
|
|
|
}
|
2013-11-16 02:56:59 +00:00
|
|
|
});
|
2013-09-29 20:16:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
@EventHandler
|
|
|
|
public void onPing(ProxyPingEvent event) {
|
|
|
|
ServerPing old = event.getResponse();
|
2013-10-29 02:42:26 +00:00
|
|
|
ServerPing reply = new ServerPing();
|
2013-11-16 02:56:59 +00:00
|
|
|
if (configuration.isPlayerListInPing()) {
|
|
|
|
Set<String> players = getPlayers();
|
|
|
|
ServerPing.PlayerInfo[] info = new ServerPing.PlayerInfo[players.size()];
|
|
|
|
int idx = 0;
|
|
|
|
for (String player : players) {
|
|
|
|
info[idx] = new ServerPing.PlayerInfo(player, "");
|
|
|
|
idx++;
|
|
|
|
}
|
|
|
|
reply.setPlayers(new ServerPing.Players(old.getPlayers().getMax(), players.size(), info));
|
|
|
|
} else {
|
|
|
|
reply.setPlayers(new ServerPing.Players(old.getPlayers().getMax(), getCount(), EMPTY_PLAYERINFO));
|
|
|
|
}
|
2013-10-29 02:42:26 +00:00
|
|
|
reply.setDescription(old.getDescription());
|
|
|
|
reply.setFavicon(old.getFavicon());
|
|
|
|
reply.setVersion(old.getVersion());
|
|
|
|
event.setResponse(reply);
|
2013-09-29 20:16:47 +00:00
|
|
|
}
|
2013-11-15 22:05:29 +00:00
|
|
|
|
|
|
|
private class PubSubListener implements Runnable {
|
|
|
|
|
|
|
|
private Jedis rsc;
|
|
|
|
private JedisPubSubHandler jpsh;
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
try {
|
|
|
|
rsc = pool.getResource();
|
|
|
|
jpsh = new JedisPubSubHandler();
|
2013-11-15 22:55:57 +00:00
|
|
|
rsc.subscribe(jpsh, "redisbungee-" + configuration.getServerId(), "redisbungee-allservers");
|
2013-11-15 22:05:29 +00:00
|
|
|
} catch (JedisException | ClassCastException ignored) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void poison() {
|
|
|
|
jpsh.unsubscribe();
|
|
|
|
pool.returnResource(rsc);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private class JedisPubSubHandler extends JedisPubSub {
|
|
|
|
@Override
|
|
|
|
public void onMessage(String s, String s2) {
|
|
|
|
String cmd;
|
|
|
|
if (s2.startsWith("/")) {
|
|
|
|
cmd = s2.substring(1);
|
|
|
|
} else {
|
|
|
|
cmd = s2;
|
|
|
|
}
|
2013-11-15 22:09:03 +00:00
|
|
|
getLogger().info("Invoking command from PubSub: /" + s2);
|
2013-11-15 22:05:29 +00:00
|
|
|
getProxy().getPluginManager().dispatchCommand(commandSender, cmd);
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onPMessage(String s, String s2, String s3) {
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onSubscribe(String s, int i) {
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onUnsubscribe(String s, int i) {
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onPUnsubscribe(String s, int i) {
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onPSubscribe(String s, int i) {
|
|
|
|
}
|
|
|
|
}
|
2013-09-29 20:16:47 +00:00
|
|
|
}
|