542 lines
16 KiB
Java
542 lines
16 KiB
Java
package fr.xephi.authme.datasource;
|
|
|
|
import fr.xephi.authme.AuthMe;
|
|
import fr.xephi.authme.cache.auth.PlayerAuth;
|
|
import fr.xephi.authme.cache.auth.PlayerCache;
|
|
import fr.xephi.authme.util.Utils;
|
|
import org.bukkit.entity.Player;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.concurrent.Callable;
|
|
import java.util.concurrent.ConcurrentHashMap;
|
|
import java.util.concurrent.ExecutorService;
|
|
import java.util.concurrent.Executors;
|
|
|
|
/**
|
|
*/
|
|
public class CacheDataSource implements DataSource {
|
|
|
|
private final DataSource source;
|
|
private final ExecutorService exec;
|
|
private final ConcurrentHashMap<String, PlayerAuth> cache = new ConcurrentHashMap<>();
|
|
|
|
/**
|
|
* Constructor for CacheDataSource.
|
|
*
|
|
* @param pl AuthMe
|
|
* @param src DataSource
|
|
*/
|
|
public CacheDataSource(final AuthMe pl, DataSource src) {
|
|
this.source = src;
|
|
this.exec = Executors.newCachedThreadPool();
|
|
pl.setCanConnect(false);
|
|
|
|
/*
|
|
* We need to load all players in cache ... It will took more time to
|
|
* load the server, but it will be much easier to check for an
|
|
* isAuthAvailable !
|
|
*/
|
|
exec.execute(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
for (PlayerAuth auth : source.getAllAuths()) {
|
|
cache.put(auth.getNickname().toLowerCase(), auth);
|
|
}
|
|
pl.setCanConnect(true);
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Method isAuthAvailable.
|
|
*
|
|
* @param user String
|
|
* @return boolean * @see fr.xephi.authme.datasource.DataSource#isAuthAvailable(String)
|
|
*/
|
|
@Override
|
|
public synchronized boolean isAuthAvailable(String user) {
|
|
return cache.containsKey(user.toLowerCase());
|
|
}
|
|
|
|
/**
|
|
* Method getAuth.
|
|
*
|
|
* @param user String
|
|
* @return PlayerAuth * @see fr.xephi.authme.datasource.DataSource#getAuth(String)
|
|
*/
|
|
@Override
|
|
public synchronized PlayerAuth getAuth(String user) {
|
|
user = user.toLowerCase();
|
|
if (cache.containsKey(user)) {
|
|
return cache.get(user);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Method saveAuth.
|
|
*
|
|
* @param auth PlayerAuth
|
|
* @return boolean * @see fr.xephi.authme.datasource.DataSource#saveAuth(PlayerAuth)
|
|
*/
|
|
@Override
|
|
public synchronized boolean saveAuth(final PlayerAuth auth) {
|
|
cache.put(auth.getNickname(), auth);
|
|
exec.execute(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
if (!source.saveAuth(auth)) {
|
|
cache.remove(auth.getNickname());
|
|
}
|
|
}
|
|
});
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Method updatePassword.
|
|
*
|
|
* @param auth PlayerAuth
|
|
* @return boolean * @see fr.xephi.authme.datasource.DataSource#updatePassword(PlayerAuth)
|
|
*/
|
|
@Override
|
|
public synchronized boolean updatePassword(final PlayerAuth auth) {
|
|
if (!cache.containsKey(auth.getNickname())) {
|
|
return false;
|
|
}
|
|
final String oldHash = cache.get(auth.getNickname()).getHash();
|
|
cache.get(auth.getNickname()).setHash(auth.getHash());
|
|
exec.execute(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
if (!source.updatePassword(auth)) {
|
|
if (cache.containsKey(auth.getNickname())) {
|
|
cache.get(auth.getNickname()).setHash(oldHash);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Method updateSession.
|
|
*
|
|
* @param auth PlayerAuth
|
|
* @return boolean * @see fr.xephi.authme.datasource.DataSource#updateSession(PlayerAuth)
|
|
*/
|
|
@Override
|
|
public boolean updateSession(final PlayerAuth auth) {
|
|
if (!cache.containsKey(auth.getNickname())) {
|
|
return false;
|
|
}
|
|
PlayerAuth cachedAuth = cache.get(auth.getNickname());
|
|
final String oldIp = cachedAuth.getIp();
|
|
final long oldLastLogin = cachedAuth.getLastLogin();
|
|
final String oldRealName = cachedAuth.getRealName();
|
|
|
|
cachedAuth.setIp(auth.getIp());
|
|
cachedAuth.setLastLogin(auth.getLastLogin());
|
|
cachedAuth.setRealName(auth.getRealName());
|
|
exec.execute(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
if (!source.updateSession(auth)) {
|
|
if (cache.containsKey(auth.getNickname())) {
|
|
PlayerAuth cachedAuth = cache.get(auth.getNickname());
|
|
cachedAuth.setIp(oldIp);
|
|
cachedAuth.setLastLogin(oldLastLogin);
|
|
cachedAuth.setRealName(oldRealName);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Method updateQuitLoc.
|
|
*
|
|
* @param auth PlayerAuth
|
|
* @return boolean * @see fr.xephi.authme.datasource.DataSource#updateQuitLoc(PlayerAuth)
|
|
*/
|
|
@Override
|
|
public boolean updateQuitLoc(final PlayerAuth auth) {
|
|
if (!cache.containsKey(auth.getNickname())) {
|
|
return false;
|
|
}
|
|
final PlayerAuth cachedAuth = cache.get(auth.getNickname());
|
|
final double oldX = cachedAuth.getQuitLocX();
|
|
final double oldY = cachedAuth.getQuitLocY();
|
|
final double oldZ = cachedAuth.getQuitLocZ();
|
|
final String oldWorld = cachedAuth.getWorld();
|
|
|
|
cachedAuth.setQuitLocX(auth.getQuitLocX());
|
|
cachedAuth.setQuitLocY(auth.getQuitLocY());
|
|
cachedAuth.setQuitLocZ(auth.getQuitLocZ());
|
|
cachedAuth.setWorld(auth.getWorld());
|
|
exec.execute(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
if (!source.updateQuitLoc(auth)) {
|
|
if (cache.containsKey(auth.getNickname())) {
|
|
PlayerAuth cachedAuth = cache.get(auth.getNickname());
|
|
cachedAuth.setQuitLocX(oldX);
|
|
cachedAuth.setQuitLocY(oldY);
|
|
cachedAuth.setQuitLocZ(oldZ);
|
|
cachedAuth.setWorld(oldWorld);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Method getIps.
|
|
*
|
|
* @param ip String
|
|
* @return int * @see fr.xephi.authme.datasource.DataSource#getIps(String)
|
|
*/
|
|
@Override
|
|
public int getIps(String ip) {
|
|
int count = 0;
|
|
for (Map.Entry<String, PlayerAuth> p : cache.entrySet()) {
|
|
if (p.getValue().getIp().equals(ip)) {
|
|
count++;
|
|
}
|
|
}
|
|
return count;
|
|
}
|
|
|
|
/**
|
|
* Method purgeDatabase.
|
|
*
|
|
* @param until long
|
|
* @return int * @see fr.xephi.authme.datasource.DataSource#purgeDatabase(long)
|
|
*/
|
|
@Override
|
|
public int purgeDatabase(long until) {
|
|
int cleared = source.purgeDatabase(until);
|
|
if (cleared > 0) {
|
|
for (PlayerAuth auth : cache.values()) {
|
|
if (auth.getLastLogin() < until) {
|
|
cache.remove(auth.getNickname());
|
|
}
|
|
}
|
|
}
|
|
return cleared;
|
|
}
|
|
|
|
/**
|
|
* Method autoPurgeDatabase.
|
|
*
|
|
* @param until long
|
|
* @return List<String> * @see fr.xephi.authme.datasource.DataSource#autoPurgeDatabase(long)
|
|
*/
|
|
@Override
|
|
public List<String> autoPurgeDatabase(long until) {
|
|
List<String> cleared = source.autoPurgeDatabase(until);
|
|
if (cleared.size() > 0) {
|
|
for (PlayerAuth auth : cache.values()) {
|
|
if (auth.getLastLogin() < until) {
|
|
cache.remove(auth.getNickname());
|
|
}
|
|
}
|
|
}
|
|
return cleared;
|
|
}
|
|
|
|
/**
|
|
* Method removeAuth.
|
|
*
|
|
* @param username String
|
|
* @return boolean * @see fr.xephi.authme.datasource.DataSource#removeAuth(String)
|
|
*/
|
|
@Override
|
|
public synchronized boolean removeAuth(String username) {
|
|
final String user = username.toLowerCase();
|
|
final PlayerAuth auth = cache.get(user);
|
|
cache.remove(user);
|
|
exec.execute(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
if (!source.removeAuth(user)) {
|
|
cache.put(user, auth);
|
|
}
|
|
}
|
|
});
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Method close.
|
|
*
|
|
* @see fr.xephi.authme.datasource.DataSource#close()
|
|
*/
|
|
@Override
|
|
public synchronized void close() {
|
|
exec.shutdown();
|
|
source.close();
|
|
}
|
|
|
|
/**
|
|
* Method reload.
|
|
*
|
|
* @see fr.xephi.authme.datasource.DataSource#reload()
|
|
*/
|
|
@Override
|
|
public void reload() {
|
|
exec.execute(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
cache.clear();
|
|
source.reload();
|
|
for (Player player : Utils.getOnlinePlayers()) {
|
|
String user = player.getName().toLowerCase();
|
|
if (PlayerCache.getInstance().isAuthenticated(user)) {
|
|
PlayerAuth auth = source.getAuth(user);
|
|
cache.put(user, auth);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Method updateEmail.
|
|
*
|
|
* @param auth PlayerAuth
|
|
* @return boolean * @see fr.xephi.authme.datasource.DataSource#updateEmail(PlayerAuth)
|
|
*/
|
|
@Override
|
|
public synchronized boolean updateEmail(final PlayerAuth auth) {
|
|
try {
|
|
return exec.submit(new Callable<Boolean>() {
|
|
public Boolean call() {
|
|
return source.updateEmail(auth);
|
|
}
|
|
}).get();
|
|
} catch (Exception e) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Method updateSalt.
|
|
*
|
|
* @param auth PlayerAuth
|
|
* @return boolean * @see fr.xephi.authme.datasource.DataSource#updateSalt(PlayerAuth)
|
|
*/
|
|
@Override
|
|
public synchronized boolean updateSalt(final PlayerAuth auth) {
|
|
if (!cache.containsKey(auth.getNickname())) {
|
|
return false;
|
|
}
|
|
PlayerAuth cachedAuth = cache.get(auth.getNickname());
|
|
final String oldSalt = cachedAuth.getSalt();
|
|
cachedAuth.setSalt(auth.getSalt());
|
|
exec.execute(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
if (!source.updateSalt(auth)) {
|
|
if (cache.containsKey(auth.getNickname())) {
|
|
cache.get(auth.getNickname()).setSalt(oldSalt);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Method getAllAuthsByName.
|
|
*
|
|
* @param auth PlayerAuth
|
|
* @return List<String> * @see fr.xephi.authme.datasource.DataSource#getAllAuthsByName(PlayerAuth)
|
|
*/
|
|
@Override
|
|
public synchronized List<String> getAllAuthsByName(PlayerAuth auth) {
|
|
List<String> result = new ArrayList<>();
|
|
for (Map.Entry<String, PlayerAuth> stringPlayerAuthEntry : cache.entrySet()) {
|
|
PlayerAuth p = stringPlayerAuthEntry.getValue();
|
|
if (p.getIp().equals(auth.getIp()))
|
|
result.add(p.getNickname());
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Method getAllAuthsByIp.
|
|
*
|
|
* @param ip String
|
|
* @return List<String> * @throws Exception * @see fr.xephi.authme.datasource.DataSource#getAllAuthsByIp(String)
|
|
*/
|
|
@Override
|
|
public synchronized List<String> getAllAuthsByIp(final String ip) throws Exception {
|
|
return exec.submit(new Callable<List<String>>() {
|
|
public List<String> call() throws Exception {
|
|
return source.getAllAuthsByIp(ip);
|
|
}
|
|
}).get();
|
|
}
|
|
|
|
/**
|
|
* Method getAllAuthsByEmail.
|
|
*
|
|
* @param email String
|
|
* @return List<String> * @throws Exception * @see fr.xephi.authme.datasource.DataSource#getAllAuthsByEmail(String)
|
|
*/
|
|
@Override
|
|
public synchronized List<String> getAllAuthsByEmail(final String email) throws Exception {
|
|
return exec.submit(new Callable<List<String>>() {
|
|
public List<String> call() throws Exception {
|
|
return source.getAllAuthsByEmail(email);
|
|
}
|
|
}).get();
|
|
}
|
|
|
|
/**
|
|
* Method purgeBanned.
|
|
*
|
|
* @param banned List<String>
|
|
* @see fr.xephi.authme.datasource.DataSource#purgeBanned(List<String>)
|
|
*/
|
|
@Override
|
|
public synchronized void purgeBanned(final List<String> banned) {
|
|
exec.execute(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
source.purgeBanned(banned);
|
|
for (PlayerAuth auth : cache.values()) {
|
|
if (banned.contains(auth.getNickname())) {
|
|
cache.remove(auth.getNickname());
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Method getType.
|
|
*
|
|
* @return DataSourceType * @see fr.xephi.authme.datasource.DataSource#getType()
|
|
*/
|
|
@Override
|
|
public DataSourceType getType() {
|
|
return source.getType();
|
|
}
|
|
|
|
/**
|
|
* Method isLogged.
|
|
*
|
|
* @param user String
|
|
* @return boolean * @see fr.xephi.authme.datasource.DataSource#isLogged(String)
|
|
*/
|
|
@Override
|
|
public boolean isLogged(String user) {
|
|
user = user.toLowerCase();
|
|
return PlayerCache.getInstance().getCache().containsKey(user);
|
|
}
|
|
|
|
/**
|
|
* Method setLogged.
|
|
*
|
|
* @param user String
|
|
* @see fr.xephi.authme.datasource.DataSource#setLogged(String)
|
|
*/
|
|
@Override
|
|
public void setLogged(final String user) {
|
|
exec.execute(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
source.setLogged(user.toLowerCase());
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Method setUnlogged.
|
|
*
|
|
* @param user String
|
|
* @see fr.xephi.authme.datasource.DataSource#setUnlogged(String)
|
|
*/
|
|
@Override
|
|
public void setUnlogged(final String user) {
|
|
exec.execute(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
source.setUnlogged(user.toLowerCase());
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Method purgeLogged.
|
|
*
|
|
* @see fr.xephi.authme.datasource.DataSource#purgeLogged()
|
|
*/
|
|
@Override
|
|
public void purgeLogged() {
|
|
exec.execute(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
source.purgeLogged();
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Method getAccountsRegistered.
|
|
*
|
|
* @return int * @see fr.xephi.authme.datasource.DataSource#getAccountsRegistered()
|
|
*/
|
|
@Override
|
|
public int getAccountsRegistered() {
|
|
return cache.size();
|
|
}
|
|
|
|
/**
|
|
* Method updateName.
|
|
*
|
|
* @param oldone String
|
|
* @param newone String
|
|
* @see fr.xephi.authme.datasource.DataSource#updateName(String, String)
|
|
*/
|
|
@Override
|
|
public void updateName(final String oldone, final String newone) {
|
|
if (cache.containsKey(oldone)) {
|
|
cache.put(newone, cache.get(oldone));
|
|
cache.remove(oldone);
|
|
}
|
|
exec.execute(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
source.updateName(oldone, newone);
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Method getAllAuths.
|
|
*
|
|
* @return List<PlayerAuth> * @see fr.xephi.authme.datasource.DataSource#getAllAuths()
|
|
*/
|
|
@Override
|
|
public List<PlayerAuth> getAllAuths() {
|
|
return new ArrayList<>(cache.values());
|
|
}
|
|
|
|
/**
|
|
* Method getLoggedPlayers.
|
|
*
|
|
* @return List<PlayerAuth> * @see fr.xephi.authme.datasource.DataSource#getLoggedPlayers()
|
|
*/
|
|
@Override
|
|
public List<PlayerAuth> getLoggedPlayers() {
|
|
return new ArrayList<>(PlayerCache.getInstance().getCache().values());
|
|
}
|
|
}
|