Meishin/LoginSystem
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Del all files

Browse Source
This commit is contained in:
HaHaWTH
2023-07-11 20:42:24 +08:00
parent 912e607144
commit b014da245d
475 changed files with 0 additions and 93277 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/main/java/fr/xephi/authme/task/CleanupTask.java
-25
View File
@@ -1,25 +0,0 @@
package fr.xephi.authme.task;
import ch.jalu.injector.factory.SingletonStore;
import fr.xephi.authme.initialization.HasCleanup;
import org.bukkit.scheduler.BukkitRunnable;
import javax.inject.Inject;
/**
* Task run periodically to invoke the cleanup task on services.
*/
public class CleanupTask extends BukkitRunnable {
@Inject
private SingletonStore<HasCleanup> hasCleanupStore;
CleanupTask() {
}
@Override
public void run() {
hasCleanupStore.retrieveAllOfType()
.forEach(HasCleanup::performCleanup);
}
}
src/main/java/fr/xephi/authme/task/MessageTask.java
-34
View File
@@ -1,34 +0,0 @@
package fr.xephi.authme.task;
import org.bukkit.entity.Player;
import org.bukkit.scheduler.BukkitRunnable;
/**
* Message shown to a player in a regular interval as long as he is not logged in.
*/
public class MessageTask extends BukkitRunnable {
private final Player player;
private final String[] message;
private boolean isMuted;
/*
* Constructor.
*/
public MessageTask(Player player, String[] lines) {
this.player = player;
this.message = lines;
isMuted = false;
}
public void setMuted(boolean isMuted) {
this.isMuted = isMuted;
}
@Override
public void run() {
if (!isMuted) {
player.sendMessage(message);
}
}
}
src/main/java/fr/xephi/authme/task/TimeoutTask.java
-34
View File
@@ -1,34 +0,0 @@
package fr.xephi.authme.task;
import fr.xephi.authme.data.auth.PlayerCache;
import org.bukkit.entity.Player;
/**
* Kicks a player if he hasn't logged in (scheduled to run after a configured delay).
*/
public class TimeoutTask implements Runnable {
private final Player player;
private final String message;
private final PlayerCache playerCache;
/**
* Constructor for TimeoutTask.
*
* @param player the player to check
* @param message the kick message
* @param playerCache player cache instance
*/
public TimeoutTask(Player player, String message, PlayerCache playerCache) {
this.message = message;
this.player = player;
this.playerCache = playerCache;
}
@Override
public void run() {
if (!playerCache.isAuthenticated(player.getName())) {
player.kickPlayer(message);
}
}
}
src/main/java/fr/xephi/authme/task/purge/PurgeExecutor.java
-227
View File
@@ -1,227 +0,0 @@
package fr.xephi.authme.task.purge;
import fr.xephi.authme.ConsoleLogger;
import fr.xephi.authme.datasource.DataSource;
import fr.xephi.authme.output.ConsoleLoggerFactory;
import fr.xephi.authme.permission.PermissionsManager;
import fr.xephi.authme.service.BukkitService;
import fr.xephi.authme.service.PluginHookService;
import fr.xephi.authme.settings.Settings;
import fr.xephi.authme.settings.properties.PurgeSettings;
import org.bukkit.ChatColor;
import org.bukkit.OfflinePlayer;
import org.bukkit.Server;
import javax.inject.Inject;
import java.io.File;
import java.util.Collection;
import java.util.Locale;
import static fr.xephi.authme.util.FileUtils.makePath;
/**
* Executes the purge operations.
*/
public class PurgeExecutor {
private final ConsoleLogger logger = ConsoleLoggerFactory.get(PurgeExecutor.class);
@Inject
private Settings settings;
@Inject
private DataSource dataSource;
@Inject
private PermissionsManager permissionsManager;
@Inject
private PluginHookService pluginHookService;
@Inject
private BukkitService bukkitService;
@Inject
private Server server;
PurgeExecutor() {
}
/**
* Performs the purge operations, i.e. deletes data and removes the files associated with the given
* players and names.
*
* @param players the players to purge
* @param names names to purge
*/
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 data from the AntiXray plugin.
*
* @param cleared the players whose data should be cleared
*/
synchronized void purgeAntiXray(Collection<String> cleared) {
if (!settings.getProperty(PurgeSettings.REMOVE_ANTI_XRAY_FILE)) {
return;
}
int i = 0;
File dataFolder = new File(makePath(".", "plugins", "AntiXRayData", "PlayerData"));
if (!dataFolder.exists() || !dataFolder.isDirectory()) {
return;
}
for (String file : dataFolder.list()) {
if (cleared.contains(file.toLowerCase(Locale.ROOT))) {
File playerFile = new File(dataFolder, file);
if (playerFile.exists() && playerFile.delete()) {
i++;
}
}
}
logger.info("AutoPurge: Removed " + i + " AntiXRayData Files");
}
/**
* 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
logger.info(ChatColor.GOLD + "Deleted " + names.size() + " user accounts");
}
/**
* Purges data from the LimitedCreative plugin.
*
* @param cleared the players whose data should be cleared
*/
synchronized void purgeLimitedCreative(Collection<String> cleared) {
if (!settings.getProperty(PurgeSettings.REMOVE_LIMITED_CREATIVE_INVENTORIES)) {
return;
}
int i = 0;
File dataFolder = new File(makePath(".", "plugins", "LimitedCreative", "inventories"));
if (!dataFolder.exists() || !dataFolder.isDirectory()) {
return;
}
for (String file : dataFolder.list()) {
String name = file;
int idx;
idx = file.lastIndexOf("_creative.yml");
if (idx != -1) {
name = name.substring(0, idx);
} else {
idx = file.lastIndexOf("_adventure.yml");
if (idx != -1) {
name = name.substring(0, idx);
} else {
idx = file.lastIndexOf(".yml");
if (idx != -1) {
name = name.substring(0, idx);
}
}
}
if (name.equals(file)) {
continue;
}
if (cleared.contains(name.toLowerCase(Locale.ROOT))) {
File dataFile = new File(dataFolder, file);
if (dataFile.exists() && dataFile.delete()) {
i++;
}
}
}
logger.info("AutoPurge: Removed " + i + " LimitedCreative Survival, Creative and Adventure files");
}
/**
* 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;
}
int i = 0;
File dataFolder = new File(server.getWorldContainer(),
makePath(settings.getProperty(PurgeSettings.DEFAULT_WORLD), "players"));
for (OfflinePlayer offlinePlayer : cleared) {
File playerFile = new File(dataFolder, offlinePlayer.getUniqueId() + ".dat");
if (playerFile.delete()) {
i++;
}
}
logger.info("AutoPurge: Removed " + i + " .dat Files");
}
/**
* Removes the Essentials userdata file of each given player.
*
* @param cleared list of players to clear
*/
synchronized void purgeEssentials(Collection<OfflinePlayer> cleared) {
if (!settings.getProperty(PurgeSettings.REMOVE_ESSENTIALS_FILES)) {
return;
}
File essentialsDataFolder = pluginHookService.getEssentialsDataFolder();
if (essentialsDataFolder == null) {
logger.info("Cannot purge Essentials: plugin is not loaded");
return;
}
final File userDataFolder = new File(essentialsDataFolder, "userdata");
if (!userDataFolder.exists() || !userDataFolder.isDirectory()) {
return;
}
int deletedFiles = 0;
for (OfflinePlayer offlinePlayer : cleared) {
File playerFile = new File(userDataFolder, offlinePlayer.getUniqueId() + ".yml");
if (playerFile.exists() && playerFile.delete()) {
deletedFiles++;
}
}
logger.info("AutoPurge: Removed " + deletedFiles + " EssentialsFiles");
}
/**
* Removes permission data (groups a user belongs to) for the given players.
*
* @param cleared the players to remove data for
*/
synchronized void purgePermissions(Collection<OfflinePlayer> cleared) {
if (!settings.getProperty(PurgeSettings.REMOVE_PERMISSIONS)) {
return;
}
for (OfflinePlayer offlinePlayer : cleared) {
if (!permissionsManager.loadUserData(offlinePlayer)) {
logger.warning("Unable to purge the permissions of user " + offlinePlayer + "!");
continue;
}
permissionsManager.removeAllGroups(offlinePlayer);
}
logger.info("AutoPurge: Removed permissions from " + cleared.size() + " player(s).");
}
}
src/main/java/fr/xephi/authme/task/purge/PurgeService.java
-123
View File
@@ -1,123 +0,0 @@
package fr.xephi.authme.task.purge;
import fr.xephi.authme.ConsoleLogger;
import fr.xephi.authme.datasource.DataSource;
import fr.xephi.authme.output.ConsoleLoggerFactory;
import fr.xephi.authme.permission.PermissionsManager;
import fr.xephi.authme.service.BukkitService;
import fr.xephi.authme.settings.Settings;
import fr.xephi.authme.settings.properties.PurgeSettings;
import fr.xephi.authme.util.Utils;
import org.bukkit.OfflinePlayer;
import org.bukkit.command.CommandSender;
import javax.inject.Inject;
import java.util.Calendar;
import java.util.Collection;
import java.util.Set;
import static fr.xephi.authme.util.Utils.logAndSendMessage;
/**
* Initiates purge tasks.
*/
public class PurgeService {
private final ConsoleLogger logger = ConsoleLoggerFactory.get(PurgeService.class);
@Inject
private BukkitService bukkitService;
@Inject
private DataSource dataSource;
@Inject
private Settings settings;
@Inject
private PermissionsManager permissionsManager;
@Inject
private PurgeExecutor purgeExecutor;
/** Keeps track of whether a purge task is currently running. */
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) {
logger.warning("Did not run auto purge: configured days before purging must be positive");
return;
}
logger.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 (Utils.isCollectionEmpty(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.runTaskTimerAsynchronously(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);
}
}
src/main/java/fr/xephi/authme/task/purge/PurgeTask.java
-130
View File
@@ -1,130 +0,0 @@
package fr.xephi.authme.task.purge;
import fr.xephi.authme.ConsoleLogger;
import fr.xephi.authme.output.ConsoleLoggerFactory;
import fr.xephi.authme.permission.PermissionsManager;
import fr.xephi.authme.permission.PlayerStatePermission;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.OfflinePlayer;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.scheduler.BukkitRunnable;
import java.util.HashSet;
import java.util.Locale;
import java.util.Set;
import java.util.UUID;
class PurgeTask extends BukkitRunnable {
//how many players we should check for each tick
private static final int INTERVAL_CHECK = 5;
private final ConsoleLogger logger = ConsoleLoggerFactory.get(PurgeTask.class);
private final PurgeService purgeService;
private final PermissionsManager permissionsManager;
private final UUID sender;
private final Set<String> toPurge;
private final OfflinePlayer[] offlinePlayers;
private final int totalPurgeCount;
private int currentPage = 0;
/**
* 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 {
this.sender = null;
}
this.toPurge = toPurge;
this.totalPurgeCount = toPurge.size();
this.offlinePlayers = offlinePlayers;
}
@Override
public void run() {
if (toPurge.isEmpty()) {
//everything was removed
finish();
return;
}
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];
if (offlinePlayer.getName() != null && toPurge.remove(offlinePlayer.getName().toLowerCase(Locale.ROOT))) {
if (!permissionsManager.loadUserData(offlinePlayer)) {
logger.warning("Unable to check if the user " + offlinePlayer.getName() + " can be purged!");
continue;
}
if (!permissionsManager.hasPermissionOffline(offlinePlayer, PlayerStatePermission.BYPASS_PURGE)) {
playerPortion.add(offlinePlayer);
namePortion.add(offlinePlayer.getName());
}
}
}
if (!toPurge.isEmpty() && playerPortion.isEmpty()) {
logger.info("Finished lookup of offlinePlayers. Begin looking purging player names only");
//we went through all offlineplayers but there are still names remaining
for (String name : toPurge) {
if (!permissionsManager.hasPermissionOffline(name, PlayerStatePermission.BYPASS_PURGE)) {
namePortion.add(name);
}
}
toPurge.clear();
}
currentPage++;
purgeService.executePurge(playerPortion, namePortion);
if (currentPage % 20 == 0) {
int completed = totalPurgeCount - toPurge.size();
sendMessage("[AuthMe] Purge progress " + completed + '/' + totalPurgeCount);
}
}
private void finish() {
cancel();
// Show a status message
sendMessage(ChatColor.GREEN + "[AuthMe] Database has been purged successfully");
logger.info("Purge finished!");
purgeService.setPurging(false);
}
private void sendMessage(String message) {
if (sender == null) {
Bukkit.getConsoleSender().sendMessage(message);
} else {
Player player = Bukkit.getPlayer(sender);
if (player != null) {
player.sendMessage(message);
}
}
}
}