diff --git a/bukkit/src/main/java/me/lucko/luckperms/bukkit/LPBukkitPlugin.java b/bukkit/src/main/java/me/lucko/luckperms/bukkit/LPBukkitPlugin.java index a8eef4ded..eba042cc0 100644 --- a/bukkit/src/main/java/me/lucko/luckperms/bukkit/LPBukkitPlugin.java +++ b/bukkit/src/main/java/me/lucko/luckperms/bukkit/LPBukkitPlugin.java @@ -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(); diff --git a/bungee/src/main/java/me/lucko/luckperms/bungee/LPBungeePlugin.java b/bungee/src/main/java/me/lucko/luckperms/bungee/LPBungeePlugin.java index 1127857ed..a77434be6 100644 --- a/bungee/src/main/java/me/lucko/luckperms/bungee/LPBungeePlugin.java +++ b/bungee/src/main/java/me/lucko/luckperms/bungee/LPBungeePlugin.java @@ -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()); diff --git a/common/pom.xml b/common/pom.xml index 24e426797..857afd285 100644 --- a/common/pom.xml +++ b/common/pom.xml @@ -118,6 +118,13 @@ 19.0 provided + + + com.github.ben-manes.caffeine + caffeine + 2.4.0 + provided + org.projectlombok diff --git a/common/src/main/java/me/lucko/luckperms/common/caching/UserCache.java b/common/src/main/java/me/lucko/luckperms/common/caching/UserCache.java index 5d5e93ec6..2d3bb98e2 100644 --- a/common/src/main/java/me/lucko/luckperms/common/caching/UserCache.java +++ b/common/src/main/java/me/lucko/luckperms/common/caching/UserCache.java @@ -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 permission = CacheBuilder.newBuilder() + private final LoadingCache permission = Caffeine.newBuilder() .expireAfterAccess(10, TimeUnit.MINUTES) .build(new CacheLoader() { @Override @@ -68,13 +67,13 @@ public class UserCache implements UserData { } @Override - public ListenableFuture 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 meta = CacheBuilder.newBuilder() + private final LoadingCache meta = Caffeine.newBuilder() .expireAfterAccess(10, TimeUnit.MINUTES) .build(new CacheLoader() { @Override @@ -83,20 +82,20 @@ public class UserCache implements UserData { } @Override - public ListenableFuture 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() { diff --git a/common/src/main/java/me/lucko/luckperms/common/caching/holder/ExportNodesHolder.java b/common/src/main/java/me/lucko/luckperms/common/caching/holder/ExportNodesHolder.java deleted file mode 100644 index 513522ca0..000000000 --- a/common/src/main/java/me/lucko/luckperms/common/caching/holder/ExportNodesHolder.java +++ /dev/null @@ -1,41 +0,0 @@ -/* - * Copyright (c) 2016 Lucko (Luck) - * - * 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; - -} diff --git a/common/src/main/java/me/lucko/luckperms/common/caching/holder/GetAllNodesRequest.java b/common/src/main/java/me/lucko/luckperms/common/caching/holder/GetAllNodesRequest.java deleted file mode 100644 index 73fa654c4..000000000 --- a/common/src/main/java/me/lucko/luckperms/common/caching/holder/GetAllNodesRequest.java +++ /dev/null @@ -1,43 +0,0 @@ -/* - * Copyright (c) 2016 Lucko (Luck) - * - * 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 excludedGroups; - private final ExtractedContexts contexts; - -} diff --git a/common/src/main/java/me/lucko/luckperms/common/calculators/PermissionCalculator.java b/common/src/main/java/me/lucko/luckperms/common/calculators/PermissionCalculator.java index 0e4fa9486..55617f759 100644 --- a/common/src/main/java/me/lucko/luckperms/common/calculators/PermissionCalculator.java +++ b/common/src/main/java/me/lucko/luckperms/common/calculators/PermissionCalculator.java @@ -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 processors; - private final LoadingCache cache = CacheBuilder.newBuilder() - .build(new CacheLoader() { - @Override - public Tristate load(String s) { - return lookupPermissionValue(s); - } - }); + private final LoadingCache 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; diff --git a/common/src/main/java/me/lucko/luckperms/common/config/AbstractConfiguration.java b/common/src/main/java/me/lucko/luckperms/common/config/AbstractConfiguration.java index f62073a70..642f33d95 100644 --- a/common/src/main/java/me/lucko/luckperms/common/config/AbstractConfiguration.java +++ b/common/src/main/java/me/lucko/luckperms/common/config/AbstractConfiguration.java @@ -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, Optional> cache = CacheBuilder.newBuilder() - .build(new CacheLoader, Optional>() { - @Override - public Optional load(ConfigKey key) { - return Optional.ofNullable(key.get(AbstractConfiguration.this)); - } - }); + private final LoadingCache, Optional> cache = Caffeine.newBuilder() + .build(key -> Optional.ofNullable(key.get(AbstractConfiguration.this))); @Getter private final LPConfigurationDelegate delegate = new LPConfigurationDelegate(this); + @SuppressWarnings("unchecked") @Override public T get(ConfigKey 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 diff --git a/common/src/main/java/me/lucko/luckperms/common/constants/Patterns.java b/common/src/main/java/me/lucko/luckperms/common/constants/Patterns.java index 312658105..d86793917 100644 --- a/common/src/main/java/me/lucko/luckperms/common/constants/Patterns.java +++ b/common/src/main/java/me/lucko/luckperms/common/constants/Patterns.java @@ -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 CACHE = CacheBuilder.newBuilder() - .build(new CacheLoader() { - @Override - public Pattern load(String s) throws Exception { - return Pattern.compile(s); - } - - @Override - public ListenableFuture reload(String s, Pattern pattern) { - return Futures.immediateFuture(pattern); - } - }); - - private static final LoadingCache, String> DELIMITER_CACHE = CacheBuilder.newBuilder() - .build(new CacheLoader, String>() { - @Override - public String load(Map.Entry e) { - // note the reversed order - return "(? CACHE = Caffeine.newBuilder().build(Pattern::compile); + private static final LoadingCache, String> DELIMITER_CACHE = Caffeine.newBuilder() + .build(e -> { + // note the reversed order + return "(? { private final List> calculators = new CopyOnWriteArrayList<>(); - private final LoadingCache cache = CacheBuilder.newBuilder() + private final LoadingCache cache = Caffeine.newBuilder() .weakKeys() .expireAfterWrite(50L, TimeUnit.MILLISECONDS) - .build(new CacheLoader() { - @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 calculator : calculators) { @@ -56,7 +50,7 @@ public class ContextManager { } public ContextSet getApplicableContext(T subject) { - return cache.getUnchecked(subject); + return cache.get(subject); } public void registerCalculator(ContextCalculator calculator) { diff --git a/common/src/main/java/me/lucko/luckperms/common/core/NodeFactory.java b/common/src/main/java/me/lucko/luckperms/common/core/NodeFactory.java index 2cf8045b7..08f2b9a42 100644 --- a/common/src/main/java/me/lucko/luckperms/common/core/NodeFactory.java +++ b/common/src/main/java/me/lucko/luckperms/common/core/NodeFactory.java @@ -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 CACHE = CacheBuilder.newBuilder() - .build(new CacheLoader() { - @Override - public Node load(String s) throws Exception { - return builderFromSerialisedNode(s, true).build(); - } - }); + private static final LoadingCache CACHE = Caffeine.newBuilder() + .build(s -> builderFromSerialisedNode(s, true).build()); - private static final LoadingCache CACHE_NEGATED = CacheBuilder.newBuilder() - .build(new CacheLoader() { - @Override - public Node load(String s) throws Exception { - return builderFromSerialisedNode(s, false).build(); - } - }); + private static final LoadingCache 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); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/core/PriorityComparator.java b/common/src/main/java/me/lucko/luckperms/common/core/PriorityComparator.java index 1f3735a93..a99050e06 100644 --- a/common/src/main/java/me/lucko/luckperms/common/core/PriorityComparator.java +++ b/common/src/main/java/me/lucko/luckperms/common/core/PriorityComparator.java @@ -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 { } private final Collator collator = Collator.getInstance(Locale.ENGLISH); - private final LoadingCache collationKeyCache = CacheBuilder.newBuilder() - .build(new CacheLoader() { - @Override - public CollationKey load(String s) throws Exception { - return collator.getCollationKey(s); - } - }); + private final LoadingCache collationKeyCache = Caffeine.newBuilder().build(collator::getCollationKey); @Override public int compare(LocalizedNode one, LocalizedNode two) { diff --git a/common/src/main/java/me/lucko/luckperms/common/dependencies/Dependency.java b/common/src/main/java/me/lucko/luckperms/common/dependencies/Dependency.java index 1004f52b9..9a9a87ba3 100644 --- a/common/src/main/java/me/lucko/luckperms/common/dependencies/Dependency.java +++ b/common/src/main/java/me/lucko/luckperms/common/dependencies/Dependency.java @@ -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; } diff --git a/common/src/main/java/me/lucko/luckperms/common/managers/AbstractManager.java b/common/src/main/java/me/lucko/luckperms/common/managers/AbstractManager.java index 9f4673151..8750a741b 100644 --- a/common/src/main/java/me/lucko/luckperms/common/managers/AbstractManager.java +++ b/common/src/main/java/me/lucko/luckperms/common/managers/AbstractManager.java @@ -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> implements Manager { - @SuppressWarnings("unchecked") - private static I lowerCase(I i) { - if (i instanceof String) { - return (I) ((String) i).toLowerCase(); - } else { - return i; - } - } - - private final LoadingCache objects = CacheBuilder.newBuilder() + private final LoadingCache objects = Caffeine.newBuilder() .build(new CacheLoader() { @Override public T load(I i) { @@ -58,8 +47,8 @@ public abstract class AbstractManager> implements M } @Override - public ListenableFuture 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> 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> implements M objects.invalidateAll(); } + @SuppressWarnings("unchecked") + private static I lowerCase(I i) { + if (i instanceof String) { + return (I) ((String) i).toLowerCase(); + } else { + return i; + } + } + } diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/LPSpongePlugin.java b/sponge/src/main/java/me/lucko/luckperms/sponge/LPSpongePlugin.java index 9c85f3047..c32aa8858 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/LPSpongePlugin.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/LPSpongePlugin.java @@ -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()); diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/managers/SpongeGroupManager.java b/sponge/src/main/java/me/lucko/luckperms/sponge/managers/SpongeGroupManager.java index 8267f75f7..ea1888902 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/managers/SpongeGroupManager.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/managers/SpongeGroupManager.java @@ -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 objects = CacheBuilder.newBuilder() + private final LoadingCache objects = Caffeine.newBuilder() .build(new CacheLoader() { @Override public SpongeGroup load(String i) { @@ -67,31 +66,28 @@ public class SpongeGroupManager implements GroupManager, LPSubjectCollection { } @Override - public ListenableFuture 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 subjectLoadingCache = CacheBuilder.newBuilder() + private final LoadingCache subjectLoadingCache = Caffeine.newBuilder() .expireAfterWrite(1, TimeUnit.MINUTES) - .build(new CacheLoader() { - @Override - public LPSubject load(String s) throws Exception { - if (isLoaded(s)) { - return getIfLoaded(s).getSpongeData(); - } - - // Request load - plugin.getStorage().createAndLoadGroup(s, CreationCause.INTERNAL).join(); - - SpongeGroup group = getIfLoaded(s); - if (group == null) { - plugin.getLog().severe("Error whilst loading group '" + s + "'."); - throw new RuntimeException(); - } - - return group.getSpongeData(); + .build(s -> { + if (isLoaded(s)) { + return getIfLoaded(s).getSpongeData(); } + + // Request load + getPlugin().getStorage().createAndLoadGroup(s, CreationCause.INTERNAL).join(); + + SpongeGroup group = getIfLoaded(s); + if (group == null) { + 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 diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/managers/SpongeUserManager.java b/sponge/src/main/java/me/lucko/luckperms/sponge/managers/SpongeUserManager.java index acdf34dbd..c79d0019b 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/managers/SpongeUserManager.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/managers/SpongeUserManager.java @@ -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 objects = CacheBuilder.newBuilder() + private final LoadingCache objects = Caffeine.newBuilder() .build(new CacheLoader() { @Override public SpongeUser load(UserIdentifier i) { @@ -71,43 +70,40 @@ public class SpongeUserManager implements UserManager, LPSubjectCollection { } @Override - public ListenableFuture 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 subjectLoadingCache = CacheBuilder.newBuilder() + private final LoadingCache subjectLoadingCache = Caffeine.newBuilder() .expireAfterWrite(1, TimeUnit.MINUTES) - .build(new CacheLoader() { - @Override - public LPSubject load(UUID u) throws Exception { - if (isLoaded(UserIdentifier.of(u, null))) { - - SpongeUser user = get(u); - if (user.getUserData() == null) { - user.setupData(false); - } - - return get(u).getSpongeData(); - } - - // Request load - plugin.getStorage().loadUser(u, "null").join(); + .build(u -> { + if (isLoaded(UserIdentifier.of(u, null))) { SpongeUser user = get(u); - if (user == null) { - plugin.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); + user.setupData(false); } - return user.getSpongeData(); + return get(u).getSpongeData(); } + + // Request load + getPlugin().getStorage().loadUser(u, "null").join(); + + SpongeUser user = get(u); + if (user == null) { + getPlugin().getLog().severe("Error whilst loading user '" + u + "'."); + throw new RuntimeException(); + } + + user.setupData(false); + + if (user.getUserData() == null) { + 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 diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/model/SpongeGroup.java b/sponge/src/main/java/me/lucko/luckperms/sponge/model/SpongeGroup.java index efa768eaf..0566776e5 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/model/SpongeGroup.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/model/SpongeGroup.java @@ -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 permissionCache = CacheBuilder.newBuilder() + private final LoadingCache permissionCache = Caffeine.newBuilder() .expireAfterAccess(10, TimeUnit.MINUTES) - .build(new CacheLoader() { - @Override - public NodeTree load(ContextSet contexts) { - // TODO move this away from NodeTree - Map permissions = parent.getAllNodes(ExtractedContexts.generate(plugin.getService().calculateContexts(contexts))).stream() - .map(LocalizedNode::getNode) - .collect(Collectors.toMap(Node::getPermission, Node::getValue)); + .build(contexts -> { + // TODO move this away from NodeTree + Map permissions = getParent().getAllNodes(ExtractedContexts.generate(getPlugin().getService().calculateContexts(contexts))).stream() + .map(LocalizedNode::getNode) + .collect(Collectors.toMap(Node::getPermission, Node::getValue)); - return NodeTree.of(permissions); - } + return NodeTree.of(permissions); }); - private final LoadingCache> parentCache = CacheBuilder.newBuilder() + private final LoadingCache> parentCache = Caffeine.newBuilder() .expireAfterWrite(10, TimeUnit.MINUTES) - .build(new CacheLoader>() { - @Override - public Set load(ContextSet contexts) { - Set subjects = parent.getAllNodes(ExtractedContexts.generate(plugin.getService().calculateContexts(contexts))).stream() - .map(LocalizedNode::getNode) - .filter(Node::isGroupNode) - .map(Node::getGroupName) - .map(s -> plugin.getService().getGroupSubjects().get(s)) - .map(LPSubject::toReference) - .collect(Collectors.toSet()); + .build(contexts -> { + Set subjects = getParent().getAllNodes(ExtractedContexts.generate(getPlugin().getService().calculateContexts(contexts))).stream() + .map(LocalizedNode::getNode) + .filter(Node::isGroupNode) + .map(Node::getGroupName) + .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); - } + 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 getParents(ContextSet contexts) { try (Timing ignored = plugin.getTimings().time(LPTiming.GROUP_GET_PARENTS)) { - return parentCache.getUnchecked(contexts); + return parentCache.get(contexts); } } diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/service/LuckPermsService.java b/sponge/src/main/java/me/lucko/luckperms/sponge/service/LuckPermsService.java index ebe1b46f9..fff45c2a5 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/service/LuckPermsService.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/service/LuckPermsService.java @@ -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 localDataCaches; @Getter(value = AccessLevel.NONE) - private final LoadingCache collections = CacheBuilder.newBuilder() + private final LoadingCache collections = Caffeine.newBuilder() .build(new CacheLoader() { @Override public LPSubjectCollection load(String s) { @@ -117,8 +115,8 @@ public class LuckPermsService implements PermissionService { } @Override - public ListenableFuture 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()); } } diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/service/calculated/CalculatedSubjectData.java b/sponge/src/main/java/me/lucko/luckperms/sponge/service/calculated/CalculatedSubjectData.java index 67c7882ec..ef4f320a6 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/service/calculated/CalculatedSubjectData.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/service/calculated/CalculatedSubjectData.java @@ -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> permissions = new ConcurrentHashMap<>(); - private final LoadingCache permissionCache = CacheBuilder.newBuilder() + private final LoadingCache permissionCache = Caffeine.newBuilder() .expireAfterAccess(10, TimeUnit.MINUTES) .build(new CacheLoader() { @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> map) { diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/service/persisted/PersistedCollection.java b/sponge/src/main/java/me/lucko/luckperms/sponge/service/persisted/PersistedCollection.java index 3190ec6b0..d4165532a 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/service/persisted/PersistedCollection.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/service/persisted/PersistedCollection.java @@ -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 subjects = CacheBuilder.newBuilder() - .build(new CacheLoader() { - @Override - public PersistedSubject load(String s) { - return new PersistedSubject(s, service, PersistedCollection.this); - } - }); + private final LoadingCache subjects = Caffeine.newBuilder() + .build(s -> new PersistedSubject(s, getService(), PersistedCollection.this)); public void loadAll() { Map 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 diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/service/persisted/PersistedSubject.java b/sponge/src/main/java/me/lucko/luckperms/sponge/service/persisted/PersistedSubject.java index 81900c950..62e4d3d43 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/service/persisted/PersistedSubject.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/service/persisted/PersistedSubject.java @@ -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 permissionLookupCache = CacheBuilder.newBuilder() + private final LoadingCache permissionLookupCache = Caffeine.newBuilder() .expireAfterAccess(20, TimeUnit.MINUTES) - .build(new CacheLoader() { - @Override - public Tristate load(PermissionLookup lookup) { - return lookupPermissionValue(lookup.getContexts(), lookup.getNode()); - } - }); - private final LoadingCache> parentLookupCache = CacheBuilder.newBuilder() - .expireAfterAccess(20, TimeUnit.MINUTES) - .build(new CacheLoader>() { - @Override - public Set load(ImmutableContextSet contexts) { - return lookupParents(contexts); - } - }); - private final LoadingCache> optionLookupCache = CacheBuilder.newBuilder() - .expireAfterAccess(20, TimeUnit.MINUTES) - .build(new CacheLoader>() { - @Override - public Optional load(OptionLookup lookup) { - return lookupOptionValue(lookup.getContexts(), lookup.getKey()); - } - }); + .build(lookup -> lookupPermissionValue(lookup.getContexts(), lookup.getNode())); + private final LoadingCache> parentLookupCache = Caffeine.newBuilder() + .expireAfterAccess(20, TimeUnit.MINUTES) + .build(this::lookupParents); + + private final LoadingCache> optionLookupCache = Caffeine.newBuilder() + .expireAfterAccess(20, TimeUnit.MINUTES) + .build(lookup -> lookupOptionValue(lookup.getContexts(), lookup.getKey())); private final BufferedRequest saveBuffer = new BufferedRequest(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 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 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())); } } diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/service/proxy/Util.java b/sponge/src/main/java/me/lucko/luckperms/sponge/service/proxy/Util.java index 8012f1371..80e7a7d2f 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/service/proxy/Util.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/service/proxy/Util.java @@ -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, ImmutableContextSet> SPONGE_TO_LP_CACHE = CacheBuilder.newBuilder() - .build(new CacheLoader, ImmutableContextSet>() { - @Override - public ImmutableContextSet load(Set contexts) { - return ImmutableContextSet.fromEntries(contexts); - } - }); + private static final LoadingCache, ImmutableContextSet> SPONGE_TO_LP_CACHE = Caffeine.newBuilder() + .build(ImmutableContextSet::fromEntries); - private static final LoadingCache> LP_TO_SPONGE_CACHE = CacheBuilder.newBuilder() - .build(new CacheLoader>() { - @Override - public Set load(ImmutableContextSet set) { - return set.toSet().stream().map(e -> new Context(e.getKey(), e.getValue())).collect(ImmutableCollectors.toImmutableSet()); - } - }); + private static final LoadingCache> 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 contexts) { - return SPONGE_TO_LP_CACHE.getUnchecked(ImmutableSet.copyOf(contexts)); + return SPONGE_TO_LP_CACHE.get(ImmutableSet.copyOf(contexts)); } public static Set 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) {