Events rewrite, remove most deprecated API methods (v3.0)

Fix bukkit child permission handling to not include permissions with no children & cleanup permission registration
ensure all bukkit permissions are registered on startup
2017-02-19 14:57:20 +00:00 · 2017-02-18 21:01:09 +00:00 · 2017-02-18 08:50:06 +00:00 · 2017-02-16 21:45:43 +00:00 · 2017-02-16 21:43:27 +00:00 · 2017-02-15 19:39:24 +00:00
528 changed files with 35637 additions and 17691 deletions
@@ -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*
@@ -1,29 +1,44 @@
 ![alt text](https://i.imgur.com/7TwJZ5e.png "Banner")
 # LuckPerms [![Build Status](https://ci.lucko.me/job/LuckPerms/badge/icon)](https://ci.lucko.me/job/LuckPerms/)
-An advanced permissions implementation for Bukkit/Spigot, BungeeCord and Sponge.
+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.

-## Links
+LuckPerms also includes an extensive API for developers, and support for a variety of Minecraft server software & data storage options.
+
+[See the charts below](https://github.com/lucko/LuckPerms#luckperms-vs-other-plugins) 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")
+
+## Useful Links
 * **Development Builds** - <https://ci.lucko.me/job/LuckPerms>
 * **Javadocs** - <https://jd.lucko.me/LuckPerms>
 * **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.
+## Building
+LuckPerms uses Maven to handle dependencies.

-* [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")
+#### Requirements
+* Maven 3.3.x (the older versions will not work.)
+* Git
+
+#### Then run
+```sh
+git clone https://github.com/lucko/LuckPerms.git
+mvn clean package
+```
+
+## License
+LuckPerms is licensed under the permissive MIT license. Please see [`LICENSE.txt`](https://github.com/lucko/LuckPerms/blob/master/LICENSE.txt) for more info.

 ## LuckPerms vs Other Plugins
 ### Bukkit
 ![alt text](https://static.lucko.me/luckperms-compare-copy.png "Feature comparison")
-_Features checked on 23rd Aug 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._
+###### _Features checked on 23rd Aug 2016. If you find any inaccuracies, please let me know._
 ### 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.
+###### _Features checked on 8th Oct 2016. If you find any inaccuracies, please let me know._

-## Thanks to:
+## Thanks
 [![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").
+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").
@@ -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>3.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

@@ -27,13 +27,17 @@ import me.lucko.luckperms.api.LuckPermsApi;
 import java.util.Optional;

 /**
- * Static access to LuckPerms
+ * Singleton for the {@link LuckPermsApi}.
+ *
+ * <p> Ideally, the ServiceManager for the platform should be used to obtain and cache an instance, however, this can be
+ * used if you need static access.
 */
 public final class LuckPerms {
    private static LuckPermsApi api = null;

    /**
-     * Gets an instance of {@link LuckPermsApi}
+     * Gets an instance of {@link LuckPermsApi}, throwing {@link IllegalStateException} if the API is not loaded.
+     *
     * @return an api instance
     * @throws IllegalStateException if the api is not loaded
     */
@@ -45,8 +49,11 @@ 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}.
+     * Gets an instance of {@link LuckPermsApi} safely.
+     *
+     * <p> 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() {
@@ -22,63 +22,42 @@

 package me.lucko.luckperms.api;

-import com.google.common.collect.ImmutableMap;
-
-import java.util.Collections;
-import java.util.Map;
+import me.lucko.luckperms.api.context.ContextSet;

 /**
- * Represents the context and options for a permission lookup.
- * All values are immutable.
+ * Context and options for a permission lookup.
+ *
+ * <p> 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(Map<String, String> context, boolean includeGlobal, boolean includeGlobalWorld, boolean applyGroups, boolean applyGlobalGroups, boolean applyGlobalWorldGroups) {
-        return new Contexts(context, includeGlobal, includeGlobalWorld, applyGroups, applyGlobalGroups, applyGlobalWorldGroups);
-    }
-
-    public static Contexts of(Map<String, String> context, boolean includeGlobal, boolean includeGlobalWorld, boolean applyGroups, boolean applyGlobalGroups, boolean applyGlobalWorldGroups, boolean op) {
+    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);
    }

-    public Contexts(Map<String, String> 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.includeGlobal = includeGlobal;
-        this.includeGlobalWorld = includeGlobalWorld;
-        this.applyGroups = applyGroups;
-        this.applyGlobalGroups = applyGlobalGroups;
-        this.applyGlobalWorldGroups = applyGlobalWorldGroups;
-        this.op = op;
-    }
-
-    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;
+    private final ContextSet context;

    /**
     * The mode to parse defaults on Bukkit
+     *
     * @since 2.12
     */
    private final boolean op;
@@ -108,16 +87,33 @@ public class Contexts {
     */
    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 = context.makeImmutable();
+        this.includeGlobal = includeGlobal;
+        this.includeGlobalWorld = includeGlobalWorld;
+        this.applyGroups = applyGroups;
+        this.applyGlobalGroups = applyGlobalGroups;
+        this.applyGlobalWorldGroups = applyGlobalWorldGroups;
+        this.op = op;
+    }
+
    /**
     * 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 if OP defaults should be included
+     *
     * @return true if op defaults should be included
     */
    public boolean isOp() {
@@ -126,6 +122,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 +131,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 +140,7 @@ public class Contexts {

    /**
     * Gets if parent groups should be applied
+     *
     * @return true if parent groups should be applied
     */
    public boolean isApplyGroups() {
@@ -150,6 +149,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 +158,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 +167,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 +183,7 @@ public class Contexts {

    /**
     * Check for equality
+     *
     * @param o the other
     * @return true if equal
     * @since 2.12
@@ -190,8 +192,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 +206,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);
@@ -1,308 +0,0 @@
-/*
- * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
- *
- *  Permission is hereby granted, free of charge, to any person obtaining a copy
- *  of this software and associated documentation files (the "Software"), to deal
- *  in the Software without restriction, including without limitation the rights
- *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- *  copies of the Software, and to permit persons to whom the Software is
- *  furnished to do so, subject to the following conditions:
- *
- *  The above copyright notice and this permission notice shall be included in all
- *  copies or substantial portions of the Software.
- *
- *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- *  SOFTWARE.
- */
-
-package me.lucko.luckperms.api;
-
-import me.lucko.luckperms.api.data.Callback;
-
-import java.util.Set;
-import java.util.UUID;
-
-/**
- * Interface for the internal Datastore instance
- */
-@SuppressWarnings("unused")
-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
-     */
-    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
-     */
-    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
-     */
-    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.
-     */
-    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. 
-     */
-    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.
-     */
-    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);
-    }
-}
@@ -26,212 +26,237 @@ import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
 import me.lucko.luckperms.exceptions.ObjectLacksException;

 import java.util.List;
+import java.util.OptionalInt;

 /**
- * Interface for internal Group instances
+ * A group which holds permission data.
 */
-@SuppressWarnings("unused")
 public interface Group extends PermissionHolder {

    /**
+     * Get the name of the group
+     *
     * @return the name of the group
     */
    String getName();

    /**
     * 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;

-    /**
-     * Clear all of the groups permission nodes
-     */
-    void clearNodes();
-
    /**
     * 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
     * @return a {@link List} of group names
-     * @throws NullPointerException if the server or world is null
+     * @throws NullPointerException     if the server is null
+     * @throws IllegalArgumentException if the server is invalid
+     */
+    List<String> getLocalGroups(String server);
+
+
+    /**
+     * Get a {@link List} of the groups the group inherits on a specific server and world
+     *
+     * @param server the server 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 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 IllegalArgumentException if the server is invalid
+     * Gets the weight of this group, is present.
+     *
+     * @return the group weight
+     * @since 2.17
     */
-    List<String> getLocalGroups(String server);
+    OptionalInt getWeight();
+
 }
@@ -0,0 +1,94 @@
+/*
+ * 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 com.google.common.collect.Multimap;
+
+import java.util.Optional;
+import java.util.OptionalLong;
+
+/**
+ * A relationship between a Holder and a permission
+ *
+ * @param <T> the identifier type of the holder
+ * @since 2.17
+ */
+public interface HeldPermission<T> {
+
+    /**
+     * Gets the holder of the permission
+     *
+     * @return the holder
+     */
+    T getHolder();
+
+    /**
+     * Gets the permission being held
+     *
+     * @return the permission
+     */
+    String getPermission();
+
+    /**
+     * Gets the value of the permission
+     *
+     * @return the value
+     */
+    boolean getValue();
+
+    /**
+     * Gets the server where the permission is held
+     *
+     * @return the server
+     */
+    Optional<String> getServer();
+
+    /**
+     * Gets the world where the permission is held
+     *
+     * @return the world
+     */
+    Optional<String> getWorld();
+
+    /**
+     * Gets the time in unix time when the permission will expire
+     *
+     * @return the expiry time
+     */
+    OptionalLong getExpiry();
+
+    /**
+     * Gets the context for the permission.
+     *
+     * @return the context
+     */
+    Multimap<String, String> getContext();
+
+    /**
+     * Converts this permission into a Node
+     *
+     * @return a Node copy of this permission
+     */
+    Node asNode();
+
+}
@@ -23,152 +23,142 @@
 package me.lucko.luckperms.api;

 import me.lucko.luckperms.api.data.DatastoreConfiguration;
-import me.lucko.luckperms.api.data.MySQLConfiguration;

 import java.util.Map;

 /**
- * A wrapper interface for the internal LuckPerms configuration, providing read only access.
+ * Read-only access to the LuckPerms configuration settings
 */
-@SuppressWarnings("unused")
 public interface LPConfiguration {

    /**
+     * Returns the name of this server
     * @return the name of this server
     */
    String getServer();

    /**
+     * Returns how often a sync task will run in minutes
     * @return how often a sync task will run in minutes
     */
    int getSyncTime();

    /**
-     * @return the default group, in a node representation
-     * @deprecated as of 2.6, the default group is always "default"
-     */
-    @Deprecated
-    String getDefaultGroupNode();
-
-    /**
-     * @return the name of the default group
-     * @deprecated as of 2.6, the default group is always "default"
-     */
-    @Deprecated
-    String getDefaultGroupName();
-
-    /**
+     * Returns if the users on this server will have their global permissions applied
     * @return if the users on this server will have their global permissions applied
     */
    boolean getIncludeGlobalPerms();

    /**
+     * Returns if the users on this server will have their global world permissions applied
     * @return if the users on this server will have their global world permissions applied
     * @since 2.9
     */
    boolean getIncludeGlobalWorldPerms();

    /**
+     * Returns true if the platform is applying global groups
     * @return true if the platform is applying global groups
     * @since 2.9
     */
    boolean getApplyGlobalGroups();

    /**
+     * Returns true if the platform is applying global world groups
     * @return true if the platform is applying global world groups
     * @since 2.9
     */
    boolean getApplyGlobalWorldGroups();

    /**
-     * @return the online mode setting in the config
+     * Returns the online mode setting
+     * @return the online mode setting
     */
    boolean getOnlineMode();

    /**
+     * Returns if LuckPerms is applying wildcard permissions
     * @return if LuckPerms is applying wildcard permissions
     */
    boolean getApplyWildcards();

    /**
+     * Returns if LuckPerms is resolving and applying regex permissions
     * @return if LuckPerms is resolving and applying regex permissions
     */
    boolean getApplyRegex();

    /**
+     * Returns if LuckPerms is expanding shorthand permissions
     * @return if LuckPerms is expanding shorthand permissions
     */
    boolean getApplyShorthand();

    /**
+     * Returns if LuckPerms will send notifications to users when permissions are modified
     * @return if LuckPerms will send notifications to users when permissions are modified
     * @since 2.7
     */
    boolean getLogNotify();

    /**
-     * @return true if permission checks are being recorded / debugged
-     * @since 2.9
-     */
-    boolean getDebugPermissionChecks();
-
-    /**
+     * Returns true if the vanilla op system is enabled
     * @return true if the vanilla op system is enabled
     * @since 2.8
     */
    boolean getEnableOps();

    /**
+     * Returns true if opped players are allowed to use LuckPerms commands
     * @return true if opped players are allowed to use LuckPerms commands
     * @since 2.8
     */
    boolean getCommandsAllowOp();

    /**
+     * Returns true if auto op is enabled
     * @return true if auto op is enabled
     * @since 2.9
     */
    boolean getAutoOp();

    /**
+     * Returns the name of the server used within Vault operations
     * @return the name of the server used within Vault operations
     * @since 2.7
     */
    String getVaultServer();

    /**
+     * Returns true if global permissions should be considered when retrieving meta or player groups
     * @return true if global permissions should be considered when retrieving meta or player groups
     * @since 2.7
     */
    boolean getVaultIncludeGlobal();

    /**
-     * @return the database values set in the configuration
-     * @deprecated use {@link #getDatastoreConfig()}
-     */
-    @SuppressWarnings("deprecation")
-    @Deprecated
-    MySQLConfiguration getDatabaseValues();
-
-    /**
+     * Returns the values set for data storage in the configuration
     * @return the values set for data storage in the configuration
     */
    DatastoreConfiguration getDatastoreConfig();

    /**
+     * Returns the storage method string from the configuration
     * @return the storage method string from the configuration
     */
    String getStorageMethod();

    /**
+     * Returns true if split storage is enabled
     * @return true if split storage is enabled
     * @since 2.7
     */
    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
+     * Returns a map of split storage options
+     * @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();
@@ -23,19 +23,22 @@
 package me.lucko.luckperms.api;

 /**
- * Represents a Node and where it was inherited from.
+ * A node with a traceable origin
+ *
 * @since 2.11
 */
 public interface LocalizedNode extends Node {

    /**
-     * Gets the node
+     * Gets the delegate 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()
     */
@@ -28,9 +28,10 @@ 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.
+ *
+ * <p> The returned instance provides a copy of the data at the time of retrieval. Any changes made to log entries will
+ * only apply to this instance of the log. You can add to the log using the {@link Storage}, and then request an updated copy.
 */
-@SuppressWarnings("unused")
 public interface Log {

    /**
@@ -45,8 +46,11 @@ public interface Log {

    /**
     * Gets the recent content separated by page
+     *
     * @param pageNo the page number
     * @return the page content
+     * @throws IllegalArgumentException if the pageNo is less than 1
+     * @throws IllegalStateException if the log doesn't contain enough entries to populate the page. See {@link #getRecentMaxPages()}}
     */
    SortedMap<Integer, LogEntry> getRecent(int pageNo);

@@ -64,9 +68,12 @@ 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
+     * @throws IllegalArgumentException if the pageNo is less than 1
+     * @throws IllegalStateException if the log doesn't contain enough entries to populate the page. See {@link #getRecentMaxPages(UUID)}}
     */
    SortedMap<Integer, LogEntry> getRecent(int pageNo, UUID actor);

@@ -85,9 +92,12 @@ 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
+     * @throws IllegalArgumentException if the pageNo is less than 1
+     * @throws IllegalStateException if the log doesn't contain enough entries to populate the page. See {@link #getUserHistoryMaxPages(UUID)}}
     */
    SortedMap<Integer, LogEntry> getUserHistory(int pageNo, UUID uuid);

@@ -97,7 +107,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,9 +116,12 @@ 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
+     * @throws IllegalArgumentException if the pageNo is less than 1
+     * @throws IllegalStateException if the log doesn't contain enough entries to populate the page. See {@link #getGroupHistoryMaxPages(String)}}
     */
    SortedMap<Integer, LogEntry> getGroupHistory(int pageNo, String name);

@@ -127,8 +140,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);
@@ -136,9 +150,12 @@ public interface Log {
    /**
     * @param name the name to filter by
     * @return the max page number allowed in the {@link #getTrackHistory(int, String)} method
+     * @throws IllegalArgumentException if the pageNo is less than 1
+     * @throws IllegalStateException if the log doesn't contain enough entries to populate the page. See {@link #getTrackHistoryMaxPages(String)}}
     */
    int getTrackHistoryMaxPages(String name);

+
    /**
     * @param query the query to filter by
     * @return all content in this log where the content matches query
@@ -147,9 +164,12 @@ 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
+     * @throws IllegalArgumentException if the pageNo is less than 1
+     * @throws IllegalStateException if the log doesn't contain enough entries to populate the page. See {@link #getSearchMaxPages(String)}}
     */
    SortedMap<Integer, LogEntry> getSearch(int pageNo, String query);

@@ -25,16 +25,17 @@ package me.lucko.luckperms.api;
 import java.util.UUID;

 /**
- * Represents a single entry in a log
+ * A single entry in the log
+ *
+ * <p> Implements {@link Comparable} ordering based upon the timestamp of the entry.
 */
-@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,63 +101,69 @@ 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;
    }

    @Override
    public String toString() {
-        return "LogEntry(timestamp=" + this.getTimestamp() + ", actor=" + this.getActor() + ", actorName=" +
-                this.getActorName() + ", type=" + this.getType() + ", acted=" + this.getActed() + ", actedName=" +
-                this.getActedName() + ", action=" + this.getAction() + ")";
+        return "LogEntry(" +
+                "timestamp=" + this.getTimestamp() + ", " +
+                "actor=" + this.getActor() + ", " +
+                "actorName=" + this.getActorName() + ", " +
+                "type=" + this.getType() + ", " +
+                "acted=" + this.getActed() + ", " +
+                "actedName=" + this.getActedName() + ", " +
+                "action=" + this.getAction() +
+                ")";
    }

    @Override
@@ -165,41 +172,25 @@ public class LogEntry implements Comparable<LogEntry> {
        if (!(o instanceof LogEntry)) return false;
        final LogEntry other = (LogEntry) o;
        if (this.getTimestamp() != other.getTimestamp()) return false;
-        final Object this$actor = this.getActor();
-        final Object other$actor = other.getActor();
-        if (this$actor == null ? other$actor != null : !this$actor.equals(other$actor)) return false;
-        final Object this$actorName = this.getActorName();
-        final Object other$actorName = other.getActorName();
-        if (this$actorName == null ? other$actorName != null : !this$actorName.equals(other$actorName)) return false;
+        if (this.getActor() == null ? other.getActor() != null : !this.getActor().equals(other.getActor())) return false;
+        if (this.getActorName() == null ? other.getActorName() != null : !this.getActorName().equals(other.getActorName())) return false;
        if (this.getType() != other.getType()) return false;
-        final Object this$acted = this.getActed();
-        final Object other$acted = other.getActed();
-        if (this$acted == null ? other$acted != null : !this$acted.equals(other$acted)) return false;
-        final Object this$actedName = this.getActedName();
-        final Object other$actedName = other.getActedName();
-        if (this$actedName == null ? other$actedName != null : !this$actedName.equals(other$actedName)) return false;
-        final Object this$action = this.getAction();
-        final Object other$action = other.getAction();
-        return this$action == null ? other$action == null : this$action.equals(other$action);
+        if (this.getActed() == null ? other.getActed() != null : !this.getActed().equals(other.getActed())) return false;
+        if (this.getActedName() == null ? other.getActedName() != null : !this.getActedName().equals(other.getActedName())) return false;
+        return this.getAction() == null ? other.getAction() == null : this.getAction().equals(other.getAction());
    }

    @Override
    public int hashCode() {
        final int PRIME = 59;
        int result = 1;
-        final long $timestamp = this.getTimestamp();
-        result = result * PRIME + (int) ($timestamp >>> 32 ^ $timestamp);
-        final Object $actor = this.getActor();
-        result = result * PRIME + ($actor == null ? 43 : $actor.hashCode());
-        final Object $actorName = this.getActorName();
-        result = result * PRIME + ($actorName == null ? 43 : $actorName.hashCode());
+        result = result * PRIME + (int) (this.getTimestamp() >>> 32 ^ this.getTimestamp());
+        result = result * PRIME + (this.getActor() == null ? 43 : this.getActor().hashCode());
+        result = result * PRIME + (this.getActorName() == null ? 43 : this.getActorName().hashCode());
        result = result * PRIME + this.getType();
-        final Object $acted = this.getActed();
-        result = result * PRIME + ($acted == null ? 43 : $acted.hashCode());
-        final Object $actedName = this.getActedName();
-        result = result * PRIME + ($actedName == null ? 43 : $actedName.hashCode());
-        final Object $action = this.getAction();
-        result = result * PRIME + ($action == null ? 43 : $action.hashCode());
+        result = result * PRIME + (this.getActed() == null ? 43 : this.getActed().hashCode());
+        result = result * PRIME + (this.getActedName() == null ? 43 : this.getActedName().hashCode());
+        result = result * PRIME + (this.getAction() == null ? 43 : this.getAction().hashCode());
        return result;
    }

@@ -214,6 +205,7 @@ public class LogEntry implements Comparable<LogEntry> {
        protected LogEntryBuilder getThis() {
            return this;
        }
+
    }

    public static abstract class AbstractLogEntryBuilder<T extends LogEntry, B extends AbstractLogEntryBuilder<T, B>> {
@@ -226,6 +218,7 @@ public class LogEntry implements Comparable<LogEntry> {
        }

        protected abstract T createObj();
+
        protected abstract B getThis();

        public long getTimestamp() {
@@ -310,9 +303,15 @@ public class LogEntry implements Comparable<LogEntry> {

        @Override
        public String toString() {
-            return "LogEntry.LogEntryBuilder(timestamp=" + getTimestamp() + ", actor=" + getActor() + ", actorName=" +
-                    getActorName() + ", type=" + getType() + ", acted=" + getActed() + ", actedName=" + getActedName() +
-                    ", action=" + getAction() + ")";
+            return "LogEntry.LogEntryBuilder(" +
+                    "timestamp=" + this.getTimestamp() + ", " +
+                    "actor=" + this.getActor() + ", " +
+                    "actorName=" + this.getActorName() + ", " +
+                    "type=" + this.getType() + ", " +
+                    "acted=" + this.getActed() + ", " +
+                    "actedName=" + this.getActedName() + ", " +
+                    "action=" + this.getAction() +
+                    ")";
        }
    }

@@ -23,15 +23,17 @@
 package me.lucko.luckperms.api;

 /**
- * A wrapper interface for platform logger instances.
+ * 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);

 }
@@ -22,18 +22,17 @@

 package me.lucko.luckperms.api;

-import me.lucko.luckperms.api.context.ContextListener;
-import me.lucko.luckperms.api.context.IContextCalculator;
-import me.lucko.luckperms.api.event.LPListener;
+import me.lucko.luckperms.api.context.ContextCalculator;
+import me.lucko.luckperms.api.context.ContextSet;
+import me.lucko.luckperms.api.event.EventBus;

 import java.util.Optional;
 import java.util.Set;
 import java.util.UUID;

 /**
- * The root API interface in LuckPerms
+ * The root API interface for LuckPerms
 */
-@SuppressWarnings("unused")
 public interface LuckPermsApi {

    /**
@@ -42,62 +41,71 @@ public interface LuckPermsApi {
    void runUpdateTask();

    /**
+     * Gets the API version
     * @return the version of the API running on the platform
     * @since 2.6
     */
    double getApiVersion();

    /**
+     * Gets the plugin version
     * @return the version of the plugin running on the platform
     */
    String getVersion();

    /**
+     * Gets the platform LuckPerms is running on
     * @return the platform LuckPerms is running on
     * @since 2.7
     */
    PlatformType getPlatformType();

    /**
-     * Registers a listener to be sent LuckPerms events
-     * @param listener the listener instance
-     * @throws NullPointerException if the listener is null
+     * Gets the event bus, used for subscribing to events
+     * @return the event bus
+     * @since 3.0
     */
-    void registerListener(LPListener listener);
-
-    /**
-     * Unregisters a previously registered listener from the EventBus
-     * @param listener the listener instance to unregister
-     * @throws NullPointerException if the listener is null
-     */
-    void unregisterListener(LPListener listener);
+    EventBus getEventBus();

    /**
     * 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
     */
-    Datastore getDatastore();
+    Storage getStorage();
+
+    /**
+     * 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 +114,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 +123,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 +131,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 +142,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 +158,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 +167,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 +176,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 +185,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 +201,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 +210,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,40 +219,63 @@ 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
     */
    boolean isTrackLoaded(String name);

+    /**
+     * Gets the node factory instance for the platform
+     *
+     * @return the node factory
+     */
+    NodeFactory getNodeFactory();
+
    /**
     * 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.
     */
-    void registerContextCalculator(IContextCalculator<?> contextCalculator);
+    void registerContextCalculator(ContextCalculator<?> contextCalculator);

    /**
-     * 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.
+     * Gets a calculated context instance for the user using the rules of the platform.
+     *
+     * <p> 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.
     */
-    void registerContextListener(ContextListener<?> contextListener);
+    Optional<Contexts> getContextForUser(User user);
+
+    /**
+     * Gets set of contexts applicable to a player using the platforms {@link ContextCalculator}s.
+     *
+     * @param player the player to calculate for. Must be the player instance for the platform.
+     * @return a set of contexts.
+     * @since 2.17
+     */
+    ContextSet getContextForPlayer(Object player);

 }
@@ -0,0 +1,40 @@
+/*
+ * 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;
+
+/**
+ * A means to push changes to other servers using the platforms networking
+ *
+ * @since 2.14
+ */
+public interface MessagingService {
+
+    /**
+     * Uses the messaging service to inform other servers about changes.
+     *
+     * <p> This will push the update asynchronously, and this method will return immediately. Calling this method is
+     * equivalent to running "/lp networksync", except will not sync this server.
+     */
+    void pushUpdate();
+
+}
@@ -32,14 +32,28 @@ 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(){}
+    private static String escapeDelimiters(String s, String... delims) {
+        for (String delim : delims) {
+            s = s.replace(delim, "\\" + delim);
+        }
+        return s;
+    }
+
+    private static String unescapeDelimiters(String s, String... delims) {
+        for (String delim : delims) {
+            s = s.replace("\\" + delim, delim);
+        }
+        return s;
+    }

    /**
     * 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,16 +62,13 @@ public class MetaUtils {
        if (s == null) {
            throw new NullPointerException();
        }
-        
-        s = s.replace(".", "{SEP}");
-        s = s.replace("/", "{FSEP}");
-        s = s.replace("$", "{DSEP}");

-        return s;
+        return escapeDelimiters(s, ".", "/", "-", "$");
    }

    /**
     * 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,29 +77,31 @@ public class MetaUtils {
        if (s == null) {
            throw new NullPointerException();
        }
-        
+
        s = s.replace("{SEP}", ".");
        s = s.replace("{FSEP}", "/");
        s = s.replace("{DSEP}", "$");
+        s = unescapeDelimiters(s, ".", "/", "-", "$");

        return s;
    }

    /**
     * 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 +121,7 @@ public class MetaUtils {
        if (server == null || server.equals("")) {
            server = "global";
        }
-        
+
        node = escapeCharacters(node);
        value = escapeCharacters(value);

@@ -118,11 +131,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 +149,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 +233,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 +254,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 +277,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 +291,7 @@ public class MetaUtils {
            if (!n.shouldApplyOnWorld(world, includeGlobal, false)) {
                continue;
            }
-            
+
            if (prefix ? !n.isPrefix() : !n.isSuffix()) {
                continue;
            }
@@ -289,9 +308,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 +322,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 +333,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() {
+    }
+
 }
@@ -22,17 +22,21 @@

 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
+ * An immutable permission node
+ *
 * <p> Use {@link LuckPermsApi#buildNode(String)} to get an instance.
+ *
 * @since 2.6
 */
-@SuppressWarnings("unused")
 public interface Node extends Map.Entry<String, Boolean> {

    /**
@@ -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,47 @@ 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);

    /**
     * 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 +144,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 +153,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 +161,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 +204,13 @@ public interface Node extends Map.Entry<String, Boolean> {

    /**
     * @return the extra contexts required for this node to apply
+     * @since 2.13
     */
-    Map<String, String> getExtraContexts();
+    ContextSet getContexts();

    /**
     * Converts this node into a serialized form
+     *
     * @return a serialized node string
     */
    String toSerializedNode();
@@ -213,6 +233,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 +246,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 +259,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 +272,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 +280,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 +289,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 +297,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 +305,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 +317,7 @@ public interface Node extends Map.Entry<String, Boolean> {
     */
    interface Builder {
        Builder setNegated(boolean negated);
+
        Builder setValue(boolean value);

        /**
@@ -298,11 +327,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();
    }

@@ -0,0 +1,101 @@
+/*
+ * 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;
+
+/**
+ * Builds {@link Node} instances
+ *
+ * @since 2.17
+ */
+public interface NodeFactory {
+
+    /**
+     * Creates a node from a serialised node string
+     *
+     * @param serialisedPermission the serialised permission string
+     * @param value the value of the node
+     * @return a node instance
+     * @throws NullPointerException if the permission is null
+     */
+    Node fromSerialisedNode(String serialisedPermission, boolean value);
+
+
+    /**
+     * Creates a new node builder from a given base permission string
+     *
+     * @param permission the permission
+     * @return a node builder instance
+     * @throws NullPointerException if the permission is null
+     */
+    Node.Builder newBuilder(String permission);
+
+    /**
+     * Creates a node builder instance from an existing node
+     *
+     * @param other the other node
+     * @return a node builder instance
+     * @throws NullPointerException if the other node is null
+     */
+    Node.Builder newBuilderFromExisting(Node other);
+
+    /**
+     * Creates a node builder from a serialised node string
+     * @param serialisedPermission the serialised permission string
+     * @param value the value of the node
+     * @return a node builder instance
+     * @throws NullPointerException if the permission is null
+     */
+    Node.Builder newBuilderFromSerialisedNode(String serialisedPermission, boolean value);
+
+
+    /**
+     * Creates a node builder from a key value pair
+     *
+     * @param key the key
+     * @param value the value
+     * @return a node builder instance
+     * @throws NullPointerException if the key or value is null
+     */
+    Node.Builder makeMetaNode(String key, String value);
+
+    /**
+     * Creates a node builder from a prefix string and priority
+     *
+     * @param priority the priority
+     * @param prefix the prefix string
+     * @return a node builder instance
+     * @throws NullPointerException if the prefix is null
+     */
+    Node.Builder makePrefixNode(int priority, String prefix);
+
+    /**
+     * Creates a node builder from a prefix string and priority
+     *
+     * @param priority the priority
+     * @param suffix the suffix string
+     * @return a node builder instance
+     * @throws NullPointerException if the suffix is null
+     */
+    Node.Builder makeSuffixNode(int priority, String suffix);
+
+}
@@ -25,59 +25,59 @@ package me.lucko.luckperms.api;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
 import me.lucko.luckperms.exceptions.ObjectLacksException;

-import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.SortedSet;

 /**
- * Interface for internal PermissionHolder (user/group) instances
+ * An object capable of holding permissions
+ *
+ * <p> Any changes made will be lost unless the instance is saved back to the {@link Storage}.
 */
-@SuppressWarnings("unused")
 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()}
+     * Gets the objects name
+     *
+     * <p> {@link User#getUuid()}, {@link User#getName()} or {@link Group#getName()} should normally be used instead of
+     * this method.
+     *
+     * @return the identifier for this object. Either a uuid string or name.
     */
    String getObjectName();

    /**
-     * Gets an immutable Set of the objects permission nodes
+     * Gets a sorted set of all held permissions.
+     *
     * @return an immutable set of permissions in priority order
     * @since 2.6
     */
    SortedSet<? extends Node> getPermissions();

    /**
-     * Similar to {@link #getPermissions()}, except excluding transient permissions
+     * Similar to {@link #getPermissions()}, except without transient permissions
+     *
     * @return a set of nodes
     * @since 2.6
     */
-    Set<Node> getEnduringPermissions();
+    Set<? extends Node> getEnduringPermissions();

    /**
-     * Similar to {@link #getPermissions()}, except excluding non-transient permissions
+     * Gets an immutable set of all transiently held permissions.
+     *
+     * <p> Transient permissions only exist for the duration of the session.
+     *
     * @return a set of nodes
     * @since 2.6
     */
-    Set<Node> getTransientPermissions();
-
-
-    /**
-     * 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)}
-     */
-    @Deprecated
-    Set<Node> getAllNodes();
+    Set<? extends Node> getTransientPermissions();

    /**
     * Gets a mutable sorted set of the nodes that this object has and inherits, filtered by context
     * 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
@@ -86,9 +86,10 @@ public interface PermissionHolder {
    SortedSet<LocalizedNode> getAllNodes(Contexts contexts);

    /**
-     * Gets a mutable set of the nodes that is objects has and inherits, filtered by context.
+     * Gets a mutable set of the nodes that this object 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
@@ -97,15 +98,21 @@ public interface PermissionHolder {
    Set<LocalizedNode> getAllNodesFiltered(Contexts contexts);

    /**
-     * Gets an immutable Map of the objects permission nodes
-     * @return an immutable map of permissions
-     * @deprecated in favour of {@link #getPermissions()}
+     * Converts the output of {@link #getAllNodesFiltered(Contexts)}, and expands shorthand permissions.
+     * @param contexts the context for the lookup
+     * @param lowerCase if the keys should be made lowercase whilst being exported
+     * @return a mutable map of permissions
     */
-    @Deprecated
-    Map<String, Boolean> getNodes();
+    Map<String, Boolean> exportNodes(Contexts contexts, boolean lowerCase);
+
+    /**
+     * Removes temporary permissions that have expired
+     */
+    void auditTemporaryPermissions();

    /**
     * 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 +122,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 +132,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 +217,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 +311,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 +334,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 +348,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 +363,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 +377,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 +392,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 +408,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 +418,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 +428,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 +441,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 +453,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 +466,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 +480,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 +494,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)}
     */
@@ -471,97 +508,106 @@ public interface PermissionHolder {
    void unsetPermission(String node, String server, String world, boolean temporary) throws ObjectLacksException;

    /**
-     * 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 excludedGroups Groups that shouldn't be inherited (to prevent circular inheritance issues)
-     * @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)}
+     * Clears all nodes held by the object
+     *
+     * @since 2.17
     */
-    @Deprecated
-    Map<String, Boolean> getLocalPermissions(String server, String world, List<String> excludedGroups, List<String> possibleNodes);
+    void clearNodes();

    /**
-     * 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 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)}
+     * Clears all nodes held by the object on a specific server
+     *
+     * @param server the server to filter by, can be null
+     * @since 2.17
     */
-    @Deprecated
-    Map<String, Boolean> getLocalPermissions(String server, String world, List<String> excludedGroups);
+    void clearNodes(String server);

    /**
-     * Gets the permissions and inherited permissions that apply to a specific server
-     * @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
-     * @return a {@link Map} of the permissions
-     * @deprecated in favour of {@link #getPermissions(String, String, Map, boolean, List, boolean)}
+     * Clears all nodes held by the object on a specific server and world
+     *
+     * @param server the server to filter by, can be null
+     * @param world the world to filter by, can be null
+     * @since 2.17
     */
-    @Deprecated
-    Map<String, Boolean> getLocalPermissions(String server, List<String> excludedGroups, List<String> possibleNodes);
+    void clearNodes(String server, String world);

    /**
-     * Gets the permissions and inherited permissions that apply to a specific server
-     * @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)}
+     * Clears all parent groups
+     *
+     * @since 2.17
     */
-    @Deprecated
-    Map<String, Boolean> getLocalPermissions(String server, List<String> excludedGroups);
+    void clearParents();

    /**
-     * 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 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
-     * @return a map of permissions
-     * @since 2.6
-     * @deprecated in favour of {@link #getAllNodesFiltered(Contexts)}
+     * Clears all parents on a specific server
+     *
+     * @param server the server to filter by, can be null
+     * @since 2.17
     */
-    @Deprecated
-    Map<String, Boolean> getPermissions(String server, String world, Map<String, String> extraContext, boolean includeGlobal, List<String> possibleNodes, boolean applyGroups);
+    void clearParents(String server);

    /**
-     * Processes the nodes and returns the temporary ones.
-     * @return a map of temporary nodes
-     * @deprecated in favour of {@link #getTemporaryPermissionNodes()}
+     * Clears all parents on a specific server and world
+     *
+     * @param server the server to filter by, can be null
+     * @param world the world to filter by, can be null
+     * @since 2.17
     */
-    @Deprecated
-    Map<Map.Entry<String, Boolean>, Long> getTemporaryNodes();
+    void clearParents(String server, String world);

    /**
-     * Processes the nodes and returns the temporary ones.
-     * @return a set of temporary nodes
-     * @since 2.6
+     * Clears all meta held by the object
+     *
+     * @since 2.17
     */
-    Set<Node> getTemporaryPermissionNodes();
-
-    /**
-     * Processes the nodes and returns the non-temporary ones.
-     * @return a map of permanent nodes
-     * @deprecated in favour of {@link #getPermanentPermissionNodes()}
-     */
-    @Deprecated
-    Map<String, Boolean> getPermanentNodes();
+    void clearMeta();
+
+    /**
+     * Clears all meta held by the object on a specific server
+     *
+     * @param server the server to filter by, can be null
+     * @since 2.17
+     */
+    void clearMeta(String server);
+
+    /**
+     * Clears all meta held by the object on a specific server and world
+     *
+     * @param server the server to filter by, can be null
+     * @param world the world to filter by, can be null
+     * @since 2.17
+     */
+    void clearMeta(String server, String world);
+
+    /**
+     * Clears all meta for a given key.
+     *
+     * @param key the meta key
+     * @param server the server to filter by, can be null
+     * @param world the world to filter by, can be null
+     * @param temporary whether the query is for temporary nodes or not.
+     */
+    void clearMetaKeys(String key, String server, String world, boolean temporary);
+
+    /**
+     * Clears all transient permissions the holder has.
+     */
+    void clearTransientNodes();

    /**
     * Processes the nodes and returns the non-temporary ones.
+     *
     * @return a set of permanent nodes
     * @since 2.6
     */
    Set<Node> getPermanentPermissionNodes();

    /**
-     * Removes temporary permissions that have expired
+     * Processes the nodes and returns the temporary ones.
+     *
+     * @return a set of temporary nodes
+     * @since 2.6
     */
-    void auditTemporaryPermissions();
+    Set<Node> getTemporaryPermissionNodes();

 }
@@ -23,19 +23,15 @@
 package me.lucko.luckperms.api;

 /**
- * Represents the platform type that LuckPerms is running on
+ * The platforms which LuckPerms can run on
+ *
 * @since 2.7
 */
 public enum PlatformType {

    BUKKIT("Bukkit"),
    BUNGEE("Bungee"),
-    SPONGE("Sponge"),
-
-    /**
-     * @since 2.9
-     */
-    STANDALONE("Standalone");
+    SPONGE("Sponge");

    private final String friendlyName;

@@ -0,0 +1,273 @@
+/*
+ * 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.List;
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Executor;
+import java.util.function.Consumer;
+
+/**
+ * A means of loading and saving data to/from the Storage provider.
+ *
+ * <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();
+
+    /**
+     * Searches for a list of users with a given permission.
+     *
+     * @param permission the permission to search for
+     * @return a list of held permissions, or null if the operation failed
+     * @throws NullPointerException if the permission is null
+     * @since 2.17
+     */
+    CompletableFuture<List<HeldPermission<UUID>>> getUsersWithPermission(String permission);
+
+    /**
+     * 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);
+
+    /**
+     * Searches for a list of groups with a given permission.
+     *
+     * @param permission the permission to search for
+     * @return a list of held permissions, or null if the operation failed
+     * @throws NullPointerException if the permission is null
+     * @since 2.17
+     */
+    CompletableFuture<List<HeldPermission<String>>> getGroupsWithPermission(String permission);
+
+    /**
+     * 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);
+
+    /**
+     * Gets a username from a UUID
+     *
+     * @param uuid the corresponding uuid
+     * @return a name string, could be null
+     * @throws NullPointerException if either parameters are null
+     * @since 2.17
+     */
+    CompletableFuture<String> getName(UUID uuid);
+
+}
@@ -28,80 +28,89 @@ import me.lucko.luckperms.exceptions.ObjectLacksException;
 import java.util.List;

 /**
- * Interface for internal Track instances
+ * An ordered collection of groups for easy promotions and demotions
 */
-@SuppressWarnings("unused")
 public interface Track {

    /**
+     * Gets the name of this track
     * @return the name of this track
     */
    String getName();

    /**
     * Gets an ordered list of the groups on this track
-     * Index 0 is the first/lowest group in (or start of) the track
+     *
+     * <p> 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 +119,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
@@ -126,7 +137,7 @@ public interface Track {
    boolean containsGroup(String group);

    /**
-     * Clear all of the groups within this track
+     * Clear all of the groups from this track
     */
    void clearGroups();

@@ -23,25 +23,51 @@
 package me.lucko.luckperms.api;

 /**
- * Represents a permission value
+ * Represents a permission setting.
+ *
+ * <p> Consider a value of {@link #FALSE} to be a "negated" setting, and a value of {@link #UNDEFINED} to be a
+ * non-existent value.
 */
 public enum Tristate {

+    /**
+     * A value indicating a holder has a permission set.
+     */
    TRUE(true),
+
+    /**
+     * A value indicating a holder has a negated value for a permission.
+     */
    FALSE(false),
+
+    /**
+     * A value indicating a holder doesn't have a value for a permission set.
+     */
    UNDEFINED(false);

+    /**
+     * Converts from {@link Boolean} a boolean
+     *
+     * @param b the boolean
+     * @return {@link #TRUE} or {@link #FALSE}, depending on the value of the boolean.
+     */
+    public static Tristate fromBoolean(boolean b) {
+        return b ? TRUE : FALSE;
+    }
+
    private final boolean booleanValue;

    Tristate(boolean booleanValue) {
        this.booleanValue = booleanValue;
    }

+    /**
+     * Returns the value of the Tristate as a boolean.
+     * <p> A value of {@link #UNDEFINED} converts to false.
+     *
+     * @return a boolean representation of the Tristate.
+     */
    public boolean asBoolean() {
        return booleanValue;
    }
-
-    public static Tristate fromBoolean(boolean b) {
-        return b ? TRUE : FALSE;
-    }
 }
@@ -22,50 +22,76 @@

 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;

 /**
- * Interface for internal User instances
+ * A player holding permission data
 */
-@SuppressWarnings("unused")
 public interface User extends PermissionHolder {

    /**
+     * Gets the users unique ID
+     *
     * @return the users Mojang assigned unique id
     */
    UUID getUuid();

    /**
+     * Gets the users username
+     *
     * @return the Users Username
     */
    String getName();

    /**
     * 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;

    /**
-     * Refresh and re-assign the users permissions
+     * Refresh and re-assign the users permissions.
+     *
+     * <p> This request is not buffered, and the refresh call will be ran directly. This should ideally be called on
+     * an asynchronous thread.
     */
    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();
+
+    /**
+     * Sets up the users data cache, if the don't have one setup already.
+     *
+     * @since 2.17
+     */
+    void setupDataCache();
+
    /**
     * 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,186 +100,198 @@ 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;

-    /**
-     * Clear all of the users permission nodes
-     */
-    void clearNodes();
-
    /**
     * 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);
@@ -27,21 +27,21 @@ 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 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.
+ * <p> THIS IS ONLY EFFECTIVE FOR ONLINE PLAYERS. USE THE DATASTORE METHODS FOR OFFLINE PLAYERS.
 */
-@SuppressWarnings("unused")
 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 +49,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
     */
@@ -20,39 +20,53 @@
 *  SOFTWARE.
 */

-package me.lucko.luckperms.api.context;
+package me.lucko.luckperms.api.caching;

 import java.util.Map;
+import java.util.SortedMap;

 /**
- * Calculates whether contexts are applicable to {@link T}
+ * Holds cached Meta lookup data for a specific set of contexts
 *
- * <p>Somewhat inspired by the system used on Sponge.
- * @param <T> the subject type. Is ALWAYS the player class of the platform.
+ * @since 2.13
 */
-public interface IContextCalculator<T> {
+public interface MetaData {

    /**
-     * Gives the subject all of the applicable contexts they meet
-     * @param subject the subject to add contexts tp
-     * @param accumulator a map of contexts to add to
-     * @return the map
+     * Gets an immutable copy of the meta this user has
+     *
+     * @return an immutable map of meta
     */
-    Map<String, String> giveApplicableContext(T subject, Map<String, String> accumulator);
+    Map<String, String> getMeta();

    /**
-     * 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.
+     * 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
     */
-    boolean isContextApplicable(T subject, Map.Entry<String, String> context);
+    SortedMap<Integer, String> getPrefixes();

    /**
-     * 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
+     * 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
     */
-    void addListener(ContextListener<T> listener);
+    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();

 }
@@ -0,0 +1,59 @@
+/*
+ * 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.
+     *
+     * <p> 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();
+
+}
@@ -0,0 +1,135 @@
+/*
+ * 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.
+     *
+     * <p> 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.
+     *
+     * <p> 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.
+     *
+     * <p> 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.
+     *
+     * <p> 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.
+     *
+     * <p> 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();
+
+}
@@ -22,53 +22,34 @@

 package me.lucko.luckperms.api.context;

-import java.util.List;
 import java.util.Map;
-import java.util.concurrent.CopyOnWriteArrayList;

 /**
- * A simple implementation of the listener aspects of {@link IContextCalculator}
- * @param <T> the subject type
+ * 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 abstract class ContextCalculator<T> implements IContextCalculator<T> {
-    private final List<ContextListener<T>> listeners = new CopyOnWriteArrayList<>();
+public interface ContextCalculator<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 current the context state after the change (now)
-     * @throws NullPointerException if any parameters are null
+     * Gives the subject all of the applicable contexts they meet
+     *
+     * @param subject     the subject to add contexts to
+     * @param accumulator a map of contexts to add to
+     * @return the map
+     * @since 2.13
     */
-    protected void pushUpdate(T subject, Map.Entry<String, String> before, Map.Entry<String, String> current) {
-        if (subject == null) {
-            throw new NullPointerException("subject");
-        }
-        if (before == null) {
-            throw new NullPointerException("before");
-        }
-        if (current == null) {
-            throw new NullPointerException("current");
-        }
+    MutableContextSet giveApplicableContext(T subject, MutableContextSet accumulator);

-        for (ContextListener<T> listener : listeners) {
-            try {
-                listener.onContextChange(subject, before, current);
-            } catch (Exception e) {
-                System.out.println("Exception whilst passing context change to listener: " + listener);
-                e.printStackTrace();
-            }
-        }
-    }
-
-    @Override
-    public void addListener(ContextListener<T> listener) {
-        if (listener == null) {
-            throw new NullPointerException("listener");
-        }
-
-        listeners.add(listener);
-    }
+    /**
+     * 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.
+     */
+    boolean isContextApplicable(T subject, Map.Entry<String, String> context);

 }
@@ -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<? extends 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();
+
+}
@@ -0,0 +1,257 @@
+/*
+ * 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;
+
+/**
+ * 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");
+        }
+
+        ImmutableMultimap.Builder<String, String> b = ImmutableMultimap.builder();
+        for (Map.Entry<String, String> e : map.entrySet()) {
+            b.put(e.getKey(), e.getValue());
+        }
+
+        return new ImmutableContextSet(b.build());
+    }
+
+    /**
+     * 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<? extends 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() {
+        ImmutableMap.Builder<String, String> m = ImmutableMap.builder();
+        for (Map.Entry<String, String> e : map.entries()) {
+            m.put(e.getKey(), e.getValue());
+        }
+
+        return m.build();
+    }
+
+    @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 + ")";
+    }
+}
@@ -0,0 +1,399 @@
+/*
+ * 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<? extends 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() {
+        ImmutableMap.Builder<String, String> m = ImmutableMap.builder();
+        for (Map.Entry<String, String> e : map.entries()) {
+            m.put(e.getKey(), e.getValue());
+        }
+
+        return m.build();
+    }
+
+    @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<? extends 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 + ")";
+    }
+}
@@ -26,12 +26,14 @@ package me.lucko.luckperms.api.data;
 * Represents the data section of the main LuckPerms configuration.
 * All methods could return null.
 */
-@SuppressWarnings("deprecation")
-public interface DatastoreConfiguration extends MySQLConfiguration {
+public interface DatastoreConfiguration {

    String getAddress();
+
    String getDatabase();
+
    String getUsername();
+
    String getPassword();

 }
@@ -22,21 +22,18 @@

 package me.lucko.luckperms.api.event;

-import me.lucko.luckperms.api.User;
+import java.util.concurrent.atomic.AtomicBoolean;

 /**
- * Represents an event acting upon a user.
+ * Represents an event that can be cancelled
 */
-public class UserEvent extends LPEvent {
+public interface Cancellable {

-    private final User user;
+    /**
+     * Gets an {@link AtomicBoolean} holding the cancellation state of the event
+     *
+     * @return the cancellation
+     */
+    AtomicBoolean getCancellationState();

-    protected UserEvent(String eventName, User user) {
-        super(eventName);
-        this.user = user;
-    }
-
-    public User getUser() {
-        return user;
-    }
 }
@@ -20,33 +20,35 @@
 *  SOFTWARE.
 */

-package me.lucko.luckperms.common.tracks;
-
-import me.lucko.luckperms.common.utils.AbstractManager;
+package me.lucko.luckperms.api.event;

 import java.util.Set;
-import java.util.stream.Collectors;
+import java.util.function.Consumer;

-public class TrackManager extends AbstractManager<String, Track> {
+/**
+ * The LuckPerms event bus. Used for subscribing (or registering listeners) to events.
+ *
+ * @since 3.0
+ */
+public interface EventBus {

    /**
-     * Returns a set of tracks that contain at least one of the groups from the Set provided
-     * @param group the group to filter by
-     * @return a set of tracks that the groups could be a member of
+     * Subscribe to an event
+     *
+     * @param eventClass the event class
+     * @param handler    the event handler
+     * @param <T>        the event class
+     * @return an event handler instance representing this subscription
     */
-    public Set<Track> getApplicableTracks(String group) {
-        return getAll().values().stream()
-                .filter(t -> t.containsGroup(group))
-                .collect(Collectors.toSet());
-    }
+    <T extends LuckPermsEvent> EventHandler<T> subscribe(Class<T> eventClass, Consumer<T> handler);

    /**
-     * Makes a new track object
-     * @param name The name of the track
-     * @return a new {@link Track} object
+     * Gets a set of all registered handlers for a given event
+     *
+     * @param eventClass the event to find handlers for
+     * @param <T>        the event class
+     * @return an immutable set of event handlers
     */
-    @Override
-    public Track apply(String name) {
-        return new Track(name);
-    }
+    <T extends LuckPermsEvent> Set<EventHandler<T>> getHandlers(Class<T> eventClass);
+
 }
@@ -22,41 +22,48 @@

 package me.lucko.luckperms.api.event;

-import me.lucko.luckperms.api.PermissionHolder;
+import java.util.function.Consumer;

-import java.util.Optional;
-
-public class AbstractPermissionRemoveEvent extends TargetedEvent<PermissionHolder> {
-
-    private final String server;
-    private final String world;
-    private final boolean temporary;
-
-    protected AbstractPermissionRemoveEvent(String eventName, PermissionHolder target, String server, String world, boolean temporary) {
-        super(eventName, target);
-        this.server = server;
-        this.world = world;
-        this.temporary = temporary;
-    }
-
-    public Optional<String> getServer() {
-        return Optional.ofNullable(server);
-    }
-
-    public Optional<String> getWorld() {
-        return Optional.ofNullable(world);
-    }
+/**
+ * Represents a handler for a LuckPerms event
+ *
+ * @param <T> the event class
+ */
+public interface EventHandler<T extends LuckPermsEvent> {

    /**
-     * @deprecated use {@link #isTemporary()}
+     * Gets the class this handler is listening to
+     *
+     * @return the event class
     */
-    @Deprecated
-    public boolean getTemporary() {
-        return temporary;
-    }
+    Class<T> getEventClass();

-    public boolean isTemporary() {
-        return temporary;
-    }
+    /**
+     * Returns true if this handler is active
+     *
+     * @return true if this handler is still active
+     */
+    boolean isActive();
+
+    /**
+     * Unregisters this handler from the event bus
+     *
+     * @return true if the handler wasn't already unregistered
+     */
+    boolean unregister();
+
+    /**
+     * Gets the event consumer responsible for handling the event
+     *
+     * @return the event consumer
+     */
+    Consumer<T> getConsumer();
+
+    /**
+     * Gets the number of times this handler has been called
+     *
+     * @return the number of times this handler has been called
+     */
+    int getCallCount();

 }
@@ -0,0 +1,41 @@
+/*
+ * 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.event;
+
+import me.lucko.luckperms.api.LuckPermsApi;
+
+/**
+ * The base event interface
+ *
+ * @since 3.0
+ */
+public interface LuckPermsEvent {
+
+    /**
+     * Get the API instance this event was dispatched from
+     *
+     * @return the api instance
+     */
+    LuckPermsApi getApi();
+
+}
@@ -0,0 +1,45 @@
+/*
+ * 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.event.cause;
+
+/**
+ * The cause of a group/track creation
+ */
+public enum CreationCause {
+
+    /**
+     * The creation was caused by a command
+     */
+    COMMAND,
+
+    /**
+     * The creation was caused by an API call
+     */
+    API,
+
+    /**
+     * The creation was caused by a LuckPerms internal
+     */
+    INTERNAL;
+
+}
@@ -0,0 +1,45 @@
+/*
+ * 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.event.cause;
+
+/**
+ * The cause of a group/track deletion
+ */
+public enum DeletionCause {
+
+    /**
+     * The deletion was caused by a command
+     */
+    COMMAND,
+
+    /**
+     * The deletion was caused by an API call
+     */
+    API,
+
+    /**
+     * The deletion was caused by a LuckPerms internal
+     */
+    INTERNAL;
+
+}
@@ -1,47 +0,0 @@
-/*
- * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
- *
- *  Permission is hereby granted, free of charge, to any person obtaining a copy
- *  of this software and associated documentation files (the "Software"), to deal
- *  in the Software without restriction, including without limitation the rights
- *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- *  copies of the Software, and to permit persons to whom the Software is
- *  furnished to do so, subject to the following conditions:
- *
- *  The above copyright notice and this permission notice shall be included in all
- *  copies or substantial portions of the Software.
- *
- *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- *  SOFTWARE.
- */
-
-package me.lucko.luckperms.api.event.events;
-
-import me.lucko.luckperms.api.PermissionHolder;
-import me.lucko.luckperms.api.event.AbstractPermissionRemoveEvent;
-
-/**
- * Called whenever a user or group is removed from / stops inheriting another group
- */
-public class GroupRemoveEvent extends AbstractPermissionRemoveEvent {
-
-    /**
-     * The name of group being removed from the target.
-     * Be aware that this group may have already been deleted, and and instance may therefore not exist internally.
-     */
-    private final String group;
-
-    public GroupRemoveEvent(PermissionHolder target, String group, String server, String world, boolean temporary) {
-        super("Group Remove Event", target, server, world, temporary);
-        this.group = group;
-    }
-
-    public String getGroup() {
-        return group;
-    }
-}
@@ -1,45 +0,0 @@
-/*
- * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
- *
- *  Permission is hereby granted, free of charge, to any person obtaining a copy
- *  of this software and associated documentation files (the "Software"), to deal
- *  in the Software without restriction, including without limitation the rights
- *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- *  copies of the Software, and to permit persons to whom the Software is
- *  furnished to do so, subject to the following conditions:
- *
- *  The above copyright notice and this permission notice shall be included in all
- *  copies or substantial portions of the Software.
- *
- *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- *  SOFTWARE.
- */
-
-package me.lucko.luckperms.api.event.events;
-
-import me.lucko.luckperms.api.PermissionHolder;
-import me.lucko.luckperms.api.event.AbstractPermissionRemoveEvent;
-
-/**
- * Called whenever a user or group has a permission unset.
- * @deprecated in favour of {@link PermissionNodeUnsetEvent}
- */
-@Deprecated
-public class PermissionUnsetEvent extends AbstractPermissionRemoveEvent {
-
-    private final String node;
-
-    public PermissionUnsetEvent(PermissionHolder target, String node, String server, String world, boolean temporary) {
-        super("Permission Unset Event", target, server, world, temporary);
-        this.node = node;
-    }
-
-    public String getNode() {
-        return node;
-    }
-}
@@ -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.api.event.group;
+
+import me.lucko.luckperms.api.Group;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+import me.lucko.luckperms.api.event.cause.CreationCause;
+
+/**
+ * Called when a group is created
+ */
+public interface GroupCreateEvent extends LuckPermsEvent {
+
+    /**
+     * Gets the new group
+     *
+     * @return the new group
+     */
+    Group getGroup();
+
+    /**
+     * Gets the cause of the creation
+     *
+     * @return the cause of the creation
+     */
+    CreationCause getCause();
+
+}
@@ -20,18 +20,38 @@
 *  SOFTWARE.
 */

-package me.lucko.luckperms.api.event.events;
+package me.lucko.luckperms.api.event.group;

 import me.lucko.luckperms.api.Node;
-import me.lucko.luckperms.api.PermissionHolder;
-import me.lucko.luckperms.api.event.AbstractPermissionEvent;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+import me.lucko.luckperms.api.event.cause.DeletionCause;
+
+import java.util.Set;

 /**
- * Called when a permission node is unset from a holder
- * @since 2.6
+ * Called when a group is deleted
 */
-public class PermissionNodeUnsetEvent extends AbstractPermissionEvent {
-    public PermissionNodeUnsetEvent(PermissionHolder target, Node node) {
-        super("Permission Node Unset Event", target, node);
-    }
+public interface GroupDeleteEvent extends LuckPermsEvent {
+
+    /**
+     * Gets the name of the deleted group
+     *
+     * @return the name of the deleted group
+     */
+    String getGroupName();
+
+    /**
+     * Gets an immutable copy of the groups existing data
+     *
+     * @return a copy of the groups existing data
+     */
+    Set<Node> getExistingData();
+
+    /**
+     * Gets the cause of the deletion
+     *
+     * @return the cause of the deletion
+     */
+    DeletionCause getCause();
+
 }
@@ -20,16 +20,15 @@
 *  SOFTWARE.
 */

-package me.lucko.luckperms.api.data;
+package me.lucko.luckperms.api.event.group;
+
+import me.lucko.luckperms.api.event.LuckPermsEvent;

 /**
- * @deprecated Use {@link DatastoreConfiguration}. This is now used by multiple datastores, not just MySQL.
+ * Called when all groups have been loaded in from storage.
+ *
+ * <p>Usually only called on startup and in sync tasks.</p>
 */
-@Deprecated
-public interface MySQLConfiguration {
+public interface GroupLoadAllEvent extends LuckPermsEvent {

-    String getAddress();
-    String getDatabase();
-    String getUsername();
-    String getPassword();
 }
@@ -0,0 +1,42 @@
+/*
+ * 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.event.group;
+
+import me.lucko.luckperms.api.Group;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+/**
+ * Called when a group is loaded into memory from the storage.
+ *
+ * Note that this event is not the same as {@link GroupCreateEvent}
+ */
+public interface GroupLoadEvent extends LuckPermsEvent {
+
+    /**
+     * Gets the group that was loaded
+     *
+     * @return the group that was loaded
+     */
+    Group getGroup();
+
+}
@@ -0,0 +1,41 @@
+/*
+ * 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.event.log;
+
+import me.lucko.luckperms.api.LogEntry;
+import me.lucko.luckperms.api.event.Cancellable;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+/**
+ * Called when a log entry is about to be sent to notifiable players on the platform
+ */
+public interface LogBroadcastEvent extends LuckPermsEvent, Cancellable {
+
+    /**
+     * Gets the log entry to be broadcasted
+     *
+     * @return the log entry to be broadcasted
+     */
+    LogEntry getEntry();
+
+}
@@ -20,24 +20,22 @@
 *  SOFTWARE.
 */

-package me.lucko.luckperms.api.event;
+package me.lucko.luckperms.api.event.log;

-import me.lucko.luckperms.api.Node;
-import me.lucko.luckperms.api.PermissionHolder;
+import me.lucko.luckperms.api.LogEntry;
+import me.lucko.luckperms.api.event.Cancellable;
+import me.lucko.luckperms.api.event.LuckPermsEvent;

 /**
- * @since 2.6
+ * Called when a log is about to be published to the storage file/table
 */
-public class AbstractPermissionEvent extends TargetedEvent<PermissionHolder> {
+public interface LogPublishEvent extends LuckPermsEvent, Cancellable {

-    private final Node node;
+    /**
+     * Gets the log entry to be published
+     *
+     * @return the log entry to be published
+     */
+    LogEntry getEntry();

-    protected AbstractPermissionEvent(String eventName, PermissionHolder target, Node node) {
-        super(eventName, target);
-        this.node = node;
-    }
-
-    public Node getNode() {
-        return node;
-    }
 }
@@ -0,0 +1,39 @@
+/*
+ * 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.event.node;
+
+import me.lucko.luckperms.api.Node;
+
+/**
+ * Called when a node is added to a holder
+ */
+public interface NodeAddEvent extends NodeMutateEvent {
+
+    /**
+     * Gets the node that was added
+     *
+     * @return the node that was added
+     */
+    Node getNode();
+
+}
@@ -0,0 +1,30 @@
+/*
+ * 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.event.node;
+
+/**
+ * Called when a holder has their nodes cleared
+ */
+public interface NodeClearEvent extends NodeMutateEvent {
+
+}
@@ -0,0 +1,75 @@
+/*
+ * 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.event.node;
+
+import me.lucko.luckperms.api.Node;
+import me.lucko.luckperms.api.PermissionHolder;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+import java.util.Set;
+
+/**
+ * Called when a node is added to/removed from a user/group
+ */
+public interface NodeMutateEvent extends LuckPermsEvent {
+
+    /**
+     * Gets the target of the event
+     *
+     * @return the event target
+     */
+    PermissionHolder getTarget();
+
+    /**
+     * Gets an immutable copy of the holders data before the change
+     *
+     * @return the data before the change
+     */
+    Set<Node> getDataBefore();
+
+    /**
+     * Gets an immutable copy of the holders data after the change
+     *
+     * @return the data after the change
+     */
+    Set<Node> getDataAfter();
+
+    /**
+     * Gets whether the target of this event is a {@link me.lucko.luckperms.api.User}
+     *
+     * <p>This is equivalent to checking if getTarget() instanceof User</p>
+     *
+     * @return if the event is targeting a user
+     */
+    boolean isUser();
+
+    /**
+     * Gets whether the target of this event is a {@link me.lucko.luckperms.api.Group}
+     *
+     * <p>This is equivalent to checking if getTarget() instanceof Group</p>
+     *
+     * @return if the event is targeting a group
+     */
+    boolean isGroup();
+
+}
@@ -0,0 +1,39 @@
+/*
+ * 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.event.node;
+
+import me.lucko.luckperms.api.Node;
+
+/**
+ * Called when a node is removed from a holder
+ */
+public interface NodeRemoveEvent extends NodeMutateEvent {
+
+    /**
+     * Gets the node that was removed
+     *
+     * @return the node that was removed
+     */
+    Node getNode();
+
+}
@@ -0,0 +1,32 @@
+/*
+ * 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.event.sync;
+
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+/**
+ * Called when the configuration is reloaded
+ */
+public interface ConfigReloadEvent extends LuckPermsEvent {
+
+}
@@ -20,17 +20,13 @@
 *  SOFTWARE.
 */

-package me.lucko.luckperms.api.event.events;
+package me.lucko.luckperms.api.event.sync;

-import me.lucko.luckperms.api.event.LPEvent;
+import me.lucko.luckperms.api.event.LuckPermsEvent;

 /**
- * Called after the sync task has ran.
+ * Called when an sync task has been completed
 */
-public class PostSyncEvent extends LPEvent {
-
-    public PostSyncEvent() {
-        super("Post Sync Event");
-    }
+public interface PostSyncEvent extends LuckPermsEvent {

 }
@@ -0,0 +1,42 @@
+/*
+ * 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.event.sync;
+
+import me.lucko.luckperms.api.event.Cancellable;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+import java.util.UUID;
+
+/**
+ * Called before a network sync task runs
+ */
+public interface PreNetworkSyncEvent extends LuckPermsEvent, Cancellable {
+
+    /**
+     * Gets the ID of the sync request
+     *
+     * @return the id of the sync request
+     */
+    UUID getSyncId();
+
+}
@@ -20,18 +20,14 @@
 *  SOFTWARE.
 */

-package me.lucko.luckperms.api.event.events;
+package me.lucko.luckperms.api.event.sync;

-import me.lucko.luckperms.api.event.CancellableEvent;
+import me.lucko.luckperms.api.event.Cancellable;
+import me.lucko.luckperms.api.event.LuckPermsEvent;

 /**
- * Called before the sync task is about to run.
- * Set this event to cancelled to prevent the sync task from running.
+ * Called before a sync task runs
 */
-public class PreSyncEvent extends CancellableEvent {
-
-    public PreSyncEvent() {
-        super("Pre Sync Event");
-    }
+public interface PreSyncEvent extends LuckPermsEvent, Cancellable {

 }
@@ -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.api.event.track;
+
+import me.lucko.luckperms.api.Track;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+import me.lucko.luckperms.api.event.cause.CreationCause;
+
+/**
+ * Called when a track is created
+ */
+public interface TrackCreateEvent extends LuckPermsEvent {
+
+    /**
+     * Gets the new track
+     *
+     * @return the new track
+     */
+    Track getTrack();
+
+    /**
+     * Gets the cause of the creation
+     *
+     * @return the cause of the creation
+     */
+    CreationCause getCause();
+
+}
@@ -20,28 +20,37 @@
 *  SOFTWARE.
 */

-package me.lucko.luckperms.api.event.events;
+package me.lucko.luckperms.api.event.track;

-import me.lucko.luckperms.api.Group;
-import me.lucko.luckperms.api.PermissionHolder;
-import me.lucko.luckperms.api.event.AbstractPermissionAddEvent;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+import me.lucko.luckperms.api.event.cause.DeletionCause;
+
+import java.util.List;

 /**
- * Called whenever a user or group is added to / starts to inherit another group
+ * Called when a track is deleted
 */
-public class GroupAddEvent extends AbstractPermissionAddEvent {
+public interface TrackDeleteEvent extends LuckPermsEvent {

    /**
-     * The group being added to the target
+     * Gets the name of the deleted track
+     *
+     * @return the name of the deleted track
     */
-    private final Group group;
+    String getTrackName();

-    public GroupAddEvent(PermissionHolder target, Group group, String server, String world, long expiry) {
-        super("Group Add Event", target, server, world, expiry);
-        this.group = group;
-    }
+    /**
+     * Gets an immutable copy of the tracks existing data
+     *
+     * @return a copy of the tracks existing data
+     */
+    List<String> getExistingData();
+
+    /**
+     * Gets the cause of the deletion
+     *
+     * @return the cause of the deletion
+     */
+    DeletionCause getCause();

-    public Group getGroup() {
-        return group;
-    }
 }
@@ -0,0 +1,34 @@
+/*
+ * 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.event.track;
+
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+/**
+ * Called when all tracks have been loaded in from storage.
+ *
+ * <p>Usually only called on startup and in sync tasks.</p>
+ */
+public interface TrackLoadAllEvent extends LuckPermsEvent {
+
+}
@@ -0,0 +1,42 @@
+/*
+ * 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.event.track;
+
+import me.lucko.luckperms.api.Track;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+/**
+ * Called when a track is loaded into memory from the storage.
+ *
+ * Note that this event is not the same as {@link TrackCreateEvent}
+ */
+public interface TrackLoadEvent extends LuckPermsEvent {
+
+    /**
+     * Gets the track that was loaded
+     *
+     * @return the track that was loaded
+     */
+    Track getTrack();
+
+}
@@ -0,0 +1,37 @@
+/*
+ * 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.event.track.mutate;
+
+/**
+ * Called when a group is added to a track
+ */
+public interface TrackAddGroupEvent extends TrackMutateEvent {
+
+    /**
+     * Gets the group that was added
+     *
+     * @return the group that was added
+     */
+    String getGroup();
+
+}
@@ -0,0 +1,30 @@
+/*
+ * 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.event.track.mutate;
+
+/**
+ * Called when a track is cleared
+ */
+public interface TrackClearEvent extends TrackMutateEvent {
+
+}
@@ -20,30 +20,37 @@
 *  SOFTWARE.
 */

-package me.lucko.luckperms.api.event.events;
+package me.lucko.luckperms.api.event.track.mutate;

-import me.lucko.luckperms.api.LogEntry;
-import me.lucko.luckperms.api.event.CancellableEvent;
+import me.lucko.luckperms.api.Track;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+import java.util.List;

 /**
- * Called before a LogEntry is broadcasted to players only with the notify permission.
- * The log entry will still be recorded in the datastore, regardless of the cancellation state of this event.
- * Cancelling this event only stops the broadcast.
+ * Called when a track is changed
 */
-public class LogNotifyEvent extends CancellableEvent {
+public interface TrackMutateEvent extends LuckPermsEvent {

    /**
-     * The log entry to be broadcasted
+     * Gets the track that was mutated
+     *
+     * @return the track that was mutated
     */
-    private final LogEntry entry;
+    Track getTrack();

-    public LogNotifyEvent(LogEntry entry) {
-        super("Log Notify Event");
-        this.entry = entry;
-    }
+    /**
+     * Gets an immutable copy of the tracks data before the change
+     *
+     * @return the data before the change
+     */
+    List<String> getDataBefore();

-    public LogEntry getEntry() {
-        return entry;
-    }
+    /**
+     * Gets an immutable copy of the tracks data after the change
+     *
+     * @return the data after the change
+     */
+    List<String> getDataAfter();

 }
@@ -0,0 +1,37 @@
+/*
+ * 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.event.track.mutate;
+
+/**
+ * Called when a group is removed from a track
+ */
+public interface TrackRemoveGroupEvent extends TrackMutateEvent {
+
+    /**
+     * Gets the group that was removed
+     *
+     * @return the group that was removed
+     */
+    String getGroup();
+
+}
@@ -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.api.event.user;
+
+import me.lucko.luckperms.api.User;
+import me.lucko.luckperms.api.caching.UserData;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+/**
+ * Called when a users {@link me.lucko.luckperms.api.caching.UserData} is loaded.
+ */
+public interface UserCacheLoadEvent extends LuckPermsEvent {
+
+    /**
+     * Gets the user whose data was loaded
+     *
+     * @return the user
+     */
+    User getUser();
+
+    /**
+     * Gets the data that was loaded
+     *
+     * @return the loaded data
+     */
+    UserData getLoadedData();
+
+}
@@ -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.api.event.user;
+
+import me.lucko.luckperms.api.User;
+import me.lucko.luckperms.api.caching.UserData;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+/**
+ * Called when a users cached data is refreshed
+ */
+public interface UserDataRecalculateEvent extends LuckPermsEvent {
+
+    /**
+     * Gets the user whose data was recalculated
+     *
+     * @return the user
+     */
+    User getUser();
+
+    /**
+     * Gets the data that was recalculated
+     *
+     * @return the data
+     */
+    UserData getData();
+
+}
@@ -20,35 +20,37 @@
 *  SOFTWARE.
 */

-package me.lucko.luckperms.api.event.events;
+package me.lucko.luckperms.api.event.user;

-import me.lucko.luckperms.api.event.LPEvent;
+import me.lucko.luckperms.api.event.LuckPermsEvent;

 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.
 *
- * <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>Particularly useful for networks with multiple
+ * lobbies, who want to welcome a user when they join for the first time.</p>
+ *
+ * <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>
+ *
+ * <p>The users data will not be loaded when this event is called.</p>
 */
-public class UserFirstLoginEvent extends LPEvent {
+public interface UserFirstLoginEvent extends LuckPermsEvent {

-    private final UUID uuid;
-    private final String username;
+    /**
+     * Gets the UUID of the user
+     *
+     * @return the uuid of the user
+     */
+    UUID getUuid();

-    public UserFirstLoginEvent(UUID uuid, String username) {
-        super("User First Join Event");
-        this.uuid = uuid;
-        this.username = username;
-    }
+    /**
+     * Gets the username of the user
+     *
+     * @return the username of the user
+     */
+    String getUsername();

-    public UUID getUuid() {
-        return uuid;
-    }
-
-    public String getUsername() {
-        return username;
-    }
 }
@@ -20,19 +20,21 @@
 *  SOFTWARE.
 */

-package me.lucko.luckperms.api.event.events;
+package me.lucko.luckperms.api.event.user;

-import me.lucko.luckperms.api.Track;
 import me.lucko.luckperms.api.User;
-import me.lucko.luckperms.api.event.TrackEvent;
+import me.lucko.luckperms.api.event.LuckPermsEvent;

 /**
- * Called whenever a user is demoted down a track
+ * Called when a user is loaded into memory from the storage.
 */
-public class UserDemoteEvent extends TrackEvent {
+public interface UserLoadEvent extends LuckPermsEvent {

-    public UserDemoteEvent(Track track, User user, String from, String to) {
-        super("User Demote Event", track, user, from, to);
-    }
+    /**
+     * Gets the user that was loaded
+     *
+     * @return the user that was loaded
+     */
+    User getUser();

 }
@@ -0,0 +1,40 @@
+/*
+ * 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.event.user.track;
+
+/**
+ * Represents the type of action performed in a {@link UserTrackEvent}
+ */
+public enum TrackAction {
+
+    /**
+     * The user was promoted up a track
+     */
+    PROMOTION,
+
+    /**
+     * The user was demoted down a track
+     */
+    DEMOTION;
+
+}
@@ -0,0 +1,32 @@
+/*
+ * 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.event.user.track;
+
+/**
+ * Called when a user is demoted down a track.
+ *
+ * <p>{@link #getAction()} is always {@link TrackAction#DEMOTION}</p>
+ */
+public interface UserDemoteEvent extends UserTrackEvent {
+
+}
@@ -0,0 +1,32 @@
+/*
+ * 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.event.user.track;
+
+/**
+ * Called when a user is promoted up a track.
+ *
+ * <p>{@link #getAction()} is always {@link TrackAction#PROMOTION}</p>
+ */
+public interface UserPromoteEvent extends UserTrackEvent {
+
+}
@@ -0,0 +1,73 @@
+/*
+ * 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.event.user.track;
+
+import me.lucko.luckperms.api.Track;
+import me.lucko.luckperms.api.User;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+import java.util.Optional;
+
+/**
+ * Called when a user interacts with a track through a promotion or demotion
+ */
+public interface UserTrackEvent extends LuckPermsEvent {
+
+    /**
+     * Gets the track involved in the event
+     *
+     * @return the track involved in the event
+     */
+    Track getTrack();
+
+    /**
+     * Gets the user who was promoted or demoted
+     *
+     * @return the user involved in the event
+     */
+    User getUser();
+
+    /**
+     * Gets the action performed
+     *
+     * @return the action performed
+     */
+    TrackAction getAction();
+
+    /**
+     * Gets the group the user was promoted/demoted from.
+     *
+     * <p>May be {@link Optional#empty()} if the user wasn't already placed on the track.</p>
+     *
+     * @return the group the user was promoted/demoted from
+     */
+    Optional<String> getGroupFrom();
+
+    /**
+     * Gets the group the user was promoted/demoted to
+     *
+     * @return the group the user was promoted/demoted to
+     */
+    Optional<String> getGroupTo();
+
+}
@@ -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 {
@@ -1,23 +1,30 @@
 <?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>3.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>luckperms-bukkit-legacy</artifactId>
    <build>
        <defaultGoal>clean package</defaultGoal>
-        <finalName>LuckPerms-bukkit-legacy-${release.version}.${git.closest.tag.commit.count}</finalName>
+        <finalName>LuckPerms-Bukkit-Legacy-${release.version}.${patch.version}</finalName>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <filtering>true</filtering>
            </resource>
+            <resource>
+                <directory>../</directory>
+                <filtering>false</filtering>
+                <includes>
+                    <include>LICENSE.txt</include>
+                </includes>
+            </resource>
        </resources>
        <plugins>
            <plugin>
@@ -41,32 +48,8 @@
                        </goals>
                        <configuration>
                            <minimizeJar>false</minimizeJar>
-                            <artifactSet>
-                                <excludes>
-                                    <exclude>org.xerial:*</exclude>
-                                </excludes>
-                            </artifactSet>
+                            <createDependencyReducedPom>false</createDependencyReducedPom>
                            <relocations>
-                                <relocation>
-                                    <pattern>org.slf4j</pattern>
-                                    <shadedPattern>me.lucko.luckperms.lib.slf4j</shadedPattern>
-                                </relocation>
-                                <relocation>
-                                    <pattern>com.zaxxer.hikari</pattern>
-                                    <shadedPattern>me.lucko.luckperms.lib.hikari</shadedPattern>
-                                </relocation>
-                                <relocation>
-                                    <pattern>com.mongodb</pattern>
-                                    <shadedPattern>me.lucko.luckperms.lib.mongodb</shadedPattern>
-                                </relocation>
-                                <relocation>
-                                    <pattern>org.bson</pattern>
-                                    <shadedPattern>me.lucko.luckperms.lib.bson</shadedPattern>
-                                </relocation>
-                                <relocation>
-                                    <pattern>org.h2</pattern>
-                                    <shadedPattern>me.lucko.luckperms.lib.h2</shadedPattern>
-                                </relocation>
                                <relocation>
                                    <pattern>com.google.common</pattern>
                                    <shadedPattern>me.lucko.luckperms.lib.guava</shadedPattern>
@@ -75,26 +58,15 @@
                                    <pattern>com.google.gson</pattern>
                                    <shadedPattern>me.lucko.luckperms.lib.gson</shadedPattern>
                                </relocation>
+                                <relocation>
+                                    <pattern>io.github.mkremins.fanciful</pattern>
+                                    <shadedPattern>me.lucko.luckperms.lib.fanciful</shadedPattern>
+                                </relocation>
                            </relocations>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
-            <plugin>
-                <groupId>pl.project13.maven</groupId>
-                <artifactId>git-commit-id-plugin</artifactId>
-                <version>2.2.1</version>
-                <executions>
-                    <execution>
-                        <goals>
-                            <goal>revision</goal>
-                        </goals>
-                    </execution>
-                </executions>
-                <configuration>
-                    <injectAllReactorProjects>true</injectAllReactorProjects>
-                </configuration>
-            </plugin>
        </plugins>
    </build>

@@ -1,17 +1,26 @@
 <?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>3.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>luckperms-bukkit-placeholders</artifactId>
    <build>
        <finalName>LuckPermsPlaceholderExpansion</finalName>
+        <resources>
+            <resource>
+                <directory>../</directory>
+                <filtering>false</filtering>
+                <includes>
+                    <include>LICENSE.txt</include>
+                </includes>
+            </resource>
+        </resources>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
@@ -30,7 +39,7 @@
        <dependency>
            <groupId>me.lucko.luckperms</groupId>
            <artifactId>luckperms-api</artifactId>
-            <version>2.8</version>
+            <version>${project.version}</version>
            <scope>provided</scope>
        </dependency>
        <!-- BukkitAPI -->
@@ -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();
-    }
 }
@@ -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>3.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

@@ -14,13 +14,20 @@

    <build>
        <defaultGoal>clean package</defaultGoal>
-        <finalName>LuckPerms-${release.version}.${git.closest.tag.commit.count}</finalName>
+        <finalName>LuckPerms-Bukkit-${release.version}.${patch.version}</finalName>
        <sourceDirectory>${basedir}/src/main/java</sourceDirectory>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <filtering>true</filtering>
            </resource>
+            <resource>
+                <directory>../</directory>
+                <filtering>false</filtering>
+                <includes>
+                    <include>LICENSE.txt</include>
+                </includes>
+            </resource>
        </resources>
        <plugins>
            <plugin>
@@ -44,60 +51,25 @@
                        </goals>
                        <configuration>
                            <minimizeJar>false</minimizeJar>
-                            <artifactSet>
-                                <excludes>
-                                    <exclude>org.xerial:*</exclude>
-                                </excludes>
-                            </artifactSet>
+                            <createDependencyReducedPom>false</createDependencyReducedPom>
                            <relocations>
                                <relocation>
-                                    <pattern>org.slf4j</pattern>
-                                    <shadedPattern>me.lucko.luckperms.lib.slf4j</shadedPattern>
-                                </relocation>
-                                <relocation>
-                                    <pattern>com.zaxxer.hikari</pattern>
-                                    <shadedPattern>me.lucko.luckperms.lib.hikari</shadedPattern>
-                                </relocation>
-                                <relocation>
-                                    <pattern>com.mongodb</pattern>
-                                    <shadedPattern>me.lucko.luckperms.lib.mongodb</shadedPattern>
-                                </relocation>
-                                <relocation>
-                                    <pattern>org.bson</pattern>
-                                    <shadedPattern>me.lucko.luckperms.lib.bson</shadedPattern>
-                                </relocation>
-                                <relocation>
-                                    <pattern>org.h2</pattern>
-                                    <shadedPattern>me.lucko.luckperms.lib.h2</shadedPattern>
+                                    <pattern>io.github.mkremins.fanciful</pattern>
+                                    <shadedPattern>me.lucko.luckperms.lib.fanciful</shadedPattern>
                                </relocation>
                            </relocations>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
-            <plugin>
-                <groupId>pl.project13.maven</groupId>
-                <artifactId>git-commit-id-plugin</artifactId>
-                <version>2.2.1</version>
-                <executions>
-                    <execution>
-                        <goals>
-                            <goal>revision</goal>
-                        </goals>
-                    </execution>
-                </executions>
-                <configuration>
-                    <injectAllReactorProjects>true</injectAllReactorProjects>
-                </configuration>
-            </plugin>
        </plugins>
    </build>

    <dependencies>
        <!-- BukkitAPI -->
        <dependency>
-            <groupId>org.bukkit</groupId>
-            <artifactId>bukkit</artifactId>
+            <groupId>org.spigotmc</groupId>
+            <artifactId>spigot-api</artifactId>
            <version>1.8.8-R0.1-SNAPSHOT</version>
            <scope>provided</scope>
        </dependency>
@@ -122,6 +94,20 @@
            <version>${project.version}</version>
            <scope>compile</scope>
        </dependency>
+        <!-- LilyPad - used as a messaging service -->
+        <dependency>
+            <groupId>lilypad.client.connect</groupId>
+            <artifactId>api</artifactId>
+            <version>0.0.1-SNAPSHOT</version>
+            <scope>provided</scope>
+        </dependency>
+        <!-- HikariCP - needed as source -->
+        <dependency>
+            <groupId>com.zaxxer</groupId>
+            <artifactId>HikariCP</artifactId>
+            <version>2.5.1</version>
+            <scope>provided</scope>
+        </dependency>
        <!-- Lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
@@ -129,5 +115,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>
@@ -23,41 +23,49 @@
 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.Injector;
+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.config.ConfigKeys;
+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));
+        if (plugin.getConfiguration().get(ConfigKeys.APPLYING_REGEX)) {
+            processors.add(new RegexProcessor());
        }
-        if (plugin.getConfiguration().isApplyingRegex()) {
-            processors.add(new RegexProcessor(map));
+        if (plugin.getConfiguration().get(ConfigKeys.APPLYING_WILDCARDS)) {
+            processors.add(new WildcardProcessor());
        }
        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()));
    }
 }
@@ -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;
@@ -37,25 +37,26 @@ import org.bukkit.command.TabExecutor;
 import java.util.Arrays;
 import java.util.List;

-class BukkitCommand extends CommandManager implements CommandExecutor, TabExecutor {
-    BukkitCommand(LuckPermsPlugin plugin) {
+public class BukkitCommand extends CommandManager implements CommandExecutor, TabExecutor {
+    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()
+                Util.stripQuotes(Splitter.on(Patterns.COMMAND_SEPARATOR).omitEmptyStrings().splitToList(Joiner.on(' ').join(args)))
        );
        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));
    }
 }
@@ -22,52 +22,73 @@

 package me.lucko.luckperms.bukkit;

+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
 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;
+
+@RequiredArgsConstructor
+public class BukkitConfig extends AbstractConfiguration {
+
+    @Getter
+    private final LPBukkitPlugin plugin;

-class BukkitConfig extends AbstractConfiguration<LPBukkitPlugin> {
    private YamlConfiguration configuration;

-    BukkitConfig(LPBukkitPlugin plugin) {
-        super(plugin, "global", true, "sqlite");
-    }
-
-    @SuppressWarnings("ResultOfMethodCallIgnored")
    @Override
-    protected void init() {
-        File configFile = new File(getPlugin().getDataFolder(), "config.yml");
+    public void init() {
+        File configFile = new File(plugin.getDataFolder(), "config.yml");

        if (!configFile.exists()) {
            configFile.getParentFile().mkdirs();
-            getPlugin().saveResource("config.yml", false);
+            plugin.saveResource("config.yml", false);
        }

        configuration = YamlConfiguration.loadConfiguration(configFile);
    }

    @Override
-    protected String getString(String path, String def) {
+    public String getString(String path, String def) {
        return configuration.getString(path, def);
    }

    @Override
-    protected int getInt(String path, int def) {
+    public int getInt(String path, int def) {
        return configuration.getInt(path, def);
    }

    @Override
-    protected boolean getBoolean(String path, boolean def) {
+    public boolean getBoolean(String path, boolean def) {
        return configuration.getBoolean(path, def);
    }

-    @SuppressWarnings("unchecked")
    @Override
-    protected Map<String, String> getMap(String path, Map<String, String> def) {
+    public List<String> getList(String path, List<String> def) {
+        return Optional.ofNullable(configuration.getStringList(path)).orElse(def);
+    }
+
+    @Override
+    public 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);
+    }
+
+    @Override
+    public Map<String, String> getMap(String path, Map<String, String> def) {
        Map<String, String> map = new HashMap<>();
        ConfigurationSection section = configuration.getConfigurationSection(path);
        if (section == null) {
@@ -22,33 +22,48 @@

 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.Injector;
+import me.lucko.luckperms.bukkit.model.LPPermissible;
+import me.lucko.luckperms.common.config.ConfigKeys;
 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;
 import org.bukkit.event.Listener;
 import org.bukkit.event.player.AsyncPlayerPreLoginEvent;
+import org.bukkit.event.player.PlayerChangedWorldEvent;
 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.Collections;
+import java.util.HashSet;
+import java.util.Set;
 import java.util.UUID;

 class BukkitListener extends AbstractListener implements Listener {
    private final LPBukkitPlugin plugin;
+    private final Set<UUID> deniedAsyncLogin = Collections.synchronizedSet(new HashSet<>());
+    private final Set<UUID> deniedLogin = new HashSet<>();

    BukkitListener(LPBukkitPlugin plugin) {
        super(plugin);
        this.plugin = plugin;
    }

-    @EventHandler(priority = EventPriority.LOWEST)
+    @EventHandler(priority = EventPriority.LOW)
    public void onPlayerPreLogin(AsyncPlayerPreLoginEvent e) {
-        if (!plugin.getDatastore().isAcceptingLogins()) {
+        if (e.getLoginResult() != AsyncPlayerPreLoginEvent.Result.ALLOWED) {
+            deniedAsyncLogin.add(e.getUniqueId());
+            return;
+        }
+
+        if (!plugin.isStarted() || !plugin.getStorage().isAcceptingLogins()) {
+            deniedAsyncLogin.add(e.getUniqueId());

            // The datastore is disabled, prevent players from joining the server
            e.disallow(AsyncPlayerPreLoginEvent.Result.KICK_OTHER, Message.LOADING_ERROR.toString());
@@ -61,19 +76,31 @@ 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 they were denied before/at LOW, then don't bother handling here.
+        if (deniedAsyncLogin.remove(e.getUniqueId())) {
+            return;
+        }
+
+        if (plugin.isStarted() && plugin.getStorage().isAcceptingLogins() && e.getLoginResult() != AsyncPlayerPreLoginEvent.Result.ALLOWED) {

            // Login event was cancelled by another plugin
            onLeave(e.getUniqueId());
        }
    }

-    @EventHandler(priority = EventPriority.LOWEST)
+    @EventHandler(priority = EventPriority.LOW)
    public void onPlayerLogin(PlayerLoginEvent e) {
+        if (e.getResult() != PlayerLoginEvent.Result.ALLOWED) {
+            deniedLogin.add(e.getPlayer().getUniqueId());
+            return;
+        }
+
        final Player player = e.getPlayer();
        final User user = plugin.getUserManager().get(plugin.getUuidCache().getUUID(player.getUniqueId()));

        if (user == null) {
+            deniedLogin.add(e.getPlayer().getUniqueId());
+
            // User wasn't loaded for whatever reason.
            e.disallow(PlayerLoginEvent.Result.KICK_OTHER, Message.LOADING_ERROR.toString());
            return;
@@ -90,6 +117,8 @@ class BukkitListener extends AbstractListener implements Listener {
            t.printStackTrace();
        }

+        plugin.refreshAutoOp(player);
+
        if (player.isOp()) {

            // We assume all users are not op, but those who are need extra calculation.
@@ -101,24 +130,27 @@ class BukkitListener extends AbstractListener implements Listener {
    public void onPlayerLoginMonitor(PlayerLoginEvent e) {
        if (e.getResult() != PlayerLoginEvent.Result.ALLOWED) {

+            // If they were denied before/at LOW, then don't bother handling here.
+            if (deniedLogin.remove(e.getPlayer().getUniqueId())) {
+                return;
+            }
+
            // The player got denied on sync login.
-            onLeave(e.getPlayer().getUniqueId());
+            plugin.getServer().getScheduler().runTaskLater(plugin, () -> onLeave(e.getPlayer().getUniqueId()), 20L);
+        } else {
+            plugin.refreshAutoOp(e.getPlayer());
        }
    }

-    @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());
-
-        // Remove from World cache
-        plugin.getWorldCalculator().getWorldCache().remove(internal);

        // Remove the custom permissible
-        Injector.unInject(player);
+        Injector.unInject(player, true, true);

        // Handle auto op
-        if (plugin.getConfiguration().isAutoOp()) {
+        if (plugin.getConfiguration().get(ConfigKeys.AUTO_OP)) {
            player.setOp(false);
        }

@@ -128,7 +160,7 @@ class BukkitListener extends AbstractListener implements Listener {

    @EventHandler
    public void onPlayerCommand(PlayerCommandPreprocessEvent e) {
-        if (plugin.getConfiguration().isOpsEnabled()) {
+        if (plugin.getConfiguration().get(ConfigKeys.OPS_ENABLED)) {
            return;
        }

@@ -138,9 +170,21 @@ class BukkitListener extends AbstractListener implements Listener {
                .replace("spigot:", "")
                .replace("minecraft:", "");

-        if (s.startsWith("op") || s.startsWith("deop")) {
+        if (s.equals("op") || s.startsWith("op ") || s.equals("deop") || s.startsWith("deop ")) {
            e.setCancelled(true);
            e.getPlayer().sendMessage(Message.OP_DISABLED.toString());
        }
    }
+
+    @EventHandler
+    public void onPluginEnable(PluginEnableEvent e) {
+        if (e.getPlugin().getName().equalsIgnoreCase("Vault")) {
+            plugin.tryVaultHook(true);
+        }
+    }
+
+    @EventHandler
+    public void onWorldChange(PlayerChangedWorldEvent e) {
+        plugin.refreshAutoOp(e.getPlayer());
+    }
 }
@@ -22,26 +22,24 @@

 package me.lucko.luckperms.bukkit;

-import me.lucko.luckperms.common.LuckPermsPlugin;
-import me.lucko.luckperms.common.commands.SenderFactory;
+import me.lucko.luckperms.bukkit.compat.MessageHandler;
+import me.lucko.luckperms.common.commands.sender.SenderFactory;
 import me.lucko.luckperms.common.constants.Constants;
+import me.lucko.luckperms.common.plugin.LuckPermsPlugin;
+
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;

+import io.github.mkremins.fanciful.FancyMessage;
+
 import java.util.UUID;

 public class BukkitSenderFactory extends SenderFactory<CommandSender> {
-    private static BukkitSenderFactory instance = null;
+    private final MessageHandler messageHandler;

-    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;
+        messageHandler = new MessageHandler();
    }

    @Override
@@ -49,7 +47,7 @@ public class BukkitSenderFactory extends SenderFactory<CommandSender> {
        if (sender instanceof Player) {
            return sender.getName();
        }
-        return Constants.getConsoleName();
+        return Constants.CONSOLE_NAME;
    }

    @Override
@@ -57,7 +55,7 @@ public class BukkitSenderFactory extends SenderFactory<CommandSender> {
        if (sender instanceof Player) {
            return ((Player) sender).getUniqueId();
        }
-        return Constants.getConsoleUUID();
+        return Constants.CONSOLE_UUID;
    }

    @Override
@@ -65,6 +63,11 @@ public class BukkitSenderFactory extends SenderFactory<CommandSender> {
        sender.sendMessage(s);
    }

+    @Override
+    protected void sendMessage(CommandSender sender, FancyMessage message) {
+        messageHandler.sendJsonMessage(sender, message);
+    }
+
    @Override
    protected boolean hasPermission(CommandSender sender, String node) {
        return sender.hasPermission(node);
@@ -23,76 +23,206 @@
 package me.lucko.luckperms.bukkit;

 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.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.messaging.BungeeMessagingService;
+import me.lucko.luckperms.bukkit.messaging.LilyPadMessagingService;
+import me.lucko.luckperms.bukkit.model.ChildPermissionProvider;
+import me.lucko.luckperms.bukkit.model.DefaultsProvider;
+import me.lucko.luckperms.bukkit.model.Injector;
+import me.lucko.luckperms.bukkit.model.LPPermissible;
 import me.lucko.luckperms.bukkit.vault.VaultHook;
-import me.lucko.luckperms.common.LuckPermsPlugin;
+import me.lucko.luckperms.common.api.ApiHandler;
 import me.lucko.luckperms.common.api.ApiProvider;
+import me.lucko.luckperms.common.caching.handlers.CachedStateManager;
 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.config.LPConfiguration;
-import me.lucko.luckperms.common.constants.Message;
+import me.lucko.luckperms.common.commands.sender.Sender;
+import me.lucko.luckperms.common.config.ConfigKeys;
+import me.lucko.luckperms.common.config.LuckPermsConfiguration;
+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.debug.DebugHandler;
+import me.lucko.luckperms.common.dependencies.DependencyManager;
+import me.lucko.luckperms.common.locale.LocaleManager;
+import me.lucko.luckperms.common.locale.NoopLocaleManager;
+import me.lucko.luckperms.common.locale.SimpleLocaleManager;
+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.InternalMessagingService;
+import me.lucko.luckperms.common.messaging.RedisMessaging;
+import me.lucko.luckperms.common.plugin.LuckPermsPlugin;
+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.utils.LocaleManager;
-import me.lucko.luckperms.common.utils.LogFactory;
+import me.lucko.luckperms.common.storage.StorageType;
+import me.lucko.luckperms.common.tasks.CacheHousekeepingTask;
+import me.lucko.luckperms.common.tasks.ExpireTemporaryTask;
+import me.lucko.luckperms.common.tasks.UpdateTask;
+import me.lucko.luckperms.common.treeview.PermissionVault;
+import me.lucko.luckperms.common.utils.BufferedRequest;
+import me.lucko.luckperms.common.utils.LoggerImpl;
+
 import org.bukkit.World;
 import org.bukkit.command.PluginCommand;
 import org.bukkit.entity.Player;
-import org.bukkit.permissions.Permission;
+import org.bukkit.event.HandlerList;
 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.io.InputStream;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.UUID;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.stream.Collectors;

@Getter
 public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
+    private Set<UUID> ignoringLogs;
+    private LPBukkitScheduler scheduler;
+    private BukkitCommand commandManager;
    private VaultHook vaultHook = null;
-
-    private final Set<UUID> ignoringLogs = ConcurrentHashMap.newKeySet();
-    private LPConfiguration configuration;
+    private LuckPermsConfiguration configuration;
    private UserManager userManager;
    private GroupManager groupManager;
    private TrackManager trackManager;
-    private Datastore datastore;
+    private Storage storage;
+    private InternalMessagingService messagingService = null;
    private UuidCache uuidCache;
+    private BukkitListener listener;
    private ApiProvider apiProvider;
    private Logger log;
    private Importer importer;
-    private ConsecutiveExecutor consecutiveExecutor;
    private DefaultsProvider defaultsProvider;
+    private ChildPermissionProvider childPermissionProvider;
    private LocaleManager localeManager;
+    private CachedStateManager cachedStateManager;
    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 PermissionVault permissionVault;

    @Override
    public void onEnable() {
-        log = LogFactory.wrap(getLogger());
+        scheduler = new LPBukkitScheduler(this);
+
+        localeManager = new NoopLocaleManager();
+        senderFactory = new BukkitSenderFactory(this);
+        log = new LoggerImpl(getConsoleSender());
+        LuckPermsPlugin.sendStartupBanner(getConsoleSender(), this);
+
+        ignoringLogs = ConcurrentHashMap.newKeySet();
+        debugHandler = new DebugHandler(scheduler.getAsyncBukkitExecutor(), getVersion());
+        permissionVault = new PermissionVault(scheduler.getAsyncBukkitExecutor());

        getLog().info("Loading configuration...");
        configuration = new BukkitConfig(this);
+        configuration.init();
+        configuration.loadAll();

-        localeManager = new LocaleManager();
+        Set<StorageType> storageTypes = StorageFactory.getRequiredTypes(this, StorageType.H2);
+        DependencyManager.loadDependencies(this, storageTypes);
+
+        // setup the Bukkit defaults hook
+        defaultsProvider = new DefaultsProvider();
+        childPermissionProvider = new ChildPermissionProvider();
+
+        // give all plugins a chance to load their permissions, then refresh.
+        scheduler.doSyncLater(() -> {
+            defaultsProvider.refresh();
+            childPermissionProvider.setup();
+
+            Set<String> perms = new HashSet<>();
+            getServer().getPluginManager().getPermissions().forEach(p -> {
+                perms.add(p.getName());
+                perms.addAll(p.getChildren().keySet());
+            });
+
+            perms.forEach(p -> permissionVault.offer(p));
+        }, 1L);
+
+        // register events
+        PluginManager pm = getServer().getPluginManager();
+        listener = new BukkitListener(this);
+        pm.registerEvents(listener, this);
+
+        // initialise datastore
+        storage = StorageFactory.getInstance(this, StorageType.H2);
+
+        // initialise messaging
+        String messagingType = getConfiguration().get(ConfigKeys.MESSAGING_SERVICE).toLowerCase();
+        if (messagingType.equals("none") && getConfiguration().get(ConfigKeys.REDIS_ENABLED)) {
+            messagingType = "redis";
+        }
+        if (messagingType.equals("redis")) {
+            getLog().info("Loading redis...");
+            if (getConfiguration().get(ConfigKeys.REDIS_ENABLED)) {
+                RedisMessaging redis = new RedisMessaging(this);
+                try {
+                    redis.init(getConfiguration().get(ConfigKeys.REDIS_ADDRESS), getConfiguration().get(ConfigKeys.REDIS_PASSWORD));
+                    getLog().info("Loaded redis successfully...");
+
+                    messagingService = redis;
+                } catch (Exception e) {
+                    getLog().warn("Couldn't load redis...");
+                    e.printStackTrace();
+                }
+            } else {
+                getLog().warn("Messaging Service was set to redis, but redis is not enabled!");
+            }
+        } else if (messagingType.equals("bungee")) {
+            getLog().info("Loading bungee messaging service...");
+            BungeeMessagingService bungeeMessaging = new BungeeMessagingService(this);
+            bungeeMessaging.init();
+            messagingService = bungeeMessaging;
+        } else if (messagingType.equals("lilypad")) {
+            getLog().info("Loading LilyPad messaging service...");
+            if (getServer().getPluginManager().getPlugin("LilyPad-Connect") == null) {
+                getLog().warn("LilyPad-Connect plugin not present.");
+            } else {
+                LilyPadMessagingService lilyPadMessaging = new LilyPadMessagingService(this);
+                lilyPadMessaging.init();
+                messagingService = lilyPadMessaging;
+            }
+        } else if (!messagingType.equals("none")) {
+            getLog().warn("Messaging service '" + messagingType + "' not recognised.");
+        }
+
+        // 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 SimpleLocaleManager();
        File locale = new File(getDataFolder(), "lang.yml");
        if (locale.exists()) {
            getLog().info("Found locale file. Attempting to load from it.");
@@ -103,88 +233,118 @@ 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);
+        commandManager = new BukkitCommand(this);
        PluginCommand main = getServer().getPluginCommand("luckperms");
        main.setExecutor(commandManager);
        main.setTabCompleter(commandManager);
-        main.setAliases(Arrays.asList("perms", "lp", "permissions", "p", "perm"));
-
-        datastore = StorageFactory.getDatastore(this, "h2");
+        main.setAliases(Arrays.asList("perms", "lp", "permissions", "perm"));

+        // 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();
+        uuidCache = new UuidCache(this);
+        userManager = new GenericUserManager(this);
+        groupManager = new GenericGroupManager(this);
+        trackManager = new GenericTrackManager(this);
        importer = new Importer(commandManager);
-        consecutiveExecutor = new ConsecutiveExecutor(commandManager);
        calculatorFactory = new BukkitCalculatorFactory(this);
+        cachedStateManager = new CachedStateManager(this);

        contextManager = new ContextManager<>();
        worldCalculator = new WorldCalculator(this);
-        pm.registerEvents(worldCalculator, this);
        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);
-        }
-
-        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);
+        contextManager.registerCalculator(new ServerCalculator<>(getConfiguration()));

        // 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().get(ConfigKeys.SYNC_TIME);
+        if (mins > 0) {
+            long ticks = mins * 60 * 20;
+            scheduler.doAsyncRepeating(() -> updateTaskBuffer.request(), ticks);
+        }
+        scheduler.doAsyncLater(() -> updateTaskBuffer.request(), 40L);
+
+        // run an update instantly.
+        updateTaskBuffer.requestDirectly();
+
+        // register tasks
+        scheduler.doAsyncRepeating(new ExpireTemporaryTask(this), 60L);
+        scheduler.doAsyncRepeating(new CacheHousekeepingTask(this), 2400L);
+
+        // register permissions
+        registerPermissions(getConfiguration().get(ConfigKeys.COMMANDS_ALLOW_OP) ? PermissionDefault.OP : PermissionDefault.FALSE);
+        if (!getConfiguration().get(ConfigKeys.OPS_ENABLED)) {
+            scheduler.doSync(() -> getServer().getOperators().forEach(o -> o.setOp(false)));
        }

-        registerPermissions(getConfiguration().isCommandsAllowOp() ? PermissionDefault.OP : PermissionDefault.FALSE);
-        if (!getConfiguration().isOpsEnabled()) {
-            getServer().getOperators().forEach(o -> o.setOp(false));
+        // replace the temporary executor when the Bukkit one starts
+        getServer().getScheduler().runTaskAsynchronously(this, () -> {
+            scheduler.setUseBukkitAsync(true);
+        });
+
+        // Load any online users (in the case of a reload)
+        for (Player player : getServer().getOnlinePlayers()) {
+            scheduler.doAsync(() -> {
+                listener.onAsyncLogin(player.getUniqueId(), player.getName());
+                User user = getUserManager().get(getUuidCache().getUUID(player.getUniqueId()));
+                if (user != null) {
+                    scheduler.doSync(() -> {
+                        try {
+                            LPPermissible lpPermissible = new LPPermissible(player, user, this);
+                            Injector.inject(player, lpPermissible);
+                        } catch (Throwable t) {
+                            t.printStackTrace();
+                        }
+                    });
+                }
+            });
        }

+        started = true;
        getLog().info("Successfully loaded.");
    }

    @Override
    public void onDisable() {
+        // Switch back to the LP executor, the bukkit one won't allow new tasks
+        scheduler.setUseBukkitAsync(false);
+
+        started = false;
+
+        defaultsProvider.close();
+        permissionVault.setShutdown(true);
+        debugHandler.setShutdown(true);
+
+        for (Player player : getServer().getOnlinePlayers()) {
+            Injector.unInject(player, false, false);
+            if (getConfiguration().get(ConfigKeys.AUTO_OP)) {
+                player.setOp(false);
+            }
+
+            final User user = getUserManager().get(getUuidCache().getUUID(player.getUniqueId()));
+            if (user != null) {
+                user.unregisterData();
+                getUserManager().unload(user);
+            }
+        }
+
        getLog().info("Closing datastore...");
-        datastore.shutdown();
+        storage.shutdown();
+
+        if (messagingService != null) {
+            getLog().info("Closing messaging service...");
+            messagingService.close();
+        }

        getLog().info("Unregistering API...");
        ApiHandler.unregisterProvider();
@@ -193,16 +353,82 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
        if (vaultHook != null) {
            vaultHook.unhook(this);
        }
+
+        scheduler.shutdown();
+
+        // Bukkit will do this again when #onDisable completes, but we do it early to prevent NPEs elsewhere.
+        getServer().getScheduler().cancelTasks(this);
+        HandlerList.unregisterAll(this);
+
+        // Null everything
+        ignoringLogs = null;
+        vaultHook = null;
+        configuration = null;
+        userManager = null;
+        groupManager = null;
+        trackManager = null;
+        storage = null;
+        messagingService = null;
+        uuidCache = null;
+        listener = null;
+        apiProvider = null;
+        log = null;
+        importer = null;
+        defaultsProvider = null;
+        childPermissionProvider = null;
+        localeManager = null;
+        cachedStateManager = null;
+        contextManager = null;
+        worldCalculator = null;
+        calculatorFactory = null;
+        updateTaskBuffer = null;
+        debugHandler = null;
+        senderFactory = null;
+        permissionVault = null;
+    }
+
+    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);
+    public void onUserRefresh(User user) {
+        LPPermissible lpp = Injector.getPermissible(uuidCache.getExternalUUID(user.getUuid()));
+        if (lpp != null) {
+            lpp.updateSubscriptions();
+        }
    }

-    @Override
-    public void doSync(Runnable r) {
-        getServer().getScheduler().runTask(this, r);
+    public void refreshAutoOp(Player player) {
+        if (getConfiguration().get(ConfigKeys.AUTO_OP)) {
+            try {
+                LPPermissible permissible = Injector.getPermissible(player.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);
+                player.setOp(op);
+            } catch (Exception ignored) {}
+        }
    }

    @Override
@@ -211,18 +437,50 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
    }

    @Override
-    public PlatformType getType() {
+    public PlatformType getServerType() {
        return PlatformType.BUKKIT;
    }

    @Override
-    public File getMainDir() {
-        return getDataFolder();
+    public String getServerName() {
+        return getServer().getName();
    }

    @Override
-    public Message getPlayerStatus(UUID uuid) {
-        return getServer().getPlayer(getUuidCache().getExternalUUID(uuid)) != null ? Message.PLAYER_ONLINE : Message.PLAYER_OFFLINE;
+    public String getServerVersion() {
+        return getServer().getVersion();
+    }
+
+    @Override
+    public File getDataDirectory() {
+        return super.getDataFolder();
+    }
+
+    @Override
+    public InputStream getResourceStream(String path) {
+        return getResource(path);
+    }
+
+    @Override
+    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().get(ConfigKeys.INCLUDING_GLOBAL_PERMS),
+                getConfiguration().get(ConfigKeys.INCLUDING_GLOBAL_WORLD_PERMS),
+                true,
+                getConfiguration().get(ConfigKeys.APPLYING_GLOBAL_GROUPS),
+                getConfiguration().get(ConfigKeys.APPLYING_GLOBAL_WORLD_GROUPS),
+                player.isOp()
+        );
    }

    @Override
@@ -236,46 +494,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 isPlayerOnline(UUID external) {
+        return getServer().getPlayer(external) != null;
+    }
+
+    @Override
+    public List<Sender> getOnlineSenders() {
        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().get(ConfigKeys.SERVER)));

        // 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().get(ConfigKeys.SERVER));
+                    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()));
+        if (!getConfiguration().get(ConfigKeys.SERVER).equals(getConfiguration().get(ConfigKeys.VAULT_SERVER))) {
+            c.add(ContextSet.singleton("server", getConfiguration().get(ConfigKeys.VAULT_SERVER)));
            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().get(ConfigKeys.VAULT_SERVER));
+                        set.add("world", s);
+                        return set.makeImmutable();
                    })
                    .collect(Collectors.toList())
            );
@@ -285,27 +552,27 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {

        // Convert to full Contexts
        contexts.addAll(c.stream()
-                .map(map -> new Contexts(
-                        map,
-                        getConfiguration().isIncludingGlobalPerms(),
-                        getConfiguration().isIncludingGlobalWorldPerms(),
+                .map(set -> new Contexts(
+                        set,
+                        getConfiguration().get(ConfigKeys.INCLUDING_GLOBAL_PERMS),
+                        getConfiguration().get(ConfigKeys.INCLUDING_GLOBAL_WORLD_PERMS),
                        true,
-                        getConfiguration().isApplyingGlobalGroups(),
-                        getConfiguration().isApplyingGlobalWorldGroups(),
+                        getConfiguration().get(ConfigKeys.APPLYING_GLOBAL_GROUPS),
+                        getConfiguration().get(ConfigKeys.APPLYING_GLOBAL_WORLD_GROUPS),
                        op
                ))
                .collect(Collectors.toSet())
        );

        // 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().get(ConfigKeys.VAULT_INCLUDING_GLOBAL) != getConfiguration().get(ConfigKeys.INCLUDING_GLOBAL_PERMS) ||
+                !getConfiguration().get(ConfigKeys.INCLUDING_GLOBAL_WORLD_PERMS) ||
+                !getConfiguration().get(ConfigKeys.APPLYING_GLOBAL_GROUPS) ||
+                !getConfiguration().get(ConfigKeys.APPLYING_GLOBAL_WORLD_GROUPS);
+
+        if (vaultDiff) {
            contexts.addAll(c.stream()
-                    .map(map -> new Contexts(map, getConfiguration().isVaultIncludingGlobal(), true, true, true, true, op))
+                    .map(map -> new Contexts(map, getConfiguration().get(ConfigKeys.VAULT_INCLUDING_GLOBAL), true, true, true, true, op))
                    .collect(Collectors.toSet())
            );
        }
@@ -314,18 +581,25 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
    }

    @Override
-    public Object getPlugin(String name) {
-        return getServer().getPluginManager().getPlugin(name);
-    }
-
-    @Override
-    public Object getService(Class clazz) {
-        return getServer().getServicesManager().load(clazz);
+    public LinkedHashMap<String, Object> getExtraInfo() {
+        LinkedHashMap<String, Object> map = new LinkedHashMap<>();
+        map.put("Vault Enabled", vaultHook != null);
+        map.put("Vault Server", configuration.get(ConfigKeys.VAULT_SERVER));
+        map.put("Bukkit Defaults count", defaultsProvider.size());
+        map.put("Bukkit Child Permissions count", childPermissionProvider.getPermissions().size());
+        map.put("Vault Including Global", configuration.get(ConfigKeys.VAULT_INCLUDING_GLOBAL));
+        map.put("Vault Ignoring World", configuration.get(ConfigKeys.VAULT_IGNORE_WORLD));
+        map.put("Vault Primary Group Overrides", configuration.get(ConfigKeys.VAULT_PRIMARY_GROUP_OVERRIDES));
+        map.put("Vault Debug", configuration.get(ConfigKeys.VAULT_DEBUG));
+        map.put("OPs Enabled", configuration.get(ConfigKeys.OPS_ENABLED));
+        map.put("Auto OP", configuration.get(ConfigKeys.AUTO_OP));
+        map.put("Commands Allow OPs", configuration.get(ConfigKeys.COMMANDS_ALLOW_OP));
+        return map;
    }

    @SuppressWarnings("deprecation")
    @Override
-    public UUID getUUID(String playerName) {
+    public UUID getUuidFromUsername(String playerName) {
        try {
            return getServer().getOfflinePlayer(playerName).getUniqueId();
        } catch (Exception e) {
@@ -333,43 +607,13 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
        }
    }

-    @Override
-    public boolean isPluginLoaded(String name) {
-        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))));
    }
 }
@@ -0,0 +1,116 @@
+/*
+ * 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;
+
+import lombok.Getter;
+import lombok.Setter;
+
+import me.lucko.luckperms.common.plugin.LuckPermsScheduler;
+
+import org.bukkit.scheduler.BukkitTask;
+
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+public class LPBukkitScheduler implements LuckPermsScheduler {
+    private final LPBukkitPlugin plugin;
+
+    @Getter
+    private ExecutorService asyncLpExecutor;
+    @Getter
+    private Executor asyncBukkitExecutor;
+    private Executor syncExecutor;
+
+    @Getter
+    @Setter
+    private boolean useBukkitAsync = false;
+
+    private Set<BukkitTask> tasks = ConcurrentHashMap.newKeySet();
+
+    public LPBukkitScheduler(LPBukkitPlugin plugin) {
+        this.plugin = plugin;
+
+        this.asyncLpExecutor = Executors.newCachedThreadPool();
+        this.asyncBukkitExecutor = r -> plugin.getServer().getScheduler().runTaskAsynchronously(plugin, r);
+        this.syncExecutor = r -> plugin.getServer().getScheduler().runTask(plugin, r);
+    }
+
+    @Override
+    public Executor getAsyncExecutor() {
+        return useBukkitAsync ? asyncBukkitExecutor : asyncLpExecutor;
+    }
+
+    @Override
+    public Executor getSyncExecutor() {
+        return syncExecutor;
+    }
+
+    @Override
+    public void doAsync(Runnable r) {
+        getAsyncExecutor().execute(r);
+    }
+
+    @Override
+    public void doSync(Runnable r) {
+        getSyncExecutor().execute(r);
+    }
+
+    @Override
+    public void doAsyncRepeating(Runnable r, long interval) {
+        BukkitTask task = plugin.getServer().getScheduler().runTaskTimerAsynchronously(plugin, r, interval, interval);
+        tasks.add(task);
+    }
+
+    @Override
+    public void doSyncRepeating(Runnable r, long interval) {
+        BukkitTask task = plugin.getServer().getScheduler().runTaskTimer(plugin, r, interval, interval);
+        tasks.add(task);
+    }
+
+    @Override
+    public void doAsyncLater(Runnable r, long delay) {
+        plugin.getServer().getScheduler().runTaskLaterAsynchronously(plugin, r, delay);
+    }
+
+    @Override
+    public void doSyncLater(Runnable r, long delay) {
+        plugin.getServer().getScheduler().runTaskLater(plugin, r, delay);
+    }
+
+    @Override
+    public void shutdown() {
+        tasks.forEach(BukkitTask::cancel);
+        // wait for executor
+        asyncLpExecutor.shutdown();
+        try {
+            asyncLpExecutor.awaitTermination(30, TimeUnit.SECONDS);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+    }
+}
@@ -22,36 +22,31 @@

 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.common.LuckPermsPlugin;
+import me.lucko.luckperms.api.context.MutableContextSet;
+import me.lucko.luckperms.common.config.ConfigKeys;
+import me.lucko.luckperms.common.plugin.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 java.util.Map;
-import java.util.UUID;
-import java.util.concurrent.ConcurrentHashMap;

@RequiredArgsConstructor
-public class WorldCalculator extends ContextCalculator<Player> implements Listener {
+public class WorldCalculator implements ContextCalculator<Player> {
    private static final String WORLD_KEY = "world";

    private final LuckPermsPlugin plugin;

-    @Getter
-    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;
@@ -68,23 +63,7 @@ public class WorldCalculator extends ContextCalculator<Player> implements Listen
    }

    private String getWorld(Player player) {
-        UUID internal = plugin.getUuidCache().getUUID(player.getUniqueId());
-        if (!worldCache.containsKey(internal)) {
-            return null;
-        }
-
-        String world = worldCache.get(internal);
-        return plugin.getConfiguration().getWorldRewrites().getOrDefault(world, world);
-    }
-
-    @EventHandler(priority = EventPriority.LOWEST)
-    public void onPlayerChangedWorld(PlayerChangedWorldEvent e) {
-        UUID internal = plugin.getUuidCache().getUUID(e.getPlayer().getUniqueId());
-        worldCache.put(internal, e.getPlayer().getWorld().getName());
-        pushUpdate(
-                e.getPlayer(),
-                Maps.immutableEntry(WORLD_KEY, e.getFrom().getName()),
-                Maps.immutableEntry(WORLD_KEY, e.getPlayer().getWorld().getName())
-        );
+        String world = player.getWorld().getName();
+        return plugin.getConfiguration().get(ConfigKeys.WORLD_REWRITES).getOrDefault(world, world);
    }
 }
@@ -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
    }

 }
@@ -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);
+            }
+        }
+    }
+}
@@ -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
    }
 }
@@ -0,0 +1,122 @@
+/*
+ * 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.compat;
+
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+
+public class BukkitJsonMessageHandler {
+    private static boolean setup = false;
+    private static boolean triedAndFailed = false;
+
+    private static Method GET_HANDLE_METHOD;
+    private static Field PLAYER_CONNECTION_FIELD;
+    private static Method SEND_PACKET_METHOD;
+    private static Constructor<?> PACKET_CHAT_CONSTRUCTOR;
+    private static Method SERIALIZE_METHOD;
+
+    private static void setup(Object player) throws Exception {
+        Class<?> craftPlayerClass = player.getClass();
+        GET_HANDLE_METHOD = craftPlayerClass.getDeclaredMethod("getHandle");
+
+        Object handleObject = GET_HANDLE_METHOD.invoke(player);
+        Class<?> handleClass = handleObject.getClass();
+
+        PLAYER_CONNECTION_FIELD = handleClass.getDeclaredField("playerConnection");
+
+        Object playerConnectionObject = PLAYER_CONNECTION_FIELD.get(handleObject);
+
+        Method[] playerConnectionMethods = playerConnectionObject.getClass().getDeclaredMethods();
+        for (Method m : playerConnectionMethods) {
+            if (m.getName().equals("sendPacket")) {
+                SEND_PACKET_METHOD = m;
+                break;
+            }
+        }
+
+        Class<?> packetChatClass = Class.forName(getVersionedClassName("PacketPlayOutChat"));
+        Constructor[] packetConstructors = packetChatClass.getDeclaredConstructors();
+        for (Constructor c : packetConstructors) {
+            Class<?>[] parameters = c.getParameterTypes();
+            if (parameters.length == 1 && parameters[0].getName().endsWith("IChatBaseComponent")) {
+                PACKET_CHAT_CONSTRUCTOR = c;
+                break;
+            }
+        }
+
+        Class<?> baseComponentClass = Class.forName(getVersionedClassName("IChatBaseComponent"));
+        Class<?> chatSerializerClass = baseComponentClass.getClasses()[0];
+
+        SERIALIZE_METHOD = chatSerializerClass.getDeclaredMethod("a", String.class);
+    }
+
+    private static String getVersionedClassName(String className) {
+        Class server = Bukkit.getServer().getClass();
+        if (!server.getSimpleName().equals("CraftServer")) {
+            throw new RuntimeException("Couldn't reflect into server " + server);
+        }
+
+        String version;
+        if (server.getName().equals("org.bukkit.craftbukkit.CraftServer")) {
+            // Non versioned class
+            version = ".";
+        } else {
+            version = server.getName().substring("org.bukkit.craftbukkit".length());
+            version = version.substring(0, version.length() - "CraftServer".length());
+        }
+
+        return "net.minecraft.server" + version + className;
+    }
+
+    private static synchronized boolean trySetup(Object player) {
+        if (setup) return true;
+        if (triedAndFailed) return false;
+
+        try {
+            setup(player);
+            setup = true;
+            return true;
+        } catch (Exception e) {
+            triedAndFailed = true;
+            return false;
+        }
+    }
+
+    public boolean sendJsonMessage(Player player, String json) {
+        if (!trySetup(player)) {
+            return false;
+        }
+
+        try {
+            Object connection = PLAYER_CONNECTION_FIELD.get(GET_HANDLE_METHOD.invoke(player));
+            SEND_PACKET_METHOD.invoke(connection, PACKET_CHAT_CONSTRUCTOR.newInstance(SERIALIZE_METHOD.invoke(null, json)));
+            return true;
+        } catch (Exception e) {
+            return false;
+        }
+    }
+}
@@ -0,0 +1,68 @@
+/*
+ * 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.compat;
+
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import io.github.mkremins.fanciful.FancyMessage;
+
+public class MessageHandler {
+    private final BukkitJsonMessageHandler bukkitHandler;
+    private final SpigotJsonMessageHandler spigotHandler;
+
+    public MessageHandler() {
+        bukkitHandler = new BukkitJsonMessageHandler();
+        spigotHandler = isSpigot() ? new SpigotJsonMessageHandler() : null;
+    }
+
+    public void sendJsonMessage(CommandSender sender, FancyMessage message) {
+        if (sender instanceof Player) {
+            Player player = (Player) sender;
+            String json = message.toJSONString();
+
+            // Try Bukkit.
+            if (bukkitHandler.sendJsonMessage(player, json)) {
+                return;
+            }
+
+            // Try Spigot.
+            if (spigotHandler != null && spigotHandler.sendJsonMessage(player, json)) {
+                return;
+            }
+        }
+
+        // Fallback to Bukkit
+        sender.sendMessage(message.toOldMessageFormat());
+    }
+
+    private static boolean isSpigot() {
+        try {
+            Class.forName("net.md_5.bungee.chat.ComponentSerializer");
+            return true;
+        } catch (ClassNotFoundException e) {
+            return false;
+        }
+    }
+
+}
@@ -0,0 +1,40 @@
+/*
+ * 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.compat;
+
+import net.md_5.bungee.chat.ComponentSerializer;
+
+import org.bukkit.entity.Player;
+
+public class SpigotJsonMessageHandler {
+
+    public boolean sendJsonMessage(Player player, String json) {
+        try {
+            player.spigot().sendMessage(ComponentSerializer.parse(json));
+            return true;
+        } catch (Exception e) {
+            return false;
+        }
+    }
+
+}
@@ -0,0 +1,95 @@
+/*
+ * 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.messaging;
+
+import com.google.common.collect.Iterables;
+import com.google.common.io.ByteArrayDataInput;
+import com.google.common.io.ByteArrayDataOutput;
+import com.google.common.io.ByteStreams;
+
+import me.lucko.luckperms.bukkit.LPBukkitPlugin;
+import me.lucko.luckperms.common.messaging.AbstractMessagingService;
+
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.messaging.PluginMessageListener;
+import org.bukkit.scheduler.BukkitRunnable;
+
+import java.util.Collection;
+
+/**
+ * An implementation of {@link me.lucko.luckperms.api.MessagingService} using the plugin messaging channels.
+ */
+public class BungeeMessagingService extends AbstractMessagingService implements PluginMessageListener {
+    private final LPBukkitPlugin plugin;
+
+    public BungeeMessagingService(LPBukkitPlugin plugin) {
+        super(plugin, "Bungee");
+        this.plugin = plugin;
+    }
+
+    public void init() {
+        plugin.getServer().getMessenger().registerOutgoingPluginChannel(plugin, CHANNEL);
+        plugin.getServer().getMessenger().registerIncomingPluginChannel(plugin, CHANNEL, this);
+    }
+
+    @Override
+    public void close() {
+        plugin.getServer().getMessenger().unregisterIncomingPluginChannel(plugin, CHANNEL);
+        plugin.getServer().getMessenger().unregisterOutgoingPluginChannel(plugin, CHANNEL);
+    }
+
+    @Override
+    protected void sendMessage(String channel, String message) {
+        new BukkitRunnable() {
+            @Override
+            public void run() {
+                Collection<? extends Player> players = plugin.getServer().getOnlinePlayers();
+                if (players.isEmpty()) {
+                    return;
+                }
+
+                Player p = Iterables.getFirst(players, null);
+
+                ByteArrayDataOutput out = ByteStreams.newDataOutput();
+                out.writeUTF(message);
+
+                byte[] data = out.toByteArray();
+
+                p.sendPluginMessage(plugin, channel, data);
+                cancel();
+            }
+        }.runTaskTimer(plugin, 1L, 100L);
+    }
+
+    @Override
+    public void onPluginMessageReceived(String s, Player player, byte[] bytes) {
+        if (!s.equals(CHANNEL)) {
+            return;
+        }
+
+        ByteArrayDataInput in = ByteStreams.newDataInput(bytes);
+        String msg = in.readUTF();
+
+        onMessage(s, msg, null);
+    }
+}
@@ -0,0 +1,90 @@
+/*
+ * 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.messaging;
+
+import me.lucko.luckperms.bukkit.LPBukkitPlugin;
+import me.lucko.luckperms.common.messaging.AbstractMessagingService;
+
+import lilypad.client.connect.api.Connect;
+import lilypad.client.connect.api.event.EventListener;
+import lilypad.client.connect.api.event.MessageEvent;
+import lilypad.client.connect.api.request.RequestException;
+import lilypad.client.connect.api.request.impl.MessageRequest;
+
+import java.io.UnsupportedEncodingException;
+import java.util.Collections;
+
+/**
+ * An implementation of {@link me.lucko.luckperms.api.MessagingService} using LilyPad.
+ */
+public class LilyPadMessagingService extends AbstractMessagingService {
+    private final LPBukkitPlugin plugin;
+    private Connect connect;
+
+    public LilyPadMessagingService(LPBukkitPlugin plugin) {
+        super(plugin, "LilyPad");
+        this.plugin = plugin;
+    }
+
+    public void init() {
+        connect = plugin.getServer().getServicesManager().getRegistration(Connect.class).getProvider();
+        connect.registerEvents(this);
+    }
+
+    @Override
+    public void close() {
+        connect.unregisterEvents(this);
+    }
+
+    @Override
+    protected void sendMessage(String channel, String message) {
+        MessageRequest request;
+
+        try {
+            request = new MessageRequest(Collections.emptyList(), channel, message);
+        } catch (UnsupportedEncodingException e) {
+            e.printStackTrace();
+            return;
+        }
+
+        try {
+            connect.request(request);
+        } catch (RequestException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @EventListener
+    public void onMessage(MessageEvent event) {
+        plugin.doAsync(() -> {
+            try {
+                String channel = event.getChannel();
+                String message = event.getMessageAsString();
+
+                onMessage(channel, message, null);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        });
+    }
+}
@@ -20,24 +20,35 @@
 *  SOFTWARE.
 */

-package me.lucko.luckperms.common.commands.migration.subcommands;
+package me.lucko.luckperms.bukkit.migration;

-import de.bananaco.bpermissions.api.*;
-import me.lucko.luckperms.api.Logger;
-import me.lucko.luckperms.common.LuckPermsPlugin;
+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 me.lucko.luckperms.api.MetaUtils;
+import me.lucko.luckperms.api.event.cause.CreationCause;
+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.constants.Constants;
-import me.lucko.luckperms.common.core.PermissionHolder;
-import me.lucko.luckperms.common.data.LogEntry;
-import me.lucko.luckperms.common.utils.ArgumentChecker;
-import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.common.commands.sender.Sender;
+import me.lucko.luckperms.common.core.model.PermissionHolder;
+import me.lucko.luckperms.common.core.model.User;
+import me.lucko.luckperms.common.plugin.LuckPermsPlugin;
+import me.lucko.luckperms.common.utils.Predicates;
+import me.lucko.luckperms.common.utils.ProgressLogger;

 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 java.util.concurrent.atomic.AtomicInteger;

 import static me.lucko.luckperms.common.constants.Permission.MIGRATION;

@@ -55,6 +66,101 @@ 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 {
+        ProgressLogger log = new ProgressLogger("bPermissions");
+        log.addListener(plugin.getConsoleSender());
+        log.addListener(sender);
+
+        log.log("Starting.");
+
+        WorldManager worldManager = WorldManager.getInstance();
+        if (worldManager == null) {
+            log.logErr("Plugin not loaded.");
+            return CommandResult.STATE_ERROR;
+        }
+
+        log.log("Forcing the plugin to load all data. This could take a while.");
+        for (World world : worldManager.getAllWorlds()) {
+            log.log("Loading users in world " + world.getName());
+            Set<String> users = getUsers(world);
+            if (users == null) {
+                log.logErr("Couldn't get a list of users.");
+                return CommandResult.FAILURE;
+            }
+            AtomicInteger userLoadCount = new AtomicInteger(0);
+            users.forEach(s -> {
+                world.loadOne(s, CalculableType.USER);
+                log.logProgress("Forcefully loaded {} users so far.", userLoadCount.incrementAndGet());
+            });
+        }
+        log.log("Forcefully loaded all users.");
+
+        // Migrate one world at a time.
+        log.log("Starting world migration.");
+        for (World world : worldManager.getAllWorlds()) {
+            log.log("Migrating world: " + world.getName());
+
+            // Migrate all groups
+            log.log("Starting group migration in world " + world.getName() + ".");
+            AtomicInteger groupCount = new AtomicInteger(0);
+            for (Calculable group : world.getAll(CalculableType.GROUP)) {
+                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, CreationCause.INTERNAL).join();
+                me.lucko.luckperms.common.core.model.Group lpGroup = plugin.getGroupManager().getIfLoaded(groupName);
+
+                migrateHolder(log, world, group, lpGroup);
+                plugin.getStorage().saveGroup(lpGroup);
+
+                log.logAllProgress("Migrated {} groups so far.", groupCount.incrementAndGet());
+            }
+            log.log("Migrated " + groupCount.get() + " groups in world " + world.getName() + ".");
+
+            // Migrate all users
+            log.log("Starting user migration in world " + world.getName() + ".");
+            AtomicInteger userCount = new AtomicInteger(0);
+            for (Calculable user : world.getAll(CalculableType.USER)) {
+                // 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.getUuidFromUsername(user.getName());
+                }
+
+                if (uuid == null) {
+                    log.logErr("Unable to migrate user " + user.getName() + ". Cannot 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(log, world, user, lpUser);
+
+                plugin.getStorage().saveUser(lpUser);
+                plugin.getUserManager().cleanup(lpUser);
+
+                log.logProgress("Migrated {} users so far.", userCount.incrementAndGet());
+            }
+
+            log.log("Migrated " + userCount.get() + " users in world " + world.getName() + ".");
+        }
+
+        log.log("Success! Migration complete.");
+        return CommandResult.SUCCESS;
+    }
+
    @SuppressWarnings("unchecked")
    private static Set<String> getUsers(World world) {
        try {
@@ -81,125 +187,21 @@ 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) {
+    private static void migrateHolder(ProgressLogger log, World world, Calculable c, PermissionHolder holder) {
        // Migrate the groups permissions in this world
        for (Permission p : c.getPermissions()) {
            try {
                holder.setPermission(p.name(), p.isTrue(), "global", world.getName());
-                LogEntry.build()
-                        .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
-                        .acted(holder).action("set " + p.name() + " " + p.isTrue() + " global " + world.getName())
-                        .build().submit(plugin);
            } catch (Exception ex) {
-                if (!(ex instanceof ObjectAlreadyHasException)) {
-                    ex.printStackTrace();
-                }
+                log.handleException(ex);
            }

            // Include any child permissions
            for (Map.Entry<String, Boolean> child : p.getChildren().entrySet()) {
                try {
                    holder.setPermission(child.getKey(), child.getValue(), "global", world.getName());
-                    LogEntry.build()
-                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
-                            .acted(holder).action("set " + child.getKey() + " " + child.getValue() + " global " + world.getName())
-                            .build().submit(plugin);
                } catch (Exception ex) {
-                    if (!(ex instanceof ObjectAlreadyHasException)) {
-                        ex.printStackTrace();
-                    }
+                    log.handleException(ex);
                }
            }
        }
@@ -208,46 +210,29 @@ public class MigrationBPermissions extends SubCommand<Object> {
        for (Group parent : c.getGroups()) {
            try {
                holder.setPermission("group." + parent.getName(), true, "global", world.getName());
-                LogEntry.build()
-                        .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
-                        .acted(holder).action("setinherit " + parent.getName() + " global " + world.getName())
-                        .build().submit(plugin);
            } catch (Exception ex) {
-                if (!(ex instanceof ObjectAlreadyHasException)) {
-                    ex.printStackTrace();
-                }
+                log.handleException(ex);
            }
        }

        // 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()
-                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
-                            .acted(holder).action("set " + meta.getKey().toLowerCase() + "." + c.getPriority() + "." + chatMeta + " true")
-                            .build().submit(plugin);
                } catch (Exception ex) {
-                    if (!(ex instanceof ObjectAlreadyHasException)) {
-                        ex.printStackTrace();
-                    }
+                    log.handleException(ex);
                }
                continue;
            }

            try {
                holder.setPermission("meta." + meta.getKey() + "." + meta.getValue(), true, "global", world.getName());
-                LogEntry.build()
-                        .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
-                        .acted(holder).action("set meta." + meta.getKey() + "." + meta.getValue() + " true global " + world.getName())
-                        .build().submit(plugin);
            } catch (Exception ex) {
-                if (!(ex instanceof ObjectAlreadyHasException)) {
-                    ex.printStackTrace();
-                }
+                log.handleException(ex);
            }
        }
    }
+
 }
@@ -0,0 +1,282 @@
+/*
+ * 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 com.google.common.collect.Maps;
+
+import me.lucko.luckperms.api.event.cause.CreationCause;
+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.Permission;
+import me.lucko.luckperms.common.plugin.LuckPermsPlugin;
+import me.lucko.luckperms.common.utils.Predicates;
+import me.lucko.luckperms.common.utils.ProgressLogger;
+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;
+import org.anjocaido.groupmanager.data.User;
+import org.anjocaido.groupmanager.dataholder.WorldDataHolder;
+import org.anjocaido.groupmanager.dataholder.worlds.WorldsHolder;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+public class MigrationGroupManager extends SubCommand<Object> {
+    public MigrationGroupManager() {
+        super("groupmanager", "Migration from GroupManager", Permission.MIGRATION, Predicates.is(0),
+                Arg.list(Arg.create("migrate as global", true, "if world permissions should be ignored, and just migrated as global"))
+        );
+    }
+
+    @Override
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List<String> args, String label) throws CommandException {
+        ProgressLogger log = new ProgressLogger("GroupManager");
+        log.addListener(plugin.getConsoleSender());
+        log.addListener(sender);
+
+        log.log("Starting.");
+
+        if (!args.get(0).equalsIgnoreCase("true") && !args.get(0).equalsIgnoreCase("false")) {
+            log.logErr("Was expecting true/false, but got " + args.get(0) + " instead.");
+            return CommandResult.STATE_ERROR;
+        }
+        boolean migrateAsGlobal = Boolean.parseBoolean(args.get(0));
+        final Function<String, String> worldMappingFunc = s -> migrateAsGlobal ? "" : s;
+        
+        if (!Bukkit.getPluginManager().isPluginEnabled("GroupManager")) {
+            log.logErr("Plugin not loaded.");
+            return CommandResult.STATE_ERROR;
+        }
+
+        List<String> worlds = Bukkit.getWorlds().stream().map(World::getName).map(String::toLowerCase).collect(Collectors.toList());
+
+        GroupManager gm = (GroupManager) Bukkit.getPluginManager().getPlugin("GroupManager");
+
+        // Migrate Global Groups
+        log.log("Starting global group migration.");
+        GlobalGroups gg = GroupManager.getGlobalGroups();
+
+        AtomicInteger globalGroupCount = new AtomicInteger(0);
+        for (Group g : gg.getGroupList()) {
+            plugin.getStorage().createAndLoadGroup(g.getName().toLowerCase(), CreationCause.INTERNAL).join();
+            me.lucko.luckperms.common.core.model.Group group = plugin.getGroupManager().getIfLoaded(g.getName().toLowerCase());
+
+            for (String node : g.getPermissionList()) {
+                boolean value = true;
+                if (node.startsWith("!") || node.startsWith("-")) {
+                    node = node.substring(1);
+                    value = false;
+                } else if (node.startsWith("+")) {
+                    node = node.substring(1);
+                    value = true;
+                }
+
+                try {
+                    group.setPermission(node, value);
+                } catch (Exception ex) {
+                    log.handleException(ex);
+                }
+            }
+
+            for (String s : g.getInherits()) {
+                try {
+                    group.setPermission("group." + s.toLowerCase(), true);
+                } catch (Exception ex) {
+                    log.handleException(ex);
+                }
+            }
+
+            plugin.getStorage().saveGroup(group);
+            log.logAllProgress("Migrated {} groups so far.", globalGroupCount.incrementAndGet());
+        }
+        log.log("Migrated " + globalGroupCount.get() + " global groups");
+
+        // Collect data
+
+        // UUID --> Map<Entry<String, String>, Boolean> where k=world, v = node
+        Map<UUID, Map<Map.Entry<String, String>, Boolean>> users = new HashMap<>();
+        // UUID --> primary group name
+        Map<UUID, String> primaryGroups = new HashMap<>();
+
+        // String --> Map<Entry<String, String>, Boolean> where k=world, v = node
+        Map<String, Map<Map.Entry<String, String>, Boolean>> groups = new HashMap<>();
+
+        WorldsHolder wh = gm.getWorldsHolder();
+
+        // Collect data for all users and groups.
+        log.log("Collecting user and group data.");
+        for (String world : worlds) {
+            world = world.toLowerCase();
+            log.log("Querying world " + world);
+
+            WorldDataHolder wdh = wh.getWorldData(world);
+
+            AtomicInteger groupWorldCount = new AtomicInteger(0);
+            for (Group g : wdh.getGroupList()) {
+                groups.putIfAbsent(g.getName().toLowerCase(), new HashMap<>());
+
+                for (String node : g.getPermissionList()) {
+                    boolean value = true;
+                    if (node.startsWith("!") || node.startsWith("-")) {
+                        node = node.substring(1);
+                        value = false;
+                    } else if (node.startsWith("+")) {
+                        node = node.substring(1);
+                        value = true;
+                    }
+
+                    groups.get(g.getName().toLowerCase()).put(Maps.immutableEntry(worldMappingFunc.apply(world), node), value);
+                }
+
+                for (String s : g.getInherits()) {
+                    groups.get(g.getName().toLowerCase()).put(Maps.immutableEntry(worldMappingFunc.apply(world), "group." + s.toLowerCase()), true);
+                }
+                log.logAllProgress("Migrated {} groups so far in world " + world, groupWorldCount.incrementAndGet());
+            }
+            log.log("Migrated " + groupWorldCount.get() + " groups in world " + world);
+
+            AtomicInteger userWorldCount = new AtomicInteger(0);
+            for (User user : wdh.getUserList()) {
+                UUID uuid;
+                try {
+                    uuid = UUID.fromString(user.getUUID());
+                } catch (IllegalArgumentException e) {
+                    log.logErr("Could not parse UUID for user: " + user.getUUID());
+                    continue;
+                }
+
+                users.putIfAbsent(uuid, new HashMap<>());
+
+                for (String node : user.getPermissionList()) {
+                    boolean value = true;
+                    if (node.startsWith("!") || node.startsWith("-")) {
+                        node = node.substring(1);
+                        value = false;
+                    } else if (node.startsWith("+")) {
+                        node = node.substring(1);
+                        value = true;
+                    }
+
+                    users.get(uuid).put(Maps.immutableEntry(worldMappingFunc.apply(world), node), value);
+                }
+
+                String finalWorld = worldMappingFunc.apply(world);
+
+                // Collect sub groups
+                users.get(uuid).putAll(user.subGroupListStringCopy().stream()
+                        .map(n -> "group." + n)
+                        .map(n -> Maps.immutableEntry(finalWorld, n))
+                        .collect(Collectors.toMap(n -> n, n -> true))
+                );
+                primaryGroups.put(uuid, user.getGroupName());
+
+                log.logProgress("Migrated {} users so far in world " + world, userWorldCount.incrementAndGet());
+            }
+            log.log("Migrated " + userWorldCount.get() + " users in world " + world);
+
+        }
+
+        log.log("All data has now been processed, now starting the import process.");
+        log.log("Found a total of " + users.size() + " users and " + groups.size() + " groups.");
+
+        log.log("Starting group migration.");
+        AtomicInteger groupCount = new AtomicInteger(0);
+        for (Map.Entry<String, Map<Map.Entry<String, String>, Boolean>> e : groups.entrySet()) {
+            plugin.getStorage().createAndLoadGroup(e.getKey(), CreationCause.INTERNAL).join();
+            me.lucko.luckperms.common.core.model.Group group = plugin.getGroupManager().getIfLoaded(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 {
+                    if (n.getKey().getKey().equals("")) {
+                        group.setPermission(n.getKey().getValue(), n.getValue());
+                    } else {
+                        group.setPermission(n.getKey().getValue(), n.getValue(), "global", n.getKey().getKey());
+                    }
+                } catch (Exception ex) {
+                    log.handleException(ex);
+                }
+            }
+
+            plugin.getStorage().saveGroup(group);
+            log.logAllProgress("Migrated {} groups so far.", groupCount.incrementAndGet());
+        }
+        log.log("Migrated " + groupCount.get() + " groups");
+
+        log.log("Starting user migration.");
+        AtomicInteger userCount = new AtomicInteger(0);
+        for (Map.Entry<UUID, Map<Map.Entry<String, String>, Boolean>> e : users.entrySet()) {
+            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 {
+                    if (n.getKey().getKey().equals("")) {
+                        user.setPermission(n.getKey().getValue(), n.getValue());
+                    } else {
+                        user.setPermission(n.getKey().getValue(), n.getValue(), "global", n.getKey().getKey());
+                    }
+                } catch (Exception ex) {
+                    log.handleException(ex);
+                }
+            }
+
+            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);
+            log.logProgress("Migrated {} users so far.", userCount.incrementAndGet());
+        }
+
+        log.log("Migrated " + userCount.get() + " users.");
+        log.log("Success! Migration complete.");
+        return CommandResult.SUCCESS;
+    }
+}
@@ -0,0 +1,312 @@
+/*
+ * 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.MetaUtils;
+import me.lucko.luckperms.api.event.cause.CreationCause;
+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.model.Group;
+import me.lucko.luckperms.common.core.model.User;
+import me.lucko.luckperms.common.plugin.LuckPermsPlugin;
+import me.lucko.luckperms.common.utils.Predicates;
+import me.lucko.luckperms.common.utils.ProgressLogger;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
+
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+
+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.util.List;
+import java.util.UUID;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Collectors;
+
+public class MigrationPermissionsEx extends SubCommand<Object> {
+    public MigrationPermissionsEx() {
+        super("permissionsex", "Migration from PermissionsEx", Permission.MIGRATION, Predicates.alwaysFalse(), null);
+    }
+
+    @SuppressWarnings("deprecation")
+    @Override
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List<String> args, String label) throws CommandException {
+        ProgressLogger log = new ProgressLogger("PermissionsEx");
+        log.addListener(plugin.getConsoleSender());
+        log.addListener(sender);
+
+        log.log("Starting.");
+
+        if (!Bukkit.getPluginManager().isPluginEnabled("PermissionsEx")) {
+            log.logErr("Plugin not loaded.");
+            return CommandResult.STATE_ERROR;
+        }
+
+        List<String> worlds = Bukkit.getWorlds().stream().map(World::getName).map(String::toLowerCase).collect(Collectors.toList());
+
+        PermissionsEx pex = (PermissionsEx) Bukkit.getPluginManager().getPlugin("PermissionsEx");
+        PermissionManager manager = pex.getPermissionsManager();
+
+        NativeInterface ni;
+        try {
+            Field f = manager.getClass().getDeclaredField("nativeI");
+            f.setAccessible(true);
+            ni = (NativeInterface) f.get(manager);
+        } catch (Throwable t) {
+            t.printStackTrace();
+            return CommandResult.FAILURE;
+        }
+
+        log.log("Calculating group weightings.");
+        int maxWeight = 0;
+        for (PermissionGroup group : manager.getGroupList()) {
+            maxWeight = Math.max(maxWeight, group.getRank());
+        }
+        maxWeight += 5;
+
+        // Migrate all groups.
+        log.log("Starting group migration.");
+        AtomicInteger groupCount = new AtomicInteger(0);
+        for (PermissionGroup group : manager.getGroupList()) {
+            int groupWeight = maxWeight - group.getRank();
+
+            final String name = group.getName().toLowerCase();
+            plugin.getStorage().createAndLoadGroup(name, CreationCause.INTERNAL).join();
+            Group lpGroup = plugin.getGroupManager().getIfLoaded(name);
+
+            try {
+                for (String node : group.getOwnPermissions(null)) {
+                    boolean value = true;
+                    if (node.startsWith("-")) {
+                        node = node.substring(1);
+                        value = false;
+                    }
+
+                    try {
+                        lpGroup.setPermission(node, value);
+                    } catch (Exception ex) {
+                        log.handleException(ex);
+                    }
+                }
+            } catch (NullPointerException ignored) {
+                // No docs on if #getOwnPermissions(null) is ok. Should be fine though.
+            }
+
+            for (String world : worlds) {
+                for (String node : group.getOwnPermissions(world)) {
+                    boolean value = true;
+                    if (node.startsWith("-")) {
+                        node = node.substring(1);
+                        value = false;
+                    }
+
+                    try {
+                        lpGroup.setPermission(node, value, "global", world.toLowerCase());
+                    } catch (Exception ex) {
+                        log.handleException(ex);
+                    }
+                }
+            }
+
+            for (PermissionGroup g : group.getParents()) {
+                try {
+                    lpGroup.setPermission("group." + g.getName().toLowerCase(), true);
+                } catch (Exception ex) {
+                    log.handleException(ex);
+                }
+            }
+
+            for (String world : worlds) {
+                for (PermissionGroup g : group.getParents(world)) {
+                    try {
+                        lpGroup.setPermission("group." + g.getName().toLowerCase(), true, "global", world.toLowerCase());
+                    } catch (Exception ex) {
+                        log.handleException(ex);
+                    }
+                }
+            }
+
+            String prefix = group.getOwnPrefix();
+            String suffix = group.getOwnSuffix();
+
+            if (prefix != null && !prefix.equals("")) {
+                prefix = MetaUtils.escapeCharacters(prefix);
+                try {
+                    lpGroup.setPermission("prefix." + groupWeight + "." + prefix, true);
+                } catch (Exception ex) {
+                    log.handleException(ex);
+                }
+            }
+
+            if (suffix != null && !suffix.equals("")) {
+                suffix = MetaUtils.escapeCharacters(suffix);
+                try {
+                    lpGroup.setPermission("suffix." + groupWeight + "." + suffix, true);
+                } catch (Exception ex) {
+                    log.handleException(ex);
+                }
+            }
+
+            plugin.getStorage().saveGroup(lpGroup);
+            log.logAllProgress("Migrated {} groups so far.", groupCount.incrementAndGet());
+        }
+        log.log("Migrated " + groupCount.get() + " groups");
+
+        // Migrate all users
+        log.log("Starting user migration.");
+        AtomicInteger userCount = new AtomicInteger(0);
+
+        // Increment the max weight from the group migrations. All user meta should override.
+        maxWeight += 5;
+
+        for (PermissionUser user : manager.getUsers()) {
+            UUID u;
+            try {
+                u = UUID.fromString(user.getIdentifier());
+            } catch (IllegalArgumentException e) {
+                u = ni.nameToUUID(user.getIdentifier());
+                if (u == null) {
+                    u = plugin.getUuidFromUsername(user.getIdentifier());
+                }
+            }
+
+            if (u == null) {
+                log.logErr("Unable to get a UUID for user identifier: " + user.getIdentifier());
+                continue;
+            }
+
+            plugin.getStorage().loadUser(u, user.getName()).join();
+            User lpUser = plugin.getUserManager().get(u);
+
+            try {
+                for (String node : user.getOwnPermissions(null)) {
+                    boolean value = true;
+                    if (node.startsWith("-")) {
+                        node = node.substring(1);
+                        value = false;
+                    }
+
+                    try {
+                        lpUser.setPermission(node, value);
+                    } catch (Exception ex) {
+                        log.handleException(ex);
+                    }
+                }
+            } catch (NullPointerException ignored) {
+                // No docs on if #getOwnPermissions(null) is ok. Should be fine though.
+            }
+
+            for (String world : worlds) {
+                for (String node : user.getOwnPermissions(world)) {
+                    boolean value = true;
+                    if (node.startsWith("-")) {
+                        node = node.substring(1);
+                        value = false;
+                    }
+
+                    try {
+                        lpUser.setPermission(node, value, "global", world.toLowerCase());
+                    } catch (Exception ex) {
+                        log.handleException(ex);
+                    }
+                }
+            }
+
+            for (String s : user.getGroupNames()) {
+                try {
+                    lpUser.setPermission("group." + s.toLowerCase(), true);
+                } catch (Exception ex) {
+                    log.handleException(ex);
+                }
+            }
+
+            for (String world : worlds) {
+                for (String s : user.getGroupNames(world)) {
+                    try {
+                        lpUser.setPermission("group." + s.toLowerCase(), true, "global", world.toLowerCase());
+                    } catch (Exception ex) {
+                        log.handleException(ex);
+                    }
+                }
+            }
+
+            String prefix = user.getOwnPrefix();
+            String suffix = user.getOwnSuffix();
+
+            if (prefix != null && !prefix.equals("")) {
+                prefix = MetaUtils.escapeCharacters(prefix);
+                try {
+                    lpUser.setPermission("prefix." + maxWeight + "." + prefix, true);
+                } catch (Exception ex) {
+                    log.handleException(ex);
+                }
+            }
+
+            if (suffix != null && !suffix.equals("")) {
+                suffix = MetaUtils.escapeCharacters(suffix);
+                try {
+                    lpUser.setPermission("suffix." + maxWeight + "." + suffix, true);
+                } catch (Exception ex) {
+                    log.handleException(ex);
+                }
+            }
+
+            // Lowest rank is the highest group #logic
+            String primary = null;
+            int weight = Integer.MAX_VALUE;
+            for (PermissionGroup group : user.getOwnParents()) {
+                if (group.getRank() < weight) {
+                    primary = group.getName();
+                    weight = group.getRank();
+                }
+            }
+
+            if (primary != null && !primary.equalsIgnoreCase("default")) {
+                try {
+                    lpUser.setPermission("group." + primary.toLowerCase(), true);
+                } catch (ObjectAlreadyHasException ignored) {}
+                lpUser.setPrimaryGroup(primary);
+                try {
+                    lpUser.unsetPermission("group.default");
+                } catch (ObjectLacksException ignored) {}
+            }
+
+            plugin.getUserManager().cleanup(lpUser);
+            plugin.getStorage().saveUser(lpUser);
+            log.logProgress("Migrated {} users so far.", userCount.incrementAndGet());
+        }
+
+        log.log("Migrated " + userCount.get() + " users.");
+        log.log("Success! Migration complete.");
+        return CommandResult.SUCCESS;
+    }
+}
@@ -20,22 +20,31 @@
 *  SOFTWARE.
 */

-package me.lucko.luckperms.common.commands.migration.subcommands;
+package me.lucko.luckperms.bukkit.migration;

-import com.github.cheesesoftware.PowerfulPermsAPI.*;
+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.common.LuckPermsPlugin;
-import me.lucko.luckperms.common.commands.*;
-import me.lucko.luckperms.common.commands.migration.subcommands.utils.LPResultRunnable;
-import me.lucko.luckperms.common.constants.Constants;
-import me.lucko.luckperms.common.core.PermissionHolder;
-import me.lucko.luckperms.common.data.LogEntry;
-import me.lucko.luckperms.common.users.User;
-import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+
+import me.lucko.luckperms.api.event.cause.CreationCause;
+import me.lucko.luckperms.bukkit.migration.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.core.model.PermissionHolder;
+import me.lucko.luckperms.common.core.model.User;
+import me.lucko.luckperms.common.plugin.LuckPermsPlugin;
+import me.lucko.luckperms.common.utils.Predicates;
+import me.lucko.luckperms.common.utils.ProgressLogger;
+
+import org.bukkit.Bukkit;

 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
@@ -43,28 +52,27 @@ 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;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Consumer;

 import static me.lucko.luckperms.common.constants.Permission.MIGRATION;

-@SuppressWarnings("unchecked")
+
 public class MigrationPowerfulPerms extends SubCommand<Object> {
-    /* <sadness>
-        The PowerfulPerms API is a complete joke. Seriously, it would probably be easier reflecting into the actual plugin.
-        Methods move about randomly every version...
-
-        What kind of API requires reflection to function with multiple versions...
-        Doesn't that just defeat the whole god damn point of having an API in the first place?
-        Whatever happened to depreciation?
-    </sadness> */
-
    private static Method getPlayerPermissionsMethod = null;
    private static Method getPlayerGroupsMethod = null;
    private static Method getGroupMethod = null;

-    // lol
+    // lol, nice "api"
    private static boolean superLegacy = false;
    private static boolean legacy = false;

@@ -114,9 +122,8 @@ public class MigrationPowerfulPerms extends SubCommand<Object> {
        }
    }

-
    public MigrationPowerfulPerms() {
-        super("powerfulperms", "Migration from PowerfulPerms", MIGRATION, Predicate.not(5),
+        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"),
@@ -128,55 +135,24 @@ public class MigrationPowerfulPerms extends SubCommand<Object> {
    }

    @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 {
        try {
-            return run(plugin, args);
+            return run(plugin, sender, args);
        } catch (Throwable t) {
            t.printStackTrace();
            return CommandResult.FAILURE;
        }
    }

-    private static void getPlayerPermissions(PermissionManager manager, UUID uuid, Callback<List<Permission>> callback) {
-        if (legacy) {
-            try {
-                getPlayerPermissionsMethod.invoke(manager, uuid, new LPResultRunnable<List<Permission>>() {
-                    @Override
-                    public void run() {
-                        callback.onComplete(getResult());
-                    }
-                });
-            } catch (IllegalAccessException | InvocationTargetException e) {
-                e.printStackTrace();
-            }
-        } else {
-            try {
-                ListenableFuture<List<Permission>> lf = (ListenableFuture<List<Permission>>) getPlayerPermissionsMethod.invoke(manager, uuid);
-                try {
-                    if (lf.isDone()) {
-                        callback.onComplete(lf.get());
-                    } else {
-                        lf.addListener(() -> {
-                            try {
-                                callback.onComplete(lf.get());
-                            } catch (InterruptedException | ExecutionException e) {
-                                e.printStackTrace();
-                            }
-                        }, Runnable::run);
-                    }
-                } catch (InterruptedException | ExecutionException e) {
-                    e.printStackTrace();
-                }
-            } catch (IllegalAccessException | InvocationTargetException e) {
-                e.printStackTrace();
-            }
-        }
-    }
+    private CommandResult run(LuckPermsPlugin plugin, Sender sender, List<String> args) {
+        ProgressLogger log = new ProgressLogger("PowerfulPerms");
+        log.addListener(plugin.getConsoleSender());
+        log.addListener(sender);

-    private CommandResult run(LuckPermsPlugin plugin, List<String> args) {
-        final Logger log = plugin.getLog();
-        if (!plugin.isPluginLoaded("PowerfulPerms")) {
-            log.severe("PowerfulPerms Migration: Error -> PowerfulPerms is not loaded.");
+        log.log("Starting.");
+        
+        if (!Bukkit.getPluginManager().isPluginEnabled("PowerfulPerms")) {
+            log.logErr("PowerfulPerms is not loaded.");
            return CommandResult.STATE_ERROR;
        }

@@ -187,100 +163,90 @@ public class MigrationPowerfulPerms extends SubCommand<Object> {
        final String dbTable = args.get(4);

        // Find a list of UUIDs
-        log.info("PowerfulPerms Migration: Getting a list of UUIDs to migrate.");
-
-        @Cleanup HikariDataSource hikari = new HikariDataSource();
-        hikari.setMaximumPoolSize(2);
-        hikari.setDataSourceClassName("com.mysql.jdbc.jdbc2.optional.MysqlDataSource");
-        hikari.addDataSourceProperty("serverName", address.split(":")[0]);
-        hikari.addDataSourceProperty("port", address.split(":")[1]);
-        hikari.addDataSourceProperty("databaseName", database);
-        hikari.addDataSourceProperty("user", username);
-        hikari.addDataSourceProperty("password", password);
-
+        log.log("Getting a list of UUIDs to migrate.");
        Set<UUID> uuids = new HashSet<>();

-        try {
-            @Cleanup Connection connection = hikari.getConnection();
-            DatabaseMetaData meta = connection.getMetaData();
+        try (HikariDataSource hikari = new HikariDataSource()) {
+            hikari.setMaximumPoolSize(2);
+            hikari.setDataSourceClassName("com.mysql.jdbc.jdbc2.optional.MysqlDataSource");
+            hikari.addDataSourceProperty("serverName", address.split(":")[0]);
+            hikari.addDataSourceProperty("port", address.split(":")[1]);
+            hikari.addDataSourceProperty("databaseName", database);
+            hikari.addDataSourceProperty("user", username);
+            hikari.addDataSourceProperty("password", password);

-            @Cleanup ResultSet tables = meta.getTables(null, null, dbTable, null);
-            if (!tables.next()) {
-                log.severe("PowerfulPerms Migration: Error - Couldn't find table.");
-                return CommandResult.FAILURE;
+            try (Connection c = hikari.getConnection()) {
+                DatabaseMetaData meta = c.getMetaData();

-            } else {
-                @Cleanup PreparedStatement columnPs = connection.prepareStatement("SELECT COLUMN_NAME, COLUMN_TYPE FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME=?");
-                columnPs.setString(1, dbTable);
-                @Cleanup ResultSet columnRs = columnPs.executeQuery();
-
-                log.info("Found table: " + dbTable);
-                while (columnRs.next()) {
-                    log.info("" + columnRs.getString("COLUMN_NAME") + " - " + columnRs.getString("COLUMN_TYPE"));
-                }
-
-                @Cleanup PreparedStatement preparedStatement = connection.prepareStatement("SELECT `uuid` FROM " + dbTable);
-                @Cleanup ResultSet resultSet = preparedStatement.executeQuery();
-
-                while (resultSet.next()) {
-                    uuids.add(UUID.fromString(resultSet.getString("uuid")));
+                try (ResultSet rs = meta.getTables(null, null, dbTable, null)) {
+                    if (!rs.next()) {
+                        log.log("Error - Couldn't find table.");
+                        return CommandResult.FAILURE;
+                    }
                }
            }

+            try (Connection c = hikari.getConnection()) {
+                try (PreparedStatement ps = c.prepareStatement("SELECT COLUMN_NAME, COLUMN_TYPE FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME=?")) {
+                    ps.setString(1, dbTable);
+
+                    try (ResultSet rs = ps.executeQuery()) {
+                        log.log("Found table: " + dbTable);
+                        while (rs.next()) {
+                            log.log("" + rs.getString("COLUMN_NAME") + " - " + rs.getString("COLUMN_TYPE"));
+                        }
+                    }
+                }
+
+                try (PreparedStatement ps = c.prepareStatement("SELECT `uuid` FROM " + dbTable)) {
+                    try (ResultSet rs = ps.executeQuery()) {
+                        while (rs.next()) {
+                            uuids.add(UUID.fromString(rs.getString("uuid")));
+                        }
+                    }
+                }
+            }
        } catch (Exception e) {
            e.printStackTrace();
-            return CommandResult.FAILURE;
        }

        if (uuids.isEmpty()) {
-            log.severe("PowerfulPerms Migration: Error - Unable to find any UUIDs to migrate.");
+            log.logErr("Unable to find any UUIDs to migrate.");
            return CommandResult.FAILURE;
        }

-        log.info("PowerfulPerms Migration: Found " + uuids.size() + " uuids. Starting migration.");
+        log.log("Found " + uuids.size() + " uuids. Starting migration.");

-        PowerfulPermsPlugin ppPlugin = (PowerfulPermsPlugin) plugin.getPlugin("PowerfulPerms");
+        PowerfulPermsPlugin ppPlugin = (PowerfulPermsPlugin) Bukkit.getPluginManager().getPlugin("PowerfulPerms");
        PermissionManager pm = ppPlugin.getPermissionManager();

        // Groups first.
-        log.info("PowerfulPerms Migration: Starting group migration.");
+        log.log("Starting group migration.");
+        AtomicInteger groupCount = new AtomicInteger(0);
        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());
-            try {
-                LogEntry.build()
-                        .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
-                        .acted(group).action("create")
-                        .build().submit(plugin);
-            } catch (Exception ex) {
-                ex.printStackTrace();
-            }
+            plugin.getStorage().createAndLoadGroup(g.getName().toLowerCase(), CreationCause.INTERNAL).join();
+            final me.lucko.luckperms.common.core.model.Group group = plugin.getGroupManager().getIfLoaded(g.getName().toLowerCase());

            for (Permission p : g.getOwnPermissions()) { // All versions
-                applyPerm(group, p, plugin);
+                applyPerm(group, p, log);
            }

            for (Group parent : g.getParents()) { // All versions
                try {
                    group.setPermission("group." + parent.getName().toLowerCase(), true);
-                    LogEntry.build()
-                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
-                            .acted(group).action("setinherit " + parent.getName().toLowerCase()) // All versions
-                            .build().submit(plugin);
                } catch (Exception ex) {
-                    if (!(ex instanceof ObjectAlreadyHasException)) {
-                        ex.printStackTrace();
-                    }
+                    log.handleException(ex);
                }
            }

-            plugin.getDatastore().saveGroup(group);
+            plugin.getStorage().saveGroup(group);
+            log.logAllProgress("Migrated {} groups so far.", groupCount.incrementAndGet());
        }
-        log.info("PowerfulPerms Migration: Group migration complete.");
+        log.log("Migrated " + groupCount.get() + " groups");

        // Now users.
-        log.info("PowerfulPerms Migration: Starting user migration.");
+        log.log("Starting user migration.");
        final Map<UUID, CountDownLatch> progress = new HashMap<>();

        // Migrate all users and their groups
@@ -288,25 +254,25 @@ 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.
            getPlayerPermissions(pm, uuid, perms -> { // Changes each version
-                perms.forEach(p -> applyPerm(user, p, plugin));
+                perms.forEach(p -> applyPerm(user, p, log));

                // Update the progress so the user can be saved and unloaded.
                synchronized (progress) {
                    progress.get(uuid).countDown();
                    if (progress.get(uuid).getCount() == 0) {
-                        plugin.getDatastore().saveUser(user);
+                        plugin.getStorage().saveUser(user);
                        plugin.getUserManager().cleanup(user);
                    }
                }
            });

            // Migrate the user's groups to LuckPerms from PP.
-            Callback<Map<String, List<CachedGroup>>> callback = groups1 -> {
+            Consumer<Map<String, List<CachedGroup>>> callback = groups1 -> {
                for (Map.Entry<String, List<CachedGroup>> e : groups1.entrySet()) {
                    final String server;
                    if (e.getKey() != null && (e.getKey().equals("") || e.getKey().equalsIgnoreCase("all"))) {
@@ -331,26 +297,14 @@ public class MigrationPowerfulPerms extends SubCommand<Object> {
                                        if (server == null) {
                                            try {
                                                user.setPermission("group." + g.getName().toLowerCase(), true);
-                                                LogEntry.build()
-                                                        .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
-                                                        .acted(user).action("addgroup " + g.getName().toLowerCase())
-                                                        .build().submit(plugin);
                                            } catch (Exception ex) {
-                                                if (!(ex instanceof ObjectAlreadyHasException)) {
-                                                    ex.printStackTrace();
-                                                }
+                                                log.handleException(ex);
                                            }
                                        } else {
                                            try {
                                                user.setPermission("group." + g.getName().toLowerCase(), true, server);
-                                                LogEntry.build()
-                                                        .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
-                                                        .acted(user).action("addgroup " + g.getName().toLowerCase() + " " + server)
-                                                        .build().submit(plugin);
                                            } catch (Exception ex) {
-                                                if (!(ex instanceof ObjectAlreadyHasException)) {
-                                                    ex.printStackTrace();
-                                                }
+                                                log.handleException(ex);
                                            }
                                        }
                                    }
@@ -364,26 +318,14 @@ public class MigrationPowerfulPerms extends SubCommand<Object> {
                                        if (server == null) {
                                            try {
                                                user.setPermission("group." + group.getName().toLowerCase(), true, g.getExpirationDate().getTime() / 1000L);
-                                                LogEntry.build()
-                                                        .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
-                                                        .acted(user).action("addtempgroup " + group.getName().toLowerCase() + " " + g.getExpirationDate().getTime() / 1000L)
-                                                        .build().submit(plugin);
                                            } catch (Exception ex) {
-                                                if (!(ex instanceof ObjectAlreadyHasException)) {
-                                                    ex.printStackTrace();
-                                                }
+                                                log.handleException(ex);
                                            }
                                        } else {
                                            try {
                                                user.setPermission("group." + group.getName().toLowerCase(), true, server, g.getExpirationDate().getTime() / 1000L);
-                                                LogEntry.build()
-                                                        .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
-                                                        .acted(user).action("addtempgroup " + group.getName().toLowerCase() + " " + g.getExpirationDate().getTime() / 1000L + " " + server)
-                                                        .build().submit(plugin);
                                            } catch (Exception ex) {
-                                                if (!(ex instanceof ObjectAlreadyHasException)) {
-                                                    ex.printStackTrace();
-                                                }
+                                                log.handleException(ex);
                                            }
                                        }

@@ -391,26 +333,14 @@ public class MigrationPowerfulPerms extends SubCommand<Object> {
                                        if (server == null) {
                                            try {
                                                user.setPermission("group." + group.getName().toLowerCase(), true);
-                                                LogEntry.build()
-                                                        .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
-                                                        .acted(user).action("addgroup " + group.getName().toLowerCase())
-                                                        .build().submit(plugin);
                                            } catch (Exception ex) {
-                                                if (!(ex instanceof ObjectAlreadyHasException)) {
-                                                    ex.printStackTrace();
-                                                }
+                                                log.handleException(ex);
                                            }
                                        } else {
                                            try {
                                                user.setPermission("group." + group.getName().toLowerCase(), true, server);
-                                                LogEntry.build()
-                                                        .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
-                                                        .acted(user).action("addgroup " + group.getName().toLowerCase() + " " + server)
-                                                        .build().submit(plugin);
                                            } catch (Exception ex) {
-                                                if (!(ex instanceof ObjectAlreadyHasException)) {
-                                                    ex.printStackTrace();
-                                                }
+                                                log.handleException(ex);
                                            }
                                        }
                                    }
@@ -422,7 +352,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);
                    }
                }
@@ -433,11 +363,11 @@ public class MigrationPowerfulPerms extends SubCommand<Object> {
                    ListenableFuture<LinkedHashMap<String, List<CachedGroup>>> future = (ListenableFuture<LinkedHashMap<String, List<CachedGroup>>>) getPlayerGroupsMethod.invoke(pm, uuid);
                    try {
                        if (future.isDone()) {
-                            callback.onComplete(future.get());
+                            callback.accept(future.get());
                        } else {
                            future.addListener(() -> {
                                try {
-                                    callback.onComplete(future.get());
+                                    callback.accept(future.get());
                                } catch (InterruptedException | ExecutionException e) {
                                    e.printStackTrace();
                                }
@@ -447,7 +377,6 @@ public class MigrationPowerfulPerms extends SubCommand<Object> {
                        e.printStackTrace();
                    }
                } catch (IllegalAccessException | InvocationTargetException e) {
-                    log.info("PowerfulPerms Migration: Error");
                    e.printStackTrace();
                }
            } else {
@@ -455,11 +384,10 @@ public class MigrationPowerfulPerms extends SubCommand<Object> {
                    getPlayerGroupsMethod.invoke(pm, uuid, new LPResultRunnable<LinkedHashMap<String, List<CachedGroup>>>() {
                        @Override
                        public void run() {
-                            callback.onComplete(getResult());
+                            callback.accept(getResult());
                        }
                    });
                } catch (IllegalAccessException | InvocationTargetException e) {
-                    log.info("PowerfulPerms Migration: Error");
                    e.printStackTrace();
                }
            }
@@ -467,7 +395,7 @@ public class MigrationPowerfulPerms extends SubCommand<Object> {

        // All groups are migrated, but there may still be some users being migrated.
        // This block will wait for all users to be completed.
-        log.info("PowerfulPerms Migration: Waiting for user migration to complete. This may take some time");
+        log.log("Waiting for user migration to complete. This may take some time");
        boolean sleep = true;
        while (sleep) {
            sleep = false;
@@ -490,11 +418,11 @@ public class MigrationPowerfulPerms extends SubCommand<Object> {
        }

        // We done.
-        log.info("PowerfulPerms Migration: Success! Completed without any errors.");
+        log.log("Success! Migration complete.");
        return CommandResult.SUCCESS;
    }

-    private void applyPerm(PermissionHolder holder, Permission p, LuckPermsPlugin plugin) {
+    private void applyPerm(PermissionHolder holder, Permission p, ProgressLogger log) {
        String node = p.getPermissionString();
        boolean value = true;
        if (node.startsWith("!")) {
@@ -527,26 +455,14 @@ public class MigrationPowerfulPerms extends SubCommand<Object> {
            if (expireAt == 0L) {
                try {
                    holder.setPermission(node, value, server, world);
-                    LogEntry.build()
-                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
-                            .acted(holder).action("set " + node + " " + value + " " + server + " " + world)
-                            .build().submit(plugin);
                } catch (Exception ex) {
-                    if (!(ex instanceof ObjectAlreadyHasException)) {
-                        ex.printStackTrace();
-                    }
+                    log.handleException(ex);
                }
            } else {
                try {
                    holder.setPermission(node, value, server, world, expireAt);
-                    LogEntry.build()
-                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
-                            .acted(holder).action("settemp " + node + " " + value + " " + expireAt + " " + server + " " + world)
-                            .build().submit(plugin);
                } catch (Exception ex) {
-                    if (!(ex instanceof ObjectAlreadyHasException)) {
-                        ex.printStackTrace();
-                    }
+                    log.handleException(ex);
                }
            }

@@ -554,54 +470,66 @@ public class MigrationPowerfulPerms extends SubCommand<Object> {
            if (expireAt == 0L) {
                try {
                    holder.setPermission(node, value, server);
-                    LogEntry.build()
-                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
-                            .acted(holder).action("set " + node + " " + value + " " + server)
-                            .build().submit(plugin);
                } catch (Exception ex) {
-                    if (!(ex instanceof ObjectAlreadyHasException)) {
-                        ex.printStackTrace();
-                    }
+                    log.handleException(ex);
                }
            } else {
                try {
                    holder.setPermission(node, value, server, expireAt);
-                    LogEntry.build()
-                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
-                            .acted(holder).action("settemp " + node + " " + value + " " + expireAt + " " + server)
-                            .build().submit(plugin);
                } catch (Exception ex) {
-                    if (!(ex instanceof ObjectAlreadyHasException)) {
-                        ex.printStackTrace();
-                    }
+                    log.handleException(ex);
                }
            }
        } else {
            if (expireAt == 0L) {
                try {
                    holder.setPermission(node, value);
-                    LogEntry.build()
-                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
-                            .acted(holder).action("set " + node + " " + value)
-                            .build().submit(plugin);
                } catch (Exception ex) {
-                    if (!(ex instanceof ObjectAlreadyHasException)) {
-                        ex.printStackTrace();
-                    }
+                    log.handleException(ex);
                }
            } else {
                try {
                    holder.setPermission(node, value, expireAt);
-                    LogEntry.build()
-                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
-                            .acted(holder).action("settemp " + node + " " + value + " " + expireAt)
-                            .build().submit(plugin);
                } catch (Exception ex) {
-                    if (!(ex instanceof ObjectAlreadyHasException)) {
-                        ex.printStackTrace();
-                    }
+                    log.handleException(ex);
                }
            }
        }
    }
+
+    private static void getPlayerPermissions(PermissionManager manager, UUID uuid, Consumer<List<Permission>> callback) {
+        if (legacy) {
+            try {
+                getPlayerPermissionsMethod.invoke(manager, uuid, new LPResultRunnable<List<Permission>>() {
+                    @Override
+                    public void run() {
+                        callback.accept(getResult());
+                    }
+                });
+            } catch (IllegalAccessException | InvocationTargetException e) {
+                e.printStackTrace();
+            }
+        } else {
+            try {
+                ListenableFuture<List<Permission>> lf = (ListenableFuture<List<Permission>>) getPlayerPermissionsMethod.invoke(manager, uuid);
+                try {
+                    if (lf.isDone()) {
+                        callback.accept(lf.get());
+                    } else {
+                        lf.addListener(() -> {
+                            try {
+                                callback.accept(lf.get());
+                            } catch (InterruptedException | ExecutionException e) {
+                                e.printStackTrace();
+                            }
+                        }, Runnable::run);
+                    }
+                } catch (InterruptedException | ExecutionException e) {
+                    e.printStackTrace();
+                }
+            } catch (IllegalAccessException | InvocationTargetException e) {
+                e.printStackTrace();
+            }
+        }
+    }
 }
@@ -0,0 +1,181 @@
+/*
+ * 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.event.cause.CreationCause;
+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.plugin.LuckPermsPlugin;
+import me.lucko.luckperms.common.utils.Predicates;
+import me.lucko.luckperms.common.utils.ProgressLogger;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+
+import org.bukkit.Bukkit;
+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.Membership;
+import org.tyrannyofheaven.bukkit.zPermissions.model.PermissionEntity;
+
+import java.lang.reflect.Field;
+import java.util.List;
+import java.util.UUID;
+import java.util.concurrent.atomic.AtomicInteger;
+
+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 {
+        ProgressLogger log = new ProgressLogger("PermissionManager");
+        log.addListener(plugin.getConsoleSender());
+        log.addListener(sender);
+
+        log.log("Starting.");
+        
+        if (!Bukkit.getPluginManager().isPluginEnabled("zPermissions")) {
+            log.logErr("zPermissions is not loaded.");
+            return CommandResult.STATE_ERROR;
+        }
+
+        if (!Bukkit.getServicesManager().isProvidedFor(ZPermissionsService.class)) {
+            log.logErr("zPermissions is not loaded.");
+            return CommandResult.STATE_ERROR;
+        }
+
+        ZPermissionsService service = Bukkit.getServicesManager().getRegistration(ZPermissionsService.class).getProvider();
+
+        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.log("Starting group migration.");
+        AtomicInteger groupCount = new AtomicInteger(0);
+        for (String g : service.getAllGroups()) {
+            plugin.getStorage().createAndLoadGroup(g.toLowerCase(), CreationCause.INTERNAL).join();
+            Group group = plugin.getGroupManager().getIfLoaded(g.toLowerCase());
+
+            PermissionEntity entity = internalService.getEntity(g, null, true);
+            migrateEntity(group, entity, null);
+
+            plugin.getStorage().saveGroup(group);
+            log.logAllProgress("Migrated {} groups so far.", groupCount.incrementAndGet());
+        }
+        log.log("Migrated " + groupCount.get() + " groups");
+
+        // Migrate all tracks
+        log.log("Starting track migration.");
+        AtomicInteger trackCount = new AtomicInteger(0);
+        for (String t : service.getAllTracks()) {
+            plugin.getStorage().createAndLoadTrack(t.toLowerCase(), CreationCause.INTERNAL).join();
+            Track track = plugin.getTrackManager().getIfLoaded(t.toLowerCase());
+            track.setGroups(service.getTrackGroups(t));
+            plugin.getStorage().saveTrack(track);
+            log.logAllProgress("Migrated {} tracks so far.", trackCount.incrementAndGet());
+        }
+        log.log("Migrated " + trackCount.get() + " tracks");
+
+        // Migrate all users.
+        log.log("Starting user migration.");
+        AtomicInteger userCount = new AtomicInteger(0);
+        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, internalService.getGroups(u));
+
+            user.setPrimaryGroup(service.getPlayerPrimaryGroup(u));
+
+            if (!entity.isGroup()) {
+                user.setName(entity.getDisplayName());
+            }
+
+            plugin.getUserManager().cleanup(user);
+            plugin.getStorage().saveUser(user);
+            log.logProgress("Migrated {} users so far.", userCount.incrementAndGet());
+        }
+
+        log.log("Migrated " + userCount.get() + " users.");
+        log.log("Success! Migration complete.");
+        return CommandResult.SUCCESS;
+    }
+
+    private void migrateEntity(PermissionHolder group, PermissionEntity entity, List<Membership> memberships) {
+        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) {}
+            }
+        }
+
+        if (entity.isGroup()) {
+            for (Inheritance inheritance : entity.getInheritancesAsChild()) {
+                try {
+                    if (!inheritance.getParent().getName().equals(group.getObjectName())) {
+                        group.setPermission("group." + inheritance.getParent().getName(), true);
+                    }
+                } catch (ObjectAlreadyHasException ignored) {}
+            }
+        } else {
+            // entity.getMemberships() doesn't work (always returns 0 records)
+            for (Membership membership : memberships) {
+                try {
+                    group.setPermission("group." + membership.getGroup().getDisplayName(), true);
+                } catch (ObjectAlreadyHasException ignored) {}
+            }
+        }
+
+        for (EntityMetadata metadata : entity.getMetadata()) {
+            try {
+                group.setPermission(NodeFactory.makeMetaNode(metadata.getName(), metadata.getStringValue()).build());
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+}
@@ -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> {
@@ -0,0 +1,83 @@
+/*
+ * 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 {
+
+    @Getter
+    private ImmutableMap<Map.Entry<String, Boolean>, ImmutableMap<String, Boolean>> permissions = ImmutableMap.of();
+
+    public void setup() {
+        ImmutableMap.Builder<Map.Entry<String, Boolean>, ImmutableMap<String, Boolean>> permissions = ImmutableMap.builder();
+
+        for (Permission permission : Bukkit.getServer().getPluginManager().getPermissions()) {
+            // handle true
+            Map<String, Boolean> trueChildren = new HashMap<>();
+            resolveChildren(trueChildren, Collections.singletonMap(permission.getName(), true), false);
+            trueChildren.remove(permission.getName(), true);
+            if (!trueChildren.isEmpty()) {
+                permissions.put(Maps.immutableEntry(permission.getName().toLowerCase(), true), ImmutableMap.copyOf(trueChildren));
+            }
+
+            // handle false
+            Map<String, Boolean> falseChildren = new HashMap<>();
+            resolveChildren(falseChildren, Collections.singletonMap(permission.getName(), false), false);
+            falseChildren.remove(permission.getName(), false);
+            if (!falseChildren.isEmpty()) {
+                permissions.put(Maps.immutableEntry(permission.getName().toLowerCase(), false), ImmutableMap.copyOf(falseChildren));
+            }
+        }
+
+        this.permissions = permissions.build();
+    }
+
+    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);
+            }
+        }
+    }
+}