java.lang.IllegalStateException: Asynchronous player kick

Question

When I go to run a spigot plugin I have created, when a player completes certain actions, they will be kicked. For some reason, instead of kicking them once they have sent certain packets 20 times,

It gives an error:

[TenKAC] Unhandled exception number 64 occurred in onPacketReceiving(PacketEvent) for TenKAC
java.lang.IllegalStateException: Asynchronous player kick!
        at org.spigotmc.AsyncCatcher.catchOp(AsyncCatcher.java:14) ~[spigot.jar:git-Spigot-21fe707-741a1bd]
        at org.bukkit.craftbukkit.v1_8_R3.entity.CraftPlayer.kickPlayer(CraftPlayer.java:214) ~[spigot.jar:git-Spigot-21fe707-741a1bd]
        at cc.funkemunky.tenkac.checks.Check.flag(Check.java:57) ~[tenkac.jar:?]
        at cc.funkemunky.tenkac.checks.movement.Killaura.access$000(Killaura.java:23) ~[tenkac.jar:?]
        at cc.funkemunky.tenkac.checks.movement.Killaura$1.onPacketReceiving(Killaura.java:33) ~[tenkac.jar:?]
        at com.comphenix.protocol.injector.SortedPacketListenerList.invokeReceivingListener(SortedPacketListenerList.java:122) [ProtocolLib.jar:?]
        at com.comphenix.protocol.injector.SortedPacketListenerList.invokePacketRecieving(SortedPacketListenerList.java:75) [ProtocolLib.jar:?]
        at com.comphenix.protocol.injector.PacketFilterManager.postPacketToListeners(PacketFilterManager.java:557) [ProtocolLib.jar:?]
        at com.comphenix.protocol.injector.PacketFilterManager.invokePacketReceiving(PacketFilterManager.java:521) [ProtocolLib.jar:?]
        at com.comphenix.protocol.injector.netty.manager.NetworkManagerInjector.onPacketReceiving(NetworkManagerInjector.java:118) [ProtocolLib.jar:?]
        at com.comphenix.protocol.injector.netty.channel.NettyChannelInjector.processInboundPacket(NettyChannelInjector.java:500) [ProtocolLib.jar:?]
        at com.comphenix.protocol.injector.netty.channel.InboundPacketInterceptor.channelRead(InboundPacketInterceptor.java:33) [ProtocolLib.jar:?]
        at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:333) [spigot.jar:git-Spigot-21fe707-741a1bd]
        at io.netty.channel.AbstractChannelHandlerContext.fireChannelRead(AbstractChannelHandlerContext.java:319) [spigot.jar:git-Spigot-21fe707-741a1bd]
        at io.netty.handler.codec.ByteToMessageDecoder.channelRead(ByteToMessageDecoder.java:163) [spigot.jar:git-Spigot-21fe707-741a1bd]
        at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:333) [spigot.jar:git-Spigot-21fe707-741a1bd]
        at io.netty.channel.AbstractChannelHandlerContext.fireChannelRead(AbstractChannelHandlerContext.java:319) [spigot.jar:git-Spigot-21fe707-741a1bd]
        at io.netty.handler.codec.ByteToMessageDecoder.channelRead(ByteToMessageDecoder.java:163) [spigot.jar:git-Spigot-21fe707-741a1bd]
        at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:333) [spigot.jar:git-Spigot-21fe707-741a1bd]
        at io.netty.channel.AbstractChannelHandlerContext.fireChannelRead(AbstractChannelHandlerContext.java:319) [spigot.jar:git-Spigot-21fe707-741a1bd]
        at io.netty.handler.codec.ByteToMessageDecoder.channelRead(ByteToMessageDecoder.java:163) [spigot.jar:git-Spigot-21fe707-741a1bd]
        at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:333) [spigot.jar:git-Spigot-21fe707-741a1bd]
        at io.netty.channel.AbstractChannelHandlerContext.fireChannelRead(AbstractChannelHandlerContext.java:319) [spigot.jar:git-Spigot-21fe707-741a1bd]
        at io.netty.handler.codec.MessageToMessageDecoder.channelRead(MessageToMessageDecoder.java:103) [spigot.jar:git-Spigot-21fe707-741a1bd]
        at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:333) [spigot.jar:git-Spigot-21fe707-741a1bd]
        at io.netty.channel.AbstractChannelHandlerContext.fireChannelRead(AbstractChannelHandlerContext.java:319) [spigot.jar:git-Spigot-21fe707-741a1bd]
        at io.netty.handler.timeout.ReadTimeoutHandler.channelRead(ReadTimeoutHandler.java:150) [spigot.jar:git-Spigot-21fe707-741a1bd]
        at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:333) [spigot.jar:git-Spigot-21fe707-741a1bd]
        at io.netty.channel.AbstractChannelHandlerContext.fireChannelRead(AbstractChannelHandlerContext.java:319) [spigot.jar:git-Spigot-21fe707-741a1bd]
        at io.netty.channel.DefaultChannelPipeline.fireChannelRead(DefaultChannelPipeline.java:787) [spigot.jar:git-Spigot-21fe707-741a1bd]
        at io.netty.channel.nio.AbstractNioByteChannel$NioByteUnsafe.read(AbstractNioByteChannel.java:130) [spigot.jar:git-Spigot-21fe707-741a1bd]
        at io.netty.channel.nio.NioEventLoop.processSelectedKey(NioEventLoop.java:511) [spigot.jar:git-Spigot-21fe707-741a1bd]
        at io.netty.channel.nio.NioEventLoop.processSelectedKeysOptimized(NioEventLoop.java:468) [spigot.jar:git-Spigot-21fe707-741a1bd]
        at io.netty.channel.nio.NioEventLoop.processSelectedKeys(NioEventLoop.java:382) [spigot.jar:git-Spigot-21fe707-741a1bd]
        at io.netty.channel.nio.NioEventLoop.run(NioEventLoop.java:354) [spigot.jar:git-Spigot-21fe707-741a1bd]
        at io.netty.util.concurrent.SingleThreadEventExecutor$2.run(SingleThreadEventExecutor.java:116) [spigot.jar:git-Spigot-21fe707-741a1bd]
        at java.lang.Thread.run(Unknown Source) [?:1.8.0_301]

