Merge branch '784-purgeservice-architecture' of https://github.com/AuthMe-Team/AuthMeReloaded
This commit is contained in:
ljacqu
commit
8fcb651ebb
@ -48,7 +48,7 @@ import fr.xephi.authme.settings.properties.RestrictionSettings;
|
||||
import fr.xephi.authme.settings.properties.SecuritySettings;
|
||||
import fr.xephi.authme.settings.properties.SettingsFieldRetriever;
|
||||
import fr.xephi.authme.settings.propertymap.PropertyMap;
|
||||
import fr.xephi.authme.task.PurgeService;
|
||||
import fr.xephi.authme.task.purge.PurgeService;
|
||||
import fr.xephi.authme.util.BukkitService;
|
||||
import fr.xephi.authme.util.FileUtils;
|
||||
import fr.xephi.authme.util.GeoLiteAPI;
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
package fr.xephi.authme.command.executable.authme;
|
||||
|
||||
import fr.xephi.authme.command.ExecutableCommand;
|
||||
import fr.xephi.authme.task.PurgeService;
|
||||
import fr.xephi.authme.task.purge.PurgeService;
|
||||
import fr.xephi.authme.util.BukkitService;
|
||||
import org.bukkit.OfflinePlayer;
|
||||
import org.bukkit.command.CommandSender;
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
package fr.xephi.authme.command.executable.authme;
|
||||
|
||||
import fr.xephi.authme.command.ExecutableCommand;
|
||||
import fr.xephi.authme.task.PurgeService;
|
||||
import fr.xephi.authme.task.purge.PurgeService;
|
||||
import org.bukkit.ChatColor;
|
||||
import org.bukkit.command.CommandSender;
|
||||
|
||||
|
||||
@ -15,6 +15,7 @@ import fr.xephi.authme.cache.auth.PlayerCache;
|
||||
import fr.xephi.authme.security.crypts.HashedPassword;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collection;
|
||||
import java.util.List;
|
||||
import java.util.Set;
|
||||
import java.util.concurrent.Callable;
|
||||
@ -184,7 +185,7 @@ public class CacheDataSource implements DataSource {
|
||||
}
|
||||
|
||||
@Override
|
||||
public void purgeRecords(final Set<String> banned) {
|
||||
public void purgeRecords(final Collection<String> banned) {
|
||||
source.purgeRecords(banned);
|
||||
cachedAuths.invalidateAll(banned);
|
||||
}
|
||||
|
||||
@ -4,6 +4,7 @@ import fr.xephi.authme.cache.auth.PlayerAuth;
|
||||
import fr.xephi.authme.initialization.Reloadable;
|
||||
import fr.xephi.authme.security.crypts.HashedPassword;
|
||||
|
||||
import java.util.Collection;
|
||||
import java.util.List;
|
||||
import java.util.Set;
|
||||
|
||||
@ -82,7 +83,7 @@ public interface DataSource extends Reloadable {
|
||||
*
|
||||
* @param toPurge The players to purge
|
||||
*/
|
||||
void purgeRecords(Set<String> toPurge);
|
||||
void purgeRecords(Collection<String> toPurge);
|
||||
|
||||
/**
|
||||
* Remove a user record from the database.
|
||||
|
||||
@ -17,6 +17,7 @@ import java.io.FileReader;
|
||||
import java.io.FileWriter;
|
||||
import java.io.IOException;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collection;
|
||||
import java.util.HashSet;
|
||||
import java.util.List;
|
||||
import java.util.Set;
|
||||
@ -256,35 +257,8 @@ public class FlatFile implements DataSource {
|
||||
}
|
||||
|
||||
@Override
|
||||
public void purgeRecords(Set<String> toPurge) {
|
||||
BufferedReader br = null;
|
||||
BufferedWriter bw = null;
|
||||
ArrayList<String> lines = new ArrayList<>();
|
||||
|
||||
try {
|
||||
br = new BufferedReader(new FileReader(source));
|
||||
bw = new BufferedWriter(new FileWriter(source));
|
||||
String line;
|
||||
while ((line = br.readLine()) != null) {
|
||||
String[] args = line.split(":");
|
||||
if (args.length >= 4) {
|
||||
if (toPurge.contains(args[0])) {
|
||||
lines.add(line);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (String l : lines) {
|
||||
bw.write(l + "\n");
|
||||
}
|
||||
} catch (IOException ex) {
|
||||
ConsoleLogger.warning(ex.getMessage());
|
||||
return;
|
||||
} finally {
|
||||
silentClose(br);
|
||||
silentClose(bw);
|
||||
}
|
||||
public void purgeRecords(Collection<String> toPurge) {
|
||||
throw new UnsupportedOperationException("Flat file no longer supported");
|
||||
}
|
||||
|
||||
@Override
|
||||
|
||||
@ -23,6 +23,7 @@ import java.sql.SQLException;
|
||||
import java.sql.Statement;
|
||||
import java.sql.Types;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collection;
|
||||
import java.util.HashSet;
|
||||
import java.util.List;
|
||||
import java.util.Set;
|
||||
@ -693,11 +694,11 @@ public class MySQL implements DataSource {
|
||||
}
|
||||
|
||||
@Override
|
||||
public void purgeRecords(Set<String> toPurge) {
|
||||
public void purgeRecords(Collection<String> toPurge) {
|
||||
String sql = "DELETE FROM " + tableName + " WHERE " + col.NAME + "=?;";
|
||||
try (Connection con = getConnection(); PreparedStatement pst = con.prepareStatement(sql)) {
|
||||
for (String name : toPurge) {
|
||||
pst.setString(1, name);
|
||||
pst.setString(1, name.toLowerCase());
|
||||
pst.executeUpdate();
|
||||
}
|
||||
} catch (SQLException ex) {
|
||||
|
||||
@ -16,6 +16,7 @@ import java.sql.ResultSet;
|
||||
import java.sql.SQLException;
|
||||
import java.sql.Statement;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collection;
|
||||
import java.util.HashSet;
|
||||
import java.util.List;
|
||||
import java.util.Set;
|
||||
@ -317,11 +318,11 @@ public class SQLite implements DataSource {
|
||||
}
|
||||
|
||||
@Override
|
||||
public void purgeRecords(Set<String> toPurge) {
|
||||
public void purgeRecords(Collection<String> toPurge) {
|
||||
String delete = "DELETE FROM " + tableName + " WHERE " + col.NAME + "=?;";
|
||||
try (PreparedStatement deletePst = con.prepareStatement(delete)) {
|
||||
for (String name : toPurge) {
|
||||
deletePst.setString(1, name);
|
||||
deletePst.setString(1, name.toLowerCase());
|
||||
deletePst.executeUpdate();
|
||||
}
|
||||
} catch (SQLException ex) {
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
package fr.xephi.authme.permission;
|
||||
|
||||
import org.bukkit.command.CommandSender;
|
||||
import org.bukkit.permissions.ServerOperator;
|
||||
|
||||
/**
|
||||
* The default permission to fall back to if there is no support for permission nodes.
|
||||
@ -10,12 +10,7 @@ public enum DefaultPermission {
|
||||
/** No one has permission. */
|
||||
NOT_ALLOWED("No permission") {
|
||||
@Override
|
||||
public boolean evaluate(CommandSender sender) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean evaluateOffline(String name) {
|
||||
public boolean evaluate(ServerOperator sender) {
|
||||
return false;
|
||||
}
|
||||
},
|
||||
@ -23,26 +18,15 @@ public enum DefaultPermission {
|
||||
/** Only players with OP status have permission. */
|
||||
OP_ONLY("OP's only") {
|
||||
@Override
|
||||
public boolean evaluate(CommandSender sender) {
|
||||
return sender.isOp();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean evaluateOffline(String name) {
|
||||
// TODO #784: Check if there is an elegant way to evaluate OP status
|
||||
return false;
|
||||
public boolean evaluate(ServerOperator sender) {
|
||||
return sender != null && sender.isOp();
|
||||
}
|
||||
},
|
||||
|
||||
/** Everyone is granted permission. */
|
||||
ALLOWED("Everyone allowed") {
|
||||
@Override
|
||||
public boolean evaluate(CommandSender sender) {
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean evaluateOffline(String name) {
|
||||
public boolean evaluate(ServerOperator sender) {
|
||||
return true;
|
||||
}
|
||||
};
|
||||
@ -64,15 +48,7 @@ public enum DefaultPermission {
|
||||
* @param sender the sender to process
|
||||
* @return true if the sender has permission, false otherwise
|
||||
*/
|
||||
public abstract boolean evaluate(CommandSender sender);
|
||||
|
||||
/**
|
||||
* Evaluate whether permission is granted to an offline user.
|
||||
*
|
||||
* @param name The name to check
|
||||
* @return True if the user has permission, false otherwise
|
||||
*/
|
||||
public abstract boolean evaluateOffline(String name);
|
||||
public abstract boolean evaluate(ServerOperator sender);
|
||||
|
||||
/**
|
||||
* Return the textual representation.
|
||||
|
||||
@ -12,6 +12,7 @@ import fr.xephi.authme.permission.handlers.VaultHandler;
|
||||
import fr.xephi.authme.permission.handlers.ZPermissionsHandler;
|
||||
import fr.xephi.authme.util.StringUtils;
|
||||
import org.anjocaido.groupmanager.GroupManager;
|
||||
import org.bukkit.OfflinePlayer;
|
||||
import org.bukkit.Server;
|
||||
import org.bukkit.command.CommandSender;
|
||||
import org.bukkit.entity.Player;
|
||||
@ -210,22 +211,33 @@ public class PermissionsManager implements Reloadable {
|
||||
* Check if a player has permission for the given permission node. This is for offline player checks. If no permissions
|
||||
* system is used, then the player will not have permission.
|
||||
*
|
||||
* @param name The name of the player.
|
||||
* @param permissionNode The permission node to verify.
|
||||
* @param player The offline player
|
||||
* @param permissionNode The permission node to verify
|
||||
*
|
||||
* @return
|
||||
* @return true if the player has permission, false otherwise
|
||||
*/
|
||||
public boolean hasPermissionOffline(String name, PermissionNode permissionNode) {
|
||||
public boolean hasPermissionOffline(OfflinePlayer player, PermissionNode permissionNode) {
|
||||
// Check if the permission node is null
|
||||
if (permissionNode == null) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (!isEnabled()) {
|
||||
return permissionNode.getDefaultPermission().evaluateOffline(name);
|
||||
return permissionNode.getDefaultPermission().evaluate(player);
|
||||
}
|
||||
|
||||
return handler.hasPermission(name, permissionNode);
|
||||
return handler.hasPermissionOffline(player.getName(), permissionNode);
|
||||
}
|
||||
|
||||
public boolean hasPermissionOffline(String name, PermissionNode permissionNode) {
|
||||
if (permissionNode == null) {
|
||||
return true;
|
||||
}
|
||||
if (!isEnabled()) {
|
||||
return permissionNode.getDefaultPermission().evaluate(null);
|
||||
}
|
||||
|
||||
return handler.hasPermissionOffline(name, permissionNode);
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@ -28,7 +28,7 @@ public class BPermissionsHandler implements PermissionHandler {
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean hasPermission(String name, PermissionNode node) {
|
||||
public boolean hasPermissionOffline(String name, PermissionNode node) {
|
||||
return ApiLayer.hasPermission(null, CalculableType.USER, name, node.getNode());
|
||||
}
|
||||
|
||||
|
||||
@ -36,7 +36,7 @@ public class GroupManagerHandler implements PermissionHandler {
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean hasPermission(String name, PermissionNode node) {
|
||||
public boolean hasPermissionOffline(String name, PermissionNode node) {
|
||||
final AnjoPermissionsHandler handler = groupManager.getWorldsHolder().getWorldPermissionsByPlayerName(name);
|
||||
List<String> perms = handler.getAllPlayersPermissions(name);
|
||||
return perms.contains(node.getNode());
|
||||
|
||||
@ -47,7 +47,7 @@ public interface PermissionHandler {
|
||||
*
|
||||
* @return True if the player has permission.
|
||||
*/
|
||||
boolean hasPermission(String name, PermissionNode node);
|
||||
boolean hasPermissionOffline(String name, PermissionNode node);
|
||||
|
||||
/**
|
||||
* Check whether the player is in the specified group.
|
||||
|
||||
@ -26,7 +26,7 @@ public class PermissionsBukkitHandler implements PermissionHandler {
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean hasPermission(String name, PermissionNode node) {
|
||||
public boolean hasPermissionOffline(String name, PermissionNode node) {
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
@ -44,7 +44,7 @@ public class PermissionsExHandler implements PermissionHandler {
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean hasPermission(String name, PermissionNode node) {
|
||||
public boolean hasPermissionOffline(String name, PermissionNode node) {
|
||||
PermissionUser user = permissionManager.getUser(name);
|
||||
return user.has(node.getNode());
|
||||
}
|
||||
|
||||
@ -50,7 +50,7 @@ public class VaultHandler implements PermissionHandler {
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean hasPermission(String name, PermissionNode node) {
|
||||
public boolean hasPermissionOffline(String name, PermissionNode node) {
|
||||
return vaultProvider.has("", name, node.getNode());
|
||||
}
|
||||
|
||||
|
||||
@ -43,7 +43,7 @@ public class ZPermissionsHandler implements PermissionHandler {
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean hasPermission(String name, PermissionNode node) {
|
||||
public boolean hasPermissionOffline(String name, PermissionNode node) {
|
||||
Map<String, Boolean> perms = zPermissionsService.getPlayerPermissions(null, null, name);
|
||||
if (perms.containsKey(node.getNode()))
|
||||
return perms.get(node.getNode());
|
||||
|
||||
@ -1,155 +1,67 @@
|
||||
package fr.xephi.authme.task;
|
||||
package fr.xephi.authme.task.purge;
|
||||
|
||||
import fr.xephi.authme.ConsoleLogger;
|
||||
import fr.xephi.authme.datasource.DataSource;
|
||||
import fr.xephi.authme.hooks.PluginHooks;
|
||||
import fr.xephi.authme.initialization.Reloadable;
|
||||
import fr.xephi.authme.permission.PermissionsManager;
|
||||
import fr.xephi.authme.permission.PlayerStatePermission;
|
||||
import fr.xephi.authme.settings.NewSetting;
|
||||
import fr.xephi.authme.settings.properties.PurgeSettings;
|
||||
import fr.xephi.authme.util.BukkitService;
|
||||
import fr.xephi.authme.util.CollectionUtils;
|
||||
import fr.xephi.authme.util.Utils;
|
||||
import org.bukkit.ChatColor;
|
||||
import org.bukkit.OfflinePlayer;
|
||||
import org.bukkit.Server;
|
||||
import org.bukkit.command.CommandSender;
|
||||
import org.bukkit.command.ConsoleCommandSender;
|
||||
|
||||
import javax.annotation.PostConstruct;
|
||||
import javax.inject.Inject;
|
||||
import java.io.File;
|
||||
import java.util.Calendar;
|
||||
import java.util.HashSet;
|
||||
import java.util.Set;
|
||||
import java.util.Collection;
|
||||
|
||||
import static fr.xephi.authme.util.StringUtils.makePath;
|
||||
|
||||
public class PurgeService implements Reloadable {
|
||||
|
||||
@Inject
|
||||
private BukkitService bukkitService;
|
||||
|
||||
@Inject
|
||||
private DataSource dataSource;
|
||||
/**
|
||||
* Executes the purge operations.
|
||||
*/
|
||||
class PurgeExecutor {
|
||||
|
||||
@Inject
|
||||
private NewSetting settings;
|
||||
|
||||
@Inject
|
||||
private DataSource dataSource;
|
||||
|
||||
@Inject
|
||||
private PermissionsManager permissionsManager;
|
||||
|
||||
@Inject
|
||||
private PluginHooks pluginHooks;
|
||||
|
||||
@Inject
|
||||
private BukkitService bukkitService;
|
||||
|
||||
@Inject
|
||||
private Server server;
|
||||
|
||||
private boolean isPurging = false;
|
||||
|
||||
// Settings
|
||||
private int daysBeforePurge;
|
||||
|
||||
/**
|
||||
* Return whether a purge is in progress.
|
||||
*
|
||||
* @return True if purging.
|
||||
*/
|
||||
public boolean isPurging() {
|
||||
return this.isPurging;
|
||||
PurgeExecutor() {
|
||||
}
|
||||
|
||||
/**
|
||||
* Set if a purge is currently in progress.
|
||||
* Performs the purge operations, i.e. deletes data and removes the files associated with the given
|
||||
* players and names.
|
||||
*
|
||||
* @param purging True if purging.
|
||||
* @param players the players to purge
|
||||
* @param names names to purge
|
||||
*/
|
||||
void setPurging(boolean purging) {
|
||||
this.isPurging = purging;
|
||||
public void executePurge(Collection<OfflinePlayer> players, Collection<String> names) {
|
||||
// Purge other data
|
||||
purgeFromAuthMe(names);
|
||||
purgeEssentials(players);
|
||||
purgeDat(players);
|
||||
purgeLimitedCreative(names);
|
||||
purgeAntiXray(names);
|
||||
purgePermissions(players);
|
||||
}
|
||||
|
||||
/**
|
||||
* Purges players from the database. Run on startup if enabled.
|
||||
*/
|
||||
public void runAutoPurge() {
|
||||
if (!settings.getProperty(PurgeSettings.USE_AUTO_PURGE)) {
|
||||
return;
|
||||
} else if (daysBeforePurge <= 0) {
|
||||
ConsoleLogger.warning("Did not run auto purge: configured days before purging must be positive");
|
||||
return;
|
||||
}
|
||||
|
||||
ConsoleLogger.info("Automatically purging the database...");
|
||||
Calendar calendar = Calendar.getInstance();
|
||||
calendar.add(Calendar.DATE, -daysBeforePurge);
|
||||
long until = calendar.getTimeInMillis();
|
||||
|
||||
runPurge(null, until);
|
||||
}
|
||||
|
||||
/**
|
||||
* Run a purge with a specified time.
|
||||
*
|
||||
* @param sender Sender running the command.
|
||||
* @param until The minimum last login.
|
||||
*/
|
||||
public void runPurge(CommandSender sender, long until) {
|
||||
//todo: note this should may run async because it may executes a SQL-Query
|
||||
Set<String> initialPurge = dataSource.getRecordsToPurge(until);
|
||||
if (CollectionUtils.isEmpty(initialPurge)) {
|
||||
logAndSendMessage(sender, "No players to purge");
|
||||
return;
|
||||
}
|
||||
|
||||
Set<String> toPurge = getFinalPurgeList(initialPurge);
|
||||
purgePlayers(sender, toPurge, bukkitService.getOfflinePlayers());
|
||||
}
|
||||
|
||||
/**
|
||||
* Purges the given list of player names.
|
||||
*
|
||||
* @param sender Sender running the command.
|
||||
* @param names The names to remove.
|
||||
* @param players Collection of OfflinePlayers (including those with the given names).
|
||||
*/
|
||||
public void purgePlayers(CommandSender sender, Set<String> names, OfflinePlayer[] players) {
|
||||
//todo: note this should may run async because it may executes a SQL-Query
|
||||
if (isPurging) {
|
||||
logAndSendMessage(sender, "Purge is already in progress! Aborting purge request");
|
||||
return;
|
||||
}
|
||||
|
||||
dataSource.purgeRecords(names);
|
||||
logAndSendMessage(sender, ChatColor.GOLD + "Deleted " + names.size() + " user accounts");
|
||||
logAndSendMessage(sender, ChatColor.GOLD + "Purging user accounts...");
|
||||
|
||||
isPurging = true;
|
||||
PurgeTask purgeTask = new PurgeTask(this, sender, names, players);
|
||||
bukkitService.runTaskAsynchronously(purgeTask);
|
||||
}
|
||||
|
||||
/**
|
||||
* Check each name in the initial purge findings to remove any player from the purge list
|
||||
* that has the bypass permission.
|
||||
*
|
||||
* @param initial The initial list of players to purge.
|
||||
*
|
||||
* @return The list of players to purge after permission check.
|
||||
*/
|
||||
private Set<String> getFinalPurgeList(Set<String> initial) {
|
||||
Set<String> toPurge = new HashSet<>();
|
||||
|
||||
for (String name : initial) {
|
||||
if (!permissionsManager.hasPermissionOffline(name, PlayerStatePermission.BYPASS_PURGE)) {
|
||||
toPurge.add(name);
|
||||
}
|
||||
}
|
||||
|
||||
return toPurge;
|
||||
}
|
||||
|
||||
synchronized void purgeAntiXray(Set<String> cleared) {
|
||||
synchronized void purgeAntiXray(Collection<String> cleared) {
|
||||
if (!settings.getProperty(PurgeSettings.REMOVE_ANTI_XRAY_FILE)) {
|
||||
return;
|
||||
}
|
||||
@ -173,7 +85,18 @@ public class PurgeService implements Reloadable {
|
||||
ConsoleLogger.info("AutoPurge: Removed " + i + " AntiXRayData Files");
|
||||
}
|
||||
|
||||
synchronized void purgeLimitedCreative(Set<String> cleared) {
|
||||
/**
|
||||
* Deletes the given accounts from AuthMe.
|
||||
*
|
||||
* @param names the name of the accounts to delete
|
||||
*/
|
||||
synchronized void purgeFromAuthMe(Collection<String> names) {
|
||||
dataSource.purgeRecords(names);
|
||||
// TODO ljacqu 20160717: We shouldn't output namedBanned.size() but the actual total that was deleted
|
||||
ConsoleLogger.info(ChatColor.GOLD + "Deleted " + names.size() + " user accounts");
|
||||
}
|
||||
|
||||
synchronized void purgeLimitedCreative(Collection<String> cleared) {
|
||||
if (!settings.getProperty(PurgeSettings.REMOVE_LIMITED_CREATIVE_INVENTORIES)) {
|
||||
return;
|
||||
}
|
||||
@ -214,7 +137,12 @@ public class PurgeService implements Reloadable {
|
||||
ConsoleLogger.info("AutoPurge: Removed " + i + " LimitedCreative Survival, Creative and Adventure files");
|
||||
}
|
||||
|
||||
synchronized void purgeDat(Set<OfflinePlayer> cleared) {
|
||||
/**
|
||||
* Removes the .dat file of the given players.
|
||||
*
|
||||
* @param cleared list of players to clear
|
||||
*/
|
||||
synchronized void purgeDat(Collection<OfflinePlayer> cleared) {
|
||||
if (!settings.getProperty(PurgeSettings.REMOVE_PLAYER_DAT)) {
|
||||
return;
|
||||
}
|
||||
@ -234,11 +162,11 @@ public class PurgeService implements Reloadable {
|
||||
}
|
||||
|
||||
/**
|
||||
* Method purgeEssentials.
|
||||
* Removes the Essentials userdata file of each given player.
|
||||
*
|
||||
* @param cleared List of String
|
||||
* @param cleared list of players to clear
|
||||
*/
|
||||
synchronized void purgeEssentials(Set<OfflinePlayer> cleared) {
|
||||
synchronized void purgeEssentials(Collection<OfflinePlayer> cleared) {
|
||||
if (!settings.getProperty(PurgeSettings.REMOVE_ESSENTIALS_FILES)) {
|
||||
return;
|
||||
}
|
||||
@ -267,7 +195,7 @@ public class PurgeService implements Reloadable {
|
||||
|
||||
// TODO: What is this method for? Is it correct?
|
||||
// TODO: Make it work with OfflinePlayers group data.
|
||||
synchronized void purgePermissions(Set<OfflinePlayer> cleared) {
|
||||
synchronized void purgePermissions(Collection<OfflinePlayer> cleared) {
|
||||
if (!settings.getProperty(PurgeSettings.REMOVE_PERMISSIONS)) {
|
||||
return;
|
||||
}
|
||||
@ -279,18 +207,5 @@ public class PurgeService implements Reloadable {
|
||||
|
||||
ConsoleLogger.info("AutoPurge: Removed permissions from " + cleared.size() + " player(s).");
|
||||
}
|
||||
|
||||
private static void logAndSendMessage(CommandSender sender, String message) {
|
||||
ConsoleLogger.info(message);
|
||||
// Make sure sender is not console user, which will see the message from ConsoleLogger already
|
||||
if (sender != null && !(sender instanceof ConsoleCommandSender)) {
|
||||
sender.sendMessage(message);
|
||||
}
|
||||
}
|
||||
|
||||
@PostConstruct
|
||||
@Override
|
||||
public void reload() {
|
||||
this.daysBeforePurge = settings.getProperty(PurgeSettings.DAYS_BEFORE_REMOVE_PLAYER);
|
||||
}
|
||||
|
||||
}
|
||||
123
src/main/java/fr/xephi/authme/task/purge/PurgeService.java
Normal file
123
src/main/java/fr/xephi/authme/task/purge/PurgeService.java
Normal file
@ -0,0 +1,123 @@
|
||||
package fr.xephi.authme.task.purge;
|
||||
|
||||
import fr.xephi.authme.ConsoleLogger;
|
||||
import fr.xephi.authme.datasource.DataSource;
|
||||
import fr.xephi.authme.permission.PermissionsManager;
|
||||
import fr.xephi.authme.settings.NewSetting;
|
||||
import fr.xephi.authme.settings.properties.PurgeSettings;
|
||||
import fr.xephi.authme.util.BukkitService;
|
||||
import fr.xephi.authme.util.CollectionUtils;
|
||||
import org.bukkit.OfflinePlayer;
|
||||
import org.bukkit.command.CommandSender;
|
||||
import org.bukkit.command.ConsoleCommandSender;
|
||||
|
||||
import javax.inject.Inject;
|
||||
import java.util.Calendar;
|
||||
import java.util.Collection;
|
||||
import java.util.Set;
|
||||
|
||||
public class PurgeService {
|
||||
|
||||
@Inject
|
||||
private BukkitService bukkitService;
|
||||
|
||||
@Inject
|
||||
private DataSource dataSource;
|
||||
|
||||
@Inject
|
||||
private NewSetting settings;
|
||||
|
||||
@Inject
|
||||
private PermissionsManager permissionsManager;
|
||||
|
||||
@Inject
|
||||
private PurgeExecutor purgeExecutor;
|
||||
|
||||
private boolean isPurging = false;
|
||||
|
||||
PurgeService() {
|
||||
}
|
||||
|
||||
/**
|
||||
* Purges players from the database. Runs on startup if enabled.
|
||||
*/
|
||||
public void runAutoPurge() {
|
||||
int daysBeforePurge = settings.getProperty(PurgeSettings.DAYS_BEFORE_REMOVE_PLAYER);
|
||||
if (!settings.getProperty(PurgeSettings.USE_AUTO_PURGE)) {
|
||||
return;
|
||||
} else if (daysBeforePurge <= 0) {
|
||||
ConsoleLogger.warning("Did not run auto purge: configured days before purging must be positive");
|
||||
return;
|
||||
}
|
||||
|
||||
ConsoleLogger.info("Automatically purging the database...");
|
||||
Calendar calendar = Calendar.getInstance();
|
||||
calendar.add(Calendar.DATE, -daysBeforePurge);
|
||||
long until = calendar.getTimeInMillis();
|
||||
|
||||
runPurge(null, until);
|
||||
}
|
||||
|
||||
/**
|
||||
* Runs a purge with a specified last login threshold. Players who haven't logged in since the threshold
|
||||
* will be purged.
|
||||
*
|
||||
* @param sender Sender running the command
|
||||
* @param until The last login threshold in milliseconds
|
||||
*/
|
||||
public void runPurge(CommandSender sender, long until) {
|
||||
//todo: note this should may run async because it may executes a SQL-Query
|
||||
Set<String> toPurge = dataSource.getRecordsToPurge(until);
|
||||
if (CollectionUtils.isEmpty(toPurge)) {
|
||||
logAndSendMessage(sender, "No players to purge");
|
||||
return;
|
||||
}
|
||||
|
||||
purgePlayers(sender, toPurge, bukkitService.getOfflinePlayers());
|
||||
}
|
||||
|
||||
/**
|
||||
* Purges the given list of player names.
|
||||
*
|
||||
* @param sender Sender running the command
|
||||
* @param names The names to remove
|
||||
* @param players Collection of OfflinePlayers (including those with the given names)
|
||||
*/
|
||||
public void purgePlayers(CommandSender sender, Set<String> names, OfflinePlayer[] players) {
|
||||
if (isPurging) {
|
||||
logAndSendMessage(sender, "Purge is already in progress! Aborting purge request");
|
||||
return;
|
||||
}
|
||||
|
||||
isPurging = true;
|
||||
PurgeTask purgeTask = new PurgeTask(this, permissionsManager, sender, names, players);
|
||||
bukkitService.runTaskTimer(purgeTask, 0, 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* Set if a purge is currently in progress.
|
||||
*
|
||||
* @param purging True if purging.
|
||||
*/
|
||||
void setPurging(boolean purging) {
|
||||
this.isPurging = purging;
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform purge operations for the given players and names.
|
||||
*
|
||||
* @param players the players (associated with the names)
|
||||
* @param names the lowercase names
|
||||
*/
|
||||
void executePurge(Collection<OfflinePlayer> players, Collection<String> names) {
|
||||
purgeExecutor.executePurge(players, names);
|
||||
}
|
||||
|
||||
private static void logAndSendMessage(CommandSender sender, String message) {
|
||||
ConsoleLogger.info(message);
|
||||
// Make sure sender is not console user, which will see the message from ConsoleLogger already
|
||||
if (sender != null && !(sender instanceof ConsoleCommandSender)) {
|
||||
sender.sendMessage(message);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,6 +1,8 @@
|
||||
package fr.xephi.authme.task;
|
||||
package fr.xephi.authme.task.purge;
|
||||
|
||||
import fr.xephi.authme.ConsoleLogger;
|
||||
import fr.xephi.authme.permission.PermissionsManager;
|
||||
import fr.xephi.authme.permission.PlayerStatePermission;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.ChatColor;
|
||||
import org.bukkit.OfflinePlayer;
|
||||
@ -12,12 +14,13 @@ import java.util.HashSet;
|
||||
import java.util.Set;
|
||||
import java.util.UUID;
|
||||
|
||||
public class PurgeTask extends BukkitRunnable {
|
||||
class PurgeTask extends BukkitRunnable {
|
||||
|
||||
//how many players we should check for each tick
|
||||
private static final int INTERVALL_CHECK = 5;
|
||||
private static final int INTERVAL_CHECK = 5;
|
||||
|
||||
private final PurgeService purgeService;
|
||||
private final PermissionsManager permissionsManager;
|
||||
private final UUID sender;
|
||||
private final Set<String> toPurge;
|
||||
|
||||
@ -26,8 +29,20 @@ public class PurgeTask extends BukkitRunnable {
|
||||
|
||||
private int currentPage = 0;
|
||||
|
||||
public PurgeTask(PurgeService service, CommandSender sender, Set<String> toPurge, OfflinePlayer[] offlinePlayers) {
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* @param service the purge service
|
||||
* @param permissionsManager the permissions manager
|
||||
* @param sender the sender who initiated the purge, or null
|
||||
* @param toPurge lowercase names to purge
|
||||
* @param offlinePlayers offline players to map to the names
|
||||
*/
|
||||
PurgeTask(PurgeService service, PermissionsManager permissionsManager, CommandSender sender,
|
||||
Set<String> toPurge, OfflinePlayer[] offlinePlayers) {
|
||||
this.purgeService = service;
|
||||
this.permissionsManager = permissionsManager;
|
||||
|
||||
if (sender instanceof Player) {
|
||||
this.sender = ((Player) sender).getUniqueId();
|
||||
} else {
|
||||
@ -47,20 +62,21 @@ public class PurgeTask extends BukkitRunnable {
|
||||
return;
|
||||
}
|
||||
|
||||
Set<OfflinePlayer> playerPortion = new HashSet<OfflinePlayer>(INTERVALL_CHECK);
|
||||
Set<String> namePortion = new HashSet<String>(INTERVALL_CHECK);
|
||||
for (int i = 0; i < INTERVALL_CHECK; i++) {
|
||||
int nextPosition = (currentPage * INTERVALL_CHECK) + i;
|
||||
Set<OfflinePlayer> playerPortion = new HashSet<>(INTERVAL_CHECK);
|
||||
Set<String> namePortion = new HashSet<>(INTERVAL_CHECK);
|
||||
for (int i = 0; i < INTERVAL_CHECK; i++) {
|
||||
int nextPosition = (currentPage * INTERVAL_CHECK) + i;
|
||||
if (offlinePlayers.length <= nextPosition) {
|
||||
//no more offline players on this page
|
||||
break;
|
||||
}
|
||||
|
||||
OfflinePlayer offlinePlayer = offlinePlayers[nextPosition];
|
||||
//remove to speed up later lookups
|
||||
if (toPurge.remove(offlinePlayer.getName().toLowerCase())) {
|
||||
playerPortion.add(offlinePlayer);
|
||||
namePortion.add(offlinePlayer.getName());
|
||||
if (!permissionsManager.hasPermissionOffline(offlinePlayer, PlayerStatePermission.BYPASS_PURGE)) {
|
||||
playerPortion.add(offlinePlayer);
|
||||
namePortion.add(offlinePlayer.getName());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -68,34 +84,29 @@ public class PurgeTask extends BukkitRunnable {
|
||||
ConsoleLogger.info("Finished lookup up offlinePlayers. Begin looking purging player names only");
|
||||
|
||||
//we went through all offlineplayers but there are still names remaining
|
||||
namePortion.addAll(toPurge);
|
||||
for (String name : toPurge) {
|
||||
if (!permissionsManager.hasPermissionOffline(name, PlayerStatePermission.BYPASS_PURGE)) {
|
||||
namePortion.add(name);
|
||||
}
|
||||
}
|
||||
toPurge.clear();
|
||||
}
|
||||
|
||||
currentPage++;
|
||||
purgeData(playerPortion, namePortion);
|
||||
purgeService.executePurge(playerPortion, namePortion);
|
||||
if (currentPage % 20 == 0) {
|
||||
int completed = totalPurgeCount - toPurge.size();
|
||||
sendMessage("[AuthMe] Purge progress " + completed + '/' + totalPurgeCount);
|
||||
}
|
||||
}
|
||||
|
||||
private void purgeData(Set<OfflinePlayer> playerPortion, Set<String> namePortion) {
|
||||
// Purge other data
|
||||
purgeService.purgeEssentials(playerPortion);
|
||||
purgeService.purgeDat(playerPortion);
|
||||
purgeService.purgeLimitedCreative(namePortion);
|
||||
purgeService.purgeAntiXray(namePortion);
|
||||
purgeService.purgePermissions(playerPortion);
|
||||
}
|
||||
|
||||
private void finish() {
|
||||
cancel();
|
||||
|
||||
// Show a status message
|
||||
sendMessage(ChatColor.GREEN + "[AuthMe] Database has been purged correctly");
|
||||
sendMessage(ChatColor.GREEN + "[AuthMe] Database has been purged successfully");
|
||||
|
||||
ConsoleLogger.info("Purge Finished!");
|
||||
ConsoleLogger.info("Purge finished!");
|
||||
purgeService.setPurging(false);
|
||||
}
|
||||
|
||||
@ -9,6 +9,9 @@ import org.bukkit.OfflinePlayer;
|
||||
import org.bukkit.World;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.event.Event;
|
||||
import org.bukkit.plugin.Plugin;
|
||||
import org.bukkit.scheduler.BukkitRunnable;
|
||||
import org.bukkit.scheduler.BukkitScheduler;
|
||||
import org.bukkit.scheduler.BukkitTask;
|
||||
|
||||
import javax.inject.Inject;
|
||||
@ -123,6 +126,22 @@ public class BukkitService {
|
||||
return Bukkit.getScheduler().runTaskLaterAsynchronously(authMe, task, delay);
|
||||
}
|
||||
|
||||
/**
|
||||
* Schedules the given task to repeatedly run until cancelled, starting after the
|
||||
* specified number of server ticks.
|
||||
*
|
||||
* @param task the task to schedule
|
||||
* @param delay the ticks to wait before running the task
|
||||
* @param period the ticks to wait between runs
|
||||
* @return a BukkitTask that contains the id number
|
||||
* @throws IllegalArgumentException if plugin is null
|
||||
* @throws IllegalStateException if this was already scheduled
|
||||
* @see BukkitScheduler#runTaskTimer(Plugin, Runnable, long, long)
|
||||
*/
|
||||
public BukkitTask runTaskTimer(BukkitRunnable task, long delay, long period) {
|
||||
return task.runTaskTimer(authMe, period, delay);
|
||||
}
|
||||
|
||||
/**
|
||||
* Broadcast a message to all players.
|
||||
*
|
||||
|
||||
@ -13,7 +13,7 @@ import fr.xephi.authme.process.Management;
|
||||
import fr.xephi.authme.process.login.ProcessSyncPlayerLogin;
|
||||
import fr.xephi.authme.security.PasswordSecurity;
|
||||
import fr.xephi.authme.settings.NewSetting;
|
||||
import fr.xephi.authme.task.PurgeService;
|
||||
import fr.xephi.authme.task.purge.PurgeService;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.Server;
|
||||
import org.bukkit.plugin.PluginDescriptionFile;
|
||||
@ -94,7 +94,7 @@ public class AuthMeInitializationTest {
|
||||
// given
|
||||
NewSetting settings = new NewSetting(settingsFile, dataFolder, getAllPropertyFields(), alwaysFulfilled());
|
||||
|
||||
// TODO ljacqu 20160619: At some point setting the "plugin" field should not longer be necessary
|
||||
// TODO ljacqu 20160619: At some point setting the "plugin" field should no longer be necessary
|
||||
// We only require it right now because of usages of AuthMe#getInstance()
|
||||
ReflectionTestUtils.setField(AuthMe.class, null, "plugin", authMe);
|
||||
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
package fr.xephi.authme.command.executable.authme;
|
||||
|
||||
import fr.xephi.authme.task.PurgeService;
|
||||
import fr.xephi.authme.task.purge.PurgeService;
|
||||
import fr.xephi.authme.util.BukkitService;
|
||||
import org.bukkit.OfflinePlayer;
|
||||
import org.bukkit.command.CommandSender;
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
package fr.xephi.authme.command.executable.authme;
|
||||
|
||||
import fr.xephi.authme.task.PurgeService;
|
||||
import fr.xephi.authme.task.purge.PurgeService;
|
||||
import org.bukkit.command.CommandSender;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
|
||||
@ -369,4 +369,17 @@ public abstract class AbstractDataSourceIntegrationTest {
|
||||
assertThat(dataSource.getLoggedPlayers(), empty());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldPerformPurgeOperation() {
|
||||
// given
|
||||
List<String> names = Arrays.asList("Bobby", "USER", "DoesnotExist");
|
||||
DataSource dataSource = getDataSource();
|
||||
|
||||
// when
|
||||
dataSource.purgeRecords(names);
|
||||
|
||||
// then
|
||||
assertThat(dataSource.getAllAuths(), empty());
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -219,7 +219,7 @@ public abstract class AbstractResourceClosingTest {
|
||||
|
||||
Object element = PARAM_VALUES.get(genericType);
|
||||
Preconditions.checkNotNull(element, "No sample element for list of generic type " + genericType);
|
||||
if (List.class == parameterizedType.getRawType()) {
|
||||
if (isAssignableFrom(parameterizedType.getRawType(), List.class)) {
|
||||
return Arrays.asList(element, element, element);
|
||||
} else if (Set.class == parameterizedType.getRawType()) {
|
||||
return new HashSet<>(Arrays.asList(element, element, element));
|
||||
@ -229,6 +229,11 @@ public abstract class AbstractResourceClosingTest {
|
||||
throw new IllegalStateException("Cannot build list for unexpected Type: " + type);
|
||||
}
|
||||
|
||||
private static boolean isAssignableFrom(Type type, Class<?> fromType) {
|
||||
return (type instanceof Class<?>)
|
||||
&& ((Class<?>) type).isAssignableFrom(fromType);
|
||||
}
|
||||
|
||||
/* Initialize the map of test values to pass to methods to satisfy their signature. */
|
||||
private static Map<Class<?>, Object> getDefaultParameters() {
|
||||
HashedPassword hash = new HashedPassword("test", "test");
|
||||
|
||||
@ -1,19 +1,13 @@
|
||||
package fr.xephi.authme.task;
|
||||
package fr.xephi.authme.task.purge;
|
||||
|
||||
import ch.jalu.injector.testing.BeforeInjecting;
|
||||
import ch.jalu.injector.testing.DelayedInjectionRunner;
|
||||
import ch.jalu.injector.testing.InjectDelayed;
|
||||
import fr.xephi.authme.ReflectionTestUtils;
|
||||
import fr.xephi.authme.TestHelper;
|
||||
import fr.xephi.authme.datasource.DataSource;
|
||||
import fr.xephi.authme.hooks.PluginHooks;
|
||||
import fr.xephi.authme.permission.PermissionsManager;
|
||||
import fr.xephi.authme.permission.PlayerStatePermission;
|
||||
import fr.xephi.authme.settings.NewSetting;
|
||||
import fr.xephi.authme.settings.properties.PurgeSettings;
|
||||
import fr.xephi.authme.util.BukkitService;
|
||||
import org.bukkit.OfflinePlayer;
|
||||
import org.bukkit.Server;
|
||||
import org.bukkit.command.CommandSender;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.hamcrest.Matchers;
|
||||
@ -21,10 +15,14 @@ import org.junit.BeforeClass;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.ArgumentCaptor;
|
||||
import org.mockito.InjectMocks;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.runners.MockitoJUnitRunner;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.Calendar;
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
import java.util.Set;
|
||||
import java.util.UUID;
|
||||
|
||||
@ -32,7 +30,6 @@ import static com.google.common.collect.Sets.newHashSet;
|
||||
import static org.hamcrest.Matchers.containsInAnyOrder;
|
||||
import static org.hamcrest.Matchers.containsString;
|
||||
import static org.hamcrest.Matchers.equalTo;
|
||||
import static org.hamcrest.Matchers.equalToIgnoringCase;
|
||||
import static org.hamcrest.Matchers.greaterThan;
|
||||
import static org.hamcrest.Matchers.not;
|
||||
import static org.junit.Assert.assertThat;
|
||||
@ -49,10 +46,10 @@ import static org.mockito.Mockito.verifyZeroInteractions;
|
||||
/**
|
||||
* Test for {@link PurgeService}.
|
||||
*/
|
||||
@RunWith(DelayedInjectionRunner.class)
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
public class PurgeServiceTest {
|
||||
|
||||
@InjectDelayed
|
||||
@InjectMocks
|
||||
private PurgeService purgeService;
|
||||
|
||||
@Mock
|
||||
@ -64,24 +61,18 @@ public class PurgeServiceTest {
|
||||
@Mock
|
||||
private PermissionsManager permissionsManager;
|
||||
@Mock
|
||||
private PluginHooks pluginHooks;
|
||||
@Mock
|
||||
private Server server;
|
||||
private PurgeExecutor executor;
|
||||
|
||||
@BeforeClass
|
||||
public static void initLogger() {
|
||||
TestHelper.setupLogger();
|
||||
}
|
||||
|
||||
@BeforeInjecting
|
||||
public void initSettingDefaults() {
|
||||
given(settings.getProperty(PurgeSettings.DAYS_BEFORE_REMOVE_PLAYER)).willReturn(60);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldNotRunAutoPurge() {
|
||||
// given
|
||||
given(settings.getProperty(PurgeSettings.USE_AUTO_PURGE)).willReturn(false);
|
||||
given(settings.getProperty(PurgeSettings.DAYS_BEFORE_REMOVE_PLAYER)).willReturn(60);
|
||||
|
||||
// when
|
||||
purgeService.runAutoPurge();
|
||||
@ -95,7 +86,6 @@ public class PurgeServiceTest {
|
||||
// given
|
||||
given(settings.getProperty(PurgeSettings.USE_AUTO_PURGE)).willReturn(true);
|
||||
given(settings.getProperty(PurgeSettings.DAYS_BEFORE_REMOVE_PLAYER)).willReturn(0);
|
||||
purgeService.reload();
|
||||
|
||||
// when
|
||||
purgeService.runAutoPurge();
|
||||
@ -109,10 +99,9 @@ public class PurgeServiceTest {
|
||||
// given
|
||||
given(settings.getProperty(PurgeSettings.USE_AUTO_PURGE)).willReturn(true);
|
||||
given(settings.getProperty(PurgeSettings.DAYS_BEFORE_REMOVE_PLAYER)).willReturn(60);
|
||||
String[] playerNames = {"alpha", "bravo", "charlie", "delta"};
|
||||
given(dataSource.getRecordsToPurge(anyLong())).willReturn(newHashSet(playerNames));
|
||||
Set<String> playerNames = newHashSet("alpha", "bravo", "charlie", "delta");
|
||||
given(dataSource.getRecordsToPurge(anyLong())).willReturn(playerNames);
|
||||
mockReturnedOfflinePlayers();
|
||||
mockHasBypassPurgePermission("bravo", "delta");
|
||||
|
||||
// when
|
||||
purgeService.runAutoPurge();
|
||||
@ -121,13 +110,13 @@ public class PurgeServiceTest {
|
||||
ArgumentCaptor<Long> captor = ArgumentCaptor.forClass(Long.class);
|
||||
verify(dataSource).getRecordsToPurge(captor.capture());
|
||||
assertCorrectPurgeTimestamp(captor.getValue(), 60);
|
||||
verify(dataSource).purgeRecords(newHashSet("alpha", "charlie"));
|
||||
assertThat(purgeService.isPurging(), equalTo(true));
|
||||
verifyScheduledPurgeTask(null, "alpha", "charlie");
|
||||
assertThat(Boolean.TRUE, equalTo(
|
||||
ReflectionTestUtils.getFieldValue(PurgeService.class, purgeService, "isPurging")));
|
||||
verifyScheduledPurgeTask(null, playerNames);
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
@Test
|
||||
@SuppressWarnings("unchecked")
|
||||
public void shouldRecognizeNoPlayersToPurge() {
|
||||
// given
|
||||
long delay = 123012301L;
|
||||
@ -148,9 +137,9 @@ public class PurgeServiceTest {
|
||||
public void shouldRunPurge() {
|
||||
// given
|
||||
long delay = 1809714L;
|
||||
given(dataSource.getRecordsToPurge(delay)).willReturn(newHashSet("charlie", "delta", "echo", "foxtrot"));
|
||||
Set<String> playerNames = newHashSet("charlie", "delta", "echo", "foxtrot");
|
||||
given(dataSource.getRecordsToPurge(delay)).willReturn(playerNames);
|
||||
mockReturnedOfflinePlayers();
|
||||
mockHasBypassPurgePermission("echo");
|
||||
Player sender = mock(Player.class);
|
||||
UUID uuid = UUID.randomUUID();
|
||||
given(sender.getUniqueId()).willReturn(uuid);
|
||||
@ -160,13 +149,11 @@ public class PurgeServiceTest {
|
||||
|
||||
// then
|
||||
verify(dataSource).getRecordsToPurge(delay);
|
||||
verify(dataSource).purgeRecords(newHashSet("charlie", "delta", "foxtrot"));
|
||||
verify(sender).sendMessage(argThat(containsString("Deleted 3 user accounts")));
|
||||
verifyScheduledPurgeTask(uuid, "charlie", "delta", "foxtrot");
|
||||
verifyScheduledPurgeTask(uuid, playerNames);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldRunPurgeIfProcessIsAlreadyRunning() {
|
||||
public void shouldNotRunPurgeIfProcessIsAlreadyRunning() {
|
||||
// given
|
||||
purgeService.setPurging(true);
|
||||
CommandSender sender = mock(CommandSender.class);
|
||||
@ -180,6 +167,19 @@ public class PurgeServiceTest {
|
||||
verifyZeroInteractions(bukkitService, dataSource, permissionsManager);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldExecutePurgeActions() {
|
||||
// given
|
||||
List<OfflinePlayer> players = Arrays.asList(mockReturnedOfflinePlayers());
|
||||
List<String> names = Arrays.asList("alpha", "bravo", "foxtrot");
|
||||
|
||||
// when
|
||||
purgeService.executePurge(players, names);
|
||||
|
||||
// then
|
||||
verify(executor).executePurge(players, names);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns mock OfflinePlayer objects with names corresponding to A - G of the NATO phonetic alphabet,
|
||||
* in various casing.
|
||||
@ -198,18 +198,6 @@ public class PurgeServiceTest {
|
||||
return players;
|
||||
}
|
||||
|
||||
/**
|
||||
* Mocks the permission manager to say that the given names have the bypass purge permission.
|
||||
*
|
||||
* @param names the names
|
||||
*/
|
||||
private void mockHasBypassPurgePermission(String... names) {
|
||||
for (String name : names) {
|
||||
given(permissionsManager.hasPermissionOffline(
|
||||
argThat(equalToIgnoringCase(name)), eq(PlayerStatePermission.BYPASS_PURGE))).willReturn(true);
|
||||
}
|
||||
}
|
||||
|
||||
private void assertCorrectPurgeTimestamp(long timestamp, int configuredDays) {
|
||||
final long toleranceMillis = 100L;
|
||||
Calendar cal = Calendar.getInstance();
|
||||
@ -221,14 +209,14 @@ public class PurgeServiceTest {
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
private void verifyScheduledPurgeTask(UUID uuid, String... names) {
|
||||
private void verifyScheduledPurgeTask(UUID senderUuid, Set<String> names) {
|
||||
ArgumentCaptor<PurgeTask> captor = ArgumentCaptor.forClass(PurgeTask.class);
|
||||
verify(bukkitService).runTaskAsynchronously(captor.capture());
|
||||
verify(bukkitService).runTaskTimer(captor.capture(), eq(0L), eq(1L));
|
||||
PurgeTask task = captor.getValue();
|
||||
|
||||
Object senderInTask = ReflectionTestUtils.getFieldValue(PurgeTask.class, task, "sender");
|
||||
Set<String> namesInTask = (Set<String>) ReflectionTestUtils.getFieldValue(PurgeTask.class, task, "toPurge");
|
||||
assertThat(senderInTask, Matchers.<Object>equalTo(uuid));
|
||||
assertThat(namesInTask, containsInAnyOrder(names));
|
||||
assertThat(senderInTask, Matchers.<Object>equalTo(senderUuid));
|
||||
assertThat(namesInTask, containsInAnyOrder(names.toArray()));
|
||||
}
|
||||
}
|
||||
221
src/test/java/fr/xephi/authme/task/purge/PurgeTaskTest.java
Normal file
221
src/test/java/fr/xephi/authme/task/purge/PurgeTaskTest.java
Normal file
@ -0,0 +1,221 @@
|
||||
package fr.xephi.authme.task.purge;
|
||||
|
||||
import fr.xephi.authme.ReflectionTestUtils;
|
||||
import fr.xephi.authme.TestHelper;
|
||||
import fr.xephi.authme.permission.PermissionNode;
|
||||
import fr.xephi.authme.permission.PermissionsManager;
|
||||
import fr.xephi.authme.permission.PlayerStatePermission;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.OfflinePlayer;
|
||||
import org.bukkit.Server;
|
||||
import org.bukkit.command.ConsoleCommandSender;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.scheduler.BukkitRunnable;
|
||||
import org.bukkit.scheduler.BukkitScheduler;
|
||||
import org.junit.BeforeClass;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.ArgumentCaptor;
|
||||
import org.mockito.Captor;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.invocation.InvocationOnMock;
|
||||
import org.mockito.runners.MockitoJUnitRunner;
|
||||
import org.mockito.stubbing.Answer;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collection;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
import java.util.UUID;
|
||||
|
||||
import static com.google.common.collect.Sets.newHashSet;
|
||||
import static org.hamcrest.Matchers.containsInAnyOrder;
|
||||
import static org.hamcrest.Matchers.containsString;
|
||||
import static org.hamcrest.Matchers.empty;
|
||||
import static org.junit.Assert.assertThat;
|
||||
import static org.mockito.BDDMockito.given;
|
||||
import static org.mockito.Matchers.any;
|
||||
import static org.mockito.Matchers.anyString;
|
||||
import static org.mockito.Matchers.argThat;
|
||||
import static org.mockito.Matchers.eq;
|
||||
import static org.mockito.Mockito.mock;
|
||||
import static org.mockito.Mockito.never;
|
||||
import static org.mockito.Mockito.reset;
|
||||
import static org.mockito.Mockito.times;
|
||||
import static org.mockito.Mockito.verify;
|
||||
|
||||
/**
|
||||
* Test for {@link PurgeTask}.
|
||||
*/
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
public class PurgeTaskTest {
|
||||
|
||||
private static final PermissionNode BYPASS_NODE = PlayerStatePermission.BYPASS_PURGE;
|
||||
|
||||
private Map<OfflinePlayer, Boolean> playerBypassAssignments = new HashMap<>();
|
||||
|
||||
@Mock
|
||||
private PermissionsManager permissionsManager;
|
||||
|
||||
@Mock
|
||||
private PurgeService purgeService;
|
||||
|
||||
@Captor
|
||||
private ArgumentCaptor<Collection<OfflinePlayer>> playerCaptor;
|
||||
|
||||
@Captor
|
||||
private ArgumentCaptor<Collection<String>> namesCaptor;
|
||||
|
||||
@BeforeClass
|
||||
public static void initLogger() {
|
||||
TestHelper.setupLogger();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldRunTask() {
|
||||
// given
|
||||
Set<String> names =
|
||||
newHashSet("alpha", "bravo", "charlie", "delta", "echo", "foxtrot", "golf", "hotel", "india");
|
||||
// alpha and echo have bypass permission
|
||||
// Foxtrot and india are not present as OfflinePlayer
|
||||
// Additionally, BOGUS and 123456 are not present in the names list
|
||||
OfflinePlayer[] players = asArray(
|
||||
mockOfflinePlayer("Alpha", true), mockOfflinePlayer("BOGUS", false), mockOfflinePlayer("charlie", false),
|
||||
mockOfflinePlayer("Delta", false), mockOfflinePlayer("BRAVO", false), mockOfflinePlayer("Echo", true),
|
||||
mockOfflinePlayer("Golf", false), mockOfflinePlayer("123456", false), mockOfflinePlayer("HOTEL", false));
|
||||
reset(purgeService, permissionsManager);
|
||||
setPermissionsBehavior();
|
||||
PurgeTask task = new PurgeTask(purgeService, permissionsManager, null, names, players);
|
||||
|
||||
// when (1 - first run, 5 players per run)
|
||||
task.run();
|
||||
|
||||
// then (1)
|
||||
// In the first run, Alpha to BRAVO (see players list above) went through. One of those players is not present
|
||||
// in the names list, so expect the permission manager to have been called four times
|
||||
verify(permissionsManager, times(4)).hasPermissionOffline(any(OfflinePlayer.class), eq(BYPASS_NODE));
|
||||
// Alpha has the bypass permission, so we expect charlie, Delta and BRAVO to be purged
|
||||
assertRanPurgeWithPlayers(players[2], players[3], players[4]);
|
||||
|
||||
// when (2)
|
||||
reset(purgeService, permissionsManager);
|
||||
setPermissionsBehavior();
|
||||
task.run();
|
||||
|
||||
// then (2)
|
||||
// Echo, Golf, HOTEL
|
||||
verify(permissionsManager, times(3)).hasPermissionOffline(any(OfflinePlayer.class), eq(BYPASS_NODE));
|
||||
assertRanPurgeWithPlayers(players[6], players[8]);
|
||||
|
||||
// given (3)
|
||||
// Third round: no more OfflinePlayer objects, but some names remain
|
||||
reset(purgeService, permissionsManager);
|
||||
given(permissionsManager.hasPermissionOffline("india", BYPASS_NODE)).willReturn(true);
|
||||
|
||||
// when (3)
|
||||
task.run();
|
||||
|
||||
// then (3)
|
||||
// We no longer have any OfflinePlayers, so lookup of permissions was done with the names
|
||||
verify(permissionsManager, times(2)).hasPermissionOffline(anyString(), eq(BYPASS_NODE));
|
||||
verify(permissionsManager, never()).hasPermissionOffline(any(OfflinePlayer.class), any(PermissionNode.class));
|
||||
assertRanPurgeWithNames("foxtrot");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldStopTaskAndInformSenderUponCompletion() {
|
||||
// given
|
||||
Set<String> names = newHashSet("name1", "name2");
|
||||
Player sender = mock(Player.class);
|
||||
UUID uuid = UUID.randomUUID();
|
||||
given(sender.getUniqueId()).willReturn(uuid);
|
||||
PurgeTask task = new PurgeTask(purgeService, permissionsManager, sender, names, new OfflinePlayer[0]);
|
||||
|
||||
ReflectionTestUtils.setField(BukkitRunnable.class, task, "taskId", 10049);
|
||||
Server server = mock(Server.class);
|
||||
BukkitScheduler scheduler = mock(BukkitScheduler.class);
|
||||
given(server.getScheduler()).willReturn(scheduler);
|
||||
ReflectionTestUtils.setField(Bukkit.class, null, "server", server);
|
||||
given(server.getPlayer(uuid)).willReturn(sender);
|
||||
|
||||
task.run(); // Run for the first time -> results in empty names list
|
||||
|
||||
// when
|
||||
task.run();
|
||||
|
||||
// then
|
||||
verify(scheduler).cancelTask(task.getTaskId());
|
||||
verify(sender).sendMessage(argThat(containsString("Database has been purged successfully")));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldStopTaskAndInformConsoleUser() {
|
||||
// given
|
||||
Set<String> names = newHashSet("name1", "name2");
|
||||
PurgeTask task = new PurgeTask(purgeService, permissionsManager, null, names, new OfflinePlayer[0]);
|
||||
|
||||
ReflectionTestUtils.setField(BukkitRunnable.class, task, "taskId", 10049);
|
||||
Server server = mock(Server.class);
|
||||
BukkitScheduler scheduler = mock(BukkitScheduler.class);
|
||||
given(server.getScheduler()).willReturn(scheduler);
|
||||
ReflectionTestUtils.setField(Bukkit.class, null, "server", server);
|
||||
ConsoleCommandSender consoleSender = mock(ConsoleCommandSender.class);
|
||||
given(server.getConsoleSender()).willReturn(consoleSender);
|
||||
|
||||
task.run(); // Run for the first time -> results in empty names list
|
||||
|
||||
// when
|
||||
task.run();
|
||||
|
||||
// then
|
||||
verify(scheduler).cancelTask(task.getTaskId());
|
||||
verify(consoleSender).sendMessage(argThat(containsString("Database has been purged successfully")));
|
||||
}
|
||||
|
||||
|
||||
private OfflinePlayer mockOfflinePlayer(String name, boolean hasBypassPermission) {
|
||||
OfflinePlayer player = mock(OfflinePlayer.class);
|
||||
given(player.getName()).willReturn(name);
|
||||
playerBypassAssignments.put(player, hasBypassPermission);
|
||||
return player;
|
||||
}
|
||||
|
||||
private OfflinePlayer[] asArray(OfflinePlayer... players) {
|
||||
return players;
|
||||
}
|
||||
|
||||
private void setPermissionsBehavior() {
|
||||
given(permissionsManager.hasPermissionOffline(any(OfflinePlayer.class), eq(BYPASS_NODE)))
|
||||
.willAnswer(new Answer<Boolean>() {
|
||||
@Override
|
||||
public Boolean answer(InvocationOnMock invocationOnMock) throws Throwable {
|
||||
OfflinePlayer player = (OfflinePlayer) invocationOnMock.getArguments()[0];
|
||||
Boolean hasPermission = playerBypassAssignments.get(player);
|
||||
if (hasPermission == null) {
|
||||
throw new IllegalStateException("Unexpected check of '" + BYPASS_NODE
|
||||
+ "' with player = " + player);
|
||||
}
|
||||
return hasPermission;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
private void assertRanPurgeWithPlayers(OfflinePlayer... players) {
|
||||
List<String> names = new ArrayList<>(players.length);
|
||||
for (OfflinePlayer player : players) {
|
||||
names.add(player.getName());
|
||||
}
|
||||
verify(purgeService).executePurge(playerCaptor.capture(), namesCaptor.capture());
|
||||
assertThat(namesCaptor.getValue(), containsInAnyOrder(names.toArray()));
|
||||
assertThat(playerCaptor.getValue(), containsInAnyOrder(players));
|
||||
}
|
||||
|
||||
private void assertRanPurgeWithNames(String... names) {
|
||||
verify(purgeService).executePurge(playerCaptor.capture(), namesCaptor.capture());
|
||||
assertThat(namesCaptor.getValue(), containsInAnyOrder(names));
|
||||
assertThat(playerCaptor.getValue(), empty());
|
||||
}
|
||||
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user