#620 Add a cancellable session restore event

src/main/java/fr/xephi/authme/events/RestoreSessionEvent.java

@@ -0,0 +1,51 @@
+package fr.xephi.authme.events;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.HandlerList;
+
+/**
+ * Event fired before a session is restored.
+ */
+public class RestoreSessionEvent extends CustomEvent implements Cancellable {
+
+    private static final HandlerList handlers = new HandlerList();
+    private final Player player;
+    private boolean isCancelled;
+
+    public RestoreSessionEvent(Player player, boolean isAsync) {
+        super(isAsync);
+        this.player = player;
+    }
+
+    @Override
+    public boolean isCancelled() {
+        return isCancelled;
+    }
+
+    @Override
+    public void setCancelled(boolean isCancelled) {
+        this.isCancelled = isCancelled;
+    }
+
+    /**
+     * @return the player for which the session will be enabled
+     */
+    public Player getPlayer() {
+        return player;
+    }
+
+    /**
+     * Return the list of handlers, equivalent to {@link #getHandlers()} and required by {@link org.bukkit.event.Event}.
+     *
+     * @return The list of handlers
+     */
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+
+    @Override
+    public HandlerList getHandlers() {
+        return handlers;
+    }
+}

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

@@ -7,6 +7,7 @@ import fr.xephi.authme.data.auth.PlayerCache;
 import fr.xephi.authme.data.limbo.LimboService;
 import fr.xephi.authme.datasource.DataSource;
 import fr.xephi.authme.events.ProtectInventoryEvent;
+import fr.xephi.authme.events.RestoreSessionEvent;
 import fr.xephi.authme.message.MessageKey;
 import fr.xephi.authme.permission.AuthGroupType;
 import fr.xephi.authme.permission.PlayerStatePermission;
@@ -123,19 +124,10 @@ public class AsynchronousJoin implements AsynchronousProcess {
             }
 
             // Session logic
-            if (sessionManager.hasSession(name) || database.isLogged(name)) {
+            if (canResumeSession(player)) {
-                PlayerAuth auth = database.getAuth(name);
+                service.send(player, MessageKey.SESSION_RECONNECTION);
-                database.setUnlogged(name);
+                bukkitService.runTaskOptionallyAsync(() -> asynchronousLogin.forceLogin(player));
-                playerCache.removePlayer(name);
+                return;
-                if (auth != null) {
-                    if (auth.getIp().equals(ip)) {
-                        service.send(player, MessageKey.SESSION_RECONNECTION);
-                        bukkitService.runTaskOptionallyAsync(() -> asynchronousLogin.forceLogin(player));
-                        return;
-                    } else {
-                        service.send(player, MessageKey.SESSION_EXPIRED);
-                    }
-                }
             }
         } else {
             // Groups logic
@@ -165,6 +157,25 @@ public class AsynchronousJoin implements AsynchronousProcess {
         });
     }
 
+    private boolean canResumeSession(Player player) {
+        final String name = player.getName();
+        if (sessionManager.hasSession(name) || database.isLogged(name)) {
+            PlayerAuth auth = database.getAuth(name);
+            database.setUnlogged(name);
+            playerCache.removePlayer(name);
+            if (auth != null) {
+                if (auth.getIp().equals(PlayerUtils.getPlayerIp(player))) {
+                    RestoreSessionEvent event = bukkitService.createAndCallEvent(
+                        isAsync -> new RestoreSessionEvent(player, isAsync));
+                    return !event.isCancelled();
+                } else {
+                    service.send(player, MessageKey.SESSION_EXPIRED);
+                }
+            }
+        }
+        return false;
+    }
+
     /**
      * Checks whether the maximum number of accounts has been exceeded for the given IP address (according to
      * settings and permissions). If this is the case, the player is kicked.