From 8c22dd71594c189c421a12198fc0cf39bbb2d30d Mon Sep 17 00:00:00 2001 From: Luck Date: Thu, 5 Feb 2026 18:53:33 +0000 Subject: [PATCH] Refactor PermissionProcessors --- .../calculator/BukkitCalculatorFactory.java | 17 +- .../bukkit/calculator/ChildProcessor.java | 39 +++-- .../calculator/BungeeCalculatorFactory.java | 15 +- .../MinecraftCalculatorFactory.java | 15 +- .../cacheddata/type/PermissionCache.java | 4 +- .../common/calculator/CalculatorFactory.java | 14 +- .../calculator/PermissionCalculator.java | 53 +++--- ...che.java => PermissionCalculatorBase.java} | 36 +--- .../PermissionCalculatorMonitored.java | 67 +++++++ .../AbstractSourceBasedProcessor.java | 41 ----- .../calculator/processor/DirectProcessor.java | 11 +- .../processor/PermissionProcessor.java | 19 -- .../calculator/processor/RegexProcessor.java | 45 +++-- .../processor/SpongeWildcardProcessor.java | 10 +- .../processor/WildcardProcessor.java | 39 +++-- ...est.java => PermissionCalculatorTest.java} | 42 +++-- .../calculator/PermissionProcessorTest.java | 165 ++++++++++++++++++ .../luckperms/hytale/LPHytalePlugin.java | 24 +-- .../calculator/HytaleCalculatorFactory.java | 28 ++- .../HytaleVirtualGroupProcessor.java | 36 +++- .../virtualgroups/VirtualGroupsAccess.java | 10 +- ...kupProvider.java => VirtualGroupsMap.java} | 36 ++-- .../hytale/context/HytaleContextManager.java | 4 +- .../listeners/HytalePlatformListener.java | 2 +- .../service/PlayerVirtualGroupsMap.java | 12 +- .../hytale/service/VirtualGroups.java | 4 +- .../nukkit/calculator/ChildProcessor.java | 39 +++-- .../calculator/NukkitCalculatorFactory.java | 17 +- .../calculator/SpongeCalculatorFactory.java | 15 +- .../CalculatedSubjectCachedDataManager.java | 11 +- .../StandaloneCalculatorFactory.java | 15 +- .../calculator/VelocityCalculatorFactory.java | 15 +- 32 files changed, 581 insertions(+), 319 deletions(-) rename common/src/main/java/me/lucko/luckperms/common/calculator/{PermissionLookupCache.java => PermissionCalculatorBase.java} (73%) create mode 100644 common/src/main/java/me/lucko/luckperms/common/calculator/PermissionCalculatorMonitored.java delete mode 100644 common/src/main/java/me/lucko/luckperms/common/calculator/processor/AbstractSourceBasedProcessor.java rename common/src/test/java/me/lucko/luckperms/common/calculator/{PermissionLookupCacheTest.java => PermissionCalculatorTest.java} (82%) create mode 100644 common/src/test/java/me/lucko/luckperms/common/calculator/PermissionProcessorTest.java rename hytale/src/main/java/me/lucko/luckperms/hytale/calculator/virtualgroups/{VirtualGroupsLookupProvider.java => VirtualGroupsMap.java} (69%) diff --git a/bukkit/src/main/java/me/lucko/luckperms/bukkit/calculator/BukkitCalculatorFactory.java b/bukkit/src/main/java/me/lucko/luckperms/bukkit/calculator/BukkitCalculatorFactory.java index da3871859..de40d3c1a 100644 --- a/bukkit/src/main/java/me/lucko/luckperms/bukkit/calculator/BukkitCalculatorFactory.java +++ b/bukkit/src/main/java/me/lucko/luckperms/bukkit/calculator/BukkitCalculatorFactory.java @@ -30,6 +30,7 @@ import me.lucko.luckperms.bukkit.context.BukkitContextManager; import me.lucko.luckperms.common.cacheddata.CacheMetadata; import me.lucko.luckperms.common.calculator.CalculatorFactory; import me.lucko.luckperms.common.calculator.PermissionCalculator; +import me.lucko.luckperms.common.calculator.PermissionCalculatorMonitored; import me.lucko.luckperms.common.calculator.processor.DirectProcessor; import me.lucko.luckperms.common.calculator.processor.PermissionProcessor; import me.lucko.luckperms.common.calculator.processor.RegexProcessor; @@ -37,10 +38,12 @@ import me.lucko.luckperms.common.calculator.processor.SpongeWildcardProcessor; import me.lucko.luckperms.common.calculator.processor.WildcardProcessor; import me.lucko.luckperms.common.config.ConfigKeys; import me.lucko.luckperms.common.model.HolderType; +import net.luckperms.api.node.Node; import net.luckperms.api.query.QueryOptions; import java.util.ArrayList; import java.util.List; +import java.util.Map; public class BukkitCalculatorFactory implements CalculatorFactory { private final LPBukkitPlugin plugin; @@ -50,25 +53,25 @@ public class BukkitCalculatorFactory implements CalculatorFactory { } @Override - public PermissionCalculator build(QueryOptions queryOptions, CacheMetadata metadata) { + public PermissionCalculator build(QueryOptions queryOptions, Map sourceMap, CacheMetadata metadata) { List processors = new ArrayList<>(8); - processors.add(new DirectProcessor()); + processors.add(new DirectProcessor(sourceMap)); if (this.plugin.getConfiguration().get(ConfigKeys.APPLY_BUKKIT_CHILD_PERMISSIONS)) { - processors.add(new ChildProcessor(this.plugin)); + processors.add(new ChildProcessor(this.plugin, sourceMap)); } if (this.plugin.getConfiguration().get(ConfigKeys.APPLYING_REGEX)) { - processors.add(new RegexProcessor()); + processors.add(new RegexProcessor(sourceMap)); } if (this.plugin.getConfiguration().get(ConfigKeys.APPLYING_WILDCARDS)) { - processors.add(new WildcardProcessor()); + processors.add(new WildcardProcessor(sourceMap)); } if (this.plugin.getConfiguration().get(ConfigKeys.APPLYING_WILDCARDS_SPONGE)) { - processors.add(new SpongeWildcardProcessor()); + processors.add(new SpongeWildcardProcessor(sourceMap)); } boolean op = queryOptions.option(BukkitContextManager.OP_OPTION).orElse(false); @@ -82,6 +85,6 @@ public class BukkitCalculatorFactory implements CalculatorFactory { processors.add(OpProcessor.INSTANCE); } - return new PermissionCalculator(this.plugin, metadata, processors); + return new PermissionCalculatorMonitored(this.plugin, metadata, processors); } } diff --git a/bukkit/src/main/java/me/lucko/luckperms/bukkit/calculator/ChildProcessor.java b/bukkit/src/main/java/me/lucko/luckperms/bukkit/calculator/ChildProcessor.java index 4a253dfc8..a942a512f 100644 --- a/bukkit/src/main/java/me/lucko/luckperms/bukkit/calculator/ChildProcessor.java +++ b/bukkit/src/main/java/me/lucko/luckperms/bukkit/calculator/ChildProcessor.java @@ -26,12 +26,13 @@ package me.lucko.luckperms.bukkit.calculator; import me.lucko.luckperms.bukkit.LPBukkitPlugin; +import me.lucko.luckperms.bukkit.inject.server.LuckPermsPermissionMap; import me.lucko.luckperms.common.cacheddata.result.TristateResult; -import me.lucko.luckperms.common.calculator.processor.AbstractSourceBasedProcessor; +import me.lucko.luckperms.common.calculator.processor.AbstractPermissionProcessor; import me.lucko.luckperms.common.calculator.processor.PermissionProcessor; +import net.luckperms.api.node.Node; import net.luckperms.api.util.Tristate; -import java.util.Collections; import java.util.HashMap; import java.util.Map; import java.util.concurrent.atomic.AtomicBoolean; @@ -39,15 +40,23 @@ import java.util.concurrent.atomic.AtomicBoolean; /** * Permission Processor for Bukkits "child" permission system. */ -public class ChildProcessor extends AbstractSourceBasedProcessor implements PermissionProcessor { +public class ChildProcessor extends AbstractPermissionProcessor implements PermissionProcessor { private static final TristateResult.Factory RESULT_FACTORY = new TristateResult.Factory(ChildProcessor.class); private final LPBukkitPlugin plugin; - private final AtomicBoolean needsRefresh = new AtomicBoolean(false); - private Map childPermissions = Collections.emptyMap(); + private final Map sourceMap; - public ChildProcessor(LPBukkitPlugin plugin) { + private final AtomicBoolean needsRefresh = new AtomicBoolean(false); + private Map childPermissions; + + public ChildProcessor(LPBukkitPlugin plugin, Map sourceMap) { this.plugin = plugin; + this.sourceMap = sourceMap; + refresh(); + } + + private void refresh() { + this.childPermissions = processChildPermissions(this.sourceMap, this.plugin.getPermissionMap()); } @Override @@ -59,20 +68,18 @@ public class ChildProcessor extends AbstractSourceBasedProcessor implements Perm } @Override - public void refresh() { + public void invalidate() { + this.needsRefresh.set(true); + } + + private static Map processChildPermissions(Map sourceMap, LuckPermsPermissionMap permissionMap) { Map childPermissions = new HashMap<>(); - this.sourceMap.forEach((key, node) -> { - Map children = this.plugin.getPermissionMap().getChildPermissions(key, node.getValue()); + sourceMap.forEach((key, node) -> { + Map children = permissionMap.getChildPermissions(key, node.getValue()); children.forEach((childKey, childValue) -> { childPermissions.put(childKey, RESULT_FACTORY.resultWithOverride(node, Tristate.of(childValue))); }); }); - this.childPermissions = childPermissions; - this.needsRefresh.set(false); - } - - @Override - public void invalidate() { - this.needsRefresh.set(true); + return childPermissions; } } diff --git a/bungee/src/main/java/me/lucko/luckperms/bungee/calculator/BungeeCalculatorFactory.java b/bungee/src/main/java/me/lucko/luckperms/bungee/calculator/BungeeCalculatorFactory.java index 72fcc1f46..def17b1c1 100644 --- a/bungee/src/main/java/me/lucko/luckperms/bungee/calculator/BungeeCalculatorFactory.java +++ b/bungee/src/main/java/me/lucko/luckperms/bungee/calculator/BungeeCalculatorFactory.java @@ -29,16 +29,19 @@ import me.lucko.luckperms.bungee.LPBungeePlugin; import me.lucko.luckperms.common.cacheddata.CacheMetadata; import me.lucko.luckperms.common.calculator.CalculatorFactory; import me.lucko.luckperms.common.calculator.PermissionCalculator; +import me.lucko.luckperms.common.calculator.PermissionCalculatorMonitored; import me.lucko.luckperms.common.calculator.processor.DirectProcessor; import me.lucko.luckperms.common.calculator.processor.PermissionProcessor; import me.lucko.luckperms.common.calculator.processor.RegexProcessor; import me.lucko.luckperms.common.calculator.processor.SpongeWildcardProcessor; import me.lucko.luckperms.common.calculator.processor.WildcardProcessor; import me.lucko.luckperms.common.config.ConfigKeys; +import net.luckperms.api.node.Node; import net.luckperms.api.query.QueryOptions; import java.util.ArrayList; import java.util.List; +import java.util.Map; public class BungeeCalculatorFactory implements CalculatorFactory { private final LPBungeePlugin plugin; @@ -48,23 +51,23 @@ public class BungeeCalculatorFactory implements CalculatorFactory { } @Override - public PermissionCalculator build(QueryOptions queryOptions, CacheMetadata metadata) { + public PermissionCalculator build(QueryOptions queryOptions, Map sourceMap, CacheMetadata metadata) { List processors = new ArrayList<>(4); - processors.add(new DirectProcessor()); + processors.add(new DirectProcessor(sourceMap)); if (this.plugin.getConfiguration().get(ConfigKeys.APPLYING_REGEX)) { - processors.add(new RegexProcessor()); + processors.add(new RegexProcessor(sourceMap)); } if (this.plugin.getConfiguration().get(ConfigKeys.APPLYING_WILDCARDS)) { - processors.add(new WildcardProcessor()); + processors.add(new WildcardProcessor(sourceMap)); } if (this.plugin.getConfiguration().get(ConfigKeys.APPLYING_WILDCARDS_SPONGE)) { - processors.add(new SpongeWildcardProcessor()); + processors.add(new SpongeWildcardProcessor(sourceMap)); } - return new PermissionCalculator(this.plugin, metadata, processors); + return new PermissionCalculatorMonitored(this.plugin, metadata, processors); } } diff --git a/common/minecraft/src/main/java/me/lucko/luckperms/common/minecraft/calculator/MinecraftCalculatorFactory.java b/common/minecraft/src/main/java/me/lucko/luckperms/common/minecraft/calculator/MinecraftCalculatorFactory.java index 2a90d6b66..dff9507d0 100644 --- a/common/minecraft/src/main/java/me/lucko/luckperms/common/minecraft/calculator/MinecraftCalculatorFactory.java +++ b/common/minecraft/src/main/java/me/lucko/luckperms/common/minecraft/calculator/MinecraftCalculatorFactory.java @@ -28,6 +28,7 @@ package me.lucko.luckperms.common.minecraft.calculator; import me.lucko.luckperms.common.cacheddata.CacheMetadata; import me.lucko.luckperms.common.calculator.CalculatorFactory; import me.lucko.luckperms.common.calculator.PermissionCalculator; +import me.lucko.luckperms.common.calculator.PermissionCalculatorMonitored; import me.lucko.luckperms.common.calculator.processor.DirectProcessor; import me.lucko.luckperms.common.calculator.processor.PermissionProcessor; import me.lucko.luckperms.common.calculator.processor.RegexProcessor; @@ -36,10 +37,12 @@ import me.lucko.luckperms.common.calculator.processor.WildcardProcessor; import me.lucko.luckperms.common.config.ConfigKeys; import me.lucko.luckperms.common.minecraft.context.MinecraftContextManager; import me.lucko.luckperms.common.plugin.LuckPermsPlugin; +import net.luckperms.api.node.Node; import net.luckperms.api.query.QueryOptions; import java.util.ArrayList; import java.util.List; +import java.util.Map; public class MinecraftCalculatorFactory implements CalculatorFactory { private final LuckPermsPlugin plugin; @@ -49,21 +52,21 @@ public class MinecraftCalculatorFactory implements CalculatorFactory { } @Override - public PermissionCalculator build(QueryOptions queryOptions, CacheMetadata metadata) { + public PermissionCalculator build(QueryOptions queryOptions, Map sourceMap, CacheMetadata metadata) { List processors = new ArrayList<>(5); - processors.add(new DirectProcessor()); + processors.add(new DirectProcessor(sourceMap)); if (this.plugin.getConfiguration().get(ConfigKeys.APPLYING_REGEX)) { - processors.add(new RegexProcessor()); + processors.add(new RegexProcessor(sourceMap)); } if (this.plugin.getConfiguration().get(ConfigKeys.APPLYING_WILDCARDS)) { - processors.add(new WildcardProcessor()); + processors.add(new WildcardProcessor(sourceMap)); } if (this.plugin.getConfiguration().get(ConfigKeys.APPLYING_WILDCARDS_SPONGE)) { - processors.add(new SpongeWildcardProcessor()); + processors.add(new SpongeWildcardProcessor(sourceMap)); } boolean integratedOwner = queryOptions.option(MinecraftContextManager.INTEGRATED_SERVER_OWNER).orElse(false); @@ -71,6 +74,6 @@ public class MinecraftCalculatorFactory implements CalculatorFactory { processors.add(ServerOwnerProcessor.INSTANCE); } - return new PermissionCalculator(this.plugin, metadata, processors); + return new PermissionCalculatorMonitored(this.plugin, metadata, processors); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/cacheddata/type/PermissionCache.java b/common/src/main/java/me/lucko/luckperms/common/cacheddata/type/PermissionCache.java index b0352b3ac..ac0a0fdf3 100644 --- a/common/src/main/java/me/lucko/luckperms/common/cacheddata/type/PermissionCache.java +++ b/common/src/main/java/me/lucko/luckperms/common/cacheddata/type/PermissionCache.java @@ -74,9 +74,7 @@ public class PermissionCache extends UsageTracked implements CachedPermissionDat this.queryOptions = queryOptions; this.permissions = sourcePermissions; this.permissionsView = Collections.unmodifiableMap(Maps.transformValues(this.permissions, Node::getValue)); - - this.calculator = calculatorFactory.build(queryOptions, metadata); - this.calculator.setSourcePermissions(this.permissions); + this.calculator = calculatorFactory.build(queryOptions, this.permissions, metadata); } @Override diff --git a/common/src/main/java/me/lucko/luckperms/common/calculator/CalculatorFactory.java b/common/src/main/java/me/lucko/luckperms/common/calculator/CalculatorFactory.java index b7f494ee7..7d2e8ff83 100644 --- a/common/src/main/java/me/lucko/luckperms/common/calculator/CalculatorFactory.java +++ b/common/src/main/java/me/lucko/luckperms/common/calculator/CalculatorFactory.java @@ -26,20 +26,24 @@ package me.lucko.luckperms.common.calculator; import me.lucko.luckperms.common.cacheddata.CacheMetadata; +import net.luckperms.api.node.Node; import net.luckperms.api.query.QueryOptions; +import java.util.Map; + /** - * Creates a calculator instance given a set of contexts + * Creates {@link PermissionCalculator} instances */ public interface CalculatorFactory { /** - * Builds a PermissionCalculator for the user in the given context + * Builds a PermissionCalculator with the given source permissions and query options. * - * @param queryOptions the query options to build the calculator for - * @param metadata the calculator metadata + * @param queryOptions the query options + * @param sourceMap the source permissions map + * @param metadata the calculator metadata * @return a permission calculator instance */ - PermissionCalculator build(QueryOptions queryOptions, CacheMetadata metadata); + PermissionCalculator build(QueryOptions queryOptions, Map sourceMap, CacheMetadata metadata); } diff --git a/common/src/main/java/me/lucko/luckperms/common/calculator/PermissionCalculator.java b/common/src/main/java/me/lucko/luckperms/common/calculator/PermissionCalculator.java index 6e3fa6712..0595ed731 100644 --- a/common/src/main/java/me/lucko/luckperms/common/calculator/PermissionCalculator.java +++ b/common/src/main/java/me/lucko/luckperms/common/calculator/PermissionCalculator.java @@ -25,43 +25,34 @@ package me.lucko.luckperms.common.calculator; -import me.lucko.luckperms.common.cacheddata.CacheMetadata; import me.lucko.luckperms.common.cacheddata.result.TristateResult; -import me.lucko.luckperms.common.calculator.processor.PermissionProcessor; -import me.lucko.luckperms.common.plugin.LuckPermsPlugin; import me.lucko.luckperms.common.verbose.event.CheckOrigin; -import java.util.Collection; +public interface PermissionCalculator { -/** - * Calculates and caches permissions - */ -public class PermissionCalculator extends PermissionLookupCache { + /** + * A calculator which always returns undefined. + */ + PermissionCalculator EMPTY = new PermissionCalculator() { + @Override + public TristateResult checkPermission(String permission, CheckOrigin origin) { + return TristateResult.UNDEFINED; + } - /** The plugin instance */ - private final LuckPermsPlugin plugin; + @Override + public void invalidateCache() { - /** Info about the nature of this calculator. */ - private final CacheMetadata metadata; + } + }; - public PermissionCalculator(LuckPermsPlugin plugin, CacheMetadata metadata, Collection processors) { - super(processors); - this.plugin = plugin; - this.metadata = metadata; - } + /** + * Performs a permission check against this calculator. + * + * @param permission the permission to check + * @param origin marks where this check originated from + * @return the result + */ + TristateResult checkPermission(String permission, CheckOrigin origin); - @Override - public TristateResult checkPermission(String permission, CheckOrigin origin) { - TristateResult result = super.checkPermission(permission, origin); - this.plugin.getVerboseHandler().offerPermissionCheckEvent(origin, this.metadata.getVerboseCheckInfo(), this.metadata.getQueryOptions(), permission, result); - return result; - } - - @Override - protected void observePermission(String permission) { - // offer the permission to the permission vault - // we only need to do this once per permission, so it doesn't matter - // that this call is behind the cache. - this.plugin.getPermissionRegistry().offer(permission); - } + void invalidateCache(); } diff --git a/common/src/main/java/me/lucko/luckperms/common/calculator/PermissionLookupCache.java b/common/src/main/java/me/lucko/luckperms/common/calculator/PermissionCalculatorBase.java similarity index 73% rename from common/src/main/java/me/lucko/luckperms/common/calculator/PermissionLookupCache.java rename to common/src/main/java/me/lucko/luckperms/common/calculator/PermissionCalculatorBase.java index b95c19e9a..6abad7bc4 100644 --- a/common/src/main/java/me/lucko/luckperms/common/calculator/PermissionLookupCache.java +++ b/common/src/main/java/me/lucko/luckperms/common/calculator/PermissionCalculatorBase.java @@ -29,44 +29,32 @@ import me.lucko.luckperms.common.cache.LoadingMap; import me.lucko.luckperms.common.cacheddata.result.TristateResult; import me.lucko.luckperms.common.calculator.processor.PermissionProcessor; import me.lucko.luckperms.common.verbose.event.CheckOrigin; -import net.luckperms.api.node.Node; import org.checkerframework.checker.nullness.qual.NonNull; import java.util.Collection; import java.util.Locale; -import java.util.Map; -import java.util.function.Function; /** * Calculates and caches permissions */ -public class PermissionLookupCache implements Function { +public class PermissionCalculatorBase implements PermissionCalculator { /** The processors which back this calculator */ private final PermissionProcessor[] processors; /** Loading cache for permission checks */ - private final LoadingMap lookupCache = LoadingMap.of(this); + private final LoadingMap lookupCache = LoadingMap.of(this::resolve); - public PermissionLookupCache(Collection processors) { + public PermissionCalculatorBase(Collection processors) { this.processors = processors.toArray(new PermissionProcessor[0]); } - /** - * Performs a permission check against this calculator. - * - *

The result is calculated using the calculators backing 'processors'.

- * - * @param permission the permission to check - * @param origin marks where this check originated from - * @return the result - */ + @Override public TristateResult checkPermission(String permission, CheckOrigin origin) { return this.lookupCache.get(permission); } - @Override - public TristateResult apply(@NonNull String permission) { + private TristateResult resolve(@NonNull String permission) { // convert the permission to lowercase, as all values in the backing map are also lowercase. // this allows fast case insensitive lookups permission = permission.toLowerCase(Locale.ROOT); @@ -84,19 +72,7 @@ public class PermissionLookupCache implements Function { } - /** - * Defines the source permissions map which should be used when calculating - * a result. - * - * @param sourceMap the source map - */ - public synchronized void setSourcePermissions(Map sourceMap) { - for (PermissionProcessor processor : this.processors) { - processor.setSource(sourceMap); - processor.refresh(); - } - } - + @Override public void invalidateCache() { for (PermissionProcessor processor : this.processors) { processor.invalidate(); diff --git a/common/src/main/java/me/lucko/luckperms/common/calculator/PermissionCalculatorMonitored.java b/common/src/main/java/me/lucko/luckperms/common/calculator/PermissionCalculatorMonitored.java new file mode 100644 index 000000000..9f17a997a --- /dev/null +++ b/common/src/main/java/me/lucko/luckperms/common/calculator/PermissionCalculatorMonitored.java @@ -0,0 +1,67 @@ +/* + * This file is part of LuckPerms, licensed under the MIT License. + * + * Copyright (c) lucko (Luck) + * Copyright (c) contributors + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +package me.lucko.luckperms.common.calculator; + +import me.lucko.luckperms.common.cacheddata.CacheMetadata; +import me.lucko.luckperms.common.cacheddata.result.TristateResult; +import me.lucko.luckperms.common.calculator.processor.PermissionProcessor; +import me.lucko.luckperms.common.plugin.LuckPermsPlugin; +import me.lucko.luckperms.common.verbose.event.CheckOrigin; + +import java.util.Collection; + +/** + * Calculates and caches permissions + */ +public class PermissionCalculatorMonitored extends PermissionCalculatorBase { + + /** The plugin instance */ + private final LuckPermsPlugin plugin; + + /** Info about the nature of this calculator. */ + private final CacheMetadata metadata; + + public PermissionCalculatorMonitored(LuckPermsPlugin plugin, CacheMetadata metadata, Collection processors) { + super(processors); + this.plugin = plugin; + this.metadata = metadata; + } + + @Override + public TristateResult checkPermission(String permission, CheckOrigin origin) { + TristateResult result = super.checkPermission(permission, origin); + this.plugin.getVerboseHandler().offerPermissionCheckEvent(origin, this.metadata.getVerboseCheckInfo(), this.metadata.getQueryOptions(), permission, result); + return result; + } + + @Override + protected void observePermission(String permission) { + // offer the permission to the permission vault + // we only need to do this once per permission, so it doesn't matter + // that this call is behind the cache. + this.plugin.getPermissionRegistry().offer(permission); + } +} diff --git a/common/src/main/java/me/lucko/luckperms/common/calculator/processor/AbstractSourceBasedProcessor.java b/common/src/main/java/me/lucko/luckperms/common/calculator/processor/AbstractSourceBasedProcessor.java deleted file mode 100644 index 8b50500a3..000000000 --- a/common/src/main/java/me/lucko/luckperms/common/calculator/processor/AbstractSourceBasedProcessor.java +++ /dev/null @@ -1,41 +0,0 @@ -/* - * This file is part of LuckPerms, licensed under the MIT License. - * - * Copyright (c) lucko (Luck) - * Copyright (c) contributors - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to deal - * in the Software without restriction, including without limitation the rights - * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - * copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in all - * copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE - * SOFTWARE. - */ - -package me.lucko.luckperms.common.calculator.processor; - -import net.luckperms.api.node.Node; - -import java.util.Collections; -import java.util.Map; - -public abstract class AbstractSourceBasedProcessor extends AbstractPermissionProcessor implements PermissionProcessor { - protected Map sourceMap = Collections.emptyMap(); - - @Override - public void setSource(Map sourceMap) { - this.sourceMap = sourceMap; - } - -} diff --git a/common/src/main/java/me/lucko/luckperms/common/calculator/processor/DirectProcessor.java b/common/src/main/java/me/lucko/luckperms/common/calculator/processor/DirectProcessor.java index f2ab6828d..679743547 100644 --- a/common/src/main/java/me/lucko/luckperms/common/calculator/processor/DirectProcessor.java +++ b/common/src/main/java/me/lucko/luckperms/common/calculator/processor/DirectProcessor.java @@ -26,10 +26,19 @@ package me.lucko.luckperms.common.calculator.processor; import me.lucko.luckperms.common.cacheddata.result.TristateResult; +import net.luckperms.api.node.Node; -public class DirectProcessor extends AbstractSourceBasedProcessor implements PermissionProcessor { +import java.util.Map; + +public class DirectProcessor extends AbstractPermissionProcessor implements PermissionProcessor { private static final TristateResult.Factory RESULT_FACTORY = new TristateResult.Factory(DirectProcessor.class); + private final Map sourceMap; + + public DirectProcessor(Map sourceMap) { + this.sourceMap = sourceMap; + } + @Override public TristateResult hasPermission(String permission) { return RESULT_FACTORY.result(this.sourceMap.get(permission)); diff --git a/common/src/main/java/me/lucko/luckperms/common/calculator/processor/PermissionProcessor.java b/common/src/main/java/me/lucko/luckperms/common/calculator/processor/PermissionProcessor.java index 5d553ca13..aea650f26 100644 --- a/common/src/main/java/me/lucko/luckperms/common/calculator/processor/PermissionProcessor.java +++ b/common/src/main/java/me/lucko/luckperms/common/calculator/processor/PermissionProcessor.java @@ -27,9 +27,6 @@ package me.lucko.luckperms.common.calculator.processor; import me.lucko.luckperms.common.cacheddata.result.TristateResult; import me.lucko.luckperms.common.calculator.PermissionCalculator; -import net.luckperms.api.node.Node; - -import java.util.Map; /** * A processor within a {@link PermissionCalculator}. @@ -48,22 +45,6 @@ public interface PermissionProcessor { */ TristateResult hasPermission(TristateResult prev, String permission); - /** - * Sets the source permissions which should be used by this processor - * - * @param sourceMap the source map - */ - default void setSource(Map sourceMap) { - - } - - /** - * Called after a change has been made to the source map - */ - default void refresh() { - - } - /** * Called after the parent calculator has been invalidated */ diff --git a/common/src/main/java/me/lucko/luckperms/common/calculator/processor/RegexProcessor.java b/common/src/main/java/me/lucko/luckperms/common/calculator/processor/RegexProcessor.java index e5a387220..b6a3bbbfe 100644 --- a/common/src/main/java/me/lucko/luckperms/common/calculator/processor/RegexProcessor.java +++ b/common/src/main/java/me/lucko/luckperms/common/calculator/processor/RegexProcessor.java @@ -26,35 +26,36 @@ package me.lucko.luckperms.common.calculator.processor; import com.google.common.collect.ImmutableList; -import com.google.common.collect.Maps; import me.lucko.luckperms.common.cacheddata.result.TristateResult; import me.lucko.luckperms.common.node.types.RegexPermission; import net.luckperms.api.node.Node; -import java.util.Collections; import java.util.List; import java.util.Map; import java.util.regex.Pattern; -public class RegexProcessor extends AbstractSourceBasedProcessor implements PermissionProcessor { +public class RegexProcessor extends AbstractPermissionProcessor implements PermissionProcessor { private static final TristateResult.Factory RESULT_FACTORY = new TristateResult.Factory(RegexProcessor.class); - private List> regexPermissions = Collections.emptyList(); + private final List regexPermissions; + + public RegexProcessor(Map sourceMap) { + this.regexPermissions = process(sourceMap); + } @Override public TristateResult hasPermission(String permission) { - for (Map.Entry e : this.regexPermissions) { - if (e.getKey().matcher(permission).matches()) { - return e.getValue(); + for (RegexEntry e : this.regexPermissions) { + if (e.pattern().matcher(permission).matches()) { + return e.result(); } } return TristateResult.UNDEFINED; } - @Override - public void refresh() { - ImmutableList.Builder> builder = ImmutableList.builder(); - for (Map.Entry e : this.sourceMap.entrySet()) { + private static List process(Map sourceMap) { + ImmutableList.Builder builder = ImmutableList.builder(); + for (Map.Entry e : sourceMap.entrySet()) { RegexPermission.Builder regexPerm = RegexPermission.parse(e.getKey()); if (regexPerm == null) { continue; @@ -66,8 +67,26 @@ public class RegexProcessor extends AbstractSourceBasedProcessor implements Perm } TristateResult value = RESULT_FACTORY.result(e.getValue()); - builder.add(Maps.immutableEntry(pattern, value)); + builder.add(new RegexEntry(pattern, value)); + } + return builder.build(); + } + + private static final class RegexEntry { + private final Pattern pattern; + private final TristateResult result; + + RegexEntry(Pattern pattern, TristateResult result) { + this.pattern = pattern; + this.result = result; + } + + public Pattern pattern() { + return this.pattern; + } + + public TristateResult result() { + return this.result; } - this.regexPermissions = builder.build(); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/calculator/processor/SpongeWildcardProcessor.java b/common/src/main/java/me/lucko/luckperms/common/calculator/processor/SpongeWildcardProcessor.java index 2e2b53692..7ab750895 100644 --- a/common/src/main/java/me/lucko/luckperms/common/calculator/processor/SpongeWildcardProcessor.java +++ b/common/src/main/java/me/lucko/luckperms/common/calculator/processor/SpongeWildcardProcessor.java @@ -29,9 +29,17 @@ import me.lucko.luckperms.common.cacheddata.result.TristateResult; import me.lucko.luckperms.common.node.AbstractNode; import net.luckperms.api.node.Node; -public class SpongeWildcardProcessor extends AbstractSourceBasedProcessor implements PermissionProcessor { +import java.util.Map; + +public class SpongeWildcardProcessor extends AbstractPermissionProcessor implements PermissionProcessor { private static final TristateResult.Factory RESULT_FACTORY = new TristateResult.Factory(SpongeWildcardProcessor.class); + private final Map sourceMap; + + public SpongeWildcardProcessor(Map sourceMap) { + this.sourceMap = sourceMap; + } + @Override public TristateResult hasPermission(String permission) { String node = permission; diff --git a/common/src/main/java/me/lucko/luckperms/common/calculator/processor/WildcardProcessor.java b/common/src/main/java/me/lucko/luckperms/common/calculator/processor/WildcardProcessor.java index c12bb5a74..3c52d5a2d 100644 --- a/common/src/main/java/me/lucko/luckperms/common/calculator/processor/WildcardProcessor.java +++ b/common/src/main/java/me/lucko/luckperms/common/calculator/processor/WildcardProcessor.java @@ -31,27 +31,23 @@ import me.lucko.luckperms.common.node.AbstractNode; import net.luckperms.api.node.Node; import net.luckperms.api.util.Tristate; -import java.util.Collections; import java.util.Map; -public class WildcardProcessor extends AbstractSourceBasedProcessor implements PermissionProcessor { +public class WildcardProcessor extends AbstractPermissionProcessor implements PermissionProcessor { private static final TristateResult.Factory RESULT_FACTORY = new TristateResult.Factory(WildcardProcessor.class); public static final String WILDCARD_SUFFIX = ".*"; private static final String ROOT_WILDCARD = "*"; private static final String ROOT_WILDCARD_WITH_QUOTES = "'*'"; - public static boolean isRootWildcard(String permission) { - return ROOT_WILDCARD.equals(permission) || ROOT_WILDCARD_WITH_QUOTES.equals(permission); - } + private final Map wildcardPermissions; + private final TristateResult rootWildcardState; - public static boolean isWildcardPermission(String permission) { - return isRootWildcard(permission) || permission.endsWith(WILDCARD_SUFFIX) && permission.length() > 2; + public WildcardProcessor(Map sourceMap) { + this.wildcardPermissions = processWildcardPermissions(sourceMap); + this.rootWildcardState = rootWildcardState(sourceMap); } - private Map wildcardPermissions = Collections.emptyMap(); - private TristateResult rootWildcardState = TristateResult.UNDEFINED; - @Override public TristateResult hasPermission(String permission) { String node = permission; @@ -74,10 +70,17 @@ public class WildcardProcessor extends AbstractSourceBasedProcessor implements P return this.rootWildcardState; } - @Override - public void refresh() { + public static boolean isRootWildcard(String permission) { + return ROOT_WILDCARD.equals(permission) || ROOT_WILDCARD_WITH_QUOTES.equals(permission); + } + + public static boolean isWildcardPermission(String permission) { + return isRootWildcard(permission) || permission.endsWith(WILDCARD_SUFFIX) && permission.length() > 2; + } + + private static Map processWildcardPermissions(Map sourceMap) { ImmutableMap.Builder builder = ImmutableMap.builder(); - for (Map.Entry e : this.sourceMap.entrySet()) { + for (Map.Entry e : sourceMap.entrySet()) { String key = e.getKey(); if (!key.endsWith(WILDCARD_SUFFIX) || key.length() <= 2) { continue; @@ -87,12 +90,14 @@ public class WildcardProcessor extends AbstractSourceBasedProcessor implements P TristateResult value = RESULT_FACTORY.result(e.getValue()); builder.put(key, value); } - this.wildcardPermissions = builder.build(); + return builder.build(); + } - Node rootWildcard = this.sourceMap.get(ROOT_WILDCARD); + private static TristateResult rootWildcardState(Map sourceMap) { + Node rootWildcard = sourceMap.get(ROOT_WILDCARD); if (rootWildcard == null) { - rootWildcard = this.sourceMap.get(ROOT_WILDCARD_WITH_QUOTES); + rootWildcard = sourceMap.get(ROOT_WILDCARD_WITH_QUOTES); } - this.rootWildcardState = rootWildcard == null ? TristateResult.UNDEFINED : RESULT_FACTORY.result(rootWildcard); + return rootWildcard == null ? TristateResult.UNDEFINED : RESULT_FACTORY.result(rootWildcard); } } diff --git a/common/src/test/java/me/lucko/luckperms/common/calculator/PermissionLookupCacheTest.java b/common/src/test/java/me/lucko/luckperms/common/calculator/PermissionCalculatorTest.java similarity index 82% rename from common/src/test/java/me/lucko/luckperms/common/calculator/PermissionLookupCacheTest.java rename to common/src/test/java/me/lucko/luckperms/common/calculator/PermissionCalculatorTest.java index 7c1b17f95..1ec1cac4e 100644 --- a/common/src/test/java/me/lucko/luckperms/common/calculator/PermissionLookupCacheTest.java +++ b/common/src/test/java/me/lucko/luckperms/common/calculator/PermissionCalculatorTest.java @@ -49,7 +49,7 @@ import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNull; import static org.junit.jupiter.api.Assertions.assertSame; -public class PermissionLookupCacheTest { +public class PermissionCalculatorTest { private static final Map EXAMPLE_PERMISSIONS = ImmutableMap.builder() // direct @@ -86,10 +86,11 @@ public class PermissionLookupCacheTest { "test.node2, FALSE" }) public void testDirect(String node, Tristate expected) { - PermissionLookupCache lookupCache = new PermissionLookupCache(ImmutableList.of(new DirectProcessor())); - lookupCache.setSourcePermissions(EXAMPLE_PERMISSIONS); + PermissionCalculator calculator = new PermissionCalculatorBase(ImmutableList.of( + new DirectProcessor(EXAMPLE_PERMISSIONS) + )); - TristateResult result = lookupCache.checkPermission(node, CheckOrigin.INTERNAL); + TristateResult result = calculator.checkPermission(node, CheckOrigin.INTERNAL); assertEquals(expected, result.result()); assertNull(result.overriddenResult()); @@ -118,10 +119,12 @@ public class PermissionLookupCacheTest { "*, false, direct", }) public void testWildcard(String node, boolean expected, String type) { - PermissionLookupCache lookupCache = new PermissionLookupCache(ImmutableList.of(new DirectProcessor(), new WildcardProcessor())); - lookupCache.setSourcePermissions(EXAMPLE_PERMISSIONS); + PermissionCalculator calculator = new PermissionCalculatorBase(ImmutableList.of( + new DirectProcessor(EXAMPLE_PERMISSIONS), + new WildcardProcessor(EXAMPLE_PERMISSIONS) + )); - TristateResult result = lookupCache.checkPermission(node, CheckOrigin.INTERNAL); + TristateResult result = calculator.checkPermission(node, CheckOrigin.INTERNAL); assertEquals(Tristate.of(expected), result.result()); assertNull(result.overriddenResult()); assertNotNull(result.node()); @@ -143,10 +146,12 @@ public class PermissionLookupCacheTest { "one.two.test, true, wildcard", }) public void testSpongeWildcard(String node, boolean expected, String type) { - PermissionLookupCache lookupCache = new PermissionLookupCache(ImmutableList.of(new DirectProcessor(), new SpongeWildcardProcessor())); - lookupCache.setSourcePermissions(EXAMPLE_PERMISSIONS); + PermissionCalculator calculator = new PermissionCalculatorBase(ImmutableList.of( + new DirectProcessor(EXAMPLE_PERMISSIONS), + new SpongeWildcardProcessor(EXAMPLE_PERMISSIONS) + )); - TristateResult result = lookupCache.checkPermission(node, CheckOrigin.INTERNAL); + TristateResult result = calculator.checkPermission(node, CheckOrigin.INTERNAL); assertEquals(Tristate.of(expected), result.result()); assertNull(result.overriddenResult()); assertNotNull(result.node()); @@ -172,10 +177,12 @@ public class PermissionLookupCacheTest { "regexps4, FALSE", }) public void testRegex(String node, Tristate expected) { - PermissionLookupCache lookupCache = new PermissionLookupCache(ImmutableList.of(new DirectProcessor(), new RegexProcessor())); - lookupCache.setSourcePermissions(EXAMPLE_PERMISSIONS); + PermissionCalculator calculator = new PermissionCalculatorBase(ImmutableList.of( + new DirectProcessor(EXAMPLE_PERMISSIONS), + new RegexProcessor(EXAMPLE_PERMISSIONS) + )); - TristateResult result = lookupCache.checkPermission(node, CheckOrigin.INTERNAL); + TristateResult result = calculator.checkPermission(node, CheckOrigin.INTERNAL); assertEquals(expected, result.result()); assertNull(result.overriddenResult()); @@ -201,10 +208,13 @@ public class PermissionLookupCacheTest { } }; - PermissionLookupCache lookupCache = new PermissionLookupCache(ImmutableList.of(new DirectProcessor(), new WildcardProcessor(), overrideProcessor)); - lookupCache.setSourcePermissions(EXAMPLE_PERMISSIONS); + PermissionCalculator calculator = new PermissionCalculatorBase(ImmutableList.of( + new DirectProcessor(EXAMPLE_PERMISSIONS), + new WildcardProcessor(EXAMPLE_PERMISSIONS), + overrideProcessor + )); - TristateResult result = lookupCache.checkPermission("overridetest.test", CheckOrigin.INTERNAL); + TristateResult result = calculator.checkPermission("overridetest.test", CheckOrigin.INTERNAL); assertEquals(Tristate.FALSE, result.result()); assertSame(AbstractOverrideWildcardProcessor.class, result.processorClass()); diff --git a/common/src/test/java/me/lucko/luckperms/common/calculator/PermissionProcessorTest.java b/common/src/test/java/me/lucko/luckperms/common/calculator/PermissionProcessorTest.java new file mode 100644 index 000000000..82cc609b8 --- /dev/null +++ b/common/src/test/java/me/lucko/luckperms/common/calculator/PermissionProcessorTest.java @@ -0,0 +1,165 @@ +/* + * This file is part of LuckPerms, licensed under the MIT License. + * + * Copyright (c) lucko (Luck) + * Copyright (c) contributors + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +package me.lucko.luckperms.common.calculator; + +import me.lucko.luckperms.common.cacheddata.result.TristateResult; +import me.lucko.luckperms.common.calculator.processor.DirectProcessor; +import me.lucko.luckperms.common.calculator.processor.PermissionProcessor; +import me.lucko.luckperms.common.calculator.processor.RegexProcessor; +import me.lucko.luckperms.common.calculator.processor.SpongeWildcardProcessor; +import me.lucko.luckperms.common.calculator.processor.WildcardProcessor; +import me.lucko.luckperms.common.node.factory.NodeBuilders; +import net.luckperms.api.node.Node; +import net.luckperms.api.util.Tristate; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; + +import java.util.Map; +import java.util.stream.Collectors; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; + +public class PermissionProcessorTest { + + @ParameterizedTest + @CsvSource({ + "test, UNDEFINED", + "test.node1, TRUE", + "test.node2, FALSE" + }) + public void testDirect(String node, Tristate expected) { + PermissionProcessor processor = new DirectProcessor(createNodeMap(Map.of( + "test.node1", true, + "test.node2", false + ))); + + TristateResult result = processor.hasPermission(TristateResult.UNDEFINED, node); + assertEquals(expected, result.result()); + assertNull(result.overriddenResult()); + + if (expected != Tristate.UNDEFINED) { + assertNotNull(result.node()); + assertSame(DirectProcessor.class, result.processorClass()); + } else { + assertNull(result.node()); + assertNull(result.processorClass()); + } + } + + @ParameterizedTest + @CsvSource({ + "one.two.three.four, TRUE", + "one.two.test, TRUE", + "one.two, FALSE", + "one.test, FALSE", + "one.*, FALSE", + "one, TRUE", + "test, TRUE", + "*, TRUE", + }) + public void testWildcard(String node, Tristate expected) { + PermissionProcessor processor = new WildcardProcessor(createNodeMap(Map.of( + "one.two.*", true, + "one.*", false, + "*", true + ))); + + TristateResult result = processor.hasPermission(TristateResult.UNDEFINED, node); + assertEquals(expected, result.result()); + assertNull(result.overriddenResult()); + assertNotNull(result.node()); + assertSame(WildcardProcessor.class, result.processorClass()); + } + + @ParameterizedTest + @CsvSource({ + "one.two.three.test, FALSE", + "one.two.three, TRUE", + "one.two.test, TRUE", + "one.two, FALSE", + "one.test, FALSE", + "one, UNDEFINED", + }) + public void testSpongeWildcard(String node, Tristate expected) { + PermissionProcessor processor = new SpongeWildcardProcessor(createNodeMap(Map.of( + "one.two.three", false, + "one.two", true, + "one", false + ))); + + TristateResult result = processor.hasPermission(TristateResult.UNDEFINED, node); + assertEquals(expected, result.result()); + + if (expected != Tristate.UNDEFINED) { + assertNotNull(result.node()); + assertSame(SpongeWildcardProcessor.class, result.processorClass()); + } else { + assertNull(result.node()); + assertNull(result.processorClass()); + } + } + + @ParameterizedTest + @CsvSource({ + "hello, UNDEFINED", + "hello1, TRUE", + "hello123, TRUE", + "helloo, UNDEFINED", + "regex1, FALSE", + "regexes2, FALSE", + "regexp3, FALSE", + "regexps4, FALSE", + }) + public void testRegex(String node, Tristate expected) { + PermissionProcessor processor = new RegexProcessor(createNodeMap(Map.of( + "r=hello\\d+", true, + "R=rege(x(es)?|xps?)[1-5]", false + ))); + + TristateResult result = processor.hasPermission(TristateResult.UNDEFINED, node); + assertEquals(expected, result.result()); + assertNull(result.overriddenResult()); + + if (expected != Tristate.UNDEFINED) { + assertNotNull(result.node()); + assertSame(RegexProcessor.class, result.processorClass()); + } else { + assertNull(result.node()); + assertNull(result.processorClass()); + } + } + + private static Map createNodeMap(Map nodes) { + return nodes.entrySet().stream().collect(Collectors.toMap( + Map.Entry::getKey, + e -> NodeBuilders.determineMostApplicable(e.getKey()).value(e.getValue()).build() + )); + } + +} diff --git a/hytale/src/main/java/me/lucko/luckperms/hytale/LPHytalePlugin.java b/hytale/src/main/java/me/lucko/luckperms/hytale/LPHytalePlugin.java index 1d3ba83e8..2c2d4aaf6 100644 --- a/hytale/src/main/java/me/lucko/luckperms/hytale/LPHytalePlugin.java +++ b/hytale/src/main/java/me/lucko/luckperms/hytale/LPHytalePlugin.java @@ -49,7 +49,7 @@ import me.lucko.luckperms.common.plugin.AbstractLuckPermsPlugin; import me.lucko.luckperms.common.plugin.util.AbstractConnectionListener; import me.lucko.luckperms.common.sender.Sender; import me.lucko.luckperms.hytale.calculator.HytaleCalculatorFactory; -import me.lucko.luckperms.hytale.calculator.virtualgroups.VirtualGroupsLookupProvider; +import me.lucko.luckperms.hytale.calculator.virtualgroups.VirtualGroupsMap; import me.lucko.luckperms.hytale.chat.LuckPermsChatFormatter; import me.lucko.luckperms.hytale.context.HytaleContextManager; import me.lucko.luckperms.hytale.context.HytalePlayerCalculator; @@ -81,8 +81,8 @@ public class LPHytalePlugin extends AbstractLuckPermsPlugin { private HytaleContextManager contextManager; private PlayerVirtualGroupsMap playerVirtualGroupsMap; - private VirtualGroupsLookupProvider virtualGroupsLookupProvider; - private LuckPermsPermissionProvider luckPermsPermissionProvider; + private VirtualGroupsMap virtualGroupsMap; + private LuckPermsPermissionProvider permissionProvider; public LPHytalePlugin(LPHytaleBootstrap bootstrap) { this.bootstrap = bootstrap; @@ -163,8 +163,8 @@ public class LPHytalePlugin extends AbstractLuckPermsPlugin { @Override protected CalculatorFactory provideCalculatorFactory() { - this.virtualGroupsLookupProvider = new VirtualGroupsLookupProvider(); - return new HytaleCalculatorFactory(this, this.virtualGroupsLookupProvider); + this.virtualGroupsMap = new VirtualGroupsMap(); + return new HytaleCalculatorFactory(this); } @Override @@ -193,12 +193,12 @@ public class LPHytalePlugin extends AbstractLuckPermsPlugin { } // register our provider - this.luckPermsPermissionProvider = new LuckPermsPermissionProvider(this, hytaleProvider, this.playerVirtualGroupsMap); - permissionsModule.addProvider(this.luckPermsPermissionProvider); + this.permissionProvider = new LuckPermsPermissionProvider(this, hytaleProvider, this.playerVirtualGroupsMap); + permissionsModule.addProvider(this.permissionProvider); // remove all other providers for (PermissionProvider provider : permissionsModule.getProviders()) { - if (provider != this.luckPermsPermissionProvider) { + if (provider != this.permissionProvider) { permissionsModule.removeProvider(provider); } } @@ -217,11 +217,11 @@ public class LPHytalePlugin extends AbstractLuckPermsPlugin { @Override protected void removePlatformHooks() { PermissionsModule permissionsModule = PermissionsModule.get(); - HytalePermissionsProvider hytaleProvider = this.luckPermsPermissionProvider.getHytaleProvider(); + HytalePermissionsProvider hytaleProvider = this.permissionProvider.getHytaleProvider(); if (hytaleProvider != null) { permissionsModule.addProvider(hytaleProvider); } - permissionsModule.removeProvider(this.luckPermsPermissionProvider); + permissionsModule.removeProvider(this.permissionProvider); } @Override @@ -261,8 +261,8 @@ public class LPHytalePlugin extends AbstractLuckPermsPlugin { return this.senderFactory; } - public VirtualGroupsLookupProvider getVirtualGroupsLookupProvider() { - return this.virtualGroupsLookupProvider; + public VirtualGroupsMap getVirtualGroupsMap() { + return this.virtualGroupsMap; } @Override diff --git a/hytale/src/main/java/me/lucko/luckperms/hytale/calculator/HytaleCalculatorFactory.java b/hytale/src/main/java/me/lucko/luckperms/hytale/calculator/HytaleCalculatorFactory.java index 8c5deb964..f88fe6f7a 100644 --- a/hytale/src/main/java/me/lucko/luckperms/hytale/calculator/HytaleCalculatorFactory.java +++ b/hytale/src/main/java/me/lucko/luckperms/hytale/calculator/HytaleCalculatorFactory.java @@ -25,9 +25,11 @@ package me.lucko.luckperms.hytale.calculator; +import com.google.common.collect.ImmutableSet; import me.lucko.luckperms.common.cacheddata.CacheMetadata; import me.lucko.luckperms.common.calculator.CalculatorFactory; import me.lucko.luckperms.common.calculator.PermissionCalculator; +import me.lucko.luckperms.common.calculator.PermissionCalculatorMonitored; import me.lucko.luckperms.common.calculator.processor.DirectProcessor; import me.lucko.luckperms.common.calculator.processor.PermissionProcessor; import me.lucko.luckperms.common.calculator.processor.RegexProcessor; @@ -35,40 +37,38 @@ import me.lucko.luckperms.common.calculator.processor.SpongeWildcardProcessor; import me.lucko.luckperms.common.calculator.processor.WildcardProcessor; import me.lucko.luckperms.common.config.ConfigKeys; import me.lucko.luckperms.hytale.LPHytalePlugin; -import me.lucko.luckperms.hytale.calculator.virtualgroups.VirtualGroupsLookupProvider; import me.lucko.luckperms.hytale.context.HytaleContextManager; import me.lucko.luckperms.hytale.service.VirtualGroups; +import net.luckperms.api.node.Node; import net.luckperms.api.query.QueryOptions; import java.util.ArrayList; import java.util.List; -import java.util.Set; +import java.util.Map; public class HytaleCalculatorFactory implements CalculatorFactory { private final LPHytalePlugin plugin; - private final VirtualGroupsLookupProvider virtualGroupsLookupProvider; - public HytaleCalculatorFactory(LPHytalePlugin plugin, VirtualGroupsLookupProvider virtualGroupsLookupProvider) { + public HytaleCalculatorFactory(LPHytalePlugin plugin) { this.plugin = plugin; - this.virtualGroupsLookupProvider = virtualGroupsLookupProvider; } @Override - public PermissionCalculator build(QueryOptions queryOptions, CacheMetadata metadata) { + public PermissionCalculator build(QueryOptions queryOptions, Map sourceMap, CacheMetadata metadata) { List processors = new ArrayList<>(6); - processors.add(new DirectProcessor()); + processors.add(new DirectProcessor(sourceMap)); if (this.plugin.getConfiguration().get(ConfigKeys.APPLYING_REGEX)) { - processors.add(new RegexProcessor()); + processors.add(new RegexProcessor(sourceMap)); } if (this.plugin.getConfiguration().get(ConfigKeys.APPLYING_WILDCARDS)) { - processors.add(new WildcardProcessor()); + processors.add(new WildcardProcessor(sourceMap)); } if (this.plugin.getConfiguration().get(ConfigKeys.APPLYING_WILDCARDS_SPONGE)) { - processors.add(new SpongeWildcardProcessor()); + processors.add(new SpongeWildcardProcessor(sourceMap)); } boolean integratedOwner = queryOptions.option(HytaleContextManager.INTEGRATED_SERVER_OWNER).orElse(false); @@ -77,12 +77,10 @@ public class HytaleCalculatorFactory implements CalculatorFactory { } if (this.plugin.getConfiguration().get(ConfigKeys.APPLY_HYTALE_VIRTUAL_GROUPS)) { - Set virtualGroups = queryOptions.option(VirtualGroups.KEY).orElse(VirtualGroups.EMPTY).groups(); - if (!virtualGroups.isEmpty()) { - processors.add(new HytaleVirtualGroupProcessor(this.virtualGroupsLookupProvider.getLookup(virtualGroups))); - } + ImmutableSet virtualGroups = queryOptions.option(VirtualGroups.KEY).orElse(VirtualGroups.EMPTY).groups(); + processors.add(new HytaleVirtualGroupProcessor(this.plugin, virtualGroups, sourceMap)); } - return new PermissionCalculator(this.plugin, metadata, processors); + return new PermissionCalculatorMonitored(this.plugin, metadata, processors); } } diff --git a/hytale/src/main/java/me/lucko/luckperms/hytale/calculator/HytaleVirtualGroupProcessor.java b/hytale/src/main/java/me/lucko/luckperms/hytale/calculator/HytaleVirtualGroupProcessor.java index 6b4924c6f..5cccd672b 100644 --- a/hytale/src/main/java/me/lucko/luckperms/hytale/calculator/HytaleVirtualGroupProcessor.java +++ b/hytale/src/main/java/me/lucko/luckperms/hytale/calculator/HytaleVirtualGroupProcessor.java @@ -25,11 +25,20 @@ package me.lucko.luckperms.hytale.calculator; +import com.google.common.collect.ImmutableSet; import me.lucko.luckperms.common.cacheddata.result.TristateResult; -import me.lucko.luckperms.common.calculator.PermissionLookupCache; +import me.lucko.luckperms.common.calculator.PermissionCalculator; import me.lucko.luckperms.common.calculator.processor.AbstractPermissionProcessor; import me.lucko.luckperms.common.calculator.processor.PermissionProcessor; +import me.lucko.luckperms.common.node.types.Inheritance; import me.lucko.luckperms.common.verbose.event.CheckOrigin; +import me.lucko.luckperms.hytale.LPHytalePlugin; +import me.lucko.luckperms.hytale.calculator.virtualgroups.VirtualGroupsMap; +import net.luckperms.api.node.Node; + +import java.util.HashSet; +import java.util.Map; +import java.util.Set; /** * Permission Processor for Hytale "virtual groups". @@ -37,15 +46,32 @@ import me.lucko.luckperms.common.verbose.event.CheckOrigin; public class HytaleVirtualGroupProcessor extends AbstractPermissionProcessor implements PermissionProcessor { public static final TristateResult.Factory RESULT_FACTORY = new TristateResult.Factory(HytaleVirtualGroupProcessor.class); - private final PermissionLookupCache lookup; + private final PermissionCalculator calculator; - public HytaleVirtualGroupProcessor(PermissionLookupCache lookup) { - this.lookup = lookup; + public HytaleVirtualGroupProcessor(LPHytalePlugin plugin, ImmutableSet virtualGroups, Map sourceMap) { + VirtualGroupsMap virtualGroupsMap = plugin.getVirtualGroupsMap(); + + Set groups = virtualGroups; + for (String group : virtualGroupsMap.getAllVirtualGroups()) { + if (groups.contains(group)) { + continue; + } + + Node node = sourceMap.get(Inheritance.key(group)); + if (node != null && node.getValue()) { + if (groups instanceof ImmutableSet) { + groups = new HashSet<>(groups); + } + groups.add(group); + } + } + + this.calculator = virtualGroupsMap.getCalculator(ImmutableSet.copyOf(groups)); } @Override public TristateResult hasPermission(String permission) { - return RESULT_FACTORY.result(this.lookup.checkPermission(permission, CheckOrigin.INTERNAL).result()); + return RESULT_FACTORY.result(this.calculator.checkPermission(permission, CheckOrigin.INTERNAL).result()); } } diff --git a/hytale/src/main/java/me/lucko/luckperms/hytale/calculator/virtualgroups/VirtualGroupsAccess.java b/hytale/src/main/java/me/lucko/luckperms/hytale/calculator/virtualgroups/VirtualGroupsAccess.java index 42ecf5f78..7cc7d4249 100644 --- a/hytale/src/main/java/me/lucko/luckperms/hytale/calculator/virtualgroups/VirtualGroupsAccess.java +++ b/hytale/src/main/java/me/lucko/luckperms/hytale/calculator/virtualgroups/VirtualGroupsAccess.java @@ -28,13 +28,13 @@ package me.lucko.luckperms.hytale.calculator.virtualgroups; import com.google.common.collect.ImmutableMap; import com.hypixel.hytale.server.core.permissions.PermissionsModule; import me.lucko.luckperms.common.node.factory.NodeBuilders; +import me.lucko.luckperms.common.util.ImmutableCollectors; import net.luckperms.api.node.Node; import java.lang.reflect.Field; import java.util.Locale; import java.util.Map; import java.util.Set; -import java.util.stream.Collectors; public class VirtualGroupsAccess { @@ -54,10 +54,10 @@ public class VirtualGroupsAccess { * * @return the exported mapping */ - public static Map> export() { + public static ImmutableMap> export() { Map> virtualGroups = getVirtualGroups(); - return virtualGroups.entrySet().stream().collect(Collectors.toMap( - Map.Entry::getKey, + return virtualGroups.entrySet().stream().collect(ImmutableCollectors.toMap( + e -> e.getKey().toLowerCase(Locale.ROOT), e -> transformSet(e.getValue()) )); } @@ -83,7 +83,7 @@ public class VirtualGroupsAccess { * @param permissions the input * @return the transformed map */ - private static Map transformSet(Set permissions) { + private static ImmutableMap transformSet(Set permissions) { ImmutableMap.Builder builder = ImmutableMap.builder(); for (String permission : permissions) { diff --git a/hytale/src/main/java/me/lucko/luckperms/hytale/calculator/virtualgroups/VirtualGroupsLookupProvider.java b/hytale/src/main/java/me/lucko/luckperms/hytale/calculator/virtualgroups/VirtualGroupsMap.java similarity index 69% rename from hytale/src/main/java/me/lucko/luckperms/hytale/calculator/virtualgroups/VirtualGroupsLookupProvider.java rename to hytale/src/main/java/me/lucko/luckperms/hytale/calculator/virtualgroups/VirtualGroupsMap.java index 79f304f84..ba845a71d 100644 --- a/hytale/src/main/java/me/lucko/luckperms/hytale/calculator/virtualgroups/VirtualGroupsLookupProvider.java +++ b/hytale/src/main/java/me/lucko/luckperms/hytale/calculator/virtualgroups/VirtualGroupsMap.java @@ -26,8 +26,10 @@ package me.lucko.luckperms.hytale.calculator.virtualgroups; import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; import me.lucko.luckperms.common.cache.LoadingMap; -import me.lucko.luckperms.common.calculator.PermissionLookupCache; +import me.lucko.luckperms.common.calculator.PermissionCalculator; +import me.lucko.luckperms.common.calculator.PermissionCalculatorBase; import me.lucko.luckperms.common.calculator.processor.DirectProcessor; import me.lucko.luckperms.common.calculator.processor.PermissionProcessor; import me.lucko.luckperms.common.calculator.processor.WildcardProcessor; @@ -39,12 +41,12 @@ import java.util.Map; import java.util.Set; import java.util.concurrent.ConcurrentHashMap; -public class VirtualGroupsLookupProvider { - private final Map, PermissionLookupCache> caches; - private Map> virtualGroupToNodesMap; +public class VirtualGroupsMap { + private final Map, PermissionCalculator> caches; + private ImmutableMap> virtualGroupToNodesMap; - public VirtualGroupsLookupProvider() { - this.caches = LoadingMap.of(this::buildCache); + public VirtualGroupsMap() { + this.caches = LoadingMap.of(this::buildCalculator); refresh(); } @@ -53,23 +55,29 @@ public class VirtualGroupsLookupProvider { this.caches.clear(); } - public PermissionLookupCache getLookup(Set virtualGroups) { + public ImmutableSet getAllVirtualGroups() { + return this.virtualGroupToNodesMap.keySet(); + } + + public PermissionCalculator getCalculator(ImmutableSet virtualGroups) { return this.caches.get(virtualGroups); } - private PermissionLookupCache buildCache(Set virtualGroups) { + private PermissionCalculator buildCalculator(Set virtualGroups) { Map sourceMap = new ConcurrentHashMap<>(); for (String virtualGroup : virtualGroups) { sourceMap.putAll(this.virtualGroupToNodesMap.getOrDefault(virtualGroup, ImmutableMap.of())); } - List processors = new ArrayList<>(2); - processors.add(new DirectProcessor()); - processors.add(new WildcardProcessor()); + if (sourceMap.isEmpty()) { + return PermissionCalculator.EMPTY; + } - PermissionLookupCache lookupCache = new PermissionLookupCache(processors); - lookupCache.setSourcePermissions(sourceMap); - return lookupCache; + List processors = new ArrayList<>(2); + processors.add(new DirectProcessor(sourceMap)); + processors.add(new WildcardProcessor(sourceMap)); + + return new PermissionCalculatorBase(processors); } } diff --git a/hytale/src/main/java/me/lucko/luckperms/hytale/context/HytaleContextManager.java b/hytale/src/main/java/me/lucko/luckperms/hytale/context/HytaleContextManager.java index 1586456e9..1ce084dab 100644 --- a/hytale/src/main/java/me/lucko/luckperms/hytale/context/HytaleContextManager.java +++ b/hytale/src/main/java/me/lucko/luckperms/hytale/context/HytaleContextManager.java @@ -25,6 +25,7 @@ package me.lucko.luckperms.hytale.context; +import com.google.common.collect.ImmutableSet; import com.hypixel.hytale.server.core.Constants; import com.hypixel.hytale.server.core.modules.singleplayer.SingleplayerModule; import com.hypixel.hytale.server.core.universe.PlayerRef; @@ -35,7 +36,6 @@ import me.lucko.luckperms.hytale.service.VirtualGroups; import net.luckperms.api.query.OptionKey; import net.luckperms.api.query.QueryOptions; -import java.util.Set; import java.util.UUID; public class HytaleContextManager extends SimpleContextManager { @@ -59,7 +59,7 @@ public class HytaleContextManager extends SimpleContextManager groups = this.playerVirtualGroupsMap.getPlayerGroups(subject.getUuid()); + ImmutableSet groups = this.playerVirtualGroupsMap.getPlayerGroups(subject.getUuid()); builder.option(VirtualGroups.KEY, new VirtualGroups(groups)); } } diff --git a/hytale/src/main/java/me/lucko/luckperms/hytale/listeners/HytalePlatformListener.java b/hytale/src/main/java/me/lucko/luckperms/hytale/listeners/HytalePlatformListener.java index e42747435..0d9b22d6d 100644 --- a/hytale/src/main/java/me/lucko/luckperms/hytale/listeners/HytalePlatformListener.java +++ b/hytale/src/main/java/me/lucko/luckperms/hytale/listeners/HytalePlatformListener.java @@ -46,7 +46,7 @@ public class HytalePlatformListener { public void onBoot(BootEvent e) { insertCommandPermissionsIntoRegistry(); - this.plugin.getVirtualGroupsLookupProvider().refresh(); + this.plugin.getVirtualGroupsMap().refresh(); } public void insertCommandPermissionsIntoRegistry() { diff --git a/hytale/src/main/java/me/lucko/luckperms/hytale/service/PlayerVirtualGroupsMap.java b/hytale/src/main/java/me/lucko/luckperms/hytale/service/PlayerVirtualGroupsMap.java index 8f4db8eb7..cd4199d17 100644 --- a/hytale/src/main/java/me/lucko/luckperms/hytale/service/PlayerVirtualGroupsMap.java +++ b/hytale/src/main/java/me/lucko/luckperms/hytale/service/PlayerVirtualGroupsMap.java @@ -27,8 +27,8 @@ package me.lucko.luckperms.hytale.service; import com.google.common.collect.ImmutableSet; +import java.util.Locale; import java.util.Map; -import java.util.Set; import java.util.UUID; import java.util.concurrent.ConcurrentHashMap; @@ -38,7 +38,9 @@ import java.util.concurrent.ConcurrentHashMap; public class PlayerVirtualGroupsMap { private final Map> uuidToGroups = new ConcurrentHashMap<>(); - public void addPlayerToGroup(UUID uuid, String group) { + public void addPlayerToGroup(UUID uuid, String group0) { + String group = group0.toLowerCase(Locale.ROOT); + this.uuidToGroups.compute(uuid, (key, existing)-> { if (existing == null) { return ImmutableSet.of(group); @@ -55,7 +57,9 @@ public class PlayerVirtualGroupsMap { }); } - public void removePlayerFromGroup(UUID uuid, String group) { + public void removePlayerFromGroup(UUID uuid, String group0) { + String group = group0.toLowerCase(Locale.ROOT); + this.uuidToGroups.computeIfPresent(uuid, (key, existing) -> { if (!existing.contains(group)) { return existing; @@ -75,7 +79,7 @@ public class PlayerVirtualGroupsMap { }); } - public Set getPlayerGroups(UUID uuid) { + public ImmutableSet getPlayerGroups(UUID uuid) { return this.uuidToGroups.getOrDefault(uuid, ImmutableSet.of()); } diff --git a/hytale/src/main/java/me/lucko/luckperms/hytale/service/VirtualGroups.java b/hytale/src/main/java/me/lucko/luckperms/hytale/service/VirtualGroups.java index 545bd7465..a499a56a6 100644 --- a/hytale/src/main/java/me/lucko/luckperms/hytale/service/VirtualGroups.java +++ b/hytale/src/main/java/me/lucko/luckperms/hytale/service/VirtualGroups.java @@ -29,14 +29,12 @@ import com.google.common.collect.ImmutableSet; import net.luckperms.api.query.OptionKey; import net.luckperms.api.query.QueryOptions; -import java.util.Set; - /** * A {@link QueryOptions} option key for virtual groups. * * @param groups the groups */ -public record VirtualGroups(Set groups) { +public record VirtualGroups(ImmutableSet groups) { public static final VirtualGroups EMPTY = new VirtualGroups(ImmutableSet.of()); public static final OptionKey KEY = OptionKey.of("virtual_groups", VirtualGroups.class); diff --git a/nukkit/src/main/java/me/lucko/luckperms/nukkit/calculator/ChildProcessor.java b/nukkit/src/main/java/me/lucko/luckperms/nukkit/calculator/ChildProcessor.java index 824457e80..4c91b4b87 100644 --- a/nukkit/src/main/java/me/lucko/luckperms/nukkit/calculator/ChildProcessor.java +++ b/nukkit/src/main/java/me/lucko/luckperms/nukkit/calculator/ChildProcessor.java @@ -26,12 +26,13 @@ package me.lucko.luckperms.nukkit.calculator; import me.lucko.luckperms.common.cacheddata.result.TristateResult; -import me.lucko.luckperms.common.calculator.processor.AbstractSourceBasedProcessor; +import me.lucko.luckperms.common.calculator.processor.AbstractPermissionProcessor; import me.lucko.luckperms.common.calculator.processor.PermissionProcessor; import me.lucko.luckperms.nukkit.LPNukkitPlugin; +import me.lucko.luckperms.nukkit.inject.server.LuckPermsPermissionMap; +import net.luckperms.api.node.Node; import net.luckperms.api.util.Tristate; -import java.util.Collections; import java.util.HashMap; import java.util.Map; import java.util.concurrent.atomic.AtomicBoolean; @@ -39,15 +40,23 @@ import java.util.concurrent.atomic.AtomicBoolean; /** * Permission Processor for Nukkits "child" permission system. */ -public class ChildProcessor extends AbstractSourceBasedProcessor implements PermissionProcessor { +public class ChildProcessor extends AbstractPermissionProcessor implements PermissionProcessor { private static final TristateResult.Factory RESULT_FACTORY = new TristateResult.Factory(ChildProcessor.class); private final LPNukkitPlugin plugin; - private final AtomicBoolean needsRefresh = new AtomicBoolean(false); - private Map childPermissions = Collections.emptyMap(); + private final Map sourceMap; - public ChildProcessor(LPNukkitPlugin plugin) { + private final AtomicBoolean needsRefresh = new AtomicBoolean(false); + private Map childPermissions; + + public ChildProcessor(LPNukkitPlugin plugin, Map sourceMap) { this.plugin = plugin; + this.sourceMap = sourceMap; + refresh(); + } + + private void refresh() { + this.childPermissions = processChildPermissions(this.sourceMap, this.plugin.getPermissionMap()); } @Override @@ -59,20 +68,18 @@ public class ChildProcessor extends AbstractSourceBasedProcessor implements Perm } @Override - public void refresh() { + public void invalidate() { + this.needsRefresh.set(true); + } + + private static Map processChildPermissions(Map sourceMap, LuckPermsPermissionMap permissionMap) { Map childPermissions = new HashMap<>(); - this.sourceMap.forEach((key, node) -> { - Map children = this.plugin.getPermissionMap().getChildPermissions(key, node.getValue()); + sourceMap.forEach((key, node) -> { + Map children = permissionMap.getChildPermissions(key, node.getValue()); children.forEach((childKey, childValue) -> { childPermissions.put(childKey, RESULT_FACTORY.resultWithOverride(node, Tristate.of(childValue))); }); }); - this.childPermissions = childPermissions; - this.needsRefresh.set(false); - } - - @Override - public void invalidate() { - this.needsRefresh.set(true); + return childPermissions; } } diff --git a/nukkit/src/main/java/me/lucko/luckperms/nukkit/calculator/NukkitCalculatorFactory.java b/nukkit/src/main/java/me/lucko/luckperms/nukkit/calculator/NukkitCalculatorFactory.java index a2549a0d6..5bd15933d 100644 --- a/nukkit/src/main/java/me/lucko/luckperms/nukkit/calculator/NukkitCalculatorFactory.java +++ b/nukkit/src/main/java/me/lucko/luckperms/nukkit/calculator/NukkitCalculatorFactory.java @@ -28,6 +28,7 @@ package me.lucko.luckperms.nukkit.calculator; import me.lucko.luckperms.common.cacheddata.CacheMetadata; import me.lucko.luckperms.common.calculator.CalculatorFactory; import me.lucko.luckperms.common.calculator.PermissionCalculator; +import me.lucko.luckperms.common.calculator.PermissionCalculatorMonitored; import me.lucko.luckperms.common.calculator.processor.DirectProcessor; import me.lucko.luckperms.common.calculator.processor.PermissionProcessor; import me.lucko.luckperms.common.calculator.processor.RegexProcessor; @@ -37,10 +38,12 @@ import me.lucko.luckperms.common.config.ConfigKeys; import me.lucko.luckperms.common.model.HolderType; import me.lucko.luckperms.nukkit.LPNukkitPlugin; import me.lucko.luckperms.nukkit.context.NukkitContextManager; +import net.luckperms.api.node.Node; import net.luckperms.api.query.QueryOptions; import java.util.ArrayList; import java.util.List; +import java.util.Map; public class NukkitCalculatorFactory implements CalculatorFactory { private final LPNukkitPlugin plugin; @@ -50,25 +53,25 @@ public class NukkitCalculatorFactory implements CalculatorFactory { } @Override - public PermissionCalculator build(QueryOptions queryOptions, CacheMetadata metadata) { + public PermissionCalculator build(QueryOptions queryOptions, Map sourceMap, CacheMetadata metadata) { List processors = new ArrayList<>(8); - processors.add(new DirectProcessor()); + processors.add(new DirectProcessor(sourceMap)); if (this.plugin.getConfiguration().get(ConfigKeys.APPLY_NUKKIT_CHILD_PERMISSIONS)) { - processors.add(new ChildProcessor(this.plugin)); + processors.add(new ChildProcessor(this.plugin, sourceMap)); } if (this.plugin.getConfiguration().get(ConfigKeys.APPLYING_REGEX)) { - processors.add(new RegexProcessor()); + processors.add(new RegexProcessor(sourceMap)); } if (this.plugin.getConfiguration().get(ConfigKeys.APPLYING_WILDCARDS)) { - processors.add(new WildcardProcessor()); + processors.add(new WildcardProcessor(sourceMap)); } if (this.plugin.getConfiguration().get(ConfigKeys.APPLYING_WILDCARDS_SPONGE)) { - processors.add(new SpongeWildcardProcessor()); + processors.add(new SpongeWildcardProcessor(sourceMap)); } boolean op = queryOptions.option(NukkitContextManager.OP_OPTION).orElse(false); @@ -82,6 +85,6 @@ public class NukkitCalculatorFactory implements CalculatorFactory { processors.add(OpProcessor.INSTANCE); } - return new PermissionCalculator(this.plugin, metadata, processors); + return new PermissionCalculatorMonitored(this.plugin, metadata, processors); } } diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/calculator/SpongeCalculatorFactory.java b/sponge/src/main/java/me/lucko/luckperms/sponge/calculator/SpongeCalculatorFactory.java index ac7044c9b..68284ec6e 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/calculator/SpongeCalculatorFactory.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/calculator/SpongeCalculatorFactory.java @@ -28,6 +28,7 @@ package me.lucko.luckperms.sponge.calculator; import me.lucko.luckperms.common.cacheddata.CacheMetadata; import me.lucko.luckperms.common.calculator.CalculatorFactory; import me.lucko.luckperms.common.calculator.PermissionCalculator; +import me.lucko.luckperms.common.calculator.PermissionCalculatorMonitored; import me.lucko.luckperms.common.calculator.processor.DirectProcessor; import me.lucko.luckperms.common.calculator.processor.PermissionProcessor; import me.lucko.luckperms.common.calculator.processor.RegexProcessor; @@ -36,10 +37,12 @@ import me.lucko.luckperms.common.calculator.processor.WildcardProcessor; import me.lucko.luckperms.common.config.ConfigKeys; import me.lucko.luckperms.common.model.HolderType; import me.lucko.luckperms.sponge.LPSpongePlugin; +import net.luckperms.api.node.Node; import net.luckperms.api.query.QueryOptions; import java.util.ArrayList; import java.util.List; +import java.util.Map; public class SpongeCalculatorFactory implements CalculatorFactory { private final LPSpongePlugin plugin; @@ -49,21 +52,21 @@ public class SpongeCalculatorFactory implements CalculatorFactory { } @Override - public PermissionCalculator build(QueryOptions queryOptions, CacheMetadata metadata) { + public PermissionCalculator build(QueryOptions queryOptions, Map sourceMap, CacheMetadata metadata) { List processors = new ArrayList<>(6); - processors.add(new DirectProcessor()); + processors.add(new DirectProcessor(sourceMap)); if (this.plugin.getConfiguration().get(ConfigKeys.APPLYING_REGEX)) { - processors.add(new RegexProcessor()); + processors.add(new RegexProcessor(sourceMap)); } if (this.plugin.getConfiguration().get(ConfigKeys.APPLYING_WILDCARDS)) { - processors.add(new WildcardProcessor()); + processors.add(new WildcardProcessor(sourceMap)); } if (this.plugin.getConfiguration().get(ConfigKeys.APPLYING_WILDCARDS_SPONGE)) { - processors.add(new SpongeWildcardProcessor()); + processors.add(new SpongeWildcardProcessor(sourceMap)); } if (this.plugin.getConfiguration().get(ConfigKeys.APPLY_SPONGE_DEFAULT_SUBJECTS)) { @@ -76,6 +79,6 @@ public class SpongeCalculatorFactory implements CalculatorFactory { processors.add(new RootDefaultsProcessor(this.plugin.getService(), queryOptions, overrideWildcards)); } - return new PermissionCalculator(this.plugin, metadata, processors); + return new PermissionCalculatorMonitored(this.plugin, metadata, processors); } } diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/service/model/calculated/CalculatedSubjectCachedDataManager.java b/sponge/src/main/java/me/lucko/luckperms/sponge/service/model/calculated/CalculatedSubjectCachedDataManager.java index 8cb13ccc4..9e9e3c287 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/service/model/calculated/CalculatedSubjectCachedDataManager.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/service/model/calculated/CalculatedSubjectCachedDataManager.java @@ -33,6 +33,7 @@ import me.lucko.luckperms.common.cacheddata.metastack.StandardStackElements; import me.lucko.luckperms.common.cacheddata.type.MetaAccumulator; import me.lucko.luckperms.common.calculator.CalculatorFactory; import me.lucko.luckperms.common.calculator.PermissionCalculator; +import me.lucko.luckperms.common.calculator.PermissionCalculatorMonitored; import me.lucko.luckperms.common.calculator.processor.DirectProcessor; import me.lucko.luckperms.common.calculator.processor.PermissionProcessor; import me.lucko.luckperms.common.calculator.processor.SpongeWildcardProcessor; @@ -100,17 +101,17 @@ public class CalculatedSubjectCachedDataManager extends AbstractCachedDataManage } @Override - public PermissionCalculator build(QueryOptions queryOptions, CacheMetadata metadata) { + public PermissionCalculator build(QueryOptions queryOptions, Map sourceMap, CacheMetadata metadata) { List processors = new ArrayList<>(5); - processors.add(new DirectProcessor()); - processors.add(new SpongeWildcardProcessor()); - processors.add(new WildcardProcessor()); + processors.add(new DirectProcessor(sourceMap)); + processors.add(new SpongeWildcardProcessor(sourceMap)); + processors.add(new WildcardProcessor(sourceMap)); if (!this.subject.getParentCollection().isDefaultsCollection()) { processors.add(new FixedTypeDefaultsProcessor(this.subject.getService(), queryOptions, this.subject.getDefaults(), true)); processors.add(new RootDefaultsProcessor(this.subject.getService(), queryOptions, true)); } - return new PermissionCalculator(getPlugin(), metadata, processors); + return new PermissionCalculatorMonitored(getPlugin(), metadata, processors); } } diff --git a/standalone/src/main/java/me/lucko/luckperms/standalone/StandaloneCalculatorFactory.java b/standalone/src/main/java/me/lucko/luckperms/standalone/StandaloneCalculatorFactory.java index 1819b0326..c4d500c7f 100644 --- a/standalone/src/main/java/me/lucko/luckperms/standalone/StandaloneCalculatorFactory.java +++ b/standalone/src/main/java/me/lucko/luckperms/standalone/StandaloneCalculatorFactory.java @@ -28,16 +28,19 @@ package me.lucko.luckperms.standalone; import me.lucko.luckperms.common.cacheddata.CacheMetadata; import me.lucko.luckperms.common.calculator.CalculatorFactory; import me.lucko.luckperms.common.calculator.PermissionCalculator; +import me.lucko.luckperms.common.calculator.PermissionCalculatorMonitored; import me.lucko.luckperms.common.calculator.processor.DirectProcessor; import me.lucko.luckperms.common.calculator.processor.PermissionProcessor; import me.lucko.luckperms.common.calculator.processor.RegexProcessor; import me.lucko.luckperms.common.calculator.processor.SpongeWildcardProcessor; import me.lucko.luckperms.common.calculator.processor.WildcardProcessor; import me.lucko.luckperms.common.config.ConfigKeys; +import net.luckperms.api.node.Node; import net.luckperms.api.query.QueryOptions; import java.util.ArrayList; import java.util.List; +import java.util.Map; public class StandaloneCalculatorFactory implements CalculatorFactory { private final LPStandalonePlugin plugin; @@ -47,23 +50,23 @@ public class StandaloneCalculatorFactory implements CalculatorFactory { } @Override - public PermissionCalculator build(QueryOptions queryOptions, CacheMetadata metadata) { + public PermissionCalculator build(QueryOptions queryOptions, Map sourceMap, CacheMetadata metadata) { List processors = new ArrayList<>(8); - processors.add(new DirectProcessor()); + processors.add(new DirectProcessor(sourceMap)); if (this.plugin.getConfiguration().get(ConfigKeys.APPLYING_REGEX)) { - processors.add(new RegexProcessor()); + processors.add(new RegexProcessor(sourceMap)); } if (this.plugin.getConfiguration().get(ConfigKeys.APPLYING_WILDCARDS)) { - processors.add(new WildcardProcessor()); + processors.add(new WildcardProcessor(sourceMap)); } if (this.plugin.getConfiguration().get(ConfigKeys.APPLYING_WILDCARDS_SPONGE)) { - processors.add(new SpongeWildcardProcessor()); + processors.add(new SpongeWildcardProcessor(sourceMap)); } - return new PermissionCalculator(this.plugin, metadata, processors); + return new PermissionCalculatorMonitored(this.plugin, metadata, processors); } } diff --git a/velocity/src/main/java/me/lucko/luckperms/velocity/calculator/VelocityCalculatorFactory.java b/velocity/src/main/java/me/lucko/luckperms/velocity/calculator/VelocityCalculatorFactory.java index 92f8383cc..8d9e1f13f 100644 --- a/velocity/src/main/java/me/lucko/luckperms/velocity/calculator/VelocityCalculatorFactory.java +++ b/velocity/src/main/java/me/lucko/luckperms/velocity/calculator/VelocityCalculatorFactory.java @@ -28,6 +28,7 @@ package me.lucko.luckperms.velocity.calculator; import me.lucko.luckperms.common.cacheddata.CacheMetadata; import me.lucko.luckperms.common.calculator.CalculatorFactory; import me.lucko.luckperms.common.calculator.PermissionCalculator; +import me.lucko.luckperms.common.calculator.PermissionCalculatorMonitored; import me.lucko.luckperms.common.calculator.processor.DirectProcessor; import me.lucko.luckperms.common.calculator.processor.PermissionProcessor; import me.lucko.luckperms.common.calculator.processor.RegexProcessor; @@ -35,10 +36,12 @@ import me.lucko.luckperms.common.calculator.processor.SpongeWildcardProcessor; import me.lucko.luckperms.common.calculator.processor.WildcardProcessor; import me.lucko.luckperms.common.config.ConfigKeys; import me.lucko.luckperms.velocity.LPVelocityPlugin; +import net.luckperms.api.node.Node; import net.luckperms.api.query.QueryOptions; import java.util.ArrayList; import java.util.List; +import java.util.Map; public class VelocityCalculatorFactory implements CalculatorFactory { private final LPVelocityPlugin plugin; @@ -48,23 +51,23 @@ public class VelocityCalculatorFactory implements CalculatorFactory { } @Override - public PermissionCalculator build(QueryOptions queryOptions, CacheMetadata metadata) { + public PermissionCalculator build(QueryOptions queryOptions, Map sourceMap, CacheMetadata metadata) { List processors = new ArrayList<>(4); - processors.add(new DirectProcessor()); + processors.add(new DirectProcessor(sourceMap)); if (this.plugin.getConfiguration().get(ConfigKeys.APPLYING_REGEX)) { - processors.add(new RegexProcessor()); + processors.add(new RegexProcessor(sourceMap)); } if (this.plugin.getConfiguration().get(ConfigKeys.APPLYING_WILDCARDS)) { - processors.add(new WildcardProcessor()); + processors.add(new WildcardProcessor(sourceMap)); } if (this.plugin.getConfiguration().get(ConfigKeys.APPLYING_WILDCARDS_SPONGE)) { - processors.add(new SpongeWildcardProcessor()); + processors.add(new SpongeWildcardProcessor(sourceMap)); } - return new PermissionCalculator(this.plugin, metadata, processors); + return new PermissionCalculatorMonitored(this.plugin, metadata, processors); } }