Upstream/LuckPerms
1
0
Fork 0
mirror of https://github.com/LuckPerms/LuckPerms.git synced 2025-02-05 23:21:22 +01:00
Code Issues Projects Releases Wiki Activity

Replace guava caches with caffeine

Browse Source
This commit is contained in:
Luck 2017-04-03 00:53:04 +01:00
parent e7e2e3f7e0
commit 2749563f5d
No known key found for this signature in database
GPG Key ID: EFA9B3EC5FD90F8B
23 changed files with 228 additions and 394 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
bukkit/src/main/java/me/lucko/luckperms/bukkit/LPBukkitPlugin.java
View File

@ -50,6 +50,7 @@ import me.lucko.luckperms.common.contexts.ContextManager;
import me.lucko.luckperms.common.contexts.ServerCalculator;
import me.lucko.luckperms.common.core.UuidCache;
import me.lucko.luckperms.common.core.model.User;
import me.lucko.luckperms.common.dependencies.Dependency;
import me.lucko.luckperms.common.dependencies.DependencyManager;
import me.lucko.luckperms.common.locale.LocaleManager;
import me.lucko.luckperms.common.locale.NoopLocaleManager;
@ -89,6 +90,7 @@ import org.bukkit.plugin.java.JavaPlugin;
import java.io.File;
import java.io.InputStream;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
@ -130,12 +132,18 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
private PermissionVault permissionVault;
@Override
public void onEnable() {
public void onLoad() {
// setup minimal functionality in order to load initial dependencies
scheduler = new LPBukkitScheduler(this);
localeManager = new NoopLocaleManager();
senderFactory = new BukkitSenderFactory(this);
log = new LoggerImpl(getConsoleSender());
DependencyManager.loadDependencies(this, Collections.singletonList(Dependency.CAFFEINE));
}
@Override
public void onEnable() {
LuckPermsPlugin.sendStartupBanner(getConsoleSender(), this);
ignoringLogs = ConcurrentHashMap.newKeySet();

11
bungee/src/main/java/me/lucko/luckperms/bungee/LPBungeePlugin.java
View File

@ -41,6 +41,7 @@ import me.lucko.luckperms.common.contexts.ContextManager;
import me.lucko.luckperms.common.contexts.ServerCalculator;
import me.lucko.luckperms.common.core.UuidCache;
import me.lucko.luckperms.common.core.model.User;
import me.lucko.luckperms.common.dependencies.Dependency;
import me.lucko.luckperms.common.dependencies.DependencyManager;
import me.lucko.luckperms.common.locale.LocaleManager;
import me.lucko.luckperms.common.locale.NoopLocaleManager;
@ -73,6 +74,7 @@ import net.md_5.bungee.api.plugin.Plugin;
import java.io.File;
import java.io.InputStream;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
@ -105,11 +107,18 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
private PermissionVault permissionVault;
@Override
public void onEnable() {
public void onLoad() {
// setup minimal functionality in order to load initial dependencies
scheduler = new LPBungeeScheduler(this);
localeManager = new NoopLocaleManager();
senderFactory = new BungeeSenderFactory(this);
log = new LoggerImpl(getConsoleSender());
DependencyManager.loadDependencies(this, Collections.singletonList(Dependency.CAFFEINE));
}
@Override
public void onEnable() {
LuckPermsPlugin.sendStartupBanner(getConsoleSender(), this);
verboseHandler = new VerboseHandler(scheduler.getAsyncExecutor(), getVersion());
permissionVault = new PermissionVault(scheduler.getAsyncExecutor());

7
common/pom.xml
View File

@ -118,6 +118,13 @@
<version>19.0</version>
<scope>provided</scope>
</dependency>
<!-- caffeine -->
<dependency>
<groupId>com.github.ben-manes.caffeine</groupId>
<artifactId>caffeine</artifactId>
<version>2.4.0</version>
<scope>provided</scope>
</dependency>
<!-- Lombok -->
<dependency>
<groupId>org.projectlombok</groupId>

29
common/src/main/java/me/lucko/luckperms/common/caching/UserCache.java
View File

@ -25,12 +25,10 @@ package me.lucko.luckperms.common.caching;
import lombok.NonNull;
import lombok.RequiredArgsConstructor;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.github.benmanes.caffeine.cache.CacheLoader;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.LoadingCache;
import com.google.common.collect.ImmutableSet;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import me.lucko.luckperms.api.Contexts;
import me.lucko.luckperms.api.caching.MetaData;
@ -49,6 +47,7 @@ import java.util.concurrent.TimeUnit;
@RequiredArgsConstructor
public class UserCache implements UserData {
/**
* The user whom this data instance is representing
*/
@ -59,7 +58,7 @@ public class UserCache implements UserData {
*/
private final CalculatorFactory calculatorFactory;
private final LoadingCache<Contexts, PermissionCache> permission = CacheBuilder.newBuilder()
private final LoadingCache<Contexts, PermissionCache> permission = Caffeine.newBuilder()
.expireAfterAccess(10, TimeUnit.MINUTES)
.build(new CacheLoader<Contexts, PermissionCache>() {
@Override
@ -68,13 +67,13 @@ public class UserCache implements UserData {
}
@Override
public ListenableFuture<PermissionCache> reload(Contexts contexts, PermissionCache oldData) {
public PermissionCache reload(Contexts contexts, PermissionCache oldData) {
oldData.comparePermissions(user.exportNodes(ExtractedContexts.generate(contexts), true));
return Futures.immediateFuture(oldData);
return oldData;
}
});
private final LoadingCache<Contexts, MetaCache> meta = CacheBuilder.newBuilder()
private final LoadingCache<Contexts, MetaCache> meta = Caffeine.newBuilder()
.expireAfterAccess(10, TimeUnit.MINUTES)
.build(new CacheLoader<Contexts, MetaCache>() {
@Override
@ -83,20 +82,20 @@ public class UserCache implements UserData {
}
@Override
public ListenableFuture<MetaCache> reload(Contexts contexts, MetaCache oldData) {
public MetaCache reload(Contexts contexts, MetaCache oldData) {
oldData.loadMeta(user.accumulateMeta(null, null, ExtractedContexts.generate(contexts)));
return Futures.immediateFuture(oldData);
return oldData;
}
});
@Override
public PermissionData getPermissionData(@NonNull Contexts contexts) {
return permission.getUnchecked(contexts);
return permission.get(contexts);
}
@Override
public MetaData getMetaData(@NonNull Contexts contexts) {
return meta.getUnchecked(contexts);
return meta.get(contexts);
}
@Override
@ -142,8 +141,8 @@ public class UserCache implements UserData {
@Override
public void preCalculate(@NonNull Contexts contexts) {
permission.getUnchecked(contexts);
meta.getUnchecked(contexts);
permission.get(contexts);
meta.get(contexts);
}
public void invalidateCache() {

41
common/src/main/java/me/lucko/luckperms/common/caching/holder/ExportNodesHolder.java
View File

@ -1,41 +0,0 @@
/*
* Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
*
* 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.caching.holder;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.ToString;
import me.lucko.luckperms.api.Contexts;
@Getter
@ToString
@EqualsAndHashCode
@AllArgsConstructor(staticName = "of")
public class ExportNodesHolder {
private final Contexts contexts;
private final Boolean lowerCase;
}

43
common/src/main/java/me/lucko/luckperms/common/caching/holder/GetAllNodesRequest.java
View File

@ -1,43 +0,0 @@
/*
* Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
*
* 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.caching.holder;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.ToString;
import com.google.common.collect.ImmutableSet;
import me.lucko.luckperms.common.utils.ExtractedContexts;
@Getter
@ToString
@EqualsAndHashCode
@AllArgsConstructor(staticName = "of")
public class GetAllNodesRequest {
private final ImmutableSet<String> excludedGroups;
private final ExtractedContexts contexts;
}

15
common/src/main/java/me/lucko/luckperms/common/calculators/PermissionCalculator.java
View File

@ -24,9 +24,8 @@ package me.lucko.luckperms.common.calculators;
import lombok.RequiredArgsConstructor;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.LoadingCache;
import me.lucko.luckperms.api.Tristate;
import me.lucko.luckperms.common.plugin.LuckPermsPlugin;
@ -43,13 +42,7 @@ public class PermissionCalculator {
private final String objectName;
private final List<PermissionProcessor> processors;
private final LoadingCache<String, Tristate> cache = CacheBuilder.newBuilder()
.build(new CacheLoader<String, Tristate>() {
@Override
public Tristate load(String s) {
return lookupPermissionValue(s);
}
});
private final LoadingCache<String, Tristate> cache = Caffeine.newBuilder().build(this::lookupPermissionValue);
public void invalidateCache() {
cache.invalidateAll();
@ -57,7 +50,7 @@ public class PermissionCalculator {
public Tristate getPermissionValue(String permission) {
permission = permission.toLowerCase();
Tristate t = cache.getUnchecked(permission);
Tristate t = cache.get(permission);
plugin.getVerboseHandler().offer(objectName, permission, t);
plugin.getPermissionVault().offer(permission);
return t;

20
common/src/main/java/me/lucko/luckperms/common/config/AbstractConfiguration.java
View File

@ -24,9 +24,8 @@ package me.lucko.luckperms.common.config;
import lombok.Getter;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.LoadingCache;
import me.lucko.luckperms.common.api.delegates.LPConfigurationDelegate;
import me.lucko.luckperms.common.config.keys.EnduringKey;
@ -35,27 +34,22 @@ import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
@SuppressWarnings("unchecked")
public abstract class AbstractConfiguration implements LuckPermsConfiguration {
private final LoadingCache<ConfigKey<?>, Optional<Object>> cache = CacheBuilder.newBuilder()
.build(new CacheLoader<ConfigKey<?>, Optional<Object>>() {
@Override
public Optional<Object> load(ConfigKey<?> key) {
return Optional.ofNullable(key.get(AbstractConfiguration.this));
}
});
private final LoadingCache<ConfigKey<?>, Optional<Object>> cache = Caffeine.newBuilder()
.build(key -> Optional.ofNullable(key.get(AbstractConfiguration.this)));
@Getter
private final LPConfigurationDelegate delegate = new LPConfigurationDelegate(this);
@SuppressWarnings("unchecked")
@Override
public <T> T get(ConfigKey<T> key) {
return (T) cache.getUnchecked(key).orElse(null);
return (T) cache.get(key).orElse(null);
}
@Override
public void loadAll() {
ConfigKeys.getAllKeys().forEach(cache::getUnchecked);
ConfigKeys.getAllKeys().forEach(cache::get);
}
@Override

34
common/src/main/java/me/lucko/luckperms/common/constants/Patterns.java
View File

@ -24,40 +24,20 @@ package me.lucko.luckperms.common.constants;
import lombok.experimental.UtilityClass;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.LoadingCache;
import com.google.common.collect.Maps;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.UncheckedExecutionException;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.regex.Pattern;
@UtilityClass
public class Patterns {
private static final LoadingCache<String, Pattern> CACHE = CacheBuilder.newBuilder()
.build(new CacheLoader<String, Pattern>() {
@Override
public Pattern load(String s) throws Exception {
return Pattern.compile(s);
}
@Override
public ListenableFuture<Pattern> reload(String s, Pattern pattern) {
return Futures.immediateFuture(pattern);
}
});
private static final LoadingCache<Map.Entry<String, String>, String> DELIMITER_CACHE = CacheBuilder.newBuilder()
.build(new CacheLoader<Map.Entry<String, String>, String>() {
@Override
public String load(Map.Entry<String, String> e) {
private static final LoadingCache<String, Pattern> CACHE = Caffeine.newBuilder().build(Pattern::compile);
private static final LoadingCache<Map.Entry<String, String>, String> DELIMITER_CACHE = Caffeine.newBuilder()
.build(e -> {
// note the reversed order
return "(?<!" + Pattern.quote(e.getValue()) + ")" + Pattern.quote(e.getKey());
}
});
public static final Pattern COMMAND_SEPARATOR = Pattern.compile(" (?=([^\\\"]*\\\"[^\\\"]*\\\")*[^\\\"]*$)");
@ -70,14 +50,14 @@ public class Patterns {
public static Pattern compile(String regex) {
try {
return CACHE.get(regex);
} catch (UncheckedExecutionException | ExecutionException e) {
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
public static String buildDelimitedMatcher(String delim, String esc) {
return DELIMITER_CACHE.getUnchecked(Maps.immutableEntry(delim, esc));
return DELIMITER_CACHE.get(Maps.immutableEntry(delim, esc));
}
public static Pattern compileDelimitedMatcher(String delim, String esc) {

16
common/src/main/java/me/lucko/luckperms/common/contexts/ContextManager.java
View File

@ -22,9 +22,8 @@
package me.lucko.luckperms.common.contexts;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.LoadingCache;
import me.lucko.luckperms.api.context.ContextCalculator;
import me.lucko.luckperms.api.context.ContextSet;
@ -38,15 +37,10 @@ public class ContextManager<T> {
private final List<ContextCalculator<T>> calculators = new CopyOnWriteArrayList<>();
private final LoadingCache<T, ContextSet> cache = CacheBuilder.newBuilder()
private final LoadingCache<T, ContextSet> cache = Caffeine.newBuilder()
.weakKeys()
.expireAfterWrite(50L, TimeUnit.MILLISECONDS)
.build(new CacheLoader<T, ContextSet>() {
@Override
public ContextSet load(T t) {
return calculateApplicableContext(t, MutableContextSet.create()).makeImmutable();
}
});
.build(t -> calculateApplicableContext(t, MutableContextSet.create()).makeImmutable());
private MutableContextSet calculateApplicableContext(T subject, MutableContextSet accumulator) {
for (ContextCalculator<T> calculator : calculators) {
@ -56,7 +50,7 @@ public class ContextManager<T> {
}
public ContextSet getApplicableContext(T subject) {
return cache.getUnchecked(subject);
return cache.get(subject);
}
public void registerCalculator(ContextCalculator<T> calculator) {

27
common/src/main/java/me/lucko/luckperms/common/core/NodeFactory.java
View File

@ -24,11 +24,9 @@ package me.lucko.luckperms.common.core;
import lombok.experimental.UtilityClass;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.LoadingCache;
import com.google.common.base.Splitter;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.google.common.util.concurrent.UncheckedExecutionException;
import me.lucko.luckperms.api.MetaUtils;
import me.lucko.luckperms.api.Node;
@ -38,33 +36,22 @@ import me.lucko.luckperms.common.core.model.Group;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutionException;
/**
* Utility class to make Node(Builder) instances from serialised strings or existing Nodes
*/
@UtilityClass
public class NodeFactory {
private static final LoadingCache<String, Node> CACHE = CacheBuilder.newBuilder()
.build(new CacheLoader<String, Node>() {
@Override
public Node load(String s) throws Exception {
return builderFromSerialisedNode(s, true).build();
}
});
private static final LoadingCache<String, Node> CACHE = Caffeine.newBuilder()
.build(s -> builderFromSerialisedNode(s, true).build());
private static final LoadingCache<String, Node> CACHE_NEGATED = CacheBuilder.newBuilder()
.build(new CacheLoader<String, Node>() {
@Override
public Node load(String s) throws Exception {
return builderFromSerialisedNode(s, false).build();
}
});
private static final LoadingCache<String, Node> CACHE_NEGATED = Caffeine.newBuilder()
.build(s -> builderFromSerialisedNode(s, false).build());
public static Node fromSerialisedNode(String s, Boolean b) {
try {
return b ? CACHE.get(s) : CACHE_NEGATED.get(s);
} catch (UncheckedExecutionException | ExecutionException e) {
} catch (Exception e) {
throw new IllegalArgumentException(e);
}
}

13
common/src/main/java/me/lucko/luckperms/common/core/PriorityComparator.java
View File

@ -25,9 +25,8 @@ package me.lucko.luckperms.common.core;
import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.LoadingCache;
import me.lucko.luckperms.api.LocalizedNode;
import me.lucko.luckperms.api.Node;
@ -48,13 +47,7 @@ public class PriorityComparator implements Comparator<LocalizedNode> {
}
private final Collator collator = Collator.getInstance(Locale.ENGLISH);
private final LoadingCache<String, CollationKey> collationKeyCache = CacheBuilder.newBuilder()
.build(new CacheLoader<String, CollationKey>() {
@Override
public CollationKey load(String s) throws Exception {
return collator.getCollationKey(s);
}
});
private final LoadingCache<String, CollationKey> collationKeyCache = Caffeine.newBuilder().build(collator::getCollationKey);
@Override
public int compare(LocalizedNode one, LocalizedNode two) {

20
common/src/main/java/me/lucko/luckperms/common/dependencies/Dependency.java
View File

@ -29,18 +29,18 @@ import lombok.Getter;
@AllArgsConstructor
public enum Dependency {
MYSQL_DRIVER("https://repo1.maven.org/maven2/mysql/mysql-connector-java/5.1.6/mysql-connector-java-5.1.6.jar", "5.1.6", "com.mysql.jdbc.jdbc2.optional.MysqlDataSource"),
POSTGRESQL_DRIVER("https://repo1.maven.org/maven2/org/postgresql/postgresql/9.4.1212/postgresql-9.4.1212.jar", "9.4.1212", "org.postgresql.ds.PGSimpleDataSource"),
H2_DRIVER("https://repo1.maven.org/maven2/com/h2database/h2/1.4.193/h2-1.4.193.jar", "1.4.193", "org.h2.Driver"),
SQLITE_DRIVER("https://repo1.maven.org/maven2/org/xerial/sqlite-jdbc/3.15.1/sqlite-jdbc-3.15.1.jar", "3.15.1", "org.sqlite.JDBC"),
HIKARI("https://repo1.maven.org/maven2/com/zaxxer/HikariCP/2.6.1/HikariCP-2.6.1.jar", "2.6.1", "com.zaxxer.hikari.HikariConfig"),
SLF4J_SIMPLE("https://repo1.maven.org/maven2/org/slf4j/slf4j-simple/1.7.9/slf4j-simple-1.7.9.jar", "1.7.9", "org.slf4j.impl.SimpleLoggerFactory"),
SLF4J_API("https://repo1.maven.org/maven2/org/slf4j/slf4j-api/1.7.9/slf4j-api-1.7.9.jar", "1.7.9", "org.slf4j.helpers.BasicMarkerFactory"),
MONGODB_DRIVER("https://repo1.maven.org/maven2/org/mongodb/mongo-java-driver/3.4.1/mongo-java-driver-3.4.1.jar", "3.4.1", "com.mongodb.Mongo"),
JEDIS("https://github.com/lucko/jedis/releases/download/jedis-2.9.1-shaded/jedis-2.9.1-shaded.jar", "2.9.1-shaded", "redis.clients.jedis.shaded.Jedis");
CAFFEINE("https://repo1.maven.org/maven2/com/github/ben-manes/caffeine/caffeine/2.4.0/caffeine-2.4.0.jar", "2.4.0"),
MYSQL_DRIVER("https://repo1.maven.org/maven2/mysql/mysql-connector-java/5.1.6/mysql-connector-java-5.1.6.jar", "5.1.6"),
POSTGRESQL_DRIVER("https://repo1.maven.org/maven2/org/postgresql/postgresql/9.4.1212/postgresql-9.4.1212.jar", "9.4.1212"),
H2_DRIVER("https://repo1.maven.org/maven2/com/h2database/h2/1.4.193/h2-1.4.193.jar", "1.4.193"),
SQLITE_DRIVER("https://repo1.maven.org/maven2/org/xerial/sqlite-jdbc/3.15.1/sqlite-jdbc-3.15.1.jar", "3.15.1"),
HIKARI("https://repo1.maven.org/maven2/com/zaxxer/HikariCP/2.6.1/HikariCP-2.6.1.jar", "2.6.1"),
SLF4J_SIMPLE("https://repo1.maven.org/maven2/org/slf4j/slf4j-simple/1.7.9/slf4j-simple-1.7.9.jar", "1.7.9"),
SLF4J_API("https://repo1.maven.org/maven2/org/slf4j/slf4j-api/1.7.9/slf4j-api-1.7.9.jar", "1.7.9"),
MONGODB_DRIVER("https://repo1.maven.org/maven2/org/mongodb/mongo-java-driver/3.4.1/mongo-java-driver-3.4.1.jar", "3.4.1"),
JEDIS("https://github.com/lucko/jedis/releases/download/jedis-2.9.1-shaded/jedis-2.9.1-shaded.jar", "2.9.1-shaded");
private final String url;
private final String version;
private final String testClass;
}

34
common/src/main/java/me/lucko/luckperms/common/managers/AbstractManager.java
View File

@ -22,12 +22,10 @@
package me.lucko.luckperms.common.managers;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.github.benmanes.caffeine.cache.CacheLoader;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.LoadingCache;
import com.google.common.collect.ImmutableMap;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import me.lucko.luckperms.common.utils.Identifiable;
@ -41,16 +39,7 @@ import java.util.Map;
*/
public abstract class AbstractManager<I, T extends Identifiable<I>> implements Manager<I, T> {
@SuppressWarnings("unchecked")
private static <I> I lowerCase(I i) {
if (i instanceof String) {
return (I) ((String) i).toLowerCase();
} else {
return i;
}
}
private final LoadingCache<I, T> objects = CacheBuilder.newBuilder()
private final LoadingCache<I, T> objects = Caffeine.newBuilder()
.build(new CacheLoader<I, T>() {
@Override
public T load(I i) {
@ -58,8 +47,8 @@ public abstract class AbstractManager<I, T extends Identifiable<I>> implements M
}
@Override
public ListenableFuture<T> reload(I i, T t) {
return Futures.immediateFuture(t); // Never needs to be refreshed.
public T reload(I i, T t) {
return t; // Never needs to be refreshed.
}
});
@ -70,7 +59,7 @@ public abstract class AbstractManager<I, T extends Identifiable<I>> implements M
@Override
public T getOrMake(I id) {
return objects.getUnchecked(lowerCase(id));
return objects.get(lowerCase(id));
}
@Override
@ -102,4 +91,13 @@ public abstract class AbstractManager<I, T extends Identifiable<I>> implements M
objects.invalidateAll();
}
@SuppressWarnings("unchecked")
private static <I> I lowerCase(I i) {
if (i instanceof String) {
return (I) ((String) i).toLowerCase();
} else {
return i;
}
}
}

1
sponge/src/main/java/me/lucko/luckperms/sponge/LPSpongePlugin.java
View File

@ -169,6 +169,7 @@ public class LPSpongePlugin implements LuckPermsPlugin {
localeManager = new NoopLocaleManager();
senderFactory = new SpongeSenderFactory(this);
log = new LoggerImpl(getConsoleSender());
LuckPermsPlugin.sendStartupBanner(getConsoleSender(), this);
verboseHandler = new VerboseHandler(scheduler.getAsyncExecutor(), getVersion());
permissionVault = new PermissionVault(scheduler.getAsyncExecutor());

34
sponge/src/main/java/me/lucko/luckperms/sponge/managers/SpongeGroupManager.java
View File

@ -22,15 +22,13 @@
package me.lucko.luckperms.sponge.managers;
import lombok.Getter;
import lombok.NonNull;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.github.benmanes.caffeine.cache.CacheLoader;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.LoadingCache;
import com.google.common.collect.ImmutableMap;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.UncheckedExecutionException;
import me.lucko.luckperms.api.Tristate;
import me.lucko.luckperms.api.context.ContextSet;
@ -53,13 +51,14 @@ import co.aikar.timings.Timing;
import java.util.Collection;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
public class SpongeGroupManager implements GroupManager, LPSubjectCollection {
@Getter
private final LPSpongePlugin plugin;
private final LoadingCache<String, SpongeGroup> objects = CacheBuilder.newBuilder()
private final LoadingCache<String, SpongeGroup> objects = Caffeine.newBuilder()
.build(new CacheLoader<String, SpongeGroup>() {
@Override
public SpongeGroup load(String i) {
@ -67,31 +66,28 @@ public class SpongeGroupManager implements GroupManager, LPSubjectCollection {
}
@Override
public ListenableFuture<SpongeGroup> reload(String i, SpongeGroup t) {
return Futures.immediateFuture(t); // Never needs to be refreshed.
public SpongeGroup reload(String i, SpongeGroup t) {
return t; // Never needs to be refreshed.
}
});
private final LoadingCache<String, LPSubject> subjectLoadingCache = CacheBuilder.newBuilder()
private final LoadingCache<String, LPSubject> subjectLoadingCache = Caffeine.newBuilder()
.expireAfterWrite(1, TimeUnit.MINUTES)
.build(new CacheLoader<String, LPSubject>() {
@Override
public LPSubject load(String s) throws Exception {
.build(s -> {
if (isLoaded(s)) {
return getIfLoaded(s).getSpongeData();
}
// Request load
plugin.getStorage().createAndLoadGroup(s, CreationCause.INTERNAL).join();
getPlugin().getStorage().createAndLoadGroup(s, CreationCause.INTERNAL).join();
SpongeGroup group = getIfLoaded(s);
if (group == null) {
plugin.getLog().severe("Error whilst loading group '" + s + "'.");
getPlugin().getLog().severe("Error whilst loading group '" + s + "'.");
throw new RuntimeException();
}
return group.getSpongeData();
}
});
public SpongeGroupManager(LPSpongePlugin plugin) {
@ -114,7 +110,7 @@ public class SpongeGroupManager implements GroupManager, LPSubjectCollection {
@Override
public SpongeGroup getOrMake(String id) {
return objects.getUnchecked(id.toLowerCase());
return objects.get(id.toLowerCase());
}
@Override
@ -173,7 +169,7 @@ public class SpongeGroupManager implements GroupManager, LPSubjectCollection {
try {
return subjectLoadingCache.get(id);
} catch (UncheckedExecutionException | ExecutionException e) {
} catch (Exception e) {
e.printStackTrace();
plugin.getLog().warn("Couldn't get group subject for id: " + id);
return plugin.getService().getFallbackGroupSubjects().get(id); // fallback to the transient collection

36
sponge/src/main/java/me/lucko/luckperms/sponge/managers/SpongeUserManager.java
View File

@ -22,15 +22,13 @@
package me.lucko.luckperms.sponge.managers;
import lombok.Getter;
import lombok.NonNull;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.github.benmanes.caffeine.cache.CacheLoader;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.LoadingCache;
import com.google.common.collect.ImmutableMap;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.UncheckedExecutionException;
import me.lucko.luckperms.api.Tristate;
import me.lucko.luckperms.api.context.ContextSet;
@ -57,13 +55,14 @@ import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
public class SpongeUserManager implements UserManager, LPSubjectCollection {
@Getter
private final LPSpongePlugin plugin;
private final LoadingCache<UserIdentifier, SpongeUser> objects = CacheBuilder.newBuilder()
private final LoadingCache<UserIdentifier, SpongeUser> objects = Caffeine.newBuilder()
.build(new CacheLoader<UserIdentifier, SpongeUser>() {
@Override
public SpongeUser load(UserIdentifier i) {
@ -71,16 +70,14 @@ public class SpongeUserManager implements UserManager, LPSubjectCollection {
}
@Override
public ListenableFuture<SpongeUser> reload(UserIdentifier i, SpongeUser t) {
return Futures.immediateFuture(t); // Never needs to be refreshed.
public SpongeUser reload(UserIdentifier i, SpongeUser t) {
return t; // Never needs to be refreshed.
}
});
private final LoadingCache<UUID, LPSubject> subjectLoadingCache = CacheBuilder.newBuilder()
private final LoadingCache<UUID, LPSubject> subjectLoadingCache = Caffeine.<UUID, LPSubject>newBuilder()
.expireAfterWrite(1, TimeUnit.MINUTES)
.build(new CacheLoader<UUID, LPSubject>() {
@Override
public LPSubject load(UUID u) throws Exception {
.build(u -> {
if (isLoaded(UserIdentifier.of(u, null))) {
SpongeUser user = get(u);
@ -92,22 +89,21 @@ public class SpongeUserManager implements UserManager, LPSubjectCollection {
}
// Request load
plugin.getStorage().loadUser(u, "null").join();
getPlugin().getStorage().loadUser(u, "null").join();
SpongeUser user = get(u);
if (user == null) {
plugin.getLog().severe("Error whilst loading user '" + u + "'.");
getPlugin().getLog().severe("Error whilst loading user '" + u + "'.");
throw new RuntimeException();
}
user.setupData(false);
if (user.getUserData() == null) {
plugin.getLog().warn("User data not present for requested user id: " + u);
getPlugin().getLog().warn("User data not present for requested user id: " + u);
}
return user.getSpongeData();
}
});
public SpongeUserManager(LPSpongePlugin plugin) {
@ -144,7 +140,7 @@ public class SpongeUserManager implements UserManager, LPSubjectCollection {
@Override
public SpongeUser getOrMake(UserIdentifier id) {
return objects.getUnchecked(id);
return objects.get(id);
}
@Override
@ -251,7 +247,7 @@ public class SpongeUserManager implements UserManager, LPSubjectCollection {
UUID u = plugin.getUuidCache().getUUID(uuid);
try {
return subjectLoadingCache.get(u);
} catch (UncheckedExecutionException | ExecutionException e) {
} catch (Exception e) {
e.printStackTrace();
plugin.getLog().warn("Couldn't get user subject for id: " + id);
return plugin.getService().getFallbackUserSubjects().get(id); // fallback to the transient collection

37
sponge/src/main/java/me/lucko/luckperms/sponge/model/SpongeGroup.java
View File

@ -24,9 +24,8 @@ package me.lucko.luckperms.sponge.model;
import lombok.Getter;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.LoadingCache;
import com.google.common.collect.ImmutableSet;
import me.lucko.luckperms.api.LocalizedNode;
@ -68,7 +67,11 @@ public class SpongeGroup extends Group {
}
public static class GroupSubject implements LPSubject {
@Getter
private final SpongeGroup parent;
@Getter
private final LPSpongePlugin plugin;
@Getter
@ -77,38 +80,32 @@ public class SpongeGroup extends Group {
@Getter
private final LuckPermsSubjectData transientSubjectData;
private final LoadingCache<ContextSet, NodeTree> permissionCache = CacheBuilder.newBuilder()
private final LoadingCache<ContextSet, NodeTree> permissionCache = Caffeine.newBuilder()
.expireAfterAccess(10, TimeUnit.MINUTES)
.build(new CacheLoader<ContextSet, NodeTree>() {
@Override
public NodeTree load(ContextSet contexts) {
.build(contexts -> {
// TODO move this away from NodeTree
Map<String, Boolean> permissions = parent.getAllNodes(ExtractedContexts.generate(plugin.getService().calculateContexts(contexts))).stream()
Map<String, Boolean> permissions = getParent().getAllNodes(ExtractedContexts.generate(getPlugin().getService().calculateContexts(contexts))).stream()
.map(LocalizedNode::getNode)
.collect(Collectors.toMap(Node::getPermission, Node::getValue));
return NodeTree.of(permissions);
}
});
private final LoadingCache<ContextSet, Set<SubjectReference>> parentCache = CacheBuilder.newBuilder()
private final LoadingCache<ContextSet, Set<SubjectReference>> parentCache = Caffeine.newBuilder()
.expireAfterWrite(10, TimeUnit.MINUTES)
.build(new CacheLoader<ContextSet, Set<SubjectReference>>() {
@Override
public Set<SubjectReference> load(ContextSet contexts) {
Set<SubjectReference> subjects = parent.getAllNodes(ExtractedContexts.generate(plugin.getService().calculateContexts(contexts))).stream()
.build(contexts -> {
Set<SubjectReference> subjects = getParent().getAllNodes(ExtractedContexts.generate(getPlugin().getService().calculateContexts(contexts))).stream()
.map(LocalizedNode::getNode)
.filter(Node::isGroupNode)
.map(Node::getGroupName)
.map(s -> plugin.getService().getGroupSubjects().get(s))
.map(s -> getPlugin().getService().getGroupSubjects().get(s))
.map(LPSubject::toReference)
.collect(Collectors.toSet());
subjects.addAll(plugin.getService().getGroupSubjects().getDefaultSubject().resolve(getService()).getParents(contexts));
subjects.addAll(plugin.getService().getDefaults().getParents(contexts));
subjects.addAll(getPlugin().getService().getGroupSubjects().getDefaultSubject().resolve(getService()).getParents(contexts));
subjects.addAll(getPlugin().getService().getDefaults().getParents(contexts));
return ImmutableSet.copyOf(subjects);
}
});
private GroupSubject(LPSpongePlugin plugin, SpongeGroup parent) {
@ -159,7 +156,7 @@ public class SpongeGroup extends Group {
@Override
public Tristate getPermissionValue(ContextSet contexts, String permission) {
try (Timing ignored = plugin.getTimings().time(LPTiming.GROUP_GET_PERMISSION_VALUE)) {
NodeTree nt = permissionCache.getUnchecked(contexts);
NodeTree nt = permissionCache.get(contexts);
Tristate t = Util.convertTristate(nt.get(permission));
if (t != Tristate.UNDEFINED) {
return t;
@ -185,7 +182,7 @@ public class SpongeGroup extends Group {
@Override
public Set<SubjectReference> getParents(ContextSet contexts) {
try (Timing ignored = plugin.getTimings().time(LPTiming.GROUP_GET_PARENTS)) {
return parentCache.getUnchecked(contexts);
return parentCache.get(contexts);
}
}

16
sponge/src/main/java/me/lucko/luckperms/sponge/service/LuckPermsService.java
View File

@ -30,15 +30,13 @@ import lombok.NonNull;
import lombok.RequiredArgsConstructor;
import lombok.ToString;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.github.benmanes.caffeine.cache.CacheLoader;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.LoadingCache;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.MapMaker;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import me.lucko.luckperms.api.Contexts;
import me.lucko.luckperms.api.Tristate;
@ -109,7 +107,7 @@ public class LuckPermsService implements PermissionService {
private final Set<CalculatedSubjectData> localDataCaches;
@Getter(value = AccessLevel.NONE)
private final LoadingCache<String, LPSubjectCollection> collections = CacheBuilder.newBuilder()
private final LoadingCache<String, LPSubjectCollection> collections = Caffeine.newBuilder()
.build(new CacheLoader<String, LPSubjectCollection>() {
@Override
public LPSubjectCollection load(String s) {
@ -117,8 +115,8 @@ public class LuckPermsService implements PermissionService {
}
@Override
public ListenableFuture<LPSubjectCollection> reload(String s, LPSubjectCollection collection) {
return Futures.immediateFuture(collection); // Never needs to be refreshed.
public LPSubjectCollection reload(String s, LPSubjectCollection collection) {
return collection; // Never needs to be refreshed.
}
});
@ -171,7 +169,7 @@ public class LuckPermsService implements PermissionService {
@Override
public LPSubjectCollection getSubjects(String s) {
try (Timing ignored = plugin.getTimings().time(LPTiming.GET_SUBJECTS)) {
return collections.getUnchecked(s.toLowerCase());
return collections.get(s.toLowerCase());
}
}

10
sponge/src/main/java/me/lucko/luckperms/sponge/service/calculated/CalculatedSubjectData.java
View File

@ -25,9 +25,9 @@ package me.lucko.luckperms.sponge.service.calculated;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.github.benmanes.caffeine.cache.CacheLoader;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.LoadingCache;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
@ -103,7 +103,7 @@ public class CalculatedSubjectData implements LPSubjectData {
private final String calculatorDisplayName;
private final Map<ContextSet, Map<String, Boolean>> permissions = new ConcurrentHashMap<>();
private final LoadingCache<ContextSet, CalculatorHolder> permissionCache = CacheBuilder.newBuilder()
private final LoadingCache<ContextSet, CalculatorHolder> permissionCache = Caffeine.newBuilder()
.expireAfterAccess(10, TimeUnit.MINUTES)
.build(new CacheLoader<ContextSet, CalculatorHolder>() {
@Override
@ -131,7 +131,7 @@ public class CalculatedSubjectData implements LPSubjectData {
}
public Tristate getPermissionValue(ContextSet contexts, String permission) {
return permissionCache.getUnchecked(contexts).getCalculator().getPermissionValue(permission);
return permissionCache.get(contexts).getCalculator().getPermissionValue(permission);
}
public void replacePermissions(Map<ImmutableContextSet, Map<String, Boolean>> map) {

16
sponge/src/main/java/me/lucko/luckperms/sponge/service/persisted/PersistedCollection.java
View File

@ -27,9 +27,8 @@ import lombok.Getter;
import lombok.NonNull;
import lombok.RequiredArgsConstructor;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.LoadingCache;
import com.google.common.collect.ImmutableMap;
import me.lucko.luckperms.api.Tristate;
@ -55,13 +54,8 @@ public class PersistedCollection implements LPSubjectCollection {
private final boolean transientHasPriority;
@Getter(AccessLevel.NONE)
private final LoadingCache<String, PersistedSubject> subjects = CacheBuilder.newBuilder()
.build(new CacheLoader<String, PersistedSubject>() {
@Override
public PersistedSubject load(String s) {
return new PersistedSubject(s, service, PersistedCollection.this);
}
});
private final LoadingCache<String, PersistedSubject> subjects = Caffeine.newBuilder()
.build(s -> new PersistedSubject(s, getService(), PersistedCollection.this));
public void loadAll() {
Map<String, SubjectStorageModel> holders = service.getStorage().loadAllFromFile(identifier);
@ -73,7 +67,7 @@ public class PersistedCollection implements LPSubjectCollection {
@Override
public PersistedSubject get(@NonNull String id) {
return subjects.getUnchecked(id.toLowerCase());
return subjects.get(id.toLowerCase());
}
@Override

43
sponge/src/main/java/me/lucko/luckperms/sponge/service/persisted/PersistedSubject.java
View File

@ -25,9 +25,8 @@ package me.lucko.luckperms.sponge.service.persisted;
import lombok.Getter;
import lombok.NonNull;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.LoadingCache;
import com.google.common.collect.ImmutableSet;
import me.lucko.luckperms.api.Tristate;
@ -67,31 +66,17 @@ public class PersistedSubject implements LPSubject {
private final PersistedSubjectData subjectData;
private final CalculatedSubjectData transientSubjectData;
private final LoadingCache<PermissionLookup, Tristate> permissionLookupCache = CacheBuilder.newBuilder()
private final LoadingCache<PermissionLookup, Tristate> permissionLookupCache = Caffeine.newBuilder()
.expireAfterAccess(20, TimeUnit.MINUTES)
.build(new CacheLoader<PermissionLookup, Tristate>() {
@Override
public Tristate load(PermissionLookup lookup) {
return lookupPermissionValue(lookup.getContexts(), lookup.getNode());
}
});
private final LoadingCache<ImmutableContextSet, Set<SubjectReference>> parentLookupCache = CacheBuilder.newBuilder()
.expireAfterAccess(20, TimeUnit.MINUTES)
.build(new CacheLoader<ImmutableContextSet, Set<SubjectReference>>() {
@Override
public Set<SubjectReference> load(ImmutableContextSet contexts) {
return lookupParents(contexts);
}
});
private final LoadingCache<OptionLookup, Optional<String>> optionLookupCache = CacheBuilder.newBuilder()
.expireAfterAccess(20, TimeUnit.MINUTES)
.build(new CacheLoader<OptionLookup, Optional<String>>() {
@Override
public Optional<String> load(OptionLookup lookup) {
return lookupOptionValue(lookup.getContexts(), lookup.getKey());
}
});
.build(lookup -> lookupPermissionValue(lookup.getContexts(), lookup.getNode()));
private final LoadingCache<ImmutableContextSet, Set<SubjectReference>> parentLookupCache = Caffeine.newBuilder()
.expireAfterAccess(20, TimeUnit.MINUTES)
.build(this::lookupParents);
private final LoadingCache<OptionLookup, Optional<String>> optionLookupCache = Caffeine.newBuilder()
.expireAfterAccess(20, TimeUnit.MINUTES)
.build(lookup -> lookupOptionValue(lookup.getContexts(), lookup.getKey()));
private final BufferedRequest<Void> saveBuffer = new BufferedRequest<Void>(1000L, r -> PersistedSubject.this.service.getPlugin().doAsync(r)) {
@Override
@ -251,7 +236,7 @@ public class PersistedSubject implements LPSubject {
@Override
public Tristate getPermissionValue(@NonNull ContextSet contexts, @NonNull String node) {
try (Timing ignored = service.getPlugin().getTimings().time(LPTiming.INTERNAL_SUBJECT_GET_PERMISSION_VALUE)) {
Tristate t = permissionLookupCache.getUnchecked(PermissionLookup.of(node, contexts.makeImmutable()));
Tristate t = permissionLookupCache.get(PermissionLookup.of(node, contexts.makeImmutable()));
service.getPlugin().getVerboseHandler().offer("local:" + getParentCollection().getCollection() + "/" + identifier, node, t);
return t;
}
@ -275,14 +260,14 @@ public class PersistedSubject implements LPSubject {
@Override
public Set<SubjectReference> getParents(@NonNull ContextSet contexts) {
try (Timing ignored = service.getPlugin().getTimings().time(LPTiming.INTERNAL_SUBJECT_GET_PARENTS)) {
return parentLookupCache.getUnchecked(contexts.makeImmutable());
return parentLookupCache.get(contexts.makeImmutable());
}
}
@Override
public Optional<String> getOption(ContextSet contexts, String key) {
try (Timing ignored = service.getPlugin().getTimings().time(LPTiming.INTERNAL_SUBJECT_GET_OPTION)) {
return optionLookupCache.getUnchecked(OptionLookup.of(key, contexts.makeImmutable()));
return optionLookupCache.get(OptionLookup.of(key, contexts.makeImmutable()));
}
}

27
sponge/src/main/java/me/lucko/luckperms/sponge/service/proxy/Util.java
View File

@ -25,9 +25,8 @@ package me.lucko.luckperms.sponge.service.proxy;
import lombok.NonNull;
import lombok.experimental.UtilityClass;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.LoadingCache;
import com.google.common.collect.ImmutableSet;
import me.lucko.luckperms.api.context.ContextSet;
@ -41,28 +40,18 @@ import java.util.Set;
@UtilityClass
public class Util {
private static final LoadingCache<Set<Context>, ImmutableContextSet> SPONGE_TO_LP_CACHE = CacheBuilder.newBuilder()
.build(new CacheLoader<Set<Context>, ImmutableContextSet>() {
@Override
public ImmutableContextSet load(Set<Context> contexts) {
return ImmutableContextSet.fromEntries(contexts);
}
});
private static final LoadingCache<Set<Context>, ImmutableContextSet> SPONGE_TO_LP_CACHE = Caffeine.newBuilder()
.build(ImmutableContextSet::fromEntries);
private static final LoadingCache<ImmutableContextSet, Set<Context>> LP_TO_SPONGE_CACHE = CacheBuilder.newBuilder()
.build(new CacheLoader<ImmutableContextSet, Set<Context>>() {
@Override
public Set<Context> load(ImmutableContextSet set) {
return set.toSet().stream().map(e -> new Context(e.getKey(), e.getValue())).collect(ImmutableCollectors.toImmutableSet());
}
});
private static final LoadingCache<ImmutableContextSet, Set<Context>> LP_TO_SPONGE_CACHE = Caffeine.newBuilder()
.build(set -> set.toSet().stream().map(e -> new Context(e.getKey(), e.getValue())).collect(ImmutableCollectors.toImmutableSet()));
public static ContextSet convertContexts(@NonNull Set<Context> contexts) {
return SPONGE_TO_LP_CACHE.getUnchecked(ImmutableSet.copyOf(contexts));
return SPONGE_TO_LP_CACHE.get(ImmutableSet.copyOf(contexts));
}
public static Set<Context> convertContexts(@NonNull ContextSet contexts) {
return LP_TO_SPONGE_CACHE.getUnchecked(contexts.makeImmutable());
return LP_TO_SPONGE_CACHE.get(contexts.makeImmutable());
}
public static Tristate convertTristate(me.lucko.luckperms.api.Tristate tristate) {