Refactor PermissionProcessors

This commit is contained in:
Luck committed 2026-02-05 18:55:26 +00:00
1 parent f944fc0770
commit 8c22dd7159
32 files changed
+581 -319

No files matched your search

@@ -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<String, Node> sourceMap, CacheMetadata metadata) {
List<PermissionProcessor> 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);
}
}
@@ -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<String, TristateResult> childPermissions = Collections.emptyMap();
private final Map<String, Node> sourceMap;
public ChildProcessor(LPBukkitPlugin plugin) {
private final AtomicBoolean needsRefresh = new AtomicBoolean(false);
private Map<String, TristateResult> childPermissions;
public ChildProcessor(LPBukkitPlugin plugin, Map<String, Node> 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<String, TristateResult> processChildPermissions(Map<String, Node> sourceMap, LuckPermsPermissionMap permissionMap) {
Map<String, TristateResult> childPermissions = new HashMap<>();
this.sourceMap.forEach((key, node) -> {
Map<String, Boolean> children = this.plugin.getPermissionMap().getChildPermissions(key, node.getValue());
sourceMap.forEach((key, node) -> {
Map<String, Boolean> 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;
}
}
@@ -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<String, Node> sourceMap, CacheMetadata metadata) {
List<PermissionProcessor> 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);
}
}
@@ -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<String, Node> sourceMap, CacheMetadata metadata) {
List<PermissionProcessor> 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);
}
}
@@ -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
@@ -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<String, Node> sourceMap, CacheMetadata metadata);
}
@@ -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<PermissionProcessor> 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();
}
@@ -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<String, TristateResult> {
public class PermissionCalculatorBase implements PermissionCalculator {
/** The processors which back this calculator */
private final PermissionProcessor[] processors;
/** Loading cache for permission checks */
private final LoadingMap<String, TristateResult> lookupCache = LoadingMap.of(this);
private final LoadingMap<String, TristateResult> lookupCache = LoadingMap.of(this::resolve);
public PermissionLookupCache(Collection<PermissionProcessor> processors) {
public PermissionCalculatorBase(Collection<PermissionProcessor> processors) {
this.processors = processors.toArray(new PermissionProcessor[0]);
}
/**
* Performs a permission check against this calculator.
*
* <p>The result is calculated using the calculators backing 'processors'.</p>
*
* @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<String, TristateResult> {
}
/**
* Defines the source permissions map which should be used when calculating
* a result.
*
* @param sourceMap the source map
*/
public synchronized void setSourcePermissions(Map<String, Node> sourceMap) {
for (PermissionProcessor processor : this.processors) {
processor.setSource(sourceMap);
processor.refresh();
}
}
@Override
public void invalidateCache() {
for (PermissionProcessor processor : this.processors) {
processor.invalidate();
@@ -0,0 +1,67 @@
/*
* This file is part of LuckPerms, licensed under the MIT License.
*
* Copyright (c) lucko (Luck) <[email protected]>
* 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<PermissionProcessor> 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);
}
}
@@ -1,41 +0,0 @@
/*
* This file is part of LuckPerms, licensed under the MIT License.
*
* Copyright (c) lucko (Luck) <[email protected]>
* 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<String, Node> sourceMap = Collections.emptyMap();
@Override
public void setSource(Map<String, Node> sourceMap) {
this.sourceMap = sourceMap;
}
}
@@ -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<String, Node> sourceMap;
public DirectProcessor(Map<String, Node> sourceMap) {
this.sourceMap = sourceMap;
}
@Override
public TristateResult hasPermission(String permission) {
return RESULT_FACTORY.result(this.sourceMap.get(permission));
@@ -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<String, Node> sourceMap) {
}
/**
* Called after a change has been made to the source map
*/
default void refresh() {
}
/**
* Called after the parent calculator has been invalidated
*/
@@ -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<Map.Entry<Pattern, TristateResult>> regexPermissions = Collections.emptyList();
private final List<RegexEntry> regexPermissions;
public RegexProcessor(Map<String, Node> sourceMap) {
this.regexPermissions = process(sourceMap);
}
@Override
public TristateResult hasPermission(String permission) {
for (Map.Entry<Pattern, TristateResult> 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<Map.Entry<Pattern, TristateResult>> builder = ImmutableList.builder();
for (Map.Entry<String, Node> e : this.sourceMap.entrySet()) {
private static List<RegexEntry> process(Map<String, Node> sourceMap) {
ImmutableList.Builder<RegexEntry> builder = ImmutableList.builder();
for (Map.Entry<String, Node> 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();
}
}
@@ -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<String, Node> sourceMap;
public SpongeWildcardProcessor(Map<String, Node> sourceMap) {
this.sourceMap = sourceMap;
}
@Override
public TristateResult hasPermission(String permission) {
String node = permission;
@@ -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<String, TristateResult> wildcardPermissions;
private final TristateResult rootWildcardState;
public static boolean isWildcardPermission(String permission) {
return isRootWildcard(permission) || permission.endsWith(WILDCARD_SUFFIX) && permission.length() > 2;
public WildcardProcessor(Map<String, Node> sourceMap) {
this.wildcardPermissions = processWildcardPermissions(sourceMap);
this.rootWildcardState = rootWildcardState(sourceMap);
}
private Map<String, TristateResult> 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<String, TristateResult> processWildcardPermissions(Map<String, Node> sourceMap) {
ImmutableMap.Builder<String, TristateResult> builder = ImmutableMap.builder();
for (Map.Entry<String, Node> e : this.sourceMap.entrySet()) {
for (Map.Entry<String, Node> 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<String, Node> 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);
}
}
@@ -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<String, Node> EXAMPLE_PERMISSIONS = ImmutableMap.<String, Boolean>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());
@@ -0,0 +1,165 @@
/*
* This file is part of LuckPerms, licensed under the MIT License.
*
* Copyright (c) lucko (Luck) <[email protected]>
* 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<String, Node> createNodeMap(Map<String, Boolean> nodes) {
return nodes.entrySet().stream().collect(Collectors.toMap(
Map.Entry::getKey,
e -> NodeBuilders.determineMostApplicable(e.getKey()).value(e.getValue()).build()
));
}
}
@@ -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
@@ -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<String, Node> sourceMap, CacheMetadata metadata) {
List<PermissionProcessor> 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<String> virtualGroups = queryOptions.option(VirtualGroups.KEY).orElse(VirtualGroups.EMPTY).groups();
if (!virtualGroups.isEmpty()) {
processors.add(new HytaleVirtualGroupProcessor(this.virtualGroupsLookupProvider.getLookup(virtualGroups)));
}
ImmutableSet<String> 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);
}
}
@@ -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<String> virtualGroups, Map<String, Node> sourceMap) {
VirtualGroupsMap virtualGroupsMap = plugin.getVirtualGroupsMap();
Set<String> 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());
}
}
@@ -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<String, Map<String, Node>> export() {
public static ImmutableMap<String, ImmutableMap<String, Node>> export() {
Map<String, Set<String>> 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<String, Node> transformSet(Set<String> permissions) {
private static ImmutableMap<String, Node> transformSet(Set<String> permissions) {
ImmutableMap.Builder<String, Node> builder = ImmutableMap.builder();
for (String permission : permissions) {
@@ -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<Set<String>, PermissionLookupCache> caches;
private Map<String, Map<String, Node>> virtualGroupToNodesMap;
public class VirtualGroupsMap {
private final Map<ImmutableSet<String>, PermissionCalculator> caches;
private ImmutableMap<String, ImmutableMap<String, Node>> 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<String> virtualGroups) {
public ImmutableSet<String> getAllVirtualGroups() {
return this.virtualGroupToNodesMap.keySet();
}
public PermissionCalculator getCalculator(ImmutableSet<String> virtualGroups) {
return this.caches.get(virtualGroups);
}
private PermissionLookupCache buildCache(Set<String> virtualGroups) {
private PermissionCalculator buildCalculator(Set<String> virtualGroups) {
Map<String, Node> sourceMap = new ConcurrentHashMap<>();
for (String virtualGroup : virtualGroups) {
sourceMap.putAll(this.virtualGroupToNodesMap.getOrDefault(virtualGroup, ImmutableMap.of()));
}
List<PermissionProcessor> 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<PermissionProcessor> processors = new ArrayList<>(2);
processors.add(new DirectProcessor(sourceMap));
processors.add(new WildcardProcessor(sourceMap));
return new PermissionCalculatorBase(processors);
}
}
@@ -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<PlayerRef, PlayerRef> {
@@ -59,7 +59,7 @@ public class HytaleContextManager extends SimpleContextManager<PlayerRef, Player
builder.option(INTEGRATED_SERVER_OWNER, true);
}
Set<String> groups = this.playerVirtualGroupsMap.getPlayerGroups(subject.getUuid());
ImmutableSet<String> groups = this.playerVirtualGroupsMap.getPlayerGroups(subject.getUuid());
builder.option(VirtualGroups.KEY, new VirtualGroups(groups));
}
}
@@ -46,7 +46,7 @@ public class HytalePlatformListener {
public void onBoot(BootEvent e) {
insertCommandPermissionsIntoRegistry();
this.plugin.getVirtualGroupsLookupProvider().refresh();
this.plugin.getVirtualGroupsMap().refresh();
}
public void insertCommandPermissionsIntoRegistry() {
@@ -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<UUID, ImmutableSet<String>> 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<String> getPlayerGroups(UUID uuid) {
public ImmutableSet<String> getPlayerGroups(UUID uuid) {
return this.uuidToGroups.getOrDefault(uuid, ImmutableSet.of());
}
@@ -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<String> groups) {
public record VirtualGroups(ImmutableSet<String> groups) {
public static final VirtualGroups EMPTY = new VirtualGroups(ImmutableSet.of());
public static final OptionKey<VirtualGroups> KEY = OptionKey.of("virtual_groups", VirtualGroups.class);
@@ -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<String, TristateResult> childPermissions = Collections.emptyMap();
private final Map<String, Node> sourceMap;
public ChildProcessor(LPNukkitPlugin plugin) {
private final AtomicBoolean needsRefresh = new AtomicBoolean(false);
private Map<String, TristateResult> childPermissions;
public ChildProcessor(LPNukkitPlugin plugin, Map<String, Node> 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<String, TristateResult> processChildPermissions(Map<String, Node> sourceMap, LuckPermsPermissionMap permissionMap) {
Map<String, TristateResult> childPermissions = new HashMap<>();
this.sourceMap.forEach((key, node) -> {
Map<String, Boolean> children = this.plugin.getPermissionMap().getChildPermissions(key, node.getValue());
sourceMap.forEach((key, node) -> {
Map<String, Boolean> 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;
}
}
@@ -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<String, Node> sourceMap, CacheMetadata metadata) {
List<PermissionProcessor> 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);
}
}
@@ -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<String, Node> sourceMap, CacheMetadata metadata) {
List<PermissionProcessor> 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);
}
}
@@ -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<String, Node> sourceMap, CacheMetadata metadata) {
List<PermissionProcessor> 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);
}
}
@@ -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<String, Node> sourceMap, CacheMetadata metadata) {
List<PermissionProcessor> 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);
}
}
@@ -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<String, Node> sourceMap, CacheMetadata metadata) {
List<PermissionProcessor> 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);
}
}