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
471 changed files with 21259 additions and 9432 deletions
@@ -1,34 +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.
-
-## 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 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.

 LuckPerms also includes an extensive API for developers, and support for a variety of Minecraft server software & data storage options.

-See the charts below for a partial list of features & comparison with other providers.
+[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>
+
+## Building
+LuckPerms uses Maven to handle dependencies.
+
+#### 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._
+###### _Features checked on 8th Oct 2016. If you find any inaccuracies, please let me know._

-## License
-LuckPerms is licensed under the permissive MIT license. See LICENSE.md for more info.
-
-## Sponsor
+## 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.15-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() {
@@ -24,20 +24,21 @@ package me.lucko.luckperms.api;

 import me.lucko.luckperms.api.context.ContextSet;

-import java.util.Map;
-
 /**
- * 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 {
-    private static final Contexts ALLOW_ALL = new Contexts(ContextSet.empty(), true, true, true, true, true, true);
    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() {
@@ -48,43 +49,6 @@ public class Contexts {
        return new Contexts(context, includeGlobal, includeGlobalWorld, applyGroups, applyGlobalGroups, applyGlobalWorldGroups, op);
    }

-    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;
-    }
-
-    @SuppressWarnings("deprecation")
-    @Deprecated
-    public static Contexts of(Map<String, String> context, boolean includeGlobal, boolean includeGlobalWorld, boolean applyGroups, boolean applyGlobalGroups, boolean applyGlobalWorldGroups) {
-        return new Contexts(context, includeGlobal, includeGlobalWorld, applyGroups, applyGlobalGroups, applyGlobalWorldGroups);
-    }
-
-    @SuppressWarnings("deprecation")
-    @Deprecated
-    public static Contexts of(Map<String, String> context, boolean includeGlobal, boolean includeGlobalWorld, boolean applyGroups, boolean applyGlobalGroups, boolean applyGlobalWorldGroups, boolean op) {
-        return new Contexts(context, includeGlobal, includeGlobalWorld, applyGroups, applyGlobalGroups, applyGlobalWorldGroups, op);
-    }
-
-    @Deprecated
-    public Contexts(Map<String, String> context, boolean includeGlobal, boolean includeGlobalWorld, boolean applyGroups, boolean applyGlobalGroups, boolean applyGlobalWorldGroups, boolean op) {
-        this(context == null ? null : ContextSet.fromMap(context), includeGlobal, includeGlobalWorld, applyGroups, applyGlobalGroups, applyGlobalWorldGroups, op);
-    }
-
-    @SuppressWarnings("deprecation")
-    @Deprecated
-    public Contexts(Map<String, String> context, boolean includeGlobal, boolean includeGlobalWorld, boolean applyGroups, boolean applyGlobalGroups, boolean applyGlobalWorldGroups) {
-        this(context, includeGlobal, includeGlobalWorld, applyGroups, applyGlobalGroups, applyGlobalWorldGroups, false);
-    }
-
    /**
     * The contexts that apply for this lookup
     * The keys for servers and worlds are defined as static values.
@@ -93,6 +57,7 @@ public class Contexts {

    /**
     * The mode to parse defaults on Bukkit
+     *
     * @since 2.12
     */
    private final boolean op;
@@ -122,8 +87,23 @@ 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 set of context key value pairs
     * @since 2.13
     */
@@ -131,18 +111,9 @@ public class Contexts {
        return this.context;
    }

-    /**
-     * Gets the contexts that apply for this lookup
-     * @return an immutable map of context key value pairs
-     * @deprecated in favour of {@link #getContexts()}
-     */
-    @Deprecated
-    public Map<String, String> getContext() {
-        return this.context.toMap();
-    }
-
    /**
     * Gets if OP defaults should be included
+     *
     * @return true if op defaults should be included
     */
    public boolean isOp() {
@@ -151,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() {
@@ -159,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() {
@@ -167,6 +140,7 @@ public class Contexts {

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

    /**
     * Check for equality
+     *
     * @param o the other
     * @return true if equal
     * @since 2.12
@@ -229,6 +206,7 @@ public class Contexts {

    /**
     * Gets the hashcode
+     *
     * @return the hashcode
     * @since 2.12
     */
@@ -1,126 +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
- * @deprecated as of version 2.14 in favour of {@link Storage}.
- */
-@Deprecated
-public interface Datastore {
-
-    String getName();
-    boolean isAcceptingLogins();
-
-    @Deprecated
-    Sync sync();
-
-    @Deprecated
-    Async async();
-
-    @Deprecated
-    Future future();
-
-    @Deprecated
-    interface Sync {
-        boolean logAction(LogEntry entry);
-        Log getLog();
-        @Deprecated
-        boolean loadOrCreateUser(UUID uuid, String username);
-        @Deprecated
-        boolean loadUser(UUID uuid);
-        boolean loadUser(UUID uuid, String username);
-        boolean saveUser(User user);
-        boolean cleanupUsers();
-        Set<UUID> getUniqueUsers();
-        boolean createAndLoadGroup(String name);
-        boolean loadGroup(String name);
-        boolean loadAllGroups();
-        boolean saveGroup(Group group);
-        boolean deleteGroup(Group group);
-        boolean createAndLoadTrack(String name);
-        boolean loadTrack(String name);
-        boolean loadAllTracks();
-        boolean saveTrack(Track track);
-        boolean deleteTrack(Track track);
-        boolean saveUUIDData(String username, UUID uuid);
-        UUID getUUID(String username);
-    }
-
-    @Deprecated
-    interface Async {
-        void logAction(LogEntry entry, Callback<Boolean> callback);
-        void getLog(Callback<Log> callback);
-        @Deprecated
-        void loadOrCreateUser(UUID uuid, String username, Callback<Boolean> callback);
-        @Deprecated
-        void loadUser(UUID uuid, Callback<Boolean> callback);
-        void loadUser(UUID uuid, String username, Callback<Boolean> callback);
-        void saveUser(User user, Callback<Boolean> callback);
-        void cleanupUsers(Callback<Boolean> callback);
-        void getUniqueUsers(Callback<Set<UUID>> callback);
-        void createAndLoadGroup(String name, Callback<Boolean> callback);
-        void loadGroup(String name, Callback<Boolean> callback);
-        void loadAllGroups(Callback<Boolean> callback);
-        void saveGroup(Group group, Callback<Boolean> callback);
-        void deleteGroup(Group group, Callback<Boolean> callback);
-        void createAndLoadTrack(String name, Callback<Boolean> callback);
-        void loadTrack(String name, Callback<Boolean> callback);
-        void loadAllTracks(Callback<Boolean> callback);
-        void saveTrack(Track track, Callback<Boolean> callback);
-        void deleteTrack(Track track, Callback<Boolean> callback);
-        void saveUUIDData(String username, UUID uuid, Callback<Boolean> callback);
-        void getUUID(String username, Callback<UUID> callback);
-    }
-
-    @Deprecated
-    interface Future {
-        java.util.concurrent.Future<Boolean> logAction(LogEntry entry);
-        java.util.concurrent.Future<Log> getLog();
-        @Deprecated
-        java.util.concurrent.Future<Boolean> loadOrCreateUser(UUID uuid, String username);
-        @Deprecated
-        java.util.concurrent.Future<Boolean> loadUser(UUID uuid);
-        java.util.concurrent.Future<Boolean> loadUser(UUID uuid, String username);
-        java.util.concurrent.Future<Boolean> saveUser(User user);
-        java.util.concurrent.Future<Boolean> cleanupUsers();
-        java.util.concurrent.Future<Set<UUID>> getUniqueUsers();
-        java.util.concurrent.Future<Boolean> createAndLoadGroup(String name);
-        java.util.concurrent.Future<Boolean> loadGroup(String name);
-        java.util.concurrent.Future<Boolean> loadAllGroups();
-        java.util.concurrent.Future<Boolean> saveGroup(Group group);
-        java.util.concurrent.Future<Boolean> deleteGroup(Group group);
-        java.util.concurrent.Future<Boolean> createAndLoadTrack(String name);
-        java.util.concurrent.Future<Boolean> loadTrack(String name);
-        java.util.concurrent.Future<Boolean> loadAllTracks();
-        java.util.concurrent.Future<Boolean> saveTrack(Track track);
-        java.util.concurrent.Future<Boolean> deleteTrack(Track track);
-        java.util.concurrent.Future<Boolean> saveUUIDData(String username, UUID uuid);
-        java.util.concurrent.Future<UUID> getUUID(String username);
-    }
-}
@@ -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,154 +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
-     * @deprecated as this value is now always false. Functionality was replaced by the verbose command.
-     */
-    @Deprecated
-    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,78 +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 Storage} instance.
+     *
     * @return a storage instance
     * @since 2.14
     */
    Storage getStorage();

-    /**
-     * Gets a wrapped Datastore instance.
-     * @return a datastore instance
-     * @deprecated in favour of {@link #getStorage()}
-     */
-    @SuppressWarnings("deprecation")
-    @Deprecated
-    Datastore getDatastore();
-
    /**
     * Gets the messaging service in use on the platform, if present.
+     *
     * @return an optional that may contain a messaging service instance.
     */
    Optional<MessagingService> getMessagingService();

    /**
     * Gets the {@link Logger} wrapping used by the platform
+     *
     * @return the logger instance
     */
    Logger getLogger();

    /**
     * Gets a wrapped {@link UuidCache} instance, providing read access to the LuckPerms internal uuid caching system
+     *
     * @return a 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
@@ -122,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
@@ -130,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
@@ -137,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
@@ -146,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
@@ -160,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
@@ -168,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
@@ -176,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
@@ -184,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
@@ -198,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
@@ -206,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
@@ -214,48 +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);
-
-    /**
-     * Registers a custom context listener to the server,
-     * @param contextListener the context listener to register. The type MUST be the player class of the platform.
-     * @throws ClassCastException if the type is not the player class of the platform.
-     */
-    void registerContextListener(ContextListener<?> contextListener);
+    void registerContextCalculator(ContextCalculator<?> contextCalculator);

    /**
     * Gets a calculated context instance for the user using the rules of the platform.
-     * These values are calculated using the options in the configuration, and the provided calculators.
+     *
+     * <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.
     */
    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);
+
 }
@@ -23,14 +23,17 @@
 package me.lucko.luckperms.api;

 /**
- * Exposes any networking provider being used on the platform. e.g. Redis
+ * 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.
-     * This will push the update asynchronously, and this method will return almost immediately.
+     *
+     * <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) {
@@ -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() {
+    }
+
 }
@@ -24,14 +24,19 @@ package me.lucko.luckperms.api;

 import me.lucko.luckperms.api.context.ContextSet;

-import java.util.*;
+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> {

    /**
@@ -41,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
@@ -59,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();
@@ -87,25 +96,28 @@ 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
@@ -114,38 +126,17 @@ public interface Node extends Map.Entry<String, Boolean> {

    /**
     * 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(ContextSet context);

-    /**
-     * If this node should apply in the given context
-     * @param context the context key value pairs
-     * @param worldAndServer if world and server contexts should be checked
-     * @return true if the node should apply
-     * @deprecated in favour of {@link #shouldApplyWithContext(ContextSet, boolean)}
-     */
-    @Deprecated
-    default boolean shouldApplyWithContext(Map<String, String> context, boolean worldAndServer) {
-        return shouldApplyWithContext(ContextSet.fromMap(context), worldAndServer);
-    }
-
-    /**
-     * If this node should apply in the given context
-     * @param context the context key value pairs
-     * @return true if the node should apply
-     * @deprecated in favour of {@link #shouldApplyWithContext(ContextSet)}
-     */
-    @Deprecated
-    default boolean shouldApplyWithContext(Map<String, String> context) {
-        return shouldApplyWithContext(ContextSet.fromMap(context));
-    }
-
    /**
     * Similar to {@link #shouldApplyOnServer(String, boolean, boolean)}, except this method accepts a List
-     * @param servers the list of servers
+     *
+     * @param servers       the list of servers
     * @param includeGlobal if global permissions should apply
     * @return true if the node should apply
     */
@@ -153,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
     */
@@ -161,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
     */
@@ -168,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();
@@ -208,15 +202,6 @@ public interface Node extends Map.Entry<String, Boolean> {
     */
    boolean hasExpired();

-    /**
-     * @return the extra contexts required for this node to apply
-     * @deprecated in favour of {@link #getContexts()}
-     */
-    @Deprecated
-    default Map<String, String> getExtraContexts() {
-        return getContexts().toMap();
-    }
-
    /**
     * @return the extra contexts required for this node to apply
     * @since 2.13
@@ -225,6 +210,7 @@ public interface Node extends Map.Entry<String, Boolean> {

    /**
     * Converts this node into a serialized form
+     *
     * @return a serialized node string
     */
    String toSerializedNode();
@@ -247,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
     */
@@ -259,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
     */
@@ -271,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
     */
@@ -283,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
     */
@@ -290,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
@@ -298,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
     */
@@ -305,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
     */
@@ -312,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
@@ -323,6 +317,7 @@ public interface Node extends Map.Entry<String, Boolean> {
     */
    interface Builder {
        Builder setNegated(boolean negated);
+
        Builder setValue(boolean value);

        /**
@@ -332,13 +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;

@@ -22,6 +22,7 @@

 package me.lucko.luckperms.api;

+import java.util.List;
 import java.util.Set;
 import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
@@ -29,14 +30,15 @@ import java.util.concurrent.Executor;
 import java.util.function.Consumer;

 /**
- * Interface for the internal Storage instance
+ * A means of loading and saving data to/from the Storage provider.
 *
- * 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>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.
 *
- * 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()}.
+ * <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
 */
@@ -44,30 +46,36 @@ 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.
+     * 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
@@ -76,14 +84,17 @@ public interface Storage {

    /**
     * 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.)
+     *
+     * @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
     */
@@ -91,15 +102,17 @@ public interface Storage {

    /**
     * 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 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();
@@ -107,111 +120,154 @@ public interface Storage {
    /**
     * 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 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 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 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 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 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 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 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 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
+     * @param uuid     the users mojang unique id
     * @return true if the operation completed successfully.
-     * @throws NullPointerException if either parameters are null
+     * @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 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;
-    }
 }
@@ -31,50 +31,67 @@ 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
@@ -83,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 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> 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
     */
@@ -27,36 +27,44 @@ import java.util.SortedMap;

 /**
 * Holds cached Meta lookup data for a specific set of contexts
+ *
 * @since 2.13
 */
 public interface MetaData {

    /**
     * Gets an immutable copy of the meta this user has
+     *
     * @return an immutable map of meta
     */
    Map<String, String> getMeta();

    /**
-     * Gets an immutable sorted map of all of the prefixes the user has, whereby the first value is the highest priority prefix.
+     * Gets an immutable sorted map of all of the prefixes the user has, whereby the first value is the highest priority
+     * prefix.
+     *
     * @return a sorted map of prefixes
     */
    SortedMap<Integer, String> getPrefixes();

    /**
-     * Gets an immutable sorted map of all of the suffixes the user has, whereby the first value is the highest priority suffix.
+     * Gets an immutable sorted map of all of the suffixes the user has, whereby the first value is the highest priority
+     * suffix.
+     *
     * @return a sorted map of suffixes
     */
    SortedMap<Integer, String> getSuffixes();

    /**
     * Gets the user's highest priority prefix, or null if the user has no prefixes
+     *
     * @return a prefix string, or null
     */
    String getPrefix();

    /**
     * Gets the user's highest priority suffix, or null if the user has no suffixes
+     *
     * @return a suffix string, or null
     */
    String getSuffix();
@@ -28,12 +28,14 @@ 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
@@ -42,12 +44,14 @@ public interface PermissionData {

    /**
     * Invalidates the underlying permission calculator cache.
-     * Can be called to allow for an update in defaults.
+     *
+     * <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();
@@ -28,7 +28,8 @@ import java.util.Set;

 /**
 * Holds cached permission and meta lookup data for a {@link me.lucko.luckperms.api.User}.
- * Data is only likely to be available for online users. All calls will account for inheritance, as well as any
+ *
+ * <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
@@ -37,7 +38,9 @@ public interface UserData {

    /**
     * Gets PermissionData from the cache, given a specified context.
-     * If the data is not cached, it is calculated. Therefore, this call could be costly.
+     *
+     * <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
@@ -46,7 +49,9 @@ public interface UserData {

    /**
     * Gets MetaData from the cache, given a specified context.
-     * If the data is not cached, it is calculated. Therefore, this call could be costly.
+     *
+     * <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
@@ -55,6 +60,7 @@ public interface UserData {

    /**
     * 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
@@ -63,6 +69,7 @@ public interface UserData {

    /**
     * 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
@@ -70,16 +77,22 @@ public interface UserData {
    MetaData calculateMeta(Contexts contexts);

    /**
-     * Calculates permission data and stores it in the cache. If there is already data cached for the given contexts,
-     * and if the resultant output is different, the cached value is updated.
+     * 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. If there is already data cached for the given contexts,
-     * and if the resultant output is different, the cached value is updated.
+     * 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
     */
@@ -97,14 +110,17 @@ public interface UserData {

    /**
     * Calls {@link #preCalculate(Contexts)} for the given contexts
+     *
     * @param contexts a set of contexts
     * @throws NullPointerException if contexts is null
     */
    void preCalculate(Set<Contexts> contexts);

    /**
-     * Ensures that PermissionData and MetaData is cached for a context. If the cache does not contain any data for the
-     * context, it will be calculated and saved.
+     * 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
     */
@@ -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);

 }
@@ -22,135 +22,114 @@

 package me.lucko.luckperms.api.context;

-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Multimap;

-import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
-import java.util.stream.Collectors;

 /**
 * Holds contexts.
- * All contained contexts are immutable, and unlike {@link MutableContextSet}, contexts cannot be added or removed.
+ * Implementations may be either mutable or immutable.
 *
 * @since 2.13
 */
-public class ContextSet {
-    private static final ContextSet EMPTY = new ContextSet();
+public interface ContextSet {

    /**
-     * Make a singleton ContextSet from a context pair
-     * @param key the key
+     * Make a singleton ImmutableContextSet from a context pair
+     *
+     * @param key   the key
     * @param value the value
-     * @return a new ContextSet containing one KV pair
+     * @return a new ImmutableContextSet containing one KV pair
     * @throws NullPointerException if key or value is null
     */
-    public static ContextSet 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.immutableCopy();
+    static ImmutableContextSet singleton(String key, String value) {
+        return ImmutableContextSet.singleton(key, value);
    }

    /**
-     * Creates a ContextSet from an existing map
+     * Creates a ImmutableContextSet from an existing map
+     *
     * @param map the map to copy from
-     * @return a new ContextSet representing the pairs from the map
+     * @return a new ImmutableContextSet representing the pairs from the map
     * @throws NullPointerException if the map is null
     */
-    public static ContextSet fromMap(Map<String, String> map) {
-        if (map == null) {
-            throw new NullPointerException("map");
-        }
-
-        MutableContextSet set = new MutableContextSet();
-        set.addAll(map);
-        return set.immutableCopy();
+    static ImmutableContextSet fromMap(Map<String, String> map) {
+        return ImmutableContextSet.fromMap(map);
    }

    /**
-     * Creates a ContextSet from an existing iterable of Map Entries
+     * Creates a ImmutableContextSet from an existing iterable of Map Entries
+     *
     * @param iterable the iterable to copy from
-     * @return a new ContextSet representing the pairs in the iterable
+     * @return a new ImmutableContextSet representing the pairs in the iterable
     * @throws NullPointerException if the iterable is null
     */
-    public static ContextSet fromEntries(Iterable<Map.Entry<String, String>> iterable) {
-        if (iterable == null) {
-            throw new NullPointerException("iterable");
-        }
-
-        MutableContextSet set = new MutableContextSet();
-        set.addAll(iterable);
-        return set.immutableCopy();
+    static ImmutableContextSet fromEntries(Iterable<? extends Map.Entry<String, String>> iterable) {
+        return ImmutableContextSet.fromEntries(iterable);
    }

    /**
-     * Creates a new ContextSet from an existing set.
+     * 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 ContextSet with the same content and the one provided
+     * @return a new ImmutableContextSet with the same content and the one provided
     * @throws NullPointerException if contextSet is null
     */
-    public static ContextSet fromSet(ContextSet contextSet) {
-        if (contextSet == null) {
-            throw new NullPointerException("contextSet");
-        }
-
-        MutableContextSet set = new MutableContextSet();
-        set.addAll(contextSet.toSet());
-        return set.immutableCopy();
+    static ImmutableContextSet fromSet(ContextSet contextSet) {
+        return ImmutableContextSet.fromSet(contextSet);
    }

    /**
-     * Creates a new empty ContextSet.
-     * @return a new ContextSet
+     * Creates a new empty ImmutableContextSet.
+     *
+     * @return a new ImmutableContextSet
     */
-    public static ContextSet empty() {
-        return EMPTY;
-    }
-
-    final Set<Map.Entry<String, String>> contexts;
-
-    public ContextSet() {
-        this.contexts = new HashSet<>();
-    }
-
-    protected ContextSet(Set<Map.Entry<String, String>> contexts) {
-        this.contexts = contexts;
+    static ImmutableContextSet empty() {
+        return ImmutableContextSet.empty();
    }

    /**
     * Check to see if this set is in an immutable form
+     *
     * @return true if the set is immutable
     */
-    public boolean isImmutable() {
-        return true;
-    }
+    boolean isImmutable();

    /**
     * If the set is mutable, this method will return an immutable copy. Otherwise just returns itself.
+     *
     * @return an immutable ContextSet
     */
-    public ContextSet makeImmutable() {
-        return this;
-    }
+    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
     */
-    public Set<Map.Entry<String, String>> toSet() {
-        synchronized (contexts) {
-            return ImmutableSet.copyOf(contexts);
-        }
-    }
+    Set<Map.Entry<String, String>> toSet();

    /**
     * Converts this ContextSet to an immutable {@link Map}
@@ -160,153 +139,66 @@ public class ContextSet {
     *
     * @return an immutable map
     */
-    public Map<String, String> toMap() {
-        synchronized (contexts) {
-            return ImmutableMap.copyOf(contexts.stream().collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)));
-        }
-    }
+    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
     */
-    public boolean containsKey(String key) {
-        if (key == null) {
-            throw new NullPointerException("key");
-        }
-
-        synchronized (contexts) {
-            for (Map.Entry<String, String> e : contexts) {
-                if (e.getKey().equalsIgnoreCase(key)) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
+    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
     */
-    public Set<String> getValues(String key) {
-        if (key == null) {
-            throw new NullPointerException("key");
-        }
-
-        synchronized (contexts) {
-            return ImmutableSet.copyOf(contexts.stream()
-                    .filter(e -> e.getKey().equalsIgnoreCase(key))
-                    .map(Map.Entry::getValue)
-                    .collect(Collectors.toSet())
-            );
-        }
-    }
+    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 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
     */
-    public boolean has(String key, String value) {
-        if (key == null) {
-            throw new NullPointerException("key");
-        }
-        if (value == null) {
-            throw new NullPointerException("value");
-        }
-
-        synchronized (contexts) {
-            for (Map.Entry<String, String> e : contexts) {
-                if (!e.getKey().equalsIgnoreCase(key)) {
-                    continue;
-                }
-
-                if (!e.getValue().equals(value)) {
-                    continue;
-                }
-
-                return true;
-            }
-        }
-        return false;
-    }
+    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 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
     */
-    public boolean hasIgnoreCase(String key, String value) {
-        if (key == null) {
-            throw new NullPointerException("key");
-        }
-        if (value == null) {
-            throw new NullPointerException("value");
-        }
-
-        synchronized (contexts) {
-            for (Map.Entry<String, String> e : contexts) {
-                if (!e.getKey().equalsIgnoreCase(key)) {
-                    continue;
-                }
-
-                if (!e.getValue().equalsIgnoreCase(value)) {
-                    continue;
-                }
-
-                return true;
-            }
-        }
-        return false;
-    }
+    boolean hasIgnoreCase(String key, String value);

    /**
     * Check if the set is empty
+     *
     * @return true if the set is empty
     */
-    public boolean isEmpty() {
-        synchronized (contexts) {
-            return contexts.isEmpty();
-        }
-    }
+    boolean isEmpty();

    /**
     * Gets the number of key-value context pairs in the set
+     *
     * @return the size of the set
     */
-    public int size() {
-        synchronized (contexts) {
-            return contexts.size();
-        }
-    }
+    int size();

-    @Override
-    public boolean equals(Object o) {
-        if (o == this) return true;
-        if (!(o instanceof ContextSet)) return false;
-        final ContextSet other = (ContextSet) o;
-
-        final Object thisContexts = this.contexts;
-        final Object otherContexts = other.contexts;
-        return thisContexts == null ? otherContexts == null : thisContexts.equals(otherContexts);
-    }
-
-    @Override
-    public int hashCode() {
-        return 59 + (this.contexts == null ? 43 : this.contexts.hashCode());
-    }
-
-    @Override
-    public String toString() {
-        return "ContextSet(contexts=" + this.contexts + ")";
-    }
 }
@@ -1,88 +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.context;
-
-import java.util.HashMap;
-import java.util.Map;
-
-/**
- * Calculates whether contexts are applicable to {@link T}
- *
- * <p>Somewhat inspired by the system used on Sponge.
- * @param <T> the subject type. Is ALWAYS the player class of the platform.
- */
-public interface IContextCalculator<T> {
-
-    /**
-     * Gives the subject all of the applicable contexts they meet
-     * @param subject the subject to add contexts to
-     * @param accumulator a map of contexts to add to
-     * @return the map
-     * @deprecated in favour of {@link #giveApplicableContext(Object, MutableContextSet)}. Older implementations of this interface
-     * will still work, as the replacement method is given as a default, and falls back to using this method.
-     */
-    @Deprecated
-    default Map<String, String> giveApplicableContext(T subject, Map<String, String> accumulator) {
-        MutableContextSet acc = new MutableContextSet();
-        giveApplicableContext(subject, acc);
-
-        accumulator.putAll(acc.toMap());
-        return accumulator;
-    }
-
-    /**
-     * Gives the subject all of the applicable contexts they meet
-     *
-     * <p><b>You MUST implement this method. The default is only provided for backwards compatibility with
-     * {@link #giveApplicableContext(Object, Map)}.</b>
-     *
-     * @param subject the subject to add contexts to
-     * @param accumulator a map of contexts to add to
-     * @return the map
-     * @since 2.13
-     */
-    @SuppressWarnings("deprecation")
-    default MutableContextSet giveApplicableContext(T subject, MutableContextSet accumulator) {
-        Map<String, String> acc = new HashMap<>();
-        giveApplicableContext(subject, acc);
-
-        accumulator.addAll(acc.entrySet());
-        return accumulator;
-    }
-
-    /**
-     * Checks to see if a context is applicable to a subject
-     * @param subject the subject to check against
-     * @param context the context to check for
-     * @return true if met, or false if not. If this calculator does not calculate the given context, return false.
-     */
-    boolean isContextApplicable(T subject, Map.Entry<String, String> context);
-
-    /**
-     * 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
-     */
-    void addListener(ContextListener<T> listener);
-
-}
@@ -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 + ")";
+    }
+}
@@ -22,27 +22,39 @@

 package me.lucko.luckperms.api.context;

-import com.google.common.collect.Maps;
+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.HashSet;
+import java.util.Collection;
 import java.util.Map;
+import java.util.Set;

 /**
- * Holds contexts
- * All contained contexts are immutable, but contexts can be added or removed from the set.
+ * A mutable implementation of {@link ContextSet}.
 *
- * @since 2.13
+ * @since 2.16
 */
-public class MutableContextSet extends ContextSet {
+public final class MutableContextSet implements ContextSet {

    /**
     * Make a singleton MutableContextSet from a context pair
-     * @param key the key
+     *
+     * @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;
@@ -50,11 +62,16 @@ public class MutableContextSet extends ContextSet {

    /**
     * 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;
@@ -62,24 +79,49 @@ public class MutableContextSet extends ContextSet {

    /**
     * Creates a MutableContextSet from an existing iterable of Map Entries
+     *
     * @param iterable the iterable to copy from
     * @return a new MutableContextSet representing the pairs in the iterable
     * @throws NullPointerException if the iterable is null
     */
-    public static MutableContextSet fromEntries(Iterable<Map.Entry<String, String>> iterable) {
+    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;
@@ -87,35 +129,125 @@ public class MutableContextSet extends ContextSet {

    /**
     * Creates a new empty MutableContextSet.
+     *
     * @return a new MutableContextSet
     */
-    public static MutableContextSet empty() {
+    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 ContextSet makeImmutable() {
-        return immutableCopy();
+    public ImmutableContextSet makeImmutable() {
+        return new ImmutableContextSet(map);
    }

-    /**
-     * Returns an immutable copy of this set.
-     * @return an immutable copy of this set
-     */
-    public ContextSet immutableCopy() {
-        synchronized (contexts) {
-            return new ContextSet(new HashSet<>(contexts));
+    @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 key   the key to add
     * @param value the value to add
     * @throws NullPointerException if the key or value is null
     */
@@ -127,13 +259,12 @@ public class MutableContextSet extends ContextSet {
            throw new NullPointerException("value");
        }

-        synchronized (contexts) {
-            contexts.add(Maps.immutableEntry(key, 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
     */
@@ -142,30 +273,28 @@ public class MutableContextSet extends ContextSet {
            throw new NullPointerException("context");
        }

-        synchronized (contexts) {
-            contexts.add(Maps.immutableEntry(entry.getKey(), entry.getValue()));
-        }
+        map.put(entry.getKey().toLowerCase(), entry.getValue());
    }

    /**
     * Adds an iterable containing contexts to the set
+     *
     * @param iterable an iterable of key value context pairs
     * @throws NullPointerException if iterable is null
     */
-    public void addAll(Iterable<Map.Entry<String, String>> iterable) {
+    public void addAll(Iterable<? extends Map.Entry<String, String>> iterable) {
        if (iterable == null) {
            throw new NullPointerException("contexts");
        }

-        synchronized (this.contexts) {
-            for (Map.Entry<String, String> e : iterable) {
-                this.contexts.add(Maps.immutableEntry(e.getKey(), e.getValue()));
-            }
+        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
     */
@@ -178,6 +307,7 @@ public class MutableContextSet extends ContextSet {

    /**
     * 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
     */
@@ -186,14 +316,13 @@ public class MutableContextSet extends ContextSet {
            throw new NullPointerException("contextSet");
        }

-        synchronized (this.contexts) {
-            this.contexts.addAll(contextSet.toSet());
-        }
+        this.map.putAll(contextSet.toMultimap());
    }

    /**
     * Remove a key value pair from this set
-     * @param key the key to remove
+     *
+     * @param key   the key to remove
     * @param value the value to remove (case sensitive)
     * @throws NullPointerException if the key or value is null
     */
@@ -205,14 +334,13 @@ public class MutableContextSet extends ContextSet {
            throw new NullPointerException("value");
        }

-        synchronized (contexts) {
-            contexts.removeIf(e -> e.getKey().equalsIgnoreCase(key) && e.getValue().equals(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 key   the key to remove
     * @param value the value to remove
     * @throws NullPointerException if the key or value is null
     */
@@ -224,13 +352,12 @@ public class MutableContextSet extends ContextSet {
            throw new NullPointerException("value");
        }

-        synchronized (contexts) {
-            contexts.removeIf(e -> e.getKey().equalsIgnoreCase(key) && e.getValue().equalsIgnoreCase(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
     */
@@ -239,18 +366,14 @@ public class MutableContextSet extends ContextSet {
            throw new NullPointerException("key");
        }

-        synchronized (contexts) {
-            contexts.removeIf(e -> e.getKey().equalsIgnoreCase(key));
-        }
+        map.removeAll(key.toLowerCase());
    }

    /**
     * Clears the set
     */
    public void clear() {
-        synchronized (contexts) {
-            contexts.clear();
-        }
+        map.clear();
    }

    @Override
@@ -259,14 +382,18 @@ public class MutableContextSet extends ContextSet {
        if (!(o instanceof ContextSet)) return false;
        final ContextSet other = (ContextSet) o;

-        final Object thisContexts = this.contexts;
-        final Object otherContexts = other.contexts;
+        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.contexts == null ? 43 : this.contexts.hashCode());
+        return 59 + (this.map == null ? 43 : this.map.hashCode());
    }

+    @Override
+    public String toString() {
+        return "MutableContextSet(contexts=" + this.map + ")";
+    }
 }
@@ -1,73 +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.data;
-
-import java.util.function.Consumer;
-
-/**
- * A callback used to wait for the completion of asynchronous operations.
- * All callbacks are ran on the main server thread.
- * @param <T> the return type
- * @deprecated in favour of {@link Consumer}
- */
-@Deprecated
-public interface Callback<T> {
-
-    /**
-     * Called when the operation completes.
-     * @param t the return value, may be null
-     */
-    void onComplete(T t);
-
-    static <T> Callback<T> empty() {
-        return t -> {};
-    }
-
-    static <T> Callback<T> of(Runnable runnable) {
-        if (runnable == null) {
-            throw new NullPointerException("runnable");
-        }
-        return t -> runnable.run();
-    }
-
-    static <T> Callback<T> of(Consumer<T> consumer) {
-        if (consumer == null) {
-            throw new NullPointerException("consumer");
-        }
-        return consumer::accept;
-    }
-
-    /**
-     * Helper method for converting old {@link Callback}s to use the new {@link me.lucko.luckperms.api.Storage} interface.
-     * @param callback the callback to convert
-     * @param <T> the return type
-     * @return a consumer instance
-     * @since 2.14
-     * @deprecated in favour of just using {@link Consumer}s.
-     */
-    @Deprecated
-    static <T> Consumer<T> convertToConsumer(Callback<T> callback) {
-        return callback::onComplete;
-    }
-
-}
@@ -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;
-    }
 }
@@ -0,0 +1,54 @@
+/*
+ * 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 java.util.Set;
+import java.util.function.Consumer;
+
+/**
+ * The LuckPerms event bus. Used for subscribing (or registering listeners) to events.
+ *
+ * @since 3.0
+ */
+public interface EventBus {
+
+    /**
+     * 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
+     */
+    <T extends LuckPermsEvent> EventHandler<T> subscribe(Class<T> eventClass, Consumer<T> handler);
+
+    /**
+     * 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
+     */
+    <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();
 }
@@ -20,24 +20,23 @@
 *  SOFTWARE.
 */

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

 /**
- * Event that allows listeners to set the cancelled state of an event.
+ * Called when a group is loaded into memory from the storage.
+ *
+ * Note that this event is not the same as {@link GroupCreateEvent}
 */
-public abstract class CancellableEvent extends LPEvent {
+public interface GroupLoadEvent extends LuckPermsEvent {

-    private boolean cancelled = false;
+    /**
+     * Gets the group that was loaded
+     *
+     * @return the group that was loaded
+     */
+    Group getGroup();

-    protected CancellableEvent(String eventName) {
-        super(eventName);
-    }
-
-    public boolean isCancelled() {
-        return cancelled;
-    }
-
-    public void setCancelled(boolean cancelled) {
-        this.cancelled = cancelled;
-    }
 }
@@ -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 {
+
+}
@@ -20,18 +20,56 @@
 *  SOFTWARE.
 */

-package me.lucko.luckperms.api.event.events;
+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.AbstractPermissionEvent;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+import java.util.Set;

 /**
- * Called when a temporary permission node expires
- * @since 2.6
+ * Called when a node is added to/removed from a user/group
 */
-public class PermissionNodeExpireEvent extends AbstractPermissionEvent {
-    public PermissionNodeExpireEvent(PermissionHolder target, Node node) {
-        super("Permission Node Expire Event", target, node);
-    }
+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.15-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>
@@ -76,37 +59,14 @@
                                    <shadedPattern>me.lucko.luckperms.lib.gson</shadedPattern>
                                </relocation>
                                <relocation>
-                                    <pattern>redis.clients.jedis</pattern>
-                                    <shadedPattern>me.lucko.luckperms.lib.jedis.jedis</shadedPattern>
-                                </relocation>
-                                <relocation>
-                                    <pattern>redis.clients.util</pattern>
-                                    <shadedPattern>me.lucko.luckperms.lib.jedis.util</shadedPattern>
-                                </relocation>
-                                <relocation>
-                                    <pattern>org.apache.commons.pool2</pattern>
-                                    <shadedPattern>me.lucko.luckperms.lib.jedis.pool2</shadedPattern>
+                                    <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.15-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>
@@ -25,9 +25,14 @@ 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;

@@ -56,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
@@ -208,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.15-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,72 +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>
-                                </relocation>
-                                <relocation>
-                                    <pattern>redis.clients.jedis</pattern>
-                                    <shadedPattern>me.lucko.luckperms.lib.jedis.jedis</shadedPattern>
-                                </relocation>
-                                <relocation>
-                                    <pattern>redis.clients.util</pattern>
-                                    <shadedPattern>me.lucko.luckperms.lib.jedis.util</shadedPattern>
-                                </relocation>
-                                <relocation>
-                                    <pattern>org.apache.commons.pool2</pattern>
-                                    <shadedPattern>me.lucko.luckperms.lib.jedis.pool2</shadedPattern>
+                                    <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>
@@ -134,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>
@@ -22,26 +22,29 @@

 package me.lucko.luckperms.bukkit;

-import com.google.common.collect.ImmutableList;
 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.model.Injector;
 import me.lucko.luckperms.bukkit.model.LPPermissible;
-import me.lucko.luckperms.common.calculators.CalculatorFactory;
+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.users.User;
+import me.lucko.luckperms.common.config.ConfigKeys;
+import me.lucko.luckperms.common.core.model.User;

 import java.util.UUID;

@AllArgsConstructor
-public class BukkitCalculatorFactory implements CalculatorFactory {
+public class BukkitCalculatorFactory extends AbstractCalculatorFactory {
    private final LPBukkitPlugin plugin;

    @Override
@@ -55,14 +58,14 @@ public class BukkitCalculatorFactory implements CalculatorFactory {
            LPPermissible permissible = Injector.getPermissible(uuid);
            return permissible == null ? null : permissible.getAttachmentPermissions();
        }));
-        if (plugin.getConfiguration().isApplyingWildcards()) {
-            processors.add(new WildcardProcessor());
-        }
-        if (plugin.getConfiguration().isApplyingRegex()) {
+        if (plugin.getConfiguration().get(ConfigKeys.APPLYING_REGEX)) {
            processors.add(new RegexProcessor());
        }
+        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(), processors.build());
+        return registerCalculator(new PermissionCalculator(plugin, user.getName(), processors.build()));
    }
 }
@@ -24,9 +24,11 @@ package me.lucko.luckperms.bukkit;

 import com.google.common.base.Joiner;
 import com.google.common.base.Splitter;
+
 import me.lucko.luckperms.common.commands.CommandManager;
 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;
@@ -35,7 +37,7 @@ import org.bukkit.command.TabExecutor;
 import java.util.Arrays;
 import java.util.List;

-class BukkitCommand extends CommandManager implements CommandExecutor, TabExecutor {
+public class BukkitCommand extends CommandManager implements CommandExecutor, TabExecutor {
    private final LPBukkitPlugin plugin;

    BukkitCommand(LPBukkitPlugin plugin) {
@@ -48,8 +50,7 @@ class BukkitCommand extends CommandManager implements CommandExecutor, TabExecut
        onCommand(
                plugin.getSenderFactory().wrap(sender),
                label,
-                Util.stripQuotes(Splitter.on(Patterns.COMMAND_SEPARATOR).omitEmptyStrings().splitToList(Joiner.on(' ').join(args))),
-                null
+                Util.stripQuotes(Splitter.on(Patterns.COMMAND_SEPARATOR).omitEmptyStrings().splitToList(Joiner.on(' ').join(args)))
        );
        return true;
    }
@@ -22,7 +22,11 @@

 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;

@@ -33,48 +37,48 @@ import java.util.Map;
 import java.util.Optional;
 import java.util.stream.Collectors;

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

    @Override
-    protected List<String> getList(String path, List<String> def) {
+    public List<String> getList(String path, List<String> def) {
        return Optional.ofNullable(configuration.getStringList(path)).orElse(def);
    }

    @Override
-    protected List<String> getObjectList(String path, List<String> def) {
+    public List<String> getObjectList(String path, List<String> def) {
        ConfigurationSection section = configuration.getConfigurationSection(path);
        if (section == null) {
            return def;
@@ -83,9 +87,8 @@ class BukkitConfig extends AbstractConfiguration<LPBukkitPlugin> {
        return Optional.ofNullable(section.getKeys(false).stream().collect(Collectors.toList())).orElse(def);
    }

-    @SuppressWarnings("unchecked")
    @Override
-    protected Map<String, String> getMap(String path, Map<String, String> def) {
+    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,34 +22,48 @@

 package me.lucko.luckperms.bukkit;

-import me.lucko.luckperms.bukkit.inject.Injector;
+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 (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());
@@ -62,6 +76,11 @@ class BukkitListener extends AbstractListener implements Listener {

    @EventHandler(priority = EventPriority.MONITOR)
    public void onPlayerPreLoginMonitor(AsyncPlayerPreLoginEvent e) {
+        // 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
@@ -69,12 +88,19 @@ class BukkitListener extends AbstractListener implements Listener {
        }
    }

-    @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;
@@ -91,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.
@@ -102,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.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);
        }

@@ -129,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;
        }

@@ -139,7 +170,7 @@ 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());
        }
@@ -151,4 +182,9 @@ class BukkitListener extends AbstractListener implements Listener {
            plugin.tryVaultHook(true);
        }
    }
+
+    @EventHandler
+    public void onWorldChange(PlayerChangedWorldEvent e) {
+        plugin.refreshAutoOp(e.getPlayer());
+    }
 }
@@ -22,17 +22,24 @@

 package me.lucko.luckperms.bukkit;

-import me.lucko.luckperms.common.LuckPermsPlugin;
+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 final MessageHandler messageHandler;
+
    public BukkitSenderFactory(LuckPermsPlugin plugin) {
        super(plugin);
+        messageHandler = new MessageHandler();
    }

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

    @Override
@@ -48,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
@@ -56,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,79 +23,100 @@
 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.api.context.ContextSet;
 import me.lucko.luckperms.api.context.MutableContextSet;
-import me.lucko.luckperms.bukkit.calculators.AutoOPListener;
+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.Sender;
-import me.lucko.luckperms.common.config.LPConfiguration;
+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.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.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.tracks.TrackManager;
-import me.lucko.luckperms.common.users.User;
-import me.lucko.luckperms.common.users.UserManager;
+import me.lucko.luckperms.common.treeview.PermissionVault;
 import me.lucko.luckperms.common.utils.BufferedRequest;
-import me.lucko.luckperms.common.utils.DebugHandler;
-import me.lucko.luckperms.common.utils.LocaleManager;
-import me.lucko.luckperms.common.utils.LogFactory;
+import me.lucko.luckperms.common.utils.LoggerImpl;
+
 import org.bukkit.World;
 import org.bukkit.command.PluginCommand;
 import org.bukkit.entity.Player;
+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.concurrent.Executor;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
 import java.util.stream.Collectors;

@Getter
 public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
-    private ExecutorService executorService;
-    private Executor syncExecutor;
-    private Executor asyncExecutor;
+    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 Storage storage;
-    private RedisMessaging redisMessaging = null;
+    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;
@@ -103,49 +124,92 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
    private boolean started = false;
    private DebugHandler debugHandler;
    private BukkitSenderFactory senderFactory;
+    private PermissionVault permissionVault;

    @Override
    public void onEnable() {
-        // Used whilst the server is still starting
-        executorService = Executors.newCachedThreadPool();
-        asyncExecutor = executorService;
-        syncExecutor = r -> getServer().getScheduler().runTask(this, r);
+        scheduler = new LPBukkitScheduler(this);

-        log = LogFactory.wrap(getLogger());
-        debugHandler = new DebugHandler();
+        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();
+
+        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 defaults, then refresh.
-        getServer().getScheduler().runTaskLater(this, () -> {
+        // 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();
-        pm.registerEvents(new BukkitListener(this), this);
+        listener = new BukkitListener(this);
+        pm.registerEvents(listener, this);

        // initialise datastore
-        storage = StorageFactory.getInstance(this, "h2");
+        storage = StorageFactory.getInstance(this, StorageType.H2);

-        // initialise redis
-        if (getConfiguration().isRedisEnabled()) {
+        // 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...");
-            redisMessaging = new RedisMessaging(this);
-            try {
-                redisMessaging.init(getConfiguration().getRedisAddress(), getConfiguration().getRedisPassword());
-                getLog().info("Loaded redis successfully...");
-            } catch (Exception e) {
-                getLog().info("Couldn't load redis...");
-                e.printStackTrace();
+            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
@@ -158,7 +222,7 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
        };

        // load locale
-        localeManager = new LocaleManager();
+        localeManager = new SimpleLocaleManager();
        File locale = new File(getDataFolder(), "lang.yml");
        if (locale.exists()) {
            getLog().info("Found locale file. Attempting to load from it.");
@@ -171,32 +235,26 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {

        // 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"));
+        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()));
-
-        // handle server operators
-        if (getConfiguration().isAutoOp()) {
-            contextManager.registerListener(new AutoOPListener());
-        }
+        contextManager.registerCalculator(new ServerCalculator<>(getConfiguration()));

        // Provide vault support
        tryVaultHook(false);
@@ -209,43 +267,83 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {


        // schedule update tasks
-        int mins = getConfiguration().getSyncTime();
+        int mins = getConfiguration().get(ConfigKeys.SYNC_TIME);
        if (mins > 0) {
            long ticks = mins * 60 * 20;
-            getServer().getScheduler().runTaskTimerAsynchronously(this, () -> updateTaskBuffer.request(), 20L, ticks);
+            scheduler.doAsyncRepeating(() -> updateTaskBuffer.request(), ticks);
        }
+        scheduler.doAsyncLater(() -> updateTaskBuffer.request(), 40L);

        // run an update instantly.
        updateTaskBuffer.requestDirectly();

        // register tasks
-        getServer().getScheduler().runTaskTimerAsynchronously(this, new ExpireTemporaryTask(this), 60L, 60L);
-        getServer().getScheduler().runTaskTimerAsynchronously(this, consecutiveExecutor, 20L, 20L);
+        scheduler.doAsyncRepeating(new ExpireTemporaryTask(this), 60L);
+        scheduler.doAsyncRepeating(new CacheHousekeepingTask(this), 2400L);

        // register permissions
-        registerPermissions(getConfiguration().isCommandsAllowOp() ? PermissionDefault.OP : PermissionDefault.FALSE);
-        if (!getConfiguration().isOpsEnabled()) {
-            getServer().getOperators().forEach(o -> o.setOp(false));
+        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)));
        }

        // replace the temporary executor when the Bukkit one starts
        getServer().getScheduler().runTaskAsynchronously(this, () -> {
-            asyncExecutor = r -> getServer().getScheduler().runTaskAsynchronously(this, r);
+            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...");
        storage.shutdown();

-        if (redisMessaging != null) {
-            getLog().info("Closing redis...");
-            redisMessaging.shutdown();
+        if (messagingService != null) {
+            getLog().info("Closing messaging service...");
+            messagingService.close();
        }

        getLog().info("Unregistering API...");
@@ -255,6 +353,38 @@ 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) {
@@ -279,18 +409,26 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
    }

    @Override
-    public void doAsync(Runnable r) {
-        asyncExecutor.execute(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) {
-        syncExecutor.execute(r);
-    }
+    public void refreshAutoOp(Player player) {
+        if (getConfiguration().get(ConfigKeys.AUTO_OP)) {
+            try {
+                LPPermissible permissible = Injector.getPermissible(player.getUniqueId());
+                if (permissible == null) {
+                    return;
+                }

-    @Override
-    public void doAsyncRepeating(Runnable r, long interval) {
-        getServer().getScheduler().runTaskTimerAsynchronously(this, r, interval, interval);
+                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
@@ -299,13 +437,28 @@ 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 String getServerVersion() {
+        return getServer().getVersion();
+    }
+
+    @Override
+    public File getDataDirectory() {
+        return super.getDataFolder();
+    }
+
+    @Override
+    public InputStream getResourceStream(String path) {
+        return getResource(path);
    }

    @Override
@@ -321,11 +474,11 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
        }
        return new Contexts(
                getContextManager().getApplicableContext(player),
-                getConfiguration().isIncludingGlobalPerms(),
-                getConfiguration().isIncludingGlobalWorldPerms(),
+                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),
                player.isOp()
        );
    }
@@ -346,12 +499,12 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
    }

    @Override
-    public boolean isOnline(UUID external) {
+    public boolean isPlayerOnline(UUID external) {
        return getServer().getPlayer(external) != null;
    }

    @Override
-    public List<Sender> getSenders() {
+    public List<Sender> getOnlineSenders() {
        return getServer().getOnlinePlayers().stream()
                .map(p -> getSenderFactory().wrap(p))
                .collect(Collectors.toList());
@@ -366,14 +519,14 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
    public Set<Contexts> getPreProcessContexts(boolean op) {
        Set<ContextSet> c = new HashSet<>();
        c.add(ContextSet.empty());
-        c.add(ContextSet.singleton("server", getConfiguration().getServer()));
+        c.add(ContextSet.singleton("server", getConfiguration().get(ConfigKeys.SERVER)));

        // Pre process all worlds
        c.addAll(getServer().getWorlds().stream()
                .map(World::getName)
                .map(s -> {
-                    MutableContextSet set = new MutableContextSet();
-                    set.add("server", getConfiguration().getServer());
+                    MutableContextSet set = MutableContextSet.create();
+                    set.add("server", getConfiguration().get(ConfigKeys.SERVER));
                    set.add("world", s);
                    return set.makeImmutable();
                })
@@ -381,13 +534,13 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
        );

        // Pre process the separate Vault server, if any
-        if (!getConfiguration().getServer().equals(getConfiguration().getVaultServer())) {
-            c.add(ContextSet.singleton("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 -> {
-                        MutableContextSet set = new MutableContextSet();
-                        set.add("server", getConfiguration().getVaultServer());
+                        MutableContextSet set = MutableContextSet.create();
+                        set.add("server", getConfiguration().get(ConfigKeys.VAULT_SERVER));
                        set.add("world", s);
                        return set.makeImmutable();
                    })
@@ -401,25 +554,25 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
        contexts.addAll(c.stream()
                .map(set -> new Contexts(
                        set,
-                        getConfiguration().isIncludingGlobalPerms(),
-                        getConfiguration().isIncludingGlobalWorldPerms(),
+                        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
-        boolean vaultDiff = getConfiguration().isVaultIncludingGlobal() != getConfiguration().isIncludingGlobalPerms() ||
-                !getConfiguration().isIncludingGlobalWorldPerms() ||
-                !getConfiguration().isApplyingGlobalGroups() ||
-                !getConfiguration().isApplyingGlobalWorldGroups();
+        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())
            );
        }
@@ -431,33 +584,22 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
    public LinkedHashMap<String, Object> getExtraInfo() {
        LinkedHashMap<String, Object> map = new LinkedHashMap<>();
        map.put("Vault Enabled", vaultHook != null);
-        map.put("Vault Server", configuration.getVaultServer());
+        map.put("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("World Cache size", worldCalculator.getWorldCache().size());
-        map.put("Vault Including Global", configuration.isVaultIncludingGlobal());
-        map.put("Vault Ignoring World", configuration.isVaultIgnoreWorld());
-        map.put("Vault Primary Group Overrides", configuration.isVaultPrimaryGroupOverrides());
-        map.put("Vault Debug", configuration.isVaultDebug());
-        map.put("OPs Enabled", configuration.isOpsEnabled());
-        map.put("Auto OP", configuration.isAutoOp());
-        map.put("Commands Allow OPs", configuration.isCommandsAllowOp());
+        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;
    }

-    @Override
-    public Object getPlugin(String name) {
-        return getServer().getPluginManager().getPlugin(name);
-    }
-
-    @Override
-    public Object getService(Class clazz) {
-        return getServer().getServicesManager().load(clazz);
-    }
-
    @SuppressWarnings("deprecation")
    @Override
-    public UUID getUUID(String playerName) {
+    public UUID getUuidFromUsername(String playerName) {
        try {
            return getServer().getOfflinePlayer(playerName).getUniqueId();
        } catch (Exception e) {
@@ -465,11 +607,6 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
        }
    }

-    @Override
-    public boolean isPluginLoaded(String name) {
-        return getServer().getPluginManager().isPluginEnabled(name);
-    }
-
    private void registerPermissions(PermissionDefault def) {
        PluginManager pm = getServer().getPluginManager();

@@ -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,32 +22,25 @@

 package me.lucko.luckperms.bukkit;

-import com.google.common.collect.Maps;
-import lombok.Getter;
 import lombok.RequiredArgsConstructor;
+
+import com.google.common.collect.Maps;
+
 import me.lucko.luckperms.api.context.ContextCalculator;
 import me.lucko.luckperms.api.context.MutableContextSet;
-import me.lucko.luckperms.common.LuckPermsPlugin;
+import 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 org.bukkit.event.player.PlayerLoginEvent;

 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 MutableContextSet giveApplicableContext(Player subject, MutableContextSet accumulator) {
        String world = getWorld(subject);
@@ -70,34 +63,7 @@ public class WorldCalculator extends ContextCalculator<Player> implements Listen
    }

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

@@ -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();
+            }
+        });
+    }
+}
@@ -22,23 +22,33 @@

 package me.lucko.luckperms.bukkit.migration;

-import de.bananaco.bpermissions.api.*;
-import me.lucko.luckperms.api.Logger;
+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.common.LuckPermsPlugin;
+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.Constants;
-import me.lucko.luckperms.common.core.PermissionHolder;
-import me.lucko.luckperms.common.data.LogEntry;
+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.exceptions.ObjectAlreadyHasException;
+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;

@@ -56,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 {
@@ -82,125 +187,21 @@ public class MigrationBPermissions extends SubCommand<Object> {
        }
    }

-    public MigrationBPermissions() {
-        super("bpermissions", "Migration from bPermissions", MIGRATION, Predicates.alwaysFalse(), null);
-    }
-
-    @Override
-    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List<String> args, String label) throws CommandException {
-        final Logger log = plugin.getLog();
-
-        WorldManager worldManager = WorldManager.getInstance();
-        if (worldManager == null) {
-            log.severe("bPermissions Migration: Error -> bPermissions is not loaded.");
-            return CommandResult.STATE_ERROR;
-        }
-
-        log.info("bPermissions Migration: Forcing the plugin to load all data. This could take a while.");
-        for (World world : worldManager.getAllWorlds()) {
-            Set<String> users = getUsers(world);
-            if (users == null) {
-                log.severe("bPermissions Migration: Couldn't get a list of users.");
-                return CommandResult.FAILURE;
-            }
-            users.forEach(s -> world.loadOne(s, CalculableType.USER));
-        }
-
-        // Migrate one world at a time.
-        log.info("bPermissions Migration: Starting world migration.");
-        for (World world : worldManager.getAllWorlds()) {
-            log.info("bPermissions Migration: Migrating world: " + world.getName());
-            
-            // Migrate all groups
-            log.info("bPermissions Migration: Starting group migration in world " + world.getName() + ".");
-            int groupCount = 0;
-            for (Calculable group : world.getAll(CalculableType.GROUP)) {
-                groupCount++;
-                String groupName = group.getName().toLowerCase();
-                if (group.getName().equalsIgnoreCase(world.getDefaultGroup())) {
-                    groupName = "default";
-                }
-
-                // Make a LuckPerms group for the one being migrated.
-                plugin.getStorage().createAndLoadGroup(groupName).join();
-                me.lucko.luckperms.common.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.getStorage().saveGroup(lpGroup);
-            }
-            log.info("bPermissions Migration: Migrated " + groupCount + " groups in world " + world.getName() + ".");
-
-            // Migrate all users
-            log.info("bPermissions Migration: Starting user migration in world " + world.getName() + ".");
-            int userCount = 0;
-            for (Calculable user : world.getAll(CalculableType.USER)) {
-                userCount++;
-
-                // There is no mention of UUIDs in the API. I assume that name = uuid. idk?
-                UUID uuid;
-                try {
-                    uuid = UUID.fromString(user.getName());
-                } catch (IllegalArgumentException e) {
-                    uuid = plugin.getUUID(user.getName());
-                }
-
-                if (uuid == null) {
-                    log.info("bPermissions Migration: Unable to migrate user " + user.getName() + ". Unable to get UUID.");
-                    continue;
-                }
-
-                // Make a LuckPerms user for the one being migrated.
-                plugin.getStorage().loadUser(uuid, "null").join();
-                me.lucko.luckperms.common.users.User lpUser = plugin.getUserManager().get(uuid);
-
-                migrateHolder(plugin, world, user, lpUser);
-
-                plugin.getStorage().saveUser(lpUser);
-                plugin.getUserManager().cleanup(lpUser);
-            }
-
-            log.info("bPermissions Migration: Migrated " + userCount + " users in world " + world.getName() + ".");
-        }
-
-        log.info("bPermissions Migration: Success! Completed without any errors.");
-        return CommandResult.SUCCESS;
-    }
-    
-    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);
                }
            }
        }
@@ -209,14 +210,8 @@ 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);
            }
        }

@@ -226,29 +221,18 @@ public class MigrationBPermissions extends SubCommand<Object> {
                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);
            }
        }
    }
+
 }
@@ -22,66 +22,77 @@

 package me.lucko.luckperms.bukkit.migration;

-import me.lucko.luckperms.api.Logger;
-import me.lucko.luckperms.common.LuckPermsPlugin;
+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.Constants;
 import me.lucko.luckperms.common.constants.Permission;
-import me.lucko.luckperms.common.core.NodeFactory;
-import me.lucko.luckperms.common.data.LogEntry;
+import me.lucko.luckperms.common.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.*;
+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("world names...", false, "a list of worlds to migrate permissions from"))
+                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 {
-        final Logger log = plugin.getLog();
-        if (!plugin.isPluginLoaded("GroupManager")) {
-            log.severe("GroupManager Migration: Error -> GroupManager is not loaded.");
+        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;
        }

-        final List<String> worlds = args.stream()
-                .map(String::toLowerCase)
-                .collect(Collectors.toList());
+        List<String> worlds = Bukkit.getWorlds().stream().map(World::getName).map(String::toLowerCase).collect(Collectors.toList());

-        GroupManager gm = (GroupManager) plugin.getPlugin("GroupManager");
+        GroupManager gm = (GroupManager) Bukkit.getPluginManager().getPlugin("GroupManager");

        // Migrate Global Groups
-        log.info("GroupManager Migration: Starting Global Group migration.");
+        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()).join();
-            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();
+            me.lucko.luckperms.common.core.model.Group group = plugin.getGroupManager().getIfLoaded(g.getName().toLowerCase());

            for (String node : g.getPermissionList()) {
                boolean value = true;
@@ -95,47 +106,45 @@ public class MigrationGroupManager extends SubCommand<Object> {

                try {
                    group.setPermission(node, value);
-                    LogEntry.build()
-                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
-                            .acted(group).action("set " + node + " " + value)
-                            .build().submit(plugin);
                } catch (Exception ex) {
-                    if (!(ex instanceof ObjectAlreadyHasException)) {
-                        ex.printStackTrace();
-                    }
+                    log.handleException(ex);
                }
            }

            for (String s : g.getInherits()) {
                try {
                    group.setPermission("group." + s.toLowerCase(), true);
-                    LogEntry.build()
-                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
-                            .acted(group).action("setinherit " + s.toLowerCase())
-                            .build().submit(plugin);
                } catch (Exception ex) {
-                    if (!(ex instanceof ObjectAlreadyHasException)) {
-                        ex.printStackTrace();
-                    }
+                    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.info("GroupManager Migration: Starting user and group migration.");
+        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<>());

@@ -149,19 +158,23 @@ public class MigrationGroupManager extends SubCommand<Object> {
                        value = true;
                    }

-                    groups.get(g.getName().toLowerCase()).put(new AbstractMap.SimpleEntry<>(world, node), value);
+                    groups.get(g.getName().toLowerCase()).put(Maps.immutableEntry(worldMappingFunc.apply(world), node), value);
                }

                for (String s : g.getInherits()) {
-                    groups.get(g.getName().toLowerCase()).put(new AbstractMap.SimpleEntry<>(world, "group." + s.toLowerCase()), true);
+                    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){
+                } catch (IllegalArgumentException e) {
+                    log.logErr("Could not parse UUID for user: " + user.getUUID());
                    continue;
                }

@@ -177,94 +190,72 @@ public class MigrationGroupManager extends SubCommand<Object> {
                        value = true;
                    }

-                    users.get(uuid).put(new AbstractMap.SimpleEntry<>(world, node), value);
+                    users.get(uuid).put(Maps.immutableEntry(worldMappingFunc.apply(world), node), value);
                }

-                String finalWorld = world;
+                String finalWorld = worldMappingFunc.apply(world);
+
+                // Collect sub groups
                users.get(uuid).putAll(user.subGroupListStringCopy().stream()
                        .map(n -> "group." + n)
-                        .map(n -> new AbstractMap.SimpleEntry<>(finalWorld, 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.info("GroupManager Migration: All existing GroupManager data has been processed. Now beginning the import process.");
-        log.info("GroupManager Migration: Found a total of " + users.size() + " users and " + groups.size() + " groups.");
+        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()).join();
-            me.lucko.luckperms.common.groups.Group group = plugin.getGroupManager().get(e.getKey());
-            try {
-                LogEntry.build()
-                        .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
-                        .acted(group).action("create")
-                        .build().submit(plugin);
-            } catch (Exception ex) {
-                ex.printStackTrace();
-            }
-
+            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 {
-                    group.setPermission(NodeFactory.fromSerialisedNode("global-" + n.getKey().getKey() + "/" + n.getKey().getValue(), n.getValue()));
-
-                    if (n.getKey().getValue().startsWith("group.")) {
-                        String groupName = n.getKey().getValue().substring(6);
-                        LogEntry.build()
-                                .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
-                                .acted(group).action("setinherit " + groupName + " global " + n.getKey().getKey())
-                                .build().submit(plugin);
+                    if (n.getKey().getKey().equals("")) {
+                        group.setPermission(n.getKey().getValue(), n.getValue());
                    } else {
-                        LogEntry.build()
-                                .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
-                                .acted(group).action("set " + n.getKey().getValue() + " " + n.getValue() + " global " + n.getKey().getKey())
-                                .build().submit(plugin);
+                        group.setPermission(n.getKey().getValue(), n.getValue(), "global", n.getKey().getKey());
                    }
-
                } catch (Exception ex) {
-                    if (!(ex instanceof ObjectAlreadyHasException)) {
-                        ex.printStackTrace();
-                    }
+                    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.users.User user = plugin.getUserManager().get(e.getKey());
+            me.lucko.luckperms.common.core.model.User user = plugin.getUserManager().get(e.getKey());

            for (Map.Entry<Map.Entry<String, String>, Boolean> n : e.getValue().entrySet()) {
                // n.key.key = world
                // n.key.value = node
                // n.value = true/false
                try {
-                    user.setPermission(NodeFactory.fromSerialisedNode("global-" + n.getKey().getKey() + "/" + n.getKey().getValue(), n.getValue()));
-
-                    if (n.getKey().getValue().startsWith("group.")) {
-                        String group = n.getKey().getValue().substring(6);
-                        LogEntry.build()
-                                .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
-                                .acted(user).action("addgroup " + group + " global " + n.getKey().getKey())
-                                .build().submit(plugin);
+                    if (n.getKey().getKey().equals("")) {
+                        user.setPermission(n.getKey().getValue(), n.getValue());
                    } else {
-                        LogEntry.build()
-                                .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
-                                .acted(user).action("set " + n.getKey().getValue() + " " + n.getValue() + " global " + n.getKey().getKey())
-                                .build().submit(plugin);
+                        user.setPermission(n.getKey().getValue(), n.getValue(), "global", n.getKey().getKey());
                    }
-
                } catch (Exception ex) {
-                    if (!(ex instanceof ObjectAlreadyHasException)) {
-                        ex.printStackTrace();
-                    }
+                    log.handleException(ex);
                }
            }

@@ -281,9 +272,11 @@ public class MigrationGroupManager extends SubCommand<Object> {

            plugin.getStorage().saveUser(user);
            plugin.getUserManager().cleanup(user);
+            log.logProgress("Migrated {} users so far.", userCount.incrementAndGet());
        }

-        log.info("GroupManager Migration: Success! Completed without any errors.");
+        log.log("Migrated " + userCount.get() + " users.");
+        log.log("Success! Migration complete.");
        return CommandResult.SUCCESS;
    }
 }
@@ -22,22 +22,24 @@

 package me.lucko.luckperms.bukkit.migration;

-import me.lucko.luckperms.api.Logger;
 import me.lucko.luckperms.api.MetaUtils;
-import me.lucko.luckperms.api.PlatformType;
-import me.lucko.luckperms.common.LuckPermsPlugin;
-import me.lucko.luckperms.common.commands.Arg;
+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.Constants;
 import me.lucko.luckperms.common.constants.Permission;
-import me.lucko.luckperms.common.data.LogEntry;
-import me.lucko.luckperms.common.groups.Group;
-import me.lucko.luckperms.common.users.User;
+import me.lucko.luckperms.common.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;
@@ -47,35 +49,31 @@ 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(),
-                Arg.list(Arg.create("world names...", false, "a list of worlds to migrate permissions from"))
-        );
+        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 {
-        final Logger log = plugin.getLog();
-        if (!plugin.isPluginLoaded("PermissionsEx")) {
-            log.severe("PermissionsEx Migration: Error -> PermissionsEx is not loaded.");
+        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;
        }

-        if (plugin.getType() != PlatformType.BUKKIT) {
-            // Sponge uses a completely different version of PEX.
-            log.severe("PEX import is not supported on this platform.");
-            return CommandResult.STATE_ERROR;
-        }
+        List<String> worlds = Bukkit.getWorlds().stream().map(World::getName).map(String::toLowerCase).collect(Collectors.toList());

-        final List<String> worlds = args.stream()
-                .map(String::toLowerCase)
-                .collect(Collectors.toList());
-
-        PermissionsEx pex = (PermissionsEx) plugin.getPlugin("PermissionsEx");
+        PermissionsEx pex = (PermissionsEx) Bukkit.getPluginManager().getPlugin("PermissionsEx");
        PermissionManager manager = pex.getPermissionsManager();

        NativeInterface ni;
@@ -88,28 +86,22 @@ public class MigrationPermissionsEx extends SubCommand<Object> {
            return CommandResult.FAILURE;
        }

-        // Migrate all groups.
-        log.info("PermissionsEx Migration: Starting group migration.");
-
-        int maxGroupWeight = 0;
-        int groupCount = 0;
-
+        log.log("Calculating group weightings.");
+        int maxWeight = 0;
        for (PermissionGroup group : manager.getGroupList()) {
-            int groupWeight = group.getWeight() * -1;
-            groupCount ++;
-            maxGroupWeight = Math.max(maxGroupWeight, groupWeight);
+            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).join();
-            Group lpGroup = plugin.getGroupManager().get(name);
-            try {
-                LogEntry.build()
-                        .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
-                        .acted(lpGroup).action("create")
-                        .build().submit(plugin);
-            } catch (Exception ex) {
-                ex.printStackTrace();
-            }
+            plugin.getStorage().createAndLoadGroup(name, CreationCause.INTERNAL).join();
+            Group lpGroup = plugin.getGroupManager().getIfLoaded(name);

            try {
                for (String node : group.getOwnPermissions(null)) {
@@ -121,40 +113,26 @@ public class MigrationPermissionsEx extends SubCommand<Object> {

                    try {
                        lpGroup.setPermission(node, value);
-                        LogEntry.build()
-                                .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
-                                .acted(lpGroup).action("set " + node + " " + value)
-                                .build().submit(plugin);
                    } catch (Exception ex) {
-                        if (!(ex instanceof ObjectAlreadyHasException)) {
-                            ex.printStackTrace();
-                        }
+                        log.handleException(ex);
                    }
                }
            } catch (NullPointerException ignored) {
-                // Probably won't happen. I have no API docs on getOwnPermissions#null though.
+                // No docs on if #getOwnPermissions(null) is ok. Should be fine though.
            }

-            if (worlds != null && !worlds.isEmpty()) {
-                for (String world : worlds) {
-                    for (String node : group.getOwnPermissions(world)) {
-                        boolean value = true;
-                        if (node.startsWith("-")) {
-                            node = node.substring(1);
-                            value = false;
-                        }
+            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);
-                            LogEntry.build()
-                                    .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
-                                    .acted(lpGroup).action("set " + node + " " + value + " global " + world)
-                                    .build().submit(plugin);
-                        } catch (Exception ex) {
-                            if (!(ex instanceof ObjectAlreadyHasException)) {
-                                ex.printStackTrace();
-                            }
-                        }
+                    try {
+                        lpGroup.setPermission(node, value, "global", world.toLowerCase());
+                    } catch (Exception ex) {
+                        log.handleException(ex);
                    }
                }
            }
@@ -162,31 +140,17 @@ public class MigrationPermissionsEx extends SubCommand<Object> {
            for (PermissionGroup g : group.getParents()) {
                try {
                    lpGroup.setPermission("group." + g.getName().toLowerCase(), true);
-                    LogEntry.build()
-                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
-                            .acted(lpGroup).action("setinherit " + g.getName().toLowerCase())
-                            .build().submit(plugin);
                } catch (Exception ex) {
-                    if (!(ex instanceof ObjectAlreadyHasException)) {
-                        ex.printStackTrace();
-                    }
+                    log.handleException(ex);
                }
            }

-            if (worlds != null && !worlds.isEmpty()) {
-                for (String world : worlds) {
-                    for (PermissionGroup g : group.getParents(world)) {
-                        try {
-                            lpGroup.setPermission("group." + g.getName().toLowerCase(), true, "global", world);
-                            LogEntry.build()
-                                    .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
-                                    .acted(lpGroup).action("setinherit " + g.getName().toLowerCase() + " global " + world)
-                                    .build().submit(plugin);
-                        } catch (Exception ex) {
-                            if (!(ex instanceof ObjectAlreadyHasException)) {
-                                ex.printStackTrace();
-                            }
-                        }
+            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);
                    }
                }
            }
@@ -198,14 +162,8 @@ public class MigrationPermissionsEx extends SubCommand<Object> {
                prefix = MetaUtils.escapeCharacters(prefix);
                try {
                    lpGroup.setPermission("prefix." + groupWeight + "." + prefix, true);
-                    LogEntry.build()
-                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
-                            .acted(lpGroup).action("set prefix." + groupWeight + "." + prefix + " true")
-                            .build().submit(plugin);
                } catch (Exception ex) {
-                    if (!(ex instanceof ObjectAlreadyHasException)) {
-                        ex.printStackTrace();
-                    }
+                    log.handleException(ex);
                }
            }

@@ -213,46 +171,40 @@ public class MigrationPermissionsEx extends SubCommand<Object> {
                suffix = MetaUtils.escapeCharacters(suffix);
                try {
                    lpGroup.setPermission("suffix." + groupWeight + "." + suffix, true);
-                    LogEntry.build()
-                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
-                            .acted(lpGroup).action("set suffix." + groupWeight + "." + suffix + " true")
-                            .build().submit(plugin);
                } catch (Exception ex) {
-                    if (!(ex instanceof ObjectAlreadyHasException)) {
-                        ex.printStackTrace();
-                    }
+                    log.handleException(ex);
                }
            }

            plugin.getStorage().saveGroup(lpGroup);
-
+            log.logAllProgress("Migrated {} groups so far.", groupCount.incrementAndGet());
        }
-
-        log.info("PermissionsEx Migration: Migrated " + groupCount + " groups");
+        log.log("Migrated " + groupCount.get() + " groups");

        // Migrate all users
-        log.info("PermissionsEx Migration: Starting user migration.");
-        int userCount = 0;
-        maxGroupWeight++;
-        for (PermissionUser user : manager.getUsers()) {
-            UUID u = null;
+        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.getUUID(user.getIdentifier());
+                    u = plugin.getUuidFromUsername(user.getIdentifier());
                }
            }

            if (u == null) {
-                log.severe("Unable to get a UUID for user identifier: " + user.getIdentifier());
+                log.logErr("Unable to get a UUID for user identifier: " + user.getIdentifier());
                continue;
            }

-            userCount++;
-            plugin.getStorage().loadUser(u, "null").join();
+            plugin.getStorage().loadUser(u, user.getName()).join();
            User lpUser = plugin.getUserManager().get(u);

            try {
@@ -265,40 +217,26 @@ public class MigrationPermissionsEx extends SubCommand<Object> {

                    try {
                        lpUser.setPermission(node, value);
-                        LogEntry.build()
-                                .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
-                                .acted(lpUser).action("set " + node + " " + value)
-                                .build().submit(plugin);
                    } catch (Exception ex) {
-                        if (!(ex instanceof ObjectAlreadyHasException)) {
-                            ex.printStackTrace();
-                        }
+                        log.handleException(ex);
                    }
                }
            } catch (NullPointerException ignored) {
-                // Probably won't happen. I have no API docs on getOwnPermissions#null though.
+                // No docs on if #getOwnPermissions(null) is ok. Should be fine though.
            }

-            if (worlds != null && !worlds.isEmpty()) {
-                for (String world : worlds) {
-                    for (String node : user.getOwnPermissions(world)) {
-                        boolean value = true;
-                        if (node.startsWith("-")) {
-                            node = node.substring(1);
-                            value = false;
-                        }
+            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);
-                            LogEntry.build()
-                                    .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
-                                    .acted(lpUser).action("set " + node + " " + value + " global " + world)
-                                    .build().submit(plugin);
-                        } catch (Exception ex) {
-                            if (!(ex instanceof ObjectAlreadyHasException)) {
-                                ex.printStackTrace();
-                            }
-                        }
+                    try {
+                        lpUser.setPermission(node, value, "global", world.toLowerCase());
+                    } catch (Exception ex) {
+                        log.handleException(ex);
                    }
                }
            }
@@ -306,31 +244,17 @@ public class MigrationPermissionsEx extends SubCommand<Object> {
            for (String s : user.getGroupNames()) {
                try {
                    lpUser.setPermission("group." + s.toLowerCase(), true);
-                    LogEntry.build()
-                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
-                            .acted(lpUser).action("addgroup " + s.toLowerCase())
-                            .build().submit(plugin);
                } catch (Exception ex) {
-                    if (!(ex instanceof ObjectAlreadyHasException)) {
-                        ex.printStackTrace();
-                    }
+                    log.handleException(ex);
                }
            }

-            if (worlds != null && !worlds.isEmpty()) {
-                for (String world : worlds) {
-                    for (String s : user.getGroupNames(world)) {
-                        try {
-                            lpUser.setPermission("group." + s.toLowerCase(), true, "global", world);
-                            LogEntry.build()
-                                    .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
-                                    .acted(lpUser).action("addgroup " + s.toLowerCase() + " global " + world)
-                                    .build().submit(plugin);
-                        } catch (Exception ex) {
-                            if (!(ex instanceof ObjectAlreadyHasException)) {
-                                ex.printStackTrace();
-                            }
-                        }
+            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);
                    }
                }
            }
@@ -341,55 +265,48 @@ public class MigrationPermissionsEx extends SubCommand<Object> {
            if (prefix != null && !prefix.equals("")) {
                prefix = MetaUtils.escapeCharacters(prefix);
                try {
-                    lpUser.setPermission("prefix." + maxGroupWeight + "." + prefix, true);
-                    LogEntry.build()
-                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
-                            .acted(lpUser).action("set prefix." + maxGroupWeight + "." + prefix + " true")
-                            .build().submit(plugin);
+                    lpUser.setPermission("prefix." + maxWeight + "." + prefix, true);
                } catch (Exception ex) {
-                    if (!(ex instanceof ObjectAlreadyHasException)) {
-                        ex.printStackTrace();
-                    }
+                    log.handleException(ex);
                }
            }

            if (suffix != null && !suffix.equals("")) {
                suffix = MetaUtils.escapeCharacters(suffix);
                try {
-                    lpUser.setPermission("suffix." + maxGroupWeight + "." + suffix, true);
-                    LogEntry.build()
-                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
-                            .acted(lpUser).action("set suffix." + maxGroupWeight + "." + suffix + " true")
-                            .build().submit(plugin);
+                    lpUser.setPermission("suffix." + maxWeight + "." + suffix, true);
                } catch (Exception ex) {
-                    if (!(ex instanceof ObjectAlreadyHasException)) {
-                        ex.printStackTrace();
-                    }
+                    log.handleException(ex);
                }
            }

+            // Lowest rank is the highest group #logic
            String primary = null;
-            int weight = -100;
+            int weight = Integer.MAX_VALUE;
            for (PermissionGroup group : user.getOwnParents()) {
-                if (group.getRank() > weight) {
+                if (group.getRank() < weight) {
                    primary = group.getName();
-                    weight = group.getWeight();
+                    weight = group.getRank();
                }
            }

-            if (primary != null) {
+            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.info("PermissionsEx Migration: Migrated " + userCount + " users.");
-        log.info("PermissionsEx Migration: Success! Completed without any errors.");
+        log.log("Migrated " + userCount.get() + " users.");
+        log.log("Success! Migration complete.");
        return CommandResult.SUCCESS;
    }
 }
@@ -22,25 +22,29 @@

 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.api.event.cause.CreationCause;
 import me.lucko.luckperms.bukkit.migration.utils.LPResultRunnable;
-import me.lucko.luckperms.common.LuckPermsPlugin;
 import me.lucko.luckperms.common.commands.Arg;
 import me.lucko.luckperms.common.commands.CommandException;
 import me.lucko.luckperms.common.commands.CommandResult;
 import me.lucko.luckperms.common.commands.SubCommand;
 import me.lucko.luckperms.common.commands.sender.Sender;
-import me.lucko.luckperms.common.constants.Constants;
-import me.lucko.luckperms.common.core.PermissionHolder;
-import me.lucko.luckperms.common.data.LogEntry;
-import me.lucko.luckperms.common.users.User;
+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.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.common.utils.ProgressLogger;
+
+import org.bukkit.Bukkit;

 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
@@ -48,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;

@@ -119,7 +122,6 @@ public class MigrationPowerfulPerms extends SubCommand<Object> {
        }
    }

-
    public MigrationPowerfulPerms() {
        super("powerfulperms", "Migration from PowerfulPerms", MIGRATION, Predicates.not(5),
                Arg.list(
@@ -135,53 +137,22 @@ public class MigrationPowerfulPerms extends SubCommand<Object> {
    @Override
    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;
        }

@@ -192,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.getStorage().createAndLoadGroup(g.getName().toLowerCase()).join();
-            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.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
@@ -298,7 +259,7 @@ public class MigrationPowerfulPerms extends SubCommand<Object> {

            // 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) {
@@ -311,7 +272,7 @@ public class MigrationPowerfulPerms extends SubCommand<Object> {
            });

            // 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"))) {
@@ -336,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);
                                            }
                                        }
                                    }
@@ -369,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);
                                            }
                                        }

@@ -396,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);
                                            }
                                        }
                                    }
@@ -438,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();
                                }
@@ -452,7 +377,6 @@ public class MigrationPowerfulPerms extends SubCommand<Object> {
                        e.printStackTrace();
                    }
                } catch (IllegalAccessException | InvocationTargetException e) {
-                    log.info("PowerfulPerms Migration: Error");
                    e.printStackTrace();
                }
            } else {
@@ -460,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();
                }
            }
@@ -472,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;
@@ -495,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("!")) {
@@ -532,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);
                }
            }

@@ -559,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();
+            }
+        }
+    }
 }
@@ -22,30 +22,35 @@

 package me.lucko.luckperms.bukkit.migration;

-import me.lucko.luckperms.api.Logger;
-import me.lucko.luckperms.common.LuckPermsPlugin;
+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.PermissionHolder;
-import me.lucko.luckperms.common.groups.Group;
-import me.lucko.luckperms.common.tracks.Track;
-import me.lucko.luckperms.common.users.User;
+import me.lucko.luckperms.common.core.model.Group;
+import me.lucko.luckperms.common.core.model.PermissionHolder;
+import me.lucko.luckperms.common.core.model.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() {
@@ -54,20 +59,25 @@ public class MigrationZPermissions extends SubCommand<Object> {

    @Override
    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List<String> args, String label) throws CommandException {
-        final Logger log = plugin.getLog();
-        if (!plugin.isPluginLoaded("zPermissions")) {
-            log.severe("zPermissions Migration: Error -> zPermissions is not loaded.");
+        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;
        }

-        ZPermissionsService service = (ZPermissionsService) plugin.getService(ZPermissionsService.class);
-        if (service == null) {
-            log.severe("zPermissions Migration: Error -> zPermissions is not loaded.");
+        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);
@@ -78,46 +88,59 @@ public class MigrationZPermissions extends SubCommand<Object> {
        }

        // Migrate all groups
-        log.info("zPermissions Migration: Starting group migration.");
+        log.log("Starting group migration.");
+        AtomicInteger groupCount = new AtomicInteger(0);
        for (String g : service.getAllGroups()) {
-            plugin.getStorage().createAndLoadGroup(g.toLowerCase()).join();
-            Group group = plugin.getGroupManager().get(g.toLowerCase());
+            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);
+            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.info("zPermissions Migration: Starting track migration.");
+        log.log("Starting track migration.");
+        AtomicInteger trackCount = new AtomicInteger(0);
        for (String t : service.getAllTracks()) {
-            plugin.getStorage().createAndLoadTrack(t.toLowerCase()).join();
-            Track track = plugin.getTrackManager().get(t.toLowerCase());
+            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.info("zPermissions Migration: Starting user migration.");
+        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);
+            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.info("zPermissions Migration: Success! Completed without any errors.");
+        log.log("Migrated " + userCount.get() + " users.");
+        log.log("Success! Migration complete.");
        return CommandResult.SUCCESS;
    }

-    private void migrateEntity(PermissionHolder group, PermissionEntity entity) {
+    private void migrateEntity(PermissionHolder group, PermissionEntity entity, List<Membership> memberships) {
        for (Entry e : entity.getPermissions()) {
            if (e.getWorld() != null) {
                try {
@@ -130,15 +153,21 @@ public class MigrationZPermissions extends SubCommand<Object> {
            }
        }

-        for (Inheritance inheritance : entity.getInheritancesAsChild()) {
-            if (!inheritance.getChild().getId().equals(entity.getId())) {
-                new Throwable("Illegal inheritance").printStackTrace();
-                continue;
+        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) {}
            }
-
-            try {
-                group.setPermission("group." + inheritance.getParent(), true);
-            } catch (ObjectAlreadyHasException ignored) {}
        }

        for (EntityMetadata metadata : entity.getMetadata()) {
@@ -26,6 +26,7 @@ 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> {
Author	SHA1	Message	Date
Luck	6798fb21b2	Events rewrite, remove most deprecated API methods (v3.0)	2017-02-19 14:57:20 +00:00
Luck	89ff3b169b	Fix bukkit child permission handling to not include permissions with no children & cleanup permission registration	2017-02-18 21:01:09 +00:00
Luck	abddb265be	ensure all bukkit permissions are registered on startup	2017-02-18 08:50:06 +00:00
Luck	b328fa74a7	Clarify thrown exception when a null context is returned	2017-02-16 21:45:43 +00:00
Luck	f97aa651a0	Fix NPE caused by generating the wrong ExtractedContexts type - closes #185	2017-02-16 21:43:27 +00:00
Luck	8d86eed0a7	Don't bother adding checks to the listener queue if no listeners are registered	2017-02-15 19:39:24 +00:00
Luck	05f906a759	Add /lp tree command - closes #175	2017-02-15 19:21:27 +00:00
Luck	4b16be1b75	Fix setting chat meta with Vault, remove unnecessary permissible recalculations & general cleanup	2017-02-15 12:53:52 +00:00
Luck	bd97a7c5d2	Respect prefix option set in subject - closes #149	2017-02-14 17:11:17 +00:00
Luck	a3a23d8870	Remove redundant SQL queries and fix issue where multiple uuids could be mapped to the same username - fixes #179	2017-02-14 16:23:54 +00:00
Luck	30bddceac5	import log should be sent to console too	2017-02-13 16:26:41 +00:00
Luck	989a2cc89c	Make the bukkit command manager more accessible	2017-02-13 12:53:22 +00:00
Luck	3f17e8c3c8	Test verbose filters before registering them (#178 )	2017-02-12 17:19:16 +00:00
Luck	140e6b08ca	Apply regex perms before wildcards	2017-02-11 12:12:28 +00:00
Luck	6a39b721ba	Fix sponge service returning subjects in reverse priority order	2017-02-09 23:00:48 +00:00
Luck	1df6f4b9df	Allow negated group permissions	2017-02-08 21:04:34 +00:00
Luck	9493fb3a7a	Switch SpongeGroup meta handling to use MetaHolder - closes #171	2017-02-06 22:38:03 +00:00
Luck	0d1f3b855f	Ignore commented lines on dump imports & add annotations to export files - closes #169	2017-02-05 09:58:24 +00:00
Michael Vorburger	0982154a15	"Explaination" --> "Explanation" (#168 )	2017-02-04 22:32:34 +00:00
Luck	378f3f5efa	Fix NPE for vault getUserMeta when defaultValue is null and the LP value is also null	2017-02-04 17:45:26 +00:00
Luck	9b8d6e1dc7	Modify node escaping to use "\" characters, and remove all limits on node/server/world strings - closes #166	2017-02-04 12:18:45 +00:00
Luck	6540c695de	Add configurable duration handling when a holder already has a temporary permission/parent/option set - closes #152	2017-02-03 22:24:42 +00:00
Luck	1d71ec07be	fix option lookups in specific contexts returning as global instead	2017-02-03 17:18:18 +00:00
Luck	c837dd5cc8	fix jedis shading - closes #158	2017-02-02 16:00:18 +00:00
Luck	bc52e4da0e	Fix OPs disabled message	2017-02-02 15:58:34 +00:00
Luck	f0b4040458	Fix Sponge PEX meta migration weightings	2017-02-02 15:33:15 +00:00
Luck	d804c4be2a	fix build	2017-02-02 15:16:08 +00:00
Luck	ede413a213	Fix import/export handling - closes #159	2017-02-02 15:13:44 +00:00
Luck	9cee319ed9	Cleanup all migration commands - closes #63	2017-02-01 18:41:15 +00:00
Luck	f7b281f655	Fix build	2017-01-31 12:32:18 +00:00
Luck	8dbb083b90	Fix migration log being sent to the console twice	2017-01-31 12:29:06 +00:00
Luck	0be6d658ed	Refactor plugin and scheduler interfaces	2017-01-31 12:14:42 +00:00
Luck	1efce41767	Fix search command page number	2017-01-30 20:13:19 +00:00
Luck	da23b6ea9a	Fix search command page number	2017-01-30 20:13:19 +00:00
Luck	a61d3b3fd4	Fix sponge PEX/PM migration issue with defaults	2017-01-29 21:56:09 +00:00
Luck	ab9284b80f	Use reflection in the #getAllKeys method instead of a list	2017-01-29 14:52:42 +00:00
Luck	424af27a47	Change update messages to account for more than just redis messaging	2017-01-29 11:09:11 +00:00
Luck	5039a05055	Update readme	2017-01-27 20:37:27 +00:00
Luck	d150b22eae	fix NPE on login	2017-01-26 21:05:44 +00:00
Luck	a617675771	prettify the verbose paste output	2017-01-26 19:47:46 +00:00
Luck	f27034bb35	Pull git commit id once only - should improve build time	2017-01-26 13:55:06 +00:00
Luck	86b203c21b	Compile with shaded redis version - fixes #150	2017-01-26 13:54:23 +00:00
Luck	73c5a1ad9b	Fix apache pool2 jar not loading correctly - closes #150	2017-01-25 22:07:50 +00:00
Luck	81c71777cb	Fix some usage messages	2017-01-24 21:48:47 +00:00
Luck	599072eef6	Fix null config values throwing exception - closes #147	2017-01-24 20:13:18 +00:00
Luck	02ea3afbe9	Add "!" delimiter to verbose matching	2017-01-23 22:47:39 +00:00
Luck	0c1a2e82bf	implement verbose expression matching	2017-01-23 22:43:52 +00:00
Luck	f89fb87c92	Log the file name when I/O fails	2017-01-23 21:15:25 +00:00
Luck	98d6cf842a	reword check result message slightly	2017-01-23 21:08:27 +00:00
Luck	69dc02b2c2	Add /lp check <user> <permission> command	2017-01-23 21:03:58 +00:00
Luck	7d1a3d32e9	Fix login NPE when async tasks run after the event has been fully handled	2017-01-23 16:22:25 +00:00
Luck	d93cc826b2	Fix backwards compatibility with redis	2017-01-22 22:49:11 +00:00
Luck	8025f3a082	Fix all users sharing the same meta state	2017-01-22 22:19:29 +00:00
Luck	247871f678	Cancel messaging task when the message is sent	2017-01-22 21:47:57 +00:00
Luck	327c8b83be	Implement BungeeCord & LilyPad messaging services - closes #142	2017-01-22 21:46:22 +00:00
Luck	0f8c334de8	FIx stacking backwards compatibility	2017-01-22 19:01:34 +00:00
Luck	292d4cd450	Implement stacking prefixes - closes #60	2017-01-22 18:23:08 +00:00
Luck	38d1c9974b	Soften server checking regex - also towards #143	2017-01-22 16:36:06 +00:00
Luck	0be7300677	Fix node shorthand parsing - closes #143	2017-01-22 16:29:52 +00:00
Luck	c03585aeca	Fix using UTF-8 characters with MySQL - closes #129	2017-01-22 12:19:29 +00:00
Luck	d39dad3287	Fix config reloading causing ClassCastExceptions	2017-01-22 11:58:48 +00:00
Luck	0a3ca3affe	Add /lp reloadconfig command - closes #100	2017-01-21 20:14:25 +00:00
Luck	b7cf0e6bc7	Refactor config handling - towards #100	2017-01-21 15:36:13 +00:00
Luck	7430013cc3	don't unload sponge data when a player quits	2017-01-20 20:02:42 +00:00
Luck	6dd093fe72	fix API ClassCastException	2017-01-19 21:29:54 +00:00
Luck	8a8d6f16ae	Return subjects in priority order - related CodeCrafter47/BungeeTabListPlus#175	2017-01-19 21:09:44 +00:00
Luck	2e16844141	Remove console only commands - closes #137	2017-01-19 20:39:09 +00:00
Luck	a152cc47c7	Fix bukkit login handling - closes #110	2017-01-19 20:04:22 +00:00
Luck	241507228f	Colorize console info messages	2017-01-19 19:51:41 +00:00
Luck	8aa7d272fa	Include license file in the jars	2017-01-19 19:03:59 +00:00
Luck	01ac5382ea	Prevent some shutdown exceptions - closes #136	2017-01-19 18:56:22 +00:00
Luck	02b88a8357	Maybe fix default assignment parsing error with sponge	2017-01-18 22:40:25 +00:00
Luck	c99d6556db	Fix issues with default assignment loading on Sponge	2017-01-18 21:37:41 +00:00
Luck	1db777cd31	Remove world cache - fixes #135	2017-01-18 21:05:14 +00:00
Luck	aea44fc8bc	API changes for 2.17 - closes #123	2017-01-16 20:01:41 +00:00
Luck	c0da9d49d9	make clickable message invert filter more specific	2017-01-16 16:55:59 +00:00
Luck	ce42573f43	Properly invalidate user caches when defaults chance - fixes #118	2017-01-15 17:47:59 +00:00
Luck	148fe4c729	Make prefix/suffix string optional in the meta remove commands - related to #83	2017-01-15 15:11:35 +00:00
Luck	32fd484b58	Change promote / demote behaviour at the end of tracks - towards #112	2017-01-15 13:22:50 +00:00
Luck	7d24e748b7	Fix reading and writing UTF-8 characters from storage files - closes #129	2017-01-15 12:18:12 +00:00
Luck	f1a1612f5d	Subscribe to default permissions too	2017-01-14 23:49:45 +00:00
Luck	6501e5cf8d	Fix bukkit permission subscriptions	2017-01-14 23:19:11 +00:00
Luck	cd4a684613	Fix demote command not removing old group	2017-01-14 08:27:09 +00:00
Luck	d06fda6d9d	Add /lp search command	2017-01-13 20:11:25 +00:00
Luck	139010e75b	Fix repo	2017-01-12 21:59:38 +00:00
Luck	7638b07e34	bump fanciful version	2017-01-12 21:48:16 +00:00
Luck	f7bf4416c9	Fix illegal cast from LPSubject to SpongeGroup - fixes #126	2017-01-12 21:19:34 +00:00
Luck	2b96b656a9	constants do not need getters	2017-01-12 21:14:27 +00:00
Luck	0fe251b6ec	Fix promote/demote commands and primary groups conflicting	2017-01-12 19:45:44 +00:00
Luck	a1afc70bcb	Cache regex permissions when they get processed	2017-01-12 19:45:15 +00:00
Luck	ced3e6959c	Add methods to get a list of users/groups with a specific permission	2017-01-11 21:25:57 +00:00
Luck	1c229d54d9	Cleanup	2017-01-11 18:55:46 +00:00
Luck	dd50193c18	Fix Sponge subjects from being unloaded and never reinitialized - closes #124	2017-01-10 19:17:45 +00:00
Luck	ab0f9bbdbd	Fix creating new tracks with SQLBacking	2017-01-09 19:24:12 +00:00
Luck	055d181c67	Fix KCauldron dependency loading - closes #121	2017-01-09 18:20:03 +00:00
Luck	7042c45deb	Fix retrieving log from SQLBacking	2017-01-08 20:12:33 +00:00
Luck	960c2291b6	Fully implement new SQL schema & add migration code	2017-01-08 19:33:27 +00:00
Luck	773bfe1407	Automatically sort YAML/JSON storage - closes #113	2017-01-08 11:02:13 +00:00
Luck	a23f995717	Hopefully fix #118	2017-01-08 10:44:48 +00:00
Luck	bd509b3c75	Fix build	2017-01-05 18:30:09 +00:00
Luck	a0f8ba9afb	Fix NPE in LuckPermsSubjectData - closes #115	2017-01-05 18:27:58 +00:00
Luck	a71e040c6d	Fix NPE with Vault transient permissions - closes #117	2017-01-05 18:20:17 +00:00
Luck	454abec468	Cleanup vault hook	2017-01-05 18:19:14 +00:00
Luck	96035d5257	Fix clickable node list	2016-12-30 15:02:22 +00:00
Luck	9f2b59f2a2	Refactor SQLBacking - still towards #77	2016-12-30 14:27:43 +00:00
Luck	a54046907d	change first login event handling	2016-12-30 12:46:24 +00:00
Luck	2ce5679373	Fix issue where only the first request for a user subject would wait for the loading task to complete. Closes #108	2016-12-30 00:42:33 +00:00
Luck	2dad9f84fc	Fixes towards #77	2016-12-27 14:55:21 +00:00
Luck	a81a361a93	Fully implement new SQLBacking - towards #77	2016-12-27 14:27:05 +00:00
Luck	4660e68abf	Some small fixes for new SQL backing	2016-12-27 13:03:59 +00:00
bakatrouble	f8a77cf809	Change comments on configs; default ports for all storage backends	2016-12-27 12:39:54 +00:00
bakatrouble	0abe9598f6	It shouldn't be here	2016-12-27 12:39:54 +00:00
bakatrouble	20de713716	Some readability	2016-12-27 12:39:54 +00:00
bakatrouble	9dbef6acc2	Change providers syntax; fix port for PostgreSQL provider	2016-12-27 12:39:54 +00:00
bakatrouble	4c93bf7cf0	Fix connection leaking on batch inserts; fix IDEA analyser warning	2016-12-27 12:39:54 +00:00
bakatrouble	a8fea0fc49	Implement NodeDataHolder	2016-12-27 12:39:54 +00:00
Luck	2d5975d6e3	Vault only save if a change was made	2016-12-27 12:24:19 +00:00
Luck	6874cfd5b1	WIP: implement better sql schema - towards #77	2016-12-24 20:30:35 +00:00
Luck	d34013396a	woops	2016-12-23 16:59:01 +00:00
Luck	a35b0915ab	Refactor SQL storage - towards #77	2016-12-23 16:55:35 +00:00
Luck	b35f3b4375	Properly cleanup in the case of a reload - towards #100	2016-12-23 11:28:42 +00:00
Luck	f4f9612789	Fix MongoDB auth-less connection	2016-12-23 10:14:41 +00:00
Luck	bfc79c6051	Reduce page entry count to 15 - resolves #95	2016-12-22 22:06:41 +00:00
Luck	d3e60487bb	Download dependencies at runtime instead of shading them in the jar	2016-12-22 21:17:02 +00:00
Luck	f36f411a8d	Fix broken inheritance caching system - closes #97	2016-12-22 17:50:56 +00:00
Luck	35f4aea69f	Maybe fix caching issues - closes #99	2016-12-22 15:34:22 +00:00
Luck	8795383e7c	Make sync command reload sponge data too - resolves #98	2016-12-21 21:34:43 +00:00
Luck	fc4750706b	Cleanup sponge files and don't persist empty sections - resolves #96	2016-12-21 21:33:32 +00:00
Luck	0ae59bd3e6	show group weight value in the group info command output	2016-12-21 21:26:22 +00:00
Luck	61fd14c816	Add group setweight command - closes #94	2016-12-21 21:22:48 +00:00
Luck	c7d3d87b09	Fix verbose recording filters (again)	2016-12-20 13:59:56 +00:00
Luck	5e68f7b58c	Implement paginated permission listings - closes #80	2016-12-20 13:55:42 +00:00
Luck	8a692200d5	Improve memory footprint in low throughput caches	2016-12-20 12:42:20 +00:00
Luck	829eacb0fb	Fix verbose recording not taking note of filters	2016-12-20 02:53:37 +00:00
Luck	9aeca91f22	Allow space on Sponge Group subjectcollection	2016-12-19 21:52:26 +00:00
Luck	1bdb512826	Ease handling of group names containing spaces, after a faulty migration process	2016-12-19 21:50:34 +00:00
Luck	060fa6e5f7	change weight node	2016-12-19 18:22:32 +00:00
Luck	171a54c0fc	PEX migration - include username too. Closes #92	2016-12-19 01:22:47 +00:00
Luck	17406b448d	Add more detail to the group info command	2016-12-18 23:34:33 +00:00
Luck	b4b661a3ad	Set default port	2016-12-18 10:16:05 +00:00
Luck	4857969ca4	Cache calls querying parent groups in bridge subjects - closes #69	2016-12-18 09:57:39 +00:00
Luck	d9d01e09aa	Cache collation keys - resolves #90	2016-12-18 09:42:27 +00:00
Luck	dadca97d8a	actually remove	2016-12-17 00:04:04 +00:00
Luck	8afba8b53d	remove /p alias	2016-12-17 00:03:21 +00:00
Luck	85dac1184c	silence NPE in autoop listener	2016-12-16 22:47:44 +00:00
Luck	4167460d28	Print true/false alongside permission info output for consoles without color. Closes #84	2016-12-16 19:21:36 +00:00
Eric Coan	1d8a60749d	help tame mysql connection settings this commit further helps tame the mysql connection pool (and really reconnecting to the pool even when the underlying db goes down) further from commit: #31a597c this sets up `setValidationTimeout`, and `setConnectionTestQuery` in order to better (more speedily(?)/fastly(?)/<other adective>ly(?)) handle connection timeouts in a timely manner. (although admittedly this is already handeled well imo with the cache). however, it could be better ™️. in order to do this I did the following things: 1. Switch to `TimeUnit.SECONDS.toMillis` instead of manually entering milliseconds, and having the time in seconds as a comment. just makes it more readable imo. if you want me to change it back I can I'm not like attached to this or anything. 2. Perform more common validation timeouts with `setValidationTimeout` this allows us to potentially bump back up the connection timeout (although I see no harm leaving it where it is), although allows us to still "fail-fast" in a way when doing validations. 3. Use `setConnectionTestQuery` for people who somehow someway may not be using a JDBC4 compliant driver.	2016-12-16 17:14:24 +00:00
Luck	31a597ca81	lower mysql connection timeout - may help with #81	2016-12-12 22:21:54 +00:00
Luck	e5e77ffec5	Add PEX track migration - closes #78	2016-12-12 19:51:21 +00:00
Luck	41c3df41b4	Allow group weights as permission nodes - resolves #73	2016-12-12 19:30:42 +00:00
Luck	053066f1a7	add parent clear command - closes #67	2016-12-12 19:06:23 +00:00
Luck	21135dac07	Implement (partially) clickable permission lists - towards #68	2016-12-12 18:56:48 +00:00
Luck	22ccce3208	Default the value to true in set/settemp commands if no arg is given. Closes #82	2016-12-12 16:52:15 +00:00
Luck	70aa3964ee	Run all commands on the same thread - fixes #79	2016-12-11 11:34:18 +00:00
Luck	167489823a	more lenient command blocking	2016-12-09 19:39:05 +00:00
Luck	d1426f1b37	change jar names	2016-12-08 19:33:49 +00:00
Luck	7dcdc59c8e	Fix IllegalArgumentException with BiMap#put	2016-12-08 16:30:00 +00:00
Luck	1e13ee87af	cleanup imports	2016-12-07 22:21:22 +00:00
Luck	5101c1a759	fix build	2016-12-07 22:16:01 +00:00
Slind14	74bb079625	Fix zPermissions imports (PR #72 , fixes #61 ) * removed zPerm inherit loop check. (blocked the import due to throwing NPE) * should fix zperm migration (group inheritance and memberships) * zperm import, include username * zperm import: fixed memberships	2016-12-07 22:13:50 +00:00
Luck	2da7979d94	Partially add clickable command listings - towards #68	2016-12-07 22:09:11 +00:00
Luck	4ecb2c7c27	Closes #58 - Disable OP commands on Sponge	2016-12-07 21:27:50 +00:00
Luck	251f51b01c	add missing messages	2016-12-07 21:20:54 +00:00
Luck	2fba9b83af	apply group rewrites to vault - resolves #59	2016-12-07 21:18:57 +00:00
Luck	1c97cb3cec	Sponge: Fix migration for subjects with identifiers containing spaces	2016-12-07 21:14:24 +00:00
Luck	25511f898c	implement clickable message base - towards #68	2016-12-07 21:08:40 +00:00
Luck	d820f153a9	idk	2016-12-06 22:35:06 +00:00
Luck	77b06acad4	declare child states	2016-12-06 21:53:57 +00:00
Luck	6760a96527	Ensure holder state is always declared	2016-12-06 21:48:37 +00:00
Luck	257f426ab9	implement cached state for all permission holders. towards #69	2016-12-06 21:33:55 +00:00
Luck	3771a50f30	cleanup	2016-12-06 19:21:48 +00:00
dracnis	85ee211172	Update VaultChatHook.java need update as soon as possible.	2016-12-06 19:03:01 +00:00
Luck	1b7a66b41a	Fix #66	2016-12-04 23:09:12 +00:00
Luck	8f9a1aa931	Add verbose pastebin upload functionality - resolves #55	2016-12-03 19:30:25 +00:00
Luck	8b60fd0e55	Sponge: remove spammy user not already loaded message	2016-12-03 14:11:53 +00:00
Luck	cd7b3b4f6e	Fix compat with older guava versions	2016-12-03 13:55:51 +00:00
Luck	83b0f62d59	Implement full caching for non user/group subjects	2016-12-03 13:26:17 +00:00
Luck	dd3a78ada8	Fix #65	2016-12-03 11:08:47 +00:00
Luck	307e2b889c	Changes for version 2.16	2016-12-02 20:20:31 +00:00
Luck	a063f7664d	Fix #54 - getPermissionValue not checking default user	2016-12-02 17:26:38 +00:00
Luck	b1ab857592	Merge remote-tracking branch 'origin/master'	2016-12-02 17:21:10 +00:00
Luck	2b8bbc434f	WIP: Sponge service refactor	2016-12-02 17:20:36 +00:00
Luck	c6878c27b9	Fix Vault #setPrefix method	2016-11-30 21:43:10 +00:00
Luck	02ff4a4acb	cleanup	2016-11-29 23:35:25 +00:00
Luck	23f757e916	fix formatting	2016-11-28 21:50:19 +00:00
Luck	f0ababa409	Maybe fix lilypad uuid retrieval	2016-11-28 21:39:10 +00:00
Luck	331ff341f3	Fix autoop	2016-11-28 20:11:10 +00:00
Luck	793a84edfb	Sponge: replace MemorySubjectData with own implementation	2016-11-26 17:19:04 +00:00
Luck	2893d4aebd	Silence InterruptedException when the plugin disables	2016-11-26 13:21:21 +00:00
Luck	b7ac7680d9	Fix NPE	2016-11-25 21:19:12 +00:00
Luck	18dd59ed0f	Refactor Sponge subject handling	2016-11-25 20:59:28 +00:00
Luck	443906da55	Refactor managers	2016-11-25 18:28:10 +00:00
Luck	a9f29da4f8	Fix potential memory leak	2016-11-24 21:59:48 +00:00
Luck	cf456cff81	Implement tab completion for permissions	2016-11-24 19:07:01 +00:00
Luck	69b3c96e09	Fix Sponge subject data permission overrides	2016-11-23 22:17:49 +00:00
Luck	61eb86b3a0	Fix Sponge defaults serialization	2016-11-23 21:44:59 +00:00
Luck	f0ad32bc37	Change PermissionService handling	2016-11-22 21:57:51 +00:00
Luck	aeeb2820f9	Sponge: also migrate defaults	2016-11-22 21:14:43 +00:00
Luck	2d88405d69	Fix onLateEnable always being fired	2016-11-22 20:42:43 +00:00
Luck	f32ed5db89	Fix Sponge PEX migration	2016-11-22 20:39:56 +00:00