Changes for version 2.16

.gitignore

@@ -1,31 +1,27 @@
-# built application files
-*.jar
+# Created by https://www.gitignore.io/
 
-# Java class files
-*.class
+### Intellij ###
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and Webstorm
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
 
-# Local configuration file (sdk path, etc)
-logs/
-
-# Eclipse project files
-.classpath
-.project
-
-# Intellij project files
-*.iml
-*.ipr
-*.iws
+# User-specific stuff:
 .idea/
+*.iws
+/out/
+*.iml
+.idea_modules/
 
-# Gradle
-.gradletasknamecache
-.gradle/
-build/
-bin/
-gradle/
-gradlew*
+# JIRA plugin
+atlassian-ide-plugin.xml
 
-# Maven
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+
+### Maven ###
 target/
 pom.xml.tag
 pom.xml.releaseBackup
@@ -34,4 +30,135 @@ pom.xml.next
 release.properties
 dependency-reduced-pom.xml
 buildNumber.properties
-.mvn/timing.properties
+.mvn/timing.properties
+
+
+### Eclipse ###
+
+.metadata
+bin/
+tmp/
+*.tmp
+*.bak
+*.swp
+*~.nib
+local.properties
+.settings/
+.loadpath
+.recommenders
+
+# Eclipse Core
+.project
+
+# External tool builders
+.externalToolBuilders/
+
+# Locally stored "Eclipse launch configurations"
+*.launch
+
+# PyDev specific (Python IDE for Eclipse)
+*.pydevproject
+
+# CDT-specific (C/C++ Development Tooling)
+.cproject
+
+# JDT-specific (Eclipse Java Development Tools)
+.classpath
+
+# Java annotation processor (APT)
+.factorypath
+
+# PDT-specific (PHP Development Tools)
+.buildpath
+
+# sbteclipse plugin
+.target
+
+# Tern plugin
+.tern-project
+
+# TeXlipse plugin
+.texlipse
+
+# STS (Spring Tool Suite)
+.springBeans
+
+# Code Recommenders
+.recommenders/
+
+
+### Linux ###
+*~
+
+# temporary files which can be created if a process still has a handle open of a deleted file
+.fuse_hidden*
+
+# KDE directory preferences
+.directory
+
+# Linux trash folder which might appear on any partition or disk
+.Trash-*
+
+# .nfs files are created when an open file is removed but is still being accessed
+.nfs*
+
+
+### macOS ###
+*.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+# Thumbnails
+._*
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+
+### Windows ###
+# Windows image file caches
+Thumbs.db
+ehthumbs.db
+
+# Folder config file
+Desktop.ini
+
+# Recycle Bin used on file shares
+$RECYCLE.BIN/
+
+# Windows Installer files
+*.cab
+*.msi
+*.msm
+*.msp
+
+# Windows shortcuts
+*.lnk
+
+
+### Java ###
+*.class
+
+# Mobile Tools for Java (J2ME)
+.mtj.tmp/
+
+# Package Files #
+*.jar
+*.war
+*.ear
+
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*

README.md

@@ -8,10 +8,14 @@ An advanced permissions implementation for Bukkit/Spigot, BungeeCord and Sponge.
 * **Wiki** - <https://github.com/lucko/LuckPerms/wiki>
 
 ## Description
-LuckPerms is an advanced permissions implementation aiming to be a flexible, performant and reliable alternative to other permission systems, providing all the features you could ever possibly need in a permissions plugin, along with an extensive and well documented API for developers.
+LuckPerms is an advanced permissions implementation aiming to be a fast, reliable and flexible alternative to existing permission plugins. The project's main goals are centered around high performance and a wide feature set, filling the gaps of functionality and building upon existing features found in other plugins.
 
-* [Spigot Plugin Page](https://www.spigotmc.org/resources/luckperms-an-advanced-permissions-system.28140/ "Spigot Plugin Page")
-* [Sponge Plugin Page](https://forums.spongepowered.org/t/luckperms-an-advanced-permissions-system/14274 "Sponge Plugin Page")
+LuckPerms also includes an extensive API for developers, and support for a variety of Minecraft server software & data storage options.
+
+See the charts below for a partial list of features & comparison with other providers.
+
+* [Spigot Plugin Release Page](https://www.spigotmc.org/resources/luckperms-an-advanced-permissions-system.28140/ "Spigot Plugin Page")
+* [Sponge Plugin Release Page](https://forums.spongepowered.org/t/luckperms-an-advanced-permissions-system/14274 "Sponge Plugin Page")
 
 ## LuckPerms vs Other Plugins
 ### Bukkit
@@ -20,10 +24,11 @@ _Features checked on 23rd Aug 2016. If you find any inaccuracies, please do let
 ### Sponge
 ![alt text](https://static.lucko.me/luckperms-compare-sponge.png "Feature comparison")
 _Features checked on 8th Oct 2016. If you find any inaccuracies, please do let me know. I tried to be as fair as possible, and copy all major features from the respective plugin pages._
+
 ## License
 LuckPerms is licensed under the permissive MIT license. See LICENSE.md for more info.
 
-## Thanks to:
+## Sponsor
 [![JProfiler](https://www.ej-technologies.com/images/product_banners/jprofiler_large.png)](http://www.ej-technologies.com/products/jprofiler/overview.html)
 
 Thanks to ej-technologies for granting LuckPerms an open source licence to their [Java Profiling Software](http://www.ej-technologies.com/products/jprofiler/overview.html "Java Profiler").

api/pom.xml

@@ -1,11 +1,11 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xmlns="http://maven.apache.org/POM/4.0.0"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <parent>
         <artifactId>luckperms</artifactId>
         <groupId>me.lucko.luckperms</groupId>
-        <version>2.12-SNAPSHOT</version>
+        <version>2.16-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

api/src/main/java/me/lucko/luckperms/LuckPerms.java

@@ -34,6 +34,7 @@ public final class LuckPerms {
 
     /**
      * Gets an instance of {@link LuckPermsApi}
+     *
      * @return an api instance
      * @throws IllegalStateException if the api is not loaded
      */
@@ -47,6 +48,7 @@ public final class LuckPerms {
     /**
      * Gets an instance of {@link LuckPermsApi} safely. Unlike {@link LuckPerms#getApi}, this method will not throw an
      * {@link IllegalStateException} if the api is not loaded, rather return an empty {@link Optional}.
+     *
      * @return an optional api instance
      */
     public static Optional<LuckPermsApi> getApiSafe() {

api/src/main/java/me/lucko/luckperms/api/Contexts.java

@@ -22,42 +22,84 @@
 
 package me.lucko.luckperms.api;
 
-import com.google.common.collect.ImmutableMap;
+import me.lucko.luckperms.api.context.ContextSet;
 
-import java.util.Collections;
 import java.util.Map;
 
 /**
  * Represents the context and options for a permission lookup.
  * All values are immutable.
+ *
  * @since 2.11
  */
 public class Contexts {
     public static final String SERVER_KEY = "server";
     public static final String WORLD_KEY = "world";
+    private static final Contexts ALLOW_ALL = new Contexts(ContextSet.empty(), true, true, true, true, true, true);
 
     /**
      * Gets a context that will allow all nodes
+     *
      * @return a context that will not apply any filters
      */
     public static Contexts allowAll() {
-        return new Contexts(Collections.emptyMap(), true, true, true, true, true, true);
+        return ALLOW_ALL;
     }
 
+    public static Contexts of(ContextSet context, boolean includeGlobal, boolean includeGlobalWorld, boolean applyGroups, boolean applyGlobalGroups, boolean applyGlobalWorldGroups, boolean op) {
+        return new Contexts(context, includeGlobal, includeGlobalWorld, applyGroups, applyGlobalGroups, applyGlobalWorldGroups, op);
+    }
+
+    @SuppressWarnings("deprecation")
+    @Deprecated
     public static Contexts of(Map<String, String> context, boolean includeGlobal, boolean includeGlobalWorld, boolean applyGroups, boolean applyGlobalGroups, boolean applyGlobalWorldGroups) {
         return new Contexts(context, includeGlobal, includeGlobalWorld, applyGroups, applyGlobalGroups, applyGlobalWorldGroups);
     }
 
+    @SuppressWarnings("deprecation")
+    @Deprecated
     public static Contexts of(Map<String, String> context, boolean includeGlobal, boolean includeGlobalWorld, boolean applyGroups, boolean applyGlobalGroups, boolean applyGlobalWorldGroups, boolean op) {
         return new Contexts(context, includeGlobal, includeGlobalWorld, applyGroups, applyGlobalGroups, applyGlobalWorldGroups, op);
     }
 
-    public Contexts(Map<String, String> context, boolean includeGlobal, boolean includeGlobalWorld, boolean applyGroups, boolean applyGlobalGroups, boolean applyGlobalWorldGroups, boolean op) {
+    /**
+     * The contexts that apply for this lookup
+     * The keys for servers and worlds are defined as static values.
+     */
+    private final ContextSet context;
+    /**
+     * The mode to parse defaults on Bukkit
+     *
+     * @since 2.12
+     */
+    private final boolean op;
+    /**
+     * If global or non server specific nodes should be applied
+     */
+    private final boolean includeGlobal;
+    /**
+     * If global or non world specific nodes should be applied
+     */
+    private final boolean includeGlobalWorld;
+    /**
+     * If parent groups should be applied
+     */
+    private final boolean applyGroups;
+    /**
+     * If global or non server specific group memberships should be applied
+     */
+    private final boolean applyGlobalGroups;
+    /**
+     * If global or non world specific group memberships should be applied
+     */
+    private final boolean applyGlobalWorldGroups;
+
+    public Contexts(ContextSet context, boolean includeGlobal, boolean includeGlobalWorld, boolean applyGroups, boolean applyGlobalGroups, boolean applyGlobalWorldGroups, boolean op) {
         if (context == null) {
             throw new NullPointerException("context");
         }
 
-        this.context = ImmutableMap.copyOf(context);
+        this.context = context.makeImmutable();
         this.includeGlobal = includeGlobal;
         this.includeGlobalWorld = includeGlobalWorld;
         this.applyGroups = applyGroups;
@@ -66,58 +108,41 @@ public class Contexts {
         this.op = op;
     }
 
+    @Deprecated
+    public Contexts(Map<String, String> context, boolean includeGlobal, boolean includeGlobalWorld, boolean applyGroups, boolean applyGlobalGroups, boolean applyGlobalWorldGroups, boolean op) {
+        this(context == null ? null : ContextSet.fromMap(context), includeGlobal, includeGlobalWorld, applyGroups, applyGlobalGroups, applyGlobalWorldGroups, op);
+    }
+
+    @SuppressWarnings("deprecation")
+    @Deprecated
     public Contexts(Map<String, String> context, boolean includeGlobal, boolean includeGlobalWorld, boolean applyGroups, boolean applyGlobalGroups, boolean applyGlobalWorldGroups) {
         this(context, includeGlobal, includeGlobalWorld, applyGroups, applyGlobalGroups, applyGlobalWorldGroups, false);
     }
 
-    /**
-     * The contexts that apply for this lookup
-     *
-     * The keys for servers and worlds are defined as static values.
-     */
-    private final Map<String, String> context;
-
-    /**
-     * The mode to parse defaults on Bukkit
-     * @since 2.12
-     */
-    private final boolean op;
-
-    /**
-     * If global or non server specific nodes should be applied
-     */
-    private final boolean includeGlobal;
-
-    /**
-     * If global or non world specific nodes should be applied
-     */
-    private final boolean includeGlobalWorld;
-
-    /**
-     * If parent groups should be applied
-     */
-    private final boolean applyGroups;
-
-    /**
-     * If global or non server specific group memberships should be applied
-     */
-    private final boolean applyGlobalGroups;
-
-    /**
-     * If global or non world specific group memberships should be applied
-     */
-    private final boolean applyGlobalWorldGroups;
-
     /**
      * Gets the contexts that apply for this lookup
-     * @return an immutable map of context key value pairs
+     *
+     * @return an immutable set of context key value pairs
+     * @since 2.13
      */
-    public Map<String, String> getContext() {
+    public ContextSet getContexts() {
         return this.context;
     }
 
+    /**
+     * Gets the contexts that apply for this lookup
+     *
+     * @return an immutable map of context key value pairs
+     * @deprecated in favour of {@link #getContexts()}
+     */
+    @Deprecated
+    public Map<String, String> getContext() {
+        return this.context.toMap();
+    }
+
     /**
      * Gets if OP defaults should be included
+     *
      * @return true if op defaults should be included
      */
     public boolean isOp() {
@@ -126,6 +151,7 @@ public class Contexts {
 
     /**
      * Gets if global or non server specific nodes should be applied
+     *
      * @return true if global or non server specific nodes should be applied
      */
     public boolean isIncludeGlobal() {
@@ -134,6 +160,7 @@ public class Contexts {
 
     /**
      * Gets if global or non world specific nodes should be applied
+     *
      * @return true if global or non world specific nodes should be applied
      */
     public boolean isIncludeGlobalWorld() {
@@ -142,6 +169,7 @@ public class Contexts {
 
     /**
      * Gets if parent groups should be applied
+     *
      * @return true if parent groups should be applied
      */
     public boolean isApplyGroups() {
@@ -150,6 +178,7 @@ public class Contexts {
 
     /**
      * Gets if global or non server specific group memberships should be applied
+     *
      * @return true if global or non server specific group memberships should be applied
      */
     public boolean isApplyGlobalGroups() {
@@ -158,6 +187,7 @@ public class Contexts {
 
     /**
      * Gets if global or non world specific group memberships should be applied
+     *
      * @return true if global or non world specific group memberships should be applied
      */
     public boolean isApplyGlobalWorldGroups() {
@@ -166,7 +196,7 @@ public class Contexts {
 
     public String toString() {
         return "Contexts(" +
-                "context=" + this.getContext() + ", " +
+                "context=" + this.getContexts() + ", " +
                 "op=" + this.isOp() + ", " +
                 "includeGlobal=" + this.isIncludeGlobal() + ", " +
                 "includeGlobalWorld=" + this.isIncludeGlobalWorld() + ", " +
@@ -182,6 +212,7 @@ public class Contexts {
 
     /**
      * Check for equality
+     *
      * @param o the other
      * @return true if equal
      * @since 2.12
@@ -190,8 +221,8 @@ public class Contexts {
         if (o == this) return true;
         if (!(o instanceof Contexts)) return false;
         final Contexts other = (Contexts) o;
-        final Object this$context = this.getContext();
-        final Object other$context = other.getContext();
+        final Object this$context = this.getContexts();
+        final Object other$context = other.getContexts();
         if (this$context == null ? other$context != null : !this$context.equals(other$context)) return false;
         if (this.isOp() != other.isOp()) return false;
         if (this.isIncludeGlobal() != other.isIncludeGlobal()) return false;
@@ -204,13 +235,14 @@ public class Contexts {
 
     /**
      * Gets the hashcode
+     *
      * @return the hashcode
      * @since 2.12
      */
     public int hashCode() {
         final int PRIME = 59;
         int result = 1;
-        final Object $context = this.getContext();
+        final Object $context = this.getContexts();
         result = result * PRIME + ($context == null ? 43 : $context.hashCode());
         result = result * PRIME + (this.isOp() ? 79 : 97);
         result = result * PRIME + (this.isIncludeGlobal() ? 79 : 97);

api/src/main/java/me/lucko/luckperms/api/Datastore.java

@@ -29,280 +29,157 @@ import java.util.UUID;
 
 /**
  * Interface for the internal Datastore instance
+ *
+ * @deprecated as of version 2.14 in favour of {@link Storage}.
  */
-@SuppressWarnings("unused")
+@Deprecated
 public interface Datastore {
 
     String getName();
+
     boolean isAcceptingLogins();
 
-    /**
-     * Gets the {@link Sync} interface.
-     *
-     * All operations through this interface are called immediately and in the same thread as they are called.
-     * Datastore operations are thread blocking, and Sync operations should not be called on the main server thread.
-     * @return the sync interface
-     */
+    @Deprecated
     Sync sync();
 
-    /**
-     * Gets the {@link Async} interface.
-     * 
-     * All operations through this interface are called in a new, separate asynchronous thread.
-     * When the operation is complete, the provided callback method is called, in applicable, in the main server thread.
-     * @return the async interface
-     */
+    @Deprecated
     Async async();
 
-    /**
-     * Gets the {@link Future} interface.
-     * 
-     * All operations through this interface are called in a new, separate asynchronous thread, similar to {@link Async}.
-     * The only difference is that instead of providing a callback, a {@link java.util.concurrent.Future} is returned.
-     * See the Oracle JavaDocs for usage of the Future class.
-     * @return the future interface
-     */
+    @Deprecated
     Future future();
 
-    /**
-     * All operations through this interface are called immediately and in the same thread as they are called.
-     * Datastore operations are thread blocking, and Sync operations should not be called on the main server thread.
-     */
+    @Deprecated
     interface Sync {
-
-        /**
-         * Saves an action to the datastore
-         * @param entry the log entry to be saved
-         * @return true if the operation completed successfully.
-         * @throws NullPointerException if entry is null
-         */
         boolean logAction(LogEntry entry);
 
-        /**
-         * Loads and returns the log from the datastore
-         * @return a log instance, could be null
-         */
         Log getLog();
 
-        /**
-         * Either loads or creates a user object, and loads it into the plugins internal storage
-         * @param uuid the uuid of the user
-         * @param username the users username. (if you want to specify <code>null</code> here, just input "null" as a string.)
-         * @return true if the operation completed successfully.
-         * @throws NullPointerException if uuid or username is null
-         * @throws IllegalArgumentException if either of the parameters are invalid
-         * @deprecated functionality of this method is taken on by {@link #loadUser(UUID, String)}
-         */
         @Deprecated
         boolean loadOrCreateUser(UUID uuid, String username);
 
-        /**
-         * Loads a user from the datastore into the plugins internal storage.
-         * @param uuid the uuid of the user to load
-         * @return true if the user exists, and was loaded correctly.
-         * @throws NullPointerException if uuid is null
-         * @deprecated replaced by {@link #loadUser(UUID, String)}
-         */
         @Deprecated
         boolean loadUser(UUID uuid);
 
-        /**
-         * Loads a user's data into the plugins internal storage.
-         * @param uuid the uuid of the user to load
-         * @param username the users username. (if you want to specify <code>null</code> here, just input "null" as a string.)
-         * @return if the operation was performed successfully
-         * @throws NullPointerException if uuid or username is null
-         * @since 2.6
-         */
         boolean loadUser(UUID uuid, String username);
 
-        /**
-         * Saves a user object into the datastore. You should call this after you make any changes to a user.
-         * @param user the user to save
-         * @return true if the operation completed successfully.
-         * @throws NullPointerException if user is null
-         * @throws IllegalStateException if the user instance was not obtained from LuckPerms.
-         */
         boolean saveUser(User user);
 
-        /**
-         * Removes users from the datastore who are "default". This is called every time the plugin loads.
-         * @return true if the operation completed successfully
-         * @since 2.6
-         */
         boolean cleanupUsers();
 
-        /**
-         * Gets a set all user's UUIDs who are "unique", and aren't just a member of the "default" group.
-         * @return a set of uuids, or null if the operation failed.
-         * @since 2.6
-         */
         Set<UUID> getUniqueUsers();
 
-        /**
-         * Creates and loads a group into the plugins internal storage
-         * @param name the name of the group
-         * @return true if the operation completed successfully
-         * @throws NullPointerException if name is null
-         * @throws IllegalArgumentException if the name is invalid
-         */
         boolean createAndLoadGroup(String name);
 
-        /**
-         * Loads a group into the plugins internal storage.
-         * @param name the name of the group
-         * @return true if the operation completed successfully
-         * @throws NullPointerException if name is null
-         * @throws IllegalArgumentException if the name is invalid
-         */
         boolean loadGroup(String name);
 
-        /**
-         * Loads all groups from the datastore into the plugins internal storage
-         * @return true if the operation completed successfully.
-         */
         boolean loadAllGroups();
 
-        /**
-         * Saves a group back to the datastore. You should call this after you make any changes to a group.
-         * @param group the group to save
-         * @return true if the operation completed successfully.
-         * @throws NullPointerException if group is null
-         * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
-         */
         boolean saveGroup(Group group);
 
-        /**
-         * Permanently deletes a group from the datastore
-         * @param group the group to delete
-         * @return true if the operation completed successfully.
-         * @throws NullPointerException if group is null
-         * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
-         */
         boolean deleteGroup(Group group);
 
-        /**
-         * Creates and loads a track into the plugins internal storage
-         * @param name the name of the track
-         * @return true if the operation completed successfully
-         * @throws NullPointerException if name is null
-         * @throws IllegalArgumentException if the name is invalid
-         */
         boolean createAndLoadTrack(String name);
 
-        /**
-         * Loads a track into the plugins internal storage.
-         * @param name the name of the track
-         * @return true if the operation completed successfully
-         * @throws NullPointerException if name is null
-         * @throws IllegalArgumentException if the name is invalid
-         */
         boolean loadTrack(String name);
 
-        /**
-         * Loads all tracks from the datastore into the plugins internal storage
-         * @return true if the operation completed successfully.
-         */
         boolean loadAllTracks();
 
-        /**
-         * Saves a track back to the datastore. You should call this after you make any changes to a track.
-         * @param track the track to save
-         * @return true if the operation completed successfully.
-         * @throws NullPointerException if track is null
-         * @throws IllegalStateException if the track instance was not obtained from LuckPerms.
-         */
         boolean saveTrack(Track track);
 
-        /**
-         * Permanently deletes a track from the datastore
-         * @param track the track to delete
-         * @return true if the operation completed successfully.
-         * @throws NullPointerException if track is null
-         * @throws IllegalStateException if the track instance was not obtained from LuckPerms.
-         */
         boolean deleteTrack(Track track);
 
-        /**
-         * Saves UUID caching data to the datastore
-         * @param username the users username
-         * @param uuid the users mojang unique id
-         * @return true if the operation completed successfully.
-         * @throws NullPointerException if either parameters are null
-         * @throws IllegalArgumentException if the username is invalid
-         */
         boolean saveUUIDData(String username, UUID uuid);
 
-        /**
-         * Gets a UUID from a username
-         * @param username the corresponding username
-         * @return a uuid object, could be null
-         * @throws NullPointerException if either parameters are null
-         * @throws IllegalArgumentException if the username is invalid
-         */
         UUID getUUID(String username);
     }
 
-    /**
-     * All operations through this interface are called in a new, separate asynchronous thread.
-     * When the operation is complete, the provided callback method is called, in applicable, in the main server thread.
-     * 
-     * See {@link Sync} for method documentation. 
-     */
+    @Deprecated
     interface Async {
         void logAction(LogEntry entry, Callback<Boolean> callback);
+
         void getLog(Callback<Log> callback);
+
         @Deprecated
         void loadOrCreateUser(UUID uuid, String username, Callback<Boolean> callback);
+
         @Deprecated
         void loadUser(UUID uuid, Callback<Boolean> callback);
+
         void loadUser(UUID uuid, String username, Callback<Boolean> callback);
+
         void saveUser(User user, Callback<Boolean> callback);
+
         void cleanupUsers(Callback<Boolean> callback);
+
         void getUniqueUsers(Callback<Set<UUID>> callback);
+
         void createAndLoadGroup(String name, Callback<Boolean> callback);
+
         void loadGroup(String name, Callback<Boolean> callback);
+
         void loadAllGroups(Callback<Boolean> callback);
+
         void saveGroup(Group group, Callback<Boolean> callback);
+
         void deleteGroup(Group group, Callback<Boolean> callback);
+
         void createAndLoadTrack(String name, Callback<Boolean> callback);
+
         void loadTrack(String name, Callback<Boolean> callback);
+
         void loadAllTracks(Callback<Boolean> callback);
+
         void saveTrack(Track track, Callback<Boolean> callback);
+
         void deleteTrack(Track track, Callback<Boolean> callback);
+
         void saveUUIDData(String username, UUID uuid, Callback<Boolean> callback);
+
         void getUUID(String username, Callback<UUID> callback);
     }
 
-    /**
-     * All operations through this interface are called in a new, separate asynchronous thread, similar to {@link Async}.
-     * The only difference is that instead of providing a callback, a {@link java.util.concurrent.Future} is returned.
-     * See the Oracle JavaDocs for usage of the Future class.
-     * 
-     * See {@link Sync} for method documentation.
-     */
+    @Deprecated
     interface Future {
         java.util.concurrent.Future<Boolean> logAction(LogEntry entry);
+
         java.util.concurrent.Future<Log> getLog();
+
         @Deprecated
         java.util.concurrent.Future<Boolean> loadOrCreateUser(UUID uuid, String username);
+
         @Deprecated
         java.util.concurrent.Future<Boolean> loadUser(UUID uuid);
+
         java.util.concurrent.Future<Boolean> loadUser(UUID uuid, String username);
+
         java.util.concurrent.Future<Boolean> saveUser(User user);
+
         java.util.concurrent.Future<Boolean> cleanupUsers();
+
         java.util.concurrent.Future<Set<UUID>> getUniqueUsers();
+
         java.util.concurrent.Future<Boolean> createAndLoadGroup(String name);
+
         java.util.concurrent.Future<Boolean> loadGroup(String name);
+
         java.util.concurrent.Future<Boolean> loadAllGroups();
+
         java.util.concurrent.Future<Boolean> saveGroup(Group group);
+
         java.util.concurrent.Future<Boolean> deleteGroup(Group group);
+
         java.util.concurrent.Future<Boolean> createAndLoadTrack(String name);
+
         java.util.concurrent.Future<Boolean> loadTrack(String name);
+
         java.util.concurrent.Future<Boolean> loadAllTracks();
+
         java.util.concurrent.Future<Boolean> saveTrack(Track track);
+
         java.util.concurrent.Future<Boolean> deleteTrack(Track track);
+
         java.util.concurrent.Future<Boolean> saveUUIDData(String username, UUID uuid);
+
         java.util.concurrent.Future<UUID> getUUID(String username);
     }
 }

api/src/main/java/me/lucko/luckperms/api/Group.java

@@ -40,167 +40,182 @@ public interface Group extends PermissionHolder {
 
     /**
      * Check to see if a group inherits a group
+     *
      * @param group The group to check membership of
      * @return true if the group inherits the other group
-     * @throws NullPointerException if the group is null
+     * @throws NullPointerException  if the group is null
      * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
      */
     boolean inheritsGroup(Group group);
 
     /**
      * Check to see if the group inherits a group on a specific server
-     * @param group The group to check membership of
+     *
+     * @param group  The group to check membership of
      * @param server The server to check on
      * @return true if the group inherits the group on the server
-     * @throws NullPointerException if the group or server is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
+     * @throws NullPointerException     if the group or server is null
+     * @throws IllegalStateException    if the group instance was not obtained from LuckPerms.
      * @throws IllegalArgumentException if the server is invalid
      */
     boolean inheritsGroup(Group group, String server);
 
     /**
      * Check to see if the group inherits a group on a specific server and world
-     * @param group The group to check membership of
+     *
+     * @param group  The group to check membership of
      * @param server The server to check on
-     * @param world The world to check on
+     * @param world  The world to check on
      * @return true if the group inherits the group on the server and world
-     * @throws NullPointerException if the group, server or world is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
+     * @throws NullPointerException     if the group, server or world is null
+     * @throws IllegalStateException    if the group instance was not obtained from LuckPerms.
      * @throws IllegalArgumentException if the server or world is invalid
      */
     boolean inheritsGroup(Group group, String server, String world);
 
     /**
      * Make this group inherit another group
+     *
      * @param group the group to be inherited
      * @throws ObjectAlreadyHasException if the group already inherits the group
-     * @throws NullPointerException if the group is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
+     * @throws NullPointerException      if the group is null
+     * @throws IllegalStateException     if the group instance was not obtained from LuckPerms.
      */
     void setInheritGroup(Group group) throws ObjectAlreadyHasException;
 
     /**
      * Make this group inherit another group on a specific server
-     * @param group the group to be inherited
+     *
+     * @param group  the group to be inherited
      * @param server The server to inherit the group on
      * @throws ObjectAlreadyHasException if the group already inherits the group on that server
-     * @throws NullPointerException if the group or server is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
-     * @throws IllegalArgumentException if the server is invalid
+     * @throws NullPointerException      if the group or server is null
+     * @throws IllegalStateException     if the group instance was not obtained from LuckPerms.
+     * @throws IllegalArgumentException  if the server is invalid
      */
     void setInheritGroup(Group group, String server) throws ObjectAlreadyHasException;
 
     /**
      * Make this group inherit another group on a specific server and world
-     * @param group the group to be inherited
+     *
+     * @param group  the group to be inherited
      * @param server The server to inherit the group on
-     * @param world The world to inherit the group on
+     * @param world  The world to inherit the group on
      * @throws ObjectAlreadyHasException if the group already inherits the group on that server and world
-     * @throws NullPointerException if the group, server or world is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
-     * @throws IllegalArgumentException if the server or world is invalid
+     * @throws NullPointerException      if the group, server or world is null
+     * @throws IllegalStateException     if the group instance was not obtained from LuckPerms.
+     * @throws IllegalArgumentException  if the server or world is invalid
      */
     void setInheritGroup(Group group, String server, String world) throws ObjectAlreadyHasException;
 
     /**
      * Make this group inherit another group temporarily
-     * @param group the group to be inherited
+     *
+     * @param group    the group to be inherited
      * @param expireAt the unix time when the group should expire
      * @throws ObjectAlreadyHasException if the group already inherits the group temporarily
-     * @throws NullPointerException if the group is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
-     * @throws IllegalArgumentException if the expiry time is in the past
+     * @throws NullPointerException      if the group is null
+     * @throws IllegalStateException     if the group instance was not obtained from LuckPerms.
+     * @throws IllegalArgumentException  if the expiry time is in the past
      */
     void setInheritGroup(Group group, long expireAt) throws ObjectAlreadyHasException;
 
     /**
      * Make this group inherit another group on a specific server temporarily
-     * @param group the group to be inherited
-     * @param server The server inherit add the group on
+     *
+     * @param group    the group to be inherited
+     * @param server   The server inherit add the group on
      * @param expireAt when the group should expire
      * @throws ObjectAlreadyHasException if the group already inherits the group on that server temporarily
-     * @throws NullPointerException if the group or server is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
-     * @throws IllegalArgumentException if the expiry time is in the past or the server is invalid
+     * @throws NullPointerException      if the group or server is null
+     * @throws IllegalStateException     if the group instance was not obtained from LuckPerms.
+     * @throws IllegalArgumentException  if the expiry time is in the past or the server is invalid
      */
     void setInheritGroup(Group group, String server, long expireAt) throws ObjectAlreadyHasException;
 
     /**
      * Make this group inherit another group on a specific server and world temporarily
-     * @param group the group to be inherited
-     * @param server The server to inherit the group on
-     * @param world The world to inherit the group on
+     *
+     * @param group    the group to be inherited
+     * @param server   The server to inherit the group on
+     * @param world    The world to inherit the group on
      * @param expireAt when the group should expire
      * @throws ObjectAlreadyHasException if the group already inherits the group on that server and world temporarily
-     * @throws NullPointerException if the group, server or world is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
-     * @throws IllegalArgumentException if the expiry time is in the past or the server/world is invalid
+     * @throws NullPointerException      if the group, server or world is null
+     * @throws IllegalStateException     if the group instance was not obtained from LuckPerms.
+     * @throws IllegalArgumentException  if the expiry time is in the past or the server/world is invalid
      */
     void setInheritGroup(Group group, String server, String world, long expireAt) throws ObjectAlreadyHasException;
 
     /**
      * Remove a previously set inheritance rule
+     *
      * @param group the group to uninherit
-     * @throws ObjectLacksException if the group does not already inherit the group
-     * @throws NullPointerException if the group is null
+     * @throws ObjectLacksException  if the group does not already inherit the group
+     * @throws NullPointerException  if the group is null
      * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
      */
     void unsetInheritGroup(Group group) throws ObjectLacksException;
 
     /**
      * Remove a previously set inheritance rule
-     * @param group the group to uninherit
+     *
+     * @param group     the group to uninherit
      * @param temporary if the group being removed is temporary
-     * @throws ObjectLacksException if the group does not already inherit the group
-     * @throws NullPointerException if the group is null
+     * @throws ObjectLacksException  if the group does not already inherit the group
+     * @throws NullPointerException  if the group is null
      * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
      */
     void unsetInheritGroup(Group group, boolean temporary) throws ObjectLacksException;
 
     /**
      * Remove a previously set inheritance rule on a specific server
-     * @param group the group to uninherit
+     *
+     * @param group  the group to uninherit
      * @param server The server to remove the group on
-     * @throws ObjectLacksException if the group does not already inherit the group on that server
-     * @throws NullPointerException if the group or server is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
+     * @throws ObjectLacksException     if the group does not already inherit the group on that server
+     * @throws NullPointerException     if the group or server is null
+     * @throws IllegalStateException    if the group instance was not obtained from LuckPerms.
      * @throws IllegalArgumentException if the server is invalid
      */
     void unsetInheritGroup(Group group, String server) throws ObjectLacksException;
 
     /**
      * Remove a previously set inheritance rule on a specific server and world
-     * @param group the group to uninherit
+     *
+     * @param group  the group to uninherit
      * @param server The server to remove the group on
-     * @param world The world to remove the group on
-     * @throws ObjectLacksException if the group does not already inherit the group
-     * @throws NullPointerException if the group, server or world is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
+     * @param world  The world to remove the group on
+     * @throws ObjectLacksException     if the group does not already inherit the group
+     * @throws NullPointerException     if the group, server or world is null
+     * @throws IllegalStateException    if the group instance was not obtained from LuckPerms.
      * @throws IllegalArgumentException if the server or world is invalid
      */
     void unsetInheritGroup(Group group, String server, String world) throws ObjectLacksException;
 
     /**
      * Remove a previously set inheritance rule on a specific server
-     * @param group the group to uninherit
-     * @param server The server to remove the group on
+     *
+     * @param group     the group to uninherit
+     * @param server    The server to remove the group on
      * @param temporary if the group being removed is temporary
-     * @throws ObjectLacksException if the group does not already inherit the group
-     * @throws NullPointerException if the group or server is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
+     * @throws ObjectLacksException     if the group does not already inherit the group
+     * @throws NullPointerException     if the group or server is null
+     * @throws IllegalStateException    if the group instance was not obtained from LuckPerms.
      * @throws IllegalArgumentException if the expiry time is in the past or the server is invalid
      */
     void unsetInheritGroup(Group group, String server, boolean temporary) throws ObjectLacksException;
 
     /**
      * Remove a previously set inheritance rule on a specific server and world
-     * @param group the group to uninherit
-     * @param server The server to remove the group on
-     * @param world The world to remove the group on
+     *
+     * @param group     the group to uninherit
+     * @param server    The server to remove the group on
+     * @param world     The world to remove the group on
      * @param temporary if the group being removed was set temporarily
-     * @throws ObjectLacksException if the group does not already inherit the group
-     * @throws NullPointerException if the group, server or world is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
+     * @throws ObjectLacksException     if the group does not already inherit the group
+     * @throws NullPointerException     if the group, server or world is null
+     * @throws IllegalStateException    if the group instance was not obtained from LuckPerms.
      * @throws IllegalArgumentException if the expiry time is in the past or the server/world is invalid
      */
     void unsetInheritGroup(Group group, String server, String world, boolean temporary) throws ObjectLacksException;
@@ -212,25 +227,28 @@ public interface Group extends PermissionHolder {
 
     /**
      * Get a {@link List} of all of the groups the group inherits, on all servers
+     *
      * @return a {@link List} of group names
      */
     List<String> getGroupNames();
 
     /**
      * Get a {@link List} of the groups the group inherits on a specific server
+     *
      * @param server the server to check
-     * @param world the world to check
+     * @param world  the world to check
      * @return a {@link List} of group names
-     * @throws NullPointerException if the server or world is null
+     * @throws NullPointerException     if the server or world is null
      * @throws IllegalArgumentException if the server or world is invalid
      */
     List<String> getLocalGroups(String server, String world);
 
     /**
      * Get a {@link List} of the groups the group inherits on a specific server
+     *
      * @param server the server to check
      * @return a {@link List} of group names
-     * @throws NullPointerException if the server is null
+     * @throws NullPointerException     if the server is null
      * @throws IllegalArgumentException if the server is invalid
      */
     List<String> getLocalGroups(String server);

api/src/main/java/me/lucko/luckperms/api/LPConfiguration.java

@@ -109,7 +109,9 @@ public interface LPConfiguration {
     /**
      * @return true if permission checks are being recorded / debugged
      * @since 2.9
+     * @deprecated as this value is now always false. Functionality was replaced by the verbose command.
      */
+    @Deprecated
     boolean getDebugPermissionChecks();
 
     /**
@@ -167,8 +169,8 @@ public interface LPConfiguration {
     boolean getSplitStorage();
 
     /**
-     * @return a map of split storage options, where the key is the storage section, and the value is the storage method.
-     * For example: key = user, value = json
+     * @return a map of split storage options, where the key is the storage section, and the value is the storage
+     * method. For example: key = user, value = json
      * @since 2.7
      */
     Map<String, String> getSplitStorageOptions();

api/src/main/java/me/lucko/luckperms/api/LocalizedNode.java

@@ -24,18 +24,21 @@ package me.lucko.luckperms.api;
 
 /**
  * Represents a Node and where it was inherited from.
+ *
  * @since 2.11
  */
 public interface LocalizedNode extends Node {
 
     /**
      * Gets the node
+     *
      * @return the node this instance is representing
      */
     Node getNode();
 
     /**
      * Gets the location where the {@link Node} is inherited from
+     *
      * @return where the node was inherited from. Will not return null.
      * @see PermissionHolder#getObjectName()
      */

api/src/main/java/me/lucko/luckperms/api/Log.java

@@ -27,8 +27,8 @@ import java.util.SortedSet;
 import java.util.UUID;
 
 /**
- * Represents the internal LuckPerms log.
- * All content internally is immutable. You can add to the log using the {@link Datastore}, and then request an updated copy.
+ * Represents the internal LuckPerms log. All content internally is immutable. You can add to the log using the {@link
+ * Datastore}, and then request an updated copy.
  */
 @SuppressWarnings("unused")
 public interface Log {
@@ -45,6 +45,7 @@ public interface Log {
 
     /**
      * Gets the recent content separated by page
+     *
      * @param pageNo the page number
      * @return the page content
      */
@@ -64,8 +65,9 @@ public interface Log {
 
     /**
      * Gets the recent content for the uuid, separated into pages
+     *
      * @param pageNo the page number
-     * @param actor the uuid of the actor to filter by
+     * @param actor  the uuid of the actor to filter by
      * @return the page content
      */
     SortedMap<Integer, LogEntry> getRecent(int pageNo, UUID actor);
@@ -85,8 +87,9 @@ public interface Log {
 
     /**
      * Gets the user history content, separated by pages
+     *
      * @param pageNo the page number
-     * @param uuid the uuid of the acted user to filter by
+     * @param uuid   the uuid of the acted user to filter by
      * @return the page content
      */
     SortedMap<Integer, LogEntry> getUserHistory(int pageNo, UUID uuid);
@@ -97,7 +100,7 @@ public interface Log {
      */
     int getUserHistoryMaxPages(UUID uuid);
 
-    
+
     /**
      * @param name the name to filter by
      * @return all content in this log where the group = name
@@ -106,8 +109,9 @@ public interface Log {
 
     /**
      * Gets the group history content, separated by pages
+     *
      * @param pageNo the page number
-     * @param name the name of the acted group to filter by
+     * @param name   the name of the acted group to filter by
      * @return the page content
      */
     SortedMap<Integer, LogEntry> getGroupHistory(int pageNo, String name);
@@ -127,8 +131,9 @@ public interface Log {
 
     /**
      * Gets the track history content, separated by pages
+     *
      * @param pageNo the page number
-     * @param name the name of the acted track to filter by
+     * @param name   the name of the acted track to filter by
      * @return the page content
      */
     SortedMap<Integer, LogEntry> getTrackHistory(int pageNo, String name);
@@ -147,8 +152,9 @@ public interface Log {
 
     /**
      * Gets the search content, separated by pages
+     *
      * @param pageNo the page number
-     * @param query the query to filter by
+     * @param query  the query to filter by
      * @return the page content
      */
     SortedMap<Integer, LogEntry> getSearch(int pageNo, String query);

api/src/main/java/me/lucko/luckperms/api/LogEntry.java

@@ -29,12 +29,12 @@ import java.util.UUID;
  */
 @SuppressWarnings({"unused", "WeakerAccess"})
 public class LogEntry implements Comparable<LogEntry> {
+    private static final String FORMAT = "&8(&e%s&8) [&a%s&8] (&b%s&8) &7--> &f%s";
+
     public static LogEntryBuilder builder() {
         return new LogEntryBuilder();
     }
 
-    private static final String FORMAT = "&8(&e%s&8) [&a%s&8] (&b%s&8) &7--> &f%s";
-
     private long timestamp;
     private UUID actor;
     private String actorName;
@@ -100,54 +100,54 @@ public class LogEntry implements Comparable<LogEntry> {
         return timestamp;
     }
 
-    public UUID getActor() {
-        return actor;
-    }
-
-    public String getActorName() {
-        return actorName;
-    }
-
-    public char getType() {
-        return type;
-    }
-
-    public UUID getActed() {
-        return acted;
-    }
-
-    public String getActedName() {
-        return actedName;
-    }
-
-    public String getAction() {
-        return action;
-    }
-
     void setTimestamp(long timestamp) {
         this.timestamp = timestamp;
     }
 
+    public UUID getActor() {
+        return actor;
+    }
+
     void setActor(UUID actor) {
         this.actor = actor;
     }
 
+    public String getActorName() {
+        return actorName;
+    }
+
     void setActorName(String actorName) {
         this.actorName = actorName;
     }
 
+    public char getType() {
+        return type;
+    }
+
     void setType(char type) {
         this.type = type;
     }
 
+    public UUID getActed() {
+        return acted;
+    }
+
     void setActed(UUID acted) {
         this.acted = acted;
     }
 
+    public String getActedName() {
+        return actedName;
+    }
+
     void setActedName(String actedName) {
         this.actedName = actedName;
     }
 
+    public String getAction() {
+        return action;
+    }
+
     void setAction(String action) {
         this.action = action;
     }
@@ -226,6 +226,7 @@ public class LogEntry implements Comparable<LogEntry> {
         }
 
         protected abstract T createObj();
+
         protected abstract B getThis();
 
         public long getTimestamp() {

api/src/main/java/me/lucko/luckperms/api/Logger.java

@@ -25,13 +25,15 @@ package me.lucko.luckperms.api;
 /**
  * A wrapper interface for platform logger instances.
  *
- * <p> Bukkit/Bungee both use java.util.logging, and Sponge uses org.slf4j. This class wraps those classes so the commons
- * module can access a logger.
+ * <p> Bukkit/Bungee both use java.util.logging, and Sponge uses org.slf4j. This class wraps those classes so the
+ * commons module can access a logger.
  */
 public interface Logger {
 
     void info(String s);
+
     void warn(String s);
+
     void severe(String s);
 
 }

api/src/main/java/me/lucko/luckperms/api/LuckPermsApi.java

@@ -60,6 +60,7 @@ public interface LuckPermsApi {
 
     /**
      * Registers a listener to be sent LuckPerms events
+     *
      * @param listener the listener instance
      * @throws NullPointerException if the listener is null
      */
@@ -67,6 +68,7 @@ public interface LuckPermsApi {
 
     /**
      * Unregisters a previously registered listener from the EventBus
+     *
      * @param listener the listener instance to unregister
      * @throws NullPointerException if the listener is null
      */
@@ -74,30 +76,53 @@ public interface LuckPermsApi {
 
     /**
      * Gets a wrapped {@link LPConfiguration} instance, with read only access
+     *
      * @return a configuration instance
      */
     LPConfiguration getConfiguration();
 
     /**
-     * Gets a wrapped {@link Datastore} instance, with somewhat limited access
-     * @return a datastore instance
+     * Gets a wrapped {@link Storage} instance.
+     *
+     * @return a storage instance
+     * @since 2.14
      */
+    Storage getStorage();
+
+    /**
+     * Gets a wrapped Datastore instance.
+     *
+     * @return a datastore instance
+     * @deprecated in favour of {@link #getStorage()}
+     */
+    @SuppressWarnings("deprecation")
+    @Deprecated
     Datastore getDatastore();
 
+    /**
+     * Gets the messaging service in use on the platform, if present.
+     *
+     * @return an optional that may contain a messaging service instance.
+     */
+    Optional<MessagingService> getMessagingService();
+
     /**
      * Gets the {@link Logger} wrapping used by the platform
+     *
      * @return the logger instance
      */
     Logger getLogger();
 
     /**
      * Gets a wrapped {@link UuidCache} instance, providing read access to the LuckPerms internal uuid caching system
-     * @return a uuidcache instance
+     *
+     * @return a uuid cache instance
      */
     UuidCache getUuidCache();
 
     /**
      * Gets a wrapped user object from the user storage
+     *
      * @param uuid the uuid of the user to get
      * @return a {@link User} object, if one matching the uuid is loaded, or null if not
      * @throws NullPointerException if the uuid is null
@@ -106,6 +131,7 @@ public interface LuckPermsApi {
 
     /**
      * Gets a wrapped user object from the user storage. This method does not return null, unlike {@link #getUser(UUID)}
+     *
      * @param uuid the uuid of the user to get
      * @return an optional {@link User} object
      * @throws NullPointerException if the uuid is null
@@ -114,6 +140,7 @@ public interface LuckPermsApi {
 
     /**
      * Gets a wrapped user object from the user storage
+     *
      * @param name the username of the user to get
      * @return a {@link User} object, if one matching the uuid is loaded, or null if not
      * @throws NullPointerException if the name is null
@@ -121,7 +148,9 @@ public interface LuckPermsApi {
     User getUser(String name);
 
     /**
-     * Gets a wrapped user object from the user storage. This method does not return null, unlike {@link #getUser(String)}
+     * Gets a wrapped user object from the user storage. This method does not return null, unlike {@link
+     * #getUser(String)}
+     *
      * @param name the username of the user to get
      * @return an optional {@link User} object
      * @throws NullPointerException if the name is null
@@ -130,12 +159,14 @@ public interface LuckPermsApi {
 
     /**
      * Gets a set of all loaded users.
+     *
      * @return a {@link Set} of {@link User} objects
      */
     Set<User> getUsers();
 
     /**
      * Check if a user is loaded in memory
+     *
      * @param uuid the uuid to check for
      * @return true if the user is loaded
      * @throws NullPointerException if the uuid is null
@@ -144,6 +175,7 @@ public interface LuckPermsApi {
 
     /**
      * Unload a user from the internal storage, if they're not currently online.
+     *
      * @param user the user to unload
      * @throws NullPointerException if the user is null
      * @since 2.6
@@ -152,6 +184,7 @@ public interface LuckPermsApi {
 
     /**
      * Gets a wrapped group object from the group storage
+     *
      * @param name the name of the group to get
      * @return a {@link Group} object, if one matching the name exists, or null if not
      * @throws NullPointerException if the name is null
@@ -160,6 +193,7 @@ public interface LuckPermsApi {
 
     /**
      * Gets a wrapped group object from the group storage. This method does not return null, unlike {@link #getGroup}
+     *
      * @param name the name of the group to get
      * @return an optional {@link Group} object
      * @throws NullPointerException if the name is null
@@ -168,12 +202,14 @@ public interface LuckPermsApi {
 
     /**
      * Gets a set of all loaded groups.
+     *
      * @return a {@link Set} of {@link Group} objects
      */
     Set<Group> getGroups();
 
     /**
      * Check if a group is loaded in memory
+     *
      * @param name the name to check for
      * @return true if the group is loaded
      * @throws NullPointerException if the name is null
@@ -182,6 +218,7 @@ public interface LuckPermsApi {
 
     /**
      * Gets a wrapped track object from the track storage
+     *
      * @param name the name of the track to get
      * @return a {@link Track} object, if one matching the name exists, or null if not
      * @throws NullPointerException if the name is null
@@ -190,6 +227,7 @@ public interface LuckPermsApi {
 
     /**
      * Gets a wrapped track object from the track storage. This method does not return null, unlike {@link #getTrack}
+     *
      * @param name the name of the track to get
      * @return an optional {@link Track} object
      * @throws NullPointerException if the name is null
@@ -198,12 +236,14 @@ public interface LuckPermsApi {
 
     /**
      * Gets a set of all loaded tracks.
+     *
      * @return a {@link Set} of {@link Track} objects
      */
     Set<Track> getTracks();
 
     /**
      * Check if a track is loaded in memory
+     *
      * @param name the name to check for
      * @return true if the track is loaded
      * @throws NullPointerException if the name is null
@@ -212,16 +252,18 @@ public interface LuckPermsApi {
 
     /**
      * Returns a permission builder instance
+     *
      * @param permission the main permission node to build
      * @return a {@link Node.Builder} instance
      * @throws IllegalArgumentException if the permission is invalid
-     * @throws NullPointerException if the permission is null
+     * @throws NullPointerException     if the permission is null
      * @since 2.6
      */
     Node.Builder buildNode(String permission) throws IllegalArgumentException;
 
     /**
      * Register a custom context calculator to the server
+     *
      * @param contextCalculator the context calculator to register. The type MUST be the player class of the platform.
      * @throws ClassCastException if the type is not the player class of the platform.
      */
@@ -229,9 +271,19 @@ public interface LuckPermsApi {
 
     /**
      * Registers a custom context listener to the server,
+     *
      * @param contextListener the context listener to register. The type MUST be the player class of the platform.
      * @throws ClassCastException if the type is not the player class of the platform.
      */
     void registerContextListener(ContextListener<?> contextListener);
 
+    /**
+     * Gets a calculated context instance for the user using the rules of the platform.
+     * These values are calculated using the options in the configuration, and the provided calculators.
+     *
+     * @param user the user to get contexts for
+     * @return an optional containing contexts. Will return empty if the user is not online.
+     */
+    Optional<Contexts> getContextForUser(User user);
+
 }

api/src/main/java/me/lucko/luckperms/api/MessagingService.java

@@ -0,0 +1,38 @@
+/*
+ * 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.api;
+
+/**
+ * Exposes any networking provider being used on the platform. e.g. Redis
+ *
+ * @since 2.14
+ */
+public interface MessagingService {
+
+    /**
+     * Uses the messaging service to inform other servers about changes.
+     * This will push the update asynchronously, and this method will return almost immediately.
+     */
+    void pushUpdate();
+
+}

api/src/main/java/me/lucko/luckperms/api/MetaUtils.java

@@ -32,14 +32,14 @@ import java.util.Set;
 
 /**
  * A collection of utilities to help retrieve meta values for {@link PermissionHolder}s
+ *
  * @since 2.7
  */
 public class MetaUtils {
 
-    private MetaUtils(){}
-
     /**
      * Escapes special characters used within LuckPerms, so the string can be saved without issues
+     *
      * @param s the string to escape
      * @return an escaped string
      * @throws NullPointerException if the string is null
@@ -48,7 +48,7 @@ public class MetaUtils {
         if (s == null) {
             throw new NullPointerException();
         }
-        
+
         s = s.replace(".", "{SEP}");
         s = s.replace("/", "{FSEP}");
         s = s.replace("$", "{DSEP}");
@@ -58,6 +58,7 @@ public class MetaUtils {
 
     /**
      * Unescapes special characters used within LuckPerms, the inverse of {@link #escapeCharacters(String)}
+     *
      * @param s the string to unescape
      * @return an unescaped string
      * @throws NullPointerException if the string is null
@@ -66,7 +67,7 @@ public class MetaUtils {
         if (s == null) {
             throw new NullPointerException();
         }
-        
+
         s = s.replace("{SEP}", ".");
         s = s.replace("{FSEP}", "/");
         s = s.replace("{DSEP}", "$");
@@ -76,19 +77,20 @@ public class MetaUtils {
 
     /**
      * Sets a meta value on a holder
+     *
      * @param holder the holder to apply the meta node to
      * @param server the server to apply the meta on, can be null
-     * @param world the world to apply the meta on, can be null
-     * @param node the meta node
-     * @param value the meta value
-     * @throws NullPointerException if the holder, node or value is null
+     * @param world  the world to apply the meta on, can be null
+     * @param node   the meta node
+     * @param value  the meta value
+     * @throws NullPointerException     if the holder, node or value is null
      * @throws IllegalArgumentException if the node or value is empty
      */
     public static void setMeta(PermissionHolder holder, String server, String world, String node, String value) {
         if (holder == null) {
             throw new NullPointerException("holder");
         }
-        
+
         if (node == null) {
             throw new NullPointerException("node");
         }
@@ -108,7 +110,7 @@ public class MetaUtils {
         if (server == null || server.equals("")) {
             server = "global";
         }
-        
+
         node = escapeCharacters(node);
         value = escapeCharacters(value);
 
@@ -118,11 +120,12 @@ public class MetaUtils {
                 toRemove.add(n);
             }
         }
-        
+
         for (Node n : toRemove) {
             try {
                 holder.unsetPermission(n);
-            } catch (ObjectLacksException ignored) {}
+            } catch (ObjectLacksException ignored) {
+            }
         }
 
         Node.Builder metaNode = LuckPerms.getApi().buildNode("meta." + node + "." + value).setValue(true);
@@ -135,19 +138,21 @@ public class MetaUtils {
 
         try {
             holder.setPermission(metaNode.build());
-        } catch (ObjectAlreadyHasException ignored) {}
+        } catch (ObjectAlreadyHasException ignored) {
+        }
     }
 
     /**
      * Gets a meta value for the holder
-     * @param holder the holder to get the meta from
-     * @param server the server to retrieve the meta on, can be null
-     * @param world the world to retrieve the meta on, can be null
-     * @param node the node to get
-     * @param defaultValue the default value to return if the node is not set
+     *
+     * @param holder        the holder to get the meta from
+     * @param server        the server to retrieve the meta on, can be null
+     * @param world         the world to retrieve the meta on, can be null
+     * @param node          the node to get
+     * @param defaultValue  the default value to return if the node is not set
      * @param includeGlobal if global nodes should be considered when retrieving the meta
      * @return a meta string, or the default value if the user does not have the meta node
-     * @throws NullPointerException if the holder or node is null
+     * @throws NullPointerException     if the holder or node is null
      * @throws IllegalArgumentException if the node is empty
      */
     public static String getMeta(PermissionHolder holder, String server, String world, String node, String defaultValue, boolean includeGlobal) {
@@ -217,17 +222,19 @@ public class MetaUtils {
 
         try {
             holder.setPermission(node.build());
-        } catch (ObjectAlreadyHasException ignored) {}
+        } catch (ObjectAlreadyHasException ignored) {
+        }
     }
 
     /**
      * Adds a prefix to a holder on a specific server and world
-     * @param holder the holder to set the prefix for
-     * @param prefix the prefix value
+     *
+     * @param holder   the holder to set the prefix for
+     * @param prefix   the prefix value
      * @param priority the priority to set the prefix at
-     * @param server the server to set the prefix on, can be null
-     * @param world the world to set the prefix on, can be null
-     * @throws NullPointerException if the holder is null
+     * @param server   the server to set the prefix on, can be null
+     * @param world    the world to set the prefix on, can be null
+     * @throws NullPointerException     if the holder is null
      * @throws IllegalArgumentException if the prefix is null or empty
      */
     public static void setPrefix(PermissionHolder holder, String prefix, int priority, String server, String world) {
@@ -236,12 +243,13 @@ public class MetaUtils {
 
     /**
      * Adds a suffix to a holder on a specific server and world
-     * @param holder the holder to set the suffix for
-     * @param suffix the suffix value
+     *
+     * @param holder   the holder to set the suffix for
+     * @param suffix   the suffix value
      * @param priority the priority to set the suffix at
-     * @param server the server to set the suffix on, can be null
-     * @param world the world to set the suffix on, can be null
-     * @throws NullPointerException if the holder is null
+     * @param server   the server to set the suffix on, can be null
+     * @param world    the world to set the suffix on, can be null
+     * @throws NullPointerException     if the holder is null
      * @throws IllegalArgumentException if the suffix is null or empty
      */
     public static void setSuffix(PermissionHolder holder, String suffix, int priority, String server, String world) {
@@ -258,7 +266,7 @@ public class MetaUtils {
 
         int priority = Integer.MIN_VALUE;
         String meta = null;
-        for (Node n : holder.getAllNodes()) {
+        for (Node n : holder.getAllNodes(Contexts.allowAll())) {
             if (!n.getValue()) {
                 continue;
             }
@@ -272,7 +280,7 @@ public class MetaUtils {
             if (!n.shouldApplyOnWorld(world, includeGlobal, false)) {
                 continue;
             }
-            
+
             if (prefix ? !n.isPrefix() : !n.isSuffix()) {
                 continue;
             }
@@ -289,9 +297,10 @@ public class MetaUtils {
 
     /**
      * Returns a holders highest priority prefix, if they have one
-     * @param holder the holder
-     * @param server the server to retrieve the prefix on
-     * @param world the world to retrieve the prefix on
+     *
+     * @param holder        the holder
+     * @param server        the server to retrieve the prefix on
+     * @param world         the world to retrieve the prefix on
      * @param includeGlobal if global nodes should be considered when retrieving the prefix
      * @return a prefix string, if the holder has one, or an empty string if not.
      * @throws NullPointerException if the holder is null
@@ -302,9 +311,10 @@ public class MetaUtils {
 
     /**
      * Returns a holders highest priority suffix, if they have one
-     * @param holder the holder
-     * @param server the server to retrieve the suffix on
-     * @param world the world to retrieve the suffix on
+     *
+     * @param holder        the holder
+     * @param server        the server to retrieve the suffix on
+     * @param world         the world to retrieve the suffix on
      * @param includeGlobal if global nodes should be considered when retrieving the suffix
      * @return a suffix string, if the holder has one, or an empty string if not.
      * @throws NullPointerException if the holder is null
@@ -312,5 +322,8 @@ public class MetaUtils {
     public static String getSuffix(PermissionHolder holder, String server, String world, boolean includeGlobal) {
         return getChatMeta(false, holder, server, world, includeGlobal);
     }
-    
+
+    private MetaUtils() {
+    }
+
 }

api/src/main/java/me/lucko/luckperms/api/Node.java

@@ -22,14 +22,18 @@
 
 package me.lucko.luckperms.api;
 
+import me.lucko.luckperms.api.context.ContextSet;
+
 import java.util.Date;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
+import java.util.Set;
 
 /**
  * Represents an immutable node object
  * <p> Use {@link LuckPermsApi#buildNode(String)} to get an instance.
+ *
  * @since 2.6
  */
 @SuppressWarnings("unused")
@@ -42,6 +46,7 @@ public interface Node extends Map.Entry<String, Boolean> {
 
     /**
      * Get what value the permission is set to. A negated node would return <code>false</code>.
+     *
      * @return the permission's value
      */
     @Override
@@ -60,18 +65,21 @@ public interface Node extends Map.Entry<String, Boolean> {
     /**
      * If this node is set to override explicitly.
      * This value does not persist across saves, and is therefore only useful for transient nodes
+     *
      * @return true if this node is set to override explicitly
      */
     boolean isOverride();
 
     /**
      * Gets the server this node applies on, if the node is server specific
+     *
      * @return an {@link Optional} containing the server, if one is defined
      */
     Optional<String> getServer();
 
     /**
      * Gets the world this node applies on, if the node is world specific
+     *
      * @return an {@link Optional} containing the world, if one is defined
      */
     Optional<String> getWorld();
@@ -88,40 +96,72 @@ public interface Node extends Map.Entry<String, Boolean> {
 
     /**
      * If this node should apply on a specific server
-     * @param server the name of the server
+     *
+     * @param server        the name of the server
      * @param includeGlobal if global permissions should apply
-     * @param applyRegex if regex should be applied
+     * @param applyRegex    if regex should be applied
      * @return true if the node should apply
      */
     boolean shouldApplyOnServer(String server, boolean includeGlobal, boolean applyRegex);
 
     /**
      * If this node should apply on a specific world
-     * @param world the name of the world
+     *
+     * @param world         the name of the world
      * @param includeGlobal if global permissions should apply
-     * @param applyRegex if regex should be applied
+     * @param applyRegex    if regex should be applied
      * @return true if the node should apply
      */
     boolean shouldApplyOnWorld(String world, boolean includeGlobal, boolean applyRegex);
 
     /**
      * If this node should apply in the given context
-     * @param context the context key value pairs
+     *
+     * @param context        the context key value pairs
      * @param worldAndServer if world and server contexts should be checked
      * @return true if the node should apply
+     * @since 2.13
      */
-    boolean shouldApplyWithContext(Map<String, String> context, boolean worldAndServer);
+    boolean shouldApplyWithContext(ContextSet context, boolean worldAndServer);
 
     /**
      * If this node should apply in the given context
+     *
      * @param context the context key value pairs
      * @return true if the node should apply
+     * @since 2.13
      */
-    boolean shouldApplyWithContext(Map<String, String> context);
+    boolean shouldApplyWithContext(ContextSet context);
+
+    /**
+     * If this node should apply in the given context
+     *
+     * @param context        the context key value pairs
+     * @param worldAndServer if world and server contexts should be checked
+     * @return true if the node should apply
+     * @deprecated in favour of {@link #shouldApplyWithContext(ContextSet, boolean)}
+     */
+    @Deprecated
+    default boolean shouldApplyWithContext(Map<String, String> context, boolean worldAndServer) {
+        return shouldApplyWithContext(ContextSet.fromMap(context), worldAndServer);
+    }
+
+    /**
+     * If this node should apply in the given context
+     *
+     * @param context the context key value pairs
+     * @return true if the node should apply
+     * @deprecated in favour of {@link #shouldApplyWithContext(ContextSet)}
+     */
+    @Deprecated
+    default boolean shouldApplyWithContext(Map<String, String> context) {
+        return shouldApplyWithContext(ContextSet.fromMap(context));
+    }
 
     /**
      * Similar to {@link #shouldApplyOnServer(String, boolean, boolean)}, except this method accepts a List
-     * @param servers the list of servers
+     *
+     * @param servers       the list of servers
      * @param includeGlobal if global permissions should apply
      * @return true if the node should apply
      */
@@ -129,7 +169,8 @@ public interface Node extends Map.Entry<String, Boolean> {
 
     /**
      * Similar to {@link #shouldApplyOnWorld(String, boolean, boolean)}, except this method accepts a List
-     * @param worlds the list of world
+     *
+     * @param worlds        the list of world
      * @param includeGlobal if global permissions should apply
      * @return true if the node should apply
      */
@@ -137,6 +178,7 @@ public interface Node extends Map.Entry<String, Boolean> {
 
     /**
      * Resolves a list of wildcards that match this node
+     *
      * @param possibleNodes a list of possible permission nodes
      * @return a list of permissions that match this wildcard
      */
@@ -144,6 +186,7 @@ public interface Node extends Map.Entry<String, Boolean> {
 
     /**
      * Resolves any shorthand parts of this node and returns the full list
+     *
      * @return a list of full nodes
      */
     List<String> resolveShorthand();
@@ -186,11 +229,22 @@ public interface Node extends Map.Entry<String, Boolean> {
 
     /**
      * @return the extra contexts required for this node to apply
+     * @deprecated in favour of {@link #getContexts()}
      */
-    Map<String, String> getExtraContexts();
+    @Deprecated
+    default Map<String, String> getExtraContexts() {
+        return getContexts().toMap();
+    }
+
+    /**
+     * @return the extra contexts required for this node to apply
+     * @since 2.13
+     */
+    ContextSet getContexts();
 
     /**
      * Converts this node into a serialized form
+     *
      * @return a serialized node string
      */
     String toSerializedNode();
@@ -213,6 +267,7 @@ public interface Node extends Map.Entry<String, Boolean> {
 
     /**
      * Gets the level of this wildcard, higher is more specific
+     *
      * @return the wildcard level
      * @throws IllegalStateException if this is not a wildcard
      */
@@ -225,6 +280,7 @@ public interface Node extends Map.Entry<String, Boolean> {
 
     /**
      * Gets the meta value from this node
+     *
      * @return the meta value
      * @throws IllegalStateException if this node is not a meta node
      */
@@ -237,6 +293,7 @@ public interface Node extends Map.Entry<String, Boolean> {
 
     /**
      * Gets the prefix value from this node
+     *
      * @return the prefix value
      * @throws IllegalStateException if this node is a not a prefix node
      */
@@ -249,6 +306,7 @@ public interface Node extends Map.Entry<String, Boolean> {
 
     /**
      * Gets the suffix value from this node
+     *
      * @return the suffix value
      * @throws IllegalStateException if this node is a not a suffix node
      */
@@ -256,6 +314,7 @@ public interface Node extends Map.Entry<String, Boolean> {
 
     /**
      * Checks if this Node is equal to another node
+     *
      * @param obj the other node
      * @return true if this node is equal to the other provided
      * @see #equalsIgnoringValue(Node) for a less strict implementation of this method
@@ -264,6 +323,7 @@ public interface Node extends Map.Entry<String, Boolean> {
 
     /**
      * Similar to {@link Node#equals(Object)}, except doesn't take note of the value
+     *
      * @param other the other node
      * @return true if the two nodes are almost equal
      */
@@ -271,6 +331,7 @@ public interface Node extends Map.Entry<String, Boolean> {
 
     /**
      * Similar to {@link Node#equals(Object)}, except doesn't take note of the expiry time or value
+     *
      * @param other the other node
      * @return true if the two nodes are almost equal
      */
@@ -278,6 +339,7 @@ public interface Node extends Map.Entry<String, Boolean> {
 
     /**
      * Similar to {@link Node#equals(Object)}, except doesn't take note of the value or if the node is temporary
+     *
      * @param other the other node
      * @return true if the two nodes are almost equal
      * @since 2.8
@@ -289,6 +351,7 @@ public interface Node extends Map.Entry<String, Boolean> {
      */
     interface Builder {
         Builder setNegated(boolean negated);
+
         Builder setValue(boolean value);
 
         /**
@@ -298,11 +361,21 @@ public interface Node extends Map.Entry<String, Boolean> {
         Builder setOverride(boolean override);
 
         Builder setExpiry(long expireAt);
+
         Builder setWorld(String world);
+
         Builder setServer(String server) throws IllegalArgumentException;
+
         Builder withExtraContext(String key, String value);
+
         Builder withExtraContext(Map<String, String> map);
+
+        Builder withExtraContext(Set<Map.Entry<String, String>> context);
+
         Builder withExtraContext(Map.Entry<String, String> entry);
+
+        Builder withExtraContext(ContextSet set);
+
         Node build();
     }
 

api/src/main/java/me/lucko/luckperms/api/PermissionHolder.java

@@ -37,13 +37,14 @@ import java.util.SortedSet;
 public interface PermissionHolder {
 
     /**
-     * @return the identifier for this object. either a uuid string or name
-     * However, you should really just use {@link User#getUuid()}, {@link User#getName()} or {@link Group#getName()}
+     * @return the identifier for this object. either a uuid string or name However, you should really just use {@link
+     * User#getUuid()}, {@link User#getName()} or {@link Group#getName()}
      */
     String getObjectName();
 
     /**
      * Gets an immutable Set of the objects permission nodes
+     *
      * @return an immutable set of permissions in priority order
      * @since 2.6
      */
@@ -51,6 +52,7 @@ public interface PermissionHolder {
 
     /**
      * Similar to {@link #getPermissions()}, except excluding transient permissions
+     *
      * @return a set of nodes
      * @since 2.6
      */
@@ -58,6 +60,7 @@ public interface PermissionHolder {
 
     /**
      * Similar to {@link #getPermissions()}, except excluding non-transient permissions
+     *
      * @return a set of nodes
      * @since 2.6
      */
@@ -66,6 +69,7 @@ public interface PermissionHolder {
 
     /**
      * Gets an immutable set of the nodes that this object has and inherits
+     *
      * @return an immutable set of permissions
      * @since 2.6
      * @deprecated in favour of {@link #getAllNodes(Contexts)}
@@ -78,6 +82,7 @@ public interface PermissionHolder {
      * Unlike {@link #getAllNodesFiltered(Contexts)}, this method will not filter individual nodes. The context is only
      * used to determine which groups should apply.
      * Nodes are sorted into priority order.
+     *
      * @param contexts the context for the lookup,
      * @return a mutable sorted set of permissions
      * @throws NullPointerException if the context is null
@@ -89,6 +94,7 @@ public interface PermissionHolder {
      * Gets a mutable set of the nodes that is objects has and inherits, filtered by context.
      * Unlike {@link #getAllNodes(Contexts)}, this method WILL filter individual nodes, and only return ones that fully
      * meet the context provided.
+     *
      * @param contexts the context for the lookup
      * @return a mutable set of permissions
      * @throws NullPointerException if the context is null
@@ -98,6 +104,7 @@ public interface PermissionHolder {
 
     /**
      * Gets an immutable Map of the objects permission nodes
+     *
      * @return an immutable map of permissions
      * @deprecated in favour of {@link #getPermissions()}
      */
@@ -106,6 +113,7 @@ public interface PermissionHolder {
 
     /**
      * Checks to see if the object has a certain permission
+     *
      * @param node the node to check for
      * @return a Tristate for the holders permission status for the node
      * @throws NullPointerException if the node is null
@@ -115,6 +123,7 @@ public interface PermissionHolder {
 
     /**
      * Checks to see if the object has a certain permission
+     *
      * @param node the node to check for
      * @return a Tristate for the holders permission status for the node
      * @throws NullPointerException if the node is null
@@ -124,75 +133,82 @@ public interface PermissionHolder {
 
     /**
      * Checks to see if the object has a certain permission
+     *
      * @param node The permission node
-     * @param b If the node is true/false(negated)
+     * @param b    If the node is true/false(negated)
      * @return true if the object has the permission
-     * @throws NullPointerException if the node is null
+     * @throws NullPointerException     if the node is null
      * @throws IllegalArgumentException if the node is invalid
      */
     boolean hasPermission(String node, boolean b);
 
     /**
      * Checks to see the the object has a permission on a certain server
-     * @param node The permission node
-     * @param b If the node is true/false(negated)
+     *
+     * @param node   The permission node
+     * @param b      If the node is true/false(negated)
      * @param server The server
      * @return true if the object has the permission
-     * @throws NullPointerException if the node or server is null
+     * @throws NullPointerException     if the node or server is null
      * @throws IllegalArgumentException if the node or server is invalid
      */
     boolean hasPermission(String node, boolean b, String server);
 
     /**
      * Checks to see the the object has a permission on a certain server and world
-     * @param node The permission node
-     * @param b If the node is true/false(negated)
+     *
+     * @param node   The permission node
+     * @param b      If the node is true/false(negated)
      * @param server The server
-     * @param world The world
+     * @param world  The world
      * @return true if the object has the permission
-     * @throws NullPointerException if the node, server or world is null
+     * @throws NullPointerException     if the node, server or world is null
      * @throws IllegalArgumentException if the node, server or world is invalid
      */
     boolean hasPermission(String node, boolean b, String server, String world);
 
     /**
      * Checks to see the the object has a permission
-     * @param node The permission node
-     * @param b If the node is true/false(negated)
+     *
+     * @param node      The permission node
+     * @param b         If the node is true/false(negated)
      * @param temporary if the permission is temporary
      * @return true if the object has the permission
-     * @throws NullPointerException if the node is null
+     * @throws NullPointerException     if the node is null
      * @throws IllegalArgumentException if the node is invalid
      */
     boolean hasPermission(String node, boolean b, boolean temporary);
 
     /**
      * Checks to see the the object has a permission on a certain server
-     * @param node The permission node
-     * @param b If the node is true/false(negated)
-     * @param server The server to check on
+     *
+     * @param node      The permission node
+     * @param b         If the node is true/false(negated)
+     * @param server    The server to check on
      * @param temporary if the permission is temporary
      * @return true if the object has the permission
-     * @throws NullPointerException if the node or server is null
+     * @throws NullPointerException     if the node or server is null
      * @throws IllegalArgumentException if the node or server is invalid
      */
     boolean hasPermission(String node, boolean b, String server, boolean temporary);
 
     /**
      * Checks to see the the object has a permission on a certain server and world
-     * @param node The permission node
-     * @param b If the node is true/false(negated)
-     * @param server The server to check on
-     * @param world The world to check on
+     *
+     * @param node      The permission node
+     * @param b         If the node is true/false(negated)
+     * @param server    The server to check on
+     * @param world     The world to check on
      * @param temporary if the permission is temporary
      * @return true if the object has the permission
-     * @throws NullPointerException if the node, server or world is null
+     * @throws NullPointerException     if the node, server or world is null
      * @throws IllegalArgumentException if the node, server or world is invalid
      */
     boolean hasPermission(String node, boolean b, String server, String world, boolean temporary);
 
     /**
      * Cheks to see if the object inherits a certain permission
+     *
      * @param node the node to check for
      * @return a Tristate for the holders inheritance status for the node
      * @throws NullPointerException if the node is null
@@ -202,78 +218,85 @@ public interface PermissionHolder {
 
     /**
      * Checks to see if the object inherits a certain permission
+     *
      * @param node The permission node
-     * @param b If the node is true/false(negated)
+     * @param b    If the node is true/false(negated)
      * @return true if the object inherits the permission
-     * @throws NullPointerException if the node is null
+     * @throws NullPointerException     if the node is null
      * @throws IllegalArgumentException if the node is invalid
      */
     boolean inheritsPermission(String node, boolean b);
 
     /**
      * Checks to see the the object inherits a permission on a certain server
-     * @param node The permission node
-     * @param b If the node is true/false(negated)
+     *
+     * @param node   The permission node
+     * @param b      If the node is true/false(negated)
      * @param server The server
      * @return true if the object inherits the permission
-     * @throws NullPointerException if the node or server is null
+     * @throws NullPointerException     if the node or server is null
      * @throws IllegalArgumentException if the node or server is invalid
      */
     boolean inheritsPermission(String node, boolean b, String server);
 
     /**
      * Checks to see the the object inherits a permission on a certain server and world
-     * @param node The permission node
-     * @param b If the node is true/false(negated)
+     *
+     * @param node   The permission node
+     * @param b      If the node is true/false(negated)
      * @param server The server
-     * @param world The world
+     * @param world  The world
      * @return true if the object inherits the permission
-     * @throws NullPointerException if the node, server or world is null
+     * @throws NullPointerException     if the node, server or world is null
      * @throws IllegalArgumentException if the node server or world is invalid
      */
     boolean inheritsPermission(String node, boolean b, String server, String world);
 
     /**
      * Checks to see if the object inherits a permission
-     * @param node The permission node
-     * @param b If the node is true/false(negated)
+     *
+     * @param node      The permission node
+     * @param b         If the node is true/false(negated)
      * @param temporary if the permission is temporary
      * @return true if the object inherits the permission
-     * @throws NullPointerException if the node is null
+     * @throws NullPointerException     if the node is null
      * @throws IllegalArgumentException if the node is invalid
      */
     boolean inheritsPermission(String node, boolean b, boolean temporary);
 
     /**
      * Checks to see if the object inherits a permission on a certain server
-     * @param node The permission node
-     * @param b If the node is true/false(negated)
-     * @param server The server
+     *
+     * @param node      The permission node
+     * @param b         If the node is true/false(negated)
+     * @param server    The server
      * @param temporary if the permission is temporary
      * @return true if the object inherits the permission
-     * @throws NullPointerException if the node or server is null
+     * @throws NullPointerException     if the node or server is null
      * @throws IllegalArgumentException if the node or server is invalid
      */
     boolean inheritsPermission(String node, boolean b, String server, boolean temporary);
 
     /**
      * Checks to see if the object inherits a permission on a certain server and world
-     * @param node The permission node
-     * @param b If the node is true/false(negated)
-     * @param server The server
-     * @param world The world
+     *
+     * @param node      The permission node
+     * @param b         If the node is true/false(negated)
+     * @param server    The server
+     * @param world     The world
      * @param temporary if the permission is temporary
      * @return true if the object inherits the permission
-     * @throws NullPointerException if the node, server or world is null
+     * @throws NullPointerException     if the node, server or world is null
      * @throws IllegalArgumentException if the node, server or world if invalid
      */
     boolean inheritsPermission(String node, boolean b, String server, String world, boolean temporary);
 
     /**
      * Sets a permission for the object
+     *
      * @param node The node to be set
      * @throws ObjectAlreadyHasException if the object already has the permission
-     * @throws NullPointerException if the node is null
+     * @throws NullPointerException      if the node is null
      * @since 2.6
      */
     void setPermission(Node node) throws ObjectAlreadyHasException;
@@ -289,20 +312,22 @@ public interface PermissionHolder {
      * want it to persist, and have to worry about removing it when they log out.
      *
      * <p> For unsetting a transient permission, see {@link #unsetTransientPermission(Node)}
+     *
      * @param node The node to be set
      * @throws ObjectAlreadyHasException if the object already has the permission
-     * @throws NullPointerException if the node is null
+     * @throws NullPointerException      if the node is null
      * @since 2.6
      */
     void setTransientPermission(Node node) throws ObjectAlreadyHasException;
 
     /**
      * Sets a permission for the object
-     * @param node The node to be set
+     *
+     * @param node  The node to be set
      * @param value What to set the node to - true/false(negated)
      * @throws ObjectAlreadyHasException if the object already has the permission
-     * @throws NullPointerException if the node is null
-     * @throws IllegalArgumentException if the node is invalid
+     * @throws NullPointerException      if the node is null
+     * @throws IllegalArgumentException  if the node is invalid
      * @deprecated in favour of {@link #setPermission(Node)}
      */
     @Deprecated
@@ -310,12 +335,13 @@ public interface PermissionHolder {
 
     /**
      * Sets a permission for the object on a specific server
-     * @param node The node to set
-     * @param value What to set the node to - true/false(negated)
+     *
+     * @param node   The node to set
+     * @param value  What to set the node to - true/false(negated)
      * @param server The server to set the permission on
      * @throws ObjectAlreadyHasException if the object already has the permission
-     * @throws NullPointerException if the node or server is null
-     * @throws IllegalArgumentException if the node or server is invalid
+     * @throws NullPointerException      if the node or server is null
+     * @throws IllegalArgumentException  if the node or server is invalid
      * @deprecated in favour of {@link #setPermission(Node)}
      */
     @Deprecated
@@ -323,13 +349,14 @@ public interface PermissionHolder {
 
     /**
      * Sets a permission for the object on a specific server and world
-     * @param node The node to set
-     * @param value What to set the node to - true/false(negated)
+     *
+     * @param node   The node to set
+     * @param value  What to set the node to - true/false(negated)
      * @param server The server to set the permission on
-     * @param world The world to set the permission on
+     * @param world  The world to set the permission on
      * @throws ObjectAlreadyHasException if the object already has the permission
-     * @throws NullPointerException if the node, server or world is null
-     * @throws IllegalArgumentException if the node, server or world is invalid
+     * @throws NullPointerException      if the node, server or world is null
+     * @throws IllegalArgumentException  if the node, server or world is invalid
      * @deprecated in favour of {@link #setPermission(Node)}
      */
     @Deprecated
@@ -337,12 +364,13 @@ public interface PermissionHolder {
 
     /**
      * Sets a temporary permission for the object
-     * @param node The node to set
-     * @param value What to set the node to - true/false(negated)
+     *
+     * @param node     The node to set
+     * @param value    What to set the node to - true/false(negated)
      * @param expireAt The time in unixtime when the permission will expire
      * @throws ObjectAlreadyHasException if the object already has the permission
-     * @throws NullPointerException if the node is null
-     * @throws IllegalArgumentException if the node is invalid or if the expiry time is in the past
+     * @throws NullPointerException      if the node is null
+     * @throws IllegalArgumentException  if the node is invalid or if the expiry time is in the past
      * @deprecated in favour of {@link #setPermission(Node)}
      */
     @Deprecated
@@ -350,13 +378,14 @@ public interface PermissionHolder {
 
     /**
      * Sets a temporary permission for the object on a specific server
-     * @param node The node to set
-     * @param value What to set the node to - true/false(negated)
-     * @param server The server to set the permission on
+     *
+     * @param node     The node to set
+     * @param value    What to set the node to - true/false(negated)
+     * @param server   The server to set the permission on
      * @param expireAt The time in unixtime when the permission will expire
      * @throws ObjectAlreadyHasException if the object already has the permission
-     * @throws NullPointerException if the node or server is null
-     * @throws IllegalArgumentException if the node/server is invalid or if the expiry time is in the past
+     * @throws NullPointerException      if the node or server is null
+     * @throws IllegalArgumentException  if the node/server is invalid or if the expiry time is in the past
      * @deprecated in favour of {@link #setPermission(Node)}
      */
     @Deprecated
@@ -364,14 +393,15 @@ public interface PermissionHolder {
 
     /**
      * Sets a temporary permission for the object on a specific server and world
-     * @param node The node to set
-     * @param value What to set the node to - true/false(negated)
-     * @param server The server to set the permission on
-     * @param world The world to set the permission on
+     *
+     * @param node     The node to set
+     * @param value    What to set the node to - true/false(negated)
+     * @param server   The server to set the permission on
+     * @param world    The world to set the permission on
      * @param expireAt The time in unixtime when the permission will expire
      * @throws ObjectAlreadyHasException if the object already has the permission
-     * @throws NullPointerException if the node, server or world is null
-     * @throws IllegalArgumentException if the node/server/world is invalid, or if the expiry time is in the past
+     * @throws NullPointerException      if the node, server or world is null
+     * @throws IllegalArgumentException  if the node/server/world is invalid, or if the expiry time is in the past
      * @deprecated in favour of {@link #setPermission(Node)}
      */
     @Deprecated
@@ -379,6 +409,7 @@ public interface PermissionHolder {
 
     /**
      * Unsets a permission for the object
+     *
      * @param node The node to be unset
      * @throws ObjectLacksException if the node wasn't already set
      * @throws NullPointerException if the node is null
@@ -388,6 +419,7 @@ public interface PermissionHolder {
 
     /**
      * Unsets a transient permission for the object
+     *
      * @param node The node to be unset
      * @throws ObjectLacksException if the node wasn't already set
      * @throws NullPointerException if the node is null
@@ -397,10 +429,11 @@ public interface PermissionHolder {
 
     /**
      * Unsets a permission for the object
-     * @param node The node to be unset
+     *
+     * @param node      The node to be unset
      * @param temporary if the permission being removed is temporary
-     * @throws ObjectLacksException if the node wasn't already set
-     * @throws NullPointerException if the node is null
+     * @throws ObjectLacksException     if the node wasn't already set
+     * @throws NullPointerException     if the node is null
      * @throws IllegalArgumentException if the node is invalid
      * @deprecated in favour of {@link #unsetPermission(Node)}
      */
@@ -409,9 +442,10 @@ public interface PermissionHolder {
 
     /**
      * Unsets a permission for the object
+     *
      * @param node The node to be unset
-     * @throws ObjectLacksException if the node wasn't already set
-     * @throws NullPointerException if the node is null
+     * @throws ObjectLacksException     if the node wasn't already set
+     * @throws NullPointerException     if the node is null
      * @throws IllegalArgumentException if the node is invalid
      * @deprecated in favour of {@link #unsetPermission(Node)}
      */
@@ -420,10 +454,11 @@ public interface PermissionHolder {
 
     /**
      * Unsets a permission for the object on a specific server
-     * @param node The node to be unset
+     *
+     * @param node   The node to be unset
      * @param server The server to unset the node on
-     * @throws ObjectLacksException if the node wasn't already set
-     * @throws NullPointerException if the node or server is null
+     * @throws ObjectLacksException     if the node wasn't already set
+     * @throws NullPointerException     if the node or server is null
      * @throws IllegalArgumentException if the node or server is invalid
      * @deprecated in favour of {@link #unsetPermission(Node)}
      */
@@ -432,11 +467,12 @@ public interface PermissionHolder {
 
     /**
      * Unsets a permission for the object on a specific server and world
-     * @param node The node to be unset
+     *
+     * @param node   The node to be unset
      * @param server The server to unset the node on
-     * @param world The world to unset the node on
-     * @throws ObjectLacksException if the node wasn't already set
-     * @throws NullPointerException if the node, server or world is null
+     * @param world  The world to unset the node on
+     * @throws ObjectLacksException     if the node wasn't already set
+     * @throws NullPointerException     if the node, server or world is null
      * @throws IllegalArgumentException if the node, server or world is invalid
      * @deprecated in favour of {@link #unsetPermission(Node)}
      */
@@ -445,11 +481,12 @@ public interface PermissionHolder {
 
     /**
      * Unsets a permission for the object on a specific server
-     * @param node The node to be unset
-     * @param server The server to unset the node on
+     *
+     * @param node      The node to be unset
+     * @param server    The server to unset the node on
      * @param temporary if the permission being unset is temporary
-     * @throws ObjectLacksException if the node wasn't already set
-     * @throws NullPointerException if the node or server is null
+     * @throws ObjectLacksException     if the node wasn't already set
+     * @throws NullPointerException     if the node or server is null
      * @throws IllegalArgumentException if the node or server is invalid
      * @deprecated in favour of {@link #unsetPermission(Node)}
      */
@@ -458,12 +495,13 @@ public interface PermissionHolder {
 
     /**
      * Unsets a permission for the object on a specific server and world
-     * @param node The node to be unset
-     * @param server The server to unset the node on
-     * @param world The world to unset the node on
+     *
+     * @param node      The node to be unset
+     * @param server    The server to unset the node on
+     * @param world     The world to unset the node on
      * @param temporary if the permission being unset is temporary
-     * @throws ObjectLacksException if the node wasn't already set
-     * @throws NullPointerException if the node, server or world is null
+     * @throws ObjectLacksException     if the node wasn't already set
+     * @throws NullPointerException     if the node, server or world is null
      * @throws IllegalArgumentException if the node, server or world is invalid
      * @deprecated in favour of {@link #unsetPermission(Node)}
      */
@@ -472,10 +510,11 @@ public interface PermissionHolder {
 
     /**
      * Gets the permissions and inherited permissions that apply to a specific server and world
-     * @param server The server to get nodes for
-     * @param world The world to get nodes for
+     *
+     * @param server         The server to get nodes for
+     * @param world          The world to get nodes for
      * @param excludedGroups Groups that shouldn't be inherited (to prevent circular inheritance issues)
-     * @param possibleNodes A list of possible permission nodes for wildcard permission handling
+     * @param possibleNodes  A list of possible permission nodes for wildcard permission handling
      * @return a {@link Map} of the permissions
      * @deprecated in favour of {@link #getPermissions(String, String, Map, boolean, List, boolean)}
      */
@@ -484,8 +523,9 @@ public interface PermissionHolder {
 
     /**
      * Gets the permissions and inherited permissions that apply to a specific server and world
-     * @param server The server to get nodes for
-     * @param world The world to get nodes for
+     *
+     * @param server         The server to get nodes for
+     * @param world          The world to get nodes for
      * @param excludedGroups Groups that shouldn't be inherited (to prevent circular inheritance issues)
      * @return a {@link Map} of the permissions
      * @deprecated in favour of {@link #getPermissions(String, String, Map, boolean, List, boolean)}
@@ -495,9 +535,10 @@ public interface PermissionHolder {
 
     /**
      * Gets the permissions and inherited permissions that apply to a specific server
-     * @param server The server to get nodes for
+     *
+     * @param server         The server to get nodes for
      * @param excludedGroups Groups that shouldn't be inherited (to prevent circular inheritance issues)
-     * @param possibleNodes A list of possible permission nodes for wildcard permission handling
+     * @param possibleNodes  A list of possible permission nodes for wildcard permission handling
      * @return a {@link Map} of the permissions
      * @deprecated in favour of {@link #getPermissions(String, String, Map, boolean, List, boolean)}
      */
@@ -506,7 +547,8 @@ public interface PermissionHolder {
 
     /**
      * Gets the permissions and inherited permissions that apply to a specific server
-     * @param server The server to get nodes for
+     *
+     * @param server         The server to get nodes for
      * @param excludedGroups Groups that shouldn't be inherited (to prevent circular inheritance issues)
      * @return a {@link Map} of the permissions
      * @deprecated in favour of {@link #getPermissions(String, String, Map, boolean, List, boolean)}
@@ -516,12 +558,13 @@ public interface PermissionHolder {
 
     /**
      * Convert the holders nodes into a Map of permissions to be applied on the platform
-     * @param server the server
-     * @param world the world
-     * @param extraContext any extra context to filter by
+     *
+     * @param server        the server
+     * @param world         the world
+     * @param extraContext  any extra context to filter by
      * @param includeGlobal whether to include global nodes
      * @param possibleNodes a list of possible permissions for resolving wildcards
-     * @param applyGroups if inherited group permissions should be included
+     * @param applyGroups   if inherited group permissions should be included
      * @return a map of permissions
      * @since 2.6
      * @deprecated in favour of {@link #getAllNodesFiltered(Contexts)}
@@ -531,6 +574,7 @@ public interface PermissionHolder {
 
     /**
      * Processes the nodes and returns the temporary ones.
+     *
      * @return a map of temporary nodes
      * @deprecated in favour of {@link #getTemporaryPermissionNodes()}
      */
@@ -539,6 +583,7 @@ public interface PermissionHolder {
 
     /**
      * Processes the nodes and returns the temporary ones.
+     *
      * @return a set of temporary nodes
      * @since 2.6
      */
@@ -546,6 +591,7 @@ public interface PermissionHolder {
 
     /**
      * Processes the nodes and returns the non-temporary ones.
+     *
      * @return a map of permanent nodes
      * @deprecated in favour of {@link #getPermanentPermissionNodes()}
      */
@@ -554,6 +600,7 @@ public interface PermissionHolder {
 
     /**
      * Processes the nodes and returns the non-temporary ones.
+     *
      * @return a set of permanent nodes
      * @since 2.6
      */

api/src/main/java/me/lucko/luckperms/api/PlatformType.java

@@ -24,6 +24,7 @@ package me.lucko.luckperms.api;
 
 /**
  * Represents the platform type that LuckPerms is running on
+ *
  * @since 2.7
  */
 public enum PlatformType {

api/src/main/java/me/lucko/luckperms/api/Storage.java

@@ -0,0 +1,242 @@
+/*
+ * 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.api;
+
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Executor;
+import java.util.function.Consumer;
+
+/**
+ * Interface for the internal Storage instance
+ *
+ * <p>All methods return {@link CompletableFuture}s, which will be populated with the result once the data has been
+ * loaded asynchronously. Care should be taken when using the methods to ensure that the main server thread is not
+ * blocked.
+ *
+ * <p>Methods such as {@link CompletableFuture#get()} and equivalent should <strong>not</strong> be called on the main
+ * server thread. If you need to use the result of these operations on the main server thread, please register a
+ * callback using {@link CompletableFuture#thenAcceptAsync(Consumer, Executor)} and {@link #getSyncExecutor()}.
+ *
+ * @since 2.14
+ */
+public interface Storage {
+
+    /**
+     * Get the name of the storage implementation.
+     *
+     * @return the name of the implementation
+     */
+    String getName();
+
+    /**
+     * Return whether the storage instance is allowing logins on the platform.
+     *
+     * @return true if logins are enabled
+     */
+    boolean isAcceptingLogins();
+
+    /**
+     * Returns an executor which will run all passed runnables on the main server thread.
+     *
+     * @return an executor instance
+     */
+    Executor getSyncExecutor();
+
+    /**
+     * Returns an executor which will run all passed runnables asynchronously using the platforms scheduler and thread
+     * pools.
+     *
+     * @return an executor instance
+     */
+    Executor getAsyncExecutor();
+
+    /**
+     * Saves an action to storage
+     *
+     * @param entry the log entry to be saved
+     * @return true if the operation completed successfully.
+     * @throws NullPointerException if entry is null
+     */
+    CompletableFuture<Boolean> logAction(LogEntry entry);
+
+    /**
+     * Loads and returns the entire log from storage
+     *
+     * @return a log instance, could be null if loading failed
+     */
+    CompletableFuture<Log> getLog();
+
+    /**
+     * Loads a user's data from the main storage into the plugins local storage.
+     *
+     * @param uuid     the uuid of the user to load
+     * @param username the users username. (if you want to specify <code>null</code> here, just input "null" as a
+     *                 string.)
+     * @return if the operation completed successfully
+     * @throws NullPointerException if uuid or username is null
+     */
+    CompletableFuture<Boolean> loadUser(UUID uuid, String username);
+
+    /**
+     * Saves a user object back to storage. You should call this after you make any changes to a user.
+     *
+     * @param user the user to save
+     * @return true if the operation completed successfully.
+     * @throws NullPointerException  if user is null
+     * @throws IllegalStateException if the user instance was not obtained from LuckPerms.
+     */
+    CompletableFuture<Boolean> saveUser(User user);
+
+    /**
+     * Removes users from the main storage who are "default". This is called every time the plugin loads.
+     *
+     * @return true if the operation completed successfully
+     */
+    CompletableFuture<Boolean> cleanupUsers();
+
+    /**
+     * Gets a set all "unique" user UUIDs.
+     * "Unique" meaning the user isn't just a member of the "default" group.
+     *
+     * @return a set of uuids, or null if the operation failed.
+     */
+    CompletableFuture<Set<UUID>> getUniqueUsers();
+
+    /**
+     * Creates and loads a group into the plugins local storage
+     *
+     * @param name the name of the group
+     * @return true if the operation completed successfully
+     * @throws NullPointerException     if name is null
+     * @throws IllegalArgumentException if the name is invalid
+     */
+    CompletableFuture<Boolean> createAndLoadGroup(String name);
+
+    /**
+     * Loads a group into the plugins local storage.
+     *
+     * @param name the name of the group
+     * @return true if the operation completed successfully
+     * @throws NullPointerException     if name is null
+     * @throws IllegalArgumentException if the name is invalid
+     */
+    CompletableFuture<Boolean> loadGroup(String name);
+
+    /**
+     * Loads all groups from the storage into memory
+     *
+     * @return true if the operation completed successfully.
+     */
+    CompletableFuture<Boolean> loadAllGroups();
+
+    /**
+     * Saves a group back to storage. You should call this after you make any changes to a group.
+     *
+     * @param group the group to save
+     * @return true if the operation completed successfully.
+     * @throws NullPointerException  if group is null
+     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
+     */
+    CompletableFuture<Boolean> saveGroup(Group group);
+
+    /**
+     * Permanently deletes a group from storage.
+     *
+     * @param group the group to delete
+     * @return true if the operation completed successfully.
+     * @throws NullPointerException  if group is null
+     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
+     */
+    CompletableFuture<Boolean> deleteGroup(Group group);
+
+    /**
+     * Creates and loads a track into the plugins local storage
+     *
+     * @param name the name of the track
+     * @return true if the operation completed successfully
+     * @throws NullPointerException     if name is null
+     * @throws IllegalArgumentException if the name is invalid
+     */
+    CompletableFuture<Boolean> createAndLoadTrack(String name);
+
+    /**
+     * Loads a track into the plugins local storage.
+     *
+     * @param name the name of the track
+     * @return true if the operation completed successfully
+     * @throws NullPointerException     if name is null
+     * @throws IllegalArgumentException if the name is invalid
+     */
+    CompletableFuture<Boolean> loadTrack(String name);
+
+    /**
+     * Loads all tracks from the storage into memory
+     *
+     * @return true if the operation completed successfully.
+     */
+    CompletableFuture<Boolean> loadAllTracks();
+
+    /**
+     * Saves a track back to storage. You should call this after you make any changes to a track.
+     *
+     * @param track the track to save
+     * @return true if the operation completed successfully.
+     * @throws NullPointerException  if track is null
+     * @throws IllegalStateException if the track instance was not obtained from LuckPerms.
+     */
+    CompletableFuture<Boolean> saveTrack(Track track);
+
+    /**
+     * Permanently deletes a track from storage
+     *
+     * @param track the track to delete
+     * @return true if the operation completed successfully.
+     * @throws NullPointerException  if track is null
+     * @throws IllegalStateException if the track instance was not obtained from LuckPerms.
+     */
+    CompletableFuture<Boolean> deleteTrack(Track track);
+
+    /**
+     * Saves UUID caching data to the global cache
+     *
+     * @param username the users username
+     * @param uuid     the users mojang unique id
+     * @return true if the operation completed successfully.
+     * @throws NullPointerException     if either parameters are null
+     * @throws IllegalArgumentException if the username is invalid
+     */
+    CompletableFuture<Boolean> saveUUIDData(String username, UUID uuid);
+
+    /**
+     * Gets a UUID from a username
+     *
+     * @param username the corresponding username
+     * @return a uuid object, could be null
+     * @throws NullPointerException     if either parameters are null
+     * @throws IllegalArgumentException if the username is invalid
+     */
+    CompletableFuture<UUID> getUUID(String username);
+
+}

api/src/main/java/me/lucko/luckperms/api/Track.java

@@ -41,67 +41,75 @@ public interface Track {
     /**
      * Gets an ordered list of the groups on this track
      * Index 0 is the first/lowest group in (or start of) the track
+     *
      * @return an ordered {@link List} of the groups on this track
      */
     List<String> getGroups();
 
     /**
      * Gets the number of groups on this track
+     *
      * @return the number of groups on this track
      */
     int getSize();
 
     /**
      * Gets the next group on the track, after the one provided
+     *
      * @param current the group before the group being requested
      * @return the group name, or null if the end of the track has been reached
-     * @throws ObjectLacksException if the track does not contain the group given
-     * @throws NullPointerException if the group is null
+     * @throws ObjectLacksException  if the track does not contain the group given
+     * @throws NullPointerException  if the group is null
      * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
      */
     String getNext(Group current) throws ObjectLacksException;
 
     /**
      * Gets the previous group on the track, before the one provided
+     *
      * @param current the group after the group being requested
      * @return the group name, or null if the start of the track has been reached
-     * @throws ObjectLacksException if the track does not contain the group given
-     * @throws NullPointerException if the group is null
+     * @throws ObjectLacksException  if the track does not contain the group given
+     * @throws NullPointerException  if the group is null
      * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
      */
     String getPrevious(Group current) throws ObjectLacksException;
 
     /**
      * Appends a group to the end of this track
+     *
      * @param group the group to append
      * @throws ObjectAlreadyHasException if the group is already on this track somewhere
-     * @throws NullPointerException if the group is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
+     * @throws NullPointerException      if the group is null
+     * @throws IllegalStateException     if the group instance was not obtained from LuckPerms.
      */
     void appendGroup(Group group) throws ObjectAlreadyHasException;
 
     /**
      * Inserts a group at a certain position on this track
-     * @param group the group to be inserted
+     *
+     * @param group    the group to be inserted
      * @param position the index position (a value of 0 inserts at the start)
      * @throws ObjectAlreadyHasException if the group is already on this track somewhere
      * @throws IndexOutOfBoundsException if the position is less than 0 or greater than the size of the track
-     * @throws NullPointerException if the group is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
+     * @throws NullPointerException      if the group is null
+     * @throws IllegalStateException     if the group instance was not obtained from LuckPerms.
      */
     void insertGroup(Group group, int position) throws ObjectAlreadyHasException, IndexOutOfBoundsException;
 
     /**
      * Removes a group from this track
+     *
      * @param group the group to remove
-     * @throws ObjectLacksException if the group is not on this track
-     * @throws NullPointerException if the group is null
+     * @throws ObjectLacksException  if the group is not on this track
+     * @throws NullPointerException  if the group is null
      * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
      */
     void removeGroup(Group group) throws ObjectLacksException;
 
     /**
      * Removes a group from this track
+     *
      * @param group the group to remove
      * @throws ObjectLacksException if the group is not on this track
      * @throws NullPointerException if the group is null
@@ -110,15 +118,17 @@ public interface Track {
 
     /**
      * Checks if a group features on this track
+     *
      * @param group the group to check
      * @return true if the group is on this track
-     * @throws NullPointerException if the group is null
+     * @throws NullPointerException  if the group is null
      * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
      */
     boolean containsGroup(Group group);
 
     /**
      * Checks if a group features on this track
+     *
      * @param group the group to check
      * @return true if the group is on this track
      * @throws NullPointerException if the group is null

api/src/main/java/me/lucko/luckperms/api/Tristate.java

@@ -31,6 +31,10 @@ public enum Tristate {
     FALSE(false),
     UNDEFINED(false);
 
+    public static Tristate fromBoolean(boolean b) {
+        return b ? TRUE : FALSE;
+    }
+
     private final boolean booleanValue;
 
     Tristate(boolean booleanValue) {
@@ -40,8 +44,4 @@ public enum Tristate {
     public boolean asBoolean() {
         return booleanValue;
     }
-
-    public static Tristate fromBoolean(boolean b) {
-        return b ? TRUE : FALSE;
-    }
 }

api/src/main/java/me/lucko/luckperms/api/User.java

@@ -22,10 +22,12 @@
 
 package me.lucko.luckperms.api;
 
+import me.lucko.luckperms.api.caching.UserData;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
 
 import java.util.List;
+import java.util.Optional;
 import java.util.UUID;
 
 /**
@@ -46,16 +48,18 @@ public interface User extends PermissionHolder {
 
     /**
      * Gets the users primary group
+     *
      * @return the users primary group
      */
     String getPrimaryGroup();
 
     /**
      * Sets a users primary group
+     *
      * @param group the new primary group
      * @throws ObjectAlreadyHasException if the user already has this set as their primary group
-     * @throws IllegalStateException if the user is not a member of that group
-     * @throws NullPointerException if the group is null
+     * @throws IllegalStateException     if the user is not a member of that group
+     * @throws NullPointerException      if the group is null
      */
     void setPrimaryGroup(String group) throws ObjectAlreadyHasException;
 
@@ -64,8 +68,17 @@ public interface User extends PermissionHolder {
      */
     void refreshPermissions();
 
+    /**
+     * Gets the user's {@link UserData} cache, if they have one setup.
+     *
+     * @return an optional, possibly containing the user's cached lookup data.
+     * @since 2.13
+     */
+    Optional<UserData> getUserDataCache();
+
     /**
      * Check to see if the user is a member of a group
+     *
      * @param group The group to check membership of
      * @return true if the user is a member of the group
      * @throws NullPointerException if the group is null
@@ -74,156 +87,170 @@ public interface User extends PermissionHolder {
 
     /**
      * Check to see if a user is a member of a group on a specific server
-     * @param group The group to check membership of
+     *
+     * @param group  The group to check membership of
      * @param server The server to check on
      * @return true if the user is a member of the group
-     * @throws NullPointerException if the group or server is null
+     * @throws NullPointerException     if the group or server is null
      * @throws IllegalArgumentException if the server is invalid
      */
     boolean isInGroup(Group group, String server);
 
     /**
      * Check to see if a user is a member of a group on a specific server and world
-     * @param group The group to check membership of
+     *
+     * @param group  The group to check membership of
      * @param server The server to check on
-     * @param world The world to check on
+     * @param world  The world to check on
      * @return true if the user is a member of the group
-     * @throws NullPointerException if the group, server or world is null
+     * @throws NullPointerException     if the group, server or world is null
      * @throws IllegalArgumentException if the server or world is invalid
      */
     boolean isInGroup(Group group, String server, String world);
 
     /**
      * Add a user to a group
+     *
      * @param group The group to add the user to
      * @throws ObjectAlreadyHasException if the user is already a member of the group
-     * @throws NullPointerException if the group is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
+     * @throws NullPointerException      if the group is null
+     * @throws IllegalStateException     if the group instance was not obtained from LuckPerms.
      */
     void addGroup(Group group) throws ObjectAlreadyHasException;
 
     /**
      * Add a user to a group on a specific server
-     * @param group The group to add the user to
+     *
+     * @param group  The group to add the user to
      * @param server The server to add the group on
      * @throws ObjectAlreadyHasException if the user is already a member of the group on that server
-     * @throws NullPointerException if the group or server is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
-     * @throws IllegalArgumentException if the server is invalid
+     * @throws NullPointerException      if the group or server is null
+     * @throws IllegalStateException     if the group instance was not obtained from LuckPerms.
+     * @throws IllegalArgumentException  if the server is invalid
      */
     void addGroup(Group group, String server) throws ObjectAlreadyHasException;
 
     /**
      * Add a user to a group on a specific server and world
-     * @param group The group to add the user to
+     *
+     * @param group  The group to add the user to
      * @param server The server to add the group on
-     * @param world The world to add the group on
+     * @param world  The world to add the group on
      * @throws ObjectAlreadyHasException if the user is already a member of the group on that server
-     * @throws NullPointerException if the group, server or world is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
-     * @throws IllegalArgumentException if the server or world is invalid
+     * @throws NullPointerException      if the group, server or world is null
+     * @throws IllegalStateException     if the group instance was not obtained from LuckPerms.
+     * @throws IllegalArgumentException  if the server or world is invalid
      */
     void addGroup(Group group, String server, String world) throws ObjectAlreadyHasException;
 
     /**
      * Add a user to a group temporarily on a specific server
-     * @param group The group to add the user to
+     *
+     * @param group    The group to add the user to
      * @param expireAt when the group should expire
      * @throws ObjectAlreadyHasException if the user is already a member of the group on that server
-     * @throws NullPointerException if the group is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
-     * @throws IllegalArgumentException if the expiry time is in the past
+     * @throws NullPointerException      if the group is null
+     * @throws IllegalStateException     if the group instance was not obtained from LuckPerms.
+     * @throws IllegalArgumentException  if the expiry time is in the past
      */
     void addGroup(Group group, long expireAt) throws ObjectAlreadyHasException;
 
     /**
      * Add a user to a group temporarily on a specific server
-     * @param group The group to add the user to
-     * @param server The server to add the group on
+     *
+     * @param group    The group to add the user to
+     * @param server   The server to add the group on
      * @param expireAt when the group should expire
      * @throws ObjectAlreadyHasException if the user is already a member of the group on that server
-     * @throws NullPointerException if the group or server is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
-     * @throws IllegalArgumentException if the expiry time is in the past or the server is invalid
+     * @throws NullPointerException      if the group or server is null
+     * @throws IllegalStateException     if the group instance was not obtained from LuckPerms.
+     * @throws IllegalArgumentException  if the expiry time is in the past or the server is invalid
      */
     void addGroup(Group group, String server, long expireAt) throws ObjectAlreadyHasException;
 
     /**
      * Add a user to a group temporarily on a specific server and world
-     * @param group The group to add the user to
-     * @param server The server to add the group on
-     * @param world The world to add the group on
+     *
+     * @param group    The group to add the user to
+     * @param server   The server to add the group on
+     * @param world    The world to add the group on
      * @param expireAt when the group should expire
      * @throws ObjectAlreadyHasException if the user is already a member of the group on that server
-     * @throws NullPointerException if the group, server or world is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
-     * @throws IllegalArgumentException if the expiry time is in the past or the server/world is invalid
+     * @throws NullPointerException      if the group, server or world is null
+     * @throws IllegalStateException     if the group instance was not obtained from LuckPerms.
+     * @throws IllegalArgumentException  if the expiry time is in the past or the server/world is invalid
      */
     void addGroup(Group group, String server, String world, long expireAt) throws ObjectAlreadyHasException;
 
     /**
      * Remove the user from a group
+     *
      * @param group the group to remove the user from
-     * @throws ObjectLacksException if the user isn't a member of the group
-     * @throws NullPointerException if the group is null
+     * @throws ObjectLacksException  if the user isn't a member of the group
+     * @throws NullPointerException  if the group is null
      * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
      */
     void removeGroup(Group group) throws ObjectLacksException;
 
     /**
      * Remove the user from a group
-     * @param group the group to remove the user from
+     *
+     * @param group     the group to remove the user from
      * @param temporary if the group being removed is temporary
-     * @throws ObjectLacksException if the user isn't a member of the group
-     * @throws NullPointerException if the group is null
+     * @throws ObjectLacksException  if the user isn't a member of the group
+     * @throws NullPointerException  if the group is null
      * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
      */
     void removeGroup(Group group, boolean temporary) throws ObjectLacksException;
 
     /**
      * Remove the user from a group on a specific server
-     * @param group The group to remove the user from
+     *
+     * @param group  The group to remove the user from
      * @param server The server to remove the group on
-     * @throws ObjectLacksException if the user isn't a member of the group
-     * @throws NullPointerException if the group or server is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
+     * @throws ObjectLacksException     if the user isn't a member of the group
+     * @throws NullPointerException     if the group or server is null
+     * @throws IllegalStateException    if the group instance was not obtained from LuckPerms.
      * @throws IllegalArgumentException if the server is invalid
      */
     void removeGroup(Group group, String server) throws ObjectLacksException;
 
     /**
      * Remove the user from a group on a specific server and world
-     * @param group The group to remove the user from
+     *
+     * @param group  The group to remove the user from
      * @param server The server to remove the group on
-     * @param world The world to remove the group on
-     * @throws ObjectLacksException if the user isn't a member of the group
-     * @throws NullPointerException if the group, server or world is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
+     * @param world  The world to remove the group on
+     * @throws ObjectLacksException     if the user isn't a member of the group
+     * @throws NullPointerException     if the group, server or world is null
+     * @throws IllegalStateException    if the group instance was not obtained from LuckPerms.
      * @throws IllegalArgumentException if the server or world is invalid
      */
     void removeGroup(Group group, String server, String world) throws ObjectLacksException;
 
     /**
      * Remove the user from a group on a specific server
-     * @param group The group to remove the user from
-     * @param server The server to remove the group on
+     *
+     * @param group     The group to remove the user from
+     * @param server    The server to remove the group on
      * @param temporary if the group being removed is temporary
-     * @throws ObjectLacksException if the user isn't a member of the group
-     * @throws NullPointerException if the group or server is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
+     * @throws ObjectLacksException     if the user isn't a member of the group
+     * @throws NullPointerException     if the group or server is null
+     * @throws IllegalStateException    if the group instance was not obtained from LuckPerms.
      * @throws IllegalArgumentException if the expiry time is in the past or the server is invalid
      */
     void removeGroup(Group group, String server, boolean temporary) throws ObjectLacksException;
 
     /**
      * Remove the user from a group on a specific server and world
-     * @param group The group to remove the user from
-     * @param server The server to remove the group on
-     * @param world The world to remove the group on
+     *
+     * @param group     The group to remove the user from
+     * @param server    The server to remove the group on
+     * @param world     The world to remove the group on
      * @param temporary if the group being removed is temporary
-     * @throws ObjectLacksException if the user isn't a member of the group
-     * @throws NullPointerException if the group, server or world is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
+     * @throws ObjectLacksException     if the user isn't a member of the group
+     * @throws NullPointerException     if the group, server or world is null
+     * @throws IllegalStateException    if the group instance was not obtained from LuckPerms.
      * @throws IllegalArgumentException if the expiry time is in the past or the server/world is invalid
      */
     void removeGroup(Group group, String server, String world, boolean temporary) throws ObjectLacksException;
@@ -235,25 +262,28 @@ public interface User extends PermissionHolder {
 
     /**
      * Get a {@link List} of all of the groups the user is a member of, on all servers
+     *
      * @return a {@link List} of group names
      */
     List<String> getGroupNames();
 
     /**
      * Get a {@link List} of the groups the user is a member of on a specific server
+     *
      * @param server the server to check
-     * @param world the world to check
+     * @param world  the world to check
      * @return a {@link List} of group names
-     * @throws NullPointerException if the server or world is null
+     * @throws NullPointerException     if the server or world is null
      * @throws IllegalArgumentException if the server or world is invalid
      */
     List<String> getLocalGroups(String server, String world);
 
     /**
      * Get a {@link List} of the groups the user is a member of on a specific server
+     *
      * @param server the server to check
      * @return a {@link List} of group names
-     * @throws NullPointerException if the server is null
+     * @throws NullPointerException     if the server is null
      * @throws IllegalArgumentException if the server is invalid
      */
     List<String> getLocalGroups(String server);

api/src/main/java/me/lucko/luckperms/api/UuidCache.java

@@ -27,13 +27,13 @@ import java.util.UUID;
 /**
  * A UUID cache for online users, between external Mojang UUIDs, and internal LuckPerms UUIDs.
  *
- * <p> This UuidCache is a means of allowing users to have the same internal UUID across a network of offline mode servers
- * or mixed offline mode and online mode servers. Platforms running in offline mode generate a random UUID for a user when
- * they first join the server, but this UUID will then not be consistent across the network. LuckPerms will instead check
- * the datastore cache, to get a UUID for a user that is consistent across an entire network.
+ * <p> This UuidCache is a means of allowing users to have the same internal UUID across a network of offline mode
+ * servers or mixed offline mode and online mode servers. Platforms running in offline mode generate a random UUID for a
+ * user when they first join the server, but this UUID will then not be consistent across the network. LuckPerms will
+ * instead check the datastore cache, to get a UUID for a user that is consistent across an entire network.
  *
- * <p> If you want to get a user object from the datastore using the api on a server in offline mode, you will need to use this cache,
- * OR use Datastore#getUUID, for users that are not online.
+ * <p> If you want to get a user object from the Storage using the api on a server in offline mode, you will need to use
+ * this cache, OR use Storage#getUUID, for users that are not online.
  *
  * <p> WARNING: THIS IS ONLY EFFECTIVE FOR ONLINE PLAYERS. USE THE DATASTORE METHODS FOR OFFLINE PLAYERS.
  */
@@ -42,6 +42,7 @@ public interface UuidCache {
 
     /**
      * Gets a users internal "LuckPerms" UUID, from the one given by the server.
+     *
      * @param external the UUID assigned by the server, through Player#getUniqueId or ProxiedPlayer#getUniqueId
      * @return the corresponding internal UUID
      */
@@ -49,6 +50,7 @@ public interface UuidCache {
 
     /**
      * Gets a users external, server assigned or Mojang assigned unique id, from the internal one used within LuckPerms.
+     *
      * @param internal the UUID used within LuckPerms, through User#getUuid
      * @return the corresponding external UUID
      */

api/src/main/java/me/lucko/luckperms/api/caching/MetaData.java

@@ -0,0 +1,72 @@
+/*
+ * 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.api.caching;
+
+import java.util.Map;
+import java.util.SortedMap;
+
+/**
+ * Holds cached Meta lookup data for a specific set of contexts
+ *
+ * @since 2.13
+ */
+public interface MetaData {
+
+    /**
+     * Gets an immutable copy of the meta this user has
+     *
+     * @return an immutable map of meta
+     */
+    Map<String, String> getMeta();
+
+    /**
+     * Gets an immutable sorted map of all of the prefixes the user has, whereby the first value is the highest priority
+     * prefix.
+     *
+     * @return a sorted map of prefixes
+     */
+    SortedMap<Integer, String> getPrefixes();
+
+    /**
+     * Gets an immutable sorted map of all of the suffixes the user has, whereby the first value is the highest priority
+     * suffix.
+     *
+     * @return a sorted map of suffixes
+     */
+    SortedMap<Integer, String> getSuffixes();
+
+    /**
+     * Gets the user's highest priority prefix, or null if the user has no prefixes
+     *
+     * @return a prefix string, or null
+     */
+    String getPrefix();
+
+    /**
+     * Gets the user's highest priority suffix, or null if the user has no suffixes
+     *
+     * @return a suffix string, or null
+     */
+    String getSuffix();
+
+}

api/src/main/java/me/lucko/luckperms/api/caching/PermissionData.java

@@ -0,0 +1,58 @@
+/*
+ * 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.api.caching;
+
+import me.lucko.luckperms.api.Tristate;
+
+import java.util.Map;
+
+/**
+ * Holds cached Permission lookup data for a specific set of contexts
+ *
+ * @since 2.13
+ */
+public interface PermissionData {
+
+    /**
+     * Gets a permission value for the given permission node
+     *
+     * @param permission the permission node
+     * @return a tristate result
+     * @throws NullPointerException if permission is null
+     */
+    Tristate getPermissionValue(String permission);
+
+    /**
+     * Invalidates the underlying permission calculator cache.
+     * Can be called to allow for an update in defaults.
+     */
+    void invalidateCache();
+
+    /**
+     * Gets an immutable copy of the permission map backing the permission calculator
+     *
+     * @return an immutable set of permissions
+     */
+    Map<String, Boolean> getImmutableBacking();
+
+}

api/src/main/java/me/lucko/luckperms/api/caching/UserData.java

@@ -0,0 +1,128 @@
+/*
+ * 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.api.caching;
+
+import me.lucko.luckperms.api.Contexts;
+
+import java.util.Set;
+
+/**
+ * Holds cached permission and meta lookup data for a {@link me.lucko.luckperms.api.User}.
+ *
+ * <p>Data is only likely to be available for online users. All calls will account for inheritance, as well as any
+ * default data provided by the platform. This calls are heavily cached and are therefore fast.
+ *
+ * @since 2.13
+ */
+public interface UserData {
+
+    /**
+     * Gets PermissionData from the cache, given a specified context.
+     * If the data is not cached, it is calculated. Therefore, this call could be costly.
+     *
+     * @param contexts the contexts to get the permission data in
+     * @return a permission data instance
+     * @throws NullPointerException if contexts is null
+     */
+    PermissionData getPermissionData(Contexts contexts);
+
+    /**
+     * Gets MetaData from the cache, given a specified context.
+     * If the data is not cached, it is calculated. Therefore, this call could be costly.
+     *
+     * @param contexts the contexts to get the permission data in
+     * @return a meta data instance
+     * @throws NullPointerException if contexts is null
+     */
+    MetaData getMetaData(Contexts contexts);
+
+    /**
+     * Calculates permission data, bypassing the cache.
+     *
+     * @param contexts the contexts to get permission data in
+     * @return a permission data instance
+     * @throws NullPointerException if contexts is null
+     */
+    PermissionData calculatePermissions(Contexts contexts);
+
+    /**
+     * Calculates meta data, bypassing the cache.
+     *
+     * @param contexts the contexts to get meta data in
+     * @return a meta data instance
+     * @throws NullPointerException if contexts is null
+     */
+    MetaData calculateMeta(Contexts contexts);
+
+    /**
+     * Calculates permission data and stores it in the cache. If there is already data cached for the given contexts,
+     * and if the resultant output is different, the cached value is updated.
+     *
+     * @param contexts the contexts to recalculate in.
+     * @throws NullPointerException if contexts is null
+     */
+    void recalculatePermissions(Contexts contexts);
+
+    /**
+     * Calculates meta data and stores it in the cache. If there is already data cached for the given contexts,
+     * and if the resultant output is different, the cached value is updated.
+     *
+     * @param contexts the contexts to recalculate in.
+     * @throws NullPointerException if contexts is null
+     */
+    void recalculateMeta(Contexts contexts);
+
+    /**
+     * Calls {@link #recalculatePermissions(Contexts)} for all current loaded contexts
+     */
+    void recalculatePermissions();
+
+    /**
+     * Calls {@link #recalculateMeta(Contexts)} for all current loaded contexts
+     */
+    void recalculateMeta();
+
+    /**
+     * Calls {@link #preCalculate(Contexts)} for the given contexts
+     *
+     * @param contexts a set of contexts
+     * @throws NullPointerException if contexts is null
+     */
+    void preCalculate(Set<Contexts> contexts);
+
+    /**
+     * Ensures that PermissionData and MetaData is cached for a context. If the cache does not contain any data for the
+     * context, it will be calculated and saved.
+     *
+     * @param contexts the contexts to pre-calculate for
+     * @throws NullPointerException if contexts is null
+     */
+    void preCalculate(Contexts contexts);
+
+    /**
+     * Invalidates all of the underlying Permission calculators.
+     * Can be called to allow for an update in defaults.
+     */
+    void invalidatePermissionCalculators();
+
+}

api/src/main/java/me/lucko/luckperms/api/context/ContextCalculator.java

@@ -28,6 +28,7 @@ import java.util.concurrent.CopyOnWriteArrayList;
 
 /**
  * A simple implementation of the listener aspects of {@link IContextCalculator}
+ *
  * @param <T> the subject type
  */
 public abstract class ContextCalculator<T> implements IContextCalculator<T> {
@@ -36,8 +37,9 @@ public abstract class ContextCalculator<T> implements IContextCalculator<T> {
     /**
      * Pushes an update to all registered {@link ContextListener}s.
      * Make sure any changes are applied internally before this method is called.
+     *
      * @param subject the subject that changed
-     * @param before the context state before the change
+     * @param before  the context state before the change
      * @param current the context state after the change (now)
      * @throws NullPointerException if any parameters are null
      */

api/src/main/java/me/lucko/luckperms/api/context/ContextListener.java

@@ -26,14 +26,16 @@ import java.util.Map;
 
 /**
  * Listens to context changes
+ *
  * @param <T> the subject type, Is ALWAYS the player class of the platform.
  */
 public interface ContextListener<T> {
 
     /**
      * Called whenever a context changes on the
+     *
      * @param subject the subject that had context changed
-     * @param before the context state before the change
+     * @param before  the context state before the change
      * @param current the context state after the change (now)
      */
     void onContextChange(T subject, Map.Entry<String, String> before, Map.Entry<String, String> current) throws Exception;

api/src/main/java/me/lucko/luckperms/api/context/ContextSet.java

@@ -0,0 +1,204 @@
+/*
+ * 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.api.context;
+
+import com.google.common.collect.Multimap;
+
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Holds contexts.
+ * Implementations may be either mutable or immutable.
+ *
+ * @since 2.13
+ */
+public interface ContextSet {
+
+    /**
+     * Make a singleton ImmutableContextSet from a context pair
+     *
+     * @param key   the key
+     * @param value the value
+     * @return a new ImmutableContextSet containing one KV pair
+     * @throws NullPointerException if key or value is null
+     */
+    static ImmutableContextSet singleton(String key, String value) {
+        return ImmutableContextSet.singleton(key, value);
+    }
+
+    /**
+     * Creates a ImmutableContextSet from an existing map
+     *
+     * @param map the map to copy from
+     * @return a new ImmutableContextSet representing the pairs from the map
+     * @throws NullPointerException if the map is null
+     */
+    static ImmutableContextSet fromMap(Map<String, String> map) {
+        return ImmutableContextSet.fromMap(map);
+    }
+
+    /**
+     * Creates a ImmutableContextSet from an existing iterable of Map Entries
+     *
+     * @param iterable the iterable to copy from
+     * @return a new ImmutableContextSet representing the pairs in the iterable
+     * @throws NullPointerException if the iterable is null
+     */
+    static ImmutableContextSet fromEntries(Iterable<Map.Entry<String, String>> iterable) {
+        return ImmutableContextSet.fromEntries(iterable);
+    }
+
+    /**
+     * Creates a ImmutableContextSet from an existing multimap
+     *
+     * @param multimap the multimap to copy from
+     * @return a new ImmutableContextSet representing the pairs in the multimap
+     * @throws NullPointerException if the multimap is null
+     * @since 2.16
+     */
+    static ImmutableContextSet fromMultimap(Multimap<String, String> multimap) {
+        return ImmutableContextSet.fromMultimap(multimap);
+    }
+
+    /**
+     * Creates a new ImmutableContextSet from an existing set.
+     * Only really useful for converting between mutable and immutable types.
+     *
+     * @param contextSet the context set to copy from
+     * @return a new ImmutableContextSet with the same content and the one provided
+     * @throws NullPointerException if contextSet is null
+     */
+    static ImmutableContextSet fromSet(ContextSet contextSet) {
+        return ImmutableContextSet.fromSet(contextSet);
+    }
+
+    /**
+     * Creates a new empty ImmutableContextSet.
+     *
+     * @return a new ImmutableContextSet
+     */
+    static ImmutableContextSet empty() {
+        return ImmutableContextSet.empty();
+    }
+
+    /**
+     * Check to see if this set is in an immutable form
+     *
+     * @return true if the set is immutable
+     */
+    boolean isImmutable();
+
+    /**
+     * If the set is mutable, this method will return an immutable copy. Otherwise just returns itself.
+     *
+     * @return an immutable ContextSet
+     */
+    ImmutableContextSet makeImmutable();
+
+    /**
+     * Creates a mutable copy of this set.
+     *
+     * @return a mutable ContextSet
+     * @since 2.16
+     */
+    MutableContextSet mutableCopy();
+
+    /**
+     * Converts this ContextSet to an immutable {@link Set} of {@link Map.Entry}s.
+     *
+     * @return an immutable set
+     */
+    Set<Map.Entry<String, String>> toSet();
+
+    /**
+     * Converts this ContextSet to an immutable {@link Map}
+     *
+     * <b>NOTE: Use of this method may result in data being lost. ContextSets can contain lots of different values for
+     * one key.</b>
+     *
+     * @return an immutable map
+     */
+    Map<String, String> toMap();
+
+    /**
+     * Converts this ContextSet to an immutable {@link Multimap}
+     *
+     * @return a multimap
+     * @since 2.16
+     */
+    Multimap<String, String> toMultimap();
+
+    /**
+     * Check if the set contains at least one value for the given key.
+     *
+     * @param key the key to check for
+     * @return true if the set contains a value for the key
+     * @throws NullPointerException if the key is null
+     */
+    boolean containsKey(String key);
+
+    /**
+     * Gets a set of all of the values mapped to the given key
+     *
+     * @param key the key to find values for
+     * @return a set of values
+     * @throws NullPointerException if the key is null
+     */
+    Set<String> getValues(String key);
+
+    /**
+     * Check if thr set contains a given key mapped to a given value
+     *
+     * @param key   the key to look for
+     * @param value the value to look for (case sensitive)
+     * @return true if the set contains the KV pair
+     * @throws NullPointerException if the key or value is null
+     */
+    boolean has(String key, String value);
+
+    /**
+     * Same as {@link #has(String, String)}, except ignores the case of the value.
+     *
+     * @param key   the key to look for
+     * @param value the value to look for
+     * @return true if the set contains the KV pair
+     * @throws NullPointerException if the key or value is null
+     */
+    boolean hasIgnoreCase(String key, String value);
+
+    /**
+     * Check if the set is empty
+     *
+     * @return true if the set is empty
+     */
+    boolean isEmpty();
+
+    /**
+     * Gets the number of key-value context pairs in the set
+     *
+     * @return the size of the set
+     */
+    int size();
+
+}

api/src/main/java/me/lucko/luckperms/api/context/IContextCalculator.java

@@ -22,26 +22,59 @@
 
 package me.lucko.luckperms.api.context;
 
+import java.util.HashMap;
 import java.util.Map;
 
 /**
  * Calculates whether contexts are applicable to {@link T}
  *
  * <p>Somewhat inspired by the system used on Sponge.
+ *
  * @param <T> the subject type. Is ALWAYS the player class of the platform.
  */
 public interface IContextCalculator<T> {
 
     /**
      * Gives the subject all of the applicable contexts they meet
-     * @param subject the subject to add contexts tp
+     *
+     * @param subject     the subject to add contexts to
      * @param accumulator a map of contexts to add to
      * @return the map
+     * @deprecated in favour of {@link #giveApplicableContext(Object, MutableContextSet)}. Older implementations of this
+     * interface will still work, as the replacement method is given as a default, and falls back to using this method.
      */
-    Map<String, String> giveApplicableContext(T subject, Map<String, String> accumulator);
+    @Deprecated
+    default Map<String, String> giveApplicableContext(T subject, Map<String, String> accumulator) {
+        MutableContextSet acc = new MutableContextSet();
+        giveApplicableContext(subject, acc);
+
+        accumulator.putAll(acc.toMap());
+        return accumulator;
+    }
+
+    /**
+     * Gives the subject all of the applicable contexts they meet
+     *
+     * <p><b>You MUST implement this method. The default is only provided for backwards compatibility with
+     * {@link #giveApplicableContext(Object, Map)}.</b>
+     *
+     * @param subject     the subject to add contexts to
+     * @param accumulator a map of contexts to add to
+     * @return the map
+     * @since 2.13
+     */
+    @SuppressWarnings("deprecation")
+    default MutableContextSet giveApplicableContext(T subject, MutableContextSet accumulator) {
+        Map<String, String> acc = new HashMap<>();
+        giveApplicableContext(subject, acc);
+
+        accumulator.addAll(acc.entrySet());
+        return accumulator;
+    }
 
     /**
      * Checks to see if a context is applicable to a subject
+     *
      * @param subject the subject to check against
      * @param context the context to check for
      * @return true if met, or false if not. If this calculator does not calculate the given context, return false.
@@ -50,6 +83,7 @@ public interface IContextCalculator<T> {
 
     /**
      * Adds a listener to be called whenever a context handled by this calculator changes
+     *
      * @param listener the listener instance
      * @throws NullPointerException if listener is null
      */

api/src/main/java/me/lucko/luckperms/api/context/ImmutableContextSet.java

@@ -0,0 +1,254 @@
+/*
+ * 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.api.context;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableMultimap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Multimap;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+/**
+ * An immutable implementation of {@link ContextSet}.
+ *
+ * @since 2.16
+ */
+public final class ImmutableContextSet implements ContextSet {
+    private static final ImmutableContextSet EMPTY = new ImmutableContextSet(ImmutableMultimap.of());
+
+    /**
+     * Make a singleton ImmutableContextSet from a context pair
+     *
+     * @param key   the key
+     * @param value the value
+     * @return a new ImmutableContextSet containing one KV pair
+     * @throws NullPointerException if key or value is null
+     */
+    public static ImmutableContextSet singleton(String key, String value) {
+        if (key == null) {
+            throw new NullPointerException("key");
+        }
+        if (value == null) {
+            throw new NullPointerException("value");
+        }
+
+        return new ImmutableContextSet(ImmutableMultimap.of(key.toLowerCase(), value));
+    }
+
+    /**
+     * Creates a ImmutableContextSet from an existing map
+     *
+     * @param map the map to copy from
+     * @return a new ImmutableContextSet representing the pairs from the map
+     * @throws NullPointerException if the map is null
+     */
+    public static ImmutableContextSet fromMap(Map<String, String> map) {
+        if (map == null) {
+            throw new NullPointerException("map");
+        }
+
+        return new ImmutableContextSet(ImmutableMultimap.copyOf(
+                map.entrySet().stream()
+                        .collect(Collectors.toMap(
+                                e -> e.getKey().toLowerCase(),
+                                Map.Entry::getValue
+                        )).entrySet()
+        ));
+    }
+
+    /**
+     * Creates a ImmutableContextSet from an existing iterable of Map Entries
+     *
+     * @param iterable the iterable to copy from
+     * @return a new ImmutableContextSet representing the pairs in the iterable
+     * @throws NullPointerException if the iterable is null
+     */
+    public static ImmutableContextSet fromEntries(Iterable<Map.Entry<String, String>> iterable) {
+        if (iterable == null) {
+            throw new NullPointerException("iterable");
+        }
+
+        return MutableContextSet.fromEntries(iterable).makeImmutable();
+    }
+
+    /**
+     * Creates a ImmutableContextSet from an existing multimap
+     *
+     * @param multimap the multimap to copy from
+     * @return a new ImmutableContextSet representing the pairs in the multimap
+     * @throws NullPointerException if the multimap is null
+     */
+    public static ImmutableContextSet fromMultimap(Multimap<String, String> multimap) {
+        if (multimap == null) {
+            throw new NullPointerException("multimap");
+        }
+
+        return MutableContextSet.fromMultimap(multimap).makeImmutable();
+    }
+
+    /**
+     * Creates a new ImmutableContextSet from an existing set.
+     * Only really useful for converting between mutable and immutable types.
+     *
+     * @param contextSet the context set to copy from
+     * @return a new ImmutableContextSet with the same content and the one provided
+     * @throws NullPointerException if contextSet is null
+     */
+    public static ImmutableContextSet fromSet(ContextSet contextSet) {
+        return contextSet.makeImmutable();
+    }
+
+    /**
+     * Creates a new empty ContextSet.
+     *
+     * @return a new ContextSet
+     */
+    public static ImmutableContextSet empty() {
+        return EMPTY;
+    }
+
+    private final Multimap<String, String> map;
+
+    ImmutableContextSet(Multimap<String, String> contexts) {
+        this.map = ImmutableMultimap.copyOf(contexts);
+    }
+
+    @Override
+    public boolean isImmutable() {
+        return true;
+    }
+
+    @Override
+    @Deprecated // This set is already immutable!
+    public ImmutableContextSet makeImmutable() {
+        return this;
+    }
+
+    @Override
+    public MutableContextSet mutableCopy() {
+        return MutableContextSet.fromSet(this);
+    }
+
+    @Override
+    public Set<Map.Entry<String, String>> toSet() {
+        return ImmutableSet.copyOf(map.entries());
+    }
+
+    @Override
+    public Map<String, String> toMap() {
+        return ImmutableMap.copyOf(map.entries());
+    }
+
+    @Override
+    public Multimap<String, String> toMultimap() {
+        return map;
+    }
+
+    @Override
+    public boolean containsKey(String key) {
+        if (key == null) {
+            throw new NullPointerException("key");
+        }
+
+        return map.containsKey(key);
+    }
+
+    @Override
+    public Set<String> getValues(String key) {
+        if (key == null) {
+            throw new NullPointerException("key");
+        }
+
+        Collection<String> c = map.get(key);
+        return c != null && !c.isEmpty() ? ImmutableSet.copyOf(c) : ImmutableSet.of();
+    }
+
+    @Override
+    public boolean has(String key, String value) {
+        if (key == null) {
+            throw new NullPointerException("key");
+        }
+        if (value == null) {
+            throw new NullPointerException("value");
+        }
+
+        return map.containsEntry(key, value);
+    }
+
+    @Override
+    public boolean hasIgnoreCase(String key, String value) {
+        if (key == null) {
+            throw new NullPointerException("key");
+        }
+        if (value == null) {
+            throw new NullPointerException("value");
+        }
+
+        Collection<String> c = map.get(key);
+        if (c == null || c.isEmpty()) {
+            return false;
+        }
+
+        for (String val : c) {
+            if (val.equalsIgnoreCase(value)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return map.isEmpty();
+    }
+
+    @Override
+    public int size() {
+        return map.size();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o == this) return true;
+        if (!(o instanceof ContextSet)) return false;
+        final ContextSet other = (ContextSet) o;
+
+        final Multimap<String, String> thisContexts = this.toMultimap();
+        final Multimap<String, String> otherContexts = other.toMultimap();
+        return thisContexts == null ? otherContexts == null : thisContexts.equals(otherContexts);
+    }
+
+    @Override
+    public int hashCode() {
+        return 59 + (this.map == null ? 43 : this.map.hashCode());
+    }
+
+    @Override
+    public String toString() {
+        return "ImmutableContextSet(contexts=" + this.map + ")";
+    }
+}

api/src/main/java/me/lucko/luckperms/api/context/MutableContextSet.java

@@ -0,0 +1,394 @@
+/*
+ * 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.api.context;
+
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Multimap;
+import com.google.common.collect.Multimaps;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * A mutable implementation of {@link ContextSet}.
+ *
+ * @since 2.16
+ */
+public final class MutableContextSet implements ContextSet {
+
+    /**
+     * Make a singleton MutableContextSet from a context pair
+     *
+     * @param key   the key
+     * @param value the value
+     * @return a new MutableContextSet containing one KV pair
+     * @throws NullPointerException if key or value is null
+     */
+    public static MutableContextSet singleton(String key, String value) {
+        if (key == null) {
+            throw new NullPointerException("key");
+        }
+        if (value == null) {
+            throw new NullPointerException("value");
+        }
+
+        MutableContextSet set = new MutableContextSet();
+        set.add(key, value);
+        return set;
+    }
+
+    /**
+     * Creates a MutableContextSet from an existing map
+     *
+     * @param map the map to copy from
+     * @return a new MutableContextSet representing the pairs from the map
+     * @throws NullPointerException if the map is null
+     */
+    public static MutableContextSet fromMap(Map<String, String> map) {
+        if (map == null) {
+            throw new NullPointerException("map");
+        }
+
+        MutableContextSet set = new MutableContextSet();
+        set.addAll(map);
+        return set;
+    }
+
+    /**
+     * Creates a MutableContextSet from an existing iterable of Map Entries
+     *
+     * @param iterable the iterable to copy from
+     * @return a new MutableContextSet representing the pairs in the iterable
+     * @throws NullPointerException if the iterable is null
+     */
+    public static MutableContextSet fromEntries(Iterable<Map.Entry<String, String>> iterable) {
+        if (iterable == null) {
+            throw new NullPointerException("iterable");
+        }
+
+        MutableContextSet set = new MutableContextSet();
+        set.addAll(iterable);
+        return set;
+    }
+
+    /**
+     * Creates a MutableContextSet from an existing multimap
+     *
+     * @param multimap the multimap to copy from
+     * @return a new MutableContextSet representing the pairs in the multimap
+     * @throws NullPointerException if the multimap is null
+     */
+    public static MutableContextSet fromMultimap(Multimap<String, String> multimap) {
+        if (multimap == null) {
+            throw new NullPointerException("multimap");
+        }
+
+        return fromEntries(multimap.entries());
+    }
+
+    /**
+     * Creates a new MutableContextSet from an existing set.
+     * Only really useful for converting between mutable and immutable types.
+     *
+     * @param contextSet the context set to copy from
+     * @return a new MutableContextSet with the same content and the one provided
+     * @throws NullPointerException if contextSet is null
+     */
+    public static MutableContextSet fromSet(ContextSet contextSet) {
+        if (contextSet == null) {
+            throw new NullPointerException("contextSet");
+        }
+
+        MutableContextSet set = new MutableContextSet();
+        set.addAll(contextSet.toSet());
+        return set;
+    }
+
+    /**
+     * Creates a new empty MutableContextSet.
+     *
+     * @return a new MutableContextSet
+     */
+    public static MutableContextSet create() {
+        return new MutableContextSet();
+    }
+
+    private final Multimap<String, String> map;
+
+    public MutableContextSet() {
+        this.map = Multimaps.synchronizedMultimap(HashMultimap.create());
+    }
+
+    private MutableContextSet(Multimap<String, String> contexts) {
+        this.map = Multimaps.synchronizedMultimap(HashMultimap.create(contexts));
+    }
+
+    @Override
+    public boolean isImmutable() {
+        return false;
+    }
+
+    @Override
+    public ImmutableContextSet makeImmutable() {
+        return new ImmutableContextSet(map);
+    }
+
+    @Override
+    public MutableContextSet mutableCopy() {
+        return new MutableContextSet(map);
+    }
+
+    @Override
+    public Set<Map.Entry<String, String>> toSet() {
+        return ImmutableSet.copyOf(map.entries());
+    }
+
+    @Override
+    public Map<String, String> toMap() {
+        return ImmutableMap.copyOf(map.entries());
+    }
+
+    @Override
+    public Multimap<String, String> toMultimap() {
+        return map;
+    }
+
+    @Override
+    public boolean containsKey(String key) {
+        if (key == null) {
+            throw new NullPointerException("key");
+        }
+
+        return map.containsKey(key);
+    }
+
+    @Override
+    public Set<String> getValues(String key) {
+        if (key == null) {
+            throw new NullPointerException("key");
+        }
+
+        Collection<String> c = map.get(key);
+        return c != null && !c.isEmpty() ? ImmutableSet.copyOf(c) : ImmutableSet.of();
+    }
+
+    @Override
+    public boolean has(String key, String value) {
+        if (key == null) {
+            throw new NullPointerException("key");
+        }
+        if (value == null) {
+            throw new NullPointerException("value");
+        }
+
+        return map.containsEntry(key, value);
+    }
+
+    @Override
+    public boolean hasIgnoreCase(String key, String value) {
+        if (key == null) {
+            throw new NullPointerException("key");
+        }
+        if (value == null) {
+            throw new NullPointerException("value");
+        }
+
+        Collection<String> c = map.get(key);
+        if (c == null || c.isEmpty()) {
+            return false;
+        }
+
+        for (String val : c) {
+            if (val.equalsIgnoreCase(value)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return map.isEmpty();
+    }
+
+    @Override
+    public int size() {
+        return map.size();
+    }
+
+    /**
+     * Adds a new key value pair to the set
+     *
+     * @param key   the key to add
+     * @param value the value to add
+     * @throws NullPointerException if the key or value is null
+     */
+    public void add(String key, String value) {
+        if (key == null) {
+            throw new NullPointerException("key");
+        }
+        if (value == null) {
+            throw new NullPointerException("value");
+        }
+
+        map.put(key.toLowerCase(), value);
+    }
+
+    /**
+     * Adds a new key value pair to the set
+     *
+     * @param entry the entry to add
+     * @throws NullPointerException if the entry is null
+     */
+    public void add(Map.Entry<String, String> entry) {
+        if (entry == null) {
+            throw new NullPointerException("context");
+        }
+
+        map.put(entry.getKey().toLowerCase(), entry.getValue());
+    }
+
+    /**
+     * Adds an iterable containing contexts to the set
+     *
+     * @param iterable an iterable of key value context pairs
+     * @throws NullPointerException if iterable is null
+     */
+    public void addAll(Iterable<Map.Entry<String, String>> iterable) {
+        if (iterable == null) {
+            throw new NullPointerException("contexts");
+        }
+
+        for (Map.Entry<String, String> e : iterable) {
+            this.map.put(e.getKey().toLowerCase(), e.getValue());
+        }
+    }
+
+    /**
+     * Adds the entry set of a map to the set
+     *
+     * @param map the map to add from
+     * @throws NullPointerException if the map is null
+     */
+    public void addAll(Map<String, String> map) {
+        if (map == null) {
+            throw new NullPointerException("contexts");
+        }
+        addAll(map.entrySet());
+    }
+
+    /**
+     * Adds of of the values in another ContextSet to this set
+     *
+     * @param contextSet the set to add from
+     * @throws NullPointerException if the contextSet is null
+     */
+    public void addAll(ContextSet contextSet) {
+        if (contextSet == null) {
+            throw new NullPointerException("contextSet");
+        }
+
+        this.map.putAll(contextSet.toMultimap());
+    }
+
+    /**
+     * Remove a key value pair from this set
+     *
+     * @param key   the key to remove
+     * @param value the value to remove (case sensitive)
+     * @throws NullPointerException if the key or value is null
+     */
+    public void remove(String key, String value) {
+        if (key == null) {
+            throw new NullPointerException("key");
+        }
+        if (value == null) {
+            throw new NullPointerException("value");
+        }
+
+        map.entries().removeIf(entry -> entry.getKey().equalsIgnoreCase(key) && entry.getValue().equals(value));
+    }
+
+    /**
+     * Same as {@link #remove(String, String)}, except ignores the case of the value
+     *
+     * @param key   the key to remove
+     * @param value the value to remove
+     * @throws NullPointerException if the key or value is null
+     */
+    public void removeIgnoreCase(String key, String value) {
+        if (key == null) {
+            throw new NullPointerException("key");
+        }
+        if (value == null) {
+            throw new NullPointerException("value");
+        }
+
+        map.entries().removeIf(e -> e.getKey().equalsIgnoreCase(key) && e.getValue().equalsIgnoreCase(value));
+    }
+
+    /**
+     * Removes all pairs with the given key
+     *
+     * @param key the key to remove
+     * @throws NullPointerException if the key is null
+     */
+    public void removeAll(String key) {
+        if (key == null) {
+            throw new NullPointerException("key");
+        }
+
+        map.removeAll(key.toLowerCase());
+    }
+
+    /**
+     * Clears the set
+     */
+    public void clear() {
+        map.clear();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o == this) return true;
+        if (!(o instanceof ContextSet)) return false;
+        final ContextSet other = (ContextSet) o;
+
+        final Multimap<String, String> thisContexts = this.toMultimap();
+        final Multimap<String, String> otherContexts = other.toMultimap();
+        return thisContexts == null ? otherContexts == null : thisContexts.equals(otherContexts);
+    }
+
+    @Override
+    public int hashCode() {
+        return 59 + (this.map == null ? 43 : this.map.hashCode());
+    }
+
+    @Override
+    public String toString() {
+        return "MutableContextSet(contexts=" + this.map + ")";
+    }
+}

api/src/main/java/me/lucko/luckperms/api/data/Callback.java

@@ -27,18 +27,16 @@ import java.util.function.Consumer;
 /**
  * A callback used to wait for the completion of asynchronous operations.
  * All callbacks are ran on the main server thread.
+ *
  * @param <T> the return type
+ * @deprecated in favour of {@link Consumer}
  */
+@Deprecated
 public interface Callback<T> {
 
-    /**
-     * Called when the operation completes.
-     * @param t the return value, may be null
-     */
-    void onComplete(T t);
-
     static <T> Callback<T> empty() {
-        return t -> {};
+        return t -> {
+        };
     }
 
     static <T> Callback<T> of(Runnable runnable) {
@@ -55,4 +53,26 @@ public interface Callback<T> {
         return consumer::accept;
     }
 
+    /**
+     * Helper method for converting old {@link Callback}s to use the new {@link me.lucko.luckperms.api.Storage}
+     * interface.
+     *
+     * @param callback the callback to convert
+     * @param <T>      the return type
+     * @return a consumer instance
+     * @since 2.14
+     * @deprecated in favour of just using {@link Consumer}s.
+     */
+    @Deprecated
+    static <T> Consumer<T> convertToConsumer(Callback<T> callback) {
+        return callback::onComplete;
+    }
+
+    /**
+     * Called when the operation completes.
+     *
+     * @param t the return value, may be null
+     */
+    void onComplete(T t);
+
 }

api/src/main/java/me/lucko/luckperms/api/data/DatastoreConfiguration.java

@@ -30,8 +30,11 @@ package me.lucko.luckperms.api.data;
 public interface DatastoreConfiguration extends MySQLConfiguration {
 
     String getAddress();
+
     String getDatabase();
+
     String getUsername();
+
     String getPassword();
 
 }

api/src/main/java/me/lucko/luckperms/api/data/MySQLConfiguration.java

@@ -29,7 +29,10 @@ package me.lucko.luckperms.api.data;
 public interface MySQLConfiguration {
 
     String getAddress();
+
     String getDatabase();
+
     String getUsername();
+
     String getPassword();
 }

api/src/main/java/me/lucko/luckperms/api/event/LPEvent.java

@@ -29,15 +29,14 @@ import me.lucko.luckperms.api.LuckPermsApi;
  */
 public abstract class LPEvent {
 
-    /**
-     * A link to the API instance provided for convenience.
-     */
-    private LuckPermsApi api = null;
-
     /**
      * A friendly name of the event
      */
     private final String eventName;
+    /**
+     * A link to the API instance provided for convenience.
+     */
+    private LuckPermsApi api = null;
 
     protected LPEvent(String eventName) {
         this.eventName = eventName;

api/src/main/java/me/lucko/luckperms/api/event/TargetedEvent.java

@@ -24,6 +24,7 @@ package me.lucko.luckperms.api.event;
 
 /**
  * Represents an event acting upon a target
+ *
  * @param <T> the target type
  */
 public class TargetedEvent<T> extends LPEvent {

api/src/main/java/me/lucko/luckperms/api/event/events/PermissionExpireEvent.java

@@ -27,6 +27,7 @@ import me.lucko.luckperms.api.event.TargetedEvent;
 
 /**
  * Called when a permission expires for an object.
+ *
  * @deprecated in favour of {@link PermissionNodeExpireEvent}
  */
 @Deprecated

api/src/main/java/me/lucko/luckperms/api/event/events/PermissionNodeExpireEvent.java

@@ -28,6 +28,7 @@ import me.lucko.luckperms.api.event.AbstractPermissionEvent;
 
 /**
  * Called when a temporary permission node expires
+ *
  * @since 2.6
  */
 public class PermissionNodeExpireEvent extends AbstractPermissionEvent {

api/src/main/java/me/lucko/luckperms/api/event/events/PermissionNodeSetEvent.java

@@ -28,6 +28,7 @@ import me.lucko.luckperms.api.event.AbstractPermissionEvent;
 
 /**
  * Called when a permission node is set on a holder
+ *
  * @since 2.6
  */
 public class PermissionNodeSetEvent extends AbstractPermissionEvent {

api/src/main/java/me/lucko/luckperms/api/event/events/PermissionNodeUnsetEvent.java

@@ -28,6 +28,7 @@ import me.lucko.luckperms.api.event.AbstractPermissionEvent;
 
 /**
  * Called when a permission node is unset from a holder
+ *
  * @since 2.6
  */
 public class PermissionNodeUnsetEvent extends AbstractPermissionEvent {

api/src/main/java/me/lucko/luckperms/api/event/events/PermissionSetEvent.java

@@ -30,6 +30,7 @@ import java.util.Map;
 
 /**
  * Called whenever a user or group has a permission set.
+ *
  * @deprecated in favour of {@link PermissionNodeSetEvent}
  */
 @Deprecated

api/src/main/java/me/lucko/luckperms/api/event/events/PermissionUnsetEvent.java

@@ -27,6 +27,7 @@ import me.lucko.luckperms.api.event.AbstractPermissionRemoveEvent;
 
 /**
  * Called whenever a user or group has a permission unset.
+ *
  * @deprecated in favour of {@link PermissionNodeUnsetEvent}
  */
 @Deprecated

api/src/main/java/me/lucko/luckperms/api/event/events/UserFirstLoginEvent.java

@@ -27,11 +27,11 @@ import me.lucko.luckperms.api.event.LPEvent;
 import java.util.UUID;
 
 /**
- * Called when the user logs into the network for the first time.
- * Particularly useful for networks with multiple lobbies, who want to welcome a user when they join for the first time.
+ * Called when the user logs into the network for the first time. Particularly useful for networks with multiple
+ * lobbies, who want to welcome a user when they join for the first time.
  *
- * <p>This event is fired before the player has actually joined the game on the async login / auth event.
- * If you want to do something with the user, store the UUID in a set, and then check the set in the PlayerJoinEvent o.e.
+ * <p>This event is fired before the player has actually joined the game on the async login / auth event. If you want to
+ * do something with the user, store the UUID in a set, and then check the set in the PlayerJoinEvent o.e.
  */
 public class UserFirstLoginEvent extends LPEvent {
 

api/src/main/java/me/lucko/luckperms/api/event/events/UserPermissionRefreshEvent.java

@@ -26,8 +26,8 @@ import me.lucko.luckperms.api.User;
 import me.lucko.luckperms.api.event.UserEvent;
 
 /**
- * Called after a user has their permissions refreshed.
- * If you cache user permissions within your own plugin, it's a good idea to update said cache whenever this event is called.
+ * Called after a user has their permissions refreshed. If you cache user permissions within your own plugin, it's a
+ * good idea to update said cache whenever this event is called.
  */
 public class UserPermissionRefreshEvent extends UserEvent {
 

api/src/main/java/me/lucko/luckperms/exceptions/MembershipException.java

@@ -23,7 +23,9 @@
 package me.lucko.luckperms.exceptions;
 
 /**
- * Thrown when a permission holding object doesn't / already has a permission or isn't / is already is a member of a group
+ * Thrown when a permission holding object doesn't / already has a permission or isn't / is already is a member of a
+ * group
+ *
  * @since 2.7
  */
 public abstract class MembershipException extends Exception {

bukkit-legacy/pom.xml

@@ -1,11 +1,11 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xmlns="http://maven.apache.org/POM/4.0.0"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <parent>
         <artifactId>luckperms</artifactId>
         <groupId>me.lucko.luckperms</groupId>
-        <version>2.12-SNAPSHOT</version>
+        <version>2.16-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
@@ -75,6 +75,18 @@
                                     <pattern>com.google.gson</pattern>
                                     <shadedPattern>me.lucko.luckperms.lib.gson</shadedPattern>
                                 </relocation>
+                                <relocation>
+                                    <pattern>redis.clients.jedis</pattern>
+                                    <shadedPattern>me.lucko.luckperms.lib.jedis.jedis</shadedPattern>
+                                </relocation>
+                                <relocation>
+                                    <pattern>redis.clients.util</pattern>
+                                    <shadedPattern>me.lucko.luckperms.lib.jedis.util</shadedPattern>
+                                </relocation>
+                                <relocation>
+                                    <pattern>org.apache.commons.pool2</pattern>
+                                    <shadedPattern>me.lucko.luckperms.lib.jedis.pool2</shadedPattern>
+                                </relocation>
                             </relocations>
                         </configuration>
                     </execution>

bukkit-placeholders/pom.xml

@@ -1,11 +1,11 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xmlns="http://maven.apache.org/POM/4.0.0"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <parent>
         <artifactId>luckperms</artifactId>
         <groupId>me.lucko.luckperms</groupId>
-        <version>2.12-SNAPSHOT</version>
+        <version>2.16-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
@@ -30,7 +30,7 @@
         <dependency>
             <groupId>me.lucko.luckperms</groupId>
             <artifactId>luckperms-api</artifactId>
-            <version>2.8</version>
+            <version>${project.version}</version>
             <scope>provided</scope>
         </dependency>
         <!-- BukkitAPI -->

bukkit-placeholders/src/main/java/me/lucko/luckperms/api/placeholders/LuckPermsPlaceholderExpansion.java

@@ -25,17 +25,26 @@ package me.lucko.luckperms.api.placeholders;
 import me.clip.placeholderapi.PlaceholderAPIPlugin;
 import me.clip.placeholderapi.expansion.PlaceholderExpansion;
 import me.clip.placeholderapi.util.TimeUtil;
-import me.lucko.luckperms.api.*;
+import me.lucko.luckperms.api.Contexts;
+import me.lucko.luckperms.api.LuckPermsApi;
+import me.lucko.luckperms.api.Node;
+import me.lucko.luckperms.api.Track;
+import me.lucko.luckperms.api.User;
+import me.lucko.luckperms.api.caching.UserData;
+import me.lucko.luckperms.api.context.MutableContextSet;
+
 import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
 
 import java.util.Optional;
+import java.util.stream.Collectors;
 
 /*
  * PlaceholderAPI Expansion for LuckPerms, implemented using the LuckPerms API.
  *
  * Placeholders:
  * - group_name
+ * - groups
  * - has_permission_<node>
  * - inherits_permission_<node>
  * - in_group_<name>
@@ -52,6 +61,10 @@ public class LuckPermsPlaceholderExpansion extends PlaceholderExpansion {
     private static final String PLUGIN_NAME = "LuckPerms";
     private static final String AUTHOR = "Luck";
 
+    private static String formatBoolean(boolean b) {
+        return b ? PlaceholderAPIPlugin.booleanTrue() : PlaceholderAPIPlugin.booleanFalse();
+    }
+
     private LuckPermsApi api = null;
 
     @Override
@@ -71,7 +84,14 @@ public class LuckPermsPlaceholderExpansion extends PlaceholderExpansion {
 
     @Override
     public String getVersion() {
-        return "2.8";
+        return "2.13";
+    }
+
+    private Contexts makeContexts(Player player) {
+        MutableContextSet contextSet = new MutableContextSet();
+        contextSet.add("server", api.getConfiguration().getVaultServer());
+        contextSet.add("world", player.getWorld().getName());// ignore world?
+        return Contexts.of(contextSet.makeImmutable(), api.getConfiguration().getVaultIncludeGlobal(), true, true, true, true, player.isOp());
     }
 
     @Override
@@ -84,14 +104,24 @@ public class LuckPermsPlaceholderExpansion extends PlaceholderExpansion {
         if (!u.isPresent()) {
             return "";
         }
+        final User user = u.get();
+
+        Optional<UserData> d = user.getUserDataCache();
+        if (!d.isPresent()) {
+            return "";
+        }
+        final UserData data = d.get();
 
         identifier = identifier.toLowerCase();
-        final User user = u.get();
 
         if (identifier.equalsIgnoreCase("group_name")) {
             return user.getPrimaryGroup();
         }
 
+        if (identifier.equalsIgnoreCase("groups")) {
+            return user.getGroupNames().stream().collect(Collectors.joining(", "));
+        }
+
         if (identifier.startsWith("has_permission_") && identifier.length() > "has_permission_".length()) {
             String node = identifier.substring("has_permission_".length());
             return formatBoolean(user.hasPermission(node, true));
@@ -99,7 +129,7 @@ public class LuckPermsPlaceholderExpansion extends PlaceholderExpansion {
 
         if (identifier.startsWith("inherits_permission_") && identifier.length() > "inherits_permission_".length()) {
             String node = identifier.substring("inherits_permission_".length());
-            return formatBoolean(user.inheritsPermission(node, true));
+            return formatBoolean(data.getPermissionData(makeContexts(player)).getPermissionValue(node).asBoolean());
         }
 
         if (identifier.startsWith("in_group_") && identifier.length() > "in_group_".length()) {
@@ -109,7 +139,7 @@ public class LuckPermsPlaceholderExpansion extends PlaceholderExpansion {
 
         if (identifier.startsWith("inherits_group_") && identifier.length() > "inherits_group_".length()) {
             String groupName = identifier.substring("inherits_group_".length());
-            return formatBoolean(user.getLocalGroups("global").contains(groupName));
+            return formatBoolean(data.getPermissionData(makeContexts(player)).getPermissionValue("group." + groupName).asBoolean());
         }
 
         if (identifier.startsWith("on_track_") && identifier.length() > "on_track_".length()) {
@@ -125,7 +155,7 @@ public class LuckPermsPlaceholderExpansion extends PlaceholderExpansion {
             String node = identifier.substring("expiry_time_".length());
             long currentTime = System.currentTimeMillis() / 1000L;
             for (Node n : user.getTemporaryPermissionNodes()) {
-                if (n.getPermission().equalsIgnoreCase(node)) {
+                if (n.toSerializedNode().equalsIgnoreCase(node)) {
                     return TimeUtil.getTime((int) (n.getExpiryUnixTime() - currentTime));
                 }
             }
@@ -146,16 +176,28 @@ public class LuckPermsPlaceholderExpansion extends PlaceholderExpansion {
         }
 
         if (identifier.equalsIgnoreCase("prefix")) {
-            return MetaUtils.getPrefix(user, null, null, true);
+            String prefix = data.calculateMeta(makeContexts(player)).getPrefix();
+            if (prefix == null) {
+                prefix = "";
+            }
+            return prefix;
         }
 
         if (identifier.equalsIgnoreCase("suffix")) {
-            return MetaUtils.getSuffix(user, null, null, true);
+            String suffix = data.calculateMeta(makeContexts(player)).getSuffix();
+            if (suffix == null) {
+                suffix = "";
+            }
+            return suffix;
         }
 
         if (identifier.startsWith("meta_") && identifier.length() > "meta_".length()) {
             String node = identifier.substring("meta_".length());
-            return MetaUtils.getMeta(user, null, null, node, "", true);
+            String meta = data.getMetaData(makeContexts(player)).getMeta().get(node);
+            if (meta == null) {
+                meta = "";
+            }
+            return meta;
         }
 
         return null;
@@ -175,8 +217,4 @@ public class LuckPermsPlaceholderExpansion extends PlaceholderExpansion {
     public String getAuthor() {
         return AUTHOR;
     }
-
-    private static String formatBoolean(boolean b) {
-        return b ? PlaceholderAPIPlugin.booleanTrue() : PlaceholderAPIPlugin.booleanFalse();
-    }
 }

bukkit/pom.xml

@@ -1,11 +1,11 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xmlns="http://maven.apache.org/POM/4.0.0"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <parent>
         <artifactId>luckperms</artifactId>
         <groupId>me.lucko.luckperms</groupId>
-        <version>2.12-SNAPSHOT</version>
+        <version>2.16-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
@@ -70,6 +70,18 @@
                                     <pattern>org.h2</pattern>
                                     <shadedPattern>me.lucko.luckperms.lib.h2</shadedPattern>
                                 </relocation>
+                                <relocation>
+                                    <pattern>redis.clients.jedis</pattern>
+                                    <shadedPattern>me.lucko.luckperms.lib.jedis.jedis</shadedPattern>
+                                </relocation>
+                                <relocation>
+                                    <pattern>redis.clients.util</pattern>
+                                    <shadedPattern>me.lucko.luckperms.lib.jedis.util</shadedPattern>
+                                </relocation>
+                                <relocation>
+                                    <pattern>org.apache.commons.pool2</pattern>
+                                    <shadedPattern>me.lucko.luckperms.lib.jedis.pool2</shadedPattern>
+                                </relocation>
                             </relocations>
                         </configuration>
                     </execution>
@@ -129,5 +141,46 @@
             <version>1.16.10</version>
             <scope>provided</scope>
         </dependency>
+        <!-- **************Migration Plugins************** -->
+        <dependency>
+            <groupId>org.tyrannyofheaven.bukkit</groupId>
+            <artifactId>zPermissions</artifactId>
+            <version>1.3</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>ru.tehkode</groupId>
+            <artifactId>PermissionsEx</artifactId>
+            <version>1.23</version>
+            <scope>provided</scope>
+            <exclusions>
+                <exclusion>
+                    <groupId>org.bukkit</groupId>
+                    <artifactId>bukkit</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>net.gravitydevelopment.updater</groupId>
+                    <artifactId>updater</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+        <dependency>
+            <groupId>com.github.cheesesoftware</groupId>
+            <artifactId>PowerfulPermsAPI</artifactId>
+            <version>1.0.1</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.anjocaido</groupId>
+            <artifactId>GroupManager</artifactId>
+            <version>1.4</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>de.bananaco</groupId>
+            <artifactId>bpermissions-api</artifactId>
+            <version>2.12</version>
+            <scope>provided</scope>
+        </dependency>
     </dependencies>
 </project>

bukkit/src/main/java/me/lucko/luckperms/bukkit/BukkitCalculatorFactory.java

@@ -23,41 +23,48 @@
 package me.lucko.luckperms.bukkit;
 
 import lombok.AllArgsConstructor;
+
+import com.google.common.collect.ImmutableList;
+
 import me.lucko.luckperms.api.Contexts;
 import me.lucko.luckperms.bukkit.calculators.AttachmentProcessor;
+import me.lucko.luckperms.bukkit.calculators.ChildProcessor;
 import me.lucko.luckperms.bukkit.calculators.DefaultsProcessor;
 import me.lucko.luckperms.bukkit.inject.Injector;
-import me.lucko.luckperms.bukkit.inject.LPPermissible;
-import me.lucko.luckperms.common.calculators.*;
-import me.lucko.luckperms.common.users.User;
+import me.lucko.luckperms.bukkit.model.LPPermissible;
+import me.lucko.luckperms.common.calculators.AbstractCalculatorFactory;
+import me.lucko.luckperms.common.calculators.PermissionCalculator;
+import me.lucko.luckperms.common.calculators.PermissionProcessor;
+import me.lucko.luckperms.common.calculators.processors.MapProcessor;
+import me.lucko.luckperms.common.calculators.processors.RegexProcessor;
+import me.lucko.luckperms.common.calculators.processors.WildcardProcessor;
+import me.lucko.luckperms.common.core.model.User;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
 import java.util.UUID;
 
 @AllArgsConstructor
-public class BukkitCalculatorFactory implements CalculatorFactory {
+public class BukkitCalculatorFactory extends AbstractCalculatorFactory {
     private final LPBukkitPlugin plugin;
 
     @Override
-    public PermissionCalculator build(Contexts contexts, User user, Map<String, Boolean> map) {
+    public PermissionCalculator build(Contexts contexts, User user) {
         UUID uuid = plugin.getUuidCache().getExternalUUID(user.getUuid());
 
-        List<PermissionProcessor> processors = new ArrayList<>(5);
-        processors.add(new MapProcessor(map));
+        ImmutableList.Builder<PermissionProcessor> processors = ImmutableList.builder();
+        processors.add(new MapProcessor());
+        processors.add(new ChildProcessor(plugin.getChildPermissionProvider()));
         processors.add(new AttachmentProcessor(() -> {
             LPPermissible permissible = Injector.getPermissible(uuid);
             return permissible == null ? null : permissible.getAttachmentPermissions();
         }));
         if (plugin.getConfiguration().isApplyingWildcards()) {
-            processors.add(new WildcardProcessor(map));
+            processors.add(new WildcardProcessor());
         }
         if (plugin.getConfiguration().isApplyingRegex()) {
-            processors.add(new RegexProcessor(map));
+            processors.add(new RegexProcessor());
         }
         processors.add(new DefaultsProcessor(contexts.isOp(), plugin.getDefaultsProvider()));
 
-        return new PermissionCalculator(plugin, user.getName(), plugin.getConfiguration().isDebugPermissionChecks(), processors);
+        return registerCalculator(new PermissionCalculator(plugin, user.getName(), processors.build()));
     }
 }

bukkit/src/main/java/me/lucko/luckperms/bukkit/BukkitCommand.java

@@ -24,11 +24,11 @@ package me.lucko.luckperms.bukkit;
 
 import com.google.common.base.Joiner;
 import com.google.common.base.Splitter;
-import me.lucko.luckperms.api.data.Callback;
-import me.lucko.luckperms.common.LuckPermsPlugin;
+
 import me.lucko.luckperms.common.commands.CommandManager;
-import me.lucko.luckperms.common.commands.Util;
+import me.lucko.luckperms.common.commands.utils.Util;
 import me.lucko.luckperms.common.constants.Patterns;
+
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
@@ -38,24 +38,26 @@ import java.util.Arrays;
 import java.util.List;
 
 class BukkitCommand extends CommandManager implements CommandExecutor, TabExecutor {
-    BukkitCommand(LuckPermsPlugin plugin) {
+    private final LPBukkitPlugin plugin;
+
+    BukkitCommand(LPBukkitPlugin plugin) {
         super(plugin);
+        this.plugin = plugin;
     }
 
     @Override
     public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
         onCommand(
-                BukkitSenderFactory.get(getPlugin()).wrap(sender),
+                plugin.getSenderFactory().wrap(sender),
                 label,
                 Util.stripQuotes(Splitter.on(Patterns.COMMAND_SEPARATOR).omitEmptyStrings().splitToList(Joiner.on(' ').join(args))),
-                Callback.empty()
+                null
         );
         return true;
     }
 
-
     @Override
     public List<String> onTabComplete(CommandSender sender, Command command, String label, String[] args) {
-        return onTabComplete(BukkitSenderFactory.get(getPlugin()).wrap(sender), Arrays.asList(args));
+        return onTabComplete(plugin.getSenderFactory().wrap(sender), Arrays.asList(args));
     }
 }

bukkit/src/main/java/me/lucko/luckperms/bukkit/BukkitConfig.java

@@ -23,12 +23,16 @@
 package me.lucko.luckperms.bukkit;
 
 import me.lucko.luckperms.common.config.AbstractConfiguration;
+
 import org.bukkit.configuration.ConfigurationSection;
 import org.bukkit.configuration.file.YamlConfiguration;
 
 import java.io.File;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
+import java.util.Optional;
+import java.util.stream.Collectors;
 
 class BukkitConfig extends AbstractConfiguration<LPBukkitPlugin> {
     private YamlConfiguration configuration;
@@ -65,6 +69,21 @@ class BukkitConfig extends AbstractConfiguration<LPBukkitPlugin> {
         return configuration.getBoolean(path, def);
     }
 
+    @Override
+    protected List<String> getList(String path, List<String> def) {
+        return Optional.ofNullable(configuration.getStringList(path)).orElse(def);
+    }
+
+    @Override
+    protected List<String> getObjectList(String path, List<String> def) {
+        ConfigurationSection section = configuration.getConfigurationSection(path);
+        if (section == null) {
+            return def;
+        }
+
+        return Optional.ofNullable(section.getKeys(false).stream().collect(Collectors.toList())).orElse(def);
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     protected Map<String, String> getMap(String path, Map<String, String> def) {

bukkit/src/main/java/me/lucko/luckperms/bukkit/BukkitListener.java

@@ -23,10 +23,11 @@
 package me.lucko.luckperms.bukkit;
 
 import me.lucko.luckperms.bukkit.inject.Injector;
-import me.lucko.luckperms.bukkit.inject.LPPermissible;
+import me.lucko.luckperms.bukkit.model.LPPermissible;
 import me.lucko.luckperms.common.constants.Message;
-import me.lucko.luckperms.common.users.User;
+import me.lucko.luckperms.common.core.model.User;
 import me.lucko.luckperms.common.utils.AbstractListener;
+
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
@@ -35,6 +36,7 @@ import org.bukkit.event.player.AsyncPlayerPreLoginEvent;
 import org.bukkit.event.player.PlayerCommandPreprocessEvent;
 import org.bukkit.event.player.PlayerLoginEvent;
 import org.bukkit.event.player.PlayerQuitEvent;
+import org.bukkit.event.server.PluginEnableEvent;
 
 import java.util.UUID;
 
@@ -46,9 +48,9 @@ class BukkitListener extends AbstractListener implements Listener {
         this.plugin = plugin;
     }
 
-    @EventHandler(priority = EventPriority.LOWEST)
+    @EventHandler(priority = EventPriority.LOW)
     public void onPlayerPreLogin(AsyncPlayerPreLoginEvent e) {
-        if (!plugin.getDatastore().isAcceptingLogins()) {
+        if (!plugin.isStarted() || !plugin.getStorage().isAcceptingLogins()) {
 
             // The datastore is disabled, prevent players from joining the server
             e.disallow(AsyncPlayerPreLoginEvent.Result.KICK_OTHER, Message.LOADING_ERROR.toString());
@@ -61,7 +63,7 @@ class BukkitListener extends AbstractListener implements Listener {
 
     @EventHandler(priority = EventPriority.MONITOR)
     public void onPlayerPreLoginMonitor(AsyncPlayerPreLoginEvent e) {
-        if (plugin.getDatastore().isAcceptingLogins() && e.getLoginResult() != AsyncPlayerPreLoginEvent.Result.ALLOWED) {
+        if (plugin.isStarted() && plugin.getStorage().isAcceptingLogins() && e.getLoginResult() != AsyncPlayerPreLoginEvent.Result.ALLOWED) {
 
             // Login event was cancelled by another plugin
             onLeave(e.getUniqueId());
@@ -106,7 +108,7 @@ class BukkitListener extends AbstractListener implements Listener {
         }
     }
 
-    @EventHandler(priority = EventPriority.HIGHEST) // Allow other plugins to see data when this event gets called.
+    @EventHandler(priority = EventPriority.MONITOR) // Allow other plugins to see data when this event gets called.
     public void onPlayerQuit(PlayerQuitEvent e) {
         final Player player = e.getPlayer();
         final UUID internal = plugin.getUuidCache().getUUID(player.getUniqueId());
@@ -143,4 +145,11 @@ class BukkitListener extends AbstractListener implements Listener {
             e.getPlayer().sendMessage(Message.OP_DISABLED.toString());
         }
     }
+
+    @EventHandler
+    public void onPluginEnable(PluginEnableEvent e) {
+        if (e.getPlugin().getName().equalsIgnoreCase("Vault")) {
+            plugin.tryVaultHook(true);
+        }
+    }
 }

bukkit/src/main/java/me/lucko/luckperms/bukkit/BukkitSenderFactory.java

@@ -23,27 +23,19 @@
 package me.lucko.luckperms.bukkit;
 
 import me.lucko.luckperms.common.LuckPermsPlugin;
-import me.lucko.luckperms.common.commands.SenderFactory;
+import me.lucko.luckperms.common.commands.sender.SenderFactory;
 import me.lucko.luckperms.common.constants.Constants;
+
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 
 import java.util.UUID;
 
 public class BukkitSenderFactory extends SenderFactory<CommandSender> {
-    private static BukkitSenderFactory instance = null;
-
-    private BukkitSenderFactory(LuckPermsPlugin plugin) {
+    public BukkitSenderFactory(LuckPermsPlugin plugin) {
         super(plugin);
     }
 
-    public static synchronized BukkitSenderFactory get(LuckPermsPlugin plugin) {
-        if (instance == null) {
-            instance = new BukkitSenderFactory(plugin);
-        }
-        return instance;
-    }
-
     @Override
     protected String getName(CommandSender sender) {
         if (sender instanceof Player) {

bukkit/src/main/java/me/lucko/luckperms/bukkit/LPBukkitPlugin.java

@@ -23,75 +23,173 @@
 package me.lucko.luckperms.bukkit;
 
 import lombok.Getter;
+
+import com.google.common.collect.ImmutableMap;
+
 import me.lucko.luckperms.ApiHandler;
 import me.lucko.luckperms.api.Contexts;
 import me.lucko.luckperms.api.Logger;
 import me.lucko.luckperms.api.LuckPermsApi;
 import me.lucko.luckperms.api.PlatformType;
-import me.lucko.luckperms.bukkit.calculators.DefaultsProvider;
+import me.lucko.luckperms.api.context.ContextSet;
+import me.lucko.luckperms.api.context.MutableContextSet;
+import me.lucko.luckperms.bukkit.calculators.AutoOPListener;
+import me.lucko.luckperms.bukkit.model.ChildPermissionProvider;
+import me.lucko.luckperms.bukkit.model.DefaultsProvider;
 import me.lucko.luckperms.bukkit.vault.VaultHook;
 import me.lucko.luckperms.common.LuckPermsPlugin;
 import me.lucko.luckperms.common.api.ApiProvider;
 import me.lucko.luckperms.common.calculators.CalculatorFactory;
 import me.lucko.luckperms.common.commands.ConsecutiveExecutor;
-import me.lucko.luckperms.common.commands.Sender;
+import me.lucko.luckperms.common.commands.sender.Sender;
 import me.lucko.luckperms.common.config.LPConfiguration;
-import me.lucko.luckperms.common.constants.Message;
+import me.lucko.luckperms.common.constants.Permission;
 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.data.Importer;
-import me.lucko.luckperms.common.groups.GroupManager;
-import me.lucko.luckperms.common.runnables.ExpireTemporaryTask;
-import me.lucko.luckperms.common.runnables.UpdateTask;
-import me.lucko.luckperms.common.storage.Datastore;
+import me.lucko.luckperms.common.managers.GroupManager;
+import me.lucko.luckperms.common.managers.TrackManager;
+import me.lucko.luckperms.common.managers.UserManager;
+import me.lucko.luckperms.common.managers.impl.GenericGroupManager;
+import me.lucko.luckperms.common.managers.impl.GenericTrackManager;
+import me.lucko.luckperms.common.managers.impl.GenericUserManager;
+import me.lucko.luckperms.common.messaging.RedisMessaging;
+import me.lucko.luckperms.common.storage.Storage;
 import me.lucko.luckperms.common.storage.StorageFactory;
-import me.lucko.luckperms.common.tracks.TrackManager;
-import me.lucko.luckperms.common.users.UserManager;
+import me.lucko.luckperms.common.tasks.ExpireTemporaryTask;
+import me.lucko.luckperms.common.tasks.UpdateTask;
+import me.lucko.luckperms.common.utils.BufferedRequest;
+import me.lucko.luckperms.common.utils.DebugHandler;
 import me.lucko.luckperms.common.utils.LocaleManager;
 import me.lucko.luckperms.common.utils.LogFactory;
+import me.lucko.luckperms.common.utils.PermissionCache;
+
 import org.bukkit.World;
 import org.bukkit.command.PluginCommand;
 import org.bukkit.entity.Player;
-import org.bukkit.permissions.Permission;
 import org.bukkit.permissions.PermissionDefault;
 import org.bukkit.plugin.PluginManager;
 import org.bukkit.plugin.ServicePriority;
 import org.bukkit.plugin.java.JavaPlugin;
 
 import java.io.File;
-import java.util.*;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.Executor;
+import java.util.concurrent.Executors;
 import java.util.stream.Collectors;
 
 @Getter
 public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
-    private VaultHook vaultHook = null;
-
     private final Set<UUID> ignoringLogs = ConcurrentHashMap.newKeySet();
+    private Executor syncExecutor;
+    private Executor asyncExecutor;
+    private VaultHook vaultHook = null;
     private LPConfiguration configuration;
     private UserManager userManager;
     private GroupManager groupManager;
     private TrackManager trackManager;
-    private Datastore datastore;
+    private Storage storage;
+    private RedisMessaging redisMessaging = null;
     private UuidCache uuidCache;
     private ApiProvider apiProvider;
     private Logger log;
     private Importer importer;
     private ConsecutiveExecutor consecutiveExecutor;
     private DefaultsProvider defaultsProvider;
+    private ChildPermissionProvider childPermissionProvider;
     private LocaleManager localeManager;
     private ContextManager<Player> contextManager;
     private WorldCalculator worldCalculator;
     private CalculatorFactory calculatorFactory;
+    private BufferedRequest<Void> updateTaskBuffer;
+    private boolean started = false;
+    private DebugHandler debugHandler;
+    private BukkitSenderFactory senderFactory;
+    private PermissionCache permissionCache;
 
     @Override
     public void onEnable() {
+        // Used whilst the server is still starting
+        asyncExecutor = Executors.newCachedThreadPool();
+        syncExecutor = r -> getServer().getScheduler().runTask(this, r);
+        Executor bukkitAsyncExecutor = r -> getServer().getScheduler().runTaskAsynchronously(this, r);
+
         log = LogFactory.wrap(getLogger());
+        debugHandler = new DebugHandler(bukkitAsyncExecutor);
+        senderFactory = new BukkitSenderFactory(this);
+        permissionCache = new PermissionCache(bukkitAsyncExecutor);
 
         getLog().info("Loading configuration...");
         configuration = new BukkitConfig(this);
 
+        // setup the Bukkit defaults hook
+        defaultsProvider = new DefaultsProvider();
+        childPermissionProvider = new ChildPermissionProvider();
+
+        // give all plugins a chance to load their defaults, then refresh.
+        getServer().getScheduler().runTaskLater(this, () -> {
+            defaultsProvider.refresh();
+            childPermissionProvider.setup();
+
+            getServer().getScheduler().runTaskAsynchronously(this, () -> {
+                for (Map.Entry<String, Boolean> e : defaultsProvider.getOpDefaults().entrySet()) {
+                    permissionCache.offer(e.getKey());
+                }
+
+                for (Map.Entry<String, Boolean> e : defaultsProvider.getNonOpDefaults().entrySet()) {
+                    permissionCache.offer(e.getKey());
+                }
+
+                ImmutableMap<Map.Entry<String, Boolean>, ImmutableMap<String, Boolean>> permissions = childPermissionProvider.getPermissions();
+                for (Map.Entry<Map.Entry<String, Boolean>, ImmutableMap<String, Boolean>> e : permissions.entrySet()) {
+                    permissionCache.offer(e.getKey().getKey());
+                    for (Map.Entry<String, Boolean> e1 : e.getValue().entrySet()) {
+                        permissionCache.offer(e1.getKey());
+                    }
+                }
+            });
+
+        }, 1L);
+
+        // register events
+        PluginManager pm = getServer().getPluginManager();
+        pm.registerEvents(new BukkitListener(this), this);
+
+        // initialise datastore
+        storage = StorageFactory.getInstance(this, "h2");
+
+        // initialise redis
+        if (getConfiguration().isRedisEnabled()) {
+            getLog().info("Loading redis...");
+            redisMessaging = new RedisMessaging(this);
+            try {
+                redisMessaging.init(getConfiguration().getRedisAddress(), getConfiguration().getRedisPassword());
+                getLog().info("Loaded redis successfully...");
+            } catch (Exception e) {
+                getLog().info("Couldn't load redis...");
+                e.printStackTrace();
+            }
+        }
+
+        // setup the update task buffer
+        updateTaskBuffer = new BufferedRequest<Void>(1000L, this::doAsync) {
+            @Override
+            protected Void perform() {
+                new UpdateTask(LPBukkitPlugin.this).run();
+                return null;
+            }
+        };
+
+        // load locale
         localeManager = new LocaleManager();
         File locale = new File(getDataFolder(), "lang.yml");
         if (locale.exists()) {
@@ -103,13 +201,6 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
             }
         }
 
-        defaultsProvider = new DefaultsProvider();
-        getServer().getScheduler().runTaskLater(this, () -> defaultsProvider.refresh(), 1L);
-
-        // register events
-        PluginManager pm = getServer().getPluginManager();
-        pm.registerEvents(new BukkitListener(this), this);
-
         // register commands
         getLog().info("Registering commands...");
         BukkitCommand commandManager = new BukkitCommand(this);
@@ -118,13 +209,12 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
         main.setTabCompleter(commandManager);
         main.setAliases(Arrays.asList("perms", "lp", "permissions", "p", "perm"));
 
-        datastore = StorageFactory.getDatastore(this, "h2");
-
+        // load internal managers
         getLog().info("Loading internal permission managers...");
         uuidCache = new UuidCache(getConfiguration().isOnlineMode());
-        userManager = new UserManager(this);
-        groupManager = new GroupManager(this);
-        trackManager = new TrackManager();
+        userManager = new GenericUserManager(this);
+        groupManager = new GenericGroupManager(this);
+        trackManager = new GenericTrackManager();
         importer = new Importer(commandManager);
         consecutiveExecutor = new ConsecutiveExecutor(commandManager);
         calculatorFactory = new BukkitCalculatorFactory(this);
@@ -135,56 +225,60 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
         contextManager.registerCalculator(worldCalculator);
         contextManager.registerCalculator(new ServerCalculator<>(getConfiguration().getServer()));
 
-        int mins = getConfiguration().getSyncTime();
-        if (mins > 0) {
-            long ticks = mins * 60 * 20;
-            getServer().getScheduler().runTaskTimerAsynchronously(this, new UpdateTask(this), ticks, ticks);
+        // handle server operators
+        if (getConfiguration().isAutoOp()) {
+            contextManager.registerListener(new AutoOPListener());
         }
 
-        getServer().getScheduler().runTaskTimer(this, BukkitSenderFactory.get(this), 1L, 1L);
-        getServer().getScheduler().runTaskTimerAsynchronously(this, new ExpireTemporaryTask(this), 60L, 60L);
-        getServer().getScheduler().runTaskTimerAsynchronously(this, consecutiveExecutor, 20L, 20L);
-
         // Provide vault support
-        getLog().info("Attempting to hook into Vault...");
-        try {
-            if (getServer().getPluginManager().isPluginEnabled("Vault")) {
-                vaultHook = new VaultHook();
-                vaultHook.hook(this);
-                getLog().info("Registered Vault permission & chat hook.");
-            } else {
-                getLog().info("Vault not found.");
-            }
-        } catch (Exception e) {
-            getLog().severe("Error occurred whilst hooking into Vault.");
-            e.printStackTrace();
-        }
+        tryVaultHook(false);
 
+        // register with the LP API
         getLog().info("Registering API...");
         apiProvider = new ApiProvider(this);
         ApiHandler.registerProvider(apiProvider);
         getServer().getServicesManager().register(LuckPermsApi.class, apiProvider, this, ServicePriority.Normal);
 
-        // Run update task to refresh any online users
-        getLog().info("Scheduling Update Task to refresh any online users.");
-        try {
-            new UpdateTask(this).run();
-        } catch (Exception e) {
-            e.printStackTrace();
+
+        // schedule update tasks
+        int mins = getConfiguration().getSyncTime();
+        if (mins > 0) {
+            long ticks = mins * 60 * 20;
+            getServer().getScheduler().runTaskTimerAsynchronously(this, () -> updateTaskBuffer.request(), 20L, ticks);
         }
 
+        // run an update instantly.
+        updateTaskBuffer.requestDirectly();
+
+        // register tasks
+        getServer().getScheduler().runTaskTimerAsynchronously(this, new ExpireTemporaryTask(this), 60L, 60L);
+        getServer().getScheduler().runTaskTimerAsynchronously(this, consecutiveExecutor, 20L, 20L);
+
+        // register permissions
         registerPermissions(getConfiguration().isCommandsAllowOp() ? PermissionDefault.OP : PermissionDefault.FALSE);
         if (!getConfiguration().isOpsEnabled()) {
-            getServer().getOperators().forEach(o -> o.setOp(false));
+            getServer().getScheduler().runTask(this, () -> getServer().getOperators().forEach(o -> o.setOp(false)));
         }
 
+        // replace the temporary executor when the Bukkit one starts
+        getServer().getScheduler().runTaskAsynchronously(this, () -> {
+            asyncExecutor = bukkitAsyncExecutor;
+        });
+
+        started = true;
         getLog().info("Successfully loaded.");
     }
 
     @Override
     public void onDisable() {
+        started = false;
         getLog().info("Closing datastore...");
-        datastore.shutdown();
+        storage.shutdown();
+
+        if (redisMessaging != null) {
+            getLog().info("Closing redis...");
+            redisMessaging.shutdown();
+        }
 
         getLog().info("Unregistering API...");
         ApiHandler.unregisterProvider();
@@ -195,14 +289,40 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
         }
     }
 
+    public void tryVaultHook(boolean force) {
+        if (vaultHook != null) {
+            return;
+        }
+
+        getLog().info("Attempting to hook with Vault...");
+        try {
+            if (force || getServer().getPluginManager().isPluginEnabled("Vault")) {
+                vaultHook = new VaultHook();
+                vaultHook.hook(this);
+                getLog().info("Registered Vault permission & chat hook.");
+            } else {
+                getLog().info("Vault not found.");
+            }
+        } catch (Exception e) {
+            vaultHook = null;
+            getLog().severe("Error occurred whilst hooking into Vault.");
+            e.printStackTrace();
+        }
+    }
+
     @Override
     public void doAsync(Runnable r) {
-        getServer().getScheduler().runTaskAsynchronously(this, r);
+        asyncExecutor.execute(r);
     }
 
     @Override
     public void doSync(Runnable r) {
-        getServer().getScheduler().runTask(this, r);
+        syncExecutor.execute(r);
+    }
+
+    @Override
+    public void doAsyncRepeating(Runnable r, long interval) {
+        getServer().getScheduler().runTaskTimerAsynchronously(this, r, interval, interval);
     }
 
     @Override
@@ -221,8 +341,25 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
     }
 
     @Override
-    public Message getPlayerStatus(UUID uuid) {
-        return getServer().getPlayer(getUuidCache().getExternalUUID(uuid)) != null ? Message.PLAYER_ONLINE : Message.PLAYER_OFFLINE;
+    public Player getPlayer(User user) {
+        return getServer().getPlayer(uuidCache.getExternalUUID(user.getUuid()));
+    }
+
+    @Override
+    public Contexts getContextForUser(User user) {
+        Player player = getPlayer(user);
+        if (player == null) {
+            return null;
+        }
+        return new Contexts(
+                getContextManager().getApplicableContext(player),
+                getConfiguration().isIncludingGlobalPerms(),
+                getConfiguration().isIncludingGlobalWorldPerms(),
+                true,
+                getConfiguration().isApplyingGlobalGroups(),
+                getConfiguration().isApplyingGlobalWorldGroups(),
+                player.isOp()
+        );
     }
 
     @Override
@@ -236,46 +373,55 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
     }
 
     @Override
-    public List<Sender> getNotifyListeners() {
+    public Set<UUID> getOnlinePlayers() {
+        return getServer().getOnlinePlayers().stream().map(Player::getUniqueId).collect(Collectors.toSet());
+    }
+
+    @Override
+    public boolean isOnline(UUID external) {
+        return getServer().getPlayer(external) != null;
+    }
+
+    @Override
+    public List<Sender> getSenders() {
         return getServer().getOnlinePlayers().stream()
-                .map(p -> BukkitSenderFactory.get(this).wrap(p, Collections.singleton(me.lucko.luckperms.common.constants.Permission.LOG_NOTIFY)))
-                .filter(me.lucko.luckperms.common.constants.Permission.LOG_NOTIFY::isAuthorized)
+                .map(p -> getSenderFactory().wrap(p))
                 .collect(Collectors.toList());
     }
 
     @Override
     public Sender getConsoleSender() {
-        return BukkitSenderFactory.get(this).wrap(getServer().getConsoleSender());
+        return getSenderFactory().wrap(getServer().getConsoleSender());
     }
 
     @Override
     public Set<Contexts> getPreProcessContexts(boolean op) {
-        Set<Map<String, String>> c = new HashSet<>();
-        c.add(Collections.emptyMap());
-        c.add(Collections.singletonMap("server", getConfiguration().getServer()));
+        Set<ContextSet> c = new HashSet<>();
+        c.add(ContextSet.empty());
+        c.add(ContextSet.singleton("server", getConfiguration().getServer()));
 
         // Pre process all worlds
         c.addAll(getServer().getWorlds().stream()
                 .map(World::getName)
                 .map(s -> {
-                    Map<String, String> map = new HashMap<>();
-                    map.put("server", getConfiguration().getServer());
-                    map.put("world", s);
-                    return map;
+                    MutableContextSet set = MutableContextSet.create();
+                    set.add("server", getConfiguration().getServer());
+                    set.add("world", s);
+                    return set.makeImmutable();
                 })
                 .collect(Collectors.toList())
         );
 
         // Pre process the separate Vault server, if any
         if (!getConfiguration().getServer().equals(getConfiguration().getVaultServer())) {
-            c.add(Collections.singletonMap("server", getConfiguration().getVaultServer()));
+            c.add(ContextSet.singleton("server", getConfiguration().getVaultServer()));
             c.addAll(getServer().getWorlds().stream()
                     .map(World::getName)
                     .map(s -> {
-                        Map<String, String> map = new HashMap<>();
-                        map.put("server", getConfiguration().getVaultServer());
-                        map.put("world", s);
-                        return map;
+                        MutableContextSet set = MutableContextSet.create();
+                        set.add("server", getConfiguration().getVaultServer());
+                        set.add("world", s);
+                        return set.makeImmutable();
                     })
                     .collect(Collectors.toList())
             );
@@ -285,8 +431,8 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
 
         // Convert to full Contexts
         contexts.addAll(c.stream()
-                .map(map -> new Contexts(
-                        map,
+                .map(set -> new Contexts(
+                        set,
                         getConfiguration().isIncludingGlobalPerms(),
                         getConfiguration().isIncludingGlobalWorldPerms(),
                         true,
@@ -298,12 +444,12 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
         );
 
         // Check for and include varying Vault config options
-        try {
-            assert getConfiguration().isVaultIncludingGlobal() == getConfiguration().isIncludingGlobalPerms();
-            assert getConfiguration().isIncludingGlobalWorldPerms();
-            assert getConfiguration().isApplyingGlobalGroups();
-            assert getConfiguration().isApplyingGlobalWorldGroups();
-        } catch (AssertionError e) {
+        boolean vaultDiff = getConfiguration().isVaultIncludingGlobal() != getConfiguration().isIncludingGlobalPerms() ||
+                !getConfiguration().isIncludingGlobalWorldPerms() ||
+                !getConfiguration().isApplyingGlobalGroups() ||
+                !getConfiguration().isApplyingGlobalWorldGroups();
+
+        if (vaultDiff) {
             contexts.addAll(c.stream()
                     .map(map -> new Contexts(map, getConfiguration().isVaultIncludingGlobal(), true, true, true, true, op))
                     .collect(Collectors.toSet())
@@ -313,6 +459,24 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
         return contexts;
     }
 
+    @Override
+    public LinkedHashMap<String, Object> getExtraInfo() {
+        LinkedHashMap<String, Object> map = new LinkedHashMap<>();
+        map.put("Vault Enabled", vaultHook != null);
+        map.put("Vault Server", configuration.getVaultServer());
+        map.put("Bukkit Defaults count", defaultsProvider.size());
+        map.put("Bukkit Child Permissions count", childPermissionProvider.getPermissions().size());
+        map.put("World Cache size", worldCalculator.getWorldCache().size());
+        map.put("Vault Including Global", configuration.isVaultIncludingGlobal());
+        map.put("Vault Ignoring World", configuration.isVaultIgnoreWorld());
+        map.put("Vault Primary Group Overrides", configuration.isVaultPrimaryGroupOverrides());
+        map.put("Vault Debug", configuration.isVaultDebug());
+        map.put("OPs Enabled", configuration.isOpsEnabled());
+        map.put("Auto OP", configuration.isAutoOp());
+        map.put("Commands Allow OPs", configuration.isCommandsAllowOp());
+        return map;
+    }
+
     @Override
     public Object getPlugin(String name) {
         return getServer().getPluginManager().getPlugin(name);
@@ -338,38 +502,13 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
         return getServer().getPluginManager().isPluginEnabled(name);
     }
 
-    @Override
-    public void runUpdateTask() {
-        getServer().getScheduler().runTaskAsynchronously(this, new UpdateTask(this));
-    }
-
     private void registerPermissions(PermissionDefault def) {
         PluginManager pm = getServer().getPluginManager();
 
-        Map<String, List<String>> wildcards = new HashMap<>();
-        List<String> all = new ArrayList<>();
-        for (me.lucko.luckperms.common.constants.Permission p : me.lucko.luckperms.common.constants.Permission.values()) {
-            pm.addPermission(new Permission(p.getNode(), def));
-            if (p.getGroup() != null) {
-                if (!wildcards.containsKey(p.getGroup())) {
-                    wildcards.put(p.getGroup(), new ArrayList<>());
-                }
-                wildcards.get(p.getGroup()).add(p.getTag());
+        for (Permission p : Permission.values()) {
+            for (String node : p.getNodes()) {
+                pm.addPermission(new org.bukkit.permissions.Permission(node, def));
             }
-
-            all.add(p.getNode());
         }
-
-        for (Map.Entry<String, List<String>> e : wildcards.entrySet()) {
-            pm.addPermission(new Permission(
-                    "luckperms." + e.getKey() + ".*", def,
-                    e.getValue().stream()
-                            .map(tag -> "luckperms." + e.getKey() + "." + tag)
-                            .collect(Collectors.toMap(s -> s, s -> true))
-                    )
-            );
-        }
-
-        pm.addPermission(new Permission("luckperms.*", def, all.stream().collect(Collectors.toMap(s -> s, s -> true))));
     }
 }

bukkit/src/main/java/me/lucko/luckperms/bukkit/WorldCalculator.java

@@ -22,16 +22,21 @@
 
 package me.lucko.luckperms.bukkit;
 
-import com.google.common.collect.Maps;
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
+
+import com.google.common.collect.Maps;
+
 import me.lucko.luckperms.api.context.ContextCalculator;
+import me.lucko.luckperms.api.context.MutableContextSet;
 import me.lucko.luckperms.common.LuckPermsPlugin;
+
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
 import org.bukkit.event.player.PlayerChangedWorldEvent;
+import org.bukkit.event.player.PlayerLoginEvent;
 
 import java.util.Map;
 import java.util.UUID;
@@ -47,11 +52,11 @@ public class WorldCalculator extends ContextCalculator<Player> implements Listen
     private final Map<UUID, String> worldCache = new ConcurrentHashMap<>();
 
     @Override
-    public Map<String, String> giveApplicableContext(Player subject, Map<String, String> accumulator) {
+    public MutableContextSet giveApplicableContext(Player subject, MutableContextSet accumulator) {
         String world = getWorld(subject);
 
         if (world != null) {
-            accumulator.put(WORLD_KEY, world);
+            accumulator.add(Maps.immutableEntry(WORLD_KEY, world));
         }
 
         return accumulator;
@@ -69,14 +74,25 @@ public class WorldCalculator extends ContextCalculator<Player> implements Listen
 
     private String getWorld(Player player) {
         UUID internal = plugin.getUuidCache().getUUID(player.getUniqueId());
-        if (!worldCache.containsKey(internal)) {
+        String world = worldCache.get(internal);
+        if (world == null) {
             return null;
         }
 
-        String world = worldCache.get(internal);
         return plugin.getConfiguration().getWorldRewrites().getOrDefault(world, world);
     }
 
+    @EventHandler(priority = EventPriority.LOW)
+    public void onPlayerJoin(PlayerLoginEvent e) {
+        UUID internal = plugin.getUuidCache().getUUID(e.getPlayer().getUniqueId());
+        worldCache.put(internal, e.getPlayer().getWorld().getName());
+        pushUpdate(
+                e.getPlayer(),
+                Maps.immutableEntry(WORLD_KEY, null),
+                Maps.immutableEntry(WORLD_KEY, e.getPlayer().getWorld().getName())
+        );
+    }
+
     @EventHandler(priority = EventPriority.LOWEST)
     public void onPlayerChangedWorld(PlayerChangedWorldEvent e) {
         UUID internal = plugin.getUuidCache().getUUID(e.getPlayer().getUniqueId());

bukkit/src/main/java/me/lucko/luckperms/bukkit/calculators/AttachmentProcessor.java

@@ -24,8 +24,10 @@ package me.lucko.luckperms.bukkit.calculators;
 
 import lombok.AllArgsConstructor;
 import lombok.Getter;
+
 import me.lucko.luckperms.api.Tristate;
 import me.lucko.luckperms.common.calculators.PermissionProcessor;
+
 import org.bukkit.permissions.PermissionAttachmentInfo;
 
 import java.util.Map;
@@ -44,10 +46,13 @@ public class AttachmentProcessor implements PermissionProcessor {
             return Tristate.UNDEFINED;
         }
 
-        if (m.containsKey(permission)) {
-            return Tristate.fromBoolean(m.get(permission).getValue());
-        }
-        return Tristate.UNDEFINED;
+        PermissionAttachmentInfo pai = m.get(permission);
+        return pai == null ? Tristate.UNDEFINED : Tristate.fromBoolean(pai.getValue());
+    }
+
+    @Override
+    public void updateBacking(Map<String, Boolean> map) {
+        // Do nothing, this doesn't use the backing
     }
 
 }

bukkit/src/main/java/me/lucko/luckperms/bukkit/calculators/AutoOPListener.java

@@ -0,0 +1,48 @@
+/*
+ * 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.bukkit.calculators;
+
+import me.lucko.luckperms.api.context.ContextListener;
+import me.lucko.luckperms.bukkit.inject.Injector;
+import me.lucko.luckperms.bukkit.model.LPPermissible;
+
+import org.bukkit.entity.Player;
+
+import java.util.Map;
+import java.util.Optional;
+
+public class AutoOPListener implements ContextListener<Player> {
+
+    @Override
+    public void onContextChange(Player subject, Map.Entry<String, String> before, Map.Entry<String, String> current) throws Exception {
+        LPPermissible permissible = Injector.getPermissible(subject.getUniqueId());
+        if (permissible == null) {
+            return;
+        }
+
+        Map<String, Boolean> backing = permissible.getUser().getUserData().getPermissionData(permissible.calculateContexts()).getImmutableBacking();
+        boolean op = Optional.ofNullable(backing.get("luckperms.autoop")).orElse(false);
+        subject.setOp(op);
+    }
+
+}

bukkit/src/main/java/me/lucko/luckperms/bukkit/calculators/ChildProcessor.java

@@ -0,0 +1,55 @@
+/*
+ * 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.bukkit.calculators;
+
+import lombok.RequiredArgsConstructor;
+
+import me.lucko.luckperms.api.Tristate;
+import me.lucko.luckperms.bukkit.model.ChildPermissionProvider;
+import me.lucko.luckperms.common.calculators.PermissionProcessor;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+@RequiredArgsConstructor
+public class ChildProcessor implements PermissionProcessor {
+    private final ChildPermissionProvider provider;
+    private Map<String, Boolean> childPermissions = new ConcurrentHashMap<>();
+
+    @Override
+    public Tristate hasPermission(String permission) {
+        Boolean b = childPermissions.get(permission);
+        return b == null ? Tristate.UNDEFINED : Tristate.fromBoolean(b);
+    }
+
+    @Override
+    public void updateBacking(Map<String, Boolean> map) {
+        childPermissions.clear();
+        for (Map.Entry<String, Boolean> e : map.entrySet()) {
+            Map<String, Boolean> children = provider.getPermissions().get(e);
+            if (children != null) {
+                childPermissions.putAll(children);
+            }
+        }
+    }
+}

bukkit/src/main/java/me/lucko/luckperms/bukkit/calculators/DefaultsProcessor.java

@@ -23,11 +23,16 @@
 package me.lucko.luckperms.bukkit.calculators;
 
 import lombok.AllArgsConstructor;
+
 import me.lucko.luckperms.api.Tristate;
+import me.lucko.luckperms.bukkit.model.DefaultsProvider;
 import me.lucko.luckperms.common.calculators.PermissionProcessor;
+
 import org.bukkit.Bukkit;
 import org.bukkit.permissions.Permission;
 
+import java.util.Map;
+
 @AllArgsConstructor
 public class DefaultsProcessor implements PermissionProcessor {
     private final boolean isOp;
@@ -41,10 +46,11 @@ public class DefaultsProcessor implements PermissionProcessor {
         }
 
         Permission defPerm = Bukkit.getServer().getPluginManager().getPermission(permission);
-        if (defPerm != null) {
-            return Tristate.fromBoolean(defPerm.getDefault().getValue(isOp));
-        } else {
-            return Tristate.UNDEFINED;
-        }
+        return defPerm == null ? Tristate.UNDEFINED : Tristate.fromBoolean(defPerm.getDefault().getValue(isOp));
+    }
+
+    @Override
+    public void updateBacking(Map<String, Boolean> map) {
+        // Do nothing, this doesn't use the backing
     }
 }

bukkit/src/main/java/me/lucko/luckperms/bukkit/inject/Injector.java

@@ -23,6 +23,9 @@
 package me.lucko.luckperms.bukkit.inject;
 
 import lombok.experimental.UtilityClass;
+
+import me.lucko.luckperms.bukkit.model.LPPermissible;
+
 import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
 import org.bukkit.permissions.Permissible;

bukkit/src/main/java/me/lucko/luckperms/bukkit/migration/MigrationBPermissions.java

@@ -20,24 +20,36 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.common.commands.migration.subcommands;
+package me.lucko.luckperms.bukkit.migration;
+
+import de.bananaco.bpermissions.api.Calculable;
+import de.bananaco.bpermissions.api.CalculableType;
+import de.bananaco.bpermissions.api.Group;
+import de.bananaco.bpermissions.api.Permission;
+import de.bananaco.bpermissions.api.World;
+import de.bananaco.bpermissions.api.WorldManager;
 
-import de.bananaco.bpermissions.api.*;
 import me.lucko.luckperms.api.Logger;
+import me.lucko.luckperms.api.MetaUtils;
 import me.lucko.luckperms.common.LuckPermsPlugin;
+import me.lucko.luckperms.common.commands.CommandException;
 import me.lucko.luckperms.common.commands.CommandResult;
-import me.lucko.luckperms.common.commands.Predicate;
-import me.lucko.luckperms.common.commands.Sender;
 import me.lucko.luckperms.common.commands.SubCommand;
+import me.lucko.luckperms.common.commands.sender.Sender;
 import me.lucko.luckperms.common.constants.Constants;
-import me.lucko.luckperms.common.core.PermissionHolder;
+import me.lucko.luckperms.common.core.model.PermissionHolder;
+import me.lucko.luckperms.common.core.model.User;
 import me.lucko.luckperms.common.data.LogEntry;
-import me.lucko.luckperms.common.utils.ArgumentChecker;
+import me.lucko.luckperms.common.utils.Predicates;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
 
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
-import java.util.*;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
 
 import static me.lucko.luckperms.common.constants.Permission.MIGRATION;
 
@@ -81,98 +93,6 @@ public class MigrationBPermissions extends SubCommand<Object> {
         }
     }
 
-    public MigrationBPermissions() {
-        super("bpermissions", "Migration from bPermissions", MIGRATION, Predicate.alwaysFalse(), null);
-    }
-
-    @Override
-    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List<String> args, String label) {
-        final Logger log = plugin.getLog();
-
-        WorldManager worldManager = WorldManager.getInstance();
-        if (worldManager == null) {
-            log.severe("bPermissions Migration: Error -> bPermissions is not loaded.");
-            return CommandResult.STATE_ERROR;
-        }
-
-        log.info("bPermissions Migration: Forcing the plugin to load all data. This could take a while.");
-        for (World world : worldManager.getAllWorlds()) {
-            Set<String> users = getUsers(world);
-            if (users == null) {
-                log.severe("bPermissions Migration: Couldn't get a list of users.");
-                return CommandResult.FAILURE;
-            }
-            users.forEach(s -> world.loadOne(s, CalculableType.USER));
-        }
-
-        // Migrate one world at a time.
-        log.info("bPermissions Migration: Starting world migration.");
-        for (World world : worldManager.getAllWorlds()) {
-            log.info("bPermissions Migration: Migrating world: " + world.getName());
-            
-            // Migrate all groups
-            log.info("bPermissions Migration: Starting group migration in world " + world.getName() + ".");
-            int groupCount = 0;
-            for (Calculable group : world.getAll(CalculableType.GROUP)) {
-                groupCount++;
-                String groupName = group.getName().toLowerCase();
-                if (group.getName().equalsIgnoreCase(world.getDefaultGroup())) {
-                    groupName = "default";
-                }
-
-                // Make a LuckPerms group for the one being migrated.
-                plugin.getDatastore().createAndLoadGroup(groupName);
-                me.lucko.luckperms.common.groups.Group lpGroup = plugin.getGroupManager().get(groupName);
-                try {
-                    LogEntry.build()
-                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
-                            .acted(lpGroup).action("create")
-                            .build().submit(plugin);
-                } catch (Exception ex) {
-                    ex.printStackTrace();
-                }
-                
-                migrateHolder(plugin, world, group, lpGroup);
-                plugin.getDatastore().saveGroup(lpGroup);
-            }
-            log.info("bPermissions Migration: Migrated " + groupCount + " groups in world " + world.getName() + ".");
-
-            // Migrate all users
-            log.info("bPermissions Migration: Starting user migration in world " + world.getName() + ".");
-            int userCount = 0;
-            for (Calculable user : world.getAll(CalculableType.USER)) {
-                userCount++;
-
-                // There is no mention of UUIDs in the API. I assume that name = uuid. idk?
-                UUID uuid;
-                try {
-                    uuid = UUID.fromString(user.getName());
-                } catch (IllegalArgumentException e) {
-                    uuid = plugin.getUUID(user.getName());
-                }
-
-                if (uuid == null) {
-                    log.info("bPermissions Migration: Unable to migrate user " + user.getName() + ". Unable to get UUID.");
-                    continue;
-                }
-
-                // Make a LuckPerms user for the one being migrated.
-                plugin.getDatastore().loadUser(uuid, "null");
-                me.lucko.luckperms.common.users.User lpUser = plugin.getUserManager().get(uuid);
-
-                migrateHolder(plugin, world, user, lpUser);
-
-                plugin.getDatastore().saveUser(lpUser);
-                plugin.getUserManager().cleanup(lpUser);
-            }
-
-            log.info("bPermissions Migration: Migrated " + userCount + " users in world " + world.getName() + ".");
-        }
-
-        log.info("bPermissions Migration: Success! Completed without any errors.");
-        return CommandResult.SUCCESS;
-    }
-    
     private static void migrateHolder(LuckPermsPlugin plugin, World world, Calculable c, PermissionHolder holder) {
         // Migrate the groups permissions in this world
         for (Permission p : c.getPermissions()) {
@@ -222,7 +142,7 @@ public class MigrationBPermissions extends SubCommand<Object> {
         // Migrate existing meta
         for (Map.Entry<String, String> meta : c.getMeta().entrySet()) {
             if (meta.getKey().equalsIgnoreCase("prefix") || meta.getKey().equalsIgnoreCase("suffix")) {
-                String chatMeta = ArgumentChecker.escapeCharacters(meta.getValue());
+                String chatMeta = MetaUtils.escapeCharacters(meta.getValue());
                 try {
                     holder.setPermission(meta.getKey().toLowerCase() + "." + c.getPriority() + "." + chatMeta, true);
                     LogEntry.build()
@@ -250,4 +170,96 @@ public class MigrationBPermissions extends SubCommand<Object> {
             }
         }
     }
+
+    public MigrationBPermissions() {
+        super("bpermissions", "Migration from bPermissions", MIGRATION, Predicates.alwaysFalse(), null);
+    }
+
+    @Override
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List<String> args, String label) throws CommandException {
+        final Logger log = plugin.getLog();
+
+        WorldManager worldManager = WorldManager.getInstance();
+        if (worldManager == null) {
+            log.severe("bPermissions Migration: Error -> bPermissions is not loaded.");
+            return CommandResult.STATE_ERROR;
+        }
+
+        log.info("bPermissions Migration: Forcing the plugin to load all data. This could take a while.");
+        for (World world : worldManager.getAllWorlds()) {
+            Set<String> users = getUsers(world);
+            if (users == null) {
+                log.severe("bPermissions Migration: Couldn't get a list of users.");
+                return CommandResult.FAILURE;
+            }
+            users.forEach(s -> world.loadOne(s, CalculableType.USER));
+        }
+
+        // Migrate one world at a time.
+        log.info("bPermissions Migration: Starting world migration.");
+        for (World world : worldManager.getAllWorlds()) {
+            log.info("bPermissions Migration: Migrating world: " + world.getName());
+
+            // Migrate all groups
+            log.info("bPermissions Migration: Starting group migration in world " + world.getName() + ".");
+            int groupCount = 0;
+            for (Calculable group : world.getAll(CalculableType.GROUP)) {
+                groupCount++;
+                String groupName = group.getName().toLowerCase();
+                if (group.getName().equalsIgnoreCase(world.getDefaultGroup())) {
+                    groupName = "default";
+                }
+
+                // Make a LuckPerms group for the one being migrated.
+                plugin.getStorage().createAndLoadGroup(groupName).join();
+                me.lucko.luckperms.common.core.model.Group lpGroup = plugin.getGroupManager().getIfLoaded(groupName);
+                try {
+                    LogEntry.build()
+                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                            .acted(lpGroup).action("create")
+                            .build().submit(plugin);
+                } catch (Exception ex) {
+                    ex.printStackTrace();
+                }
+
+                migrateHolder(plugin, world, group, lpGroup);
+                plugin.getStorage().saveGroup(lpGroup);
+            }
+            log.info("bPermissions Migration: Migrated " + groupCount + " groups in world " + world.getName() + ".");
+
+            // Migrate all users
+            log.info("bPermissions Migration: Starting user migration in world " + world.getName() + ".");
+            int userCount = 0;
+            for (Calculable user : world.getAll(CalculableType.USER)) {
+                userCount++;
+
+                // There is no mention of UUIDs in the API. I assume that name = uuid. idk?
+                UUID uuid;
+                try {
+                    uuid = UUID.fromString(user.getName());
+                } catch (IllegalArgumentException e) {
+                    uuid = plugin.getUUID(user.getName());
+                }
+
+                if (uuid == null) {
+                    log.info("bPermissions Migration: Unable to migrate user " + user.getName() + ". Unable to get UUID.");
+                    continue;
+                }
+
+                // Make a LuckPerms user for the one being migrated.
+                plugin.getStorage().loadUser(uuid, "null").join();
+                User lpUser = plugin.getUserManager().get(uuid);
+
+                migrateHolder(plugin, world, user, lpUser);
+
+                plugin.getStorage().saveUser(lpUser);
+                plugin.getUserManager().cleanup(lpUser);
+            }
+
+            log.info("bPermissions Migration: Migrated " + userCount + " users in world " + world.getName() + ".");
+        }
+
+        log.info("bPermissions Migration: Success! Completed without any errors.");
+        return CommandResult.SUCCESS;
+    }
 }

bukkit/src/main/java/me/lucko/luckperms/bukkit/migration/MigrationGroupManager.java

@@ -20,15 +20,23 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.common.commands.migration.subcommands;
+package me.lucko.luckperms.bukkit.migration;
 
 import me.lucko.luckperms.api.Logger;
 import me.lucko.luckperms.common.LuckPermsPlugin;
-import me.lucko.luckperms.common.commands.*;
+import me.lucko.luckperms.common.commands.Arg;
+import me.lucko.luckperms.common.commands.CommandException;
+import me.lucko.luckperms.common.commands.CommandResult;
+import me.lucko.luckperms.common.commands.SubCommand;
+import me.lucko.luckperms.common.commands.sender.Sender;
 import me.lucko.luckperms.common.constants.Constants;
 import me.lucko.luckperms.common.constants.Permission;
+import me.lucko.luckperms.common.core.NodeFactory;
 import me.lucko.luckperms.common.data.LogEntry;
+import me.lucko.luckperms.common.utils.Predicates;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
+
 import org.anjocaido.groupmanager.GlobalGroups;
 import org.anjocaido.groupmanager.GroupManager;
 import org.anjocaido.groupmanager.data.Group;
@@ -36,19 +44,22 @@ import org.anjocaido.groupmanager.data.User;
 import org.anjocaido.groupmanager.dataholder.WorldDataHolder;
 import org.anjocaido.groupmanager.dataholder.worlds.WorldsHolder;
 
-import java.lang.reflect.InvocationTargetException;
-import java.util.*;
+import java.util.AbstractMap;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
 import java.util.stream.Collectors;
 
 public class MigrationGroupManager extends SubCommand<Object> {
     public MigrationGroupManager() {
-        super("groupmanager", "Migration from GroupManager", Permission.MIGRATION, Predicate.is(0),
+        super("groupmanager", "Migration from GroupManager", Permission.MIGRATION, Predicates.is(0),
                 Arg.list(Arg.create("world names...", false, "a list of worlds to migrate permissions from"))
         );
     }
 
     @Override
-    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List<String> args, String label) {
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List<String> args, String label) throws CommandException {
         final Logger log = plugin.getLog();
         if (!plugin.isPluginLoaded("GroupManager")) {
             log.severe("GroupManager Migration: Error -> GroupManager is not loaded.");
@@ -63,18 +74,11 @@ public class MigrationGroupManager extends SubCommand<Object> {
 
         // Migrate Global Groups
         log.info("GroupManager Migration: Starting Global Group migration.");
-
-        GlobalGroups gg;
-        try {
-            gg = (GlobalGroups) GroupManager.class.getMethod("getGlobalGroups").invoke(gm);
-        } catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
-            e.printStackTrace();
-            return CommandResult.FAILURE;
-        }
+        GlobalGroups gg = GroupManager.getGlobalGroups();
 
         for (Group g : gg.getGroupList()) {
-            plugin.getDatastore().createAndLoadGroup(g.getName().toLowerCase());
-            me.lucko.luckperms.common.groups.Group group = plugin.getGroupManager().get(g.getName().toLowerCase());
+            plugin.getStorage().createAndLoadGroup(g.getName().toLowerCase()).join();
+            me.lucko.luckperms.common.core.model.Group group = plugin.getGroupManager().getIfLoaded(g.getName().toLowerCase());
             try {
                 LogEntry.build()
                         .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
@@ -121,33 +125,21 @@ public class MigrationGroupManager extends SubCommand<Object> {
                 }
             }
 
-            plugin.getDatastore().saveGroup(group);
+            plugin.getStorage().saveGroup(group);
         }
 
         Map<UUID, Map<Map.Entry<String, String>, Boolean>> users = new HashMap<>();
+        Map<UUID, String> primaryGroups = new HashMap<>();
         Map<String, Map<Map.Entry<String, String>, Boolean>> groups = new HashMap<>();
 
-        WorldsHolder wh;
-        try {
-            wh = (WorldsHolder) GroupManager.class.getMethod("getWorldsHolder").invoke(gm);
-        } catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
-            e.printStackTrace();
-            return CommandResult.FAILURE;
-        }
+        WorldsHolder wh = gm.getWorldsHolder();
 
         // Collect data for all users and groups.
         log.info("GroupManager Migration: Starting user and group migration.");
         for (String world : worlds) {
             world = world.toLowerCase();
 
-            WorldDataHolder wdh;
-
-            try {
-                wdh = (WorldDataHolder) WorldsHolder.class.getMethod("getWorldData", String.class).invoke(wh, world);
-            } catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
-                e.printStackTrace();
-                return CommandResult.FAILURE;
-            }
+            WorldDataHolder wdh = wh.getWorldData(world);
 
             for (Group g : wdh.getGroupList()) {
                 groups.putIfAbsent(g.getName().toLowerCase(), new HashMap<>());
@@ -174,7 +166,7 @@ public class MigrationGroupManager extends SubCommand<Object> {
                 UUID uuid;
                 try {
                     uuid = UUID.fromString(user.getUUID());
-                } catch (IllegalArgumentException e){
+                } catch (IllegalArgumentException e) {
                     continue;
                 }
 
@@ -193,7 +185,13 @@ public class MigrationGroupManager extends SubCommand<Object> {
                     users.get(uuid).put(new AbstractMap.SimpleEntry<>(world, node), value);
                 }
 
-                users.get(uuid).put(new AbstractMap.SimpleEntry<>(world, "group." + user.getGroupName().toLowerCase()), true);
+                String finalWorld = world;
+                users.get(uuid).putAll(user.subGroupListStringCopy().stream()
+                        .map(n -> "group." + n)
+                        .map(n -> new AbstractMap.SimpleEntry<>(finalWorld, n))
+                        .collect(Collectors.toMap(n -> n, n -> true))
+                );
+                primaryGroups.put(uuid, user.getGroupName());
             }
 
         }
@@ -202,8 +200,8 @@ public class MigrationGroupManager extends SubCommand<Object> {
         log.info("GroupManager Migration: Found a total of " + users.size() + " users and " + groups.size() + " groups.");
 
         for (Map.Entry<String, Map<Map.Entry<String, String>, Boolean>> e : groups.entrySet()) {
-            plugin.getDatastore().createAndLoadGroup(e.getKey());
-            me.lucko.luckperms.common.groups.Group group = plugin.getGroupManager().get(e.getKey());
+            plugin.getStorage().createAndLoadGroup(e.getKey()).join();
+            me.lucko.luckperms.common.core.model.Group group = plugin.getGroupManager().getIfLoaded(e.getKey());
             try {
                 LogEntry.build()
                         .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
@@ -219,7 +217,7 @@ public class MigrationGroupManager extends SubCommand<Object> {
                 // n.key.value = node
                 // n.value = true/false
                 try {
-                    group.setPermission("global-" + n.getKey().getKey() + "/" + n.getKey().getValue(), n.getValue());
+                    group.setPermission(NodeFactory.fromSerialisedNode("global-" + n.getKey().getKey() + "/" + n.getKey().getValue(), n.getValue()));
 
                     if (n.getKey().getValue().startsWith("group.")) {
                         String groupName = n.getKey().getValue().substring(6);
@@ -241,19 +239,19 @@ public class MigrationGroupManager extends SubCommand<Object> {
                 }
             }
 
-            plugin.getDatastore().saveGroup(group);
+            plugin.getStorage().saveGroup(group);
         }
 
         for (Map.Entry<UUID, Map<Map.Entry<String, String>, Boolean>> e : users.entrySet()) {
-            plugin.getDatastore().loadUser(e.getKey(), "null");
-            me.lucko.luckperms.common.users.User user = plugin.getUserManager().get(e.getKey());
+            plugin.getStorage().loadUser(e.getKey(), "null").join();
+            me.lucko.luckperms.common.core.model.User user = plugin.getUserManager().get(e.getKey());
 
             for (Map.Entry<Map.Entry<String, String>, Boolean> n : e.getValue().entrySet()) {
                 // n.key.key = world
                 // n.key.value = node
                 // n.value = true/false
                 try {
-                    user.setPermission("global-" + n.getKey().getKey() + "/" + n.getKey().getValue(), n.getValue());
+                    user.setPermission(NodeFactory.fromSerialisedNode("global-" + n.getKey().getKey() + "/" + n.getKey().getValue(), n.getValue()));
 
                     if (n.getKey().getValue().startsWith("group.")) {
                         String group = n.getKey().getValue().substring(6);
@@ -275,7 +273,20 @@ public class MigrationGroupManager extends SubCommand<Object> {
                 }
             }
 
-            plugin.getDatastore().saveUser(user);
+            String primaryGroup = primaryGroups.get(e.getKey());
+            if (primaryGroup != null) {
+                try {
+                    user.setPermission("group." + primaryGroup, true);
+                } catch (ObjectAlreadyHasException ignored) {
+                }
+                user.setPrimaryGroup(primaryGroup);
+                try {
+                    user.unsetPermission("group.default");
+                } catch (ObjectLacksException ignored) {
+                }
+            }
+
+            plugin.getStorage().saveUser(user);
             plugin.getUserManager().cleanup(user);
         }
 

bukkit/src/main/java/me/lucko/luckperms/bukkit/migration/MigrationPermissionsEx.java

@@ -20,41 +20,46 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.common.commands.migration.subcommands;
+package me.lucko.luckperms.bukkit.migration;
 
 import me.lucko.luckperms.api.Logger;
+import me.lucko.luckperms.api.MetaUtils;
 import me.lucko.luckperms.api.PlatformType;
 import me.lucko.luckperms.common.LuckPermsPlugin;
-import me.lucko.luckperms.common.commands.*;
+import me.lucko.luckperms.common.commands.Arg;
+import me.lucko.luckperms.common.commands.CommandException;
+import me.lucko.luckperms.common.commands.CommandResult;
+import me.lucko.luckperms.common.commands.SubCommand;
+import me.lucko.luckperms.common.commands.sender.Sender;
 import me.lucko.luckperms.common.constants.Constants;
 import me.lucko.luckperms.common.constants.Permission;
+import me.lucko.luckperms.common.core.model.Group;
+import me.lucko.luckperms.common.core.model.User;
 import me.lucko.luckperms.common.data.LogEntry;
-import me.lucko.luckperms.common.groups.Group;
-import me.lucko.luckperms.common.users.User;
-import me.lucko.luckperms.common.utils.ArgumentChecker;
+import me.lucko.luckperms.common.utils.Predicates;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+
+import java.lang.reflect.Field;
+import java.util.List;
+import java.util.UUID;
+import java.util.stream.Collectors;
+
 import ru.tehkode.permissions.NativeInterface;
 import ru.tehkode.permissions.PermissionGroup;
 import ru.tehkode.permissions.PermissionManager;
 import ru.tehkode.permissions.PermissionUser;
 import ru.tehkode.permissions.bukkit.PermissionsEx;
 
-import java.lang.reflect.Field;
-import java.lang.reflect.InvocationTargetException;
-import java.util.List;
-import java.util.UUID;
-import java.util.stream.Collectors;
-
 public class MigrationPermissionsEx extends SubCommand<Object> {
     public MigrationPermissionsEx() {
-        super("permissionsex", "Migration from PermissionsEx", Permission.MIGRATION, Predicate.alwaysFalse(),
+        super("permissionsex", "Migration from PermissionsEx", Permission.MIGRATION, Predicates.alwaysFalse(),
                 Arg.list(Arg.create("world names...", false, "a list of worlds to migrate permissions from"))
         );
     }
 
     @SuppressWarnings("deprecation")
     @Override
-    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List<String> args, String label) {
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List<String> args, String label) throws CommandException {
         final Logger log = plugin.getLog();
         if (!plugin.isPluginLoaded("PermissionsEx")) {
             log.severe("PermissionsEx Migration: Error -> PermissionsEx is not loaded.");
@@ -72,13 +77,7 @@ public class MigrationPermissionsEx extends SubCommand<Object> {
                 .collect(Collectors.toList());
 
         PermissionsEx pex = (PermissionsEx) plugin.getPlugin("PermissionsEx");
-        PermissionManager manager; // The compiler complains if you call the method directly, as Bukkit is not in this module.
-        try {
-            manager = (PermissionManager) PermissionsEx.class.getMethod("getPermissionsManager").invoke(pex);
-        } catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
-            e.printStackTrace();
-            return CommandResult.FAILURE;
-        }
+        PermissionManager manager = pex.getPermissionsManager();
 
         NativeInterface ni;
         try {
@@ -98,12 +97,12 @@ public class MigrationPermissionsEx extends SubCommand<Object> {
 
         for (PermissionGroup group : manager.getGroupList()) {
             int groupWeight = group.getWeight() * -1;
-            groupCount ++;
+            groupCount++;
             maxGroupWeight = Math.max(maxGroupWeight, groupWeight);
 
             final String name = group.getName().toLowerCase();
-            plugin.getDatastore().createAndLoadGroup(name);
-            Group lpGroup = plugin.getGroupManager().get(name);
+            plugin.getStorage().createAndLoadGroup(name).join();
+            Group lpGroup = plugin.getGroupManager().getIfLoaded(name);
             try {
                 LogEntry.build()
                         .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
@@ -197,7 +196,7 @@ public class MigrationPermissionsEx extends SubCommand<Object> {
             String suffix = group.getOwnSuffix();
 
             if (prefix != null && !prefix.equals("")) {
-                prefix = ArgumentChecker.escapeCharacters(prefix);
+                prefix = MetaUtils.escapeCharacters(prefix);
                 try {
                     lpGroup.setPermission("prefix." + groupWeight + "." + prefix, true);
                     LogEntry.build()
@@ -212,7 +211,7 @@ public class MigrationPermissionsEx extends SubCommand<Object> {
             }
 
             if (suffix != null && !suffix.equals("")) {
-                suffix = ArgumentChecker.escapeCharacters(suffix);
+                suffix = MetaUtils.escapeCharacters(suffix);
                 try {
                     lpGroup.setPermission("suffix." + groupWeight + "." + suffix, true);
                     LogEntry.build()
@@ -226,7 +225,7 @@ public class MigrationPermissionsEx extends SubCommand<Object> {
                 }
             }
 
-            plugin.getDatastore().saveGroup(lpGroup);
+            plugin.getStorage().saveGroup(lpGroup);
 
         }
 
@@ -254,7 +253,7 @@ public class MigrationPermissionsEx extends SubCommand<Object> {
             }
 
             userCount++;
-            plugin.getDatastore().loadUser(u, "null");
+            plugin.getStorage().loadUser(u, "null").join();
             User lpUser = plugin.getUserManager().get(u);
 
             try {
@@ -341,7 +340,7 @@ public class MigrationPermissionsEx extends SubCommand<Object> {
             String suffix = user.getOwnSuffix();
 
             if (prefix != null && !prefix.equals("")) {
-                prefix = ArgumentChecker.escapeCharacters(prefix);
+                prefix = MetaUtils.escapeCharacters(prefix);
                 try {
                     lpUser.setPermission("prefix." + maxGroupWeight + "." + prefix, true);
                     LogEntry.build()
@@ -356,7 +355,7 @@ public class MigrationPermissionsEx extends SubCommand<Object> {
             }
 
             if (suffix != null && !suffix.equals("")) {
-                suffix = ArgumentChecker.escapeCharacters(suffix);
+                suffix = MetaUtils.escapeCharacters(suffix);
                 try {
                     lpUser.setPermission("suffix." + maxGroupWeight + "." + suffix, true);
                     LogEntry.build()
@@ -382,12 +381,13 @@ public class MigrationPermissionsEx extends SubCommand<Object> {
             if (primary != null) {
                 try {
                     lpUser.setPermission("group." + primary.toLowerCase(), true);
-                } catch (ObjectAlreadyHasException ignored) {}
+                } catch (ObjectAlreadyHasException ignored) {
+                }
                 lpUser.setPrimaryGroup(primary);
             }
 
             plugin.getUserManager().cleanup(lpUser);
-            plugin.getDatastore().saveUser(lpUser);
+            plugin.getStorage().saveUser(lpUser);
         }
 
         log.info("PermissionsEx Migration: Migrated " + userCount + " users.");

bukkit/src/main/java/me/lucko/luckperms/bukkit/migration/MigrationPowerfulPerms.java

@@ -20,21 +20,33 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.common.commands.migration.subcommands;
+package me.lucko.luckperms.bukkit.migration;
 
-import com.github.cheesesoftware.PowerfulPermsAPI.*;
+import lombok.Cleanup;
+
+import com.github.cheesesoftware.PowerfulPermsAPI.CachedGroup;
+import com.github.cheesesoftware.PowerfulPermsAPI.Group;
+import com.github.cheesesoftware.PowerfulPermsAPI.Permission;
+import com.github.cheesesoftware.PowerfulPermsAPI.PermissionManager;
+import com.github.cheesesoftware.PowerfulPermsAPI.PowerfulPermsPlugin;
+import com.github.cheesesoftware.PowerfulPermsAPI.ResultRunnable;
 import com.google.common.util.concurrent.ListenableFuture;
 import com.zaxxer.hikari.HikariDataSource;
-import lombok.Cleanup;
+
 import me.lucko.luckperms.api.Logger;
 import me.lucko.luckperms.api.data.Callback;
+import me.lucko.luckperms.bukkit.migration.utils.LPResultRunnable;
 import me.lucko.luckperms.common.LuckPermsPlugin;
-import me.lucko.luckperms.common.commands.*;
-import me.lucko.luckperms.common.commands.migration.subcommands.utils.LPResultRunnable;
+import me.lucko.luckperms.common.commands.Arg;
+import me.lucko.luckperms.common.commands.CommandException;
+import me.lucko.luckperms.common.commands.CommandResult;
+import me.lucko.luckperms.common.commands.SubCommand;
+import me.lucko.luckperms.common.commands.sender.Sender;
 import me.lucko.luckperms.common.constants.Constants;
-import me.lucko.luckperms.common.core.PermissionHolder;
+import me.lucko.luckperms.common.core.model.PermissionHolder;
+import me.lucko.luckperms.common.core.model.User;
 import me.lucko.luckperms.common.data.LogEntry;
-import me.lucko.luckperms.common.users.User;
+import me.lucko.luckperms.common.utils.Predicates;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
 
 import java.lang.reflect.InvocationTargetException;
@@ -43,7 +55,13 @@ import java.sql.Connection;
 import java.sql.DatabaseMetaData;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
-import java.util.*;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutionException;
 
@@ -72,25 +90,29 @@ public class MigrationPowerfulPerms extends SubCommand<Object> {
         try {
             Class.forName("com.github.cheesesoftware.PowerfulPermsAPI.ResponseRunnable");
             legacy = true;
-        } catch (ClassNotFoundException ignored) {}
+        } catch (ClassNotFoundException ignored) {
+        }
 
         if (legacy) {
             try {
                 getPlayerPermissionsMethod = PermissionManager.class.getMethod("getPlayerOwnPermissions", UUID.class, ResultRunnable.class);
                 getPlayerPermissionsMethod.setAccessible(true);
-            } catch (NoSuchMethodException ignored) {}
+            } catch (NoSuchMethodException ignored) {
+            }
         } else {
             try {
                 getPlayerPermissionsMethod = PermissionManager.class.getMethod("getPlayerOwnPermissions", UUID.class);
                 getPlayerPermissionsMethod.setAccessible(true);
-            } catch (NoSuchMethodException ignored) {}
+            } catch (NoSuchMethodException ignored) {
+            }
         }
 
         try {
             getGroupMethod = CachedGroup.class.getMethod("getGroup");
             getGroupMethod.setAccessible(true);
             superLegacy = true;
-        } catch (NoSuchMethodException ignored) {}
+        } catch (NoSuchMethodException ignored) {
+        }
 
         if (!legacy) {
             try {
@@ -114,29 +136,6 @@ public class MigrationPowerfulPerms extends SubCommand<Object> {
         }
     }
 
-
-    public MigrationPowerfulPerms() {
-        super("powerfulperms", "Migration from PowerfulPerms", MIGRATION, Predicate.not(5),
-                Arg.list(
-                        Arg.create("address", true, "the address of the PP database"),
-                        Arg.create("database", true, "the name of the PP database"),
-                        Arg.create("username", true, "the username to log into the DB"),
-                        Arg.create("password", true, "the password to log into the DB"),
-                        Arg.create("db table", true, "the name of the PP table where player data is stored")
-                )
-        );
-    }
-
-    @Override
-    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List<String> args, String label) {
-        try {
-            return run(plugin, args);
-        } catch (Throwable t) {
-            t.printStackTrace();
-            return CommandResult.FAILURE;
-        }
-    }
-
     private static void getPlayerPermissions(PermissionManager manager, UUID uuid, Callback<List<Permission>> callback) {
         if (legacy) {
             try {
@@ -173,6 +172,28 @@ public class MigrationPowerfulPerms extends SubCommand<Object> {
         }
     }
 
+    public MigrationPowerfulPerms() {
+        super("powerfulperms", "Migration from PowerfulPerms", MIGRATION, Predicates.not(5),
+                Arg.list(
+                        Arg.create("address", true, "the address of the PP database"),
+                        Arg.create("database", true, "the name of the PP database"),
+                        Arg.create("username", true, "the username to log into the DB"),
+                        Arg.create("password", true, "the password to log into the DB"),
+                        Arg.create("db table", true, "the name of the PP table where player data is stored")
+                )
+        );
+    }
+
+    @Override
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List<String> args, String label) throws CommandException {
+        try {
+            return run(plugin, args);
+        } catch (Throwable t) {
+            t.printStackTrace();
+            return CommandResult.FAILURE;
+        }
+    }
+
     private CommandResult run(LuckPermsPlugin plugin, List<String> args) {
         final Logger log = plugin.getLog();
         if (!plugin.isPluginLoaded("PowerfulPerms")) {
@@ -246,8 +267,8 @@ public class MigrationPowerfulPerms extends SubCommand<Object> {
         log.info("PowerfulPerms Migration: Starting group migration.");
         Map<Integer, Group> groups = pm.getGroups(); // All versions
         for (Group g : groups.values()) {
-            plugin.getDatastore().createAndLoadGroup(g.getName().toLowerCase());
-            final me.lucko.luckperms.common.groups.Group group = plugin.getGroupManager().get(g.getName().toLowerCase());
+            plugin.getStorage().createAndLoadGroup(g.getName().toLowerCase()).join();
+            final me.lucko.luckperms.common.core.model.Group group = plugin.getGroupManager().getIfLoaded(g.getName().toLowerCase());
             try {
                 LogEntry.build()
                         .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
@@ -275,7 +296,7 @@ public class MigrationPowerfulPerms extends SubCommand<Object> {
                 }
             }
 
-            plugin.getDatastore().saveGroup(group);
+            plugin.getStorage().saveGroup(group);
         }
         log.info("PowerfulPerms Migration: Group migration complete.");
 
@@ -288,7 +309,7 @@ public class MigrationPowerfulPerms extends SubCommand<Object> {
             progress.put(uuid, new CountDownLatch(2));
 
             // Create a LuckPerms user for the UUID
-            plugin.getDatastore().loadUser(uuid, "null");
+            plugin.getStorage().loadUser(uuid, "null").join();
             User user = plugin.getUserManager().get(uuid);
 
             // Get a list of Permissions held by the user from the PP API.
@@ -299,7 +320,7 @@ public class MigrationPowerfulPerms extends SubCommand<Object> {
                 synchronized (progress) {
                     progress.get(uuid).countDown();
                     if (progress.get(uuid).getCount() == 0) {
-                        plugin.getDatastore().saveUser(user);
+                        plugin.getStorage().saveUser(user);
                         plugin.getUserManager().cleanup(user);
                     }
                 }
@@ -422,7 +443,7 @@ public class MigrationPowerfulPerms extends SubCommand<Object> {
                 synchronized (progress) {
                     progress.get(uuid).countDown();
                     if (progress.get(uuid).getCount() == 0) {
-                        plugin.getDatastore().saveUser(user);
+                        plugin.getStorage().saveUser(user);
                         plugin.getUserManager().cleanup(user);
                     }
                 }

bukkit/src/main/java/me/lucko/luckperms/bukkit/migration/MigrationZPermissions.java

@@ -0,0 +1,156 @@
+/*
+ * 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.bukkit.migration;
+
+import me.lucko.luckperms.api.Logger;
+import me.lucko.luckperms.common.LuckPermsPlugin;
+import me.lucko.luckperms.common.commands.CommandException;
+import me.lucko.luckperms.common.commands.CommandResult;
+import me.lucko.luckperms.common.commands.SubCommand;
+import me.lucko.luckperms.common.commands.sender.Sender;
+import me.lucko.luckperms.common.constants.Permission;
+import me.lucko.luckperms.common.core.NodeFactory;
+import me.lucko.luckperms.common.core.model.Group;
+import me.lucko.luckperms.common.core.model.PermissionHolder;
+import me.lucko.luckperms.common.core.model.Track;
+import me.lucko.luckperms.common.core.model.User;
+import me.lucko.luckperms.common.utils.Predicates;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+
+import org.tyrannyofheaven.bukkit.zPermissions.ZPermissionsService;
+import org.tyrannyofheaven.bukkit.zPermissions.dao.PermissionService;
+import org.tyrannyofheaven.bukkit.zPermissions.model.EntityMetadata;
+import org.tyrannyofheaven.bukkit.zPermissions.model.Entry;
+import org.tyrannyofheaven.bukkit.zPermissions.model.Inheritance;
+import org.tyrannyofheaven.bukkit.zPermissions.model.PermissionEntity;
+
+import java.lang.reflect.Field;
+import java.util.List;
+import java.util.UUID;
+
+public class MigrationZPermissions extends SubCommand<Object> {
+    public MigrationZPermissions() {
+        super("zpermissions", "Migration from zPermissions", Permission.MIGRATION, Predicates.alwaysFalse(), null);
+    }
+
+    @Override
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List<String> args, String label) throws CommandException {
+        final Logger log = plugin.getLog();
+        if (!plugin.isPluginLoaded("zPermissions")) {
+            log.severe("zPermissions Migration: Error -> zPermissions is not loaded.");
+            return CommandResult.STATE_ERROR;
+        }
+
+        ZPermissionsService service = (ZPermissionsService) plugin.getService(ZPermissionsService.class);
+        if (service == null) {
+            log.severe("zPermissions Migration: Error -> zPermissions is not loaded.");
+            return CommandResult.STATE_ERROR;
+        }
+
+        PermissionService internalService;
+
+        try {
+            Field psField = service.getClass().getDeclaredField("permissionService");
+            psField.setAccessible(true);
+            internalService = (PermissionService) psField.get(service);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return CommandResult.FAILURE;
+        }
+
+        // Migrate all groups
+        log.info("zPermissions Migration: Starting group migration.");
+        for (String g : service.getAllGroups()) {
+            plugin.getStorage().createAndLoadGroup(g.toLowerCase()).join();
+            Group group = plugin.getGroupManager().getIfLoaded(g.toLowerCase());
+
+            PermissionEntity entity = internalService.getEntity(g, null, true);
+            migrateEntity(group, entity);
+
+            plugin.getStorage().saveGroup(group);
+        }
+
+        // Migrate all tracks
+        log.info("zPermissions Migration: Starting track migration.");
+        for (String t : service.getAllTracks()) {
+            plugin.getStorage().createAndLoadTrack(t.toLowerCase()).join();
+            Track track = plugin.getTrackManager().getIfLoaded(t.toLowerCase());
+            track.setGroups(service.getTrackGroups(t));
+            plugin.getStorage().saveTrack(track);
+        }
+
+        // Migrate all users.
+        log.info("zPermissions Migration: Starting user migration.");
+        for (UUID u : service.getAllPlayersUUID()) {
+            plugin.getStorage().loadUser(u, "null").join();
+            User user = plugin.getUserManager().get(u);
+
+            PermissionEntity entity = internalService.getEntity(null, u, false);
+            migrateEntity(user, entity);
+
+            user.setPrimaryGroup(service.getPlayerPrimaryGroup(u));
+
+            plugin.getUserManager().cleanup(user);
+            plugin.getStorage().saveUser(user);
+        }
+
+        log.info("zPermissions Migration: Success! Completed without any errors.");
+        return CommandResult.SUCCESS;
+    }
+
+    private void migrateEntity(PermissionHolder group, PermissionEntity entity) {
+        for (Entry e : entity.getPermissions()) {
+            if (e.getWorld() != null) {
+                try {
+                    group.setPermission(e.getPermission(), true, "global", e.getWorld().getName());
+                } catch (ObjectAlreadyHasException ignored) {
+                }
+            } else {
+                try {
+                    group.setPermission(e.getPermission(), true); // TODO handle negated.
+                } catch (ObjectAlreadyHasException ignored) {
+                }
+            }
+        }
+
+        for (Inheritance inheritance : entity.getInheritancesAsChild()) {
+            if (!inheritance.getChild().getId().equals(entity.getId())) {
+                new Throwable("Illegal inheritance").printStackTrace();
+                continue;
+            }
+
+            try {
+                group.setPermission("group." + inheritance.getParent(), true);
+            } catch (ObjectAlreadyHasException ignored) {
+            }
+        }
+
+        for (EntityMetadata metadata : entity.getMetadata()) {
+            try {
+                group.setPermission(NodeFactory.makeMetaNode(metadata.getName(), metadata.getStringValue()).build());
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+}

bukkit/src/main/java/me/lucko/luckperms/bukkit/migration/utils/LPResultRunnable.java

@@ -20,12 +20,13 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.common.commands.migration.subcommands.utils;
+package me.lucko.luckperms.bukkit.migration.utils;
 
 import com.github.cheesesoftware.PowerfulPermsAPI.ResultRunnable;
 
 /**
  * Overrides the default ResultRunnable, callbacks will always run in the same thread. (an async one, hopefully.)
+ *
  * @param <T> type
  */
 public abstract class LPResultRunnable<T> extends ResultRunnable<T> {

bukkit/src/main/java/me/lucko/luckperms/bukkit/model/ChildPermissionProvider.java

@@ -0,0 +1,77 @@
+/*
+ * 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.bukkit.model;
+
+import lombok.Getter;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Maps;
+
+import org.bukkit.Bukkit;
+import org.bukkit.permissions.Permission;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+public class ChildPermissionProvider {
+
+    private static void resolveChildren(Map<String, Boolean> accumulator, Map<String, Boolean> children, boolean invert) {
+        for (Map.Entry<String, Boolean> e : children.entrySet()) {
+            if (accumulator.containsKey(e.getKey())) {
+                continue; // Prevent infinite loops
+            }
+
+            Permission perm = Bukkit.getServer().getPluginManager().getPermission(e.getKey());
+            boolean value = e.getValue() ^ invert;
+            String lName = e.getKey().toLowerCase();
+
+            accumulator.put(lName, value);
+
+            if (perm != null) {
+                resolveChildren(accumulator, perm.getChildren(), !value);
+            }
+        }
+    }
+
+    @Getter
+    private ImmutableMap<Map.Entry<String, Boolean>, ImmutableMap<String, Boolean>> permissions = ImmutableMap.of();
+
+    public void setup() {
+        Map<Map.Entry<String, Boolean>, ImmutableMap<String, Boolean>> permissions = new HashMap<>();
+
+        for (Permission permission : Bukkit.getServer().getPluginManager().getPermissions()) {
+            // handle true
+            Map<String, Boolean> children = new HashMap<>();
+            resolveChildren(children, Collections.singletonMap(permission.getName(), true), false);
+            permissions.put(Maps.immutableEntry(permission.getName().toLowerCase(), true), ImmutableMap.copyOf(children));
+
+            // handle false
+            Map<String, Boolean> nChildren = new HashMap<>();
+            resolveChildren(nChildren, Collections.singletonMap(permission.getName(), false), false);
+            permissions.put(Maps.immutableEntry(permission.getName().toLowerCase(), false), ImmutableMap.copyOf(nChildren));
+        }
+
+        this.permissions = ImmutableMap.copyOf(permissions);
+    }
+}

bukkit/src/main/java/me/lucko/luckperms/bukkit/model/DefaultsProvider.java

@@ -20,10 +20,15 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.bukkit.calculators;
+package me.lucko.luckperms.bukkit.model;
 
 import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+import com.google.common.collect.ImmutableMap;
+
 import me.lucko.luckperms.api.Tristate;
+
 import org.bukkit.Bukkit;
 import org.bukkit.permissions.Permissible;
 import org.bukkit.permissions.Permission;
@@ -38,26 +43,7 @@ import java.util.Set;
 
 public class DefaultsProvider {
 
-    private final DummyPermissible opDummy = new DummyPermissible(this::refreshOp);
-    private final DummyPermissible nonOpDummy = new DummyPermissible(this::refreshNonOp);
-
-    private final Map<String, Boolean> op = new HashMap<>();
-    private final Map<String, Boolean> nonOp = new HashMap<>();
-
-    public void refresh() {
-        refreshOp();
-        refreshNonOp();
-    }
-
-    private void refreshOp() {
-        calculateDefaults(op, opDummy, true);
-    }
-
-    private void refreshNonOp() {
-        calculateDefaults(nonOp, nonOpDummy, false);
-    }
-
-    private static void calculateDefaults(Map<String, Boolean> map, DummyPermissible p, boolean op) {
+    private static void unregisterDefaults(Map<String, Boolean> map, DummyPermissible p) {
         Set<String> perms = map.keySet();
 
         for (String name : perms) {
@@ -66,9 +52,9 @@ public class DefaultsProvider {
 
         Bukkit.getServer().getPluginManager().unsubscribeFromDefaultPerms(false, p);
         Bukkit.getServer().getPluginManager().unsubscribeFromDefaultPerms(true, p);
+    }
 
-        map.clear();
-
+    private static void calculateDefaults(Map<String, Boolean> map, DummyPermissible p, boolean op) {
         Set<Permission> defaults = Bukkit.getServer().getPluginManager().getDefaultPermissions(op);
         Bukkit.getServer().getPluginManager().subscribeToDefaultPerms(op, p);
 
@@ -95,13 +81,45 @@ public class DefaultsProvider {
         }
     }
 
-    public Tristate hasDefault(String permission, boolean isOp) {
-        Map<String, Boolean> map = isOp ? op : nonOp;
-        if (!map.containsKey(permission)) {
-            return Tristate.UNDEFINED;
-        }
+    @Getter
+    private Map<String, Boolean> opDefaults = ImmutableMap.of();
+    private final DummyPermissible opDummy = new DummyPermissible(this::refreshOp);
+    @Getter
+    private Map<String, Boolean> nonOpDefaults = ImmutableMap.of();
+    private final DummyPermissible nonOpDummy = new DummyPermissible(this::refreshNonOp);
 
-        return Tristate.fromBoolean(map.get(permission));
+    public void refresh() {
+        refreshOp();
+        refreshNonOp();
+    }
+
+    private void refreshOp() {
+        unregisterDefaults(opDefaults, opDummy);
+
+        Map<String, Boolean> builder = new HashMap<>();
+        calculateDefaults(builder, opDummy, true);
+
+        opDefaults = ImmutableMap.copyOf(builder);
+    }
+
+    private void refreshNonOp() {
+        unregisterDefaults(nonOpDefaults, nonOpDummy);
+
+        Map<String, Boolean> builder = new HashMap<>();
+        calculateDefaults(builder, nonOpDummy, false);
+
+        nonOpDefaults = ImmutableMap.copyOf(builder);
+    }
+
+    public Tristate hasDefault(String permission, boolean isOp) {
+        Map<String, Boolean> map = isOp ? opDefaults : nonOpDefaults;
+
+        Boolean b = map.get(permission);
+        return b == null ? Tristate.UNDEFINED : Tristate.fromBoolean(b);
+    }
+
+    public int size() {
+        return opDefaults.size() + nonOpDefaults.size();
     }
 
     @AllArgsConstructor

bukkit/src/main/java/me/lucko/luckperms/bukkit/model/LPPermissible.java

@@ -20,27 +20,38 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.bukkit.inject;
+package me.lucko.luckperms.bukkit.model;
 
 import lombok.Getter;
 import lombok.NonNull;
+
 import me.lucko.luckperms.api.Contexts;
 import me.lucko.luckperms.api.Tristate;
 import me.lucko.luckperms.bukkit.LPBukkitPlugin;
-import me.lucko.luckperms.common.users.User;
+import me.lucko.luckperms.common.core.model.User;
+
 import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
-import org.bukkit.permissions.*;
+import org.bukkit.permissions.PermissibleBase;
+import org.bukkit.permissions.Permission;
+import org.bukkit.permissions.PermissionAttachment;
+import org.bukkit.permissions.PermissionAttachmentInfo;
+import org.bukkit.permissions.PermissionRemovedExecutor;
 import org.bukkit.plugin.Plugin;
 
-import java.util.*;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
 import java.util.logging.Level;
 import java.util.stream.Collectors;
 
 /**
  * Modified PermissibleBase for LuckPerms
  */
-public class LPPermissible extends PermissibleBase { // TODO autoop stuff
+public class LPPermissible extends PermissibleBase {
 
     @Getter
     private final User user;
@@ -64,9 +75,9 @@ public class LPPermissible extends PermissibleBase { // TODO autoop stuff
         recalculatePermissions();
     }
 
-    private Contexts calculateContexts() {
+    public Contexts calculateContexts() {
         return new Contexts(
-                plugin.getContextManager().giveApplicableContext(parent, new HashMap<>()),
+                plugin.getContextManager().getApplicableContext(parent),
                 plugin.getConfiguration().isIncludingGlobalPerms(),
                 plugin.getConfiguration().isIncludingGlobalWorldPerms(),
                 true,
@@ -184,7 +195,7 @@ public class LPPermissible extends PermissibleBase { // TODO autoop stuff
         }
 
         PermissionAttachment result = addAttachment(plugin);
-        if (Bukkit.getServer().getScheduler().scheduleSyncDelayedTask(plugin, new RemoveAttachmentRunnable(result), ticks) == -1) {
+        if (Bukkit.getServer().getScheduler().scheduleSyncDelayedTask(plugin, () -> result.remove(), ticks) == -1) {
             Bukkit.getServer().getLogger().log(Level.WARNING, "Could not add PermissionAttachment to " + parent + " for plugin " + plugin.getDescription().getFullName() + ": Scheduler returned -1");
             result.remove();
             return null;
@@ -222,7 +233,7 @@ public class LPPermissible extends PermissibleBase { // TODO autoop stuff
         }
 
         if (hasData()) {
-            user.getUserData().invalidateCache();
+            user.getUserData().invalidatePermissionCalculators();
         }
     }
 
@@ -254,16 +265,4 @@ public class LPPermissible extends PermissibleBase { // TODO autoop stuff
             }
         }
     }
-
-    private class RemoveAttachmentRunnable implements Runnable {
-        private PermissionAttachment attachment;
-
-        private RemoveAttachmentRunnable(PermissionAttachment attachment) {
-            this.attachment = attachment;
-        }
-
-        public void run() {
-            attachment.remove();
-        }
-    }
 }

bukkit/src/main/java/me/lucko/luckperms/bukkit/vault/VaultChatHook.java

@@ -23,15 +23,20 @@
 package me.lucko.luckperms.bukkit.vault;
 
 import lombok.NonNull;
+
 import me.lucko.luckperms.api.Contexts;
 import me.lucko.luckperms.api.Node;
-import me.lucko.luckperms.common.caching.MetaData;
-import me.lucko.luckperms.common.core.PermissionHolder;
-import me.lucko.luckperms.common.groups.Group;
-import me.lucko.luckperms.common.users.User;
-import me.lucko.luckperms.common.utils.ArgumentChecker;
+import me.lucko.luckperms.api.caching.MetaData;
+import me.lucko.luckperms.api.context.ContextSet;
+import me.lucko.luckperms.common.core.NodeBuilder;
+import me.lucko.luckperms.common.core.NodeFactory;
+import me.lucko.luckperms.common.core.model.Group;
+import me.lucko.luckperms.common.core.model.PermissionHolder;
+import me.lucko.luckperms.common.core.model.User;
+import me.lucko.luckperms.common.utils.ExtractedContexts;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
+
 import net.milkbowl.vault.chat.Chat;
 
 import java.util.HashMap;
@@ -39,8 +44,8 @@ import java.util.List;
 import java.util.Map;
 import java.util.stream.Collectors;
 
-import static me.lucko.luckperms.common.utils.ArgumentChecker.escapeCharacters;
-import static me.lucko.luckperms.common.utils.ArgumentChecker.unescapeCharacters;
+import static me.lucko.luckperms.api.MetaUtils.escapeCharacters;
+import static me.lucko.luckperms.api.MetaUtils.unescapeCharacters;
 
 /**
  * Provides the Vault Chat service through the use of normal permission nodes.
@@ -56,7 +61,7 @@ import static me.lucko.luckperms.common.utils.ArgumentChecker.unescapeCharacters
  * Permission Nodes = meta.node.value
  *
  * Node that special characters used within LuckPerms are escaped:
- * See {@link ArgumentChecker#escapeCharacters(String)}
+ * See {@link me.lucko.luckperms.api.MetaUtils#unescapeCharacters(String)}
  */
 public class VaultChatHook extends Chat {
     private final VaultPermissionHook perms;
@@ -82,20 +87,18 @@ public class VaultChatHook extends Chat {
         perms.log("Setting meta: '" + node + "' for " + holder.getObjectName() + " on world " + world + ", server " + perms.getServer());
 
         perms.getScheduler().scheduleTask(() -> {
-            String k = escapeCharacters(node);
-            String v = escapeCharacters(value);
-
             List<Node> toRemove = holder.getNodes().stream()
-                    .filter(n -> n.isMeta() && n.getMeta().getKey().equals(k))
+                    .filter(n -> n.isMeta() && n.getMeta().getKey().equals(node))
                     .collect(Collectors.toList());
 
             toRemove.forEach(n -> {
                 try {
                     holder.unsetPermission(n);
-                } catch (ObjectLacksException ignored) {}
+                } catch (ObjectLacksException ignored) {
+                }
             });
 
-            Node.Builder metaNode = new me.lucko.luckperms.common.core.Node.Builder("meta." + k + "." + v).setValue(true);
+            Node.Builder metaNode = NodeFactory.makeMetaNode(node, value).setValue(true);
             if (!perms.getServer().equalsIgnoreCase("global")) {
                 metaNode.setServer(perms.getServer());
             }
@@ -105,7 +108,8 @@ public class VaultChatHook extends Chat {
 
             try {
                 holder.setPermission(metaNode.build());
-            } catch (ObjectAlreadyHasException ignored) {}
+            } catch (ObjectAlreadyHasException ignored) {
+            }
 
             perms.save(holder);
         });
@@ -119,7 +123,7 @@ public class VaultChatHook extends Chat {
         perms.log("Setting " + (prefix ? "prefix" : "suffix") + " for " + holder.getObjectName() + " on world " + world + ", server " + perms.getServer());
 
         perms.getScheduler().scheduleTask(() -> {
-            Node.Builder node = new me.lucko.luckperms.common.core.Node.Builder(prefix ? "prefix" : "suffix" + ".1000." + escapeCharacters(value));
+            Node.Builder node = new NodeBuilder((prefix ? "prefix" : "suffix") + ".1000." + escapeCharacters(value));
             node.setValue(true);
             if (!perms.getServer().equalsIgnoreCase("global")) {
                 node.setServer(perms.getServer());
@@ -131,7 +135,8 @@ public class VaultChatHook extends Chat {
 
             try {
                 holder.setPermission(node.build());
-            } catch (ObjectAlreadyHasException ignored) {}
+            } catch (ObjectAlreadyHasException ignored) {
+            }
 
             perms.save(holder);
         });
@@ -215,7 +220,8 @@ public class VaultChatHook extends Chat {
             context.put("world", world);
         }
 
-        for (Node n : group.getAllNodes(null, new Contexts(context, perms.isIncludeGlobal(), true, true, true, true))) {
+        ExtractedContexts ec = ExtractedContexts.generate(new Contexts(ContextSet.fromMap(context), perms.isIncludeGlobal(), true, true, true, true, false));
+        for (Node n : group.getAllNodes(null, ec)) {
             if (!n.getValue()) {
                 continue;
             }
@@ -243,47 +249,47 @@ public class VaultChatHook extends Chat {
     }
 
     public String getPlayerPrefix(String world, @NonNull String player) {
-        final User user = perms.getPlugin().getUserManager().get(player);
+        final User user = perms.getPlugin().getUserManager().getByUsername(player);
         return getUserChatMeta(true, user, world);
     }
 
     public void setPlayerPrefix(String world, @NonNull String player, @NonNull String prefix) {
-        final User user = perms.getPlugin().getUserManager().get(player);
+        final User user = perms.getPlugin().getUserManager().getByUsername(player);
         setChatMeta(true, user, prefix, world);
     }
 
     public String getPlayerSuffix(String world, @NonNull String player) {
-        final User user = perms.getPlugin().getUserManager().get(player);
+        final User user = perms.getPlugin().getUserManager().getByUsername(player);
         return getUserChatMeta(false, user, world);
     }
 
     public void setPlayerSuffix(String world, @NonNull String player, @NonNull String suffix) {
-        final User user = perms.getPlugin().getUserManager().get(player);
+        final User user = perms.getPlugin().getUserManager().getByUsername(player);
         setChatMeta(false, user, suffix, world);
     }
 
     public String getGroupPrefix(String world, @NonNull String group) {
-        final Group g = perms.getPlugin().getGroupManager().get(group);
+        final Group g = perms.getPlugin().getGroupManager().getIfLoaded(group);
         return getGroupChatMeta(false, g, world);
     }
 
     public void setGroupPrefix(String world, @NonNull String group, @NonNull String prefix) {
-        final Group g = perms.getPlugin().getGroupManager().get(group);
+        final Group g = perms.getPlugin().getGroupManager().getIfLoaded(group);
         setChatMeta(true, g, prefix, world);
     }
 
     public String getGroupSuffix(String world, @NonNull String group) {
-        final Group g = perms.getPlugin().getGroupManager().get(group);
+        final Group g = perms.getPlugin().getGroupManager().getIfLoaded(group);
         return getGroupChatMeta(false, g, world);
     }
 
     public void setGroupSuffix(String world, @NonNull String group, @NonNull String suffix) {
-        final Group g = perms.getPlugin().getGroupManager().get(group);
+        final Group g = perms.getPlugin().getGroupManager().getIfLoaded(group);
         setChatMeta(false, g, suffix, world);
     }
 
     public int getPlayerInfoInteger(String world, @NonNull String player, @NonNull String node, int defaultValue) {
-        final User user = perms.getPlugin().getUserManager().get(player);
+        final User user = perms.getPlugin().getUserManager().getByUsername(player);
         try {
             return Integer.parseInt(getUserMeta(user, world, node, String.valueOf(defaultValue)));
         } catch (NumberFormatException e) {
@@ -292,12 +298,12 @@ public class VaultChatHook extends Chat {
     }
 
     public void setPlayerInfoInteger(String world, @NonNull String player, @NonNull String node, int value) {
-        final User user = perms.getPlugin().getUserManager().get(player);
+        final User user = perms.getPlugin().getUserManager().getByUsername(player);
         setMeta(user, world, node, String.valueOf(value));
     }
 
     public int getGroupInfoInteger(String world, @NonNull String group, @NonNull String node, int defaultValue) {
-        final Group g = perms.getPlugin().getGroupManager().get(group);
+        final Group g = perms.getPlugin().getGroupManager().getIfLoaded(group);
         try {
             return Integer.parseInt(getGroupMeta(g, world, node, String.valueOf(defaultValue)));
         } catch (NumberFormatException e) {
@@ -306,12 +312,12 @@ public class VaultChatHook extends Chat {
     }
 
     public void setGroupInfoInteger(String world, @NonNull String group, @NonNull String node, int value) {
-        final Group g = perms.getPlugin().getGroupManager().get(group);
+        final Group g = perms.getPlugin().getGroupManager().getIfLoaded(group);
         setMeta(g, world, node, String.valueOf(value));
     }
 
     public double getPlayerInfoDouble(String world, @NonNull String player, @NonNull String node, double defaultValue) {
-        final User user = perms.getPlugin().getUserManager().get(player);
+        final User user = perms.getPlugin().getUserManager().getByUsername(player);
         try {
             return Double.parseDouble(getUserMeta(user, world, node, String.valueOf(defaultValue)));
         } catch (NumberFormatException e) {
@@ -320,12 +326,12 @@ public class VaultChatHook extends Chat {
     }
 
     public void setPlayerInfoDouble(String world, @NonNull String player, @NonNull String node, double value) {
-        final User user = perms.getPlugin().getUserManager().get(player);
+        final User user = perms.getPlugin().getUserManager().getByUsername(player);
         setMeta(user, world, node, String.valueOf(value));
     }
 
     public double getGroupInfoDouble(String world, @NonNull String group, @NonNull String node, double defaultValue) {
-        final Group g = perms.getPlugin().getGroupManager().get(group);
+        final Group g = perms.getPlugin().getGroupManager().getIfLoaded(group);
         try {
             return Double.parseDouble(getGroupMeta(g, world, node, String.valueOf(defaultValue)));
         } catch (NumberFormatException e) {
@@ -334,12 +340,12 @@ public class VaultChatHook extends Chat {
     }
 
     public void setGroupInfoDouble(String world, @NonNull String group, @NonNull String node, double value) {
-        final Group g = perms.getPlugin().getGroupManager().get(group);
+        final Group g = perms.getPlugin().getGroupManager().getIfLoaded(group);
         setMeta(g, world, node, String.valueOf(value));
     }
 
     public boolean getPlayerInfoBoolean(String world, @NonNull String player, @NonNull String node, boolean defaultValue) {
-        final User user = perms.getPlugin().getUserManager().get(player);
+        final User user = perms.getPlugin().getUserManager().getByUsername(player);
         String s = getUserMeta(user, world, node, String.valueOf(defaultValue));
         if (!s.equalsIgnoreCase("true") && !s.equalsIgnoreCase("false")) {
             return defaultValue;
@@ -348,12 +354,12 @@ public class VaultChatHook extends Chat {
     }
 
     public void setPlayerInfoBoolean(String world, @NonNull String player, @NonNull String node, boolean value) {
-        final User user = perms.getPlugin().getUserManager().get(player);
+        final User user = perms.getPlugin().getUserManager().getByUsername(player);
         setMeta(user, world, node, String.valueOf(value));
     }
 
     public boolean getGroupInfoBoolean(String world, @NonNull String group, @NonNull String node, boolean defaultValue) {
-        final Group g = perms.getPlugin().getGroupManager().get(group);
+        final Group g = perms.getPlugin().getGroupManager().getIfLoaded(group);
         String s = getGroupMeta(g, world, node, String.valueOf(defaultValue));
         if (!s.equalsIgnoreCase("true") && !s.equalsIgnoreCase("false")) {
             return defaultValue;
@@ -362,27 +368,27 @@ public class VaultChatHook extends Chat {
     }
 
     public void setGroupInfoBoolean(String world, @NonNull String group, @NonNull String node, boolean value) {
-        final Group g = perms.getPlugin().getGroupManager().get(group);
+        final Group g = perms.getPlugin().getGroupManager().getIfLoaded(group);
         setMeta(g, world, node, String.valueOf(value));
     }
 
     public String getPlayerInfoString(String world, @NonNull String player, @NonNull String node, String defaultValue) {
-        final User user = perms.getPlugin().getUserManager().get(player);
+        final User user = perms.getPlugin().getUserManager().getByUsername(player);
         return getUserMeta(user, world, node, defaultValue);
     }
 
     public void setPlayerInfoString(String world, @NonNull String player, @NonNull String node, String value) {
-        final User user = perms.getPlugin().getUserManager().get(player);
+        final User user = perms.getPlugin().getUserManager().getByUsername(player);
         setMeta(user, world, node, value);
     }
 
     public String getGroupInfoString(String world, @NonNull String group, @NonNull String node, String defaultValue) {
-        final Group g = perms.getPlugin().getGroupManager().get(group);
+        final Group g = perms.getPlugin().getGroupManager().getIfLoaded(group);
         return getGroupMeta(g, world, node, defaultValue);
     }
 
     public void setGroupInfoString(String world, @NonNull String group, @NonNull String node, String value) {
-        final Group g = perms.getPlugin().getGroupManager().get(group);
+        final Group g = perms.getPlugin().getGroupManager().getIfLoaded(group);
         setMeta(g, world, node, value);
     }
 

bukkit/src/main/java/me/lucko/luckperms/bukkit/vault/VaultHook.java

@@ -23,9 +23,12 @@
 package me.lucko.luckperms.bukkit.vault;
 
 import lombok.Getter;
+
 import me.lucko.luckperms.bukkit.LPBukkitPlugin;
+
 import net.milkbowl.vault.chat.Chat;
 import net.milkbowl.vault.permission.Permission;
+
 import org.bukkit.plugin.ServicePriority;
 import org.bukkit.plugin.ServicesManager;
 
@@ -42,7 +45,11 @@ public class VaultHook {
             permissionHook.setPlugin(plugin);
             permissionHook.setServer(plugin.getConfiguration().getVaultServer());
             permissionHook.setIncludeGlobal(plugin.getConfiguration().isVaultIncludingGlobal());
-            permissionHook.setIncludeGlobal(plugin.getConfiguration().isVaultIgnoreWorld());
+            permissionHook.setIgnoreWorld(plugin.getConfiguration().isVaultIgnoreWorld());
+            permissionHook.setPgo(plugin.getConfiguration().isVaultPrimaryGroupOverrides());
+            permissionHook.setPgoCheckInherited(plugin.getConfiguration().isVaultPrimaryGroupOverridesCheckInherited());
+            permissionHook.setPgoCheckExists(plugin.getConfiguration().isVaultPrimaryGroupOverridesCheckExists());
+            permissionHook.setPgoCheckMemberOf(plugin.getConfiguration().isVaultPrimaryGroupOverridesCheckMemberOf());
             permissionHook.setup();
 
             if (chatHook == null) {

bukkit/src/main/java/me/lucko/luckperms/bukkit/vault/VaultPermissionHook.java

@@ -22,20 +22,26 @@
 
 package me.lucko.luckperms.bukkit.vault;
 
+import lombok.AccessLevel;
 import lombok.Getter;
 import lombok.NonNull;
 import lombok.Setter;
+
 import me.lucko.luckperms.api.Contexts;
+import me.lucko.luckperms.api.LocalizedNode;
 import me.lucko.luckperms.api.Node;
+import me.lucko.luckperms.api.Tristate;
+import me.lucko.luckperms.api.caching.PermissionData;
+import me.lucko.luckperms.api.context.ContextSet;
 import me.lucko.luckperms.bukkit.LPBukkitPlugin;
-import me.lucko.luckperms.common.core.PermissionHolder;
-import me.lucko.luckperms.common.groups.Group;
-import me.lucko.luckperms.common.users.User;
+import me.lucko.luckperms.common.core.model.Group;
+import me.lucko.luckperms.common.core.model.PermissionHolder;
+import me.lucko.luckperms.common.core.model.User;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
+
 import net.milkbowl.vault.permission.Permission;
 
-import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
 
@@ -43,33 +49,30 @@ import java.util.Map;
  * The LuckPerms Vault Permission implementation
  * Most lookups are cached.
  */
+@Getter
+@Setter
 public class VaultPermissionHook extends Permission {
-
-    @Getter
-    @Setter
     private LPBukkitPlugin plugin;
 
-    @Getter
+    @Setter(value = AccessLevel.NONE)
     private VaultScheduler scheduler;
 
-    @Getter
-    @Setter
     private String server = "global";
-
-    @Getter
-    @Setter
     private boolean includeGlobal = true;
-
-    @Getter
-    @Setter
     private boolean ignoreWorld = false;
 
+    // Primary Group override settings
+    private boolean pgo = false;
+    private boolean pgoCheckInherited = false;
+    private boolean pgoCheckExists = true;
+    private boolean pgoCheckMemberOf = true;
+
     public void setup() {
         scheduler = new VaultScheduler(plugin);
     }
 
     public void log(String s) {
-        if (plugin.getConfiguration().isDebugPermissionChecks()) {
+        if (plugin.getConfiguration().isVaultDebug()) {
             plugin.getLog().info("[VAULT] " + s);
         }
     }
@@ -81,7 +84,7 @@ public class VaultPermissionHook extends Permission {
 
     @Override
     public boolean isEnabled() {
-        return plugin.getDatastore().isAcceptingLogins();
+        return plugin.getStorage().isAcceptingLogins();
     }
 
     @Override
@@ -91,8 +94,9 @@ public class VaultPermissionHook extends Permission {
 
     /**
      * Generic method to add a permission to a holder
-     * @param world the world to add in
-     * @param holder the holder to add the permission to
+     *
+     * @param world      the world to add in
+     * @param holder     the holder to add the permission to
      * @param permission the permission to add
      */
     private void add(String world, PermissionHolder holder, String permission) {
@@ -102,15 +106,17 @@ public class VaultPermissionHook extends Permission {
             } else {
                 holder.setPermission(permission, true, server);
             }
-        } catch (ObjectAlreadyHasException ignored) {}
+        } catch (ObjectAlreadyHasException ignored) {
+        }
 
         save(holder);
     }
 
     /**
      * Generic method to remove a permission from a holder
-     * @param world the world to remove in
-     * @param holder the holder to remove the permission from
+     *
+     * @param world      the world to remove in
+     * @param holder     the holder to remove the permission from
      * @param permission the permission to remove
      */
     private void remove(String world, PermissionHolder holder, String permission) {
@@ -120,23 +126,25 @@ public class VaultPermissionHook extends Permission {
             } else {
                 holder.unsetPermission(permission, server);
             }
-        } catch (ObjectLacksException ignored) {}
+        } catch (ObjectLacksException ignored) {
+        }
 
         save(holder);
     }
 
     /**
      * Utility method for saving a user or group
+     *
      * @param holder the holder instance
      */
     void save(PermissionHolder holder) {
         if (holder instanceof User) {
-            ((User) holder).refreshPermissions();
-            plugin.getDatastore().saveUser(((User) holder));
+            plugin.getStorage().saveUser(((User) holder))
+                    .thenRunAsync(() -> ((User) holder).getRefreshBuffer().request(), plugin.getAsyncExecutor());
         }
         if (holder instanceof Group) {
-            plugin.getDatastore().saveGroup(((Group) holder));
-            plugin.runUpdateTask();
+            plugin.getStorage().saveGroup(((Group) holder))
+                    .thenRunAsync(() -> plugin.getUpdateTaskBuffer().request(), plugin.getAsyncExecutor());
         }
     }
 
@@ -146,7 +154,7 @@ public class VaultPermissionHook extends Permission {
             context.put("world", world);
         }
         context.put("server", server);
-        return new Contexts(context, isIncludeGlobal(), true, true, true, true);
+        return new Contexts(ContextSet.fromMap(context), isIncludeGlobal(), true, true, true, true, false);
     }
 
     @Override
@@ -154,7 +162,7 @@ public class VaultPermissionHook extends Permission {
         world = ignoreWorld ? null : world; // Correct world value
         log("Checking if player " + player + " has permission: " + permission + " on world " + world + ", server " + server);
 
-        User user = plugin.getUserManager().get(player);
+        User user = plugin.getUserManager().getByUsername(player);
         if (user == null) return false;
 
         if (user.getUserData() == null) {
@@ -170,7 +178,7 @@ public class VaultPermissionHook extends Permission {
         String finalWorld = ignoreWorld ? null : world; // Correct world value
         log("Adding permission to player " + player + ": '" + permission + "' on world " + finalWorld + ", server " + server);
 
-        final User user = plugin.getUserManager().get(player);
+        final User user = plugin.getUserManager().getByUsername(player);
         if (user == null) return false;
 
         scheduler.scheduleTask(() -> add(finalWorld, user, permission));
@@ -182,7 +190,7 @@ public class VaultPermissionHook extends Permission {
         String finalWorld = ignoreWorld ? null : world; // Correct world value
         log("Removing permission from player " + player + ": '" + permission + "' on world " + finalWorld + ", server " + server);
 
-        final User user = plugin.getUserManager().get(player);
+        final User user = plugin.getUserManager().getByUsername(player);
         if (user == null) return false;
 
         scheduler.scheduleTask(() -> remove(finalWorld, user, permission));
@@ -194,11 +202,11 @@ public class VaultPermissionHook extends Permission {
         world = ignoreWorld ? null : world; // Correct world value
         log("Checking if group " + groupName + " has permission: " + permission + " on world " + world + ", server " + server);
 
-        final Group group = plugin.getGroupManager().get(groupName);
+        final Group group = plugin.getGroupManager().getIfLoaded(groupName);
         if (group == null) return false;
 
         // This is a nasty call. Groups aren't cached. :(
-        Map<String, Boolean> permissions = group.exportNodes(createContext(server, world), Collections.emptyList(), true);
+        Map<String, Boolean> permissions = group.exportNodes(createContext(server, world), true);
 
         return permissions.containsKey(permission) && permissions.get(permission);
     }
@@ -208,7 +216,7 @@ public class VaultPermissionHook extends Permission {
         String finalWorld = ignoreWorld ? null : world; // Correct world value
         log("Adding permission to group " + groupName + ": '" + permission + "' on world " + finalWorld + ", server " + server);
 
-        final Group group = plugin.getGroupManager().get(groupName);
+        final Group group = plugin.getGroupManager().getIfLoaded(groupName);
         if (group == null) return false;
 
         scheduler.scheduleTask(() -> add(finalWorld, group, permission));
@@ -220,7 +228,7 @@ public class VaultPermissionHook extends Permission {
         String finalWorld = ignoreWorld ? null : world; // Correct world value
         log("Removing permission from group " + groupName + ": '" + permission + "' on world " + finalWorld + ", server " + server);
 
-        final Group group = plugin.getGroupManager().get(groupName);
+        final Group group = plugin.getGroupManager().getIfLoaded(groupName);
         if (group == null) return false;
 
         scheduler.scheduleTask(() -> remove(finalWorld, group, permission));
@@ -232,7 +240,7 @@ public class VaultPermissionHook extends Permission {
         String finalWorld = ignoreWorld ? null : world; // Correct world value
         log("Checking if player " + player + " is in group: " + group + " on world " + finalWorld + ", server " + server);
 
-        final User user = plugin.getUserManager().get(player);
+        final User user = plugin.getUserManager().getByUsername(player);
         if (user == null) return false;
 
         return user.getNodes().stream()
@@ -249,20 +257,21 @@ public class VaultPermissionHook extends Permission {
         String finalWorld = ignoreWorld ? null : world; // Correct world value
         log("Adding player " + player + " to group: '" + groupName + "' on world " + finalWorld + ", server " + server);
 
-        final User user = plugin.getUserManager().get(player);
+        final User user = plugin.getUserManager().getByUsername(player);
         if (user == null) return false;
 
-        final Group group = plugin.getGroupManager().get(groupName);
+        final Group group = plugin.getGroupManager().getIfLoaded(groupName);
         if (group == null) return false;
 
         scheduler.scheduleTask(() -> {
             try {
                 if (finalWorld != null && !finalWorld.equals("")) {
-                    user.addGroup(group, server, finalWorld);
+                    user.setInheritGroup(group, server, finalWorld);
                 } else {
-                    user.addGroup(group, server);
+                    user.setInheritGroup(group, server);
                 }
-            } catch (ObjectAlreadyHasException ignored) {}
+            } catch (ObjectAlreadyHasException ignored) {
+            }
             save(user);
         });
         return true;
@@ -273,20 +282,21 @@ public class VaultPermissionHook extends Permission {
         String finalWorld = ignoreWorld ? null : world; // Correct world value
         log("Removing player " + player + " from group: '" + groupName + "' on world " + finalWorld + ", server " + server);
 
-        final User user = plugin.getUserManager().get(player);
+        final User user = plugin.getUserManager().getByUsername(player);
         if (user == null) return false;
 
-        final Group group = plugin.getGroupManager().get(groupName);
+        final Group group = plugin.getGroupManager().getIfLoaded(groupName);
         if (group == null) return false;
 
         scheduler.scheduleTask(() -> {
             try {
                 if (finalWorld != null && !finalWorld.equals("")) {
-                    user.removeGroup(group, server, finalWorld);
+                    user.unsetInheritGroup(group, server, finalWorld);
                 } else {
-                    user.removeGroup(group, server);
+                    user.unsetInheritGroup(group, server);
                 }
-            } catch (ObjectLacksException ignored) {}
+            } catch (ObjectLacksException ignored) {
+            }
             save(user);
         });
         return true;
@@ -297,7 +307,7 @@ public class VaultPermissionHook extends Permission {
         String finalWorld = ignoreWorld ? null : world; // Correct world value
         log("Getting groups of player: " + player + ", on world " + finalWorld + ", server " + server);
 
-        User user = plugin.getUserManager().get(player);
+        User user = plugin.getUserManager().getByUsername(player);
         if (user == null) return new String[0];
 
         return user.getNodes().stream()
@@ -310,9 +320,81 @@ public class VaultPermissionHook extends Permission {
 
     @Override
     public String getPrimaryGroup(String world, @NonNull String player) {
+        world = ignoreWorld ? null : world; // Correct world value
         log("Getting primary group of player: " + player);
-        final User user = plugin.getUserManager().get(player);
-        return (user == null) ? null : user.getPrimaryGroup();
+        final User user = plugin.getUserManager().getByUsername(player);
+
+        if (user == null) {
+            return null;
+        }
+
+        if (!pgo) {
+            return user.getPrimaryGroup();
+        }
+
+        if (pgoCheckInherited) {
+            PermissionData data = user.getUserData().getPermissionData(createContext(server, world));
+            for (Map.Entry<String, Boolean> e : data.getImmutableBacking().entrySet()) {
+                if (!e.getValue()) {
+                    continue;
+                }
+
+                if (!e.getKey().toLowerCase().startsWith("vault.primarygroup.")) {
+                    continue;
+                }
+
+                String group = e.getKey().substring("vault.primarygroup.".length());
+                if (pgoCheckExists) {
+                    if (!plugin.getGroupManager().isLoaded(group)) {
+                        continue;
+                    }
+                }
+
+                if (pgoCheckMemberOf) {
+                    if (data.getPermissionValue("group." + group) != Tristate.TRUE) {
+                        continue;
+                    }
+                }
+
+                return group;
+            }
+        } else {
+            for (LocalizedNode node : user.getPermissions(true)) {
+                if (!node.getValue()) {
+                    continue;
+                }
+
+                if (!node.getPermission().toLowerCase().startsWith("vault.primarygroup.")) {
+                    continue;
+                }
+
+                if (!node.shouldApplyOnServer(server, isIncludeGlobal(), false)) {
+                    continue;
+                }
+
+                if (!node.shouldApplyOnWorld(world, true, false)) {
+                    continue;
+                }
+
+                String group = node.getPermission().substring("vault.primarygroup.".length());
+                if (pgoCheckExists) {
+                    if (!plugin.getGroupManager().isLoaded(group)) {
+                        continue;
+                    }
+                }
+
+                if (pgoCheckMemberOf) {
+                    if (!user.getLocalGroups(server, world, isIncludeGlobal()).contains(group.toLowerCase())) {
+                        continue;
+                    }
+                }
+
+                return group;
+            }
+        }
+
+        // Fallback
+        return user.getPrimaryGroup();
     }
 
     @Override

bukkit/src/main/resources/config.yml

@@ -5,6 +5,10 @@
 # +------------------------------------------------------------------------+ #
 ##############################################################################
 
+# +------------------------------------------------------------------------+ #
+# |                               General                                  | #
+# +------------------------------------------------------------------------+ #
+
 # The name of the server, used for server specific permissions. Set to 'global' to disable.
 server: global
 
@@ -24,21 +28,31 @@ apply-global-world-groups: true
 
 # If this server is in offline or online mode.
 # This setting allows a player to have the same UUID across a network of offline mode/mixed servers.
-
+#
 # You should generally reflect the setting in server.properties here. Except when...
-
+#
 # 1. You have Spigot servers connected to a BungeeCord proxy, with online-mode set to false, but 'bungeecord' set to true in the spigot.yml
 #    AND 'ip-forward' set to true in the BungeeCord config.yml
 #    In this case, set online-mode in LuckPerms to true, despite the server being in offline mode.
-
+#
 # 2. You are only running one server instance using LuckPerms, (not a network)
 #    In this case, set online-mode to true no matter what is set in server.properties. (we can just fallback to the servers uuid cache)
-
+#
 # 3. If your proxy is running in offline mode, and you are using PaperSpigot (https://ci.destroystokyo.com/job/PaperSpigot/),
 #    you should set "bungee-online-mode" to false in the paper.yml, and set "online-mode" to true in all LuckPerms configs.
 #    This approach is thoroughly recommended for offline mode networks.
 online-mode: true
 
+# If the plugin should send log notifications to users whenever permissions are modified.
+log-notify: true
+
+
+
+
+# +------------------------------------------------------------------------+ #
+# |                        Permission Calculation                          | #
+# +------------------------------------------------------------------------+ #
+
 # If the plugin should apply wildcard permissions.
 # If set to true, LuckPerms will detect wildcard permissions, and resolve & apply all registered permissions matching
 # the wildcard.
@@ -53,11 +67,17 @@ apply-regex: true
 # If set to true, LuckPerms will detect and expand shorthand node patterns.
 apply-shorthand: true
 
-# If the plugin should send log notifications to users whenever permissions are modified.
-log-notify: true
+# Define special group weights for this server.
+# Default is just 0.
+group-weight:
+#  admin: 10
 
-# If LuckPerms should print to console every time a plugin checks if a player has a permission
-debug-permission-checks: false
+
+
+
+# +------------------------------------------------------------------------+ #
+# |                    OP (Server Operator) Settings                       | #
+# +------------------------------------------------------------------------+ #
 
 # If the vanilla OP system is enabled. If set to false, all users will be de-opped, and the op/deop commands will be disabled.
 enable-ops: true
@@ -67,12 +87,23 @@ enable-ops: true
 # Additionally, setting this to true will force the "enable-ops" option above to false. All users will be de-opped unless
 # they have the permission node, and the op/deop commands will be disabled.
 #
+# It is important to note that this setting is only checked when a player first joins the server, and when they switch
+# worlds. Therefore, simply removing this permission from a user will not automatically de-op them. A player needs to
+# relog to have the change take effect.
+#
 # It is recommended that you use this option instead of assigning a single '*' permission.
 auto-op: false
 
 # If opped players should be allowed to use LuckPerms commands. Set to false to only allow users who have the permissions access to the commands
 commands-allow-op: true
 
+
+
+
+# +------------------------------------------------------------------------+ #
+# |                                Vault                                   | #
+# +------------------------------------------------------------------------+ #
+
 # The name of the server used within Vault operations. If you don't want Vault operations to be server specific, set this
 # to "global".
 vault-server: global
@@ -83,15 +114,38 @@ vault-include-global: true
 # If Vault operations should ignore any world arguments if supplied.
 vault-ignore-world: false
 
+# This block controls the Primary Group override feature
+# See the wiki for more information.
+vault-primary-groups-overrides:
+  # If the feature is enabled
+  enabled: false
+  # If the check should query the user's inherited permissions.
+  # (a value of false only checks the permissions they explicitly have)
+  check-inherited-permissions: false
+  # If LuckPerms should check if the group exists
+  check-group-exists: true
+  # If LuckPerms should check if the user is actually a member of the group
+  check-user-member-of: true
+
+# If LuckPerms should print debugging info to console when a plugin uses a Vault function
+vault-debug: false
+
 # Mirrors world names. Whenever LuckPerms checks what world a user is in, if the world name is in this list, the value assigned
 # will be sent forward for permission calculation instead.
 world-rewrite:
-  #world_nether: world
-  #world_the_end: world
+#  world_nether: world
+#  world_the_end: world
 
 # Rewrites group names. The underlying name of the group does not change, just the output in commands / placeholders / Vault.
 group-name-rewrite:
-  #default: Member
+#  default: Member
+
+
+
+
+# +------------------------------------------------------------------------+ #
+# |                               Storage                                  | #
+# +------------------------------------------------------------------------+ #
 
 # Which storage method the plugin should use.
 # Currently supported: mysql, sqlite, h2, json, yaml, mongodb
@@ -113,7 +167,98 @@ data:
   database: minecraft
   username: root
   password: ''
+  pool-size: 10 # The size of the MySQL connection pool.
 
   # Set to -1 to disable. If this is the only instance accessing the datastore, you can disable syncing.
   # e.g. if you're using sqlite or flatfile, this can be set to -1 to save resources.
   sync-minutes: 3
+
+# Settings for Redis.
+#
+# If enabled and configured, LuckPerms will use the Redis PubSub system to inform other
+# connected servers of changes. Use the command "/luckperms networksync" to push changes.
+# Data is NOT stored on redis. It is only used as a messaging platform.
+#
+# If you decide to enable this feature, you should set "sync-minutes" to -1, as there is no need for LuckPerms
+# to poll the database for changes.
+redis:
+  enabled: false
+  address: localhost:6379
+  password: ''
+
+
+
+
+# +------------------------------------------------------------------------+ #
+# |                         Default Assignments                            | #
+# +------------------------------------------------------------------------+ #
+
+# This section allows you to define defaults to give users whenever they connect to the server.
+# The default assignments are highly configurable and conditional.
+#
+# There is one default assignment built into LuckPerms, which will add all users to the "default" group if they
+# are not a member of any other group. This setting cannot be disabled. However, you can use this section to add more of
+# your own.
+#
+# IMPORTANT:
+# In order to save storage space, LuckPerms does not store users who have no permissions defined, and are only a member
+# of the default group. Adding default assignments to this section will negate this effect. It is HIGHLY RECCOMENDED
+# that instead of assigning defaults here, you add permissions to the "default" group, or set the "default" group to inherit
+# other groups, and then use the group-name-rewrite rule above.
+#
+# It is also important to note that these rules are considered every time a player logs into the server, and are applied
+# directly to the user's data. Simply removing a rule here will not reserse the effect of that rule on any users who have
+# already had it applied to them.
+#
+# The "has" and "lacks" conditions below support standard boolean logic, using the 'and' & 'or' characters used in Java.
+# e.g. "(some.other.permission | some.permission.other) & some.thing.else" == a user has 'some.other.permission', or
+# 'some.permission.other', and they also have 'some.thing.else'
+#
+# Groups are represented by the permission node: group.<group name>
+# Per server and per world nodes are represented by: "server-world/permission" or "server/permission"
+#
+# Within conditions, permission nodes MUST be escaped using "<" and ">". See the example below.
+#
+# Explaination of the examples below: (they're just to demonstrate the features & use cases)
+#
+# rule1:
+# If a user is either in the vip or vip+ group, and they have the "titles.titlecollector" permission set to true, and the
+# "some.random.permission" set to false... if they're not in the group "prison_titlepack" on the "prison" server, then
+# give add them to the "prison_titlepack" group on the "prison" server, and remove "some.random.permission".
+#
+# rule2:
+# If the user isn't in any of the following groups on the skyblock server: sb_level1, sb_level2, sb_level3, then add
+# them to sb_level1 on the skyblock server.
+#
+# rule3:
+# If the user is a member of the default group, remove them from default, add them to member, and set their primary group
+# to member.
+#
+# WARNING: Unlike internal commands, this system does not ensure that a group exists before adding a user to it.
+# It also does not unsure that a user is a member of a group before making that group their primary group.
+#
+# Before you use "give: group.<name>" or "set-primary-group", make sure that the group exists, and that the user is
+# a member of the group.
+default-assignments:
+#  rule1:
+#    if:
+#      has-true: (<group.vip> | <group.vip+>) & <titles.tilecollector>
+#      has-false: <some.random.permission>
+#      lacks: <prison/group.prison_titlepack>
+#    give:
+#      - prison/group.prison_titlepack
+#    take:
+#      - some.random.permission
+#  rule2:
+#    if:
+#      lacks: <skyblock/group.sb_level1> & <skyblock/group.sb_level2> & <skyblock/group.sb_level3>
+#    give:
+#      - skyblock/group.sb_level1
+#  rule3:
+#    if:
+#      has-true: <group.default>
+#    take:
+#      - group.default
+#    give:
+#      - group.member
+#    set-primary-group: member

bukkit/src/main/resources/plugin.yml

@@ -5,7 +5,12 @@ author: Luck
 website: https://github.com/lucko/LuckPerms
 
 main: me.lucko.luckperms.bukkit.LPBukkitPlugin
-softdepend: [Vault, PermissionsEx, GroupManager, PowerfulPerms, zPermissions, bPermissions] # For migration
+load: STARTUP
+
+# This means that all plugins that (soft-)depend on Vault, depend on LuckPerms too.
+# It in turn fixes issues where plugins using Vault cache the provided instance when their plugin enables, or
+# when they check for the presence of a service provider, before LuckPerms has enabled.
+loadbefore: [Vault]
 
 commands:
   luckperms:
@@ -13,4 +18,5 @@ commands:
     aliases: [perms, permissions, lp, p, perm]
 
 
-# Permissions are registered programmatically instead of here.
+# Permissions are registered programmatically instead of here.
+# See: the last method in me.lucko.luckperms.bukkit.LPBukkitPlugin

bungee/pom.xml

@@ -1,11 +1,11 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xmlns="http://maven.apache.org/POM/4.0.0"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <parent>
         <artifactId>luckperms</artifactId>
         <groupId>me.lucko.luckperms</groupId>
-        <version>2.12-SNAPSHOT</version>
+        <version>2.16-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
@@ -69,6 +69,18 @@
                                     <pattern>org.sqlite</pattern>
                                     <shadedPattern>me.lucko.luckperms.lib.sqlite</shadedPattern>
                                 </relocation>
+                                <relocation>
+                                    <pattern>redis.clients.jedis</pattern>
+                                    <shadedPattern>me.lucko.luckperms.lib.jedis.jedis</shadedPattern>
+                                </relocation>
+                                <relocation>
+                                    <pattern>redis.clients.util</pattern>
+                                    <shadedPattern>me.lucko.luckperms.lib.jedis.util</shadedPattern>
+                                </relocation>
+                                <relocation>
+                                    <pattern>org.apache.commons.pool2</pattern>
+                                    <shadedPattern>me.lucko.luckperms.lib.jedis.pool2</shadedPattern>
+                                </relocation>
                             </relocations>
                         </configuration>
                     </execution>
@@ -121,6 +133,13 @@
             <version>1.16.10</version>
             <scope>provided</scope>
         </dependency>
+        <!-- **************Migration Plugins************** -->
+        <dependency>
+            <groupId>net.alpenblock</groupId>
+            <artifactId>BungeePerms</artifactId>
+            <version>3.0-dev-52</version>
+            <scope>provided</scope>
+        </dependency>
     </dependencies>
 
 </project>

bungee/src/main/java/me/lucko/luckperms/bungee/BackendServerCalculator.java

@@ -23,7 +23,10 @@
 package me.lucko.luckperms.bungee;
 
 import com.google.common.collect.Maps;
+
 import me.lucko.luckperms.api.context.ContextCalculator;
+import me.lucko.luckperms.api.context.MutableContextSet;
+
 import net.md_5.bungee.api.connection.ProxiedPlayer;
 import net.md_5.bungee.api.event.ServerSwitchEvent;
 import net.md_5.bungee.api.plugin.Listener;
@@ -34,12 +37,16 @@ import java.util.Map;
 public class BackendServerCalculator extends ContextCalculator<ProxiedPlayer> implements Listener {
     private static final String WORLD_KEY = "world";
 
+    private static String getServer(ProxiedPlayer player) {
+        return player.getServer() == null ? null : (player.getServer().getInfo() == null ? null : player.getServer().getInfo().getName());
+    }
+
     @Override
-    public Map<String, String> giveApplicableContext(ProxiedPlayer subject, Map<String, String> accumulator) {
+    public MutableContextSet giveApplicableContext(ProxiedPlayer subject, MutableContextSet accumulator) {
         String server = getServer(subject);
 
         if (server != null) {
-            accumulator.put(WORLD_KEY, server);
+            accumulator.add(Maps.immutableEntry(WORLD_KEY, server));
         }
 
         return accumulator;
@@ -59,8 +66,4 @@ public class BackendServerCalculator extends ContextCalculator<ProxiedPlayer> im
     public void onPlayerServerSwitch(ServerSwitchEvent e) {
         pushUpdate(e.getPlayer(), Maps.immutableEntry("null", "null"), Maps.immutableEntry(WORLD_KEY, getServer(e.getPlayer())));
     }
-
-    private static String getServer(ProxiedPlayer player) {
-        return player.getServer() == null ? null : (player.getServer().getInfo() == null ? null : player.getServer().getInfo().getName());
-    }
 }

bungee/src/main/java/me/lucko/luckperms/bungee/BungeeCalculatorFactory.java

@@ -23,29 +23,33 @@
 package me.lucko.luckperms.bungee;
 
 import lombok.AllArgsConstructor;
-import me.lucko.luckperms.api.Contexts;
-import me.lucko.luckperms.common.calculators.*;
-import me.lucko.luckperms.common.users.User;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
+import com.google.common.collect.ImmutableList;
+
+import me.lucko.luckperms.api.Contexts;
+import me.lucko.luckperms.common.calculators.AbstractCalculatorFactory;
+import me.lucko.luckperms.common.calculators.PermissionCalculator;
+import me.lucko.luckperms.common.calculators.PermissionProcessor;
+import me.lucko.luckperms.common.calculators.processors.MapProcessor;
+import me.lucko.luckperms.common.calculators.processors.RegexProcessor;
+import me.lucko.luckperms.common.calculators.processors.WildcardProcessor;
+import me.lucko.luckperms.common.core.model.User;
 
 @AllArgsConstructor
-public class BungeeCalculatorFactory implements CalculatorFactory {
+public class BungeeCalculatorFactory extends AbstractCalculatorFactory {
     private final LPBungeePlugin plugin;
 
     @Override
-    public PermissionCalculator build(Contexts contexts, User user, Map<String, Boolean> map) {
-        List<PermissionProcessor> processors = new ArrayList<>(3);
-        processors.add(new MapProcessor(map));
+    public PermissionCalculator build(Contexts contexts, User user) {
+        ImmutableList.Builder<PermissionProcessor> processors = ImmutableList.builder();
+        processors.add(new MapProcessor());
         if (plugin.getConfiguration().isApplyingWildcards()) {
-            processors.add(new WildcardProcessor(map));
+            processors.add(new WildcardProcessor());
         }
         if (plugin.getConfiguration().isApplyingRegex()) {
-            processors.add(new RegexProcessor(map));
+            processors.add(new RegexProcessor());
         }
 
-        return new PermissionCalculator(plugin, user.getName(), plugin.getConfiguration().isDebugPermissionChecks(), processors);
+        return registerCalculator(new PermissionCalculator(plugin, user.getName(), processors.build()));
     }
 }

bungee/src/main/java/me/lucko/luckperms/bungee/BungeeCommand.java

@@ -24,10 +24,11 @@ package me.lucko.luckperms.bungee;
 
 import com.google.common.base.Joiner;
 import com.google.common.base.Splitter;
-import me.lucko.luckperms.api.data.Callback;
+
 import me.lucko.luckperms.common.commands.CommandManager;
-import me.lucko.luckperms.common.commands.Util;
+import me.lucko.luckperms.common.commands.utils.Util;
 import me.lucko.luckperms.common.constants.Patterns;
+
 import net.md_5.bungee.api.CommandSender;
 import net.md_5.bungee.api.plugin.Command;
 import net.md_5.bungee.api.plugin.TabExecutor;
@@ -35,25 +36,27 @@ import net.md_5.bungee.api.plugin.TabExecutor;
 import java.util.Arrays;
 
 class BungeeCommand extends Command implements TabExecutor {
+    private final LPBungeePlugin plugin;
     private final CommandManager manager;
 
-    BungeeCommand(CommandManager manager) {
+    BungeeCommand(LPBungeePlugin plugin, CommandManager manager) {
         super("luckpermsbungee", null, "bperms", "lpb", "bpermissions", "bp", "bperm");
+        this.plugin = plugin;
         this.manager = manager;
     }
 
     @Override
     public void execute(CommandSender sender, String[] args) {
         manager.onCommand(
-                BungeeSenderFactory.get(manager.getPlugin()).wrap(sender),
+                plugin.getSenderFactory().wrap(sender),
                 "bperms",
                 Util.stripQuotes(Splitter.on(Patterns.COMMAND_SEPARATOR).omitEmptyStrings().splitToList(Joiner.on(' ').join(args))),
-                Callback.empty()
+                null
         );
     }
 
     @Override
     public Iterable<String> onTabComplete(CommandSender sender, String[] args) {
-        return manager.onTabComplete(BungeeSenderFactory.get(manager.getPlugin()).wrap(sender), Arrays.asList(args));
+        return manager.onTabComplete(plugin.getSenderFactory().wrap(sender), Arrays.asList(args));
     }
 }

bungee/src/main/java/me/lucko/luckperms/bungee/BungeeConfig.java

@@ -23,6 +23,7 @@
 package me.lucko.luckperms.bungee;
 
 import me.lucko.luckperms.common.config.AbstractConfiguration;
+
 import net.md_5.bungee.config.Configuration;
 import net.md_5.bungee.config.ConfigurationProvider;
 import net.md_5.bungee.config.YamlConfiguration;
@@ -32,7 +33,10 @@ import java.io.IOException;
 import java.io.InputStream;
 import java.nio.file.Files;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
+import java.util.Optional;
+import java.util.stream.Collectors;
 
 class BungeeConfig extends AbstractConfiguration<LPBungeePlugin> {
     private Configuration configuration;
@@ -79,6 +83,21 @@ class BungeeConfig extends AbstractConfiguration<LPBungeePlugin> {
         return configuration.getBoolean(path, def);
     }
 
+    @Override
+    protected List<String> getList(String path, List<String> def) {
+        return Optional.ofNullable(configuration.getStringList(path)).orElse(def);
+    }
+
+    @Override
+    protected List<String> getObjectList(String path, List<String> def) {
+        Configuration section = configuration.getSection(path);
+        if (section == null) {
+            return def;
+        }
+
+        return Optional.ofNullable(section.getKeys().stream().collect(Collectors.toList())).orElse(def);
+    }
+
     @Override
     protected Map<String, String> getMap(String path, Map<String, String> def) {
         Map<String, String> map = new HashMap<>();

bungee/src/main/java/me/lucko/luckperms/bungee/BungeeListener.java

@@ -26,8 +26,10 @@ import me.lucko.luckperms.api.Contexts;
 import me.lucko.luckperms.api.event.events.UserFirstLoginEvent;
 import me.lucko.luckperms.common.constants.Message;
 import me.lucko.luckperms.common.core.UuidCache;
-import me.lucko.luckperms.common.users.User;
+import me.lucko.luckperms.common.core.model.User;
+import me.lucko.luckperms.common.defaults.Rule;
 import me.lucko.luckperms.common.utils.AbstractListener;
+
 import net.md_5.bungee.api.chat.TextComponent;
 import net.md_5.bungee.api.connection.PendingConnection;
 import net.md_5.bungee.api.connection.ProxiedPlayer;
@@ -37,8 +39,8 @@ import net.md_5.bungee.api.event.PlayerDisconnectEvent;
 import net.md_5.bungee.api.event.PostLoginEvent;
 import net.md_5.bungee.api.plugin.Listener;
 import net.md_5.bungee.event.EventHandler;
+import net.md_5.bungee.event.EventPriority;
 
-import java.util.HashMap;
 import java.util.UUID;
 import java.util.concurrent.TimeUnit;
 
@@ -72,18 +74,19 @@ public class BungeeListener extends AbstractListener implements Listener {
         }
 
         Contexts contexts = new Contexts(
-                plugin.getContextManager().giveApplicableContext(player, new HashMap<>()),
+                plugin.getContextManager().getApplicableContext(player),
                 plugin.getConfiguration().isIncludingGlobalPerms(),
                 plugin.getConfiguration().isIncludingGlobalWorldPerms(),
                 true,
                 plugin.getConfiguration().isApplyingGlobalGroups(),
-                plugin.getConfiguration().isApplyingGlobalWorldGroups()
+                plugin.getConfiguration().isApplyingGlobalWorldGroups(),
+                false
         );
 
         e.setHasPermission(user.getUserData().getPermissionData(contexts).getPermissionValue(e.getPermission()).asBoolean());
     }
 
-    @EventHandler
+    @EventHandler(priority = EventPriority.LOWEST)
     public void onPlayerLogin(LoginEvent e) {
         /* Delay the login here, as we want to cache UUID data before the player is connected to a backend bukkit server.
            This means that a player will have the same UUID across the network, even if parts of the network are running in
@@ -95,32 +98,45 @@ public class BungeeListener extends AbstractListener implements Listener {
             final PendingConnection c = e.getConnection();
 
             if (!cache.isOnlineMode()) {
-                UUID uuid = plugin.getDatastore().getUUID(c.getName());
+                UUID uuid = plugin.getStorage().getUUID(c.getName()).join();
                 if (uuid != null) {
                     cache.addToCache(c.getUniqueId(), uuid);
                 } else {
                     // No previous data for this player
                     plugin.getApiProvider().fireEventAsync(new UserFirstLoginEvent(c.getUniqueId(), c.getName()));
                     cache.addToCache(c.getUniqueId(), c.getUniqueId());
-                    plugin.getDatastore().saveUUIDData(c.getName(), c.getUniqueId());
+                    plugin.getStorage().force().saveUUIDData(c.getName(), c.getUniqueId()).join();
                 }
             } else {
-                UUID uuid = plugin.getDatastore().getUUID(c.getName());
+                UUID uuid = plugin.getStorage().getUUID(c.getName()).join();
                 if (uuid == null) {
                     plugin.getApiProvider().fireEventAsync(new UserFirstLoginEvent(c.getUniqueId(), c.getName()));
                 }
 
                 // Online mode, no cache needed. This is just for name -> uuid lookup.
-                plugin.getDatastore().saveUUIDData(c.getName(), c.getUniqueId());
+                plugin.getStorage().force().saveUUIDData(c.getName(), c.getUniqueId()).join();
             }
 
             // We have to make a new user on this thread whilst the connection is being held, or we get concurrency issues as the Bukkit server
             // and the BungeeCord server try to make a new user at the same time.
-            plugin.getDatastore().loadUser(cache.getUUID(c.getUniqueId()), c.getName());
+            plugin.getStorage().force().loadUser(cache.getUUID(c.getUniqueId()), c.getName()).join();
             User user = plugin.getUserManager().get(cache.getUUID(c.getUniqueId()));
             if (user == null) {
                 plugin.getLog().warn("Failed to load user: " + c.getName());
             } else {
+                // Setup defaults for the user
+                boolean save = false;
+                for (Rule rule : plugin.getConfiguration().getDefaultAssignments()) {
+                    if (rule.apply(user)) {
+                        save = true;
+                    }
+                }
+
+                // If they were given a default, persist the new assignments back to the storage.
+                if (save) {
+                    plugin.getStorage().force().saveUser(user).join();
+                }
+
                 user.setupData(false); // Pretty nasty calculation call. Sets up the caching system so data is ready when the user joins.
             }
 

bungee/src/main/java/me/lucko/luckperms/bungee/BungeeSenderFactory.java

@@ -23,8 +23,9 @@
 package me.lucko.luckperms.bungee;
 
 import me.lucko.luckperms.common.LuckPermsPlugin;
-import me.lucko.luckperms.common.commands.SenderFactory;
+import me.lucko.luckperms.common.commands.sender.SenderFactory;
 import me.lucko.luckperms.common.constants.Constants;
+
 import net.md_5.bungee.api.CommandSender;
 import net.md_5.bungee.api.chat.TextComponent;
 import net.md_5.bungee.api.connection.ProxiedPlayer;
@@ -32,19 +33,10 @@ import net.md_5.bungee.api.connection.ProxiedPlayer;
 import java.util.UUID;
 
 public class BungeeSenderFactory extends SenderFactory<CommandSender> {
-    private static BungeeSenderFactory instance = null;
-
-    private BungeeSenderFactory(LuckPermsPlugin plugin) {
+    public BungeeSenderFactory(LuckPermsPlugin plugin) {
         super(plugin);
     }
 
-    public static synchronized BungeeSenderFactory get(LuckPermsPlugin plugin) {
-        if (instance == null) {
-            instance = new BungeeSenderFactory(plugin);
-        }
-        return instance;
-    }
-
     @Override
     protected String getName(CommandSender sender) {
         if (sender instanceof ProxiedPlayer) {

bungee/src/main/java/me/lucko/luckperms/bungee/LPBungeePlugin.java

@@ -23,50 +23,66 @@
 package me.lucko.luckperms.bungee;
 
 import lombok.Getter;
+
 import me.lucko.luckperms.ApiHandler;
 import me.lucko.luckperms.api.Contexts;
 import me.lucko.luckperms.api.Logger;
 import me.lucko.luckperms.api.PlatformType;
+import me.lucko.luckperms.api.context.ContextSet;
+import me.lucko.luckperms.api.context.MutableContextSet;
 import me.lucko.luckperms.common.LuckPermsPlugin;
 import me.lucko.luckperms.common.api.ApiProvider;
 import me.lucko.luckperms.common.calculators.CalculatorFactory;
 import me.lucko.luckperms.common.commands.CommandManager;
 import me.lucko.luckperms.common.commands.ConsecutiveExecutor;
-import me.lucko.luckperms.common.commands.Sender;
+import me.lucko.luckperms.common.commands.sender.Sender;
 import me.lucko.luckperms.common.config.LPConfiguration;
-import me.lucko.luckperms.common.constants.Message;
-import me.lucko.luckperms.common.constants.Permission;
 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.data.Importer;
-import me.lucko.luckperms.common.groups.GroupManager;
-import me.lucko.luckperms.common.runnables.ExpireTemporaryTask;
-import me.lucko.luckperms.common.runnables.UpdateTask;
-import me.lucko.luckperms.common.storage.Datastore;
+import me.lucko.luckperms.common.managers.GroupManager;
+import me.lucko.luckperms.common.managers.TrackManager;
+import me.lucko.luckperms.common.managers.UserManager;
+import me.lucko.luckperms.common.managers.impl.GenericGroupManager;
+import me.lucko.luckperms.common.managers.impl.GenericTrackManager;
+import me.lucko.luckperms.common.managers.impl.GenericUserManager;
+import me.lucko.luckperms.common.messaging.RedisMessaging;
+import me.lucko.luckperms.common.storage.Storage;
 import me.lucko.luckperms.common.storage.StorageFactory;
-import me.lucko.luckperms.common.tracks.TrackManager;
-import me.lucko.luckperms.common.users.UserManager;
+import me.lucko.luckperms.common.tasks.ExpireTemporaryTask;
+import me.lucko.luckperms.common.tasks.UpdateTask;
+import me.lucko.luckperms.common.utils.BufferedRequest;
+import me.lucko.luckperms.common.utils.DebugHandler;
 import me.lucko.luckperms.common.utils.LocaleManager;
 import me.lucko.luckperms.common.utils.LogFactory;
+import me.lucko.luckperms.common.utils.PermissionCache;
+
 import net.md_5.bungee.api.config.ServerInfo;
 import net.md_5.bungee.api.connection.ProxiedPlayer;
 import net.md_5.bungee.api.plugin.Plugin;
 
 import java.io.File;
-import java.util.*;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.Executor;
 import java.util.concurrent.TimeUnit;
 import java.util.stream.Collectors;
 
 @Getter
 public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
     private final Set<UUID> ignoringLogs = ConcurrentHashMap.newKeySet();
+    private Executor executor;
     private LPConfiguration configuration;
     private UserManager userManager;
     private GroupManager groupManager;
     private TrackManager trackManager;
-    private Datastore datastore;
+    private Storage storage;
+    private RedisMessaging redisMessaging = null;
     private UuidCache uuidCache;
     private ApiProvider apiProvider;
     private Logger log;
@@ -75,14 +91,51 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
     private LocaleManager localeManager;
     private ContextManager<ProxiedPlayer> contextManager;
     private CalculatorFactory calculatorFactory;
+    private BufferedRequest<Void> updateTaskBuffer;
+    private DebugHandler debugHandler;
+    private BungeeSenderFactory senderFactory;
+    private PermissionCache permissionCache;
 
     @Override
     public void onEnable() {
+        executor = r -> getProxy().getScheduler().runAsync(this, r);
         log = LogFactory.wrap(getLogger());
+        debugHandler = new DebugHandler(executor);
+        senderFactory = new BungeeSenderFactory(this);
+        permissionCache = new PermissionCache(executor);
 
         getLog().info("Loading configuration...");
         configuration = new BungeeConfig(this);
 
+        // register events
+        getProxy().getPluginManager().registerListener(this, new BungeeListener(this));
+
+        // initialise datastore
+        storage = StorageFactory.getInstance(this, "h2");
+
+        // initialise redis
+        if (getConfiguration().isRedisEnabled()) {
+            getLog().info("Loading redis...");
+            redisMessaging = new RedisMessaging(this);
+            try {
+                redisMessaging.init(getConfiguration().getRedisAddress(), getConfiguration().getRedisPassword());
+                getLog().info("Loaded redis successfully...");
+            } catch (Exception e) {
+                getLog().info("Couldn't load redis...");
+                e.printStackTrace();
+            }
+        }
+
+        // setup the update task buffer
+        updateTaskBuffer = new BufferedRequest<Void>(1000L, this::doAsync) {
+            @Override
+            protected Void perform() {
+                new UpdateTask(LPBungeePlugin.this).run();
+                return null;
+            }
+        };
+
+        // load locale
         localeManager = new LocaleManager();
         File locale = new File(getDataFolder(), "lang.yml");
         if (locale.exists()) {
@@ -94,24 +147,20 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
             }
         }
 
-        // register events
-        getProxy().getPluginManager().registerListener(this, new BungeeListener(this));
-
         // register commands
         getLog().info("Registering commands...");
         CommandManager commandManager = new CommandManager(this);
-        getProxy().getPluginManager().registerCommand(this, new BungeeCommand(commandManager));
+        getProxy().getPluginManager().registerCommand(this, new BungeeCommand(this, commandManager));
 
         // disable the default Bungee /perms command so it gets handled by the Bukkit plugin
         getProxy().getDisabledCommands().add("perms");
 
-        datastore = StorageFactory.getDatastore(this, "h2");
-
+        // load internal managers
         getLog().info("Loading internal permission managers...");
         uuidCache = new UuidCache(getConfiguration().isOnlineMode());
-        userManager = new UserManager(this);
-        groupManager = new GroupManager(this);
-        trackManager = new TrackManager();
+        userManager = new GenericUserManager(this);
+        groupManager = new GenericGroupManager(this);
+        trackManager = new GenericTrackManager();
         importer = new Importer(commandManager);
         consecutiveExecutor = new ConsecutiveExecutor(commandManager);
         calculatorFactory = new BungeeCalculatorFactory(this);
@@ -122,35 +171,36 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
         contextManager.registerCalculator(serverCalculator);
         contextManager.registerCalculator(new ServerCalculator<>(getConfiguration().getServer()));
 
+        // register with the LP API
+        getLog().info("Registering API...");
+        apiProvider = new ApiProvider(this);
+        ApiHandler.registerProvider(apiProvider);
+
+        // schedule update tasks
         int mins = getConfiguration().getSyncTime();
         if (mins > 0) {
             getProxy().getScheduler().schedule(this, new UpdateTask(this), mins, mins, TimeUnit.MINUTES);
         }
 
-        // 20 times per second (once per "tick")
-        getProxy().getScheduler().schedule(this, BungeeSenderFactory.get(this), 50L, 50L, TimeUnit.MILLISECONDS);
+        // run an update instantly.
+        updateTaskBuffer.requestDirectly();
+
+        // register tasks
         getProxy().getScheduler().schedule(this, new ExpireTemporaryTask(this), 3L, 3L, TimeUnit.SECONDS);
         getProxy().getScheduler().schedule(this, consecutiveExecutor, 1L, 1L, TimeUnit.SECONDS);
 
-        getLog().info("Registering API...");
-        apiProvider = new ApiProvider(this);
-        ApiHandler.registerProvider(apiProvider);
-
-        // Run update task to refresh any online users
-        getLog().info("Scheduling Update Task to refresh any online users.");
-        try {
-            new UpdateTask(this).run();
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-
         getLog().info("Successfully loaded.");
     }
 
     @Override
     public void onDisable() {
         getLog().info("Closing datastore...");
-        datastore.shutdown();
+        storage.shutdown();
+
+        if (redisMessaging != null) {
+            getLog().info("Closing redis...");
+            redisMessaging.shutdown();
+        }
 
         getLog().info("Unregistering API...");
         ApiHandler.unregisterProvider();
@@ -172,8 +222,25 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
     }
 
     @Override
-    public Message getPlayerStatus(UUID uuid) {
-        return getProxy().getPlayer(getUuidCache().getExternalUUID(uuid)) != null ? Message.PLAYER_ONLINE : Message.PLAYER_OFFLINE;
+    public ProxiedPlayer getPlayer(User user) {
+        return getProxy().getPlayer(uuidCache.getExternalUUID(user.getUuid()));
+    }
+
+    @Override
+    public Contexts getContextForUser(User user) {
+        ProxiedPlayer player = getPlayer(user);
+        if (player == null) {
+            return null;
+        }
+        return new Contexts(
+                getContextManager().getApplicableContext(player),
+                getConfiguration().isIncludingGlobalPerms(),
+                getConfiguration().isIncludingGlobalWorldPerms(),
+                true,
+                getConfiguration().isApplyingGlobalGroups(),
+                getConfiguration().isApplyingGlobalWorldGroups(),
+                false
+        );
     }
 
     @Override
@@ -187,42 +254,52 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
     }
 
     @Override
-    public List<Sender> getNotifyListeners() {
+    public Set<UUID> getOnlinePlayers() {
+        return getProxy().getPlayers().stream().map(ProxiedPlayer::getUniqueId).collect(Collectors.toSet());
+    }
+
+    @Override
+    public boolean isOnline(UUID external) {
+        return getProxy().getPlayer(external) != null;
+    }
+
+    @Override
+    public List<Sender> getSenders() {
         return getProxy().getPlayers().stream()
-                .map(p -> BungeeSenderFactory.get(this).wrap(p, Collections.singleton(Permission.LOG_NOTIFY)))
-                .filter(Permission.LOG_NOTIFY::isAuthorized)
+                .map(p -> getSenderFactory().wrap(p))
                 .collect(Collectors.toList());
     }
 
     @Override
     public Sender getConsoleSender() {
-        return BungeeSenderFactory.get(this).wrap(getProxy().getConsole());
+        return getSenderFactory().wrap(getProxy().getConsole());
     }
 
     @Override
     public Set<Contexts> getPreProcessContexts(boolean op) {
-        Set<Map<String, String>> c = new HashSet<>();
-        c.add(Collections.emptyMap());
-        c.add(Collections.singletonMap("server", getConfiguration().getServer()));
+        Set<ContextSet> c = new HashSet<>();
+        c.add(ContextSet.empty());
+        c.add(ContextSet.singleton("server", getConfiguration().getServer()));
         c.addAll(getProxy().getServers().values().stream()
                 .map(ServerInfo::getName)
                 .map(s -> {
-                    Map<String, String> map = new HashMap<>();
-                    map.put("server", getConfiguration().getServer());
-                    map.put("world", s);
-                    return map;
+                    MutableContextSet set = MutableContextSet.create();
+                    set.add("server", getConfiguration().getServer());
+                    set.add("world", s);
+                    return set.makeImmutable();
                 })
                 .collect(Collectors.toList())
         );
 
         return c.stream()
-                .map(map -> new Contexts(
-                        map,
+                .map(set -> new Contexts(
+                        set,
                         getConfiguration().isIncludingGlobalPerms(),
                         getConfiguration().isIncludingGlobalWorldPerms(),
                         true,
                         getConfiguration().isApplyingGlobalGroups(),
-                        getConfiguration().isApplyingGlobalWorldGroups()
+                        getConfiguration().isApplyingGlobalWorldGroups(),
+                        false
                 ))
                 .collect(Collectors.toSet());
     }
@@ -250,11 +327,6 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
                 .isPresent();
     }
 
-    @Override
-    public void runUpdateTask() {
-        doAsync(new UpdateTask(this));
-    }
-
     @Override
     public void doAsync(Runnable r) {
         getProxy().getScheduler().runAsync(this, r);
@@ -262,6 +334,22 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
 
     @Override
     public void doSync(Runnable r) {
-        r.run();
+        doAsync(r);
+    }
+
+    @Override
+    public Executor getSyncExecutor() {
+        return executor;
+    }
+
+    @Override
+    public Executor getAsyncExecutor() {
+        return executor;
+    }
+
+    @Override
+    public void doAsyncRepeating(Runnable r, long interval) {
+        long millis = interval * 50L; // convert from ticks to milliseconds
+        getProxy().getScheduler().schedule(this, r, millis, millis, TimeUnit.MILLISECONDS);
     }
 }

bungee/src/main/java/me/lucko/luckperms/bungee/migration/MigrationBungeePerms.java

@@ -20,20 +20,26 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.common.commands.migration.subcommands;
+package me.lucko.luckperms.bungee.migration;
 
 import me.lucko.luckperms.api.Logger;
+import me.lucko.luckperms.api.MetaUtils;
 import me.lucko.luckperms.common.LuckPermsPlugin;
+import me.lucko.luckperms.common.commands.CommandException;
 import me.lucko.luckperms.common.commands.CommandResult;
-import me.lucko.luckperms.common.commands.Predicate;
-import me.lucko.luckperms.common.commands.Sender;
 import me.lucko.luckperms.common.commands.SubCommand;
+import me.lucko.luckperms.common.commands.sender.Sender;
 import me.lucko.luckperms.common.constants.Constants;
 import me.lucko.luckperms.common.constants.Permission;
 import me.lucko.luckperms.common.data.LogEntry;
-import me.lucko.luckperms.common.utils.ArgumentChecker;
+import me.lucko.luckperms.common.utils.Predicates;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
-import net.alpenblock.bungeeperms.*;
+
+import net.alpenblock.bungeeperms.BungeePerms;
+import net.alpenblock.bungeeperms.Group;
+import net.alpenblock.bungeeperms.Server;
+import net.alpenblock.bungeeperms.User;
+import net.alpenblock.bungeeperms.World;
 
 import java.util.List;
 import java.util.Map;
@@ -43,11 +49,11 @@ import java.util.Map;
  */
 public class MigrationBungeePerms extends SubCommand<Object> {
     public MigrationBungeePerms() {
-        super("bungeeperms", "Migration from BungeePerms", Permission.MIGRATION, Predicate.alwaysFalse(), null);
+        super("bungeeperms", "Migration from BungeePerms", Permission.MIGRATION, Predicates.alwaysFalse(), null);
     }
 
     @Override
-    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List<String> args, String label) {
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List<String> args, String label) throws CommandException {
         final Logger log = plugin.getLog();
 
         BungeePerms bp = BungeePerms.getInstance();
@@ -60,11 +66,11 @@ public class MigrationBungeePerms extends SubCommand<Object> {
         log.info("BungeePerms Migration: Starting group migration.");
         int groupCount = 0;
         for (Group g : bp.getPermissionsManager().getBackEnd().loadGroups()) {
-            groupCount ++;
+            groupCount++;
 
             // Make a LuckPerms group for the one being migrated
-            plugin.getDatastore().createAndLoadGroup(g.getName().toLowerCase());
-            me.lucko.luckperms.common.groups.Group group = plugin.getGroupManager().get(g.getName().toLowerCase());
+            plugin.getStorage().createAndLoadGroup(g.getName().toLowerCase()).join();
+            me.lucko.luckperms.common.core.model.Group group = plugin.getGroupManager().getIfLoaded(g.getName().toLowerCase());
             try {
                 LogEntry.build()
                         .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
@@ -144,7 +150,7 @@ public class MigrationBungeePerms extends SubCommand<Object> {
             String suffix = g.getSuffix();
 
             if (prefix != null && !prefix.equals("")) {
-                prefix = ArgumentChecker.escapeCharacters(prefix);
+                prefix = MetaUtils.escapeCharacters(prefix);
                 try {
                     group.setPermission("prefix.50." + prefix, true);
                     LogEntry.build()
@@ -159,7 +165,7 @@ public class MigrationBungeePerms extends SubCommand<Object> {
             }
 
             if (suffix != null && !suffix.equals("")) {
-                suffix = ArgumentChecker.escapeCharacters(suffix);
+                suffix = MetaUtils.escapeCharacters(suffix);
                 try {
                     group.setPermission("suffix.50." + suffix, true);
                     LogEntry.build()
@@ -173,7 +179,7 @@ public class MigrationBungeePerms extends SubCommand<Object> {
                 }
             }
 
-            plugin.getDatastore().saveGroup(group);
+            plugin.getStorage().saveGroup(group);
         }
 
         log.info("BungeePerms Migration: Migrated " + groupCount + " groups");
@@ -187,8 +193,8 @@ public class MigrationBungeePerms extends SubCommand<Object> {
             userCount++;
 
             // Make a LuckPerms user for the one being migrated.
-            plugin.getDatastore().loadUser(u.getUUID(), "null");
-            me.lucko.luckperms.common.users.User user = plugin.getUserManager().get(u.getUUID());
+            plugin.getStorage().loadUser(u.getUUID(), "null").join();
+            me.lucko.luckperms.common.core.model.User user = plugin.getUserManager().get(u.getUUID());
 
             // Migrate global perms
             for (String perm : u.getPerms()) {
@@ -259,7 +265,7 @@ public class MigrationBungeePerms extends SubCommand<Object> {
             String suffix = u.getSuffix();
 
             if (prefix != null && !prefix.equals("")) {
-                prefix = ArgumentChecker.escapeCharacters(prefix);
+                prefix = MetaUtils.escapeCharacters(prefix);
                 try {
                     user.setPermission("prefix.100." + prefix, true);
                     LogEntry.build()
@@ -274,7 +280,7 @@ public class MigrationBungeePerms extends SubCommand<Object> {
             }
 
             if (suffix != null && !suffix.equals("")) {
-                suffix = ArgumentChecker.escapeCharacters(suffix);
+                suffix = MetaUtils.escapeCharacters(suffix);
                 try {
                     user.setPermission("suffix.100." + suffix, true);
                     LogEntry.build()
@@ -288,7 +294,7 @@ public class MigrationBungeePerms extends SubCommand<Object> {
                 }
             }
 
-            plugin.getDatastore().saveUser(user);
+            plugin.getStorage().saveUser(user);
             plugin.getUserManager().cleanup(user);
         }
 

bungee/src/main/resources/config.yml

@@ -5,6 +5,10 @@
 # +------------------------------------------------------------------------+ #
 ##############################################################################
 
+# +------------------------------------------------------------------------+ #
+# |                               General                                  | #
+# +------------------------------------------------------------------------+ #
+
 # The name of the server, used for server specific permissions. Set to 'global' to disable.
 server: bungee
 
@@ -24,21 +28,41 @@ apply-global-world-groups: true
 
 # If this server is in offline or online mode.
 # This setting allows a player to have the same UUID across a network of offline mode/mixed servers.
-
+#
 # You should generally reflect the setting in server.properties here. Except when...
-
+#
 # 1. You have Spigot servers connected to a BungeeCord proxy, with online-mode set to false, but 'bungeecord' set to true in the spigot.yml
 #    AND 'ip-forward' set to true in the BungeeCord config.yml
 #    In this case, set online-mode in LuckPerms to true, despite the server being in offline mode.
-
+#
 # 2. You are only running one server instance using LuckPerms, (not a network)
 #    In this case, set online-mode to true no matter what is set in server.properties. (we can just fallback to the servers uuid cache)
-
+#
 # 3. If your proxy is running in offline mode, and you are using PaperSpigot (https://ci.destroystokyo.com/job/PaperSpigot/),
 #    you should set "bungee-online-mode" to false in the paper.yml, and set "online-mode" to true in all LuckPerms configs.
 #    This approach is thoroughly recommended for offline mode networks.
 online-mode: true
 
+# If the plugin should send log notifications to users whenever permissions are modified.
+log-notify: true
+
+# Mirrors world names. Whenever LuckPerms checks what world a user is in, if the world name is in this list, the value assigned
+# will be sent forward for permission calculation instead.
+world-rewrite:
+#  world_nether: world
+#  world_the_end: world
+
+# Rewrites group names. The underlying name of the group does not change, just the output in commands / placeholders / Vault.
+group-name-rewrite:
+#  default: Member
+
+
+
+
+# +------------------------------------------------------------------------+ #
+# |                        Permission Calculation                          | #
+# +------------------------------------------------------------------------+ #
+
 # If the plugin should apply wildcard permissions.
 # If set to true, LuckPerms will detect wildcard permissions, and resolve & apply all registered permissions matching
 # the wildcard.
@@ -53,23 +77,17 @@ apply-regex: true
 # If set to true, LuckPerms will detect and expand shorthand node patterns.
 apply-shorthand: true
 
-# If the plugin should send log notifications to users whenever permissions are modified.
-log-notify: true
+# Define special group weights for this server.
+# Default is just 0.
+group-weight:
+#  admin: 10
 
-# If LuckPerms should print to console every time a plugin checks if a player has a permission
-debug-permission-checks: false
 
-# Mirrors world names. Whenever LuckPerms checks what world a user is in, if the world name is in this list, the value assigned
-# will be sent forward for permission calculation instead.
-# Remember world names on BungeeCord relate to the backend server name a user is connected to.
-world-rewrite:
-  #hub2: hub
-  #hub3: hub
-  #opfactions: factions
 
-# Rewrites group names. The underlying name of the group does not change, just the output in commands / placeholders / Vault.
-group-name-rewrite:
-  #default: Member
+
+# +------------------------------------------------------------------------+ #
+# |                               Storage                                  | #
+# +------------------------------------------------------------------------+ #
 
 # Which storage method the plugin should use.
 # Currently supported: mysql, sqlite, h2, json, yaml, mongodb
@@ -91,7 +109,98 @@ data:
   database: minecraft
   username: root
   password: ''
+  pool-size: 10 # The size of the MySQL connection pool.
 
   # Set to -1 to disable. If this is the only instance accessing the datastore, you can disable syncing.
   # e.g. if you're using sqlite or flatfile, this can be set to -1 to save resources.
-  sync-minutes: 3
+  sync-minutes: 3
+
+# Settings for Redis.
+#
+# If enabled and configured, LuckPerms will use the Redis PubSub system to inform other
+# connected servers of changes. Use the command "/luckpermsbungee networksync" to push changes.
+# Data is NOT stored on redis. It is only used as a messaging platform.
+#
+# If you decide to enable this feature, you should set "sync-minutes" to -1, as there is no need for LuckPerms
+# to poll the database for changes.
+redis:
+  enabled: false
+  address: localhost:6379
+  password: ''
+
+
+
+
+# +------------------------------------------------------------------------+ #
+# |                         Default Assignments                            | #
+# +------------------------------------------------------------------------+ #
+
+# This section allows you to define defaults to give users whenever they connect to the server.
+# The default assignments are highly configurable and conditional.
+#
+# There is one default assignment built into LuckPerms, which will add all users to the "default" group if they
+# are not a member of any other group. This setting cannot be disabled. However, you can use this section to add more of
+# your own.
+#
+# IMPORTANT:
+# In order to save storage space, LuckPerms does not store users who have no permissions defined, and are only a member
+# of the default group. Adding default assignments to this section will negate this effect. It is HIGHLY RECCOMENDED
+# that instead of assigning defaults here, you add permissions to the "default" group, or set the "default" group to inherit
+# other groups, and then use the group-name-rewrite rule above.
+#
+# It is also important to note that these rules are considered every time a player logs into the server, and are applied
+# directly to the user's data. Simply removing a rule here will not reserse the effect of that rule on any users who have
+# already had it applied to them.
+#
+# The "has" and "lacks" conditions below support standard boolean logic, using the 'and' & 'or' characters used in Java.
+# e.g. "(some.other.permission | some.permission.other) & some.thing.else" == a user has 'some.other.permission', or
+# 'some.permission.other', and they also have 'some.thing.else'
+#
+# Groups are represented by the permission node: group.<group name>
+# Per server and per world nodes are represented by: "server-world/permission" or "server/permission"
+#
+# Within conditions, permission nodes MUST be escaped using "<" and ">". See the example below.
+#
+# Explaination of the examples below: (they're just to demonstrate the features & use cases)
+#
+# rule1:
+# If a user is either in the vip or vip+ group, and they have the "titles.titlecollector" permission set to true, and the
+# "some.random.permission" set to false... if they're not in the group "prison_titlepack" on the "prison" server, then
+# give add them to the "prison_titlepack" group on the "prison" server, and remove "some.random.permission".
+#
+# rule2:
+# If the user isn't in any of the following groups on the skyblock server: sb_level1, sb_level2, sb_level3, then add
+# them to sb_level1 on the skyblock server.
+#
+# rule3:
+# If the user is a member of the default group, remove them from default, add them to member, and set their primary group
+# to member.
+#
+# WARNING: Unlike internal commands, this system does not ensure that a group exists before adding a user to it.
+# It also does not unsure that a user is a member of a group before making that group their primary group.
+#
+# Before you use "give: group.<name>" or "set-primary-group", make sure that the group exists, and that the user is
+# a member of the group.
+default-assignments:
+#  rule1:
+#    if:
+#      has-true: (<group.vip> | <group.vip+>) & <titles.tilecollector>
+#      has-false: <some.random.permission>
+#      lacks: <prison/group.prison_titlepack>
+#    give:
+#      - prison/group.prison_titlepack
+#    take:
+#      - some.random.permission
+#  rule2:
+#    if:
+#      lacks: <skyblock/group.sb_level1> & <skyblock/group.sb_level2> & <skyblock/group.sb_level3>
+#    give:
+#      - skyblock/group.sb_level1
+#  rule3:
+#    if:
+#      has-true: <group.default>
+#    take:
+#      - group.default
+#    give:
+#      - group.member
+#    set-primary-group: member

common/pom.xml

@@ -1,11 +1,11 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xmlns="http://maven.apache.org/POM/4.0.0"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <parent>
         <artifactId>luckperms</artifactId>
         <groupId>me.lucko.luckperms</groupId>
-        <version>2.12-SNAPSHOT</version>
+        <version>2.16-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
@@ -36,7 +36,14 @@
         <dependency>
             <groupId>com.zaxxer</groupId>
             <artifactId>HikariCP</artifactId>
-            <version>2.4.7</version>
+            <version>2.5.1</version>
+            <scope>compile</scope>
+        </dependency>
+        <!-- Jedis -->
+        <dependency>
+            <groupId>redis.clients</groupId>
+            <artifactId>jedis</artifactId>
+            <version>2.8.1</version>
             <scope>compile</scope>
         </dependency>
         <!-- SQLite -->
@@ -95,53 +102,6 @@
             <version>1.16.10</version>
             <scope>provided</scope>
         </dependency>
-        <!-- **************Migration Plugins************** -->
-        <dependency>
-            <groupId>org.tyrannyofheaven.bukkit</groupId>
-            <artifactId>zPermissions</artifactId>
-            <version>1.3</version>
-            <scope>provided</scope>
-        </dependency>
-        <dependency>
-            <groupId>ru.tehkode</groupId>
-            <artifactId>PermissionsEx</artifactId>
-            <version>1.23</version>
-            <scope>provided</scope>
-            <exclusions>
-                <exclusion>
-                    <groupId>org.bukkit</groupId>
-                    <artifactId>bukkit</artifactId>
-                </exclusion>
-                <exclusion>
-                    <groupId>net.gravitydevelopment.updater</groupId>
-                    <artifactId>updater</artifactId>
-                </exclusion>
-            </exclusions>
-        </dependency>
-        <dependency>
-            <groupId>com.github.cheesesoftware</groupId>
-            <artifactId>PowerfulPermsAPI</artifactId>
-            <version>1.0.1</version>
-            <scope>provided</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.anjocaido</groupId>
-            <artifactId>GroupManager</artifactId>
-            <version>1.4</version>
-            <scope>provided</scope>
-        </dependency>
-        <dependency>
-            <groupId>net.alpenblock</groupId>
-            <artifactId>BungeePerms</artifactId>
-            <version>3.0-dev-52</version>
-            <scope>provided</scope>
-        </dependency>
-        <dependency>
-            <groupId>de.bananaco</groupId>
-            <artifactId>bpermissions-api</artifactId>
-            <version>2.12</version>
-            <scope>provided</scope>
-        </dependency>
     </dependencies>
 
 </project>

common/src/main/java/me/lucko/luckperms/common/LuckPermsPlugin.java

@@ -27,107 +27,309 @@ import me.lucko.luckperms.api.Logger;
 import me.lucko.luckperms.api.PlatformType;
 import me.lucko.luckperms.common.api.ApiProvider;
 import me.lucko.luckperms.common.calculators.CalculatorFactory;
+import me.lucko.luckperms.common.commands.BaseCommand;
 import me.lucko.luckperms.common.commands.ConsecutiveExecutor;
-import me.lucko.luckperms.common.commands.Sender;
+import me.lucko.luckperms.common.commands.sender.Sender;
 import me.lucko.luckperms.common.config.LPConfiguration;
 import me.lucko.luckperms.common.constants.Message;
 import me.lucko.luckperms.common.contexts.ContextManager;
 import me.lucko.luckperms.common.core.UuidCache;
+import me.lucko.luckperms.common.core.model.User;
 import me.lucko.luckperms.common.data.Importer;
-import me.lucko.luckperms.common.groups.GroupManager;
-import me.lucko.luckperms.common.storage.Datastore;
-import me.lucko.luckperms.common.tracks.TrackManager;
-import me.lucko.luckperms.common.users.UserManager;
+import me.lucko.luckperms.common.managers.GroupManager;
+import me.lucko.luckperms.common.managers.TrackManager;
+import me.lucko.luckperms.common.managers.UserManager;
+import me.lucko.luckperms.common.messaging.RedisMessaging;
+import me.lucko.luckperms.common.storage.Storage;
+import me.lucko.luckperms.common.utils.BufferedRequest;
+import me.lucko.luckperms.common.utils.DebugHandler;
 import me.lucko.luckperms.common.utils.LocaleManager;
+import me.lucko.luckperms.common.utils.PermissionCache;
 
 import java.io.File;
+import java.util.Collections;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Set;
 import java.util.UUID;
+import java.util.concurrent.Executor;
 
 /**
- * Main internal interface for LuckPerms plugins, allowing the luckperms-common module to bind with the plugin instance.
+ * Main internal interface for LuckPerms plugins, providing the base for abstraction throughout the project.
+ *
  * All plugin platforms implement this interface.
  */
 public interface LuckPermsPlugin {
 
-    /*
-     * Access to all of the main internal manager classes
+    /**
+     * Gets the user manager instance for the platform
+     *
+     * @return the user manager
      */
     UserManager getUserManager();
+
+    /**
+     * Gets the group manager instance for the platform
+     *
+     * @return the group manager
+     */
     GroupManager getGroupManager();
+
+    /**
+     * Gets the track manager instance for the platform
+     *
+     * @return the track manager
+     */
     TrackManager getTrackManager();
+
+    /**
+     * Gets the plugin's configuration
+     *
+     * @return the plugin config
+     */
     LPConfiguration getConfiguration();
-    Datastore getDatastore();
+
+    /**
+     * Gets the primary data storage instance. This is likely to be wrapped with extra layers for caching, etc.
+     *
+     * @return the storage handler instance
+     */
+    Storage getStorage();
+
+    /**
+     * Gets the redis messaging instance if present. Could return null if redis is not enabled.
+     *
+     * @return the redis messaging service
+     */
+    RedisMessaging getRedisMessaging();
+
+    /**
+     * Gets a wrapped logger instance for the platform.
+     *
+     * @return the plugin's logger
+     */
     Logger getLog();
+
+    /**
+     * Gets the UUID caching store for the platform
+     *
+     * @return the uuid cache
+     */
     UuidCache getUuidCache();
+
+    /**
+     * Returns the class implementing the LuckPermsAPI on this platform.
+     *
+     * @return the api
+     */
     ApiProvider getApiProvider();
+
+    /**
+     * Gets the importer instance
+     *
+     * @return the importer
+     */
     Importer getImporter();
+
+    /**
+     * Gets the consecutive command executor instance
+     *
+     * @return the consecutive executor
+     */
     ConsecutiveExecutor getConsecutiveExecutor();
+
+    /**
+     * Gets the instance providing locale translations for the plugin
+     *
+     * @return the locale manager
+     */
     LocaleManager getLocaleManager();
+
+    /**
+     * Gets the context manager.
+     * This object handles context accumulation for all players on the platform.
+     *
+     * @return the context manager
+     */
     ContextManager getContextManager();
+
+    /**
+     * Gets the class responsible for constructing PermissionCalculators on this platform.
+     *
+     * @return the permission calculator factory
+     */
     CalculatorFactory getCalculatorFactory();
 
     /**
+     * Gets the verbose debug handler instance.
+     *
+     * @return the debug handler instance
+     */
+    DebugHandler getDebugHandler();
+
+    /**
+     * Gets the permission caching instance for the platform.
+     *
+     * @return the permission cache instance
+     */
+    PermissionCache getPermissionCache();
+
+    /**
+     * Execute a runnable asynchronously
+     *
+     * @param r the task to run
+     */
+    void doAsync(Runnable r);
+
+    /**
+     * Execute a runnable synchronously
+     *
+     * @param r the task to run
+     */
+    void doSync(Runnable r);
+
+    Executor getSyncExecutor();
+
+    Executor getAsyncExecutor();
+
+    /**
+     * Execute a runnable asynchronously on a loop
+     *
+     * @param r        the task to run
+     * @param interval the time between runs in ticks
+     */
+    void doAsyncRepeating(Runnable r, long interval);
+
+    /**
+     * Gets a string of the plugin's version
+     *
      * @return the version of the plugin
      */
     String getVersion();
 
     /**
+     * Gets the platform type this instance of LuckPerms is running on.
+     *
      * @return the platform type
      */
     PlatformType getType();
 
     /**
+     * Gets the plugins main directory
+     *
      * @return the main plugin directory
      */
     File getMainDir();
 
     /**
+     * Gets the plugins main data storage directory
+     *
      * @return the platforms data folder
      */
     File getDataFolder();
 
     /**
      * Returns a colored string indicating the status of a player
+     *
      * @param uuid The player's uuid
      * @return a formatted status string
      */
-    Message getPlayerStatus(UUID uuid);
+    default Message getPlayerStatus(UUID uuid) {
+        UUID external = getUuidCache().getExternalUUID(uuid);
+        return isOnline(external) ? Message.PLAYER_ONLINE : Message.PLAYER_OFFLINE;
+    }
+
+    /**
+     * Gets a player object linked to this User. The returned object must be the same type
+     * as the instance used in the platforms {@link ContextManager}
+     *
+     * @param user the user instance
+     * @return a player object, or null, if one couldn't be found.
+     */
+    Object getPlayer(User user);
+
+    /**
+     * Gets a calculated context instance for the user using the rules of the platform.
+     *
+     * @param user the user instance
+     * @return a contexts object, or null if one couldn't be generated
+     */
+    Contexts getContextForUser(User user);
 
     /**
      * Gets the number of users online on the platform
+     *
      * @return the number of users
      */
     int getPlayerCount();
 
     /**
      * Gets the usernames of the users online on the platform
+     *
      * @return a {@link List} of usernames
      */
     List<String> getPlayerList();
 
     /**
-     * @return a {@link List} of senders online on the platform
+     * Gets the UUIDs of the users online on the platform
+     *
+     * @return a {@link Set} of UUIDs
      */
-    List<Sender> getNotifyListeners();
+    Set<UUID> getOnlinePlayers();
 
     /**
+     * Checks if a user is online
+     *
+     * @param external the users external uuid
+     * @return true if the user is online
+     */
+    boolean isOnline(UUID external);
+
+    /**
+     * Gets a list of online Senders on the platform
+     *
+     * @return a {@link List} of senders online on the platform
+     */
+    List<Sender> getSenders();
+
+    /**
+     * Gets the console.
+     *
      * @return the console sender of the instance
      */
     Sender getConsoleSender();
 
-    // TODO javadoc
+    /**
+     * Gets a set of Contexts that should be pre-processed in advance
+     *
+     * @param op if the user being processed is op
+     * @return a set of contexts
+     */
     Set<Contexts> getPreProcessContexts(boolean op);
 
+    default List<BaseCommand> getExtraCommands() {
+        return Collections.emptyList();
+    }
+
+    /**
+     * Gets a map of extra information to be shown in the info command
+     *
+     * @return a map of options, or null
+     */
+    default LinkedHashMap<String, Object> getExtraInfo() {
+        return null;
+    }
+
     /**
      * Gets a set of players ignoring logging output
-     * @return a {@link Set} of uuids
+     *
+     * @return a {@link Set} of {@link UUID}s
      */
     Set<UUID> getIgnoringLogs();
 
     /**
      * Gets a loaded plugins instance from the platform
+     *
      * @param name the name of the plugin
      * @return a plugin instance
      */
@@ -135,13 +337,15 @@ public interface LuckPermsPlugin {
 
     /**
      * Gets a provided service from the platform.
+     *
      * @param clazz the class of the service
      * @return the service instance, if it is provided for
      */
     Object getService(Class clazz);
 
     /**
-     * Used as a backup for migration
+     * Gets the UUID of a player. Used as a backup for migration
+     *
      * @param playerName the players name
      * @return a uuid if found, or null if not
      */
@@ -149,26 +353,17 @@ public interface LuckPermsPlugin {
 
     /**
      * Checks if a plugin is loaded on the platform
+     *
      * @param name the name of the plugin
      * @return true if the plugin is loaded
      */
     boolean isPluginLoaded(String name);
 
     /**
-     * Runs an update task
+     * Gets the update task buffer of the platform, used for scheduling and running update tasks.
+     *
+     * @return the update task buffer instance
      */
-    void runUpdateTask();
-
-    /**
-     * Execute a runnable asynchronously
-     * @param r the task to run
-     */
-    void doAsync(Runnable r);
-
-    /**
-     * Execute a runnable synchronously
-     * @param r the task to run
-     */
-    void doSync(Runnable r);
+    BufferedRequest<Void> getUpdateTaskBuffer();
 
 }

common/src/main/java/me/lucko/luckperms/common/api/ApiProvider.java

@@ -22,16 +22,39 @@
 
 package me.lucko.luckperms.common.api;
 
-import com.google.common.eventbus.EventBus;
 import lombok.AllArgsConstructor;
 import lombok.NonNull;
-import me.lucko.luckperms.api.*;
+
+import com.google.common.eventbus.EventBus;
+
+import me.lucko.luckperms.api.Contexts;
+import me.lucko.luckperms.api.Datastore;
+import me.lucko.luckperms.api.Group;
+import me.lucko.luckperms.api.LPConfiguration;
+import me.lucko.luckperms.api.Logger;
+import me.lucko.luckperms.api.LuckPermsApi;
+import me.lucko.luckperms.api.MessagingService;
+import me.lucko.luckperms.api.Node;
+import me.lucko.luckperms.api.PlatformType;
+import me.lucko.luckperms.api.Storage;
+import me.lucko.luckperms.api.Track;
+import me.lucko.luckperms.api.User;
+import me.lucko.luckperms.api.UuidCache;
 import me.lucko.luckperms.api.context.ContextListener;
 import me.lucko.luckperms.api.context.IContextCalculator;
 import me.lucko.luckperms.api.event.LPEvent;
 import me.lucko.luckperms.api.event.LPListener;
 import me.lucko.luckperms.common.LuckPermsPlugin;
-import me.lucko.luckperms.common.users.UserIdentifier;
+import me.lucko.luckperms.common.api.internal.DatastoreLink;
+import me.lucko.luckperms.common.api.internal.GroupLink;
+import me.lucko.luckperms.common.api.internal.LPConfigurationLink;
+import me.lucko.luckperms.common.api.internal.StorageLink;
+import me.lucko.luckperms.common.api.internal.TrackLink;
+import me.lucko.luckperms.common.api.internal.UserLink;
+import me.lucko.luckperms.common.api.internal.Utils;
+import me.lucko.luckperms.common.api.internal.UuidCacheLink;
+import me.lucko.luckperms.common.core.NodeBuilder;
+import me.lucko.luckperms.common.core.UserIdentifier;
 
 import java.util.Optional;
 import java.util.Set;
@@ -64,12 +87,12 @@ public class ApiProvider implements LuckPermsApi {
 
     @Override
     public void runUpdateTask() {
-        plugin.runUpdateTask();
+        plugin.getUpdateTaskBuffer().request();
     }
 
     @Override
     public double getApiVersion() {
-        return 2.12;
+        return 2.16;
     }
 
     @Override
@@ -94,17 +117,28 @@ public class ApiProvider implements LuckPermsApi {
 
     @Override
     public LPConfiguration getConfiguration() {
-        return new me.lucko.luckperms.common.api.internal.LPConfigurationLink(plugin.getConfiguration());
+        return new LPConfigurationLink(plugin.getConfiguration());
     }
 
+    @Override
+    public Storage getStorage() {
+        return new StorageLink(plugin, plugin.getStorage());
+    }
+
+    @SuppressWarnings("deprecation")
     @Override
     public Datastore getDatastore() {
-        return new me.lucko.luckperms.common.api.internal.DatastoreLink(plugin, plugin.getDatastore());
+        return new DatastoreLink(plugin, plugin.getStorage());
+    }
+
+    @Override
+    public Optional<MessagingService> getMessagingService() {
+        return Optional.ofNullable(plugin.getRedisMessaging());
     }
 
     @Override
     public UuidCache getUuidCache() {
-        return new me.lucko.luckperms.common.api.internal.UuidCacheLink(plugin.getUuidCache());
+        return new UuidCacheLink(plugin.getUuidCache());
     }
 
     @Override
@@ -114,12 +148,8 @@ public class ApiProvider implements LuckPermsApi {
 
     @Override
     public User getUser(@NonNull UUID uuid) {
-        final me.lucko.luckperms.common.users.User user = plugin.getUserManager().get(uuid);
-        if (user == null) {
-            return null;
-        }
-
-        return new me.lucko.luckperms.common.api.internal.UserLink(user);
+        final me.lucko.luckperms.common.core.model.User user = plugin.getUserManager().get(uuid);
+        return user == null ? null : new UserLink(user);
     }
 
     @Override
@@ -129,12 +159,8 @@ public class ApiProvider implements LuckPermsApi {
 
     @Override
     public User getUser(@NonNull String name) {
-        final me.lucko.luckperms.common.users.User user = plugin.getUserManager().get(name);
-        if (user == null) {
-            return null;
-        }
-
-        return new me.lucko.luckperms.common.api.internal.UserLink(user);
+        final me.lucko.luckperms.common.core.model.User user = plugin.getUserManager().getByUsername(name);
+        return user == null ? null : new UserLink(user);
     }
 
     @Override
@@ -144,7 +170,7 @@ public class ApiProvider implements LuckPermsApi {
 
     @Override
     public Set<User> getUsers() {
-        return plugin.getUserManager().getAll().values().stream().map(me.lucko.luckperms.common.api.internal.UserLink::new).collect(Collectors.toSet());
+        return plugin.getUserManager().getAll().values().stream().map(UserLink::new).collect(Collectors.toSet());
     }
 
     @Override
@@ -154,18 +180,14 @@ public class ApiProvider implements LuckPermsApi {
 
     @Override
     public void cleanupUser(@NonNull User user) {
-        me.lucko.luckperms.common.api.internal.Utils.checkUser(user);
-        plugin.getUserManager().cleanup(((me.lucko.luckperms.common.api.internal.UserLink) user).getMaster());
+        Utils.checkUser(user);
+        plugin.getUserManager().cleanup(((UserLink) user).getMaster());
     }
 
     @Override
     public Group getGroup(@NonNull String name) {
-        final me.lucko.luckperms.common.groups.Group group = plugin.getGroupManager().get(name);
-        if (group == null) {
-            return null;
-        }
-
-        return new me.lucko.luckperms.common.api.internal.GroupLink(group);
+        final me.lucko.luckperms.common.core.model.Group group = plugin.getGroupManager().getIfLoaded(name);
+        return group == null ? null : new GroupLink(group);
     }
 
     @Override
@@ -175,7 +197,7 @@ public class ApiProvider implements LuckPermsApi {
 
     @Override
     public Set<Group> getGroups() {
-        return plugin.getGroupManager().getAll().values().stream().map(me.lucko.luckperms.common.api.internal.GroupLink::new).collect(Collectors.toSet());
+        return plugin.getGroupManager().getAll().values().stream().map(GroupLink::new).collect(Collectors.toSet());
     }
 
     @Override
@@ -185,12 +207,8 @@ public class ApiProvider implements LuckPermsApi {
 
     @Override
     public Track getTrack(@NonNull String name) {
-        final me.lucko.luckperms.common.tracks.Track track = plugin.getTrackManager().get(name);
-        if (track == null) {
-            return null;
-        }
-
-        return new me.lucko.luckperms.common.api.internal.TrackLink(track);
+        final me.lucko.luckperms.common.core.model.Track track = plugin.getTrackManager().getIfLoaded(name);
+        return track == null ? null : new TrackLink(track);
     }
 
     @Override
@@ -200,7 +218,7 @@ public class ApiProvider implements LuckPermsApi {
 
     @Override
     public Set<Track> getTracks() {
-        return plugin.getTrackManager().getAll().values().stream().map(me.lucko.luckperms.common.api.internal.TrackLink::new).collect(Collectors.toSet());
+        return plugin.getTrackManager().getAll().values().stream().map(TrackLink::new).collect(Collectors.toSet());
     }
 
     @Override
@@ -210,7 +228,7 @@ public class ApiProvider implements LuckPermsApi {
 
     @Override
     public Node.Builder buildNode(@NonNull String permission) throws IllegalArgumentException {
-        return new me.lucko.luckperms.common.core.Node.Builder(checkNode(permission));
+        return new NodeBuilder(checkNode(permission));
     }
 
     @SuppressWarnings("unchecked")
@@ -224,4 +242,10 @@ public class ApiProvider implements LuckPermsApi {
     public void registerContextListener(ContextListener<?> contextListener) {
         plugin.getContextManager().registerListener(contextListener);
     }
+
+    @Override
+    public Optional<Contexts> getContextForUser(User user) {
+        Utils.checkUser(user);
+        return Optional.ofNullable(plugin.getContextForUser(((UserLink) user).getMaster()));
+    }
 }

common/src/main/java/me/lucko/luckperms/common/api/internal/DatastoreLink.java

@@ -22,35 +22,44 @@
 
 package me.lucko.luckperms.common.api.internal;
 
-import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
-import lombok.NoArgsConstructor;
 import lombok.NonNull;
-import me.lucko.luckperms.api.*;
+
+import me.lucko.luckperms.api.Datastore;
+import me.lucko.luckperms.api.Group;
+import me.lucko.luckperms.api.Log;
+import me.lucko.luckperms.api.LogEntry;
+import me.lucko.luckperms.api.Track;
+import me.lucko.luckperms.api.User;
 import me.lucko.luckperms.api.data.Callback;
 import me.lucko.luckperms.common.LuckPermsPlugin;
+import me.lucko.luckperms.common.storage.Storage;
 
 import java.util.Set;
 import java.util.UUID;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
+import java.util.concurrent.CompletableFuture;
 
-import static me.lucko.luckperms.common.api.internal.Utils.*;
+import static me.lucko.luckperms.common.api.internal.Utils.checkGroup;
+import static me.lucko.luckperms.common.api.internal.Utils.checkName;
+import static me.lucko.luckperms.common.api.internal.Utils.checkTrack;
+import static me.lucko.luckperms.common.api.internal.Utils.checkUser;
+import static me.lucko.luckperms.common.api.internal.Utils.checkUsername;
 
 /**
- * Provides a link between {@link Datastore} and {@link me.lucko.luckperms.common.storage.Datastore}
+ * Provides a link between {@link Datastore} and {@link Storage}
+ *
+ * Note that this class only provides for the old deprecated interface, see {@link StorageLink} for the new one.
  */
-@SuppressWarnings({"unused", "WeakerAccess"})
+@SuppressWarnings({"unused", "WeakerAccess", "deprecation"})
 public class DatastoreLink implements Datastore {
 
     private final LuckPermsPlugin plugin;
-    private final me.lucko.luckperms.common.storage.Datastore master;
+    private final Storage master;
     private final Async async;
     private final Sync sync;
     private final Future future;
 
-    public DatastoreLink(@NonNull LuckPermsPlugin plugin, @NonNull me.lucko.luckperms.common.storage.Datastore master) {
+    public DatastoreLink(@NonNull LuckPermsPlugin plugin, @NonNull Storage master) {
         this.plugin = plugin;
         this.master = master;
         this.async = new Async(master);
@@ -58,12 +67,10 @@ public class DatastoreLink implements Datastore {
         this.future = new Future(master);
     }
 
-    private static <T> Callback<T> checkCallback(Callback<T> c) {
-        // If no callback was given, just send an empty one
-        if (c == null) {
-            c = Callback.empty();
+    private <T> void registerCallback(CompletableFuture<T> fut, Callback<T> c) {
+        if (c != null) {
+            fut.thenAcceptAsync(Callback.convertToConsumer(c), plugin.getSyncExecutor());
         }
-        return c;
     }
 
     @Override
@@ -93,68 +100,68 @@ public class DatastoreLink implements Datastore {
 
     @AllArgsConstructor
     public class Async implements Datastore.Async {
-        private final me.lucko.luckperms.common.storage.Datastore master;
+        private final me.lucko.luckperms.common.storage.Storage master;
 
         @Override
         public void logAction(@NonNull LogEntry entry, Callback<Boolean> callback) {
-            master.logAction(entry, checkCallback(callback));
+            registerCallback(master.force().logAction(entry), callback);
         }
 
         @Override
-        public void getLog(Callback<Log> callback) {
-            master.getLog(log -> callback.onComplete(new LogLink(log)));
+        public void getLog(@NonNull Callback<Log> callback) {
+            master.force().getLog().thenAcceptAsync(log -> callback.onComplete(new LogLink(log)), plugin.getSyncExecutor());
         }
 
         @Override
         public void loadOrCreateUser(@NonNull UUID uuid, @NonNull String username, Callback<Boolean> callback) {
-            master.loadUser(uuid, checkUsername(username), checkCallback(callback));
+            registerCallback(master.force().loadUser(uuid, checkUsername(username)), callback);
         }
 
         @Override
         public void loadUser(@NonNull UUID uuid, Callback<Boolean> callback) {
-            master.loadUser(uuid, "null", checkCallback(callback));
+            registerCallback(master.force().loadUser(uuid, "null"), callback);
         }
 
         @Override
         public void loadUser(@NonNull UUID uuid, @NonNull String username, Callback<Boolean> callback) {
-            master.loadUser(uuid, checkUsername(username), checkCallback(callback));
+            registerCallback(master.force().loadUser(uuid, checkUsername(username)), callback);
         }
 
         @Override
         public void saveUser(@NonNull User user, Callback<Boolean> callback) {
             checkUser(user);
-            master.saveUser(((UserLink) user).getMaster(), checkCallback(callback));
+            registerCallback(master.force().saveUser(((UserLink) user).getMaster()), callback);
         }
 
         @Override
         public void cleanupUsers(Callback<Boolean> callback) {
-            master.cleanupUsers(checkCallback(callback));
+            registerCallback(master.force().cleanupUsers(), callback);
         }
 
         @Override
         public void getUniqueUsers(Callback<Set<UUID>> callback) {
-            master.getUniqueUsers(checkCallback(callback));
+            registerCallback(master.force().getUniqueUsers(), callback);
         }
 
         @Override
         public void createAndLoadGroup(@NonNull String name, Callback<Boolean> callback) {
-            master.createAndLoadGroup(checkName(name), checkCallback(callback));
+            registerCallback(master.force().createAndLoadGroup(checkName(name)), callback);
         }
 
         @Override
         public void loadGroup(@NonNull String name, Callback<Boolean> callback) {
-            master.loadGroup(checkName(name), checkCallback(callback));
+            registerCallback(master.force().loadGroup(checkName(name)), callback);
         }
 
         @Override
         public void loadAllGroups(Callback<Boolean> callback) {
-            master.loadAllGroups(checkCallback(callback));
+            registerCallback(master.force().loadAllGroups(), callback);
         }
 
         @Override
         public void saveGroup(@NonNull Group group, Callback<Boolean> callback) {
             checkGroup(group);
-            master.saveGroup(((GroupLink) group).getMaster(), checkCallback(callback));
+            registerCallback(master.force().saveGroup(((GroupLink) group).getMaster()), callback);
         }
 
         @Override
@@ -163,111 +170,115 @@ public class DatastoreLink implements Datastore {
             if (group.getName().equalsIgnoreCase(plugin.getConfiguration().getDefaultGroupName())) {
                 throw new IllegalArgumentException("Cannot delete the default group.");
             }
-            master.deleteGroup(((GroupLink) group).getMaster(), checkCallback(callback));
+            registerCallback(master.force().deleteGroup(((GroupLink) group).getMaster()), callback);
         }
 
         @Override
         public void createAndLoadTrack(@NonNull String name, Callback<Boolean> callback) {
-            master.createAndLoadTrack(checkName(name), checkCallback(callback));
+            registerCallback(master.force().createAndLoadTrack(checkName(name)), callback);
         }
 
         @Override
         public void loadTrack(@NonNull String name, Callback<Boolean> callback) {
-            master.loadTrack(checkName(name), checkCallback(callback));
+            registerCallback(master.force().loadTrack(checkName(name)), callback);
         }
 
         @Override
         public void loadAllTracks(Callback<Boolean> callback) {
-            master.loadAllTracks(checkCallback(callback));
+            registerCallback(master.force().loadAllTracks(), callback);
         }
 
         @Override
         public void saveTrack(@NonNull Track track, Callback<Boolean> callback) {
             checkTrack(track);
-            master.saveTrack(((TrackLink) track).getMaster(), checkCallback(callback));
+            registerCallback(master.force().saveTrack(((TrackLink) track).getMaster()), callback);
         }
 
         @Override
         public void deleteTrack(@NonNull Track track, Callback<Boolean> callback) {
             checkTrack(track);
-            master.deleteTrack(((TrackLink) track).getMaster(), checkCallback(callback));
+            registerCallback(master.force().deleteTrack(((TrackLink) track).getMaster()), callback);
         }
 
         @Override
         public void saveUUIDData(@NonNull String username, @NonNull UUID uuid, Callback<Boolean> callback) {
-            master.saveUUIDData(checkUsername(username), uuid, checkCallback(callback));
+            registerCallback(master.force().saveUUIDData(checkUsername(username), uuid), callback);
         }
 
         @Override
         public void getUUID(@NonNull String username, Callback<UUID> callback) {
-            master.getUUID(checkUsername(username), checkCallback(callback));
+            registerCallback(master.force().getUUID(checkUsername(username)), callback);
         }
     }
 
     @AllArgsConstructor
     public class Sync implements Datastore.Sync {
-        private final me.lucko.luckperms.common.storage.Datastore master;
+        private final Storage master;
 
         @Override
         public boolean logAction(@NonNull LogEntry entry) {
-            return master.logAction(entry);
+            return master.force().logAction(entry).join();
         }
 
         @Override
         public Log getLog() {
-            return new LogLink(master.getLog());
+            me.lucko.luckperms.common.data.Log log = master.force().getLog().join();
+            if (log == null) {
+                return null;
+            }
+            return new LogLink(log);
         }
 
         @Override
         public boolean loadOrCreateUser(@NonNull UUID uuid, @NonNull String username) {
-            return master.loadUser(uuid, checkUsername(username));
+            return master.force().loadUser(uuid, checkUsername(username)).join();
         }
 
         @Override
         public boolean loadUser(@NonNull UUID uuid) {
-            return master.loadUser(uuid, "null");
+            return master.force().loadUser(uuid, "null").join();
         }
 
         @Override
         public boolean loadUser(@NonNull UUID uuid, @NonNull String username) {
-            return master.loadUser(uuid, checkUsername(username));
+            return master.force().loadUser(uuid, checkUsername(username)).join();
         }
 
         @Override
         public boolean saveUser(@NonNull User user) {
             checkUser(user);
-            return master.saveUser(((UserLink) user).getMaster());
+            return master.force().saveUser(((UserLink) user).getMaster()).join();
         }
 
         @Override
         public boolean cleanupUsers() {
-            return master.cleanupUsers();
+            return master.force().cleanupUsers().join();
         }
 
         @Override
         public Set<UUID> getUniqueUsers() {
-            return master.getUniqueUsers();
+            return master.force().getUniqueUsers().join();
         }
 
         @Override
         public boolean createAndLoadGroup(@NonNull String name) {
-            return master.createAndLoadGroup(checkName(name));
+            return master.force().createAndLoadGroup(checkName(name)).join();
         }
 
         @Override
         public boolean loadGroup(@NonNull String name) {
-            return master.loadGroup(checkName(name));
+            return master.force().loadGroup(checkName(name)).join();
         }
 
         @Override
         public boolean loadAllGroups() {
-            return master.loadAllGroups();
+            return master.force().loadAllGroups().join();
         }
 
         @Override
         public boolean saveGroup(@NonNull Group group) {
             checkGroup(group);
-            return master.saveGroup(((GroupLink) group).getMaster());
+            return master.force().saveGroup(((GroupLink) group).getMaster()).join();
         }
 
         @Override
@@ -276,240 +287,157 @@ public class DatastoreLink implements Datastore {
             if (group.getName().equalsIgnoreCase(plugin.getConfiguration().getDefaultGroupName())) {
                 throw new IllegalArgumentException("Cannot delete the default group.");
             }
-            return master.deleteGroup(((GroupLink) group).getMaster());
+            return master.force().deleteGroup(((GroupLink) group).getMaster()).join();
         }
 
         @Override
         public boolean createAndLoadTrack(@NonNull String name) {
-            return master.createAndLoadTrack(checkName(name));
+            return master.force().createAndLoadTrack(checkName(name)).join();
         }
 
         @Override
         public boolean loadTrack(@NonNull String name) {
-            return master.loadTrack(checkName(name));
+            return master.force().loadTrack(checkName(name)).join();
         }
 
         @Override
         public boolean loadAllTracks() {
-            return master.loadAllTracks();
+            return master.force().loadAllTracks().join();
         }
 
         @Override
         public boolean saveTrack(@NonNull Track track) {
             checkTrack(track);
-            return master.saveTrack(((TrackLink) track).getMaster());
+            return master.force().saveTrack(((TrackLink) track).getMaster()).join();
         }
 
         @Override
         public boolean deleteTrack(@NonNull Track track) {
             checkTrack(track);
-            return master.deleteTrack(((TrackLink) track).getMaster());
+            return master.force().deleteTrack(((TrackLink) track).getMaster()).join();
         }
 
         @Override
         public boolean saveUUIDData(@NonNull String username, @NonNull UUID uuid) {
-            return master.saveUUIDData(checkUsername(username), uuid);
+            return master.force().saveUUIDData(checkUsername(username), uuid).join();
         }
 
         @Override
         public UUID getUUID(@NonNull String username) {
-            return master.getUUID(checkUsername(username));
+            return master.force().getUUID(checkUsername(username)).join();
         }
     }
 
     @AllArgsConstructor
     public class Future implements Datastore.Future {
-        private final me.lucko.luckperms.common.storage.Datastore master;
+        private final Storage master;
 
         @Override
         public java.util.concurrent.Future<Boolean> logAction(@NonNull LogEntry entry) {
-            LPFuture<Boolean> lpf = new LPFuture<>();
-            master.logAction(entry, lpf);
-            return lpf;
+            return master.force().logAction(entry);
         }
 
         @Override
         public java.util.concurrent.Future<Log> getLog() {
-            LPFuture<Log> lpf = new LPFuture<>();
-            master.getLog(log -> lpf.onComplete(new LogLink(log)));
-            return lpf;
+            return master.force().getLog().thenApply(log -> log == null ? null : new LogLink(log));
         }
 
         @Override
         public java.util.concurrent.Future<Boolean> loadOrCreateUser(@NonNull UUID uuid, @NonNull String username) {
-            LPFuture<Boolean> lpf = new LPFuture<>();
-            master.loadUser(uuid, checkUsername(username), lpf);
-            return lpf;
+            return master.force().loadUser(uuid, checkUsername(username));
         }
 
         @Override
         public java.util.concurrent.Future<Boolean> loadUser(@NonNull UUID uuid) {
-            LPFuture<Boolean> lpf = new LPFuture<>();
-            master.loadUser(uuid, "null", lpf);
-            return lpf;
+            return master.force().loadUser(uuid, "null");
         }
 
         @Override
         public java.util.concurrent.Future<Boolean> loadUser(@NonNull UUID uuid, @NonNull String username) {
-            LPFuture<Boolean> lpf = new LPFuture<>();
-            master.loadUser(uuid, checkUsername(username), lpf);
-            return lpf;
+            return master.force().loadUser(uuid, checkUsername(username));
         }
 
         @Override
         public java.util.concurrent.Future<Boolean> saveUser(@NonNull User user) {
-            LPFuture<Boolean> lpf = new LPFuture<>();
             checkUser(user);
-            master.saveUser(((UserLink) user).getMaster(), lpf);
-            return lpf;
+            return master.force().saveUser(((UserLink) user).getMaster());
         }
 
         @Override
         public java.util.concurrent.Future<Boolean> cleanupUsers() {
-            LPFuture<Boolean> lpf = new LPFuture<>();
-            master.cleanupUsers(lpf);
-            return lpf;
+            return master.force().cleanupUsers();
         }
 
         @Override
         public java.util.concurrent.Future<Set<UUID>> getUniqueUsers() {
-            LPFuture<Set<UUID>> lpf = new LPFuture<>();
-            master.getUniqueUsers(lpf);
-            return lpf;
+            return master.force().getUniqueUsers();
         }
 
         @Override
         public java.util.concurrent.Future<Boolean> createAndLoadGroup(@NonNull String name) {
-            LPFuture<Boolean> lpf = new LPFuture<>();
-            master.createAndLoadGroup(checkName(name), lpf);
-            return lpf;
+            return master.force().createAndLoadGroup(checkName(name));
         }
 
         @Override
         public java.util.concurrent.Future<Boolean> loadGroup(@NonNull String name) {
-            LPFuture<Boolean> lpf = new LPFuture<>();
-            master.loadGroup(checkName(name), lpf);
-            return lpf;
+            return master.force().loadGroup(checkName(name));
         }
 
         @Override
         public java.util.concurrent.Future<Boolean> loadAllGroups() {
-            LPFuture<Boolean> lpf = new LPFuture<>();
-            master.loadAllGroups(lpf);
-            return lpf;
+            return master.force().loadAllGroups();
         }
 
         @Override
         public java.util.concurrent.Future<Boolean> saveGroup(@NonNull Group group) {
-            LPFuture<Boolean> lpf = new LPFuture<>();
             checkGroup(group);
-            master.saveGroup(((GroupLink) group).getMaster(), lpf);
-            return lpf;
+            return master.force().saveGroup(((GroupLink) group).getMaster());
         }
 
         @Override
         public java.util.concurrent.Future<Boolean> deleteGroup(@NonNull Group group) {
-            LPFuture<Boolean> lpf = new LPFuture<>();
             checkGroup(group);
             if (group.getName().equalsIgnoreCase(plugin.getConfiguration().getDefaultGroupName())) {
                 throw new IllegalArgumentException("Cannot delete the default group.");
             }
-            master.deleteGroup(((GroupLink) group).getMaster(), lpf);
-            return lpf;
+            return master.force().deleteGroup(((GroupLink) group).getMaster());
         }
 
         @Override
         public java.util.concurrent.Future<Boolean> createAndLoadTrack(@NonNull String name) {
-            LPFuture<Boolean> lpf = new LPFuture<>();
-            master.createAndLoadTrack(checkName(name), lpf);
-            return lpf;
+            return master.force().createAndLoadTrack(checkName(name));
         }
 
         @Override
         public java.util.concurrent.Future<Boolean> loadTrack(@NonNull String name) {
-            LPFuture<Boolean> lpf = new LPFuture<>();
-            master.loadTrack(checkName(name), lpf);
-            return lpf;
+            return master.force().loadTrack(checkName(name));
         }
 
         @Override
         public java.util.concurrent.Future<Boolean> loadAllTracks() {
-            LPFuture<Boolean> lpf = new LPFuture<>();
-            master.loadAllTracks(lpf);
-            return lpf;
+            return master.force().loadAllTracks();
         }
 
         @Override
         public java.util.concurrent.Future<Boolean> saveTrack(@NonNull Track track) {
-            LPFuture<Boolean> lpf = new LPFuture<>();
             checkTrack(track);
-            master.saveTrack(((TrackLink) track).getMaster(), lpf);
-            return lpf;
+            return master.force().saveTrack(((TrackLink) track).getMaster());
         }
 
         @Override
         public java.util.concurrent.Future<Boolean> deleteTrack(@NonNull Track track) {
-            LPFuture<Boolean> lpf = new LPFuture<>();
             checkTrack(track);
-            master.deleteTrack(((TrackLink) track).getMaster(), lpf);
-            return lpf;
+            return master.force().deleteTrack(((TrackLink) track).getMaster());
         }
 
         @Override
         public java.util.concurrent.Future<Boolean> saveUUIDData(@NonNull String username, @NonNull UUID uuid) {
-            LPFuture<Boolean> lpf = new LPFuture<>();
-            master.saveUUIDData(checkUsername(username), uuid, lpf);
-            return lpf;
+            return master.force().saveUUIDData(checkUsername(username), uuid);
         }
 
         @Override
         public java.util.concurrent.Future<UUID> getUUID(@NonNull String username) {
-            LPFuture<UUID> lpf = new LPFuture<>();
-            master.getUUID(checkUsername(username), lpf);
-            return lpf;
-        }
-    }
-
-    @NoArgsConstructor(access = AccessLevel.PRIVATE)
-    public static class LPFuture<T> implements Callback<T>, java.util.concurrent.Future<T> {
-        private final CountDownLatch latch = new CountDownLatch(1);
-        private T value;
-
-        @Override
-        public void onComplete(T t) {
-            value = t;
-            latch.countDown();
-        }
-
-        @Override
-        public boolean cancel(boolean mayInterruptIfRunning) {
-            // Not supported
-            return false;
-        }
-
-        @Override
-        public boolean isCancelled() {
-            return false;
-        }
-
-        @Override
-        public boolean isDone() {
-            return latch.getCount() == 0;
-        }
-
-        @Override
-        public T get() throws InterruptedException {
-            latch.await();
-            return value;
-        }
-
-        @Override
-        public T get(long timeout, TimeUnit unit) throws InterruptedException, TimeoutException {
-            if (latch.await(timeout, unit)) {
-                return value;
-            } else {
-                throw new TimeoutException();
-            }
+            return master.force().getUUID(checkUsername(username));
         }
     }
 

common/src/main/java/me/lucko/luckperms/common/api/internal/GroupLink.java

@@ -26,28 +26,31 @@ import lombok.AccessLevel;
 import lombok.EqualsAndHashCode;
 import lombok.Getter;
 import lombok.NonNull;
+
 import me.lucko.luckperms.api.Group;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
 
 import java.util.List;
 
-import static me.lucko.luckperms.common.api.internal.Utils.*;
+import static me.lucko.luckperms.common.api.internal.Utils.checkGroup;
+import static me.lucko.luckperms.common.api.internal.Utils.checkServer;
+import static me.lucko.luckperms.common.api.internal.Utils.checkTime;
 
 /**
- * Provides a link between {@link Group} and {@link me.lucko.luckperms.common.groups.Group}
+ * Provides a link between {@link Group} and {@link me.lucko.luckperms.common.core.model.Group}
  */
 @EqualsAndHashCode(of = {"name"}, callSuper = false)
 @SuppressWarnings("unused")
 public class GroupLink extends PermissionHolderLink implements Group {
 
     @Getter(AccessLevel.PACKAGE)
-    private final me.lucko.luckperms.common.groups.Group master;
+    private final me.lucko.luckperms.common.core.model.Group master;
 
     @Getter
     private final String name;
 
-    public GroupLink(@NonNull me.lucko.luckperms.common.groups.Group master) {
+    public GroupLink(@NonNull me.lucko.luckperms.common.core.model.Group master) {
         super(master);
         this.master = master;
         this.name = master.getName();

common/src/main/java/me/lucko/luckperms/common/api/internal/LPConfigurationLink.java

@@ -23,6 +23,7 @@
 package me.lucko.luckperms.common.api.internal;
 
 import lombok.AllArgsConstructor;
+
 import me.lucko.luckperms.api.LPConfiguration;
 import me.lucko.luckperms.api.data.DatastoreConfiguration;
 import me.lucko.luckperms.api.data.MySQLConfiguration;
@@ -103,7 +104,7 @@ public class LPConfigurationLink implements LPConfiguration {
 
     @Override
     public boolean getDebugPermissionChecks() {
-        return master.isDebugPermissionChecks();
+        return false;
     }
 
     @Override

common/src/main/java/me/lucko/luckperms/common/api/internal/LogLink.java

@@ -24,6 +24,7 @@ package me.lucko.luckperms.common.api.internal;
 
 import lombok.AllArgsConstructor;
 import lombok.NonNull;
+
 import me.lucko.luckperms.api.Log;
 import me.lucko.luckperms.api.LogEntry;
 
@@ -39,7 +40,7 @@ import static me.lucko.luckperms.common.api.internal.Utils.checkName;
 @AllArgsConstructor
 public class LogLink implements Log {
     private final me.lucko.luckperms.common.data.Log master;
-    
+
     @Override
     public SortedSet<LogEntry> getContent() {
         return master.getContent();

common/src/main/java/me/lucko/luckperms/common/api/internal/PermissionHolderLink.java

@@ -24,24 +24,37 @@ package me.lucko.luckperms.common.api.internal;
 
 import lombok.AllArgsConstructor;
 import lombok.NonNull;
-import me.lucko.luckperms.api.*;
+
+import me.lucko.luckperms.api.Contexts;
+import me.lucko.luckperms.api.LocalizedNode;
+import me.lucko.luckperms.api.Node;
+import me.lucko.luckperms.api.PermissionHolder;
+import me.lucko.luckperms.api.Tristate;
+import me.lucko.luckperms.api.context.ContextSet;
+import me.lucko.luckperms.common.utils.ExtractedContexts;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
 
-import java.util.*;
+import java.util.AbstractMap;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.SortedSet;
 
-import static me.lucko.luckperms.common.api.internal.Utils.*;
-import static me.lucko.luckperms.common.core.PermissionHolder.exportToLegacy;
+import static me.lucko.luckperms.common.api.internal.Utils.checkNode;
+import static me.lucko.luckperms.common.api.internal.Utils.checkServer;
+import static me.lucko.luckperms.common.api.internal.Utils.checkTime;
+import static me.lucko.luckperms.common.core.model.PermissionHolder.exportToLegacy;
 
 /**
- * Provides a link between {@link PermissionHolder} and {@link me.lucko.luckperms.common.core.PermissionHolder}
+ * Provides a link between {@link PermissionHolder} and {@link me.lucko.luckperms.common.core.model.PermissionHolder}
  */
 @SuppressWarnings("unused")
 @AllArgsConstructor
 public class PermissionHolderLink implements PermissionHolder {
-
-    @NonNull
-    private final me.lucko.luckperms.common.core.PermissionHolder master;
+    private final me.lucko.luckperms.common.core.model.PermissionHolder master;
 
     @Override
     public String getObjectName() {
@@ -65,17 +78,17 @@ public class PermissionHolderLink implements PermissionHolder {
 
     @Override
     public Set<Node> getAllNodes() {
-        return Collections.unmodifiableSet(master.getAllNodes(null, Contexts.allowAll()));
+        return Collections.unmodifiableSet(master.getAllNodes(null, ExtractedContexts.generate(Contexts.allowAll())));
     }
 
     @Override
     public SortedSet<LocalizedNode> getAllNodes(@NonNull Contexts contexts) {
-        return master.getAllNodes(null, contexts);
+        return master.getAllNodes(null, ExtractedContexts.generate(contexts));
     }
 
     @Override
     public Set<LocalizedNode> getAllNodesFiltered(@NonNull Contexts contexts) {
-        return master.getAllNodesFiltered(contexts);
+        return master.getAllNodesFiltered(ExtractedContexts.generate(contexts));
     }
 
     @Override
@@ -247,7 +260,7 @@ public class PermissionHolderLink implements PermissionHolder {
         if (world != null && !world.equals("")) {
             context.put("world", world);
         }
-        return master.exportNodes(new Contexts(context, true, true, true, true, true), Collections.emptyList(), false);
+        return master.exportNodes(new Contexts(ContextSet.fromMap(context), true, true, true, true, true, false), false);
     }
 
     @Override
@@ -259,7 +272,7 @@ public class PermissionHolderLink implements PermissionHolder {
         if (world != null && !world.equals("")) {
             context.put("world", world);
         }
-        return master.exportNodes(new Contexts(context, true, true, true, true, true), Collections.emptyList(), false);
+        return master.exportNodes(new Contexts(ContextSet.fromMap(context), true, true, true, true, true, false), false);
     }
 
     @Override
@@ -283,7 +296,7 @@ public class PermissionHolderLink implements PermissionHolder {
         if (world != null && !world.equals("")) {
             extraContext.put("world", world);
         }
-        return master.exportNodes(new Contexts(extraContext, includeGlobal, includeGlobal, applyGroups, true, true), possibleNodes, false);
+        return master.exportNodes(new Contexts(ContextSet.fromMap(extraContext), includeGlobal, includeGlobal, applyGroups, true, true, false), false);
     }
 
     @Override

common/src/main/java/me/lucko/luckperms/common/api/internal/StorageLink.java

@@ -0,0 +1,172 @@
+/*
+ * 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.api.internal;
+
+import lombok.AllArgsConstructor;
+import lombok.NonNull;
+
+import me.lucko.luckperms.api.Group;
+import me.lucko.luckperms.api.Log;
+import me.lucko.luckperms.api.LogEntry;
+import me.lucko.luckperms.api.Storage;
+import me.lucko.luckperms.api.Track;
+import me.lucko.luckperms.api.User;
+import me.lucko.luckperms.common.LuckPermsPlugin;
+
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Executor;
+
+import static me.lucko.luckperms.common.api.internal.Utils.checkGroup;
+import static me.lucko.luckperms.common.api.internal.Utils.checkName;
+import static me.lucko.luckperms.common.api.internal.Utils.checkTrack;
+import static me.lucko.luckperms.common.api.internal.Utils.checkUser;
+import static me.lucko.luckperms.common.api.internal.Utils.checkUsername;
+
+/**
+ * Provides a link between {@link Storage} and {@link me.lucko.luckperms.common.storage.Storage}
+ */
+@AllArgsConstructor
+public class StorageLink implements Storage {
+    private final LuckPermsPlugin plugin;
+    private final me.lucko.luckperms.common.storage.Storage master;
+
+    @Override
+    public String getName() {
+        return master.getName();
+    }
+
+    @Override
+    public boolean isAcceptingLogins() {
+        return master.isAcceptingLogins();
+    }
+
+    @Override
+    public Executor getSyncExecutor() {
+        return plugin.getSyncExecutor();
+    }
+
+    @Override
+    public Executor getAsyncExecutor() {
+        return plugin.getAsyncExecutor();
+    }
+
+    @Override
+    public CompletableFuture<Boolean> logAction(@NonNull LogEntry entry) {
+        return master.force().logAction(entry);
+    }
+
+    @Override
+    public CompletableFuture<Log> getLog() {
+        return master.force().getLog().thenApply(log -> log == null ? null : new LogLink(log));
+    }
+
+    @Override
+    public CompletableFuture<Boolean> loadUser(UUID uuid, String username) {
+        return master.force().loadUser(uuid, checkUsername(username));
+    }
+
+    @Override
+    public CompletableFuture<Boolean> saveUser(User user) {
+        checkUser(user);
+        return master.force().saveUser(((UserLink) user).getMaster());
+    }
+
+    @Override
+    public CompletableFuture<Boolean> cleanupUsers() {
+        return master.force().cleanupUsers();
+    }
+
+    @Override
+    public CompletableFuture<Set<UUID>> getUniqueUsers() {
+        return master.force().getUniqueUsers();
+    }
+
+    @Override
+    public CompletableFuture<Boolean> createAndLoadGroup(String name) {
+        return master.force().createAndLoadGroup(checkName(name));
+    }
+
+    @Override
+    public CompletableFuture<Boolean> loadGroup(String name) {
+        return master.force().loadGroup(checkName(name));
+    }
+
+    @Override
+    public CompletableFuture<Boolean> loadAllGroups() {
+        return master.force().loadAllGroups();
+    }
+
+    @Override
+    public CompletableFuture<Boolean> saveGroup(Group group) {
+        checkGroup(group);
+        return master.force().saveGroup(((GroupLink) group).getMaster());
+    }
+
+    @Override
+    public CompletableFuture<Boolean> deleteGroup(Group group) {
+        checkGroup(group);
+        if (group.getName().equalsIgnoreCase(plugin.getConfiguration().getDefaultGroupName())) {
+            throw new IllegalArgumentException("Cannot delete the default group.");
+        }
+        return master.force().deleteGroup(((GroupLink) group).getMaster());
+    }
+
+    @Override
+    public CompletableFuture<Boolean> createAndLoadTrack(String name) {
+        return master.force().createAndLoadTrack(checkName(name));
+    }
+
+    @Override
+    public CompletableFuture<Boolean> loadTrack(String name) {
+        return master.force().loadTrack(checkName(name));
+    }
+
+    @Override
+    public CompletableFuture<Boolean> loadAllTracks() {
+        return master.force().loadAllTracks();
+    }
+
+    @Override
+    public CompletableFuture<Boolean> saveTrack(Track track) {
+        checkTrack(track);
+        return master.force().saveTrack(((TrackLink) track).getMaster());
+    }
+
+    @Override
+    public CompletableFuture<Boolean> deleteTrack(Track track) {
+        checkTrack(track);
+        return master.force().deleteTrack(((TrackLink) track).getMaster());
+    }
+
+    @Override
+    public CompletableFuture<Boolean> saveUUIDData(String username, UUID uuid) {
+        return master.force().saveUUIDData(checkUsername(username), uuid);
+    }
+
+    @Override
+    public CompletableFuture<UUID> getUUID(String username) {
+        return master.force().getUUID(checkUsername(username));
+    }
+}

common/src/main/java/me/lucko/luckperms/common/api/internal/TrackLink.java

@@ -26,6 +26,7 @@ import lombok.AccessLevel;
 import lombok.EqualsAndHashCode;
 import lombok.Getter;
 import lombok.NonNull;
+
 import me.lucko.luckperms.api.Group;
 import me.lucko.luckperms.api.Track;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
@@ -36,19 +37,19 @@ import java.util.List;
 import static me.lucko.luckperms.common.api.internal.Utils.checkGroup;
 
 /**
- * Provides a link between {@link Track} and {@link me.lucko.luckperms.common.tracks.Track}
+ * Provides a link between {@link Track} and {@link me.lucko.luckperms.common.core.model.Track}
  */
 @EqualsAndHashCode(of = {"name"})
 @SuppressWarnings("unused")
 public class TrackLink implements Track {
 
     @Getter(AccessLevel.PACKAGE)
-    private final me.lucko.luckperms.common.tracks.Track master;
+    private final me.lucko.luckperms.common.core.model.Track master;
 
     @Getter
     private final String name;
 
-    public TrackLink(@NonNull me.lucko.luckperms.common.tracks.Track master) {
+    public TrackLink(@NonNull me.lucko.luckperms.common.core.model.Track master) {
         this.master = master;
         this.name = master.getName();
     }

common/src/main/java/me/lucko/luckperms/common/api/internal/UserLink.java

@@ -25,30 +25,35 @@ package me.lucko.luckperms.common.api.internal;
 import lombok.EqualsAndHashCode;
 import lombok.Getter;
 import lombok.NonNull;
+
 import me.lucko.luckperms.api.Group;
 import me.lucko.luckperms.api.User;
+import me.lucko.luckperms.api.caching.UserData;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
 
 import java.util.List;
+import java.util.Optional;
 import java.util.UUID;
 
-import static me.lucko.luckperms.common.api.internal.Utils.*;
+import static me.lucko.luckperms.common.api.internal.Utils.checkGroup;
+import static me.lucko.luckperms.common.api.internal.Utils.checkServer;
+import static me.lucko.luckperms.common.api.internal.Utils.checkTime;
 
 /**
- * Provides a link between {@link User} and {@link me.lucko.luckperms.common.users.User}
+ * Provides a link between {@link User} and {@link me.lucko.luckperms.common.core.model.User}
  */
 @EqualsAndHashCode(of = {"uuid"}, callSuper = false)
 @SuppressWarnings("unused")
 public class UserLink extends PermissionHolderLink implements User {
 
     @Getter
-    private final me.lucko.luckperms.common.users.User master;
+    private final me.lucko.luckperms.common.core.model.User master;
 
     @Getter
     private final UUID uuid;
 
-    public UserLink(@NonNull me.lucko.luckperms.common.users.User master) {
+    public UserLink(@NonNull me.lucko.luckperms.common.core.model.User master) {
         super(master);
         this.master = master;
         this.uuid = master.getUuid();
@@ -79,97 +84,102 @@ public class UserLink extends PermissionHolderLink implements User {
 
     @Override
     public void refreshPermissions() {
-        master.refreshPermissions();
+        master.getRefreshBuffer().requestDirectly();
+    }
+
+    @Override
+    public Optional<UserData> getUserDataCache() {
+        return Optional.ofNullable(master.getUserData());
     }
 
     @Override
     public boolean isInGroup(@NonNull Group group) {
         checkGroup(group);
-        return master.isInGroup(((GroupLink) group).getMaster());
+        return master.inheritsGroup(((GroupLink) group).getMaster());
     }
 
     @Override
     public boolean isInGroup(@NonNull Group group, @NonNull String server) {
         checkGroup(group);
-        return master.isInGroup(((GroupLink) group).getMaster(), server);
+        return master.inheritsGroup(((GroupLink) group).getMaster(), server);
     }
 
     @Override
     public boolean isInGroup(@NonNull Group group, @NonNull String server, @NonNull String world) {
         checkGroup(group);
-        return master.isInGroup(((GroupLink) group).getMaster(), server, world);
+        return master.inheritsGroup(((GroupLink) group).getMaster(), server, world);
     }
 
     @Override
     public void addGroup(@NonNull Group group) throws ObjectAlreadyHasException {
         checkGroup(group);
-        master.addGroup(((GroupLink) group).getMaster());
+        master.setInheritGroup(((GroupLink) group).getMaster());
     }
 
     @Override
     public void addGroup(@NonNull Group group, @NonNull String server) throws ObjectAlreadyHasException {
         checkGroup(group);
-        master.addGroup(((GroupLink) group).getMaster(), checkServer(server));
+        master.setInheritGroup(((GroupLink) group).getMaster(), checkServer(server));
     }
 
     @Override
     public void addGroup(@NonNull Group group, @NonNull String server, @NonNull String world) throws ObjectAlreadyHasException {
         checkGroup(group);
-        master.addGroup(((GroupLink) group).getMaster(), checkServer(server), world);
+        master.setInheritGroup(((GroupLink) group).getMaster(), checkServer(server), world);
     }
 
     @Override
     public void addGroup(@NonNull Group group, @NonNull long expireAt) throws ObjectAlreadyHasException {
         checkGroup(group);
-        master.addGroup(((GroupLink) group).getMaster(), checkTime(expireAt));
+        master.setInheritGroup(((GroupLink) group).getMaster(), checkTime(expireAt));
     }
 
     @Override
     public void addGroup(@NonNull Group group, @NonNull String server, @NonNull long expireAt) throws ObjectAlreadyHasException {
         checkGroup(group);
-        master.addGroup(((GroupLink) group).getMaster(), checkServer(server), checkTime(expireAt));
+        master.setInheritGroup(((GroupLink) group).getMaster(), checkServer(server), checkTime(expireAt));
     }
 
     @Override
     public void addGroup(@NonNull Group group, @NonNull String server, @NonNull String world, @NonNull long expireAt) throws ObjectAlreadyHasException {
         checkGroup(group);
-        master.addGroup(((GroupLink) group).getMaster(), checkServer(server), world, checkTime(expireAt));
+        master.setInheritGroup(((GroupLink) group).getMaster(), checkServer(server), world, checkTime(expireAt));
     }
 
     @Override
     public void removeGroup(@NonNull Group group) throws ObjectLacksException {
         checkGroup(group);
-        master.removeGroup(((GroupLink) group).getMaster());
+        master.unsetInheritGroup(((GroupLink) group).getMaster());
     }
 
     @Override
     public void removeGroup(@NonNull Group group, @NonNull boolean temporary) throws ObjectLacksException {
         checkGroup(group);
-        master.removeGroup(((GroupLink) group).getMaster(), temporary);
+        master.unsetInheritGroup(((GroupLink) group).getMaster(), temporary);
     }
 
     @Override
     public void removeGroup(@NonNull Group group, @NonNull String server) throws ObjectLacksException {
         checkGroup(group);
-        master.removeGroup(((GroupLink) group).getMaster(), checkServer(server));
+        master.unsetInheritGroup(((GroupLink) group).getMaster(), checkServer(server));
     }
 
     @Override
     public void removeGroup(@NonNull Group group, @NonNull String server, @NonNull String world) throws ObjectLacksException {
         checkGroup(group);
-        master.removeGroup(((GroupLink) group).getMaster(), checkServer(server), world);
+        master.unsetInheritGroup(((GroupLink) group).getMaster(), checkServer(server), world);
     }
 
     @Override
     public void removeGroup(@NonNull Group group, @NonNull String server, @NonNull boolean temporary) throws ObjectLacksException {
         checkGroup(group);
-        master.removeGroup(((GroupLink) group).getMaster(), checkServer(server), temporary);
+        master.unsetInheritGroup(((GroupLink) group).getMaster(), checkServer(server), temporary);
     }
 
     @Override
     public void removeGroup(@NonNull Group group, @NonNull String server, @NonNull String world, @NonNull boolean temporary) throws ObjectLacksException {
         checkGroup(group);
-        master.removeGroup(((GroupLink) group).getMaster(), checkServer(server), world, temporary);
+        master.unsetInheritGroup(((GroupLink) group).getMaster(), checkServer(server), world, temporary);
     }
 
     @Override

common/src/main/java/me/lucko/luckperms/common/api/internal/Utils.java

@@ -23,6 +23,9 @@
 package me.lucko.luckperms.common.api.internal;
 
 import lombok.experimental.UtilityClass;
+
+import com.google.common.base.Preconditions;
+
 import me.lucko.luckperms.api.Group;
 import me.lucko.luckperms.api.Track;
 import me.lucko.luckperms.api.User;
@@ -32,57 +35,51 @@ import me.lucko.luckperms.common.utils.ArgumentChecker;
 public class Utils {
 
     public static void checkUser(User user) {
-        if (!(user instanceof UserLink)) {
-            throw new IllegalStateException("User instance cannot be handled by this implementation.");
-        }
+        Preconditions.checkState(user instanceof UserLink, "User instance cannot be handled by this implementation.");
     }
 
     public static void checkGroup(Group group) {
-        if (!(group instanceof GroupLink)) {
-            throw new IllegalStateException("Group instance cannot be handled by this implementation.");
-        }
+        Preconditions.checkState(group instanceof GroupLink, "Group instance cannot be handled by this implementation.");
     }
 
     public static void checkTrack(Track track) {
-        if (!(track instanceof TrackLink)) {
-            throw new IllegalStateException("Track instance cannot be handled by this implementation.");
-        }
+        Preconditions.checkState(track instanceof TrackLink, "Track instance cannot be handled by this implementation.");
     }
 
     public static String checkUsername(String s) {
-        if (ArgumentChecker.checkUsername(s)) {
-            throw new IllegalArgumentException("Invalid username entry '" + s + "'. Usernames must be less than 16 chars" +
-                    " and only contain 'a-z A-Z 1-9 _'.");
-        }
+        Preconditions.checkArgument(
+                !ArgumentChecker.checkUsername(s),
+                "Invalid username entry '" + s + "'. Usernames must be less than 16 chars and only contain 'a-z A-Z 1-9 _'."
+        );
         return s;
     }
 
     public static String checkName(String s) {
-        if (ArgumentChecker.checkName(s)) {
-            throw new IllegalArgumentException("Invalid name entry '" + s + "'. Names must be less than 37 chars" +
-                    " and only contain 'a-z A-Z 1-9'.");
-        }
+        Preconditions.checkArgument(
+                !ArgumentChecker.checkName(s),
+                "Invalid name entry '" + s + "'. Names must be less than 37 chars and only contain 'a-z A-Z 1-9'."
+        );
         return s.toLowerCase();
     }
 
     public static String checkServer(String s) {
-        if (ArgumentChecker.checkServer(s)) {
-            throw new IllegalArgumentException("Invalid server entry '" + s + "'. Server names can only contain alphanumeric characters.");
-        }
+        Preconditions.checkArgument(
+                !ArgumentChecker.checkServer(s),
+                "Invalid server entry '" + s + "'. Server names can only contain alphanumeric characters."
+        );
         return s;
     }
 
     public static String checkNode(String s) {
-        if (ArgumentChecker.checkNode(s)) {
-            throw new IllegalArgumentException("Invalid node entry '" + s + "'. Nodes cannot contain '/' or '$' characters.");
-        }
+        Preconditions.checkArgument(
+                !ArgumentChecker.checkNode(s),
+                "Invalid node entry '" + s + "'. Nodes cannot contain '/' or '$' characters."
+        );
         return s;
     }
 
     public static long checkTime(long l) {
-        if (ArgumentChecker.checkTime(l)) {
-            throw new IllegalArgumentException("Unix time '" + l + "' is invalid, as it has already passed.");
-        }
+        Preconditions.checkArgument(!ArgumentChecker.checkTime(l), "Unix time '" + l + "' is invalid, as it has already passed.");
         return l;
     }
 

common/src/main/java/me/lucko/luckperms/common/api/internal/UuidCacheLink.java

@@ -23,6 +23,8 @@
 package me.lucko.luckperms.common.api.internal;
 
 import lombok.AllArgsConstructor;
+import lombok.NonNull;
+
 import me.lucko.luckperms.api.UuidCache;
 
 import java.util.UUID;
@@ -35,12 +37,12 @@ public class UuidCacheLink implements UuidCache {
     private final me.lucko.luckperms.common.core.UuidCache master;
 
     @Override
-    public UUID getUUID(UUID external) {
+    public UUID getUUID(@NonNull UUID external) {
         return master.getUUID(external);
     }
 
     @Override
-    public UUID getExternalUUID(UUID internal) {
+    public UUID getExternalUUID(@NonNull UUID internal) {
         return master.getExternalUUID(internal);
     }
 }

common/src/main/java/me/lucko/luckperms/common/caching/MetaCache.java

@@ -0,0 +1,93 @@
+/*
+ * 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;
+
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSortedMap;
+
+import me.lucko.luckperms.api.caching.MetaData;
+
+import java.util.Map;
+import java.util.SortedMap;
+import java.util.concurrent.locks.ReadWriteLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+
+/**
+ * Holds a user's cached meta for a given context
+ */
+@NoArgsConstructor
+public class MetaCache implements MetaData {
+    private final ReadWriteLock lock = new ReentrantReadWriteLock();
+
+    @Getter
+    private Map<String, String> meta = ImmutableMap.of();
+
+    @Getter
+    private SortedMap<Integer, String> prefixes = ImmutableSortedMap.of();
+
+    @Getter
+    private SortedMap<Integer, String> suffixes = ImmutableSortedMap.of();
+
+    public void loadMeta(MetaHolder meta) {
+        lock.writeLock().lock();
+        try {
+            this.meta = ImmutableMap.copyOf(meta.getMeta());
+            this.prefixes = ImmutableSortedMap.copyOfSorted(meta.getPrefixes());
+            this.suffixes = ImmutableSortedMap.copyOfSorted(meta.getSuffixes());
+        } finally {
+            lock.writeLock().unlock();
+        }
+    }
+
+    @Override
+    public String getPrefix() {
+        lock.readLock().lock();
+        try {
+            if (prefixes.isEmpty()) {
+                return null;
+            }
+
+            return prefixes.get(prefixes.firstKey());
+        } finally {
+            lock.readLock().unlock();
+        }
+    }
+
+    @Override
+    public String getSuffix() {
+        lock.readLock().lock();
+        try {
+            if (suffixes.isEmpty()) {
+                return null;
+            }
+
+            return suffixes.get(suffixes.firstKey());
+        } finally {
+            lock.readLock().unlock();
+        }
+    }
+
+}