I need to know how to kick a player once they have "flagged" 20x. I can see the player is being flagged up until 19x, but at 20x, an error message appears when the player should be getting kicked.

Here is my code that should kick the player once they flag:

package cc.funkemunky.tenkac.checks.movement;

import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.TimeUnit;

import cc.funkemunky.tenkac.AntiCheat;
import cc.funkemunky.tenkac.checks.Check;
import cc.funkemunky.tenkac.checks.CheckType;
import cc.funkemunky.tenkac.data.DataPlayer;
import com.comphenix.protocol.PacketType;
import com.comphenix.protocol.ProtocolLibrary;
import com.comphenix.protocol.events.PacketAdapter;
import com.comphenix.protocol.events.PacketEvent;
import com.comphenix.protocol.events.PacketListener;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;


import static org.bukkit.Bukkit.getScheduler;
import static org.bukkit.Bukkit.getServer;

public class Killaura extends Check {
    private int buffer = 0;
    public Killaura(String name, CheckType type, boolean enabled, boolean punishable, int max) {
        super(name, type, enabled, punishable, max);
        ProtocolLibrary.getProtocolManager().addPacketListener(new PacketAdapter(AntiCheat.getInstance(),
                PacketType.Play.Client.POSITION, PacketType.Play.Client.POSITION_LOOK, PacketType.Play.Client.LOOK, PacketType.Play.Client.FLYING, PacketType.Play.Client.USE_ENTITY) {
            @Override
            public void onPacketReceiving(PacketEvent event) {
                DataPlayer data = AntiCheat.getInstance().getDataManager().getDataPlayer(event.getPlayer());
                if (event.getPacketType().equals(PacketType.Play.Client.USE_ENTITY)) {
                    flag(event.getPlayer(), "Player sent flying packet too late: " + Math.abs(System.currentTimeMillis() - data.lastFlying) + "ms!",
                            "Flagged player may be using: &3♦ &l&f&lF&e&ll&6&ly &3♦ &l&9&lK&1&li&5&ll&d&ll&b&la&3&lu&9&lr&1&la");

                    if ((Math.abs(System.currentTimeMillis() - data.lastFlying) == 0) || (Math.abs(data.lastFlying) == 0) || (Math.abs(System.currentTimeMillis()) == 0)) {
                    } else if (Math.abs(System.currentTimeMillis() - data.lastFlying) < 5) {
                        ++buffer;
                        getServer().getConsoleSender().sendMessage(ChatColor.GREEN + "A player sent a fly packet too late! The packet was: " + (5 - (Math.abs(System.currentTimeMillis() - data.lastFlying))) + "ms too late!");
                        if (buffer > 1) {
                            flag(event.getPlayer(), "Player sent flying packet too late: " + Math.abs(System.currentTimeMillis() - data.lastFlying) + "ms!",
                                    "Flagged player may be using: &3♦ &l&f&lF&e&ll&6&ly &3♦ &l&9&lK&1&li&5&ll&d&ll&b&la&3&lu&9&lr&1&la");
                        }
                    } else {
                        if (buffer > 0) {
                            getServer().getConsoleSender().sendMessage(ChatColor.GREEN + "Player's late fly packet has been buffered!");
                        }
                        buffer = 0;
                    }
                } else {
                data.lastFlying = System.currentTimeMillis();
                }
            }

        });
    }
}

