Create cached permission system

Author: JRoy

Essentials/src/main/java/com/earth2me/essentials/IUser.java

@@ -32,6 +32,8 @@
 public interface IUser {
     boolean isAuthorized(String node);
 
+    boolean isAuthorizedCached(String node);
+
     boolean isAuthorized(IEssentialsCommand cmd);
 
     boolean isAuthorized(IEssentialsCommand cmd, String permissionPrefix);

Essentials/src/main/java/com/earth2me/essentials/User.java

@@ -147,6 +147,19 @@ public boolean isAuthorized(final String node) {
         return result;
     }
 
+    @Override
+    public boolean isAuthorizedCached(final String node) {
+        if (Essentials.TESTING) {
+            return false;
+        }
+
+        final boolean result = isAuthorizedCachedCheck(node);
+        if (ess.getSettings().isDebug()) {
+            ess.getLogger().log(Level.INFO, "checking if " + base.getName() + " has " + node + " (cached) - " + result);
+        }
+        return result;
+    }
+
     @Override
     public boolean isPermissionSet(final String node) {
         if (Essentials.TESTING) {
@@ -186,6 +199,24 @@ private boolean isAuthorizedCheck(final String node) {
         }
     }
 
+    private boolean isAuthorizedCachedCheck(final String node) {
+        if (base instanceof OfflinePlayerStub) {
+            return false;
+        }
+
+        try {
+            return ess.getPermissionsHandler().hasPermissionCached(base, node);
+        } catch (final Exception ex) {
+            if (ess.getSettings().isDebug()) {
+                ess.getLogger().log(Level.SEVERE, "Permission System Error: " + ess.getPermissionsHandler().getName() + " returned: " + ex.getMessage(), ex);
+            } else {
+                ess.getLogger().log(Level.SEVERE, "Permission System Error: " + ess.getPermissionsHandler().getName() + " returned: " + ex.getMessage());
+            }
+
+            return false;
+        }
+    }
+
     private boolean isPermSetCheck(final String node) {
         if (base instanceof OfflinePlayerStub) {
             return false;

Essentials/src/main/java/com/earth2me/essentials/perm/IPermissionsHandler.java

@@ -28,6 +28,10 @@ public interface IPermissionsHandler {
 
     boolean hasPermission(Player base, String node);
 
+    default boolean hasPermissionCached(Player base, String node) {
+        return hasPermission(base, node);
+    }
+
     // Does not check for * permissions
     boolean isPermissionSet(Player base, String node);
 

Essentials/src/main/java/com/earth2me/essentials/perm/PermissionsHandler.java

@@ -105,6 +105,11 @@ public boolean hasPermission(final Player base, final String node) {
         return handler.hasPermission(base, node);
     }
 
+    @Override
+    public boolean hasPermissionCached(final Player base, final String node) {
+        return handler.hasPermissionCached(base, node);
+    }
+
     @Override
     public boolean isPermissionSet(final Player base, final String node) {
         return handler.isPermissionSet(base, node);

Essentials/src/main/java/com/earth2me/essentials/perm/impl/LuckPermsHandler.java

@@ -7,24 +7,31 @@
 import net.luckperms.api.context.ContextConsumer;
 import net.luckperms.api.context.ContextSet;
 import net.luckperms.api.context.ImmutableContextSet;
+import net.luckperms.api.event.EventSubscription;
+import net.luckperms.api.event.user.UserDataRecalculateEvent;
 import net.luckperms.api.model.group.Group;
 import net.luckperms.api.query.QueryOptions;
 import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
 import org.bukkit.plugin.RegisteredServiceProvider;
 
+import java.util.logging.Level;
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Function;
 import java.util.function.Supplier;
 
 public class LuckPermsHandler extends ModernVaultHandler {
     private LuckPerms luckPerms;
     private Essentials ess;
     private CombinedCalculator calculator;
+    private final Map<UUID, Map<String, Boolean>> permissionCache = new ConcurrentHashMap<>();
+    private EventSubscription<UserDataRecalculateEvent> recalculateSubscription;
 
     @Override
     public void registerContext(final String context, final Function<User, Iterable<String>> calculator, final Supplier<Iterable<String>> suggestions) {
@@ -41,6 +48,25 @@ public void unregisterContexts() {
             this.luckPerms.getContextManager().unregisterCalculator(this.calculator);
             this.calculator = null;
         }
+        if (this.recalculateSubscription != null) {
+            this.recalculateSubscription.close();
+            this.recalculateSubscription = null;
+        }
+        this.permissionCache.clear();
+    }
+
+    @Override
+    public boolean hasPermissionCached(final Player base, final String node) {
+        final UUID uuid = base.getUniqueId();
+        final Map<String, Boolean> userCache = permissionCache.computeIfAbsent(uuid, k -> new ConcurrentHashMap<>());
+        return userCache.computeIfAbsent(node, k -> hasPermission(base, node));
+    }
+
+    public void invalidateCache(final UUID uuid) {
+        if (ess.getSettings().isDebug()) {
+            ess.getLogger().log(Level.INFO, "Invalidating permission cache for " + uuid);
+        }
+        permissionCache.remove(uuid);
     }
 
     @Override
@@ -77,6 +103,11 @@ public boolean tryProvider(Essentials ess) {
         if (provider != null) {
             this.luckPerms = provider.getProvider();
             this.ess = ess;
+            this.recalculateSubscription = this.luckPerms.getEventBus().subscribe(
+                ess,
+                UserDataRecalculateEvent.class,
+                event -> invalidateCache(event.getUser().getUniqueId())
+            );
         }
         return luckPerms != null && super.tryProvider(ess);
     }