268 lines
12 KiB
Java
268 lines
12 KiB
Java
/*
|
|
* Copyright (c) 2013-present RedisBungee contributors
|
|
*
|
|
* All rights reserved. This program and the accompanying materials
|
|
* are made available under the terms of the Eclipse Public License v1.0
|
|
* which accompanies this distribution, and is available at
|
|
*
|
|
* http://www.eclipse.org/legal/epl-v10.html
|
|
*/
|
|
|
|
package com.imaginarycode.minecraft.redisbungee.api;
|
|
|
|
import com.github.benmanes.caffeine.cache.Caffeine;
|
|
import com.github.benmanes.caffeine.cache.LoadingCache;
|
|
import com.google.common.collect.ImmutableMultimap;
|
|
import com.google.common.collect.Multimap;
|
|
import com.google.common.net.InetAddresses;
|
|
import com.imaginarycode.minecraft.redisbungee.api.events.IPlayerChangedServerNetworkEvent;
|
|
import com.imaginarycode.minecraft.redisbungee.api.events.IPlayerLeftNetworkEvent;
|
|
import com.imaginarycode.minecraft.redisbungee.api.events.IPubSubMessageEvent;
|
|
import com.imaginarycode.minecraft.redisbungee.api.tasks.RedisPipelineTask;
|
|
import net.kyori.adventure.text.Component;
|
|
import net.kyori.adventure.text.serializer.json.JSONComponentSerializer;
|
|
import org.json.JSONObject;
|
|
import redis.clients.jedis.ClusterPipeline;
|
|
import redis.clients.jedis.Pipeline;
|
|
import redis.clients.jedis.Response;
|
|
import redis.clients.jedis.UnifiedJedis;
|
|
|
|
import java.net.InetAddress;
|
|
import java.util.HashMap;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
import java.util.UUID;
|
|
import java.util.concurrent.TimeUnit;
|
|
|
|
public abstract class PlayerDataManager<P, LE, DE, PS extends IPubSubMessageEvent, SC extends IPlayerChangedServerNetworkEvent, NJE extends IPlayerLeftNetworkEvent, CE> {
|
|
|
|
protected final RedisBungeePlugin<P> plugin;
|
|
private final LoadingCache<UUID, String> serverCache = Caffeine.newBuilder().expireAfterWrite(1, TimeUnit.HOURS).build(this::getServerFromRedis);
|
|
private final LoadingCache<UUID, String> lastServerCache = Caffeine.newBuilder().expireAfterWrite(1, TimeUnit.HOURS).build(this::getLastServerFromRedis);
|
|
private final LoadingCache<UUID, String> proxyCache = Caffeine.newBuilder().expireAfterWrite(1, TimeUnit.HOURS).build(this::getProxyFromRedis);
|
|
private final LoadingCache<UUID, InetAddress> ipCache = Caffeine.newBuilder().expireAfterWrite(1, TimeUnit.HOURS).build(this::getIpAddressFromRedis);
|
|
private final LoadingCache<UUID, Long> lastOnlineCache = Caffeine.newBuilder().expireAfterWrite(1, TimeUnit.HOURS).build(this::getLastOnlineFromRedis);
|
|
private final Object SERVERS_TO_PLAYERS_KEY = new Object();
|
|
private final LoadingCache<Object, Multimap<String, UUID>> serverToPlayersCache = Caffeine.newBuilder().expireAfterWrite(10, TimeUnit.MINUTES).build(this::serversToPlayersBuilder);
|
|
private final UnifiedJedis unifiedJedis;
|
|
|
|
public PlayerDataManager(RedisBungeePlugin<P> plugin) {
|
|
this.plugin = plugin;
|
|
this.unifiedJedis = plugin.proxyDataManager().unifiedJedis();
|
|
}
|
|
|
|
// handle network wide
|
|
// server change
|
|
public abstract void onPlayerChangedServerNetworkEvent(SC event);
|
|
|
|
public abstract void onNetworkPlayerQuit(NJE event);
|
|
|
|
// local events
|
|
public abstract void onPubSubMessageEvent(PS event);
|
|
|
|
public abstract void onServerConnectedEvent(CE event);
|
|
|
|
public abstract void onLoginEvent(LE event);
|
|
|
|
public abstract void onDisconnectEvent(DE event);
|
|
|
|
|
|
protected void handleNetworkPlayerServerChange(IPlayerChangedServerNetworkEvent event) {
|
|
this.serverCache.invalidate(event.getUuid());
|
|
this.lastServerCache.invalidate(event.getUuid());
|
|
}
|
|
|
|
protected void handleNetworkPlayerQuit(IPlayerLeftNetworkEvent event) {
|
|
this.proxyCache.invalidate(event.getUuid());
|
|
this.serverCache.invalidate(event.getUuid());
|
|
this.ipCache.invalidate(event.getUuid());
|
|
this.lastOnlineCache.invalidate(event.getUuid());
|
|
}
|
|
|
|
protected void handlePubSubMessageEvent(IPubSubMessageEvent event) {
|
|
// kick api
|
|
if (event.getChannel().equals("redisbungee-kick")) {
|
|
JSONObject data = new JSONObject(event.getMessage());
|
|
String proxy = data.getString("proxy");
|
|
if (proxy.equals(plugin.configuration().getProxyId())) {
|
|
return;
|
|
}
|
|
UUID uuid = UUID.fromString(data.getString("uuid"));
|
|
String message = data.getString("message");
|
|
plugin.handlePlatformKick(uuid, COMPONENT_SERIALIZER.deserialize(message));
|
|
return;
|
|
}
|
|
if (event.getChannel().equals("redisbungee-serverchange")) {
|
|
JSONObject data = new JSONObject(event.getMessage());
|
|
String proxy = data.getString("proxy");
|
|
if (proxy.equals(plugin.configuration().getProxyId())) {
|
|
return;
|
|
}
|
|
UUID uuid = UUID.fromString(data.getString("uuid"));
|
|
String from = null;
|
|
if (data.has("from")) from = data.getString("from");
|
|
String to = data.getString("to");
|
|
plugin.fireEvent(plugin.createPlayerChangedServerNetworkEvent(uuid, from, to));
|
|
return;
|
|
}
|
|
if (event.getChannel().equals("redisbungee-player-join")) {
|
|
JSONObject data = new JSONObject(event.getMessage());
|
|
String proxy = data.getString("proxy");
|
|
if (proxy.equals(plugin.configuration().getProxyId())) {
|
|
return;
|
|
}
|
|
UUID uuid = UUID.fromString(data.getString("uuid"));
|
|
plugin.fireEvent(plugin.createPlayerJoinedNetworkEvent(uuid));
|
|
return;
|
|
}
|
|
if (event.getChannel().equals("redisbungee-player-leave")) {
|
|
JSONObject data = new JSONObject(event.getMessage());
|
|
String proxy = data.getString("proxy");
|
|
if (proxy.equals(plugin.configuration().getProxyId())) {
|
|
return;
|
|
}
|
|
UUID uuid = UUID.fromString(data.getString("uuid"));
|
|
plugin.fireEvent(plugin.createPlayerLeftNetworkEvent(uuid));
|
|
}
|
|
|
|
}
|
|
|
|
protected void playerChangedServer(UUID uuid, String from, String to) {
|
|
JSONObject data = new JSONObject();
|
|
data.put("proxy", plugin.configuration().getProxyId());
|
|
data.put("uuid", uuid);
|
|
data.put("from", from);
|
|
data.put("to", to);
|
|
plugin.proxyDataManager().sendChannelMessage("redisbungee-serverchange", data.toString());
|
|
plugin.fireEvent(plugin.createPlayerChangedServerNetworkEvent(uuid, from, to));
|
|
handleServerChangeRedis(uuid, to);
|
|
}
|
|
|
|
private final JSONComponentSerializer COMPONENT_SERIALIZER =JSONComponentSerializer.json();
|
|
|
|
public void kickPlayer(UUID uuid, Component message) {
|
|
if (!plugin.handlePlatformKick(uuid, message)) { // handle locally before SENDING a message
|
|
JSONObject data = new JSONObject();
|
|
data.put("proxy", plugin.configuration().getProxyId());
|
|
data.put("uuid", uuid);
|
|
data.put("message", COMPONENT_SERIALIZER.serialize(message));
|
|
plugin.proxyDataManager().sendChannelMessage("redisbungee-kick", data.toString());
|
|
}
|
|
}
|
|
|
|
private void handleServerChangeRedis(UUID uuid, String server) {
|
|
Map<String, String> data = new HashMap<>();
|
|
data.put("server", server);
|
|
data.put("last-server", server);
|
|
unifiedJedis.hset("redis-bungee::player::" + uuid + "::data", data);
|
|
}
|
|
|
|
protected void addPlayer(final UUID uuid, final InetAddress inetAddress) {
|
|
Map<String, String> redisData = new HashMap<>();
|
|
redisData.put("last-online", String.valueOf(0));
|
|
redisData.put("proxy", plugin.configuration().getProxyId());
|
|
redisData.put("ip", inetAddress.getHostAddress());
|
|
unifiedJedis.hset("redis-bungee::player::" + uuid + "::data", redisData);
|
|
|
|
JSONObject data = new JSONObject();
|
|
data.put("proxy", plugin.configuration().getProxyId());
|
|
data.put("uuid", uuid);
|
|
plugin.proxyDataManager().sendChannelMessage("redisbungee-player-join", data.toString());
|
|
plugin.fireEvent(plugin.createPlayerJoinedNetworkEvent(uuid));
|
|
this.plugin.proxyDataManager().addPlayer(uuid);
|
|
}
|
|
|
|
protected void removePlayer(UUID uuid) {
|
|
unifiedJedis.hset("redis-bungee::player::" + uuid + "::data", "last-online", String.valueOf(System.currentTimeMillis()));
|
|
unifiedJedis.hdel("redis-bungee::player::" + uuid + "::data", "server", "proxy", "ip");
|
|
JSONObject data = new JSONObject();
|
|
data.put("proxy", plugin.configuration().getProxyId());
|
|
data.put("uuid", uuid);
|
|
plugin.proxyDataManager().sendChannelMessage("redisbungee-player-leave", data.toString());
|
|
plugin.fireEvent(plugin.createPlayerLeftNetworkEvent(uuid));
|
|
this.plugin.proxyDataManager().removePlayer(uuid);
|
|
}
|
|
|
|
|
|
protected String getProxyFromRedis(UUID uuid) {
|
|
return unifiedJedis.hget("redis-bungee::player::" + uuid + "::data", "proxy");
|
|
}
|
|
|
|
protected String getServerFromRedis(UUID uuid) {
|
|
return unifiedJedis.hget("redis-bungee::player::" + uuid + "::data", "server");
|
|
}
|
|
|
|
protected String getLastServerFromRedis(UUID uuid) {
|
|
return unifiedJedis.hget("redis-bungee::player::" + uuid + "::data", "last-server");
|
|
}
|
|
|
|
protected InetAddress getIpAddressFromRedis(UUID uuid) {
|
|
String ip = unifiedJedis.hget("redis-bungee::player::" + uuid + "::data", "ip");
|
|
if (ip == null) return null;
|
|
return InetAddresses.forString(ip);
|
|
}
|
|
|
|
protected long getLastOnlineFromRedis(UUID uuid) {
|
|
String unixString = unifiedJedis.hget("redis-bungee::player::" + uuid + "::data", "last-online");
|
|
if (unixString == null) return -1;
|
|
return Long.parseLong(unixString);
|
|
}
|
|
|
|
public String getLastServerFor(UUID uuid) {
|
|
return this.lastServerCache.get(uuid);
|
|
}
|
|
public String getServerFor(UUID uuid) {
|
|
return this.serverCache.get(uuid);
|
|
}
|
|
|
|
public String getProxyFor(UUID uuid) {
|
|
return this.proxyCache.get(uuid);
|
|
}
|
|
|
|
public InetAddress getIpFor(UUID uuid) {
|
|
return this.ipCache.get(uuid);
|
|
}
|
|
|
|
public long getLastOnline(UUID uuid) {
|
|
return this.lastOnlineCache.get(uuid);
|
|
}
|
|
|
|
public Multimap<String, UUID> serversToPlayers() {
|
|
return this.serverToPlayersCache.get(SERVERS_TO_PLAYERS_KEY);
|
|
}
|
|
|
|
protected Multimap<String, UUID> serversToPlayersBuilder(Object o) {
|
|
try {
|
|
return new RedisPipelineTask<Multimap<String, UUID>>(plugin) {
|
|
private final Set<UUID> uuids = plugin.proxyDataManager().networkPlayers();
|
|
private final ImmutableMultimap.Builder<String, UUID> builder = ImmutableMultimap.builder();
|
|
|
|
@Override
|
|
public Multimap<String, UUID> doPooledPipeline(Pipeline pipeline) {
|
|
HashMap<UUID, Response<String>> responses = new HashMap<>();
|
|
for (UUID uuid : uuids) {
|
|
responses.put(uuid, pipeline.hget("redis-bungee::player::" + uuid + "::data", "server"));
|
|
}
|
|
pipeline.sync();
|
|
responses.forEach((uuid, response) -> builder.put(response.get(), uuid));
|
|
return builder.build();
|
|
}
|
|
|
|
@Override
|
|
public Multimap<String, UUID> clusterPipeline(ClusterPipeline pipeline) {
|
|
HashMap<UUID, Response<String>> responses = new HashMap<>();
|
|
for (UUID uuid : uuids) {
|
|
responses.put(uuid, pipeline.hget("redis-bungee::player::" + uuid + "::data", "server"));
|
|
}
|
|
pipeline.sync();
|
|
responses.forEach((uuid, response) -> builder.put(response.get(), uuid));
|
|
return builder.build();
|
|
}
|
|
}.call();
|
|
} catch (Exception e) {
|
|
throw new RuntimeException(e);
|
|
}
|
|
}
|
|
|
|
}
|