and

package cc.funkemunky.tenkac.checks;

import cc.funkemunky.tenkac.AntiCheat;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.entity.Player;
import org.bukkit.event.Listener;

import java.util.Map;
import java.util.Timer;
import java.util.TimerTask;
import java.util.WeakHashMap;
import java.util.concurrent.TimeUnit;

import static org.bukkit.Bukkit.getServer;

public abstract class Check implements Listener {

    protected String name;
    protected CheckType type;
    protected boolean enabled;
    protected boolean punishable;
    protected int max;

    public Map<Player, Integer> violations = new WeakHashMap<>();

    public Check(String name, CheckType type, boolean enabled, boolean punishable, int max) {
        this.name = name;
        this.type = type;
        this.enabled = enabled;
        this.punishable = punishable;
        this.max = max;

        Bukkit.getPluginManager().registerEvents(this, AntiCheat.getInstance());
    }

    synchronized protected void flag(Player player, String... information) {
        int violations = this.violations.getOrDefault(player, 0) + 1;
        if (information != null) {
            StringBuilder formattedInfo = new StringBuilder();
            for (String string : information) {
                formattedInfo.append(string).append(", ");
            }
            for (Player staff : Bukkit.getOnlinePlayers()) {
                if (staff.hasPermission("anticheat.staff")) {
                    staff.sendMessage(ChatColor.translateAlternateColorCodes('&', "&1[&b&lPvPCamp&1] &9" + player.getName() + " &7has been detected for &9" + name + " &1[&3" + formattedInfo.toString() + "&1]" + "&1(&b" + violations + "&1)"));
                }
            }
        } else {

        }
        if (violations > max) {
            try {
                TimeUnit.MILLISECONDS.sleep(50);
            } catch (InterruptedException e) {
            }
            player.kickPlayer("You have been kicked for " + name);
        }
        this.violations.put(player, violations);
        if (violations > 0) {
            getServer().getConsoleSender().sendMessage(ChatColor.DARK_PURPLE + player.getName() + " has " + violations + " violations!");

        }
    }
}

But instead it just gives the error above.

Answer 1

Some actions are not allowed to be do asynchronously according to the main server thread. Mostly world actions, sometimes it player-related as open inventory and kick.

So, you should "go back on main thread" by using BukkitScheduler#runTask, like this:

Bukkit.getScheduler().runTask(AntiCheat.getInstance(), () -> player.kickPlayer("You have been kicked for " + name));

Also, please do NOT use TimeUnit.MILLISECONDS.sleep(50) with spigot. This is not adapted, and spigot has is own API to wait. If you want to kick the player in X seconds, you can use BukkitScheduler#runTaskLater like this : Bukkit.getScheduler().runTaskLater(AntiCheat.getInstance(), () -> {}, 20); (this will wait 20 ticks, so 1 second)