#547 add process service to AsyncJoin

src/main/java/fr/xephi/authme/AuthMe.java

@@ -305,7 +305,7 @@ public class AuthMe extends JavaPlugin {
         setupApi();
 
         // Set up the management
-        ProcessService processService = new ProcessService(newSettings, messages);
+        ProcessService processService = new ProcessService(newSettings, messages, this);
         management = new Management(this, processService, database, PlayerCache.getInstance());
 
         // Set up the BungeeCord hook
@@ -861,15 +861,6 @@ public class AuthMe extends JavaPlugin {
         return count >= Settings.getMaxLoginPerIp;
     }
 
-    public boolean hasJoinedIp(String name, String ip) {
-        int count = 0;
-        for (Player player : Utils.getOnlinePlayers()) {
-            if (ip.equalsIgnoreCase(getIP(player)) && !player.getName().equalsIgnoreCase(name))
-                count++;
-        }
-        return count >= Settings.getMaxJoinPerIp;
-    }
-
     /**
      * Handle Bukkit commands.
      *

src/main/java/fr/xephi/authme/process/Management.java

@@ -84,14 +84,7 @@ public class Management {
     }
 
     public void performJoin(final Player player) {
-        sched.runTaskAsynchronously(plugin, new Runnable() {
+        runTask(new AsynchronousJoin(player, plugin, dataSource, playerCache, processService));
-
-            @Override
-            public void run() {
-                new AsynchronousJoin(player, plugin, dataSource).process();
-            }
-
-        });
     }
 
     public void performQuit(final Player player, final boolean isKick) {

src/main/java/fr/xephi/authme/process/ProcessService.java

@@ -1,10 +1,13 @@
 package fr.xephi.authme.process;
 
+import fr.xephi.authme.AuthMe;
 import fr.xephi.authme.output.MessageKey;
 import fr.xephi.authme.output.Messages;
 import fr.xephi.authme.settings.NewSetting;
 import fr.xephi.authme.settings.domain.Property;
 import org.bukkit.command.CommandSender;
+import org.bukkit.event.Event;
+import org.bukkit.scheduler.BukkitTask;
 
 /**
  * Service for asynchronous and synchronous processes.
@@ -13,10 +16,12 @@ public class ProcessService {
 
     private final NewSetting settings;
     private final Messages messages;
+    private final AuthMe authMe;
 
-    public ProcessService(NewSetting settings, Messages messages) {
+    public ProcessService(NewSetting settings, Messages messages, AuthMe authMe) {
         this.settings = settings;
         this.messages = messages;
+        this.authMe = authMe;
     }
 
     public <T> T getProperty(Property<T> property) {
@@ -31,4 +36,28 @@ public class ProcessService {
         messages.send(sender, key);
     }
 
+    public String retrieveMessage(MessageKey key) {
+        return messages.retrieveSingle(key);
+    }
+
+    public BukkitTask runTask(Runnable task) {
+        return authMe.getServer().getScheduler().runTask(authMe, task);
+    }
+
+    public BukkitTask runTaskLater(Runnable task, long delay) {
+        return authMe.getServer().getScheduler().runTaskLater(authMe, task, delay);
+    }
+
+    public int scheduleSyncDelayedTask(Runnable task) {
+        return authMe.getServer().getScheduler().scheduleSyncDelayedTask(authMe, task);
+    }
+
+    public void callEvent(Event event) {
+        authMe.getServer().getPluginManager().callEvent(event);
+    }
+
+    public AuthMe getAuthMe() {
+        return authMe;
+    }
+
 }

src/main/java/fr/xephi/authme/process/join/AsynchronousJoin.java

@@ -11,66 +11,71 @@ import fr.xephi.authme.events.ProtectInventoryEvent;
 import fr.xephi.authme.events.SpawnTeleportEvent;
 import fr.xephi.authme.listener.AuthMePlayerListener;
 import fr.xephi.authme.output.MessageKey;
-import fr.xephi.authme.output.Messages;
 import fr.xephi.authme.permission.PlayerStatePermission;
+import fr.xephi.authme.process.Process;
+import fr.xephi.authme.process.ProcessService;
+import fr.xephi.authme.settings.NewSetting;
 import fr.xephi.authme.settings.Settings;
 import fr.xephi.authme.settings.Spawn;
+import fr.xephi.authme.settings.properties.HooksSettings;
+import fr.xephi.authme.settings.properties.PluginSettings;
+import fr.xephi.authme.settings.properties.RegistrationSettings;
+import fr.xephi.authme.settings.properties.RestrictionSettings;
 import fr.xephi.authme.task.MessageTask;
 import fr.xephi.authme.task.TimeoutTask;
 import fr.xephi.authme.util.Utils;
 import fr.xephi.authme.util.Utils.GroupType;
-import org.bukkit.Bukkit;
 import org.bukkit.Location;
 import org.bukkit.Material;
 import org.bukkit.entity.Player;
 import org.bukkit.potion.PotionEffect;
 import org.bukkit.potion.PotionEffectType;
-import org.bukkit.scheduler.BukkitScheduler;
 import org.bukkit.scheduler.BukkitTask;
 
 /**
  */
-public class AsynchronousJoin {
+public class AsynchronousJoin implements Process {
 
     private final AuthMe plugin;
     private final Player player;
     private final DataSource database;
     private final String name;
-    private final Messages m;
+    private final ProcessService service;
-    private final BukkitScheduler sched;
+    private final PlayerCache playerCache;
 
-    public AsynchronousJoin(Player player, AuthMe plugin, DataSource database) {
+    public AsynchronousJoin(Player player, AuthMe plugin, DataSource database, PlayerCache playerCache,
-        this.m = plugin.getMessages();
+                            ProcessService service) {
         this.player = player;
         this.plugin = plugin;
-        this.sched = plugin.getServer().getScheduler();
         this.database = database;
         this.name = player.getName().toLowerCase();
+        this.service = service;
+        this.playerCache = playerCache;
     }
 
-    public void process() {
+    @Override
+    public void run() {
         if (Utils.isUnrestricted(player)) {
             return;
         }
 
-        if (Settings.checkVeryGames) {
+        if (service.getProperty(HooksSettings.ENABLE_VERYGAMES_IP_CHECK)) {
             plugin.getVerygamesIp(player);
         }
 
-        if (plugin.ess != null && Settings.disableSocialSpy) {
+        if (plugin.ess != null && service.getProperty(HooksSettings.DISABLE_SOCIAL_SPY)) {
             plugin.ess.getUser(player).setSocialSpyEnabled(false);
         }
 
         final String ip = plugin.getIP(player);
 
 
-        if (Settings.isAllowRestrictedIp && isNameRestricted(name, ip, player.getAddress().getHostName())) {
+        if (isNameRestricted(name, ip, player.getAddress().getHostName(), service.getSettings())) {
-            sched.scheduleSyncDelayedTask(plugin, new Runnable() {
+            service.scheduleSyncDelayedTask(new Runnable() {
-
                 @Override
                 public void run() {
                     AuthMePlayerListener.causeByAuthMe.putIfAbsent(name, true);
-                    player.kickPlayer(m.retrieveSingle(MessageKey.NOT_OWNER_ERROR));
+                    player.kickPlayer(service.retrieveMessage(MessageKey.NOT_OWNER_ERROR));
                     if (Settings.banUnsafeIp) {
                         plugin.getServer().banIP(ip);
                     }
@@ -78,38 +83,34 @@ public class AsynchronousJoin {
             });
             return;
         }
-        if (Settings.getMaxJoinPerIp > 0
+        if (service.getProperty(RestrictionSettings.MAX_JOIN_PER_IP) > 0
             && !plugin.getPermissionsManager().hasPermission(player, PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS)
-            && !ip.equalsIgnoreCase("127.0.0.1")
+            && !"127.0.0.1".equalsIgnoreCase(ip)
-            && !ip.equalsIgnoreCase("localhost")
+            && !"localhost".equalsIgnoreCase(ip)
-            && plugin.hasJoinedIp(player.getName(), ip)) {
+            && hasJoinedIp(player.getName(), ip, service.getSettings(), service.getAuthMe())) {
-            sched.scheduleSyncDelayedTask(plugin, new Runnable() {
+            service.scheduleSyncDelayedTask(new Runnable() {
-
                 @Override
                 public void run() {
                     player.kickPlayer("A player with the same IP is already in game!");
                 }
-
             });
             return;
         }
-        final Location spawnLoc = plugin.getSpawnLocation(player);
+        final Location spawnLoc = Spawn.getInstance().getSpawnLocation(player);
         final boolean isAuthAvailable = database.isAuthAvailable(name);
         if (isAuthAvailable) {
             if (!Settings.noTeleport) {
                 if (Settings.isTeleportToSpawnEnabled || (Settings.isForceSpawnLocOnJoinEnabled && Settings.getForcedWorlds.contains(player.getWorld().getName()))) {
-                    sched.scheduleSyncDelayedTask(plugin, new Runnable() {
+                    service.scheduleSyncDelayedTask(new Runnable() {
-
                         @Override
                         public void run() {
-                            SpawnTeleportEvent tpEvent = new SpawnTeleportEvent(player, player.getLocation(), spawnLoc, PlayerCache.getInstance().isAuthenticated(name));
+                            SpawnTeleportEvent tpEvent = new SpawnTeleportEvent(player, player.getLocation(), spawnLoc, playerCache.isAuthenticated(name));
-                            plugin.getServer().getPluginManager().callEvent(tpEvent);
+                            service.callEvent(tpEvent);
                             if (!tpEvent.isCancelled() && player.isOnline() && tpEvent.getTo() != null
                                 && tpEvent.getTo().getWorld() != null) {
                                 player.teleport(tpEvent.getTo());
                             }
                         }
-
                     });
                 }
             }
@@ -123,12 +124,12 @@ public class AsynchronousJoin {
                 if (ev.isCancelled()) {
                     plugin.inventoryProtector.sendInventoryPacket(player);
                     if (!Settings.noConsoleSpam) {
-                        ConsoleLogger.info("ProtectInventoryEvent has been cancelled for " + player.getName() + " ...");
+                        ConsoleLogger.info("ProtectInventoryEvent has been cancelled for " + player.getName() + "...");
                     }
                 }
             }
 
-            if (Settings.isSessionsEnabled && (PlayerCache.getInstance().isAuthenticated(name) || database.isLogged(name))) {
+            if (service.getProperty(PluginSettings.SESSIONS_ENABLED) && (playerCache.isAuthenticated(name) || database.isLogged(name))) {
                 if (plugin.sessions.containsKey(name)) {
                     plugin.sessions.get(name).cancel();
                     plugin.sessions.remove(name);
@@ -137,11 +138,11 @@ public class AsynchronousJoin {
                 database.setUnlogged(name);
                 PlayerCache.getInstance().removePlayer(name);
                 if (auth != null && auth.getIp().equals(ip)) {
-                    m.send(player, MessageKey.SESSION_RECONNECTION);
+                    service.send(player, MessageKey.SESSION_RECONNECTION);
                     plugin.getManagement().performLogin(player, "dontneed", true);
                     return;
                 } else if (Settings.sessionExpireOnIpChange) {
-                    m.send(player, MessageKey.SESSION_EXPIRED);
+                    service.send(player, MessageKey.SESSION_EXPIRED);
                 }
             }
         } else {
@@ -154,21 +155,18 @@ public class AsynchronousJoin {
 
             if (!Settings.noTeleport && !needFirstSpawn() && Settings.isTeleportToSpawnEnabled
                 || (Settings.isForceSpawnLocOnJoinEnabled && Settings.getForcedWorlds.contains(player.getWorld().getName()))) {
-                sched.scheduleSyncDelayedTask(plugin, new Runnable() {
+                service.scheduleSyncDelayedTask(new Runnable() {
-
                     @Override
                     public void run() {
-                    SpawnTeleportEvent tpEvent = new SpawnTeleportEvent(player, player.getLocation(), spawnLoc, PlayerCache.getInstance().isAuthenticated(name));
+                        SpawnTeleportEvent tpEvent = new SpawnTeleportEvent(player, player.getLocation(), spawnLoc, PlayerCache.getInstance().isAuthenticated(name));
-                    plugin.getServer().getPluginManager().callEvent(tpEvent);
+                        service.callEvent(tpEvent);
-                    if (!tpEvent.isCancelled() && player.isOnline() && tpEvent.getTo() != null
+                        if (!tpEvent.isCancelled() && player.isOnline() && tpEvent.getTo() != null
-                        && tpEvent.getTo().getWorld() != null) {
+                            && tpEvent.getTo().getWorld() != null) {
-                        player.teleport(tpEvent.getTo());
+                            player.teleport(tpEvent.getTo());
+                        }
                     }
-                    }
-
                 });
             }
-
         }
 
         if (!LimboCache.getInstance().hasLimboPlayer(name)) {
@@ -176,9 +174,9 @@ public class AsynchronousJoin {
         }
         Utils.setGroup(player, isAuthAvailable ? GroupType.NOTLOGGEDIN : GroupType.UNREGISTERED);
 
-        final int timeOut = Settings.getRegistrationTimeout * 20;
+        final int registrationTimeout = service.getProperty(RestrictionSettings.TIMEOUT) * 20;
 
-        sched.scheduleSyncDelayedTask(plugin, new Runnable() {
+        service.scheduleSyncDelayedTask(new Runnable() {
             @Override
             public void run() {
                 player.setOp(false);
@@ -186,27 +184,22 @@ public class AsynchronousJoin {
                     player.setFlySpeed(0.0f);
                     player.setWalkSpeed(0.0f);
                 }
-                player.setNoDamageTicks(timeOut);
+                player.setNoDamageTicks(registrationTimeout);
-                if (Settings.useEssentialsMotd) {
+                if (service.getProperty(HooksSettings.USE_ESSENTIALS_MOTD)) {
                     player.performCommand("motd");
                 }
-                if (Settings.applyBlindEffect) {
+                if (service.getProperty(RegistrationSettings.APPLY_BLIND_EFFECT)) {
-                    int blindTimeOut;
                     // Allow infinite blindness effect
-                    if (timeOut <= 0) {
+                    int blindTimeOut = (registrationTimeout <= 0) ? 99999 : registrationTimeout;
-                        blindTimeOut = 99999;
-                    } else {
-                        blindTimeOut = timeOut;
-                    }
                     player.addPotionEffect(new PotionEffect(PotionEffectType.BLINDNESS, blindTimeOut, 2));
                 }
             }
 
         });
 
-        int msgInterval = Settings.getWarnMessageInterval;
+        int msgInterval = service.getProperty(RegistrationSettings.MESSAGE_INTERVAL);
-        if (timeOut > 0) {
+        if (registrationTimeout > 0) {
-            BukkitTask id = sched.runTaskLater(plugin, new TimeoutTask(plugin, name, player), timeOut);
+            BukkitTask id = service.runTaskLater(new TimeoutTask(plugin, name, player), registrationTimeout);
             LimboCache.getInstance().getLimboPlayer(name).setTimeoutTaskId(id);
         }
 
@@ -219,7 +212,7 @@ public class AsynchronousJoin {
                 : MessageKey.REGISTER_MESSAGE;
         }
         if (msgInterval > 0 && LimboCache.getInstance().getLimboPlayer(name) != null) {
-            BukkitTask msgTask = sched.runTask(plugin, new MessageTask(plugin, name, msg, msgInterval));
+            BukkitTask msgTask = service.runTask(new MessageTask(plugin, name, msg, msgInterval));
             LimboCache.getInstance().getLimboPlayer(name).setMessageTaskId(msgTask);
         }
     }
@@ -235,13 +228,11 @@ public class AsynchronousJoin {
         if (!tpEvent.isCancelled()) {
             if (player.isOnline() && tpEvent.getTo() != null && tpEvent.getTo().getWorld() != null) {
                 final Location fLoc = tpEvent.getTo();
-                Bukkit.getScheduler().scheduleSyncDelayedTask(plugin, new Runnable() {
+                service.scheduleSyncDelayedTask(new Runnable() {
-
                     @Override
                     public void run() {
                         player.teleport(fLoc);
                     }
-
                 });
             }
         }
@@ -249,25 +240,23 @@ public class AsynchronousJoin {
     }
 
     private void placePlayerSafely(final Player player, final Location spawnLoc) {
-        if (spawnLoc == null)
+        if (spawnLoc == null || service.getProperty(RestrictionSettings.NO_TELEPORT))
-            return;
-        if (!Settings.noTeleport)
             return;
         if (Settings.isTeleportToSpawnEnabled || (Settings.isForceSpawnLocOnJoinEnabled && Settings.getForcedWorlds.contains(player.getWorld().getName())))
             return;
         if (!player.hasPlayedBefore())
             return;
-        sched.scheduleSyncDelayedTask(plugin, new Runnable() {
+        service.scheduleSyncDelayedTask(new Runnable() {
             @Override
             public void run() {
                 if (spawnLoc.getWorld() == null) {
                     return;
                 }
                 Material cur = player.getLocation().getBlock().getType();
-                Material top = player.getLocation().add(0D, 1D, 0D).getBlock().getType();
+                Material top = player.getLocation().add(0, 1, 0).getBlock().getType();
                 if (cur == Material.PORTAL || cur == Material.ENDER_PORTAL
                     || top == Material.PORTAL || top == Material.ENDER_PORTAL) {
-                    m.send(player, MessageKey.UNSAFE_QUIT_LOCATION);
+                    service.send(player, MessageKey.UNSAFE_QUIT_LOCATION);
                     player.teleport(spawnLoc);
                 }
             }
@@ -281,12 +270,17 @@ public class AsynchronousJoin {
      * @param name The name to check
      * @param ip The IP address of the player
      * @param domain The hostname of the IP address
+     * @param settings The settings instance
      * @return True if the name is restricted (IP/domain is not allowed for the given name),
      *         false if the restrictions are met or if the name has no restrictions to it
      */
-    private static boolean isNameRestricted(String name, String ip, String domain) {
+    private static boolean isNameRestricted(String name, String ip, String domain, NewSetting settings) {
+        if (!settings.getProperty(RestrictionSettings.ENABLE_RESTRICTED_USERS)) {
+            return false;
+        }
+
         boolean nameFound = false;
-        for (String entry : Settings.getRestrictedIp) {
+        for (String entry : settings.getProperty(RestrictionSettings.ALLOWED_RESTRICTED_USERS)) {
             String[] args = entry.split(";");
             String testName = args[0];
             String testIp = args[1];
@@ -301,4 +295,12 @@ public class AsynchronousJoin {
         return nameFound;
     }
 
+    private boolean hasJoinedIp(String name, String ip, NewSetting settings, AuthMe authMe) {
+        int count = 0;
+        for (Player player : Utils.getOnlinePlayers()) {
+            if (ip.equalsIgnoreCase(authMe.getIP(player)) && !player.getName().equalsIgnoreCase(name))
+                count++;
+        }
+        return count >= settings.getProperty(RestrictionSettings.MAX_JOIN_PER_IP);
+    }
 }

src/main/java/fr/xephi/authme/settings/Settings.java

@@ -97,19 +97,19 @@ public final class Settings {
         isPermissionCheckEnabled = load(PluginSettings.ENABLE_PERMISSION_CHECK);
         isForcedRegistrationEnabled = configFile.getBoolean("settings.registration.force", true);
         isRegistrationEnabled = configFile.getBoolean("settings.registration.enabled", true);
-        isTeleportToSpawnEnabled = configFile.getBoolean("settings.restrictions.teleportUnAuthedToSpawn", false);
+        isTeleportToSpawnEnabled = load(RestrictionSettings.TELEPORT_UNAUTHED_TO_SPAWN);
-        getWarnMessageInterval = configFile.getInt("settings.registration.messageInterval", 5);
+        getWarnMessageInterval = load(RegistrationSettings.MESSAGE_INTERVAL);
-        isSessionsEnabled = configFile.getBoolean("settings.sessions.enabled", false);
+        isSessionsEnabled = load(PluginSettings.SESSIONS_ENABLED);
         getSessionTimeout = configFile.getInt("settings.sessions.timeout", 10);
-        getRegistrationTimeout = configFile.getInt("settings.restrictions.timeout", 30);
+        getRegistrationTimeout = load(RestrictionSettings.TIMEOUT);
-        isChatAllowed = configFile.getBoolean("settings.restrictions.allowChat", false);
+        isChatAllowed = load(RestrictionSettings.ALLOW_CHAT);
         getMaxNickLength = configFile.getInt("settings.restrictions.maxNicknameLength", 20);
         getMinNickLength = configFile.getInt("settings.restrictions.minNicknameLength", 3);
         getPasswordMinLen = configFile.getInt("settings.security.minPasswordLength", 4);
         getNickRegex = configFile.getString("settings.restrictions.allowedNicknameCharacters", "[a-zA-Z0-9_?]*");
         nickPattern = Pattern.compile(getNickRegex);
-        isAllowRestrictedIp = configFile.getBoolean("settings.restrictions.AllowRestrictedUser", false);
+        isAllowRestrictedIp = load(RestrictionSettings.ENABLE_RESTRICTED_USERS);
-        getRestrictedIp = configFile.getStringList("settings.restrictions.AllowedRestrictedUser");
+        getRestrictedIp = load(RestrictionSettings.ALLOWED_RESTRICTED_USERS);
         isMovementAllowed = configFile.getBoolean("settings.restrictions.allowMovement", false);
         isRemoveSpeedEnabled = configFile.getBoolean("settings.restrictions.removeSpeed", true);
         getMovementRadius = configFile.getInt("settings.restrictions.allowedMovementRadius", 100);
@@ -204,13 +204,13 @@ public final class Settings {
         forceRegKick = configFile.getBoolean("settings.registration.forceKickAfterRegister", false);
         forceRegLogin = load(RegistrationSettings.FORCE_LOGIN_AFTER_REGISTER);
         spawnPriority = load(RestrictionSettings.SPAWN_PRIORITY);
-        getMaxLoginPerIp = configFile.getInt("settings.restrictions.maxLoginPerIp", 0);
+        getMaxLoginPerIp = load(RestrictionSettings.MAX_LOGIN_PER_IP);
-        getMaxJoinPerIp = configFile.getInt("settings.restrictions.maxJoinPerIp", 0);
+        getMaxJoinPerIp = load(RestrictionSettings.MAX_JOIN_PER_IP);
-        checkVeryGames = configFile.getBoolean("VeryGames.enableIpCheck", false);
+        checkVeryGames = load(HooksSettings.ENABLE_VERYGAMES_IP_CHECK);
         removeJoinMessage = load(RegistrationSettings.REMOVE_JOIN_MESSAGE);
         removeLeaveMessage = load(RegistrationSettings.REMOVE_LEAVE_MESSAGE);
         delayJoinMessage = load(RegistrationSettings.DELAY_JOIN_MESSAGE);
-        noTeleport = configFile.getBoolean("settings.restrictions.noTeleport", false);
+        noTeleport = load(RestrictionSettings.NO_TELEPORT);
         crazyloginFileName = configFile.getString("Converter.CrazyLogin.fileName", "accounts.db");
         getPassRegex = configFile.getString("settings.restrictions.allowedPasswordCharacters", "[\\x21-\\x7E]*");
         applyBlindEffect = configFile.getBoolean("settings.applyBlindEffect", false);

src/main/java/fr/xephi/authme/settings/properties/RestrictionSettings.java

@@ -64,7 +64,7 @@ public class RestrictionSettings implements SettingsClass {
 
     @Comment({
         "To activate the restricted user feature you need",
-        "to enable this option and configure the AllowedRestrctedUser field."})
+        "to enable this option and configure the AllowedRestrictedUser field."})
     public static final Property<Boolean> ENABLE_RESTRICTED_USERS =
         newProperty("settings.restrictions.AllowRestrictedUser", false);
 

src/main/java/fr/xephi/authme/util/Utils.java

@@ -154,8 +154,7 @@ public final class Utils {
 
     public static boolean isUnrestricted(Player player) {
         return Settings.isAllowRestrictedIp
-            && !Settings.getUnrestrictedName.isEmpty()
+            && Settings.getUnrestrictedName.contains(player.getName().toLowerCase());
-            && (Settings.getUnrestrictedName.contains(player.getName().toLowerCase()));
     }
 
     public static void packCoords(double x, double y, double z, String w, final Player pl) {
@@ -216,8 +215,7 @@ public final class Utils {
                 ConsoleLogger.showError("Unknown list of online players of type " + type);
             }
         } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
-            ConsoleLogger.showError("Could not retrieve list of online players: ["
+            ConsoleLogger.logException("Could not retrieve list of online players:", e);
-                + e.getClass().getName() + "] " + e.getMessage());
         }
         return Collections.emptyList();
     }