Release 2.7

Remove unnecessary reflection
Fix permissions not being removed on Sponge
2016-09-05 20:00:01 +01:00 · 2016-09-05 16:44:59 +01:00 · 2016-09-04 17:59:01 +01:00 · 2016-09-04 16:25:10 +01:00 · 2016-09-04 16:24:36 +01:00 · 2016-09-03 21:34:35 +01:00
257 changed files with 26010 additions and 4197 deletions
@@ -1,6 +1,6 @@
 MIT License

-Copyright (c) 2016 Luck
+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
@@ -1,142 +0,0 @@
-= LuckPerms
-A (fairly bad) permissions implementation for Bukkit/BungeeCord.
-
-== Features
-* **Group inheritance** - users can be members of multiple groups, groups can inherit other groups
-* **Temporary permissions** - users/groups can be given permissions that expire after a given time
-* **Temporary groups** - users/groups can be added to/inherit other groups temporarily
-* **Multi-server support** - data is synced across all servers/platforms
-* **Per-server permissions/groups** - define user/group permissions that only apply on certain servers
-* **Server-specific groups** - define groups that only apply on certain servers
-* **Tracks / paths** - users can be promoted/demoted along multiple group tracks
-* **Vault Support** - hooks into Vault to integrate with other plugins
-* **Easy and simple setup and configuration using commands** - no editing yml files, yuck
-* **Efficient/lightweight** - maybe? Who knows, it might be.
-* **BungeeCord compatible** - permissions, users and groups are synced across Bukkit/BungeeCord instances
-* **Support for MySQL, SQLite & Flatfile (JSON)** - other storage methods coming soon (maybe)
-
-===== Possible Caveats
-* Currently only supports MySQL, SQLite & Flatfile (JSON) (support for more methods might come in the future)
-* Not at all tested and could produce unexpected/buggy results and errors
-
-== Setup
-All configuration options are in the **config.yml** file, which is generated automagically when the plugin first starts.
-
-You can define the settings for per-server permissions, the storage method and credentials within this file.
-
-== Info
-=== Permission Calculation
-Permissions are calculated based on a priority system as follows.
-
-* Temporary permissions will override non-temporary permissions.
-
-Example: if a user has a false permission set for "test.node", and a temporary true permission set for "test.node", the temporary permission will override the permanent one, and the user will be granted the true node.
-
-* Server specific permissions will override generic/global permissions.
-
-Example: if a user has a global "fly.use" permission, and then has a negated "fly.use" permission on the "factions" server, the server specific permission will override the globally defined one, and the user will be granted the negated node.
-
-* Inherited permissions will be overridden by an objects own permissions.
-
-Example: A user is a member of the default group, which grants "some.thing.perm", but the users own permissions has "some.thing.perm" set to false. The inherited permission will be overridden by the users own permissions, and the user will be granted the negative node.
-
-=== Temporary Permissions
-Temporary permissions are checked each time a user/group is loaded, and when the sync task runs. This means if you set a temporary permission to expire after 30 seconds, it won't actually be removed until the sync task runs.
-
-The only way around this is to decrease the sync interval.
-
-== Commands
-
-Command usage is printed to the console/chat whenever invalid arguments are provided. Simply typing /perms will list all commands a user has permission to use.
-
-=== Aliases
-| Bukkit | /luckperms |
-| | /perms |
-| | /permissions |
-| | /lp |
-| | /perm |
-| Bungee | /luckpermsbungee |
-| | /bperms |
-| | /bpermissions |
-| | /lpb |
-| | /bperm |
-
-Arguments: <required> [optional]
-
-Users with OP have access to all commands.
-
-Additionally, you can use wildcards to grant users access to a selection of commands.
-* **All commands** - luckperms.*
-* **All user commands** - luckperms.user.*
-* **All group commands** - luckperms.group.*
-* **All track commands** - luckperms.track.*
-
-
-|  **Command**  |  **Description**  |  **Permission**  |
-| /perms | Sends plugin info and usage | N/A |
-| /perms sync | Runs an update task and reloads the data of all online users | luckperms.sync |
-| /perms info | Shows information about the plugin | luckperms.info |
-| /perms debug | Shows some very brief debug info about the number of users/groups loaded | luckperms.debug |
-|  |  |  |
-|  |  |  |
-|  |  |  |
-| /perms creategroup <group> | Creates a new group with the given name | luckperms.creategroup |
-| /perms deletegroup <group> | Deletes an existing group | luckperms.deletegroup |
-| /perms listgroups | Shows a list of the groups registered within the system | luckperms.listgroups |
-|  |  |  |
-|  |  |  |
-|  |  |  |
-| /perms createtrack <track> | Creates a new track with the given name | luckperms.createtrack |
-| /perms deletetrack <track> | Deletes an existing track | luckperms.deletetrack |
-| /perms listtracks | Shows a list of the tracks registered within the system | luckperms.listtracks |
-|  |  |  |
-|  |  |  |
-|  |  |  |
-| /perms user <user> info | Shows info about the user | luckperms.user.info |
-| /perms user <user> getuuid | Shows the users Mojang UUID | luckperms.user.getuuid |
-| /perms user <user> listnodes | Lists all of the permission nodes the user has | luckperms.user.listnodes |
-| /perms user <user> haspermission <node> [server] | Checks if the user has a permission on a certain server | luckperms.user.haspermission |
-| /perms user <user> inheritspermission <node> [server] | Checks if the user inherits a permission on a certain server. (This checks all parent groups unlike haspermission) | luckperms.user.inheritspermission |
-| /perms user <user> set <node> <true/false> [server]| Sets a permission for the user | luckperms.user.setpermission |
-| /perms user <user> unset <node> [server] | Unsets a permission for the user | luckperms.user.unsetpermission |
-| /perms user <user> addgroup <group> [server] | Adds the user to a group | luckperms.user.addgroup |
-| /perms user <user> removegroup <group> [server] | Removes the user from a group | luckperms.user.removegroup |
-| /perms user <user> settemp <node> <true/false> <duration> [server]| Sets a temporary permission for the user | luckperms.user.settemppermission |
-| /perms user <user> unsettemp <node> [server] | Unsets a temporary permission for the user | luckperms.user.unsettemppermission |
-| /perms user <user> addtempgroup <group> <duration> [server] | Adds the user to a group temporarily | luckperms.user.addtempgroup |
-| /perms user <user> removetempgroup <group> [server] | Removes the user from a temporary group | luckperms.user.removetempgroup |
-| /perms user <user> setprimarygroup <group> | Sets the users primary group | luckperms.user.setprimarygroup |
-| /perms user <user> showtracks | Shows a list of the tracks the user can be promoted/demoted on | luckperms.user.showtracks |
-| /perms user <user> promote <track> | Promotes the user along a given track | luckperms.user.promote |
-| /perms user <user> demote <track> | Demotes the user along a given track | luckperms.user.demote |
-| /perms user <user> showpos <track> | Shows the users position on a given track | luckperms.user.showpos |
-| /perms user <user> clear | Clears all permissions the user has | luckperms.user.clear |
-|  |  |  |
-|  |  |  |
-|  |  |  |
-| /perms group <group> info | Shows info about the group | luckperms.group.info |
-| /perms group <group> listnodes | Lists all of the permission nodes the group has | luckperms.group.listnodes |
-| /perms group <group> haspermission <node> [server] | Checks if the group has a permission on a certain server | luckperms.group.haspermission |
-| /perms group <group> inheritspermission <node> [server] | Checks if the group inherits a permission on a certain server. (This checks all parent groups unlike haspermission) | luckperms.group.inheritspermission |
-| /perms group <group> set <node> <true/false> [server]| Sets a permission for the group | luckperms.group.setpermission |
-| /perms group <group> unset <node> [server] | Unsets a permission for the group | luckperms.group.unsetpermission |
-| /perms group <group> setinherit <group> [server]| Sets the group to inherit all permissions from another group | luckperms.group.setinherit |
-| /perms group <group> unsetinherit <group> [server] | Unsets a previously defined inheritance rule | luckperms.group.unsetinherit |
-| /perms group <group> settemp <node> <true/false> <duration> [server] | Sets a temporary permission for the group | luckperms.group.settemppermission |
-| /perms group <group> unsettemp <node> [server] | Unsets a temporary permission for the group | luckperms.group.unsettemppermission |
-| /perms group <group> settempinherit <group> <duration> [server] | Sets the group to inherit all permissions from another group temporarily | luckperms.group.settempinherit |
-| /perms group <group> unsettempinherit <group> [server] | Unsets a previously defined temporary inheritance rule | luckperms.group.unsettempinherit |
-| /perms group <group> showtracks | Shows a list of the tracks that the users in the group can be promoted/demoted on | luckperms.group.showtracks |
-| /perms group <group> clear | Clears all permissions the group has | luckperms.group.clear |
-|  |  |  |
-|  |  |  |
-|  |  |  |
-| /perms track <track> info | Shows info about the track | luckperms.track.info |
-| /perms track <track> append <group> | Appends a group to the end of the track | luckperms.track.append |
-| /perms track <track> insert <group> <position> | Inserts a group at the given position on the track | luckperms.track.insert |
-| /perms track <track> remove <group> | Removes a group from the track | luckperms.track.remove |
-| /perms track <track> clear | Clears all groups on the track | luckperms.track.clear |
-
-
-== License
-See LICENSE.md.
@@ -0,0 +1,17 @@
+# LuckPerms [![Build Status](https://ci.lucko.me/job/LuckPerms/badge/icon)](https://ci.lucko.me/job/LuckPerms/)
+A 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 flexible, performant and reliable alternative to other permission systems, providing all the features you could ever possibly need in a permissions plugin, along with an extensive and well documented API for developers.
+
+## LuckPerms vs Other Plugins
+![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._
+
+## License
+See LICENSE.md.
@@ -0,0 +1,37 @@
+<?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"
+         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.7-SNAPSHOT</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>luckperms-api</artifactId>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.5.1</version>
+                <configuration>
+                    <source>1.8</source>
+                    <target>1.8</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+    <dependencies>
+        <!-- guava -->
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>19.0</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+
+</project>
@@ -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;
+
+import me.lucko.luckperms.api.LuckPermsApi;
+
+import java.util.Optional;
+
+/**
+ * Static access to LuckPerms
+ */
+public final class LuckPerms {
+    private static LuckPermsApi api = null;
+
+    /**
+     * Gets an instance of {@link LuckPermsApi}
+     * @return an api instance
+     * @throws IllegalStateException if the api is not loaded
+     */
+    public static LuckPermsApi getApi() {
+        if (api == null) {
+            throw new IllegalStateException("API is not loaded.");
+        }
+        return api;
+    }
+
+    /**
+     * Gets an instance of {@link LuckPermsApi} safely. Unlike {@link LuckPerms#getApi}, this method will not throw an
+     * {@link IllegalStateException} if the api is not loaded, rather return an empty {@link Optional}.
+     * @return an optional api instance
+     */
+    public static Optional<LuckPermsApi> getApiSafe() {
+        return Optional.ofNullable(api);
+    }
+
+    static void registerProvider(LuckPermsApi luckPermsApi) {
+        api = luckPermsApi;
+    }
+
+    static void unregisterProvider() {
+        api = null;
+    }
+
+    private LuckPerms() {
+        throw new UnsupportedOperationException("This class cannot be instantiated.");
+    }
+
+}
@@ -0,0 +1,308 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api;
+
+import me.lucko.luckperms.api.data.Callback;
+
+import java.util.Set;
+import java.util.UUID;
+
+/**
+ * Interface for the internal Datastore instance
+ */
+@SuppressWarnings("unused")
+public interface Datastore {
+
+    String getName();
+    boolean isAcceptingLogins();
+
+    /**
+     * Gets the {@link Sync} interface.
+     *
+     * All operations through this interface are called immediately and in the same thread as they are called.
+     * Datastore operations are thread blocking, and Sync operations should not be called on the main server thread.
+     * @return the sync interface
+     */
+    Sync sync();
+
+    /**
+     * Gets the {@link Async} interface.
+     * 
+     * All operations through this interface are called in a new, separate asynchronous thread.
+     * When the operation is complete, the provided callback method is called, in applicable, in the main server thread.
+     * @return the async interface
+     */
+    Async async();
+
+    /**
+     * Gets the {@link Future} interface.
+     * 
+     * All operations through this interface are called in a new, separate asynchronous thread, similar to {@link Async}.
+     * The only difference is that instead of providing a callback, a {@link java.util.concurrent.Future} is returned.
+     * See the Oracle JavaDocs for usage of the Future class.
+     * @return the future interface
+     */
+    Future future();
+
+    /**
+     * All operations through this interface are called immediately and in the same thread as they are called.
+     * Datastore operations are thread blocking, and Sync operations should not be called on the main server thread.
+     */
+    interface Sync {
+
+        /**
+         * Saves an action to the datastore
+         * @param entry the log entry to be saved
+         * @return true if the operation completed successfully.
+         * @throws NullPointerException if entry is null
+         */
+        boolean logAction(LogEntry entry);
+
+        /**
+         * Loads and returns the log from the datastore
+         * @return a log instance, could be null
+         */
+        Log getLog();
+
+        /**
+         * Either loads or creates a user object, and loads it into the plugins internal storage
+         * @param uuid the uuid of the user
+         * @param username the users username. (if you want to specify <code>null</code> here, just input "null" as a string.)
+         * @return true if the operation completed successfully.
+         * @throws NullPointerException if uuid or username is null
+         * @throws IllegalArgumentException if either of the parameters are invalid
+         * @deprecated functionality of this method is taken on by {@link #loadUser(UUID, String)}
+         */
+        @Deprecated
+        boolean loadOrCreateUser(UUID uuid, String username);
+
+        /**
+         * Loads a user from the datastore into the plugins internal storage.
+         * @param uuid the uuid of the user to load
+         * @return true if the user exists, and was loaded correctly.
+         * @throws NullPointerException if uuid is null
+         * @deprecated replaced by {@link #loadUser(UUID, String)}
+         */
+        @Deprecated
+        boolean loadUser(UUID uuid);
+
+        /**
+         * Loads a user's data into the plugins internal storage.
+         * @param uuid the uuid of the user to load
+         * @param username the users username. (if you want to specify <code>null</code> here, just input "null" as a string.)
+         * @return if the operation was performed successfully
+         * @throws NullPointerException if uuid or username is null
+         * @since 2.6
+         */
+        boolean loadUser(UUID uuid, String username);
+
+        /**
+         * Saves a user object into the datastore. You should call this after you make any changes to a user.
+         * @param user the user to save
+         * @return true if the operation completed successfully.
+         * @throws NullPointerException if user is null
+         * @throws IllegalStateException if the user instance was not obtained from LuckPerms.
+         */
+        boolean saveUser(User user);
+
+        /**
+         * Removes users from the datastore who are "default". This is called every time the plugin loads.
+         * @return true if the operation completed successfully
+         * @since 2.6
+         */
+        boolean cleanupUsers();
+
+        /**
+         * Gets a set all user's UUIDs who are "unique", and aren't just a member of the "default" group.
+         * @return a set of uuids, or null if the operation failed.
+         * @since 2.6
+         */
+        Set<UUID> getUniqueUsers();
+
+        /**
+         * Creates and loads a group into the plugins internal storage
+         * @param name the name of the group
+         * @return true if the operation completed successfully
+         * @throws NullPointerException if name is null
+         * @throws IllegalArgumentException if the name is invalid
+         */
+        boolean createAndLoadGroup(String name);
+
+        /**
+         * Loads a group into the plugins internal storage.
+         * @param name the name of the group
+         * @return true if the operation completed successfully
+         * @throws NullPointerException if name is null
+         * @throws IllegalArgumentException if the name is invalid
+         */
+        boolean loadGroup(String name);
+
+        /**
+         * Loads all groups from the datastore into the plugins internal storage
+         * @return true if the operation completed successfully.
+         */
+        boolean loadAllGroups();
+
+        /**
+         * Saves a group back to the datastore. You should call this after you make any changes to a group.
+         * @param group the group to save
+         * @return true if the operation completed successfully.
+         * @throws NullPointerException if group is null
+         * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
+         */
+        boolean saveGroup(Group group);
+
+        /**
+         * Permanently deletes a group from the datastore
+         * @param group the group to delete
+         * @return true if the operation completed successfully.
+         * @throws NullPointerException if group is null
+         * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
+         */
+        boolean deleteGroup(Group group);
+
+        /**
+         * Creates and loads a track into the plugins internal storage
+         * @param name the name of the track
+         * @return true if the operation completed successfully
+         * @throws NullPointerException if name is null
+         * @throws IllegalArgumentException if the name is invalid
+         */
+        boolean createAndLoadTrack(String name);
+
+        /**
+         * Loads a track into the plugins internal storage.
+         * @param name the name of the track
+         * @return true if the operation completed successfully
+         * @throws NullPointerException if name is null
+         * @throws IllegalArgumentException if the name is invalid
+         */
+        boolean loadTrack(String name);
+
+        /**
+         * Loads all tracks from the datastore into the plugins internal storage
+         * @return true if the operation completed successfully.
+         */
+        boolean loadAllTracks();
+
+        /**
+         * Saves a track back to the datastore. You should call this after you make any changes to a track.
+         * @param track the track to save
+         * @return true if the operation completed successfully.
+         * @throws NullPointerException if track is null
+         * @throws IllegalStateException if the track instance was not obtained from LuckPerms.
+         */
+        boolean saveTrack(Track track);
+
+        /**
+         * Permanently deletes a track from the datastore
+         * @param track the track to delete
+         * @return true if the operation completed successfully.
+         * @throws NullPointerException if track is null
+         * @throws IllegalStateException if the track instance was not obtained from LuckPerms.
+         */
+        boolean deleteTrack(Track track);
+
+        /**
+         * Saves UUID caching data to the datastore
+         * @param username the users username
+         * @param uuid the users mojang unique id
+         * @return true if the operation completed successfully.
+         * @throws NullPointerException if either parameters are null
+         * @throws IllegalArgumentException if the username is invalid
+         */
+        boolean saveUUIDData(String username, UUID uuid);
+
+        /**
+         * Gets a UUID from a username
+         * @param username the corresponding username
+         * @return a uuid object, could be null
+         * @throws NullPointerException if either parameters are null
+         * @throws IllegalArgumentException if the username is invalid
+         */
+        UUID getUUID(String username);
+    }
+
+    /**
+     * All operations through this interface are called in a new, separate asynchronous thread.
+     * When the operation is complete, the provided callback method is called, in applicable, in the main server thread.
+     * 
+     * See {@link Sync} for method documentation. 
+     */
+    interface Async {
+        void logAction(LogEntry entry, Callback<Boolean> callback);
+        void getLog(Callback<Log> callback);
+        @Deprecated
+        void loadOrCreateUser(UUID uuid, String username, Callback<Boolean> callback);
+        @Deprecated
+        void loadUser(UUID uuid, Callback<Boolean> callback);
+        void loadUser(UUID uuid, String username, Callback<Boolean> callback);
+        void saveUser(User user, Callback<Boolean> callback);
+        void cleanupUsers(Callback<Boolean> callback);
+        void getUniqueUsers(Callback<Set<UUID>> callback);
+        void createAndLoadGroup(String name, Callback<Boolean> callback);
+        void loadGroup(String name, Callback<Boolean> callback);
+        void loadAllGroups(Callback<Boolean> callback);
+        void saveGroup(Group group, Callback<Boolean> callback);
+        void deleteGroup(Group group, Callback<Boolean> callback);
+        void createAndLoadTrack(String name, Callback<Boolean> callback);
+        void loadTrack(String name, Callback<Boolean> callback);
+        void loadAllTracks(Callback<Boolean> callback);
+        void saveTrack(Track track, Callback<Boolean> callback);
+        void deleteTrack(Track track, Callback<Boolean> callback);
+        void saveUUIDData(String username, UUID uuid, Callback<Boolean> callback);
+        void getUUID(String username, Callback<UUID> callback);
+    }
+
+    /**
+     * All operations through this interface are called in a new, separate asynchronous thread, similar to {@link Async}.
+     * The only difference is that instead of providing a callback, a {@link java.util.concurrent.Future} is returned.
+     * See the Oracle JavaDocs for usage of the Future class.
+     * 
+     * See {@link Sync} for method documentation.
+     */
+    interface Future {
+        java.util.concurrent.Future<Boolean> logAction(LogEntry entry);
+        java.util.concurrent.Future<Log> getLog();
+        @Deprecated
+        java.util.concurrent.Future<Boolean> loadOrCreateUser(UUID uuid, String username);
+        @Deprecated
+        java.util.concurrent.Future<Boolean> loadUser(UUID uuid);
+        java.util.concurrent.Future<Boolean> loadUser(UUID uuid, String username);
+        java.util.concurrent.Future<Boolean> saveUser(User user);
+        java.util.concurrent.Future<Boolean> cleanupUsers();
+        java.util.concurrent.Future<Set<UUID>> getUniqueUsers();
+        java.util.concurrent.Future<Boolean> createAndLoadGroup(String name);
+        java.util.concurrent.Future<Boolean> loadGroup(String name);
+        java.util.concurrent.Future<Boolean> loadAllGroups();
+        java.util.concurrent.Future<Boolean> saveGroup(Group group);
+        java.util.concurrent.Future<Boolean> deleteGroup(Group group);
+        java.util.concurrent.Future<Boolean> createAndLoadTrack(String name);
+        java.util.concurrent.Future<Boolean> loadTrack(String name);
+        java.util.concurrent.Future<Boolean> loadAllTracks();
+        java.util.concurrent.Future<Boolean> saveTrack(Track track);
+        java.util.concurrent.Future<Boolean> deleteTrack(Track track);
+        java.util.concurrent.Future<Boolean> saveUUIDData(String username, UUID uuid);
+        java.util.concurrent.Future<UUID> getUUID(String username);
+    }
+}
@@ -0,0 +1,237 @@
+/*
+ * 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.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
+
+import java.util.List;
+
+/**
+ * Interface for internal Group instances
+ */
+@SuppressWarnings("unused")
+public interface Group extends PermissionHolder {
+
+    /**
+     * @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 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 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 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 server The server 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 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.
+     */
+    void setInheritGroup(Group group) throws ObjectAlreadyHasException;
+
+    /**
+     * Make this group inherit another group on a specific server
+     * @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
+     */
+    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 server The server 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
+     */
+    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 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
+     */
+    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 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
+     */
+    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 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
+     */
+    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 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 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 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 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 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 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.
+     * @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 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 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 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 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 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
+     */
+    List<String> getLocalGroups(String server);
+}
@@ -0,0 +1,134 @@
+/*
+ * 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.DatastoreConfiguration;
+import me.lucko.luckperms.api.data.MySQLConfiguration;
+
+import java.util.Map;
+
+/**
+ * A wrapper interface for the internal LuckPerms configuration, providing read only access.
+ */
+@SuppressWarnings("unused")
+public interface LPConfiguration {
+
+    /**
+     * @return the name of this server
+     */
+    String getServer();
+
+    /**
+     * @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();
+
+    /**
+     * @return if the users on this server will have their global permissions applied
+     */
+    boolean getIncludeGlobalPerms();
+
+    /**
+     * @return the online mode setting in the config
+     */
+    boolean getOnlineMode();
+
+    /**
+     * @return if LuckPerms is applying wildcard permissions
+     */
+    boolean getApplyWildcards();
+
+    /**
+     * @return if LuckPerms is resolving and applying regex permissions
+     */
+    boolean getApplyRegex();
+
+    /**
+     * @return if LuckPerms is expanding shorthand permissions
+     */
+    boolean getApplyShorthand();
+
+    /**
+     * @return if LuckPerms will send notifications to users when permissions are modified
+     * @since 2.7
+     */
+    boolean getLogNotify();
+
+    /**
+     * @return the name of the server used within Vault operations
+     * @since 2.7
+     */
+    String getVaultServer();
+
+    /**
+     * @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();
+
+    /**
+     * @return the values set for data storage in the configuration
+     */
+    DatastoreConfiguration getDatastoreConfig();
+
+    /**
+     * @return the storage method string from the configuration
+     */
+    String getStorageMethod();
+
+    /**
+     * @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
+     * @since 2.7
+     */
+    Map<String, String> getSplitStorageOptions();
+
+}
@@ -0,0 +1,161 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api;
+
+import java.util.SortedMap;
+import java.util.SortedSet;
+import java.util.UUID;
+
+/**
+ * Represents the internal LuckPerms log.
+ * All content internally is immutable. You can add to the log using the {@link Datastore}, and then request an updated copy.
+ */
+@SuppressWarnings("unused")
+public interface Log {
+
+    /**
+     * @return a {@link SortedSet} of all of the {@link LogEntry} objects in this {@link Log}
+     */
+    SortedSet<LogEntry> getContent();
+
+    /**
+     * @return all content in this log
+     */
+    SortedSet<LogEntry> getRecent();
+
+    /**
+     * Gets the recent content separated by page
+     * @param pageNo the page number
+     * @return the page content
+     */
+    SortedMap<Integer, LogEntry> getRecent(int pageNo);
+
+    /**
+     * @return the max page number allowed in the {@link #getRecent(int)} method
+     */
+    int getRecentMaxPages();
+
+
+    /**
+     * @param actor the uuid of the actor to filter by
+     * @return all content in this log where is actor = uuid
+     */
+    SortedSet<LogEntry> getRecent(UUID actor);
+
+    /**
+     * 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
+     * @return the page content
+     */
+    SortedMap<Integer, LogEntry> getRecent(int pageNo, UUID actor);
+
+    /**
+     * @param actor the actor to filter by
+     * @return the max page number allowed in the {@link #getRecent(int, UUID)} method
+     */
+    int getRecentMaxPages(UUID actor);
+
+
+    /**
+     * @param uuid the uuid to filter by
+     * @return all content in this log where the user = uuid
+     */
+    SortedSet<LogEntry> getUserHistory(UUID uuid);
+
+    /**
+     * Gets the user history content, separated by pages
+     * @param pageNo the page number
+     * @param uuid the uuid of the acted user to filter by
+     * @return the page content
+     */
+    SortedMap<Integer, LogEntry> getUserHistory(int pageNo, UUID uuid);
+
+    /**
+     * @param uuid the uuid to filter by
+     * @return the max page number allowed in the {@link #getUserHistory(int, UUID)} method
+     */
+    int getUserHistoryMaxPages(UUID uuid);
+
+    
+    /**
+     * @param name the name to filter by
+     * @return all content in this log where the group = name
+     */
+    SortedSet<LogEntry> getGroupHistory(String name);
+
+    /**
+     * Gets the group history content, separated by pages
+     * @param pageNo the page number
+     * @param name the name of the acted group to filter by
+     * @return the page content
+     */
+    SortedMap<Integer, LogEntry> getGroupHistory(int pageNo, String name);
+
+    /**
+     * @param name the name to filter by
+     * @return the max page number allowed in the {@link #getGroupHistory(int, String)} method
+     */
+    int getGroupHistoryMaxPages(String name);
+
+
+    /**
+     * @param name the name to filter by
+     * @return all content in this log where the track = name
+     */
+    SortedSet<LogEntry> getTrackHistory(String name);
+
+    /**
+     * Gets the track history content, separated by pages
+     * @param pageNo the page number
+     * @param name the name of the acted track to filter by
+     * @return the page content
+     */
+    SortedMap<Integer, LogEntry> getTrackHistory(int pageNo, String name);
+
+    /**
+     * @param name the name to filter by
+     * @return the max page number allowed in the {@link #getTrackHistory(int, String)} method
+     */
+    int getTrackHistoryMaxPages(String name);
+
+    /**
+     * @param query the query to filter by
+     * @return all content in this log where the content matches query
+     */
+    SortedSet<LogEntry> getSearch(String query);
+
+    /**
+     * Gets the search content, separated by pages
+     * @param pageNo the page number
+     * @param query the query to filter by
+     * @return the page content
+     */
+    SortedMap<Integer, LogEntry> getSearch(int pageNo, String query);
+
+    /**
+     * @param query the query to filter by
+     * @return the max page number allowed in the {@link #getSearch(int, String)} method
+     */
+    int getSearchMaxPages(String query);
+}
@@ -0,0 +1,319 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api;
+
+import java.util.UUID;
+
+/**
+ * Represents a single entry in a log
+ */
+@SuppressWarnings({"unused", "WeakerAccess"})
+public class LogEntry implements Comparable<LogEntry> {
+    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;
+    private char type;
+    private UUID acted;
+    private String actedName;
+    private String action;
+
+    public LogEntry(long timestamp, UUID actor, String actorName, char type, UUID acted, String actedName, String action) {
+        if (actor == null) {
+            throw new NullPointerException("actor");
+        }
+        if (actorName == null) {
+            throw new NullPointerException("actorName");
+        }
+        if (actedName == null) {
+            throw new NullPointerException("actedName");
+        }
+        if (action == null) {
+            throw new NullPointerException("action");
+        }
+
+        this.timestamp = timestamp;
+        this.actor = actor;
+        this.actorName = actorName;
+        this.type = type;
+        this.acted = acted;
+        this.actedName = actedName;
+        this.action = action;
+    }
+
+    protected LogEntry() {
+        this.timestamp = 0L;
+        this.actor = null;
+        this.actorName = null;
+        this.type = Character.MIN_VALUE;
+        this.acted = null;
+        this.actedName = null;
+        this.action = null;
+    }
+
+    @Override
+    public int compareTo(LogEntry o) {
+        return equals(o) ? 0 : (Long.compare(timestamp, o.getTimestamp()) == 0 ? 1 : Long.compare(timestamp, o.getTimestamp()));
+    }
+
+    public boolean matchesSearch(String query) {
+        query = query.toLowerCase();
+        return actorName.toLowerCase().contains(query) || actedName.toLowerCase().contains(query)
+                || action.toLowerCase().contains(query);
+    }
+
+    public String getFormatted() {
+        return String.format(FORMAT,
+                actorName,
+                Character.toString(type),
+                actedName,
+                action
+        );
+    }
+
+    public long getTimestamp() {
+        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;
+    }
+
+    void setActor(UUID actor) {
+        this.actor = actor;
+    }
+
+    void setActorName(String actorName) {
+        this.actorName = actorName;
+    }
+
+    void setType(char type) {
+        this.type = type;
+    }
+
+    void setActed(UUID acted) {
+        this.acted = acted;
+    }
+
+    void setActedName(String actedName) {
+        this.actedName = actedName;
+    }
+
+    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() + ")";
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o == this) return true;
+        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.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);
+    }
+
+    @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 + 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());
+        return result;
+    }
+
+    public static class LogEntryBuilder extends AbstractLogEntryBuilder<LogEntry, LogEntry.LogEntryBuilder> {
+
+        @Override
+        protected LogEntry createObj() {
+            return new LogEntry();
+        }
+
+        @Override
+        protected LogEntryBuilder getThis() {
+            return this;
+        }
+    }
+
+    public static abstract class AbstractLogEntryBuilder<T extends LogEntry, B extends AbstractLogEntryBuilder<T, B>> {
+        private T obj;
+        private B thisObj;
+
+        public AbstractLogEntryBuilder() {
+            obj = createObj();
+            thisObj = getThis();
+        }
+
+        protected abstract T createObj();
+        protected abstract B getThis();
+
+        public long getTimestamp() {
+            return obj.getTimestamp();
+        }
+
+        public UUID getActor() {
+            return obj.getActor();
+        }
+
+        public String getActorName() {
+            return obj.getActorName();
+        }
+
+        public char getType() {
+            return obj.getType();
+        }
+
+        public UUID getActed() {
+            return obj.getActed();
+        }
+
+        public String getActedName() {
+            return obj.getActedName();
+        }
+
+        public String getAction() {
+            return obj.getAction();
+        }
+
+        public B timestamp(long timestamp) {
+            obj.setTimestamp(timestamp);
+            return thisObj;
+        }
+
+        public B actor(UUID actor) {
+            obj.setActor(actor);
+            return thisObj;
+        }
+
+        public B actorName(String actorName) {
+            obj.setActorName(actorName);
+            return thisObj;
+        }
+
+        public B type(char type) {
+            obj.setType(type);
+            return thisObj;
+        }
+
+        public B acted(UUID acted) {
+            obj.setActed(acted);
+            return thisObj;
+        }
+
+        public B actedName(String actedName) {
+            obj.setActedName(actedName);
+            return thisObj;
+        }
+
+        public B action(String action) {
+            obj.setAction(action);
+            return thisObj;
+        }
+
+        public T build() {
+            if (getActor() == null) {
+                throw new NullPointerException("actor");
+            }
+            if (getActorName() == null) {
+                throw new NullPointerException("actorName");
+            }
+            if (getActedName() == null) {
+                throw new NullPointerException("actedName");
+            }
+            if (getAction() == null) {
+                throw new NullPointerException("action");
+            }
+
+            return obj;
+        }
+
+        @Override
+        public String toString() {
+            return "LogEntry.LogEntryBuilder(timestamp=" + getTimestamp() + ", actor=" + getActor() + ", actorName=" +
+                    getActorName() + ", type=" + getType() + ", acted=" + getActed() + ", actedName=" + getActedName() +
+                    ", action=" + getAction() + ")";
+        }
+    }
+
+}
@@ -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;
+
+/**
+ * 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.
+ */
+public interface Logger {
+
+    void info(String s);
+    void warn(String s);
+    void severe(String s);
+
+}
@@ -0,0 +1,220 @@
+/*
+ * 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.event.LPListener;
+
+import java.util.Optional;
+import java.util.Set;
+import java.util.UUID;
+
+/**
+ * The root API interface in LuckPerms
+ */
+@SuppressWarnings("unused")
+public interface LuckPermsApi {
+
+    /**
+     * Schedules an update task to run
+     */
+    void runUpdateTask();
+
+    /**
+     * @return the version of the API running on the platform
+     * @since 2.6
+     */
+    double getApiVersion();
+
+    /**
+     * @return the version of the plugin running on the platform
+     */
+    String getVersion();
+
+    /**
+     * @return the platform LuckPerms is running on
+     */
+    PlatformType getPlatformType();
+
+    /**
+     * Registers a listener to be sent LuckPerms events
+     * @param listener the listener instance
+     * @throws NullPointerException if the listener is null
+     */
+    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);
+
+    /**
+     * Gets a wrapped {@link LPConfiguration} instance, with read only access
+     * @return a configuration instance
+     */
+    LPConfiguration getConfiguration();
+
+    /**
+     * Gets a wrapped {@link Datastore} instance, with somewhat limited access
+     * @return a datastore instance
+     */
+    Datastore getDatastore();
+
+    /**
+     * Gets the {@link Logger} wrapping used by the platform
+     * @return the logger instance
+     */
+    Logger getLogger();
+
+    /**
+     * Gets a wrapped {@link UuidCache} instance, providing read access to the LuckPerms internal uuid caching system
+     * @return a uuidcache instance
+     */
+    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
+     */
+    User getUser(UUID uuid);
+
+    /**
+     * 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
+     */
+    Optional<User> getUserSafe(UUID uuid);
+
+    /**
+     * 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
+     */
+    User getUser(String name);
+
+    /**
+     * 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
+     */
+    Optional<User> getUserSafe(String name);
+
+    /**
+     * 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
+     */
+    boolean isUserLoaded(UUID uuid);
+
+    /**
+     * 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
+     */
+    void cleanupUser(User user);
+
+    /**
+     * 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
+     */
+    Group getGroup(String name);
+
+    /**
+     * 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
+     */
+    Optional<Group> getGroupSafe(String name);
+
+    /**
+     * 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
+     */
+    boolean isGroupLoaded(String name);
+
+    /**
+     * 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
+     */
+    Track getTrack(String name);
+
+    /**
+     * Gets a wrapped tracj 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
+     */
+    Optional<Track> getTrackSafe(String name);
+
+    /**
+     * 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);
+
+    /**
+     * 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
+     * @since 2.6
+     */
+    Node.Builder buildNode(String permission) throws IllegalArgumentException;
+
+}
@@ -0,0 +1,314 @@
+/*
+ * 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.LuckPerms;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
+
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * A collection of utilities to help retrieve meta values for {@link PermissionHolder}s
+ * @since 2.7
+ */
+public class MetaUtils {
+
+    /**
+     * Escapes special characters used within LuckPerms, so the string can be saved without issues
+     * @param s the string to escape
+     * @return an escaped string
+     * @throws NullPointerException if the string is null
+     */
+    public static String escapeCharacters(String s) {
+        if (s == null) {
+            throw new NullPointerException();
+        }
+        
+        s = s.replace(".", "{SEP}");
+        s = s.replace("/", "{FSEP}");
+        s = s.replace("$", "{DSEP}");
+
+        return 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
+     */
+    public static String unescapeCharacters(String s) {
+        if (s == null) {
+            throw new NullPointerException();
+        }
+        
+        s = s.replace("{SEP}", ".");
+        s = s.replace("{FSEP}", "/");
+        s = s.replace("{DSEP}", "$");
+
+        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
+     * @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");
+        }
+
+        if (value == null) {
+            throw new NullPointerException("value");
+        }
+
+        if (node.equals("")) {
+            throw new IllegalArgumentException("node is empty");
+        }
+
+        if (value.equals("")) {
+            throw new IllegalArgumentException("value is empty");
+        }
+
+        if (server == null || server.equals("")) {
+            server = "global";
+        }
+        
+        node = escapeCharacters(node);
+        value = escapeCharacters(value);
+
+        Set<Node> toRemove = new HashSet<>();
+        for (Node n : holder.getEnduringPermissions()) {
+            if (n.isMeta() && n.getMeta().getKey().equals(node)) {
+                toRemove.add(n);
+            }
+        }
+        
+        for (Node n : toRemove) {
+            try {
+                holder.unsetPermission(n);
+            } catch (ObjectLacksException ignored) {}
+        }
+
+        Node.Builder metaNode = LuckPerms.getApi().buildNode("meta." + node + "." + value).setValue(true);
+        if (!server.equalsIgnoreCase("global")) {
+            metaNode.setServer(server);
+        }
+        if (world != null && !world.equals("")) {
+            metaNode.setServer(server).setWorld(world);
+        }
+
+        try {
+            holder.setPermission(metaNode.build());
+        } 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 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 IllegalArgumentException if the node is empty
+     */
+    public static String getMeta(PermissionHolder holder, String server, String world, String node, String defaultValue, boolean includeGlobal) {
+        if (holder == null) {
+            throw new NullPointerException("holder");
+        }
+
+        if (server == null || server.equals("")) {
+            server = "global";
+        }
+
+        if (node == null) {
+            throw new NullPointerException("node");
+        }
+
+        if (node.equals("")) {
+            throw new IllegalArgumentException("node is empty");
+        }
+
+        node = escapeCharacters(node);
+
+        for (Node n : holder.getPermissions()) {
+            if (!n.getValue()) {
+                continue;
+            }
+
+            if (!n.isMeta()) {
+                continue;
+            }
+
+            if (!server.equalsIgnoreCase("global")) {
+                if (!n.shouldApplyOnServer(server, includeGlobal, false)) {
+                    continue;
+                }
+            }
+
+            if (!n.shouldApplyOnWorld(world, includeGlobal, false)) {
+                continue;
+            }
+
+            Map.Entry<String, String> meta = n.getMeta();
+            if (meta.getKey().equalsIgnoreCase(node)) {
+                return unescapeCharacters(meta.getValue());
+            }
+        }
+
+        return defaultValue;
+    }
+
+    private static void setChatMeta(boolean prefix, PermissionHolder holder, String value, int priority, String server, String world) {
+        if (holder == null) {
+            throw new NullPointerException("holder");
+        }
+
+        if (value == null || value.equals("")) {
+            throw new IllegalArgumentException("value is null/empty");
+        }
+
+        Node.Builder node = LuckPerms.getApi().buildNode(prefix ? "prefix" : "suffix" + "." + priority + "." + escapeCharacters(value));
+        node.setValue(true);
+        if (!server.equalsIgnoreCase("global")) {
+            node.setServer(server);
+        }
+        if (world != null && !world.equals("")) {
+            node.setServer(server).setWorld(world);
+        }
+
+        try {
+            holder.setPermission(node.build());
+        } 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 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
+     * @throws IllegalArgumentException if the prefix is null or empty
+     */
+    public static void setPrefix(PermissionHolder holder, String prefix, int priority, String server, String world) {
+        setChatMeta(true, holder, prefix, priority, server, world);
+    }
+
+    /**
+     * 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 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
+     * @throws IllegalArgumentException if the suffix is null or empty
+     */
+    public static void setSuffix(PermissionHolder holder, String suffix, int priority, String server, String world) {
+        setChatMeta(false, holder, suffix, priority, server, world);
+    }
+
+    private static String getChatMeta(boolean prefix, PermissionHolder holder, String server, String world, boolean includeGlobal) {
+        if (holder == null) {
+            throw new NullPointerException("holder");
+        }
+        if (server == null) {
+            server = "global";
+        }
+
+        int priority = Integer.MIN_VALUE;
+        String meta = null;
+        for (Node n : holder.getAllNodes()) {
+            if (!n.getValue()) {
+                continue;
+            }
+
+            if (!server.equalsIgnoreCase("global")) {
+                if (!n.shouldApplyOnServer(server, includeGlobal, false)) {
+                    continue;
+                }
+            }
+
+            if (!n.shouldApplyOnWorld(world, includeGlobal, false)) {
+                continue;
+            }
+            
+            if (prefix ? !n.isPrefix() : !n.isSuffix()) {
+                continue;
+            }
+
+            Map.Entry<Integer, String> value = prefix ? n.getPrefix() : n.getSuffix();
+            if (value.getKey() > priority) {
+                meta = value.getValue();
+                priority = value.getKey();
+            }
+        }
+
+        return meta == null ? "" : unescapeCharacters(meta);
+    }
+
+    /**
+     * 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 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
+     */
+    public static String getPrefix(PermissionHolder holder, String server, String world, boolean includeGlobal) {
+        return getChatMeta(true, holder, server, world, includeGlobal);
+    }
+
+    /**
+     * 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 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
+     */
+    public static String getSuffix(PermissionHolder holder, String server, String world, boolean includeGlobal) {
+        return getChatMeta(false, holder, server, world, includeGlobal);
+    }
+    
+}
@@ -0,0 +1,285 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+/**
+ * Represents an immutable node object
+ * <p> Use {@link LuckPermsApi#buildNode(String)} to get an instance.
+ * @since 2.6
+ */
+@SuppressWarnings("unused")
+public interface Node extends Map.Entry<String, Boolean> {
+
+    /**
+     * @return the actual permission node
+     */
+    String getPermission();
+
+    /**
+     * Get what value the permission is set to. A negated node would return <code>false</code>.
+     * @return the permission's value
+     */
+    @Override
+    Boolean getValue();
+
+    /**
+     * @return the value of this node as a Tristate
+     */
+    Tristate getTristate();
+
+    /**
+     * @return true if the node is negated
+     */
+    boolean isNegated();
+
+    /**
+     * 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();
+
+    /**
+     * @return true if this node is server specific
+     */
+    boolean isServerSpecific();
+
+    /**
+     * @return true if this node is server specific
+     */
+    boolean isWorldSpecific();
+
+    /**
+     * If this node should apply on a specific server
+     * @param server the name of the server
+     * @param includeGlobal if global permissions should apply
+     * @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 includeGlobal if global permissions should apply
+     * @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 given the specific context
+     * @param context the context key value pairs
+     * @return true if the node should apply
+     */
+    boolean shouldApplyWithContext(Map<String, String> context);
+
+    /**
+     * Similar to {@link #shouldApplyOnServer(String, boolean, boolean)}, except this method accepts a List
+     * @param servers the list of servers
+     * @param includeGlobal if global permissions should apply
+     * @return true if the node should apply
+     */
+    boolean shouldApplyOnAnyServers(List<String> servers, boolean includeGlobal);
+
+    /**
+     * Similar to {@link #shouldApplyOnWorld(String, boolean, boolean)}, except this method accepts a List
+     * @param worlds the list of world
+     * @param includeGlobal if global permissions should apply
+     * @return true if the node should apply
+     */
+    boolean shouldApplyOnAnyWorlds(List<String> worlds, boolean includeGlobal);
+
+    /**
+     * 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
+     */
+    List<String> resolveWildcard(List<String> possibleNodes);
+
+    /**
+     * Resolves any shorthand parts of this node and returns the full list
+     * @return a list of full nodes
+     */
+    List<String> resolveShorthand();
+
+    /**
+     * @return true if this node will expire in the future
+     */
+    boolean isTemporary();
+
+    /**
+     * @return true if this node will not expire
+     */
+    boolean isPermanent();
+
+    /**
+     * @return the time in Unix time when this node will expire
+     * @throws IllegalStateException if the node is not temporary
+     */
+    long getExpiryUnixTime();
+
+    /**
+     * @return the {@link Date} when this node will expire
+     * @throws IllegalStateException if the node is not temporary
+     */
+    Date getExpiry();
+
+    /**
+     * @return the number of seconds until this permission will expire
+     * @throws IllegalStateException if the node is not temporary
+     */
+    long getSecondsTilExpiry();
+
+    /**
+     * Return true if the node has expired.
+     * This also returns false if the node is not temporary
+     *
+     * @return true if this node has expired
+     */
+    boolean hasExpired();
+
+    /**
+     * @return the extra contexts required for this node to apply
+     */
+    Map<String, String> getExtraContexts();
+
+    /**
+     * Converts this node into a serialized form
+     * @return a serialized node string
+     */
+    String toSerializedNode();
+
+    /**
+     * @return true if this is a group node
+     */
+    boolean isGroupNode();
+
+    /**
+     * @return the name of the group
+     * @throws IllegalStateException if this is not a group node. See {@link #isGroupNode()}
+     */
+    String getGroupName();
+
+    /**
+     * @return true is this node is a wildcard node
+     */
+    boolean isWildcard();
+
+    /**
+     * Gets the level of this wildcard, higher is more specific
+     * @return the wildcard level
+     * @throws IllegalStateException if this is not a wildcard
+     */
+    int getWildcardLevel();
+
+    /**
+     * @return true if this node is a meta node
+     */
+    boolean isMeta();
+
+    /**
+     * Gets the meta value from this node
+     * @return the meta value
+     * @throws IllegalStateException if this node is not a meta node
+     */
+    Map.Entry<String, String> getMeta();
+
+    /**
+     * @return true if this node is a prefix node
+     */
+    boolean isPrefix();
+
+    /**
+     * Gets the prefix value from this node
+     * @return the prefix value
+     * @throws IllegalStateException if this node is a not a prefix node
+     */
+    Map.Entry<Integer, String> getPrefix();
+
+    /**
+     * @return true if this node is a suffix node
+     */
+    boolean isSuffix();
+
+    /**
+     * Gets the suffix value from this node
+     * @return the suffix value
+     * @throws IllegalStateException if this node is a not a suffix node
+     */
+    Map.Entry<Integer, String> getSuffix();
+
+    /**
+     * Similar to {@link #equals(Object)}, except doesn't take note of the value
+     * @param node the other node
+     * @return true if the two nodes are almost equal
+     */
+    boolean equalsIgnoringValue(Node node);
+
+    /**
+     * Similar to {@link #equals(Object)}, except doesn't take note of the expiry time or value
+     * @param node the other node
+     * @return true if the two nodes are almost equal
+     */
+    boolean almostEquals(Node node);
+
+    /**
+     * Builds a Node instance
+     */
+    interface Builder {
+        Builder setNegated(boolean negated);
+        Builder setValue(boolean value);
+
+        /**
+         * Warning: this value does not persist, and disappears when the holder is re-loaded.
+         * It is therefore only useful for transient nodes.
+         */
+        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(Map.Entry<String, String> entry);
+        Node build();
+    }
+
+}
@@ -0,0 +1,540 @@
+/*
+ * 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.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
+ */
+@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()}
+     */
+    String getObjectName();
+
+    /**
+     * Gets an immutable Set of the objects permission nodes
+     * @return an immutable set of permissions in priority order
+     * @since 2.6
+     */
+    SortedSet<Node> getPermissions();
+
+    /**
+     * Similar to {@link #getPermissions()}, except excluding transient permissions
+     * @return a set of nodes
+     * @since 2.6
+     */
+    Set<Node> getEnduringPermissions();
+
+    /**
+     * Similar to {@link #getPermissions()}, except excluding non-transient permissions
+     * @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
+     */
+    Set<Node> getAllNodes();
+
+    /**
+     * Gets an immutable Map of the objects permission nodes
+     * @return an immutable map of permissions
+     * @deprecated in favour of {@link #getPermissions()}
+     */
+    @Deprecated
+    Map<String, Boolean> getNodes();
+
+    /**
+     * 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
+     * @since 2.6
+     */
+    Tristate hasPermission(Node node);
+
+    /**
+     * 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
+     * @since 2.6
+     */
+    Tristate hasTransientPermission(Node node);
+
+    /**
+     * Checks to see if the object has a certain permission
+     * @param node The permission node
+     * @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 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 server The server
+     * @return true if the object has the permission
+     * @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 server The server
+     * @param world The world
+     * @return true if the object has the permission
+     * @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 temporary if the permission is temporary
+     * @return true if the object has the permission
+     * @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 temporary if the permission is temporary
+     * @return true if the object has the permission
+     * @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 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 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
+     * @since 2.6
+     */
+    Tristate inheritsPermission(Node node);
+
+    /**
+     * Checks to see if the object inherits a certain permission
+     * @param node The permission node
+     * @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 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 server The server
+     * @return true if the object inherits the permission
+     * @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 server The server
+     * @param world The world
+     * @return true if the object inherits the permission
+     * @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 temporary if the permission is temporary
+     * @return true if the object inherits the permission
+     * @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 temporary if the permission is temporary
+     * @return true if the object inherits the permission
+     * @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 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 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
+     * @since 2.6
+     */
+    void setPermission(Node node) throws ObjectAlreadyHasException;
+
+    /**
+     * Sets a transient permission for the object
+     *
+     * <p> A transient node is a permission that does not persist.
+     * Whenever a user logs out of the server, or the server restarts, this permission will disappear.
+     * It is never saved to the datastore, and therefore will not apply on other servers.
+     *
+     * <p> This is useful if you want to temporarily set a permission for a user while they're online, but don't
+     * 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
+     * @since 2.6
+     */
+    void setTransientPermission(Node node) throws ObjectAlreadyHasException;
+
+    /**
+     * Sets a permission for the object
+     * @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
+     * @deprecated in favour of {@link #setPermission(Node)}
+     */
+    @Deprecated
+    void setPermission(String node, boolean value) throws ObjectAlreadyHasException;
+
+    /**
+     * 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 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
+     * @deprecated in favour of {@link #setPermission(Node)}
+     */
+    @Deprecated
+    void setPermission(String node, boolean value, String server) throws ObjectAlreadyHasException;
+
+    /**
+     * 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 server The server 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
+     * @deprecated in favour of {@link #setPermission(Node)}
+     */
+    @Deprecated
+    void setPermission(String node, boolean value, String server, String world) throws ObjectAlreadyHasException;
+
+    /**
+     * 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 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
+     * @deprecated in favour of {@link #setPermission(Node)}
+     */
+    @Deprecated
+    void setPermission(String node, boolean value, long expireAt) throws ObjectAlreadyHasException;
+
+    /**
+     * 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 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
+     * @deprecated in favour of {@link #setPermission(Node)}
+     */
+    @Deprecated
+    void setPermission(String node, boolean value, String server, long expireAt) throws ObjectAlreadyHasException;
+
+    /**
+     * 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 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
+     * @deprecated in favour of {@link #setPermission(Node)}
+     */
+    @Deprecated
+    void setPermission(String node, boolean value, String server, String world, long expireAt) throws ObjectAlreadyHasException;
+
+    /**
+     * 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
+     * @since 2.6
+     */
+    void unsetPermission(Node node) throws ObjectLacksException;
+
+    /**
+     * 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
+     * @since 2.6
+     */
+    void unsetTransientPermission(Node node) throws ObjectLacksException;
+
+    /**
+     * Unsets a permission for the object
+     * @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 IllegalArgumentException if the node is invalid
+     * @deprecated in favour of {@link #unsetPermission(Node)}
+     */
+    @Deprecated
+    void unsetPermission(String node, boolean temporary) throws ObjectLacksException;
+
+    /**
+     * 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 IllegalArgumentException if the node is invalid
+     * @deprecated in favour of {@link #unsetPermission(Node)}
+     */
+    @Deprecated
+    void unsetPermission(String node) throws ObjectLacksException;
+
+    /**
+     * 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
+     * @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)}
+     */
+    @Deprecated
+    void unsetPermission(String node, String server) throws ObjectLacksException;
+
+    /**
+     * 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
+     * @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)}
+     */
+    @Deprecated
+    void unsetPermission(String node, String server, String world) throws ObjectLacksException;
+
+    /**
+     * 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 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 IllegalArgumentException if the node or server is invalid
+     * @deprecated in favour of {@link #unsetPermission(Node)}
+     */
+    @Deprecated
+    void unsetPermission(String node, String server, boolean temporary) throws ObjectLacksException;
+
+    /**
+     * 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 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 IllegalArgumentException if the node, server or world is invalid
+     * @deprecated in favour of {@link #unsetPermission(Node)}
+     */
+    @Deprecated
+    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)}
+     */
+    @Deprecated
+    Map<String, Boolean> getLocalPermissions(String server, String world, List<String> excludedGroups, List<String> possibleNodes);
+
+    /**
+     * 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)}
+     */
+    @Deprecated
+    Map<String, Boolean> getLocalPermissions(String server, String world, List<String> excludedGroups);
+
+    /**
+     * 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)}
+     */
+    @Deprecated
+    Map<String, Boolean> getLocalPermissions(String server, List<String> excludedGroups, List<String> possibleNodes);
+
+    /**
+     * 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)}
+     */
+    @Deprecated
+    Map<String, Boolean> getLocalPermissions(String server, List<String> excludedGroups);
+
+    /**
+     * 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
+     */
+    Map<String, Boolean> getPermissions(String server, String world, Map<String, String> extraContext, boolean includeGlobal, List<String> possibleNodes, boolean applyGroups);
+
+    /**
+     * Processes the nodes and returns the temporary ones.
+     * @return a map of temporary nodes
+     * @deprecated in favour of {@link #getTemporaryPermissionNodes()}
+     */
+    @Deprecated
+    Map<Map.Entry<String, Boolean>, Long> getTemporaryNodes();
+
+    /**
+     * Processes the nodes and returns the temporary ones.
+     * @return a set of temporary nodes
+     * @since 2.6
+     */
+    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();
+
+    /**
+     * 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
+     */
+    void auditTemporaryPermissions();
+
+}
@@ -0,0 +1,44 @@
+/*
+ * 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;
+
+/**
+ * Represents the platform type that LuckPerms is running on
+ * @since 2.7
+ */
+public enum PlatformType {
+
+    BUKKIT("Bukkit"),
+    BUNGEE("Bungee"),
+    SPONGE("Sponge");
+
+    private final String friendlyName;
+
+    PlatformType(String friendlyName) {
+        this.friendlyName = friendlyName;
+    }
+
+    public String getFriendlyName() {
+        return friendlyName;
+    }
+}
@@ -0,0 +1,133 @@
+/*
+ * 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.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
+
+import java.util.List;
+
+/**
+ * Interface for internal Track instances
+ */
+@SuppressWarnings("unused")
+public interface 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
+     * @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 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 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.
+     */
+    void appendGroup(Group group) throws ObjectAlreadyHasException;
+
+    /**
+     * Inserts a group at a certain position on this track
+     * @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.
+     */
+    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 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
+     */
+    void removeGroup(String group) throws ObjectLacksException;
+
+    /**
+     * 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 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
+     */
+    boolean containsGroup(String group);
+
+    /**
+     * Clear all of the groups within this track
+     */
+    void clearGroups();
+
+}
@@ -0,0 +1,47 @@
+/*
+ * 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;
+
+/**
+ * Represents a permission value
+ */
+public enum Tristate {
+
+    TRUE(true),
+    FALSE(false),
+    UNDEFINED(false);
+
+    private final boolean booleanValue;
+
+    Tristate(boolean booleanValue) {
+        this.booleanValue = booleanValue;
+    }
+
+    public boolean asBoolean() {
+        return booleanValue;
+    }
+
+    public static Tristate fromBoolean(boolean b) {
+        return b ? TRUE : FALSE;
+    }
+}
@@ -0,0 +1,261 @@
+/*
+ * 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.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
+
+import java.util.List;
+import java.util.UUID;
+
+/**
+ * Interface for internal User instances
+ */
+@SuppressWarnings("unused")
+public interface User extends PermissionHolder {
+
+    /**
+     * @return the users Mojang assigned unique id
+     */
+    UUID getUuid();
+
+    /**
+     * @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
+     */
+    void setPrimaryGroup(String group) throws ObjectAlreadyHasException;
+
+    /**
+     * Refresh and re-assign the users permissions
+     */
+    void refreshPermissions();
+
+    /**
+     * 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
+     */
+    boolean isInGroup(Group group);
+
+    /**
+     * 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 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 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 server The server 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 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.
+     */
+    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 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
+     */
+    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 server The server 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
+     */
+    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 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
+     */
+    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 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
+     */
+    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 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
+     */
+    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 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 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 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 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 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 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.
+     * @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 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 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 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 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
+     * @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 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 IllegalArgumentException if the server is invalid
+     */
+    List<String> getLocalGroups(String server);
+
+}
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api;
+
+import java.util.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> If you want to get a user object from the datastore using the api on a server in offline mode, you will need to use this cache,
+ * OR use Datastore#getUUID, for users that are not online.
+ *
+ * <p> WARNING: 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
+     */
+    UUID getUUID(UUID external);
+
+    /**
+     * 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
+     */
+    UUID getExternalUUID(UUID internal);
+
+}
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.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
+ */
+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;
+    }
+
+}
@@ -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.data;
+
+/**
+ * Represents the data section of the main LuckPerms configuration.
+ * All methods could return null.
+ */
+@SuppressWarnings("deprecation")
+public interface DatastoreConfiguration extends MySQLConfiguration {
+
+    String getAddress();
+    String getDatabase();
+    String getUsername();
+    String getPassword();
+
+}
@@ -0,0 +1,35 @@
+/*
+ * 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;
+
+/**
+ * @deprecated Use {@link DatastoreConfiguration}. This is now used by multiple datastores, not just MySQL.
+ */
+@Deprecated
+public interface MySQLConfiguration {
+
+    String getAddress();
+    String getDatabase();
+    String getUsername();
+    String getPassword();
+}
@@ -0,0 +1,57 @@
+/*
+ * 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.PermissionHolder;
+
+import java.util.Optional;
+
+public class AbstractPermissionAddEvent extends TargetedEvent<PermissionHolder> {
+
+    private final String server;
+    private final String world;
+    private final long expiry;
+
+    protected AbstractPermissionAddEvent(String eventName, PermissionHolder target, String server, String world, long expiry) {
+        super(eventName, target);
+        this.server = server;
+        this.world = world;
+        this.expiry = expiry;
+    }
+
+    public Optional<String> getServer() {
+        return Optional.ofNullable(server);
+    }
+
+    public Optional<String> getWorld() {
+        return Optional.ofNullable(world);
+    }
+
+    public boolean isTemporary() {
+        return expiry != 0L;
+    }
+
+    public long getExpiry() {
+        return expiry;
+    }
+}
@@ -0,0 +1,43 @@
+/*
+ * 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.Node;
+import me.lucko.luckperms.api.PermissionHolder;
+
+/**
+ * @since 2.6
+ */
+public class AbstractPermissionEvent extends TargetedEvent<PermissionHolder> {
+
+    private final Node node;
+
+    protected AbstractPermissionEvent(String eventName, PermissionHolder target, Node node) {
+        super(eventName, target);
+        this.node = node;
+    }
+
+    public Node getNode() {
+        return node;
+    }
+}
@@ -0,0 +1,62 @@
+/*
+ * 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.PermissionHolder;
+
+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);
+    }
+
+    /**
+     * @deprecated use {@link #isTemporary()}
+     */
+    @Deprecated
+    public boolean getTemporary() {
+        return temporary;
+    }
+
+    public boolean isTemporary() {
+        return temporary;
+    }
+
+}
@@ -0,0 +1,43 @@
+/*
+ * 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;
+
+/**
+ * Event that allows listeners to set the cancelled state of an event.
+ */
+public abstract class CancellableEvent extends LPEvent {
+
+    private boolean cancelled = false;
+
+    protected CancellableEvent(String eventName) {
+        super(eventName);
+    }
+
+    public boolean isCancelled() {
+        return cancelled;
+    }
+
+    public void setCancelled(boolean cancelled) {
+        this.cancelled = cancelled;
+    }
+}
@@ -0,0 +1,61 @@
+/*
+ * 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;
+
+/**
+ * Abstract LuckPerms Event class.
+ */
+public abstract class LPEvent {
+
+    /**
+     * A link to the API instance provided for convenience.
+     */
+    private LuckPermsApi api = null;
+
+    /**
+     * A friendly name of the event
+     */
+    private final String eventName;
+
+    protected LPEvent(String eventName) {
+        this.eventName = eventName;
+    }
+
+    public String getEventName() {
+        return eventName;
+    }
+
+    public LuckPermsApi getApi() {
+        return api;
+    }
+
+    public void setApi(LuckPermsApi api) {
+        if (this.api != null) {
+            throw new IllegalStateException("API can only be set once.");
+        }
+        this.api = api;
+    }
+
+}
@@ -0,0 +1,29 @@
+/*
+ * 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;
+
+/**
+ * Used to mark a class that listens for LuckPerms events
+ */
+public interface LPListener {
+}
@@ -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;
+
+/**
+ * Represents an event acting upon a target
+ * @param <T> the target type
+ */
+public class TargetedEvent<T> extends LPEvent {
+
+    private final T target;
+
+    protected TargetedEvent(String eventName, T target) {
+        super(eventName);
+        this.target = target;
+    }
+
+    public T getTarget() {
+        return target;
+    }
+}
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.event;
+
+import me.lucko.luckperms.api.Track;
+import me.lucko.luckperms.api.User;
+
+public abstract class TrackEvent extends LPEvent {
+
+    private final Track track;
+    private final User user;
+    private final String fromGroup;
+    private final String toGroup;
+
+    protected TrackEvent(String eventName, Track track, User user, String fromGroup, String toGroup) {
+        super(eventName);
+        this.track = track;
+        this.user = user;
+        this.fromGroup = fromGroup;
+        this.toGroup = toGroup;
+    }
+
+    public Track getTrack() {
+        return track;
+    }
+
+    public User getUser() {
+        return user;
+    }
+
+    public String getFromGroup() {
+        return fromGroup;
+    }
+
+    public String getToGroup() {
+        return toGroup;
+    }
+}
@@ -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;
+
+import me.lucko.luckperms.api.User;
+
+/**
+ * Represents an event acting upon a user.
+ */
+public class UserEvent extends LPEvent {
+
+    private final User user;
+
+    protected UserEvent(String eventName, User user) {
+        super(eventName);
+        this.user = user;
+    }
+
+    public User getUser() {
+        return user;
+    }
+}
@@ -0,0 +1,47 @@
+/*
+ * 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.Group;
+import me.lucko.luckperms.api.PermissionHolder;
+import me.lucko.luckperms.api.event.AbstractPermissionAddEvent;
+
+/**
+ * Called whenever a user or group is added to / starts to inherit another group
+ */
+public class GroupAddEvent extends AbstractPermissionAddEvent {
+
+    /**
+     * The group being added to the target
+     */
+    private final Group group;
+
+    public GroupAddEvent(PermissionHolder target, Group group, String server, String world, long expiry) {
+        super("Group Add Event", target, server, world, expiry);
+        this.group = group;
+    }
+
+    public Group getGroup() {
+        return group;
+    }
+}
@@ -0,0 +1,47 @@
+/*
+ * 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;
+    }
+}
@@ -0,0 +1,49 @@
+/*
+ * 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.LogEntry;
+import me.lucko.luckperms.api.event.CancellableEvent;
+
+/**
+ * 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.
+ */
+public class LogNotifyEvent extends CancellableEvent {
+
+    /**
+     * The log entry to be broadcasted
+     */
+    private final LogEntry entry;
+
+    public LogNotifyEvent(LogEntry entry) {
+        super("Log Notify Event");
+        this.entry = entry;
+    }
+
+    public LogEntry getEntry() {
+        return entry;
+    }
+
+}
@@ -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.events;
+
+import me.lucko.luckperms.api.PermissionHolder;
+import me.lucko.luckperms.api.event.TargetedEvent;
+
+/**
+ * Called when a permission expires for an object.
+ * @deprecated in favour of {@link PermissionNodeExpireEvent}
+ */
+@Deprecated
+public class PermissionExpireEvent extends TargetedEvent<PermissionHolder> {
+
+    private final String node;
+
+    public PermissionExpireEvent(PermissionHolder target, String node) {
+        super("Permission Expire Event", target);
+        this.node = node;
+    }
+
+    public String getNode() {
+        return node;
+    }
+}
@@ -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.events;
+
+import me.lucko.luckperms.api.Node;
+import me.lucko.luckperms.api.PermissionHolder;
+import me.lucko.luckperms.api.event.AbstractPermissionEvent;
+
+/**
+ * Called when a temporary permission node expires
+ * @since 2.6
+ */
+public class PermissionNodeExpireEvent extends AbstractPermissionEvent {
+    public PermissionNodeExpireEvent(PermissionHolder target, Node node) {
+        super("Permission Node Expire Event", target, node);
+    }
+}
@@ -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.events;
+
+import me.lucko.luckperms.api.Node;
+import me.lucko.luckperms.api.PermissionHolder;
+import me.lucko.luckperms.api.event.AbstractPermissionEvent;
+
+/**
+ * Called when a permission node is set on a holder
+ * @since 2.6
+ */
+public class PermissionNodeSetEvent extends AbstractPermissionEvent {
+    public PermissionNodeSetEvent(PermissionHolder target, Node node) {
+        super("Permission Node Set Event", target, node);
+    }
+}
@@ -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.events;
+
+import me.lucko.luckperms.api.Node;
+import me.lucko.luckperms.api.PermissionHolder;
+import me.lucko.luckperms.api.event.AbstractPermissionEvent;
+
+/**
+ * Called when a permission node is unset from a holder
+ * @since 2.6
+ */
+public class PermissionNodeUnsetEvent extends AbstractPermissionEvent {
+    public PermissionNodeUnsetEvent(PermissionHolder target, Node node) {
+        super("Permission Node Unset Event", target, node);
+    }
+}
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.event.events;
+
+import me.lucko.luckperms.api.PermissionHolder;
+import me.lucko.luckperms.api.event.AbstractPermissionAddEvent;
+
+import java.util.AbstractMap;
+import java.util.Map;
+
+/**
+ * Called whenever a user or group has a permission set.
+ * @deprecated in favour of {@link PermissionNodeSetEvent}
+ */
+@Deprecated
+public class PermissionSetEvent extends AbstractPermissionAddEvent {
+
+    private final String node;
+    private final boolean value;
+
+    public PermissionSetEvent(PermissionHolder target, String node, boolean value, String server, String world, long expiry) {
+        super("Permission Set Event", target, server, world, expiry);
+        this.node = node;
+        this.value = value;
+    }
+
+    public String getNode() {
+        return node;
+    }
+
+    public boolean getValue() {
+        return value;
+    }
+
+    public Map.Entry<String, Boolean> getEntry() {
+        return new AbstractMap.SimpleEntry<>(node, value);
+    }
+}
@@ -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.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,36 @@
+/*
+ * 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.event.LPEvent;
+
+/**
+ * Called after the sync task has ran.
+ */
+public class PostSyncEvent extends LPEvent {
+
+    public PostSyncEvent() {
+        super("Post Sync Event");
+    }
+
+}
@@ -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.events;
+
+import me.lucko.luckperms.api.event.CancellableEvent;
+
+/**
+ * Called before the sync task is about to run.
+ * Set this event to cancelled to prevent the sync task from running.
+ */
+public class PreSyncEvent extends CancellableEvent {
+
+    public PreSyncEvent() {
+        super("Pre Sync Event");
+    }
+
+}
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.event.events;
+
+import me.lucko.luckperms.api.Track;
+import me.lucko.luckperms.api.User;
+import me.lucko.luckperms.api.event.TrackEvent;
+
+/**
+ * Called whenever a user is demoted down a track
+ */
+public class UserDemoteEvent extends TrackEvent {
+
+    public UserDemoteEvent(Track track, User user, String from, String to) {
+        super("User Demote Event", track, user, from, to);
+    }
+
+}
@@ -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.events;
+
+import me.lucko.luckperms.api.event.LPEvent;
+
+import java.util.UUID;
+
+/**
+ * Called when the user logs into the network for the first time.
+ * Particularly useful for networks with multiple lobbies, who want to welcome a user when they join for the first time.
+ *
+ * <p>This event is fired before the player has actually joined the game on the async login / auth event.
+ * If you want to do something with the user, store the UUID in a set, and then check the set in the PlayerJoinEvent o.e.
+ */
+public class UserFirstLoginEvent extends LPEvent {
+
+    private final UUID uuid;
+    private final String username;
+
+    public UserFirstLoginEvent(UUID uuid, String username) {
+        super("User First Join Event");
+        this.uuid = uuid;
+        this.username = username;
+    }
+
+    public UUID getUuid() {
+        return uuid;
+    }
+
+    public String getUsername() {
+        return username;
+    }
+}
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.event.events;
+
+import me.lucko.luckperms.api.User;
+import me.lucko.luckperms.api.event.UserEvent;
+
+/**
+ * Called after a user has their permissions refreshed.
+ * If you cache user permissions within your own plugin, it's a good idea to update said cache whenever this event is called.
+ */
+public class UserPermissionRefreshEvent extends UserEvent {
+
+    public UserPermissionRefreshEvent(User user) {
+        super("User Permission Refresh Event", user);
+    }
+
+}
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.event.events;
+
+import me.lucko.luckperms.api.Track;
+import me.lucko.luckperms.api.User;
+import me.lucko.luckperms.api.event.TrackEvent;
+
+/**
+ * Called whenever a user is promoted up a track
+ */
+public class UserPromoteEvent extends TrackEvent {
+
+    public UserPromoteEvent(Track track, User user, String from, String to) {
+        super("User Promote Event", track, user, from, to);
+    }
+
+}
@@ -0,0 +1,8 @@
+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
+ * @since 2.7
+ */
+public abstract class MembershipException extends Exception {
+}
@@ -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.exceptions;
+
+/**
+ * Thrown when a permission holding object already has a permission, is already a member of a group, or when a track
+ * already contains a group.
+ */
+public class ObjectAlreadyHasException extends MembershipException {
+}
@@ -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.exceptions;
+
+/**
+ * Thrown when a permission holding object does not already have a permission, is not already a member of a group,
+ * or when a track doesn't contain a group.
+ */
+public class ObjectLacksException extends MembershipException {
+}
@@ -0,0 +1,52 @@
+<?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"
+         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.7-SNAPSHOT</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>luckperms-bukkit-placeholders</artifactId>
+    <build>
+        <finalName>LuckPermsPlaceholderExpansion</finalName>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.5.1</version>
+                <configuration>
+                    <source>1.8</source>
+                    <target>1.8</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+    <dependencies>
+        <!-- LuckPerms API -->
+        <dependency>
+            <groupId>me.lucko.luckperms</groupId>
+            <artifactId>luckperms-api</artifactId>
+            <version>2.5</version>
+            <scope>compile</scope>
+        </dependency>
+        <!-- BukkitAPI -->
+        <dependency>
+            <groupId>org.bukkit</groupId>
+            <artifactId>bukkit</artifactId>
+            <version>1.8.8-R0.1-SNAPSHOT</version>
+            <scope>provided</scope>
+        </dependency>
+        <!-- PlaceholderAPI -->
+        <dependency>
+            <groupId>me.clip</groupId>
+            <artifactId>placeholderapi</artifactId>
+            <version>2.2.0</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+
+</project>
@@ -0,0 +1,247 @@
+/*
+ * 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.placeholders;
+
+import me.clip.placeholderapi.PlaceholderAPIPlugin;
+import me.clip.placeholderapi.expansion.PlaceholderExpansion;
+import me.clip.placeholderapi.util.TimeUtil;
+import me.lucko.luckperms.api.LuckPermsApi;
+import me.lucko.luckperms.api.Track;
+import me.lucko.luckperms.api.User;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+
+import java.util.Map;
+import java.util.Optional;
+import java.util.regex.Pattern;
+
+/*
+ * PlaceholderAPI Expansion for LuckPerms, implemented using the LuckPerms API.
+ *
+ * Placeholders:
+ * - group_name
+ * - has_permission_<node>
+ * - inherits_permission_<node>
+ * - in_group_<name>
+ * - inherits_group_<name>
+ * - on_track_<track>
+ * - expiry_time_<node>
+ * - group_expiry_time_<group>
+ * - prefix
+ * - suffix
+ * - meta_<node>
+ */
+public class LuckPermsPlaceholderExpansion extends PlaceholderExpansion {
+    private static final String IDENTIFIER = "luckperms";
+    private static final String PLUGIN_NAME = "LuckPerms";
+    private static final String AUTHOR = "Luck";
+
+    private LuckPermsApi api = null;
+
+    @Override
+    public boolean canRegister() {
+        return Bukkit.getServicesManager().isProvidedFor(LuckPermsApi.class);
+    }
+
+    @Override
+    public boolean register() {
+        if (!canRegister()) {
+            return false;
+        }
+
+        api = Bukkit.getServicesManager().getRegistration(LuckPermsApi.class).getProvider();
+        return super.register();
+    }
+
+    @Override
+    public String getVersion() {
+        return "2.5";
+    }
+
+    @Override
+    public String onPlaceholderRequest(Player player, String identifier) {
+        if (player == null || api == null) {
+            return "";
+        }
+
+        Optional<User> u = api.getUserSafe(player.getUniqueId());
+        if (!u.isPresent()) {
+            return "";
+        }
+
+        identifier = identifier.toLowerCase();
+        final User user = u.get();
+
+        if (identifier.equalsIgnoreCase("group_name")) {
+            return user.getPrimaryGroup();
+        }
+
+        if (identifier.startsWith("has_permission_") && identifier.length() > "has_permission_".length()) {
+            String node = identifier.substring("has_permission_".length());
+            return formatBoolean(user.hasPermission(node, true));
+        }
+
+        if (identifier.startsWith("inherits_permission_") && identifier.length() > "inherits_permission_".length()) {
+            String node = identifier.substring("inherits_permission_".length());
+            return formatBoolean(user.inheritsPermission(node, true));
+        }
+
+        if (identifier.startsWith("in_group_") && identifier.length() > "in_group_".length()) {
+            String groupName = identifier.substring("in_group_".length());
+            return formatBoolean(user.getGroupNames().contains(groupName));
+        }
+
+        if (identifier.startsWith("inherits_group_") && identifier.length() > "inherits_group_".length()) {
+            String groupName = identifier.substring("inherits_group_".length());
+            return formatBoolean(user.getLocalGroups("global").contains(groupName));
+        }
+
+        if (identifier.startsWith("on_track_") && identifier.length() > "on_track_".length()) {
+            String trackName = identifier.substring("on_track_".length());
+
+            Optional<Track> track = api.getTrackSafe(trackName);
+            if (!track.isPresent()) return "";
+
+            return formatBoolean(track.get().containsGroup(user.getPrimaryGroup()));
+        }
+
+        if (identifier.startsWith("expiry_time_") && identifier.length() > "expiry_time_".length()) {
+            String node = identifier.substring("expiry_time_".length());
+
+
+            long currentTime = System.currentTimeMillis() / 1000L;
+            Map<Map.Entry<String, Boolean>, Long> temps = user.getTemporaryNodes();
+
+            for (Map.Entry<Map.Entry<String, Boolean>, Long> e : temps.entrySet()) {
+                if (!e.getKey().getKey().equalsIgnoreCase(node)) {
+                    continue;
+                }
+
+                return TimeUtil.getTime((int) (e.getValue() - currentTime));
+            }
+
+            return "";
+        }
+
+        if (identifier.startsWith("group_expiry_time_") && identifier.length() > "group_expiry_time_".length()) {
+            String node = "group." + identifier.substring("group_expiry_time_".length());
+
+            long currentTime = System.currentTimeMillis() / 1000L;
+            Map<Map.Entry<String, Boolean>, Long> temps = user.getTemporaryNodes();
+
+            for (Map.Entry<Map.Entry<String, Boolean>, Long> e : temps.entrySet()) {
+                if (!e.getKey().getKey().equalsIgnoreCase(node)) {
+                    continue;
+                }
+
+                return TimeUtil.getTime((int) (e.getValue() - currentTime));
+            }
+
+            return "";
+        }
+
+        if (identifier.equalsIgnoreCase("prefix")) {
+            return getChatMeta(PREFIX_PATTERN, user);
+        }
+
+        if (identifier.equalsIgnoreCase("suffix")) {
+            return getChatMeta(SUFFIX_PATTERN, user);
+        }
+
+        if (identifier.startsWith("meta_") && identifier.length() > "meta_".length()) {
+            String node = "meta." + escapeCharacters(identifier.substring("meta_".length())) + ".";
+            Map<String, Boolean> nodes = user.getNodes();
+
+            for (Map.Entry<String, Boolean> e : nodes.entrySet()) {
+                if (!e.getValue()) continue;
+                if (!e.getKey().toLowerCase().startsWith(node)) continue;
+
+                String meta = e.getKey().substring(node.length());
+                return unescapeCharacters(meta);
+            }
+
+            return "";
+        }
+
+        return null;
+    }
+
+    @Override
+    public String getIdentifier() {
+        return IDENTIFIER;
+    }
+
+    @Override
+    public String getPlugin() {
+        return PLUGIN_NAME;
+    }
+
+    @Override
+    public String getAuthor() {
+        return AUTHOR;
+    }
+
+    private static String formatBoolean(boolean b) {
+        return b ? PlaceholderAPIPlugin.booleanTrue() : PlaceholderAPIPlugin.booleanFalse();
+    }
+
+    private static String escapeCharacters(String s) {
+        s = s.replace(".", "{SEP}");
+        s = s.replace("/", "{FSEP}");
+        s = s.replace("$", "{DSEP}");
+
+        return s;
+    }
+
+    private static String unescapeCharacters(String s) {
+        s = s.replace("{SEP}", ".");
+        s = s.replace("{FSEP}", "/");
+        s = s.replace("{DSEP}", "$");
+
+        return s;
+    }
+
+    private static final Pattern PREFIX_PATTERN = Pattern.compile("(?i)prefix\\.\\d+\\..*");
+    private static final Pattern SUFFIX_PATTERN = Pattern.compile("(?i)suffix\\.\\d+\\..*");
+    private static final Pattern DOT_PATTERN = Pattern.compile("\\.");
+
+    private static String getChatMeta(Pattern pattern, User user) {
+        int priority = 0;
+        String meta = null;
+        for (Map.Entry<String, Boolean> e : user.getLocalPermissions(null, null).entrySet()) {
+            if (!e.getValue()) continue;
+
+            if (pattern.matcher(e.getKey()).matches()) {
+                String[] parts = DOT_PATTERN.split(e.getKey(), 3);
+                int p = Integer.parseInt(parts[1]);
+
+                if (meta == null || p > priority) {
+                    meta = parts[2];
+                    priority = p;
+                }
+            }
+        }
+
+        return meta == null ? "" : unescapeCharacters(meta);
+    }
+}
@@ -4,19 +4,17 @@
         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</groupId>
-        <version>1.2</version>
+        <groupId>me.lucko.luckperms</groupId>
+        <version>2.7-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>luckperms-bukkit</artifactId>
-    <version>$(project.parent.version)</version>
    <packaging>jar</packaging>
-    <name>LuckPerms</name>

    <build>
        <defaultGoal>clean package</defaultGoal>
-        <finalName>LuckPerms</finalName>
+        <finalName>LuckPerms-${release.version}.${git.closest.tag.commit.count}</finalName>
        <sourceDirectory>${basedir}/src/main/java</sourceDirectory>
        <resources>
            <resource>
@@ -45,11 +43,53 @@
                            <goal>shade</goal>
                        </goals>
                        <configuration>
-                            <minimizeJar>true</minimizeJar>
+                            <minimizeJar>false</minimizeJar>
+                            <artifactSet>
+                                <excludes>
+                                    <exclude>org.xerial:*</exclude>
+                                </excludes>
+                            </artifactSet>
+                            <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>
+                            </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>

@@ -65,15 +105,29 @@
        <dependency>
            <groupId>net.milkbowl.vault</groupId>
            <artifactId>VaultAPI</artifactId>
-            <version>1.5</version>
+            <version>1.6</version>
            <scope>provided</scope>
        </dependency>
        <!-- LuckPerms Common -->
        <dependency>
-            <groupId>me.lucko</groupId>
+            <groupId>me.lucko.luckperms</groupId>
            <artifactId>luckperms-common</artifactId>
-            <version>${project.parent.version}</version>
+            <version>${project.version}</version>
            <scope>compile</scope>
        </dependency>
+        <!-- LuckPerms API -->
+        <dependency>
+            <groupId>me.lucko.luckperms</groupId>
+            <artifactId>luckperms-api</artifactId>
+            <version>${project.version}</version>
+            <scope>compile</scope>
+        </dependency>
+        <!-- Lombok -->
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>1.16.10</version>
+            <scope>provided</scope>
+        </dependency>
    </dependencies>
-</project>
+</project>
@@ -0,0 +1,51 @@
+/*
+ * 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;
+
+import me.lucko.luckperms.api.data.Callback;
+import me.lucko.luckperms.commands.CommandManager;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+
+import java.util.Arrays;
+import java.util.List;
+
+class BukkitCommand extends CommandManager implements CommandExecutor, TabExecutor {
+    BukkitCommand(LuckPermsPlugin plugin) {
+        super(plugin);
+    }
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        onCommand(BukkitSenderFactory.get().wrap(sender), label, Arrays.asList(args), Callback.empty());
+        return true;
+    }
+
+
+    @Override
+    public List<String> onTabComplete(CommandSender sender, Command command, String label, String[] args) {
+        return onTabComplete(BukkitSenderFactory.get().wrap(sender), Arrays.asList(args));
+    }
+}
@@ -1,72 +1,77 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
 package me.lucko.luckperms;

-import me.lucko.luckperms.utils.LPConfiguration;
+import me.lucko.luckperms.core.LPConfiguration;
 import org.bukkit.configuration.InvalidConfigurationException;
 import org.bukkit.configuration.file.YamlConfiguration;

 import java.io.File;
 import java.io.IOException;

-public class BukkitConfig implements LPConfiguration {
-    private final LPBukkitPlugin plugin;
+class BukkitConfig extends LPConfiguration<LPBukkitPlugin> {
    private YamlConfiguration configuration;

-    public BukkitConfig(LPBukkitPlugin plugin) {
-        this.plugin = plugin;
-        create();
+    BukkitConfig(LPBukkitPlugin plugin) {
+        super(plugin, "global", true, "sqlite");
    }

    @SuppressWarnings("ResultOfMethodCallIgnored")
-    private void create() {
-        File configFile = new File(plugin.getDataFolder(), "config.yml");
+    @Override
+    protected void init() {
+        File configFile = new File(getPlugin().getDataFolder(), "config.yml");

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

        configuration = new YamlConfiguration();

        try {
            configuration.load(configFile);
-
        } catch (InvalidConfigurationException | IOException e) {
            e.printStackTrace();
        }
    }

    @Override
-    public String getServer() {
-        return configuration.getString("server", "global");
+    protected void set(String path, Object value) {
+        configuration.set(path, value);
    }

    @Override
-    public int getSyncTime() {
-        return configuration.getInt("sql.sync-minutes", 3);
+    protected String getString(String path, String def) {
+        return configuration.getString(path, def);
    }

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

    @Override
-    public String getDefaultGroupName() {
-        return configuration.getString("default-group", "default");
-    }
-
-    @Override
-    public boolean getIncludeGlobalPerms() {
-        return configuration.getBoolean("include-global", true);
-    }
-
-    @Override
-    public String getDatabaseValue(String value) {
-        return configuration.getString("sql." + value);
-    }
-
-    @Override
-    public String getStorageMethod() {
-        return configuration.getString("storage-method", "sqlite");
+    protected boolean getBoolean(String path, boolean def) {
+        return configuration.getBoolean(path, def);
    }
 }
@@ -0,0 +1,108 @@
+/*
+ * 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;
+
+import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.users.BukkitUser;
+import me.lucko.luckperms.users.User;
+import me.lucko.luckperms.utils.AbstractListener;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.*;
+import org.bukkit.permissions.PermissionAttachment;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+class BukkitListener extends AbstractListener implements Listener {
+    private final LPBukkitPlugin plugin;
+
+    BukkitListener(LPBukkitPlugin plugin) {
+        super(plugin);
+        this.plugin = plugin;
+    }
+
+    @EventHandler
+    public void onPlayerPreLogin(AsyncPlayerPreLoginEvent e) {
+        if (!plugin.getDatastore().isAcceptingLogins()) {
+            // The datastore is disabled, prevent players from joining the server
+            e.disallow(AsyncPlayerPreLoginEvent.Result.KICK_OTHER, Message.LOADING_ERROR.toString());
+            return;
+        }
+
+        onAsyncLogin(e.getUniqueId(), e.getName());
+    }
+
+    @EventHandler
+    public void onPlayerLogin(PlayerLoginEvent e) {
+        final Player player = e.getPlayer();
+        final User user = plugin.getUserManager().get(plugin.getUuidCache().getUUID(player.getUniqueId()));
+
+        if (user == null) {
+            e.disallow(PlayerLoginEvent.Result.KICK_OTHER, Message.LOADING_ERROR.toString());
+            return;
+        }
+
+        if (user instanceof BukkitUser) {
+            BukkitUser u = (BukkitUser) user;
+
+            PermissionAttachment attachment = player.addAttachment(plugin);
+            Map<String, Boolean> newPermMap = new ConcurrentHashMap<>();
+            try {
+                /* Replace the standard LinkedHashMap in the attachment with a ConcurrentHashMap.
+                   This means that we can iterate over and change the permissions within our attachment asynchronously,
+                   without worrying about thread safety. The Bukkit side of things should still operate normally. Internal
+                   permission stuff should work the same. This is by far the most easy and efficient way to do things, without
+                   having to do tons of reflection. */
+                BukkitUser.getPermissionsField().set(attachment, newPermMap);
+            } catch (Throwable t) {
+                t.printStackTrace();
+            }
+
+            u.setAttachment(new BukkitUser.PermissionAttachmentHolder(attachment, newPermMap));
+        }
+
+        plugin.doAsync(user::refreshPermissions);
+    }
+
+    @EventHandler
+    public void onPlayerJoin(PlayerJoinEvent e) {
+        // Refresh permissions again
+        plugin.getUserManager().getWorldCache().put(e.getPlayer().getUniqueId(), e.getPlayer().getWorld().getName());
+        plugin.doAsync(() -> refreshPlayer(e.getPlayer().getUniqueId()));
+    }
+
+    @EventHandler
+    public void onPlayerChangedWorld(PlayerChangedWorldEvent e) {
+        plugin.getUserManager().getWorldCache().put(e.getPlayer().getUniqueId(), e.getPlayer().getWorld().getName());
+        plugin.doAsync(() -> refreshPlayer(e.getPlayer().getUniqueId()));
+
+    }
+
+    @EventHandler
+    public void onPlayerQuit(PlayerQuitEvent e) {
+        plugin.getUserManager().getWorldCache().remove(e.getPlayer().getUniqueId());
+        onLeave(e.getPlayer().getUniqueId());
+    }
+}
@@ -0,0 +1,69 @@
+/*
+ * 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;
+
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+import me.lucko.luckperms.commands.SenderFactory;
+import me.lucko.luckperms.constants.Constants;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.UUID;
+
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+public class BukkitSenderFactory extends SenderFactory<CommandSender> {
+    private static BukkitSenderFactory instance = null;
+    public static BukkitSenderFactory get() {
+        if (instance == null){
+            instance = new BukkitSenderFactory();
+        }
+        return instance;
+    }
+
+    @Override
+    protected String getName(CommandSender sender) {
+        if (sender instanceof Player) {
+            return sender.getName();
+        }
+        return Constants.getConsoleName();
+    }
+
+    @Override
+    protected UUID getUuid(CommandSender sender) {
+        if (sender instanceof Player) {
+            return ((Player) sender).getUniqueId();
+        }
+        return Constants.getConsoleUUID();
+    }
+
+    @Override
+    protected void sendMessage(CommandSender sender, String s) {
+        sender.sendMessage(s);
+    }
+
+    @Override
+    protected boolean hasPermission(CommandSender sender, String node) {
+        return sender.hasPermission(node);
+    }
+}
@@ -1,49 +0,0 @@
-package me.lucko.luckperms;
-
-import me.lucko.luckperms.commands.CommandManager;
-import me.lucko.luckperms.commands.Sender;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
-import org.bukkit.command.TabExecutor;
-
-import java.lang.ref.WeakReference;
-import java.util.Arrays;
-import java.util.List;
-
-class CommandManagerBukkit extends CommandManager implements CommandExecutor, TabExecutor {
-    CommandManagerBukkit(LuckPermsPlugin plugin) {
-        super(plugin);
-    }
-
-    @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        return onCommand(makeSender(sender), label, Arrays.asList(args));
-    }
-
-
-    @Override
-    public List<String> onTabComplete(CommandSender sender, Command command, String label, String[] args) {
-        return onTabComplete(makeSender(sender), Arrays.asList(args));
-    }
-
-    private static Sender makeSender(CommandSender sender) {
-        return new Sender() {
-            final WeakReference<CommandSender> cs = new WeakReference<>(sender);
-
-            @Override
-            public void sendMessage(String s) {
-                final CommandSender c = cs.get();
-                if (c != null) {
-                    c.sendMessage(s);
-                }
-            }
-
-            @Override
-            public boolean hasPermission(String node) {
-                final CommandSender c = cs.get();
-                return c != null && c.hasPermission(node);
-            }
-        };
-    }
-}
@@ -1,85 +1,100 @@
+/*
+ * 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;

 import lombok.Getter;
-import me.lucko.luckperms.data.Datastore;
-import me.lucko.luckperms.data.MySQLConfiguration;
-import me.lucko.luckperms.data.methods.FlatfileDatastore;
-import me.lucko.luckperms.data.methods.MySQLDatastore;
-import me.lucko.luckperms.data.methods.SQLiteDatastore;
+import me.lucko.luckperms.api.Logger;
+import me.lucko.luckperms.api.LuckPermsApi;
+import me.lucko.luckperms.api.PlatformType;
+import me.lucko.luckperms.api.implementation.ApiProvider;
+import me.lucko.luckperms.api.vault.VaultHook;
+import me.lucko.luckperms.commands.ConsecutiveExecutor;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.core.LPConfiguration;
+import me.lucko.luckperms.core.UuidCache;
+import me.lucko.luckperms.data.Importer;
 import me.lucko.luckperms.groups.GroupManager;
-import me.lucko.luckperms.listeners.PlayerListener;
+import me.lucko.luckperms.runnables.ExpireTemporaryTask;
 import me.lucko.luckperms.runnables.UpdateTask;
+import me.lucko.luckperms.storage.Datastore;
+import me.lucko.luckperms.storage.StorageFactory;
 import me.lucko.luckperms.tracks.TrackManager;
 import me.lucko.luckperms.users.BukkitUserManager;
-import me.lucko.luckperms.users.UserManager;
-import me.lucko.luckperms.utils.LPConfiguration;
-import me.lucko.luckperms.vaulthooks.VaultHook;
-import org.bukkit.Bukkit;
+import me.lucko.luckperms.utils.LogFactory;
 import org.bukkit.command.PluginCommand;
 import org.bukkit.entity.Player;
 import org.bukkit.plugin.PluginManager;
+import org.bukkit.plugin.ServicePriority;
 import org.bukkit.plugin.java.JavaPlugin;

 import java.io.File;
-import java.util.Arrays;
-import java.util.List;
-import java.util.UUID;
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.stream.Collectors;

@Getter
 public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
-    public static final String VERSION = "v1.2";
-
+    private final Set<UUID> ignoringLogs = ConcurrentHashMap.newKeySet();
    private LPConfiguration configuration;
-    private UserManager userManager;
+    private BukkitUserManager userManager;
    private GroupManager groupManager;
    private TrackManager trackManager;
    private Datastore datastore;
+    private UuidCache uuidCache;
+    private ApiProvider apiProvider;
+    private Logger log;
+    private Importer importer;
+    private ConsecutiveExecutor consecutiveExecutor;

    @Override
    public void onEnable() {
+        log = LogFactory.wrap(getLogger());
+
+        getLog().info("Loading configuration...");
        configuration = new BukkitConfig(this);

        // register events
-        PluginManager pm = Bukkit.getPluginManager();
-        pm.registerEvents(new PlayerListener(this), this);
+        PluginManager pm = getServer().getPluginManager();
+        pm.registerEvents(new BukkitListener(this), this);

        // register commands
-        CommandManagerBukkit commandManager = new CommandManagerBukkit(this);
+        getLog().info("Registering commands...");
+        BukkitCommand commandManager = new BukkitCommand(this);
        PluginCommand main = getServer().getPluginCommand("luckperms");
        main.setExecutor(commandManager);
        main.setTabCompleter(commandManager);
        main.setAliases(Arrays.asList("perms", "lp", "permissions", "p", "perm"));

-        final String storageMethod = configuration.getStorageMethod();
-
-        if (storageMethod.equalsIgnoreCase("mysql")) {
-            getLogger().info("Using MySQL as storage method.");
-            datastore = new MySQLDatastore(this, new MySQLConfiguration(
-                    configuration.getDatabaseValue("address"),
-                    configuration.getDatabaseValue("database"),
-                    configuration.getDatabaseValue("username"),
-                    configuration.getDatabaseValue("password")
-            ));
-        } else if (storageMethod.equalsIgnoreCase("sqlite")) {
-            getLogger().info("Using SQLite as storage method.");
-            datastore = new SQLiteDatastore(this, new File(getDataFolder(), "luckperms.sqlite"));
-        } else if (storageMethod.equalsIgnoreCase("flatfile")) {
-            getLogger().info("Using Flatfile (JSON) as storage method.");
-            datastore = new FlatfileDatastore(this, getDataFolder());
-        } else {
-            getLogger().warning("Storage method '" + storageMethod + "' was not recognised. Using SQLite as fallback.");
-            datastore = new SQLiteDatastore(this, new File(getDataFolder(), "luckperms.sqlite"));
-        }
-
-        datastore.init();
+        datastore = StorageFactory.getDatastore(this, "h2");

+        getLog().info("Loading internal permission managers...");
+        uuidCache = new UuidCache(getConfiguration().getOnlineMode());
        userManager = new BukkitUserManager(this);
        groupManager = new GroupManager(this);
-        trackManager = new TrackManager(this);
-
-        // Run update task to refresh any online users
-        runUpdateTask();
+        trackManager = new TrackManager();
+        importer = new Importer(commandManager);
+        consecutiveExecutor = new ConsecutiveExecutor(commandManager);

        int mins = getConfiguration().getSyncTime();
        if (mins > 0) {
@@ -87,39 +102,78 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
            getServer().getScheduler().runTaskTimerAsynchronously(this, new UpdateTask(this), ticks, ticks);
        }

+        getServer().getScheduler().runTaskTimer(this, BukkitSenderFactory.get(), 1L, 1L);
+        getServer().getScheduler().runTaskTimerAsynchronously(this, new ExpireTemporaryTask(this), 60L, 60L);
+        getServer().getScheduler().runTaskTimerAsynchronously(this, consecutiveExecutor, 20L, 20L);
+
        // Provide vault support
-        if (getServer().getPluginManager().isPluginEnabled("Vault")) {
-            VaultHook.hook(this);
-            getLogger().info("Registered Vault permission & chat hook.");
-        } else {
-            getLogger().info("Vault not found.");
+        getLog().info("Attempting to hook into Vault...");
+        try {
+            if (getServer().getPluginManager().isPluginEnabled("Vault")) {
+                VaultHook.hook(this);
+                getLog().info("Registered Vault permission & chat hook.");
+            } else {
+                getLog().info("Vault not found.");
+            }
+        } catch (Exception e) {
+            getLog().severe("Error occurred whilst hooking into Vault.");
+            e.printStackTrace();
        }

+        getLog().info("Registering API...");
+        apiProvider = new ApiProvider(this);
+        LuckPerms.registerProvider(apiProvider);
+        getServer().getServicesManager().register(LuckPermsApi.class, apiProvider, this, ServicePriority.Normal);
+
+        // Run update task to refresh any online users
+        getLog().info("Scheduling Update Task to refresh any online users.");
+        try {
+            new UpdateTask(this).run();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+        getLog().info("Successfully loaded.");
    }

    @Override
    public void onDisable() {
+        getLog().info("Closing datastore...");
        datastore.shutdown();
+
+        getLog().info("Unregistering API...");
+        LuckPerms.unregisterProvider();
+        getServer().getServicesManager().unregisterAll(this);
    }

    @Override
    public void doAsync(Runnable r) {
-        Bukkit.getScheduler().runTaskAsynchronously(this, r);
+        getServer().getScheduler().runTaskAsynchronously(this, r);
    }

    @Override
    public void doSync(Runnable r) {
-        Bukkit.getScheduler().runTask(this, r);
+        getServer().getScheduler().runTask(this, r);
    }

    @Override
    public String getVersion() {
-        return VERSION;
+        return getDescription().getVersion();
    }

    @Override
-    public String getPlayerStatus(UUID uuid) {
-        return getServer().getPlayer(uuid) != null ? "&aOnline" : "&cOffline";
+    public PlatformType getType() {
+        return PlatformType.BUKKIT;
+    }
+
+    @Override
+    public File getMainDir() {
+        return getDataFolder();
+    }
+
+    @Override
+    public Message getPlayerStatus(UUID uuid) {
+        return getServer().getPlayer(getUuidCache().getExternalUUID(uuid)) != null ? Message.PLAYER_ONLINE : Message.PLAYER_OFFLINE;
    }

    @Override
@@ -132,6 +186,53 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
        return getServer().getOnlinePlayers().stream().map(Player::getName).collect(Collectors.toList());
    }

+    @Override
+    public List<Sender> getSenders() {
+        return getServer().getOnlinePlayers().stream().map(p -> BukkitSenderFactory.get().wrap(p)).collect(Collectors.toList());
+    }
+
+    @Override
+    public Sender getConsoleSender() {
+        return BukkitSenderFactory.get().wrap(getServer().getConsoleSender());
+    }
+
+    @Override
+    public List<String> getPossiblePermissions() {
+        final List<String> perms = new ArrayList<>();
+
+        getServer().getPluginManager().getPermissions().forEach(p -> {
+            perms.add(p.getName());
+            p.getChildren().keySet().forEach(perms::add);
+        });
+
+        return perms;
+    }
+
+    @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) {
+        try {
+            return getServer().getOfflinePlayer(playerName).getUniqueId();
+        } catch (Exception e) {
+            return null;
+        }
+    }
+
+    @Override
+    public boolean isPluginLoaded(String name) {
+        return getServer().getPluginManager().isPluginEnabled(name);
+    }
+
    @Override
    public void runUpdateTask() {
        getServer().getScheduler().runTaskAsynchronously(this, new UpdateTask(this));
@@ -0,0 +1,340 @@
+/*
+ * 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.vault;
+
+import lombok.NonNull;
+import lombok.Setter;
+import me.lucko.luckperms.LPBukkitPlugin;
+import me.lucko.luckperms.api.Node;
+import me.lucko.luckperms.core.PermissionHolder;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.groups.Group;
+import me.lucko.luckperms.users.User;
+import net.milkbowl.vault.chat.Chat;
+
+import java.util.Iterator;
+import java.util.Map;
+
+import static me.lucko.luckperms.utils.ArgumentChecker.escapeCharacters;
+import static me.lucko.luckperms.utils.ArgumentChecker.unescapeCharacters;
+
+/**
+ * Provides the Vault Chat service through the use of normal permission nodes.
+ *
+ * Prefixes / Suffixes:
+ * Normal inheritance rules apply.
+ * Permission Nodes = prefix.priority.value OR suffix.priority.value
+ * If a user/group has / inherits multiple prefixes and suffixes, the one with the highest priority is the one that
+ * will apply.
+ *
+ * Meta:
+ * Normal inheritance rules DO NOT apply.
+ * Permission Nodes = meta.node.value
+ *
+ * Node that special characters used within LuckPerms are escaped:
+ * See {@link me.lucko.luckperms.utils.ArgumentChecker#escapeCharacters(String)}
+ *
+ * Registered on normal priority so other plugins can override.
+ */
+public class VaultChatHook extends Chat {
+
+    @Setter
+    private LPBukkitPlugin plugin;
+    private final VaultPermissionHook perms;
+
+    VaultChatHook(VaultPermissionHook perms) {
+        super(perms);
+        this.perms = perms;
+    }
+
+    public String getName() {
+        return perms.getName();
+    }
+
+    public boolean isEnabled() {
+        return perms.isEnabled();
+    }
+
+    private void saveMeta(PermissionHolder holder, String world, String node, String value) {
+        if (holder == null) return;
+        if (node.equals("")) return;
+        node = escapeCharacters(node);
+        value = escapeCharacters(value);
+
+        Iterator<Node> nodes = holder.getNodes().iterator();
+        while (nodes.hasNext()) {
+            Node n = nodes.next();
+            if (n.isMeta() && n.getMeta().getKey().equals(node)) {
+                nodes.remove();
+            }
+        }
+
+        Node.Builder metaNode = new me.lucko.luckperms.utils.Node.Builder("meta." + node + "." + value).setValue(true);
+        if (!perms.getServer().equalsIgnoreCase("global")) {
+            metaNode.setServer(perms.getServer());
+        }
+        if (world != null && !world.equals("")) {
+            metaNode.setServer(perms.getServer()).setWorld(world);
+        }
+
+        try {
+            holder.setPermission(metaNode.build());
+        } catch (ObjectAlreadyHasException ignored) {}
+        
+        perms.objectSave(holder);
+    }
+
+    private String getMeta(PermissionHolder holder, String world, String node, String defaultValue) {
+        if (holder == null) return defaultValue;
+        if (node.equals("")) return defaultValue;
+        node = escapeCharacters(node);
+
+        for (Node n : holder.getPermissions()) {
+            if (!n.getValue()) {
+                continue;
+            }
+
+            if (!n.isMeta()) {
+                continue;
+            }
+
+            if (!perms.getServer().equalsIgnoreCase("global")) {
+                if (!n.shouldApplyOnServer(perms.getServer(), perms.isIncludeGlobal(), false)) {
+                    continue;
+                }
+            }
+
+            if (!n.shouldApplyOnWorld(world, perms.isIncludeGlobal(), false)) {
+                continue;
+            }
+
+            Map.Entry<String, String> meta = n.getMeta();
+            if (meta.getKey().equalsIgnoreCase(node)) {
+                return unescapeCharacters(meta.getValue());
+            }
+        }
+
+        return defaultValue;
+    }
+
+    private void setChatMeta(boolean prefix, PermissionHolder holder, String value, String world) {
+        if (holder == null) return;
+        if (value.equals("")) return;
+
+        Node.Builder node = new me.lucko.luckperms.utils.Node.Builder(prefix ? "prefix" : "suffix" + ".1000." + escapeCharacters(value));
+        node.setValue(true);
+        if (!perms.getServer().equalsIgnoreCase("global")) {
+            node.setServer(perms.getServer());
+        }
+
+        if (world != null && !world.equals("")) {
+            node.setServer(perms.getServer()).setWorld(world);
+        }
+
+        try {
+            holder.setPermission(node.build());
+        } catch (ObjectAlreadyHasException ignored) {}
+
+        perms.objectSave(holder);
+    }
+
+    private String getChatMeta(boolean prefix, PermissionHolder holder, String world) {
+        if (holder == null) return "";
+
+        int priority = Integer.MIN_VALUE;
+        String meta = null;
+
+        for (Node n : holder.getAllNodes(null)) {
+            if (!n.getValue()) {
+                continue;
+            }
+
+            if (!perms.getServer().equalsIgnoreCase("global")) {
+                if (!n.shouldApplyOnServer(perms.getServer(), perms.isIncludeGlobal(), false)) {
+                    continue;
+                }
+            }
+
+            if (!n.shouldApplyOnWorld(world, perms.isIncludeGlobal(), false)) {
+                continue;
+            }
+
+            if (prefix ? !n.isPrefix() : !n.isSuffix()) {
+                continue;
+            }
+
+            Map.Entry<Integer, String> value = prefix ? n.getPrefix() : n.getSuffix();
+            if (value.getKey() > priority) {
+                meta = value.getValue();
+                priority = value.getKey();
+            }
+        }
+
+        return meta == null ? "" : unescapeCharacters(meta);
+    }
+
+    public String getPlayerPrefix(String world, @NonNull String player) {
+        final User user = plugin.getUserManager().get(player);
+        return getChatMeta(true, user, world);
+    }
+
+    public void setPlayerPrefix(String world, @NonNull String player, @NonNull String prefix) {
+        final User user = plugin.getUserManager().get(player);
+        setChatMeta(true, user, prefix, world);
+    }
+
+    public String getPlayerSuffix(String world, @NonNull String player) {
+        final User user = plugin.getUserManager().get(player);
+        return getChatMeta(false, user, world);
+    }
+
+    public void setPlayerSuffix(String world, @NonNull String player, @NonNull String suffix) {
+        final User user = plugin.getUserManager().get(player);
+        setChatMeta(false, user, suffix, world);
+    }
+
+    public String getGroupPrefix(String world, @NonNull String group) {
+        final Group g = plugin.getGroupManager().get(group);
+        return getChatMeta(false, g, world);
+    }
+
+    public void setGroupPrefix(String world, @NonNull String group, @NonNull String prefix) {
+        final Group g = plugin.getGroupManager().get(group);
+        setChatMeta(true, g, prefix, world);
+    }
+
+    public String getGroupSuffix(String world, @NonNull String group) {
+        final Group g = plugin.getGroupManager().get(group);
+        return getChatMeta(false, g, world);
+    }
+
+    public void setGroupSuffix(String world, @NonNull String group, @NonNull String suffix) {
+        final Group g = plugin.getGroupManager().get(group);
+        setChatMeta(false, g, suffix, world);
+    }
+
+    public int getPlayerInfoInteger(String world, @NonNull String player, @NonNull String node, int defaultValue) {
+        final User user = plugin.getUserManager().get(player);
+        try {
+            return Integer.parseInt(getMeta(user, world, node, String.valueOf(defaultValue)));
+        } catch (NumberFormatException e) {
+            return defaultValue;
+        }
+    }
+
+    public void setPlayerInfoInteger(String world, @NonNull String player, @NonNull String node, int value) {
+        final User user = plugin.getUserManager().get(player);
+        saveMeta(user, world, node, String.valueOf(value));
+    }
+
+    public int getGroupInfoInteger(String world, @NonNull String group, @NonNull String node, int defaultValue) {
+        final Group g = plugin.getGroupManager().get(group);
+        try {
+            return Integer.parseInt(getMeta(g, world, node, String.valueOf(defaultValue)));
+        } catch (NumberFormatException e) {
+            return defaultValue;
+        }
+    }
+
+    public void setGroupInfoInteger(String world, @NonNull String group, @NonNull String node, int value) {
+        final Group g = plugin.getGroupManager().get(group);
+        saveMeta(g, world, node, String.valueOf(value));
+    }
+
+    public double getPlayerInfoDouble(String world, @NonNull String player, @NonNull String node, double defaultValue) {
+        final User user = plugin.getUserManager().get(player);
+        try {
+            return Double.parseDouble(getMeta(user, world, node, String.valueOf(defaultValue)));
+        } catch (NumberFormatException e) {
+            return defaultValue;
+        }
+    }
+
+    public void setPlayerInfoDouble(String world, @NonNull String player, @NonNull String node, double value) {
+        final User user = plugin.getUserManager().get(player);
+        saveMeta(user, world, node, String.valueOf(value));
+    }
+
+    public double getGroupInfoDouble(String world, @NonNull String group, @NonNull String node, double defaultValue) {
+        final Group g = plugin.getGroupManager().get(group);
+        try {
+            return Double.parseDouble(getMeta(g, world, node, String.valueOf(defaultValue)));
+        } catch (NumberFormatException e) {
+            return defaultValue;
+        }
+    }
+
+    public void setGroupInfoDouble(String world, @NonNull String group, @NonNull String node, double value) {
+        final Group g = plugin.getGroupManager().get(group);
+        saveMeta(g, world, node, String.valueOf(value));
+    }
+
+    public boolean getPlayerInfoBoolean(String world, @NonNull String player, @NonNull String node, boolean defaultValue) {
+        final User user = plugin.getUserManager().get(player);
+        String s = getMeta(user, world, node, String.valueOf(defaultValue));
+        if (!s.equalsIgnoreCase("true") && !s.equalsIgnoreCase("false")) {
+            return defaultValue;
+        }
+        return Boolean.parseBoolean(s);
+    }
+
+    public void setPlayerInfoBoolean(String world, @NonNull String player, @NonNull String node, boolean value) {
+        final User user = plugin.getUserManager().get(player);
+        saveMeta(user, world, node, String.valueOf(value));
+    }
+
+    public boolean getGroupInfoBoolean(String world, @NonNull String group, @NonNull String node, boolean defaultValue) {
+        final Group g = plugin.getGroupManager().get(group);
+        String s = getMeta(g, world, node, String.valueOf(defaultValue));
+        if (!s.equalsIgnoreCase("true") && !s.equalsIgnoreCase("false")) {
+            return defaultValue;
+        }
+        return Boolean.parseBoolean(s);
+    }
+
+    public void setGroupInfoBoolean(String world, @NonNull String group, @NonNull String node, boolean value) {
+        final Group g = plugin.getGroupManager().get(group);
+        saveMeta(g, world, node, String.valueOf(value));
+    }
+
+    public String getPlayerInfoString(String world, @NonNull String player, @NonNull String node, String defaultValue) {
+        final User user = plugin.getUserManager().get(player);
+        return getMeta(user, world, node, defaultValue);
+    }
+
+    public void setPlayerInfoString(String world, @NonNull String player, @NonNull String node, String value) {
+        final User user = plugin.getUserManager().get(player);
+        saveMeta(user, world, node, value);
+    }
+
+    public String getGroupInfoString(String world, @NonNull String group, @NonNull String node, String defaultValue) {
+        final Group g = plugin.getGroupManager().get(group);
+        return getMeta(g, world, node, defaultValue);
+    }
+
+    public void setGroupInfoString(String world, @NonNull String group, @NonNull String node, String value) {
+        final Group g = plugin.getGroupManager().get(group);
+        saveMeta(g, world, node, value);
+    }
+
+}
@@ -0,0 +1,61 @@
+/*
+ * 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.vault;
+
+import me.lucko.luckperms.LPBukkitPlugin;
+import net.milkbowl.vault.chat.Chat;
+import net.milkbowl.vault.permission.Permission;
+import org.bukkit.plugin.ServicePriority;
+import org.bukkit.plugin.ServicesManager;
+
+public class VaultHook {
+
+    private static VaultChatHook chatHook = null;
+    private static VaultPermissionHook permissionHook = null;
+
+    public static void hook(LPBukkitPlugin plugin) {
+        try {
+            if (permissionHook == null) {
+                permissionHook = new VaultPermissionHook();
+            }
+            permissionHook.setPlugin(plugin);
+            permissionHook.setServer(plugin.getConfiguration().getVaultServer());
+            permissionHook.setIncludeGlobal(plugin.getConfiguration().getVaultIncludeGlobal());
+
+            if (chatHook == null) {
+                chatHook = new VaultChatHook(permissionHook);
+            }
+            chatHook.setPlugin(plugin);
+
+            final ServicesManager sm = plugin.getServer().getServicesManager();
+            sm.unregisterAll(plugin);
+            sm.register(Permission.class, permissionHook, plugin, ServicePriority.High);
+            sm.register(Chat.class, chatHook, plugin, ServicePriority.Low);
+
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+    }
+
+}
@@ -0,0 +1,226 @@
+/*
+ * 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.vault;
+
+import lombok.Getter;
+import lombok.NonNull;
+import lombok.Setter;
+import me.lucko.luckperms.LPBukkitPlugin;
+import me.lucko.luckperms.api.data.Callback;
+import me.lucko.luckperms.core.PermissionHolder;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
+import me.lucko.luckperms.groups.Group;
+import me.lucko.luckperms.users.User;
+import net.milkbowl.vault.permission.Permission;
+
+public class VaultPermissionHook extends Permission {
+
+    @Setter
+    private LPBukkitPlugin plugin;
+
+    @Getter
+    @Setter
+    private String server = "global";
+
+    @Getter
+    @Setter
+    private boolean includeGlobal = true;
+
+    @Override
+    public String getName() {
+        return "LuckPerms";
+    }
+
+    @Override
+    public boolean isEnabled() {
+        return plugin.getDatastore().isAcceptingLogins();
+    }
+
+    @Override
+    public boolean hasSuperPermsCompat() {
+        return true;
+    }
+
+    private boolean objectHas(String world, PermissionHolder object, String permission) {
+        if (object == null) return false;
+
+        if (world != null && !world.equals("")) {
+            return object.hasPermission(permission, true, server, world);
+        } else {
+            return object.hasPermission(permission, true, server);
+        }
+    }
+
+    private boolean objectAdd(String world, PermissionHolder object, String permission) {
+        if (object == null) return false;
+
+        try {
+            if (world != null && !world.equals("")) {
+                object.setPermission(permission, true, server, world);
+            } else {
+                object.setPermission(permission, true, server);
+            }
+        } catch (ObjectAlreadyHasException ignored) {}
+
+        objectSave(object);
+        return true;
+    }
+
+    private boolean objectRemove(String world, PermissionHolder object, String permission) {
+        if (object == null) return false;
+
+        try {
+            if (world != null && !world.equals("")) {
+                object.unsetPermission(permission, server, world);
+            } else {
+                object.unsetPermission(permission, server);
+            }
+        } catch (ObjectLacksException ignored) {}
+
+        objectSave(object);
+        return true;
+    }
+
+    void objectSave(PermissionHolder t) {
+        if (t instanceof User) {
+            ((User) t).refreshPermissions();
+            plugin.getDatastore().saveUser(((User) t), Callback.empty());
+        }
+        if (t instanceof Group) {
+            plugin.getDatastore().saveGroup(((Group) t), c -> plugin.runUpdateTask());
+        }
+    }
+
+    @Override
+    public boolean playerHas(String world, @NonNull String player, @NonNull String permission) {
+        return objectHas(world, plugin.getUserManager().get(player), permission);
+    }
+
+    @Override
+    public boolean playerAdd(String world, @NonNull String player, @NonNull String permission) {
+        final User user = plugin.getUserManager().get(player);
+        return objectAdd(world, user, permission);
+    }
+
+    @Override
+    public boolean playerRemove(String world, @NonNull String player, @NonNull String permission) {
+        final User user = plugin.getUserManager().get(player);
+        return objectRemove(world, user, permission);
+    }
+
+    @Override
+    public boolean groupHas(String world, @NonNull String groupName, @NonNull String permission) {
+        final Group group = plugin.getGroupManager().get(groupName);
+        return objectHas(world, group, permission);
+    }
+
+    @Override
+    public boolean groupAdd(String world, @NonNull String groupName, @NonNull String permission) {
+        final Group group = plugin.getGroupManager().get(groupName);
+        return objectAdd(world, group, permission);
+    }
+
+    @Override
+    public boolean groupRemove(String world, @NonNull String groupName, @NonNull String permission) {
+        final Group group = plugin.getGroupManager().get(groupName);
+        return objectRemove(world, group, permission);
+    }
+
+    @Override
+    public boolean playerInGroup(String world, @NonNull String player, @NonNull String group) {
+        final User user = plugin.getUserManager().get(player);
+        if (user == null) return false;
+
+        final Group group1 = plugin.getGroupManager().get(group);
+        if (group1 == null) return false;
+
+        if (world != null && !world.equals("")) {
+            return user.isInGroup(group1, server, world);
+        } else {
+            return user.isInGroup(group1);
+        }
+    }
+
+    @Override
+    public boolean playerAddGroup(String world, @NonNull String player, @NonNull String groupName) {
+        final User user = plugin.getUserManager().get(player);
+        if (user == null) return false;
+
+        final Group group = plugin.getGroupManager().get(groupName);
+        if (group == null) return false;
+
+        try {
+            if (world != null && !world.equals("")) {
+                user.addGroup(group, server, world);
+            } else {
+                user.addGroup(group);
+            }
+        } catch (ObjectAlreadyHasException ignored) {}
+        objectSave(user);
+        return true;
+    }
+
+    @Override
+    public boolean playerRemoveGroup(String world, @NonNull String player, @NonNull String groupName) {
+        final User user = plugin.getUserManager().get(player);
+        if (user == null) return false;
+
+        final Group group = plugin.getGroupManager().get(groupName);
+        if (group == null) return false;
+
+        try {
+            if (world != null && !world.equals("")) {
+                user.removeGroup(group, server, world);
+            } else {
+                user.removeGroup(group);
+            }
+        } catch (ObjectLacksException ignored) {}
+        objectSave(user);
+        return true;
+    }
+
+    @Override
+    public String[] getPlayerGroups(String world, @NonNull String player) {
+        final User user = plugin.getUserManager().get(player);
+        return (user == null) ? new String[0] :
+                world != null && !world.equals("") ? user.getGroups(server, world, includeGlobal).toArray(new String[0]) :
+                        user.getGroupNames().toArray(new String[0]);
+    }
+
+    @Override
+    public String getPrimaryGroup(String world, @NonNull String player) {
+        final User user = plugin.getUserManager().get(player);
+        return (user == null) ? null : user.getPrimaryGroup();
+    }
+
+    @Override
+    public String[] getGroups() {
+        return plugin.getGroupManager().getAll().keySet().toArray(new String[0]);
+    }
+
+    @Override
+    public boolean hasGroupSupport() {
+        return true;
+    }
+}
@@ -1,72 +0,0 @@
-package me.lucko.luckperms.listeners;
-
-import lombok.AllArgsConstructor;
-import me.lucko.luckperms.LPBukkitPlugin;
-import me.lucko.luckperms.commands.Util;
-import me.lucko.luckperms.constants.Message;
-import me.lucko.luckperms.users.BukkitUser;
-import me.lucko.luckperms.users.User;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
-import org.bukkit.event.player.AsyncPlayerPreLoginEvent;
-import org.bukkit.event.player.PlayerJoinEvent;
-import org.bukkit.event.player.PlayerLoginEvent;
-import org.bukkit.event.player.PlayerQuitEvent;
-
-@AllArgsConstructor
-public class PlayerListener implements Listener {
-    private final LPBukkitPlugin plugin;
-
-    @EventHandler
-    public void onPlayerPreLogin(AsyncPlayerPreLoginEvent e) {
-        if (!plugin.getDatastore().isAcceptingLogins()) {
-            e.disallow(AsyncPlayerPreLoginEvent.Result.KICK_OTHER,
-                    Util.color(Message.PREFIX + "Error whilst validating login with the network. \nPlease contact an administrator."));
-            return;
-        }
-        plugin.getDatastore().loadOrCreateUser(e.getUniqueId(), e.getName());
-    }
-
-    @EventHandler
-    public void onPlayerLogin(PlayerLoginEvent e) {
-        Player player = e.getPlayer();
-        User user = plugin.getUserManager().getUser(player.getUniqueId());
-
-        if (user == null) {
-            e.disallow(PlayerLoginEvent.Result.KICK_OTHER,
-                    Util.color(Message.PREFIX + "User data could not be loaded. Please contact an administrator."));
-            return;
-        }
-
-        if (user instanceof BukkitUser) {
-            BukkitUser u = (BukkitUser) user;
-            u.setAttachment(player.addAttachment(plugin));
-        }
-
-        user.refreshPermissions();
-    }
-
-    @EventHandler
-    public void onPlayerJoin(PlayerJoinEvent e) {
-        // Save UUID data for the player
-        plugin.getDatastore().saveUUIDData(e.getPlayer().getName(), e.getPlayer().getUniqueId(), success -> {});
-
-        User user = plugin.getUserManager().getUser(e.getPlayer().getUniqueId());
-        if (user != null) {
-            // Refresh permissions again
-            user.refreshPermissions();
-        }
-
-    }
-
-    @EventHandler
-    public void onPlayerQuit(PlayerQuitEvent e) {
-        Player player = e.getPlayer();
-
-        // Unload the user from memory when they disconnect
-        User user = plugin.getUserManager().getUser(player.getUniqueId());
-        plugin.getUserManager().unloadUser(user);
-    }
-
-}
@@ -1,22 +1,60 @@
+/*
+ * 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.users;

+import lombok.AllArgsConstructor;
+import lombok.EqualsAndHashCode;
 import lombok.Getter;
 import lombok.Setter;
 import me.lucko.luckperms.LPBukkitPlugin;
-import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
+import me.lucko.luckperms.api.event.events.UserPermissionRefreshEvent;
+import me.lucko.luckperms.api.implementation.internal.UserLink;
 import org.bukkit.permissions.PermissionAttachment;

+import java.lang.reflect.Field;
 import java.util.Map;
 import java.util.UUID;

 public class BukkitUser extends User {
+    private static Field permissionsField = null;
+    public static Field getPermissionsField() {
+        if (permissionsField == null) {
+            try {
+                permissionsField = PermissionAttachment.class.getDeclaredField("permissions");
+                permissionsField.setAccessible(true);
+            } catch (SecurityException | NoSuchFieldException e) {
+                e.printStackTrace();
+            }
+        }
+        return permissionsField;
+    }
+

    private final LPBukkitPlugin plugin;

    @Getter
    @Setter
-    private PermissionAttachment attachment = null;
+    private PermissionAttachmentHolder attachment = null;

    BukkitUser(UUID uuid, LPBukkitPlugin plugin) {
        super(uuid, plugin);
@@ -28,23 +66,63 @@ public class BukkitUser extends User {
        this.plugin = plugin;
    }

+    @SuppressWarnings("unchecked")
    @Override
    public void refreshPermissions() {
-        plugin.doSync(() -> {
-            Player player = Bukkit.getPlayer(getUuid());
-            if (player == null) return;
+        if (attachment == null) {
+            return;
+        }

-            if (attachment == null) {
-                getPlugin().getLogger().warning("User " + getName() + " does not have a permissions attachment defined.");
-                setAttachment(player.addAttachment(plugin));
+        // Calculate the permissions that should be applied. This is done async, who cares about how long it takes or how often it's done.
+        Map<String, Boolean> toApply = exportNodes(
+                getPlugin().getConfiguration().getServer(),
+                plugin.getUserManager().getWorldCache().get(getUuid()),
+                null,
+                plugin.getConfiguration().getIncludeGlobalPerms(),
+                true,
+                plugin.getPossiblePermissions()
+        );
+
+        try {
+            // The map in the LP PermissionAttachment is a ConcurrentHashMap. We can modify and iterate over its contents async.
+            Map<String, Boolean> existing = attachment.getPermissions();
+
+            boolean different = false;
+            if (toApply.size() != existing.size()) {
+                different = true;
+            } else {
+                for (Map.Entry<String, Boolean> e : existing.entrySet()) {
+                    if (toApply.containsKey(e.getKey()) && toApply.get(e.getKey()) == e.getValue()) {
+                        continue;
+                    }
+                    different = true;
+                    break;
+                }
            }

-            // Clear existing permissions
-            attachment.getPermissions().keySet().forEach(p -> attachment.setPermission(p, false));
+            if (!different) return;

-            // Re-add all defined permissions for the user
-            Map<String, Boolean> local = getLocalPermissions(getPlugin().getConfiguration().getServer(), null);
-            local.entrySet().forEach(e -> attachment.setPermission(e.getKey(), e.getValue()));
-        });
+            existing.clear();
+            existing.putAll(toApply);
+
+            /* Must be called sync, as #recalculatePermissions is an unmodified Bukkit API call that is absolutely not thread safe.
+               Shouldn't be too taxing on the server. This only gets called when permissions have actually changed,
+               which is like once per user per login, assuming their permissions don't get modified. */
+            plugin.doSync(() -> {
+                attachment.getAttachment().getPermissible().recalculatePermissions();
+                plugin.getApiProvider().fireEventAsync(new UserPermissionRefreshEvent(new UserLink(this)));
+            });
+
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Getter
+    @EqualsAndHashCode
+    @AllArgsConstructor
+    public static class PermissionAttachmentHolder {
+        private final PermissionAttachment attachment;
+        private final Map<String, Boolean> permissions;
    }
 }
@@ -1,59 +1,89 @@
+/*
+ * 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.users;

+import lombok.Getter;
 import me.lucko.luckperms.LPBukkitPlugin;
-import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;

+import java.util.Map;
+import java.util.Set;
 import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Collectors;

 public class BukkitUserManager extends UserManager {
    private final LPBukkitPlugin plugin;

+    @Getter
+    private final Map<UUID, String> worldCache = new ConcurrentHashMap<>();
+
    public BukkitUserManager(LPBukkitPlugin plugin) {
        super(plugin);
        this.plugin = plugin;
    }

    @Override
-    public void unloadUser(User user) {
-        if (user != null) {
+    public void preUnload(User user) {
+        if (user instanceof BukkitUser) {
+            BukkitUser u = (BukkitUser) user;

-            if (user instanceof BukkitUser) {
-                BukkitUser u = (BukkitUser) user;
+            if (u.getAttachment() != null) {
+                Player player = plugin.getServer().getPlayer(plugin.getUuidCache().getExternalUUID(u.getUuid()));

-                if (u.getAttachment() != null) {
-                    Player player = Bukkit.getPlayer(u.getUuid());
-
-                    if (player != null) {
-                        player.removeAttachment(u.getAttachment());
-                    }
-                    u.setAttachment(null);
+                if (player != null) {
+                    player.removeAttachment(u.getAttachment().getAttachment());
                }
+                u.setAttachment(null);
            }
-
-            getUsers().remove(user.getUuid());
        }
    }

    @Override
-    public void cleanupUser(User user) {
-        if (Bukkit.getPlayer(user.getUuid()) == null) {
-            unloadUser(user);
+    public void cleanup(User user) {
+        if (plugin.getServer().getPlayer(plugin.getUuidCache().getExternalUUID(user.getUuid())) == null) {
+            unload(user);
        }
    }

    @Override
-    public User makeUser(UUID uuid) {
+    public User make(UUID uuid) {
        return new BukkitUser(uuid, plugin);
    }

    @Override
-    public User makeUser(UUID uuid, String username) {
+    public User make(UUID uuid, String username) {
        return new BukkitUser(uuid, username, plugin);
    }

    @Override
    public void updateAllUsers() {
-        plugin.getServer().getOnlinePlayers().stream().map(Player::getUniqueId).forEach(u -> plugin.getDatastore().loadUser(u));
+        // Sometimes called async, so we need to get the players on the Bukkit thread.
+        plugin.doSync(() -> {
+            Set<UUID> players = plugin.getServer().getOnlinePlayers().stream()
+                    .map(p -> plugin.getUuidCache().getUUID(p.getUniqueId()))
+                    .collect(Collectors.toSet());
+            plugin.doAsync(() -> players.forEach(u -> plugin.getDatastore().loadUser(u, "null")));
+        });
    }
 }
@@ -1,127 +0,0 @@
-package me.lucko.luckperms.vaulthooks;
-
-import net.milkbowl.vault.chat.Chat;
-import net.milkbowl.vault.permission.Permission;
-
-/**
- * Dummy class for hooking with Vault plugins that need both Chat + Perms
- * This doesn't return anything useful, or change anything internally
- *
- * Registered on the lowest priority so other plugins can override
- */
-class VaultChatHook extends Chat {
-
-    VaultChatHook(Permission perms) {
-        super(perms);
-    }
-
-    private void throwNotSupported() {
-        // throw new UnsupportedOperationException("LuckPerms cannot perform this operation.");
-    }
-
-    public String getName() {
-        return "LuckPerms";
-    }
-
-
-    public boolean isEnabled() {
-        return true;
-    }
-
-    public String getPlayerPrefix(String world, String player) {
-        return "";
-    }
-
-    public void setPlayerPrefix(String world, String player, String prefix) {
-        throwNotSupported();
-    }
-
-    public String getPlayerSuffix(String world, String player) {
-        return "";
-    }
-
-    public void setPlayerSuffix(String world, String player, String suffix) {
-        throwNotSupported();
-    }
-
-    public String getGroupPrefix(String world, String group) {
-        return "";
-    }
-
-    public void setGroupPrefix(String world, String group, String prefix) {
-        throwNotSupported();
-    }
-
-    public String getGroupSuffix(String world, String group) {
-        return "";
-    }
-
-    public void setGroupSuffix(String world, String group, String suffix) {
-        throwNotSupported();
-    }
-
-    public int getPlayerInfoInteger(String world, String player, String node, int defaultValue) {
-        return defaultValue;
-    }
-
-    public void setPlayerInfoInteger(String world, String player, String node, int value) {
-        throwNotSupported();
-    }
-
-    public int getGroupInfoInteger(String world, String group, String node, int defaultValue) {
-        return defaultValue;
-    }
-
-    public void setGroupInfoInteger(String world, String group, String node, int value) {
-        throwNotSupported();
-    }
-
-    public double getPlayerInfoDouble(String world, String player, String node, double defaultValue) {
-        return defaultValue;
-    }
-
-    public void setPlayerInfoDouble(String world, String player, String node, double value) {
-        throwNotSupported();
-    }
-
-    public double getGroupInfoDouble(String world, String group, String node, double defaultValue) {
-        return defaultValue;
-    }
-
-    public void setGroupInfoDouble(String world, String group, String node, double value) {
-        throwNotSupported();
-    }
-
-    public boolean getPlayerInfoBoolean(String world, String player, String node, boolean defaultValue) {
-        return defaultValue;
-    }
-
-    public void setPlayerInfoBoolean(String world, String player, String node, boolean value) {
-        throwNotSupported();
-    }
-
-    public boolean getGroupInfoBoolean(String world, String group, String node, boolean defaultValue) {
-        return defaultValue;
-    }
-
-    public void setGroupInfoBoolean(String world, String group, String node, boolean value) {
-        throwNotSupported();
-    }
-
-    public String getPlayerInfoString(String world, String player, String node, String defaultValue) {
-        return defaultValue;
-    }
-
-    public void setPlayerInfoString(String world, String player, String node, String value) {
-        throwNotSupported();
-    }
-
-    public String getGroupInfoString(String world, String group, String node, String defaultValue) {
-        return defaultValue;
-    }
-
-    public void setGroupInfoString(String world, String group, String node, String value) {
-        throwNotSupported();
-    }
-
-}
@@ -1,36 +0,0 @@
-package me.lucko.luckperms.vaulthooks;
-
-import me.lucko.luckperms.LPBukkitPlugin;
-import net.milkbowl.vault.chat.Chat;
-import net.milkbowl.vault.permission.Permission;
-import org.bukkit.plugin.ServicePriority;
-import org.bukkit.plugin.ServicesManager;
-
-public class VaultHook {
-
-    private static VaultChatHook chatHook = null;
-    private static VaultPermissionHook permissionHook = null;
-
-    public static void hook(LPBukkitPlugin plugin) {
-        try {
-            if (permissionHook == null) {
-                permissionHook = new VaultPermissionHook();
-            }
-            permissionHook.setPlugin(plugin);
-
-            if (chatHook == null) {
-                chatHook = new VaultChatHook(permissionHook);
-            }
-
-            final ServicesManager sm = plugin.getServer().getServicesManager();
-            sm.unregisterAll(plugin);
-            sm.register(Permission.class, permissionHook, plugin, ServicePriority.High);
-            sm.register(Chat.class, chatHook, plugin, ServicePriority.Lowest);
-
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-
-    }
-
-}
@@ -1,152 +0,0 @@
-package me.lucko.luckperms.vaulthooks;
-
-import lombok.Setter;
-import me.lucko.luckperms.LPBukkitPlugin;
-import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
-import me.lucko.luckperms.exceptions.ObjectLacksException;
-import me.lucko.luckperms.groups.Group;
-import me.lucko.luckperms.users.User;
-import net.milkbowl.vault.permission.Permission;
-
-class VaultPermissionHook extends Permission {
-
-    @Setter
-    private LPBukkitPlugin plugin;
-
-    @Override
-    public String getName() {
-        return "LuckPerms";
-    }
-
-    @Override
-    public boolean isEnabled() {
-        return plugin.getDatastore().isAcceptingLogins();
-    }
-
-    @Override
-    public boolean hasSuperPermsCompat() {
-        // Idk???
-        return true;
-    }
-
-    @Override
-    public boolean playerHas(String world, String player, String permission) {
-        final User user = plugin.getUserManager().getUser(player);
-        return user != null && user.hasPermission(permission, true);
-    }
-
-    @Override
-    public boolean playerAdd(String world, String player, String permission) {
-        final User user = plugin.getUserManager().getUser(player);
-        if (user == null) return false;
-
-        try {
-            user.setPermission(permission, true);
-        } catch (ObjectAlreadyHasException ignored) {}
-        plugin.getUserManager().saveUser(user, plugin.getDatastore());
-        return true;
-    }
-
-    @Override
-    public boolean playerRemove(String world, String player, String permission) {
-        final User user = plugin.getUserManager().getUser(player);
-        if (user == null) return false;
-
-        try {
-            user.unsetPermission(permission);
-        } catch (ObjectLacksException ignored) {}
-        plugin.getUserManager().saveUser(user, plugin.getDatastore());
-        return true;
-    }
-
-    @Override
-    public boolean groupHas(String world, String groupName, String permission) {
-        final Group group = plugin.getGroupManager().getGroup(groupName);
-        return group != null && group.hasPermission(permission, true);
-    }
-
-    @Override
-    public boolean groupAdd(String world, String groupName, String permission) {
-        final Group group = plugin.getGroupManager().getGroup(groupName);
-        if (group == null) return false;
-
-        try {
-            group.setPermission(permission, true);
-        } catch (ObjectAlreadyHasException ignored) {}
-        plugin.runUpdateTask();
-        return true;
-    }
-
-    @Override
-    public boolean groupRemove(String world, String groupName, String permission) {
-        final Group group = plugin.getGroupManager().getGroup(groupName);
-        if (group == null) return false;
-
-        try {
-            group.unsetPermission(permission);
-        } catch (ObjectLacksException ignored) {}
-        plugin.runUpdateTask();
-        return true;
-    }
-
-    @Override
-    public boolean playerInGroup(String world, String player, String group) {
-        final User user = plugin.getUserManager().getUser(player);
-        if (user == null) return false;
-
-        final Group group1 = plugin.getGroupManager().getGroup(group);
-        return group1 != null && user.isInGroup(group1);
-    }
-
-    @Override
-    public boolean playerAddGroup(String world, String player, String groupName) {
-        final User user = plugin.getUserManager().getUser(player);
-        if (user == null) return false;
-
-        final Group group = plugin.getGroupManager().getGroup(groupName);
-        if (group == null) return false;
-
-        try {
-            user.addGroup(group);
-        } catch (ObjectAlreadyHasException ignored) {}
-        plugin.getUserManager().saveUser(user, plugin.getDatastore());
-        return true;
-    }
-
-    @Override
-    public boolean playerRemoveGroup(String world, String player, String groupName) {
-        final User user = plugin.getUserManager().getUser(player);
-        if (user == null) return false;
-
-        final Group group = plugin.getGroupManager().getGroup(groupName);
-        if (group == null) return false;
-
-        try {
-            user.removeGroup(group);
-        } catch (ObjectLacksException ignored) {}
-        plugin.getUserManager().saveUser(user, plugin.getDatastore());
-        return true;
-    }
-
-    @Override
-    public String[] getPlayerGroups(String world, String player) {
-        final User user = plugin.getUserManager().getUser(player);
-        return (user == null) ? new String[0] : user.getGroupNames().toArray(new String[0]);
-    }
-
-    @Override
-    public String getPrimaryGroup(String world, String player) {
-        final User user = plugin.getUserManager().getUser(player);
-        return (user == null) ? null : user.getPrimaryGroup();
-    }
-
-    @Override
-    public String[] getGroups() {
-        return plugin.getGroupManager().getGroups().keySet().toArray(new String[0]);
-    }
-
-    @Override
-    public boolean hasGroupSupport() {
-        return true;
-    }
-}
@@ -1,22 +1,81 @@
-# LuckPerms Configuration
+##############################################################################
+# +------------------------------------------------------------------------+ #
+# |                       LuckPerms Configuration                          | #
+# |                  https://github.com/lucko/LuckPerms                    | #
+# +------------------------------------------------------------------------+ #
+##############################################################################

 # The name of the server, used for server specific permissions. Set to 'global' to disable.
 server: global

-# The default group assigned to all users on their first join.
-default-group: default
-
 # If users on this server should have their global permissions/groups applied.
 include-global: true

-# Which storage method the plugin should use.
-# Currently supported: mysql, sqlite, flatfile
-# Fill out connection info below if you're using MySQL
-storage-method: sqlite
+# If this server is in offline or online mode.
+# This setting allows a player to have the same UUID across a network of offline mode/mixed servers.

-sql:
+# You should generally reflect the setting in server.properties here. Except when...
+
+# 1. You have Spigot servers connected to a BungeeCord proxy, with online-mode set to false, but 'bungeecord' set to true in the spigot.yml
+#    AND 'ip-forward' set to true in the BungeeCord config.yml
+#    In this case, set online-mode in LuckPerms to true, despite the server being in offline mode.
+
+# 2. You are only running one server instance using LuckPerms, (not a network)
+#    In this case, set online-mode to true no matter what is set in server.properties. (we can just fallback to the servers uuid cache)
+
+# 3. If your proxy is running in offline mode, and you are using PaperSpigot (https://ci.destroystokyo.com/job/PaperSpigot/),
+#    you should set "bungee-online-mode" to false in the paper.yml, and set "online-mode" to true in all LuckPerms configs.
+#    This approach is thoroughly recommended for offline mode networks.
+online-mode: true
+
+# If the plugin should apply wildcard permissions.
+# If set to true, LuckPerms will detect wildcard permissions, and resolve & apply all registered permissions matching
+# the wildcard. This will only work for plugins that define all of their permissions to the server.
+apply-wildcards: true
+
+# If the plugin should parse regex permissions.
+# If set to true, LuckPerms will detect regex permissions, marked with "r=" at the start of the node, and resolve &
+# apply all registered permissions matching the regex. This will only work for plugins that define all of their
+# permissions to the server.
+apply-regex: true
+
+# If the plugin should complete and apply shorthand permissions.
+# If set to true, LuckPerms will detect and expand shorthand node patterns.
+apply-shorthand: true
+
+# If the plugin should send log notifications to users whenever permissions are modified.
+log-notify: true
+
+# The name of the server used within Vault operations. If you don't want Vault operations to be server specific, set this
+# to "global".
+vault-server: global
+
+# If global permissions should be considered when retrieving meta or player groups
+vault-include-global: true
+
+# Which storage method the plugin should use.
+# Currently supported: mysql, sqlite, h2, json, yaml, mongodb
+# Fill out connection info below if you're using MySQL or MongoDB
+storage-method: h2
+
+# This block enables support for split datastores.
+# Only touch this if you're sure that you know what you're doing.
+# I (the author) do not endorse nor recommend the use of this feature.
+split-storage:
+  enabled: false
+  methods:
+    user: h2
+    group: h2
+    track: h2
+    uuid: h2
+    log: h2
+
+data:
  address: localhost:3306
  database: minecraft
  username: root
  password: ''
+
+  # Set to -1 to disable. If this is the only instance accessing the datastore, you can disable syncing.
+  # e.g. if you're using sqlite or flatfile, this can be set to -1 to save resources.
  sync-minutes: 3
@@ -1,10 +1,170 @@
 name: LuckPerms
-author: Luck
-version: 1.2
-main: me.lucko.luckperms.LPBukkitPlugin
-softdepend: [Vault]
+version: ${release.version}.${git.closest.tag.commit.count}
 description: A permissions plugin
+author: Luck
+website: https://github.com/lucko/LuckPerms
+
+main: me.lucko.luckperms.LPBukkitPlugin
+softdepend: [Vault, PermissionsEx, GroupManager, PowerfulPerms, zPermissions, bPermissions] # For migration
+
 commands:
  luckperms:
    description: Manage permissions
-    aliases: [perms, permissions, lp, p, perm]
+    aliases: [perms, permissions, lp, p, perm]
+
+permissions:
+  luckperms.*:
+    description: Gives access to all LuckPerms commands
+    children:
+      luckperms.sync: true
+      luckperms.info: true
+      luckperms.debug: true
+      luckperms.import: true
+      luckperms.creategroup: true
+      luckperms.deletegroup: true
+      luckperms.listgroups: true
+      luckperms.createtrack: true
+      luckperms.deletetrack: true
+      luckperms.listtracks: true
+      luckperms.user.info: true
+      luckperms.user.getuuid: true
+      luckperms.user.listnodes: true
+      luckperms.user.haspermission: true
+      luckperms.user.inheritspermission: true
+      luckperms.user.setpermission: true
+      luckperms.user.unsetpermission: true
+      luckperms.user.addgroup: true
+      luckperms.user.removegroup: true
+      luckperms.user.settemppermission: true
+      luckperms.user.unsettemppermission: true
+      luckperms.user.addtempgroup: true
+      luckperms.user.removetempgroup: true
+      luckperms.user.setprimarygroup: true
+      luckperms.user.showtracks: true
+      luckperms.user.promote: true
+      luckperms.user.demote: true
+      luckperms.user.showpos: true
+      luckperms.user.chatmeta: true
+      luckperms.user.addprefix: true
+      luckperms.user.addsuffix: true
+      luckperms.user.removeprefix: true
+      luckperms.user.removesuffix: true
+      luckperms.user.addtempprefix: true
+      luckperms.user.addtempsuffix: true
+      luckperms.user.removetempprefix: true
+      luckperms.user.removetempsuffix: true
+      luckperms.user.clear: true
+      luckperms.group.info: true
+      luckperms.group.listnodes: true
+      luckperms.group.haspermission: true
+      luckperms.group.inheritspermission: true
+      luckperms.group.setpermission: true
+      luckperms.group.unsetpermission: true
+      luckperms.group.setinherit: true
+      luckperms.group.unsetinherit: true
+      luckperms.group.settemppermission: true
+      luckperms.group.unsettemppermission: true
+      luckperms.group.settempinherit: true
+      luckperms.group.unsettempinherit: true
+      luckperms.group.showtracks: true
+      luckperms.group.chatmeta: true
+      luckperms.group.addprefix: true
+      luckperms.group.addsuffix: true
+      luckperms.group.removeprefix: true
+      luckperms.group.removesuffix: true
+      luckperms.group.addtempprefix: true
+      luckperms.group.addtempsuffix: true
+      luckperms.group.removetempprefix: true
+      luckperms.group.removetempsuffix: true
+      luckperms.group.clear: true
+      luckperms.group.rename: true
+      luckperms.track.info: true
+      luckperms.track.append: true
+      luckperms.track.insert: true
+      luckperms.track.remove: true
+      luckperms.track.clear: true
+      luckperms.track.rename: true
+      luckperms.log.export: true
+      luckperms.log.userhistory: true
+      luckperms.log.grouphistory: true
+      luckperms.log.trackhistory: true
+      luckperms.log.notify: true
+      luckperms.log.recent: true
+      luckperms.log.search: true
+  luckperms.user.*:
+    description: Gives access to all LuckPerms user commands
+    children:
+      luckperms.user.info: true
+      luckperms.user.getuuid: true
+      luckperms.user.listnodes: true
+      luckperms.user.haspermission: true
+      luckperms.user.inheritspermission: true
+      luckperms.user.setpermission: true
+      luckperms.user.unsetpermission: true
+      luckperms.user.addgroup: true
+      luckperms.user.removegroup: true
+      luckperms.user.settemppermission: true
+      luckperms.user.unsettemppermission: true
+      luckperms.user.addtempgroup: true
+      luckperms.user.removetempgroup: true
+      luckperms.user.setprimarygroup: true
+      luckperms.user.showtracks: true
+      luckperms.user.promote: true
+      luckperms.user.demote: true
+      luckperms.user.showpos: true
+      luckperms.user.chatmeta: true
+      luckperms.user.addprefix: true
+      luckperms.user.addsuffix: true
+      luckperms.user.removeprefix: true
+      luckperms.user.removesuffix: true
+      luckperms.user.addtempprefix: true
+      luckperms.user.addtempsuffix: true
+      luckperms.user.removetempprefix: true
+      luckperms.user.removetempsuffix: true
+      luckperms.user.clear: true
+  luckperms.group.*:
+    description: Gives access to all LuckPerms group commands
+    children:
+      luckperms.group.info: true
+      luckperms.group.listnodes: true
+      luckperms.group.haspermission: true
+      luckperms.group.inheritspermission: true
+      luckperms.group.setpermission: true
+      luckperms.group.unsetpermission: true
+      luckperms.group.setinherit: true
+      luckperms.group.unsetinherit: true
+      luckperms.group.settemppermission: true
+      luckperms.group.unsettemppermission: true
+      luckperms.group.settempinherit: true
+      luckperms.group.unsettempinherit: true
+      luckperms.group.showtracks: true
+      luckperms.group.chatmeta: true
+      luckperms.group.addprefix: true
+      luckperms.group.addsuffix: true
+      luckperms.group.removeprefix: true
+      luckperms.group.removesuffix: true
+      luckperms.group.addtempprefix: true
+      luckperms.group.addtempsuffix: true
+      luckperms.group.removetempprefix: true
+      luckperms.group.removetempsuffix: true
+      luckperms.group.clear: true
+      luckperms.group.rename: true
+  luckperms.track.*:
+    description: Gives access to all LuckPerms track commands
+    children:
+      luckperms.track.info: true
+      luckperms.track.append: true
+      luckperms.track.insert: true
+      luckperms.track.remove: true
+      luckperms.track.clear: true
+      luckperms.track.rename: true
+  luckperms.log.*:
+    description: Gives access to all LuckPerms log commands
+    children:
+      luckperms.log.export: true
+      luckperms.log.userhistory: true
+      luckperms.log.grouphistory: true
+      luckperms.log.trackhistory: true
+      luckperms.log.notify: true
+      luckperms.log.recent: true
+      luckperms.log.search: true
@@ -4,19 +4,17 @@
         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</groupId>
-        <version>1.2</version>
+        <groupId>me.lucko.luckperms</groupId>
+        <version>2.7-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>luckperms-bungee</artifactId>
-    <version>$(project.parent.version)</version>
    <packaging>jar</packaging>
-    <name>LuckPerms</name>

    <build>
        <defaultGoal>clean package</defaultGoal>
-        <finalName>LuckPerms</finalName>
+        <finalName>LuckPermsBungee-${release.version}.${git.closest.tag.commit.count}</finalName>
        <sourceDirectory>${basedir}/src/main/java</sourceDirectory>
        <resources>
            <resource>
@@ -45,11 +43,52 @@
                            <goal>shade</goal>
                        </goals>
                        <configuration>
-                            <minimizeJar>true</minimizeJar>
+                            <minimizeJar>false</minimizeJar>
+                            <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>org.sqlite</pattern>
+                                    <shadedPattern>me.lucko.luckperms.lib.sqlite</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>

@@ -63,11 +102,25 @@
        </dependency>
        <!-- LuckPerms Common -->
        <dependency>
-            <groupId>me.lucko</groupId>
+            <groupId>me.lucko.luckperms</groupId>
            <artifactId>luckperms-common</artifactId>
-            <version>${project.parent.version}</version>
+            <version>${project.version}</version>
            <scope>compile</scope>
        </dependency>
+        <!-- LuckPerms API -->
+        <dependency>
+            <groupId>me.lucko.luckperms</groupId>
+            <artifactId>luckperms-api</artifactId>
+            <version>${project.version}</version>
+            <scope>compile</scope>
+        </dependency>
+        <!-- Lombok -->
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>1.16.10</version>
+            <scope>provided</scope>
+        </dependency>
    </dependencies>

-</project>
+</project>
@@ -0,0 +1,50 @@
+/*
+ * 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;
+
+import me.lucko.luckperms.api.data.Callback;
+import me.lucko.luckperms.commands.CommandManager;
+import net.md_5.bungee.api.CommandSender;
+import net.md_5.bungee.api.plugin.Command;
+import net.md_5.bungee.api.plugin.TabExecutor;
+
+import java.util.Arrays;
+
+class BungeeCommand extends Command implements TabExecutor {
+    private final CommandManager manager;
+
+    BungeeCommand(CommandManager manager) {
+        super("luckpermsbungee", null, "bperms", "lpb", "bpermissions", "bp", "bperm");
+        this.manager = manager;
+    }
+
+    @Override
+    public void execute(CommandSender sender, String[] args) {
+        manager.onCommand(BungeeSenderFactory.get().wrap(sender), "bperms", Arrays.asList(args), Callback.empty());
+    }
+
+    @Override
+    public Iterable<String> onTabComplete(CommandSender sender, String[] args) {
+        return manager.onTabComplete(BungeeSenderFactory.get().wrap(sender), Arrays.asList(args));
+    }
+}
@@ -1,6 +1,28 @@
+/*
+ * 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;

-import me.lucko.luckperms.utils.LPConfiguration;
+import me.lucko.luckperms.core.LPConfiguration;
 import net.md_5.bungee.config.Configuration;
 import net.md_5.bungee.config.ConfigurationProvider;
 import net.md_5.bungee.config.YamlConfiguration;
@@ -10,30 +32,20 @@ import java.io.IOException;
 import java.io.InputStream;
 import java.nio.file.Files;

-public class BungeeConfig implements LPConfiguration {
-    private final LPBungeePlugin plugin;
+class BungeeConfig extends LPConfiguration<LPBungeePlugin> {
    private Configuration configuration;

-    public BungeeConfig(LPBungeePlugin plugin) {
-        this.plugin = plugin;
-        reload();
-    }
-
-    private void reload() {
-        try {
-            configuration = ConfigurationProvider.getProvider(YamlConfiguration.class).load(makeFile("config.yml"));
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
+    BungeeConfig(LPBungeePlugin plugin) {
+        super(plugin, "bungee", false, "flatfile");
    }

    @SuppressWarnings("ResultOfMethodCallIgnored")
    private File makeFile(String file) throws IOException {
-        File cfg = new File(plugin.getDataFolder(), file);
+        File cfg = new File(getPlugin().getDataFolder(), file);

        if (!cfg.exists()) {
-            plugin.getDataFolder().mkdir();
-            try (InputStream is = plugin.getResourceAsStream(file)) {
+            getPlugin().getDataFolder().mkdir();
+            try (InputStream is = getPlugin().getResourceAsStream(file)) {
                Files.copy(is, cfg.toPath());
            }
        }
@@ -42,37 +54,31 @@ public class BungeeConfig implements LPConfiguration {
    }

    @Override
-    public String getServer() {
-        return configuration.getString("server", "bungee");
+    protected void init() {
+        try {
+            configuration = ConfigurationProvider.getProvider(YamlConfiguration.class).load(makeFile("config.yml"));
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
    }

    @Override
-    public int getSyncTime() {
-        return configuration.getInt("sql.sync-minutes", 3);
+    protected void set(String path, Object value) {
+        configuration.set(path, value);
    }

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

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

    @Override
-    public boolean getIncludeGlobalPerms() {
-        return configuration.getBoolean("include-global", false);
-    }
-
-    @Override
-    public String getDatabaseValue(String value) {
-        return configuration.getString("sql." + value);
-    }
-
-    @Override
-    public String getStorageMethod() {
-        return configuration.getString("storage-method", "sqlite");
+    protected boolean getBoolean(String path, boolean def) {
+        return configuration.getBoolean(path, def);
    }
 }
@@ -0,0 +1,129 @@
+/*
+ * 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;
+
+import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.core.UuidCache;
+import me.lucko.luckperms.users.User;
+import me.lucko.luckperms.utils.AbstractListener;
+import net.md_5.bungee.api.chat.TextComponent;
+import net.md_5.bungee.api.connection.PendingConnection;
+import net.md_5.bungee.api.connection.ProxiedPlayer;
+import net.md_5.bungee.api.event.*;
+import net.md_5.bungee.api.plugin.Listener;
+import net.md_5.bungee.event.EventHandler;
+
+import java.util.Collections;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.TimeUnit;
+
+@SuppressWarnings("WeakerAccess")
+public class BungeeListener extends AbstractListener implements Listener {
+    private static final TextComponent WARN_MESSAGE = new TextComponent(Message.LOADING_ERROR.toString());
+    private final LPBungeePlugin plugin;
+
+    BungeeListener(LPBungeePlugin plugin) {
+        super(plugin);
+        this.plugin = plugin;
+    }
+
+    @EventHandler
+    public void onPlayerPermissionCheck(PermissionCheckEvent e) {
+        if (!(e.getSender() instanceof ProxiedPlayer)) {
+            return;
+        }
+
+        final ProxiedPlayer player = ((ProxiedPlayer) e.getSender());
+        final User user = plugin.getUserManager().get(plugin.getUuidCache().getUUID(player.getUniqueId()));
+        if (user == null) return;
+
+
+        final String server = player.getServer() == null ? null : (player.getServer().getInfo() == null ? null : player.getServer().getInfo().getName());
+        Map<String, Boolean> local = user.getLocalPermissions(plugin.getConfiguration().getServer(), server, null, Collections.singletonList(e.getPermission()));
+        for (Map.Entry<String, Boolean> en : local.entrySet()) {
+            if (en.getKey().equalsIgnoreCase(e.getPermission())) {
+                e.setHasPermission(en.getValue());
+                return;
+            }
+        }
+    }
+
+    @EventHandler
+    public void onPlayerLogin(LoginEvent e) {
+        /* Delay the login here, as we want to cache UUID data before the player is connected to a backend bukkit server.
+           This means that a player will have the same UUID across the network, even if parts of the network are running in
+           Offline mode. */
+        e.registerIntent(plugin);
+        plugin.doAsync(() -> {
+            final long startTime = System.currentTimeMillis();
+            final UuidCache cache = plugin.getUuidCache();
+            final PendingConnection c = e.getConnection();
+
+            if (!cache.isOnlineMode()) {
+                UUID uuid = plugin.getDatastore().getUUID(c.getName());
+                if (uuid != null) {
+                    cache.addToCache(c.getUniqueId(), uuid);
+                } else {
+                    // No previous data for this player
+                    cache.addToCache(c.getUniqueId(), c.getUniqueId());
+                    plugin.getDatastore().saveUUIDData(c.getName(), c.getUniqueId());
+                }
+            } else {
+                // Online mode, no cache needed. This is just for name -> uuid lookup.
+                plugin.getDatastore().saveUUIDData(c.getName(), c.getUniqueId());
+            }
+
+            // We have to make a new user on this thread whilst the connection is being held, or we get concurrency issues as the Bukkit server
+            // and the BungeeCord server try to make a new user at the same time.
+            plugin.getDatastore().loadUser(cache.getUUID(c.getUniqueId()), c.getName());
+            final long time = System.currentTimeMillis() - startTime;
+            if (time >= 1000) {
+                plugin.getLog().warn("Processing login for " + c.getName() + " took " + time + "ms.");
+            }
+            e.completeIntent(plugin);
+        });
+    }
+
+    @EventHandler
+    public void onPlayerPostLogin(PostLoginEvent e) {
+        final ProxiedPlayer player = e.getPlayer();
+        final User user = plugin.getUserManager().get(plugin.getUuidCache().getUUID(e.getPlayer().getUniqueId()));
+
+        if (user == null) {
+            plugin.getProxy().getScheduler().schedule(plugin, () -> player.sendMessage(WARN_MESSAGE), 3, TimeUnit.SECONDS);
+        } else {
+            user.refreshPermissions();
+        }
+    }
+
+    @EventHandler
+    public void onPlayerQuit(PlayerDisconnectEvent e) {
+        onLeave(e.getPlayer().getUniqueId());
+    }
+
+    @EventHandler
+    public void onPlayerServerSwitch(ServerSwitchEvent e) {
+        refreshPlayer(e.getPlayer().getUniqueId());
+    }
+}
@@ -0,0 +1,70 @@
+/*
+ * 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;
+
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+import me.lucko.luckperms.commands.SenderFactory;
+import me.lucko.luckperms.constants.Constants;
+import net.md_5.bungee.api.CommandSender;
+import net.md_5.bungee.api.chat.TextComponent;
+import net.md_5.bungee.api.connection.ProxiedPlayer;
+
+import java.util.UUID;
+
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+public class BungeeSenderFactory extends SenderFactory<CommandSender> {
+    private static BungeeSenderFactory instance = null;
+    public static BungeeSenderFactory get() {
+        if (instance == null){
+            instance = new BungeeSenderFactory();
+        }
+        return instance;
+    }
+
+    @Override
+    protected String getName(CommandSender sender) {
+        if (sender instanceof ProxiedPlayer) {
+            return sender.getName();
+        }
+        return Constants.getConsoleName();
+    }
+
+    @Override
+    protected UUID getUuid(CommandSender sender) {
+        if (sender instanceof ProxiedPlayer) {
+            return ((ProxiedPlayer) sender).getUniqueId();
+        }
+        return Constants.getConsoleUUID();
+    }
+
+    @Override
+    protected void sendMessage(CommandSender sender, String s) {
+        sender.sendMessage(new TextComponent(s));
+    }
+
+    @Override
+    protected boolean hasPermission(CommandSender sender, String node) {
+        return sender.hasPermission(node);
+    }
+}
@@ -1,92 +1,153 @@
+/*
+ * 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;

 import lombok.Getter;
+import me.lucko.luckperms.api.Logger;
+import me.lucko.luckperms.api.PlatformType;
+import me.lucko.luckperms.api.implementation.ApiProvider;
 import me.lucko.luckperms.commands.CommandManager;
-import me.lucko.luckperms.data.Datastore;
-import me.lucko.luckperms.data.MySQLConfiguration;
-import me.lucko.luckperms.data.methods.FlatfileDatastore;
-import me.lucko.luckperms.data.methods.MySQLDatastore;
+import me.lucko.luckperms.commands.ConsecutiveExecutor;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.core.LPConfiguration;
+import me.lucko.luckperms.core.UuidCache;
+import me.lucko.luckperms.data.Importer;
 import me.lucko.luckperms.groups.GroupManager;
-import me.lucko.luckperms.listeners.PlayerListener;
+import me.lucko.luckperms.runnables.ExpireTemporaryTask;
 import me.lucko.luckperms.runnables.UpdateTask;
+import me.lucko.luckperms.storage.Datastore;
+import me.lucko.luckperms.storage.StorageFactory;
 import me.lucko.luckperms.tracks.TrackManager;
 import me.lucko.luckperms.users.BungeeUserManager;
 import me.lucko.luckperms.users.UserManager;
-import me.lucko.luckperms.utils.LPConfiguration;
+import me.lucko.luckperms.utils.LogFactory;
 import net.md_5.bungee.api.connection.ProxiedPlayer;
 import net.md_5.bungee.api.plugin.Plugin;

+import java.io.File;
+import java.util.Collections;
 import java.util.List;
+import java.util.Set;
 import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.TimeUnit;
 import java.util.stream.Collectors;

@Getter
 public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
-    public static final String VERSION = "v1.2";
-
+    private final Set<UUID> ignoringLogs = ConcurrentHashMap.newKeySet();
    private LPConfiguration configuration;
    private UserManager userManager;
    private GroupManager groupManager;
    private TrackManager trackManager;
    private Datastore datastore;
+    private UuidCache uuidCache;
+    private ApiProvider apiProvider;
+    private Logger log;
+    private Importer importer;
+    private ConsecutiveExecutor consecutiveExecutor;

    @Override
    public void onEnable() {
+        log = LogFactory.wrap(getLogger());
+
+        getLog().info("Loading configuration...");
        configuration = new BungeeConfig(this);

        // register events
-        getProxy().getPluginManager().registerListener(this, new PlayerListener(this));
+        getProxy().getPluginManager().registerListener(this, new BungeeListener(this));

        // register commands
-        getProxy().getPluginManager().registerCommand(this, new MainCommand(new CommandManager(this)));
+        getLog().info("Registering commands...");
+        CommandManager commandManager = new CommandManager(this);
+        getProxy().getPluginManager().registerCommand(this, new BungeeCommand(commandManager));

        // disable the default Bungee /perms command so it gets handled by the Bukkit plugin
        getProxy().getDisabledCommands().add("perms");

-        final String storageMethod = configuration.getStorageMethod();
-
-        if (storageMethod.equalsIgnoreCase("mysql")) {
-            getLogger().info("Using MySQL as storage method.");
-            datastore = new MySQLDatastore(this, new MySQLConfiguration(
-                    configuration.getDatabaseValue("address"),
-                    configuration.getDatabaseValue("database"),
-                    configuration.getDatabaseValue("username"),
-                    configuration.getDatabaseValue("password")
-            ));
-        } else if (storageMethod.equalsIgnoreCase("flatfile")) {
-            getLogger().info("Using Flatfile (JSON) as storage method.");
-            datastore = new FlatfileDatastore(this, getDataFolder());
-        } else {
-            getLogger().warning("Storage method '" + storageMethod + "' was not recognised. Using Flatfile as fallback.");
-            datastore = new FlatfileDatastore(this, getDataFolder());
-        }
-
-        datastore.init();
+        datastore = StorageFactory.getDatastore(this, "h2");

+        getLog().info("Loading internal permission managers...");
+        uuidCache = new UuidCache(getConfiguration().getOnlineMode());
        userManager = new BungeeUserManager(this);
        groupManager = new GroupManager(this);
-        trackManager = new TrackManager(this);
+        trackManager = new TrackManager();
+        importer = new Importer(commandManager);
+        consecutiveExecutor = new ConsecutiveExecutor(commandManager);

        int mins = getConfiguration().getSyncTime();
        if (mins > 0) {
            getProxy().getScheduler().schedule(this, new UpdateTask(this), mins, mins, TimeUnit.MINUTES);
        }
+
+        // 20 times per second (once per "tick")
+        getProxy().getScheduler().schedule(this, BungeeSenderFactory.get(), 50L, 50L, TimeUnit.MILLISECONDS);
+        getProxy().getScheduler().schedule(this, new ExpireTemporaryTask(this), 3L, 3L, TimeUnit.SECONDS);
+        getProxy().getScheduler().schedule(this, consecutiveExecutor, 1L, 1L, TimeUnit.SECONDS);
+
+        getLog().info("Registering API...");
+        apiProvider = new ApiProvider(this);
+        LuckPerms.registerProvider(apiProvider);
+
+        // Run update task to refresh any online users
+        getLog().info("Scheduling Update Task to refresh any online users.");
+        try {
+            new UpdateTask(this).run();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+        getLog().info("Successfully loaded.");
    }

    @Override
    public void onDisable() {
+        getLog().info("Closing datastore...");
        datastore.shutdown();
+
+        getLog().info("Unregistering API...");
+        LuckPerms.unregisterProvider();
    }

    @Override
    public String getVersion() {
-        return VERSION;
+        return getDescription().getVersion();
    }

    @Override
-    public String getPlayerStatus(UUID uuid) {
-        return getProxy().getPlayer(uuid) != null ? "&aOnline" : "&cOffline";
+    public PlatformType getType() {
+        return PlatformType.BUNGEE;
+    }
+
+    @Override
+    public File getMainDir() {
+        return getDataFolder();
+    }
+
+    @Override
+    public Message getPlayerStatus(UUID uuid) {
+        return getProxy().getPlayer(getUuidCache().getExternalUUID(uuid)) != null ? Message.PLAYER_ONLINE : Message.PLAYER_OFFLINE;
    }

    @Override
@@ -99,6 +160,45 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
        return getProxy().getPlayers().stream().map(ProxiedPlayer::getName).collect(Collectors.toList());
    }

+    @Override
+    public List<Sender> getSenders() {
+        return getProxy().getPlayers().stream().map(p -> BungeeSenderFactory.get().wrap(p)).collect(Collectors.toList());
+    }
+
+    @Override
+    public Sender getConsoleSender() {
+        return BungeeSenderFactory.get().wrap(getProxy().getConsole());
+    }
+
+    @Override
+    public List<String> getPossiblePermissions() {
+        // No such thing on Bungee. Wildcards are processed in the listener instead.
+        return Collections.emptyList();
+    }
+
+    @Override
+    public Object getPlugin(String name) {
+        return getProxy().getPluginManager().getPlugin(name);
+    }
+
+    @Override
+    public Object getService(Class clazz) {
+        return null;
+    }
+
+    @Override
+    public UUID getUUID(String playerName) {
+        return null; // Not needed on Bungee
+    }
+
+    @Override
+    public boolean isPluginLoaded(String name) {
+        return getProxy().getPluginManager().getPlugins().stream()
+                .filter(p -> p.getDescription().getName().equalsIgnoreCase(name))
+                .findAny()
+                .isPresent();
+    }
+
    @Override
    public void runUpdateTask() {
        doAsync(new UpdateTask(this));
@@ -1,51 +0,0 @@
-package me.lucko.luckperms;
-
-import me.lucko.luckperms.commands.CommandManager;
-import me.lucko.luckperms.commands.Sender;
-import net.md_5.bungee.api.CommandSender;
-import net.md_5.bungee.api.chat.TextComponent;
-import net.md_5.bungee.api.plugin.Command;
-import net.md_5.bungee.api.plugin.TabExecutor;
-
-import java.lang.ref.WeakReference;
-import java.util.Arrays;
-
-class MainCommand extends Command implements TabExecutor {
-    private final CommandManager manager;
-
-    public MainCommand(CommandManager manager) {
-        super("luckpermsbungee", null, "bperms", "lpb", "bpermissions", "bp", "bperm");
-        this.manager = manager;
-
-    }
-
-    @Override
-    public void execute(CommandSender sender, String[] args) {
-        manager.onCommand(makeSender(sender), "bperms", Arrays.asList(args));
-    }
-
-    @Override
-    public Iterable<String> onTabComplete(CommandSender sender, String[] args) {
-        return manager.onTabComplete(makeSender(sender), Arrays.asList(args));
-    }
-
-    private static Sender makeSender(CommandSender sender) {
-        return new Sender() {
-            final WeakReference<CommandSender> cs = new WeakReference<>(sender);
-
-            @Override
-            public void sendMessage(String s) {
-                final CommandSender c = cs.get();
-                if (c != null) {
-                    c.sendMessage(new TextComponent(s));
-                }
-            }
-
-            @Override
-            public boolean hasPermission(String node) {
-                final CommandSender c = cs.get();
-                return c != null && c.hasPermission(node);
-            }
-        };
-    }
-}
@@ -1,57 +0,0 @@
-package me.lucko.luckperms.listeners;
-
-import lombok.AllArgsConstructor;
-import me.lucko.luckperms.LPBungeePlugin;
-import me.lucko.luckperms.commands.Util;
-import me.lucko.luckperms.constants.Message;
-import me.lucko.luckperms.users.User;
-import net.md_5.bungee.api.chat.TextComponent;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-import net.md_5.bungee.api.event.PlayerDisconnectEvent;
-import net.md_5.bungee.api.event.PostLoginEvent;
-import net.md_5.bungee.api.plugin.Listener;
-import net.md_5.bungee.event.EventHandler;
-
-import java.lang.ref.WeakReference;
-import java.util.concurrent.TimeUnit;
-
-@AllArgsConstructor
-public class PlayerListener implements Listener {
-
-    private final LPBungeePlugin plugin;
-
-    @EventHandler
-    public void onPlayerPostLogin(PostLoginEvent e) {
-        final ProxiedPlayer player = e.getPlayer();
-        final WeakReference<ProxiedPlayer> p = new WeakReference<>(player);
-
-        plugin.getDatastore().loadOrCreateUser(player.getUniqueId(), player.getName(), success -> {
-            if (!success) {
-                plugin.getProxy().getScheduler().schedule(plugin, () -> {
-                    final ProxiedPlayer pl = p.get();
-                    if (pl != null) {
-                        pl.sendMessage(new TextComponent(Util.color(Message.PREFIX + "Permissions data could not be loaded. Please contact an administrator.")));
-                    }
-                }, 3, TimeUnit.SECONDS);
-
-            } else {
-                final ProxiedPlayer pl = p.get();
-                if (pl != null) {
-                    final User user = plugin.getUserManager().getUser(pl.getUniqueId());
-                    user.refreshPermissions();
-                }
-            }
-        });
-
-        plugin.getDatastore().saveUUIDData(player.getName(), player.getUniqueId(), success -> {});
-    }
-
-    @EventHandler
-    public void onPlayerQuit(PlayerDisconnectEvent e) {
-        ProxiedPlayer player = e.getPlayer();
-
-        // Unload the user from memory when they disconnect
-        User user = plugin.getUserManager().getUser(player.getUniqueId());
-        plugin.getUserManager().unloadUser(user);
-    }
-}
@@ -1,38 +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.users;

 import me.lucko.luckperms.LPBungeePlugin;
-import net.md_5.bungee.api.connection.ProxiedPlayer;

-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Map;
 import java.util.UUID;

 public class BungeeUser extends User {
-
-    private final LPBungeePlugin plugin;
-
    BungeeUser(UUID uuid, LPBungeePlugin plugin) {
        super(uuid, plugin);
-        this.plugin = plugin;
    }

    BungeeUser(UUID uuid, String username, LPBungeePlugin plugin) {
        super(uuid, username, plugin);
-        this.plugin = plugin;
    }

    @Override
    public void refreshPermissions() {
-        ProxiedPlayer player = plugin.getProxy().getPlayer(getUuid());
-        if (player == null) return;
-
-        // Clear existing permissions
-        Collection<String> perms = new ArrayList<>(player.getPermissions());
-        perms.forEach(p -> player.setPermission(p, false));
-
-        // Re-add all defined permissions for the user
-        Map<String, Boolean> local = getLocalPermissions(getPlugin().getConfiguration().getServer(), null);
-        local.entrySet().forEach(e -> player.setPermission(e.getKey(), e.getValue()));
+        // Do nothing. Permissions are applied when needed in a listener.
    }
 }
@@ -1,7 +1,28 @@
+/*
+ * 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.users;

 import me.lucko.luckperms.LPBungeePlugin;
-import net.md_5.bungee.api.connection.ProxiedPlayer;

 import java.util.UUID;

@@ -14,33 +35,26 @@ public class BungeeUserManager extends UserManager {
    }

    @Override
-    public void unloadUser(User user) {
-        if (user != null) {
-            // Cannot clear the ProxiedPlayer's permission map, they're leaving so that will get GCed anyway
-            // Calling getPermissions.clear() throws an UnsupportedOperationException
-            getUsers().remove(user.getUuid());
+    public void cleanup(User user) {
+        if (plugin.getProxy().getPlayer(plugin.getUuidCache().getExternalUUID(user.getUuid())) == null) {
+            unload(user);
        }
    }

    @Override
-    public void cleanupUser(User user) {
-        if (plugin.getProxy().getPlayer(user.getUuid()) == null) {
-            unloadUser(user);
-        }
-    }
-
-    @Override
-    public User makeUser(UUID uuid) {
+    public User make(UUID uuid) {
        return new BungeeUser(uuid, plugin);
    }

    @Override
-    public User makeUser(UUID uuid, String username) {
+    public User make(UUID uuid, String username) {
        return new BungeeUser(uuid, username, plugin);
    }

    @Override
    public void updateAllUsers() {
-        plugin.getProxy().getPlayers().stream().map(ProxiedPlayer::getUniqueId).forEach(u -> plugin.getDatastore().loadUser(u));
+        plugin.getProxy().getPlayers().stream()
+                .map(p -> plugin.getUuidCache().getUUID(p.getUniqueId()))
+                .forEach(u -> plugin.getDatastore().loadUser(u, "null"));
    }
 }
@@ -1,22 +1,74 @@
-# LuckPerms Configuration
+##############################################################################
+# +------------------------------------------------------------------------+ #
+# |                       LuckPerms Configuration                          | #
+# |                  https://github.com/lucko/LuckPerms                    | #
+# +------------------------------------------------------------------------+ #
+##############################################################################

 # The name of the server, used for server specific permissions. Set to 'global' to disable.
 server: bungee

-# The default group assigned to all users on their first join.
-default-group: default
-
 # If users on this server should have their global permissions/groups applied.
 include-global: false

-# Which storage method the plugin should use.
-# Currently supported: mysql & flatfile
-# Fill out connection info below if you're using MySQL
-storage-method: flatfile
+# If this server is in offline or online mode.
+# This setting allows a player to have the same UUID across a network of offline mode/mixed servers.

-sql:
+# You should generally reflect the setting in server.properties here. Except when...
+
+# 1. You have Spigot servers connected to a BungeeCord proxy, with online-mode set to false, but 'bungeecord' set to true in the spigot.yml
+#    AND 'ip-forward' set to true in the BungeeCord config.yml
+#    In this case, set online-mode in LuckPerms to true, despite the server being in offline mode.
+
+# 2. You are only running one server instance using LuckPerms, (not a network)
+#    In this case, set online-mode to true no matter what is set in server.properties. (we can just fallback to the servers uuid cache)
+
+# 3. If your proxy is running in offline mode, and you are using PaperSpigot (https://ci.destroystokyo.com/job/PaperSpigot/),
+#    you should set "bungee-online-mode" to false in the paper.yml, and set "online-mode" to true in all LuckPerms configs.
+#    This approach is thoroughly recommended for offline mode networks.
+online-mode: true
+
+# If the plugin should apply wildcard permissions.
+# If set to true, LuckPerms will detect wildcard permissions, and resolve & apply all registered permissions matching
+# the wildcard. This will only work for plugins that define all of their permissions to the server.
+apply-wildcards: true
+
+# If the plugin should parse regex permissions.
+# If set to true, LuckPerms will detect regex permissions, marked with "r=" at the start of the node, and resolve &
+# apply all registered permissions matching the regex. This will only work for plugins that define all of their
+# permissions to the server.
+apply-regex: true
+
+# If the plugin should complete and apply shorthand permissions.
+# If set to true, LuckPerms will detect and expand shorthand node patterns.
+apply-shorthand: true
+
+# If the plugin should send log notifications to users whenever permissions are modified.
+log-notify: true
+
+# Which storage method the plugin should use.
+# Currently supported: mysql, sqlite, h2, json, yaml, mongodb
+# Fill out connection info below if you're using MySQL or MongoDB
+storage-method: h2
+
+# This block enables support for split datastores.
+# Only touch this if you're sure that you know what you're doing.
+# I (the author) do not endorse nor recommend the use of this feature.
+split-storage:
+  enabled: false
+  methods:
+    user: h2
+    group: h2
+    track: h2
+    uuid: h2
+    log: h2
+
+data:
  address: localhost:3306
  database: minecraft
  username: root
  password: ''
+
+  # Set to -1 to disable. If this is the only instance accessing the datastore, you can disable syncing.
+  # e.g. if you're using sqlite or flatfile, this can be set to -1 to save resources.
  sync-minutes: 3
@@ -1,5 +1,6 @@
 name: LuckPerms
+version: ${release.version}.${git.closest.tag.commit.count}
+description: A permissions plugin
 author: Luck
-version: 1.2
 main: me.lucko.luckperms.LPBungeePlugin
-description: A permissions plugin
+softdepends: [PowerfulPerms] # For migration
@@ -4,13 +4,12 @@
         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</groupId>
-        <version>1.2</version>
+        <groupId>me.lucko.luckperms</groupId>
+        <version>2.7-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>luckperms-common</artifactId>
-    <version>$(project.parent.version)</version>
    <build>
        <plugins>
            <plugin>
@@ -24,4 +23,121 @@
            </plugin>
        </plugins>
    </build>
-</project>
+
+    <dependencies>
+        <!-- LuckPerms API -->
+        <dependency>
+            <groupId>me.lucko.luckperms</groupId>
+            <artifactId>luckperms-api</artifactId>
+            <version>${project.version}</version>
+            <scope>compile</scope>
+        </dependency>
+        <!-- HikariCP -->
+        <dependency>
+            <groupId>com.zaxxer</groupId>
+            <artifactId>HikariCP</artifactId>
+            <version>2.4.7</version>
+            <scope>compile</scope>
+        </dependency>
+        <!-- SQLite -->
+        <dependency>
+            <groupId>org.xerial</groupId>
+            <artifactId>sqlite-jdbc</artifactId>
+            <version>3.8.11.2</version>
+            <scope>compile</scope>
+        </dependency>
+        <!-- H2 -->
+        <dependency>
+            <groupId>com.h2database</groupId>
+            <artifactId>h2</artifactId>
+            <version>1.4.192</version>
+            <scope>compile</scope>
+        </dependency>
+        <!-- MongoDB -->
+        <dependency>
+            <groupId>org.mongodb</groupId>
+            <artifactId>mongo-java-driver</artifactId>
+            <version>3.3.0</version>
+            <scope>compile</scope>
+        </dependency>
+        <!-- slf4j library -->
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-simple</artifactId>
+            <version>1.7.9</version>
+            <scope>compile</scope>
+        </dependency>
+        <!-- SnakeYAML -->
+        <dependency>
+            <groupId>org.yaml</groupId>
+            <artifactId>snakeyaml</artifactId>
+            <version>1.14</version>
+            <scope>provided</scope>
+        </dependency>
+        <!-- gson -->
+        <dependency>
+            <groupId>com.google.code.gson</groupId>
+            <artifactId>gson</artifactId>
+            <version>2.7</version>
+            <scope>provided</scope>
+        </dependency>
+        <!-- guava -->
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>19.0</version>
+            <scope>provided</scope>
+        </dependency>
+        <!-- Lombok -->
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>1.16.10</version>
+            <scope>provided</scope>
+        </dependency>
+        <!-- **************Migration Plugins************** -->
+        <dependency>
+            <groupId>org.tyrannyofheaven.bukkit</groupId>
+            <artifactId>zPermissions</artifactId>
+            <version>1.3</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>ru.tehkode</groupId>
+            <artifactId>PermissionsEx</artifactId>
+            <version>1.23</version>
+            <scope>provided</scope>
+            <exclusions>
+                <exclusion>
+                    <groupId>org.bukkit</groupId>
+                    <artifactId>bukkit</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+        <dependency>
+            <groupId>com.github.cheesesoftware</groupId>
+            <artifactId>PowerfulPermsAPI</artifactId>
+            <version>1.0.1</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.anjocaido</groupId>
+            <artifactId>GroupManager</artifactId>
+            <version>1.4</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>net.alpenblock</groupId>
+            <artifactId>BungeePerms</artifactId>
+            <version>3.0-dev-52</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>de.bananaco</groupId>
+            <artifactId>bpermissions-api</artifactId>
+            <version>2.12</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+
+</project>
@@ -1,64 +1,92 @@
+/*
+ * 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;

-import me.lucko.luckperms.data.Datastore;
+import me.lucko.luckperms.api.Logger;
+import me.lucko.luckperms.api.PlatformType;
+import me.lucko.luckperms.api.implementation.ApiProvider;
+import me.lucko.luckperms.commands.ConsecutiveExecutor;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.core.LPConfiguration;
+import me.lucko.luckperms.core.UuidCache;
+import me.lucko.luckperms.data.Importer;
 import me.lucko.luckperms.groups.GroupManager;
+import me.lucko.luckperms.storage.Datastore;
 import me.lucko.luckperms.tracks.TrackManager;
 import me.lucko.luckperms.users.UserManager;
-import me.lucko.luckperms.utils.LPConfiguration;

+import java.io.File;
 import java.util.List;
+import java.util.Set;
 import java.util.UUID;
-import java.util.logging.Logger;

+/**
+ * Main internal interface for LuckPerms plugins, allowing the luckperms-common module to bind with the plugin instance.
+ * All plugin platforms implement this interface.
+ */
 public interface LuckPermsPlugin {

-    /**
-     * Retrieves the {@link UserManager} used to manage users and their permissions/groups
-     * @return the {@link UserManager} instance
+    /*
+     * Access to all of the main internal manager classes
     */
    UserManager getUserManager();
-
-    /**
-     * Retrieves the {@link GroupManager} used to manage the loaded groups and modify their permissions
-     * @return the {@link GroupManager} instance
-     */
    GroupManager getGroupManager();
-
-    /**
-     * Retrieves the {@link TrackManager} used to manage the loaded tracks
-     * @return the {@link TrackManager} instance
-     */
    TrackManager getTrackManager();
-
-    /**
-     * Retrieves the {@link LPConfiguration} for getting values from the config
-     * @return the {@link LPConfiguration} implementation for the platform
-     */
    LPConfiguration getConfiguration();
-
-    /**
-     * Retrieves the {@link Datastore} for loading/saving plugin data
-     * @return the {@link Datastore} object
-     */
    Datastore getDatastore();
-
-    /**
-     * Retrieves the {@link Logger} for the plugin
-     * @return the plugin's {@link Logger}
-     */
-    Logger getLogger();
+    Logger getLog();
+    UuidCache getUuidCache();
+    ApiProvider getApiProvider();
+    Importer getImporter();
+    ConsecutiveExecutor getConsecutiveExecutor();

    /**
     * @return the version of the plugin
     */
    String getVersion();

+    /**
+     * @return the platform type
+     */
+    PlatformType getType();
+
+    /**
+     * @return the main plugin directory
+     */
+    File getMainDir();
+
+    /**
+     * @return the platforms data folder
+     */
+    File getDataFolder();
+
    /**
     * Returns a colored string indicating the status of a player
     * @param uuid The player's uuid
     * @return a formatted status string
     */
-    String getPlayerStatus(UUID uuid);
+    Message getPlayerStatus(UUID uuid);

    /**
     * Gets the number of users online on the platform
@@ -72,6 +100,56 @@ public interface LuckPermsPlugin {
     */
    List<String> getPlayerList();

+    /**
+     * @return a {@link List} of senders online on the platform
+     */
+    List<Sender> getSenders();
+
+    /**
+     * @return the console sender of the instance
+     */
+    Sender getConsoleSender();
+
+    /**
+     * Gets all possible permission nodes, used for resolving wildcards
+     * @return a {@link List} of permission nodes
+     */
+    List<String> getPossiblePermissions();
+
+    /**
+     * Gets a set of players ignoring logging output
+     * @return a {@link Set} of uuids
+     */
+    Set<UUID> getIgnoringLogs();
+
+    /**
+     * Gets a loaded plugins instance from the platform
+     * @param name the name of the plugin
+     * @return a plugin instance
+     */
+    Object getPlugin(String name);
+
+    /**
+     * Gets a provided service from the platform.
+     * @param clazz the class of the service
+     * @return the service instance, if it is provided for
+     */
+    Object getService(Class clazz);
+
+    /**
+     * Used as a backup for migration
+     * @param playerName the players name
+     * @return a uuid if found, or null if not
+     */
+    UUID getUUID(String playerName);
+
+    /**
+     * Checks if a plugin is loaded on the platform
+     * @param name the name of the plugin
+     * @return true if the plugin is loaded
+     */
+    boolean isPluginLoaded(String name);
+
    /**
     * Runs an update task
     */
@@ -88,4 +166,5 @@ public interface LuckPermsPlugin {
     * @param r the task to run
     */
    void doSync(Runnable r);
+
 }
@@ -0,0 +1,213 @@
+/*
+ * 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.implementation;
+
+import com.google.common.eventbus.EventBus;
+import lombok.AllArgsConstructor;
+import lombok.NonNull;
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.api.*;
+import me.lucko.luckperms.api.event.LPEvent;
+import me.lucko.luckperms.api.event.LPListener;
+import me.lucko.luckperms.api.implementation.internal.*;
+
+import java.util.Optional;
+import java.util.Set;
+import java.util.UUID;
+import java.util.stream.Collectors;
+
+import static me.lucko.luckperms.api.implementation.internal.Utils.checkNode;
+
+/**
+ * Implements the LuckPerms API using the plugin instance
+ */
+@AllArgsConstructor
+public class ApiProvider implements LuckPermsApi {
+    private final LuckPermsPlugin plugin;
+    private final EventBus eventBus = new EventBus("LuckPerms");
+
+    public void fireEventAsync(LPEvent event) {
+        plugin.doAsync(() -> fireEvent(event));
+    }
+
+    public void fireEvent(LPEvent event) {
+        try {
+            event.setApi(this);
+            eventBus.post(event);
+        } catch (Exception e) {
+            getLogger().severe("Couldn't fire LuckPerms Event: " + event.getEventName());
+            e.printStackTrace();
+        }
+    }
+
+    @Override
+    public void runUpdateTask() {
+        plugin.runUpdateTask();
+    }
+
+    @Override
+    public double getApiVersion() {
+        return 2.6;
+    }
+
+    @Override
+    public String getVersion() {
+        return plugin.getVersion();
+    }
+
+    @Override
+    public PlatformType getPlatformType() {
+        return plugin.getType();
+    }
+
+    @Override
+    public void registerListener(@NonNull LPListener listener) {
+        eventBus.register(listener);
+    }
+
+    @Override
+    public void unregisterListener(@NonNull LPListener listener) {
+        eventBus.unregister(listener);
+    }
+
+    @Override
+    public LPConfiguration getConfiguration() {
+        return new LPConfigurationLink(plugin.getConfiguration());
+    }
+
+    @Override
+    public Datastore getDatastore() {
+        return new DatastoreLink(plugin, plugin.getDatastore());
+    }
+
+    @Override
+    public UuidCache getUuidCache() {
+        return new UuidCacheLink(plugin.getUuidCache());
+    }
+
+    @Override
+    public Logger getLogger() {
+        return plugin.getLog();
+    }
+
+    @Override
+    public User getUser(@NonNull UUID uuid) {
+        final me.lucko.luckperms.users.User user = plugin.getUserManager().get(uuid);
+        if (user == null) {
+            return null;
+        }
+
+        return new UserLink(user);
+    }
+
+    @Override
+    public Optional<User> getUserSafe(@NonNull UUID uuid) {
+        return Optional.ofNullable(getUser(uuid));
+    }
+
+    @Override
+    public User getUser(@NonNull String name) {
+        final me.lucko.luckperms.users.User user = plugin.getUserManager().get(name);
+        if (user == null) {
+            return null;
+        }
+
+        return new UserLink(user);
+    }
+
+    @Override
+    public Optional<User> getUserSafe(@NonNull String name) {
+        return Optional.ofNullable(getUser(name));
+    }
+
+    @Override
+    public Set<User> getUsers() {
+        return plugin.getUserManager().getAll().values().stream().map(UserLink::new).collect(Collectors.toSet());
+    }
+
+    @Override
+    public boolean isUserLoaded(@NonNull UUID uuid) {
+        return plugin.getUserManager().isLoaded(uuid);
+    }
+
+    @Override
+    public void cleanupUser(@NonNull User user) {
+        Utils.checkUser(user);
+        plugin.getUserManager().cleanup(((UserLink) user).getMaster());
+    }
+
+    @Override
+    public Group getGroup(@NonNull String name) {
+        final me.lucko.luckperms.groups.Group group = plugin.getGroupManager().get(name);
+        if (group == null) {
+            return null;
+        }
+
+        return new GroupLink(group);
+    }
+
+    @Override
+    public Optional<Group> getGroupSafe(@NonNull String name) {
+        return Optional.ofNullable(getGroup(name));
+    }
+
+    @Override
+    public Set<Group> getGroups() {
+        return plugin.getGroupManager().getAll().values().stream().map(GroupLink::new).collect(Collectors.toSet());
+    }
+
+    @Override
+    public boolean isGroupLoaded(@NonNull String name) {
+        return plugin.getGroupManager().isLoaded(name);
+    }
+
+    @Override
+    public Track getTrack(@NonNull String name) {
+        final me.lucko.luckperms.tracks.Track track = plugin.getTrackManager().get(name);
+        if (track == null) {
+            return null;
+        }
+
+        return new TrackLink(track);
+    }
+
+    @Override
+    public Optional<Track> getTrackSafe(@NonNull String name) {
+        return Optional.ofNullable(getTrack(name));
+    }
+
+    @Override
+    public Set<Track> getTracks() {
+        return plugin.getTrackManager().getAll().values().stream().map(TrackLink::new).collect(Collectors.toSet());
+    }
+
+    @Override
+    public boolean isTrackLoaded(@NonNull String name) {
+        return plugin.getTrackManager().isLoaded(name);
+    }
+
+    @Override
+    public Node.Builder buildNode(@NonNull String permission) throws IllegalArgumentException {
+        return new me.lucko.luckperms.utils.Node.Builder(checkNode(permission));
+    }
+}
@@ -0,0 +1,516 @@
+/*
+ * 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.implementation.internal;
+
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.NoArgsConstructor;
+import lombok.NonNull;
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.api.*;
+import me.lucko.luckperms.api.data.Callback;
+
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+import static me.lucko.luckperms.api.implementation.internal.Utils.*;
+
+/**
+ * Provides a link between {@link Datastore} and {@link me.lucko.luckperms.storage.Datastore}
+ */
+@SuppressWarnings({"unused", "WeakerAccess"})
+public class DatastoreLink implements Datastore {
+
+    private final LuckPermsPlugin plugin;
+    private final me.lucko.luckperms.storage.Datastore master;
+    private final Async async;
+    private final Sync sync;
+    private final Future future;
+
+    public DatastoreLink(@NonNull LuckPermsPlugin plugin, @NonNull me.lucko.luckperms.storage.Datastore master) {
+        this.plugin = plugin;
+        this.master = master;
+        this.async = new Async(master);
+        this.sync = new Sync(master);
+        this.future = new Future(master);
+    }
+
+    private static <T> Callback<T> checkCallback(Callback<T> c) {
+        // If no callback was given, just send an empty one
+        if (c == null) {
+            c = Callback.empty();
+        }
+        return c;
+    }
+
+    @Override
+    public String getName() {
+        return master.getName();
+    }
+
+    @Override
+    public boolean isAcceptingLogins() {
+        return master.isAcceptingLogins();
+    }
+
+    @Override
+    public Datastore.Async async() {
+        return async;
+    }
+
+    @Override
+    public Datastore.Sync sync() {
+        return sync;
+    }
+
+    @Override
+    public Datastore.Future future() {
+        return future;
+    }
+
+    @AllArgsConstructor
+    public class Async implements Datastore.Async {
+        private final me.lucko.luckperms.storage.Datastore master;
+
+        @Override
+        public void logAction(@NonNull LogEntry entry, Callback<Boolean> callback) {
+            master.logAction(entry, checkCallback(callback));
+        }
+
+        @Override
+        public void getLog(Callback<Log> callback) {
+            master.getLog(log -> callback.onComplete(new LogLink(log)));
+        }
+
+        @Override
+        public void loadOrCreateUser(@NonNull UUID uuid, @NonNull String username, Callback<Boolean> callback) {
+            master.loadUser(uuid, checkUsername(username), checkCallback(callback));
+        }
+
+        @Override
+        public void loadUser(@NonNull UUID uuid, Callback<Boolean> callback) {
+            master.loadUser(uuid, "null", checkCallback(callback));
+        }
+
+        @Override
+        public void loadUser(@NonNull UUID uuid, @NonNull String username, Callback<Boolean> callback) {
+            master.loadUser(uuid, checkUsername(username), checkCallback(callback));
+        }
+
+        @Override
+        public void saveUser(@NonNull User user, Callback<Boolean> callback) {
+            checkUser(user);
+            master.saveUser(((UserLink) user).getMaster(), checkCallback(callback));
+        }
+
+        @Override
+        public void cleanupUsers(Callback<Boolean> callback) {
+            master.cleanupUsers(checkCallback(callback));
+        }
+
+        @Override
+        public void getUniqueUsers(Callback<Set<UUID>> callback) {
+            master.getUniqueUsers(checkCallback(callback));
+        }
+
+        @Override
+        public void createAndLoadGroup(@NonNull String name, Callback<Boolean> callback) {
+            master.createAndLoadGroup(checkName(name), checkCallback(callback));
+        }
+
+        @Override
+        public void loadGroup(@NonNull String name, Callback<Boolean> callback) {
+            master.loadGroup(checkName(name), checkCallback(callback));
+        }
+
+        @Override
+        public void loadAllGroups(Callback<Boolean> callback) {
+            master.loadAllGroups(checkCallback(callback));
+        }
+
+        @Override
+        public void saveGroup(@NonNull Group group, Callback<Boolean> callback) {
+            checkGroup(group);
+            master.saveGroup(((GroupLink) group).getMaster(), checkCallback(callback));
+        }
+
+        @Override
+        public void deleteGroup(@NonNull Group group, Callback<Boolean> callback) {
+            checkGroup(group);
+            if (group.getName().equalsIgnoreCase(plugin.getConfiguration().getDefaultGroupName())) {
+                throw new IllegalArgumentException("Cannot delete the default group.");
+            }
+            master.deleteGroup(((GroupLink) group).getMaster(), checkCallback(callback));
+        }
+
+        @Override
+        public void createAndLoadTrack(@NonNull String name, Callback<Boolean> callback) {
+            master.createAndLoadTrack(checkName(name), checkCallback(callback));
+        }
+
+        @Override
+        public void loadTrack(@NonNull String name, Callback<Boolean> callback) {
+            master.loadTrack(checkName(name), checkCallback(callback));
+        }
+
+        @Override
+        public void loadAllTracks(Callback<Boolean> callback) {
+            master.loadAllTracks(checkCallback(callback));
+        }
+
+        @Override
+        public void saveTrack(@NonNull Track track, Callback<Boolean> callback) {
+            checkTrack(track);
+            master.saveTrack(((TrackLink) track).getMaster(), checkCallback(callback));
+        }
+
+        @Override
+        public void deleteTrack(@NonNull Track track, Callback<Boolean> callback) {
+            checkTrack(track);
+            master.deleteTrack(((TrackLink) track).getMaster(), checkCallback(callback));
+        }
+
+        @Override
+        public void saveUUIDData(@NonNull String username, @NonNull UUID uuid, Callback<Boolean> callback) {
+            master.saveUUIDData(checkUsername(username), uuid, checkCallback(callback));
+        }
+
+        @Override
+        public void getUUID(@NonNull String username, Callback<UUID> callback) {
+            master.getUUID(checkUsername(username), checkCallback(callback));
+        }
+    }
+
+    @AllArgsConstructor
+    public class Sync implements Datastore.Sync {
+        private final me.lucko.luckperms.storage.Datastore master;
+
+        @Override
+        public boolean logAction(@NonNull LogEntry entry) {
+            return master.logAction(entry);
+        }
+
+        @Override
+        public Log getLog() {
+            return new LogLink(master.getLog());
+        }
+
+        @Override
+        public boolean loadOrCreateUser(@NonNull UUID uuid, @NonNull String username) {
+            return master.loadUser(uuid, checkUsername(username));
+        }
+
+        @Override
+        public boolean loadUser(@NonNull UUID uuid) {
+            return master.loadUser(uuid, "null");
+        }
+
+        @Override
+        public boolean loadUser(@NonNull UUID uuid, @NonNull String username) {
+            return master.loadUser(uuid, checkUsername(username));
+        }
+
+        @Override
+        public boolean saveUser(@NonNull User user) {
+            checkUser(user);
+            return master.saveUser(((UserLink) user).getMaster());
+        }
+
+        @Override
+        public boolean cleanupUsers() {
+            return master.cleanupUsers();
+        }
+
+        @Override
+        public Set<UUID> getUniqueUsers() {
+            return master.getUniqueUsers();
+        }
+
+        @Override
+        public boolean createAndLoadGroup(@NonNull String name) {
+            return master.createAndLoadGroup(checkName(name));
+        }
+
+        @Override
+        public boolean loadGroup(@NonNull String name) {
+            return master.loadGroup(checkName(name));
+        }
+
+        @Override
+        public boolean loadAllGroups() {
+            return master.loadAllGroups();
+        }
+
+        @Override
+        public boolean saveGroup(@NonNull Group group) {
+            checkGroup(group);
+            return master.saveGroup(((GroupLink) group).getMaster());
+        }
+
+        @Override
+        public boolean deleteGroup(@NonNull Group group) {
+            checkGroup(group);
+            if (group.getName().equalsIgnoreCase(plugin.getConfiguration().getDefaultGroupName())) {
+                throw new IllegalArgumentException("Cannot delete the default group.");
+            }
+            return master.deleteGroup(((GroupLink) group).getMaster());
+        }
+
+        @Override
+        public boolean createAndLoadTrack(@NonNull String name) {
+            return master.createAndLoadTrack(checkName(name));
+        }
+
+        @Override
+        public boolean loadTrack(@NonNull String name) {
+            return master.loadTrack(checkName(name));
+        }
+
+        @Override
+        public boolean loadAllTracks() {
+            return master.loadAllTracks();
+        }
+
+        @Override
+        public boolean saveTrack(@NonNull Track track) {
+            checkTrack(track);
+            return master.saveTrack(((TrackLink) track).getMaster());
+        }
+
+        @Override
+        public boolean deleteTrack(@NonNull Track track) {
+            checkTrack(track);
+            return master.deleteTrack(((TrackLink) track).getMaster());
+        }
+
+        @Override
+        public boolean saveUUIDData(@NonNull String username, @NonNull UUID uuid) {
+            return master.saveUUIDData(checkUsername(username), uuid);
+        }
+
+        @Override
+        public UUID getUUID(@NonNull String username) {
+            return master.getUUID(checkUsername(username));
+        }
+    }
+
+    @AllArgsConstructor
+    public class Future implements Datastore.Future {
+        private final me.lucko.luckperms.storage.Datastore master;
+
+        @Override
+        public java.util.concurrent.Future<Boolean> logAction(@NonNull LogEntry entry) {
+            LPFuture<Boolean> lpf = new LPFuture<>();
+            master.logAction(entry, lpf);
+            return lpf;
+        }
+
+        @Override
+        public java.util.concurrent.Future<Log> getLog() {
+            LPFuture<Log> lpf = new LPFuture<>();
+            master.getLog(log -> lpf.onComplete(new LogLink(log)));
+            return lpf;
+        }
+
+        @Override
+        public java.util.concurrent.Future<Boolean> loadOrCreateUser(@NonNull UUID uuid, @NonNull String username) {
+            LPFuture<Boolean> lpf = new LPFuture<>();
+            master.loadUser(uuid, checkUsername(username), lpf);
+            return lpf;
+        }
+
+        @Override
+        public java.util.concurrent.Future<Boolean> loadUser(@NonNull UUID uuid) {
+            LPFuture<Boolean> lpf = new LPFuture<>();
+            master.loadUser(uuid, "null", lpf);
+            return lpf;
+        }
+
+        @Override
+        public java.util.concurrent.Future<Boolean> loadUser(@NonNull UUID uuid, @NonNull String username) {
+            LPFuture<Boolean> lpf = new LPFuture<>();
+            master.loadUser(uuid, checkUsername(username), lpf);
+            return lpf;
+        }
+
+        @Override
+        public java.util.concurrent.Future<Boolean> saveUser(@NonNull User user) {
+            LPFuture<Boolean> lpf = new LPFuture<>();
+            checkUser(user);
+            master.saveUser(((UserLink) user).getMaster(), lpf);
+            return lpf;
+        }
+
+        @Override
+        public java.util.concurrent.Future<Boolean> cleanupUsers() {
+            LPFuture<Boolean> lpf = new LPFuture<>();
+            master.cleanupUsers(lpf);
+            return lpf;
+        }
+
+        @Override
+        public java.util.concurrent.Future<Set<UUID>> getUniqueUsers() {
+            LPFuture<Set<UUID>> lpf = new LPFuture<>();
+            master.getUniqueUsers(lpf);
+            return lpf;
+        }
+
+        @Override
+        public java.util.concurrent.Future<Boolean> createAndLoadGroup(@NonNull String name) {
+            LPFuture<Boolean> lpf = new LPFuture<>();
+            master.createAndLoadGroup(checkName(name), lpf);
+            return lpf;
+        }
+
+        @Override
+        public java.util.concurrent.Future<Boolean> loadGroup(@NonNull String name) {
+            LPFuture<Boolean> lpf = new LPFuture<>();
+            master.loadGroup(checkName(name), lpf);
+            return lpf;
+        }
+
+        @Override
+        public java.util.concurrent.Future<Boolean> loadAllGroups() {
+            LPFuture<Boolean> lpf = new LPFuture<>();
+            master.loadAllGroups(lpf);
+            return lpf;
+        }
+
+        @Override
+        public java.util.concurrent.Future<Boolean> saveGroup(@NonNull Group group) {
+            LPFuture<Boolean> lpf = new LPFuture<>();
+            checkGroup(group);
+            master.saveGroup(((GroupLink) group).getMaster(), lpf);
+            return lpf;
+        }
+
+        @Override
+        public java.util.concurrent.Future<Boolean> deleteGroup(@NonNull Group group) {
+            LPFuture<Boolean> lpf = new LPFuture<>();
+            checkGroup(group);
+            if (group.getName().equalsIgnoreCase(plugin.getConfiguration().getDefaultGroupName())) {
+                throw new IllegalArgumentException("Cannot delete the default group.");
+            }
+            master.deleteGroup(((GroupLink) group).getMaster(), lpf);
+            return lpf;
+        }
+
+        @Override
+        public java.util.concurrent.Future<Boolean> createAndLoadTrack(@NonNull String name) {
+            LPFuture<Boolean> lpf = new LPFuture<>();
+            master.createAndLoadTrack(checkName(name), lpf);
+            return lpf;
+        }
+
+        @Override
+        public java.util.concurrent.Future<Boolean> loadTrack(@NonNull String name) {
+            LPFuture<Boolean> lpf = new LPFuture<>();
+            master.loadTrack(checkName(name), lpf);
+            return lpf;
+        }
+
+        @Override
+        public java.util.concurrent.Future<Boolean> loadAllTracks() {
+            LPFuture<Boolean> lpf = new LPFuture<>();
+            master.loadAllTracks(lpf);
+            return lpf;
+        }
+
+        @Override
+        public java.util.concurrent.Future<Boolean> saveTrack(@NonNull Track track) {
+            LPFuture<Boolean> lpf = new LPFuture<>();
+            checkTrack(track);
+            master.saveTrack(((TrackLink) track).getMaster(), lpf);
+            return lpf;
+        }
+
+        @Override
+        public java.util.concurrent.Future<Boolean> deleteTrack(@NonNull Track track) {
+            LPFuture<Boolean> lpf = new LPFuture<>();
+            checkTrack(track);
+            master.deleteTrack(((TrackLink) track).getMaster(), lpf);
+            return lpf;
+        }
+
+        @Override
+        public java.util.concurrent.Future<Boolean> saveUUIDData(@NonNull String username, @NonNull UUID uuid) {
+            LPFuture<Boolean> lpf = new LPFuture<>();
+            master.saveUUIDData(checkUsername(username), uuid, lpf);
+            return lpf;
+        }
+
+        @Override
+        public java.util.concurrent.Future<UUID> getUUID(@NonNull String username) {
+            LPFuture<UUID> lpf = new LPFuture<>();
+            master.getUUID(checkUsername(username), lpf);
+            return lpf;
+        }
+    }
+
+    @NoArgsConstructor(access = AccessLevel.PRIVATE)
+    public static class LPFuture<T> implements Callback<T>, java.util.concurrent.Future<T> {
+        private final CountDownLatch latch = new CountDownLatch(1);
+        private T value;
+
+        @Override
+        public void onComplete(T t) {
+            value = t;
+            latch.countDown();
+        }
+
+        @Override
+        public boolean cancel(boolean mayInterruptIfRunning) {
+            // Not supported
+            return false;
+        }
+
+        @Override
+        public boolean isCancelled() {
+            return false;
+        }
+
+        @Override
+        public boolean isDone() {
+            return latch.getCount() == 0;
+        }
+
+        @Override
+        public T get() throws InterruptedException {
+            latch.await();
+            return value;
+        }
+
+        @Override
+        public T get(long timeout, TimeUnit unit) throws InterruptedException, TimeoutException {
+            if (latch.await(timeout, unit)) {
+                return value;
+            } else {
+                throw new TimeoutException();
+            }
+        }
+    }
+
+}
@@ -0,0 +1,165 @@
+/*
+ * 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.implementation.internal;
+
+import lombok.AccessLevel;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NonNull;
+import me.lucko.luckperms.api.Group;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
+
+import java.util.List;
+
+import static me.lucko.luckperms.api.implementation.internal.Utils.*;
+
+/**
+ * Provides a link between {@link Group} and {@link me.lucko.luckperms.groups.Group}
+ */
+@EqualsAndHashCode(of = {"name"}, callSuper = false)
+@SuppressWarnings("unused")
+public class GroupLink extends PermissionHolderLink implements Group {
+
+    @Getter(AccessLevel.PACKAGE)
+    private final me.lucko.luckperms.groups.Group master;
+
+    @Getter
+    private final String name;
+
+    public GroupLink(@NonNull me.lucko.luckperms.groups.Group master) {
+        super(master);
+        this.master = master;
+        this.name = master.getName();
+    }
+
+    @Override
+    public boolean inheritsGroup(@NonNull Group group) {
+        checkGroup(group);
+        return master.inheritsGroup(((GroupLink) group).getMaster());
+    }
+
+    @Override
+    public boolean inheritsGroup(@NonNull Group group, @NonNull String server) {
+        checkGroup(group);
+        return master.inheritsGroup(((GroupLink) group).getMaster(), server);
+    }
+
+    @Override
+    public boolean inheritsGroup(@NonNull Group group, @NonNull String server, @NonNull String world) {
+        checkGroup(group);
+        return master.inheritsGroup(((GroupLink) group).getMaster(), server, world);
+    }
+
+    @Override
+    public void setInheritGroup(@NonNull Group group) throws ObjectAlreadyHasException {
+        checkGroup(group);
+        master.setInheritGroup(((GroupLink) group).getMaster());
+    }
+
+    @Override
+    public void setInheritGroup(@NonNull Group group, @NonNull String server) throws ObjectAlreadyHasException {
+        checkGroup(group);
+        master.setInheritGroup(((GroupLink) group).getMaster(), checkServer(server));
+    }
+
+    @Override
+    public void setInheritGroup(@NonNull Group group, @NonNull String server, @NonNull String world) throws ObjectAlreadyHasException {
+        checkGroup(group);
+        master.setInheritGroup(((GroupLink) group).getMaster(), checkServer(server), world);
+    }
+
+    @Override
+    public void setInheritGroup(@NonNull Group group, @NonNull long expireAt) throws ObjectAlreadyHasException {
+        checkGroup(group);
+        master.setInheritGroup(((GroupLink) group).getMaster(), checkTime(expireAt));
+    }
+
+    @Override
+    public void setInheritGroup(@NonNull Group group, @NonNull String server, @NonNull long expireAt) throws ObjectAlreadyHasException {
+        checkGroup(group);
+        master.setInheritGroup(((GroupLink) group).getMaster(), checkServer(server), checkTime(expireAt));
+    }
+
+    @Override
+    public void setInheritGroup(@NonNull Group group, @NonNull String server, @NonNull String world, @NonNull long expireAt) throws ObjectAlreadyHasException {
+        checkGroup(group);
+        master.setInheritGroup(((GroupLink) group).getMaster(), checkServer(server), world, checkTime(expireAt));
+    }
+
+    @Override
+    public void unsetInheritGroup(@NonNull Group group) throws ObjectLacksException {
+        checkGroup(group);
+        master.unsetInheritGroup(((GroupLink) group).getMaster());
+    }
+
+    @Override
+    public void unsetInheritGroup(@NonNull Group group, @NonNull boolean temporary) throws ObjectLacksException {
+        checkGroup(group);
+        master.unsetInheritGroup(((GroupLink) group).getMaster(), temporary);
+    }
+
+    @Override
+    public void unsetInheritGroup(@NonNull Group group, @NonNull String server) throws ObjectLacksException {
+        checkGroup(group);
+        master.unsetInheritGroup(((GroupLink) group).getMaster(), checkServer(server));
+    }
+
+    @Override
+    public void unsetInheritGroup(@NonNull Group group, @NonNull String server, @NonNull String world) throws ObjectLacksException {
+        checkGroup(group);
+        master.unsetInheritGroup(((GroupLink) group).getMaster(), checkServer(server), world);
+    }
+
+    @Override
+    public void unsetInheritGroup(@NonNull Group group, @NonNull String server, @NonNull boolean temporary) throws ObjectLacksException {
+        checkGroup(group);
+        master.unsetInheritGroup(((GroupLink) group).getMaster(), checkServer(server), temporary);
+    }
+
+    @Override
+    public void unsetInheritGroup(@NonNull Group group, @NonNull String server, @NonNull String world, @NonNull boolean temporary) throws ObjectLacksException {
+        checkGroup(group);
+        master.unsetInheritGroup(((GroupLink) group).getMaster(), checkServer(server), world, temporary);
+    }
+
+    @Override
+    public void clearNodes() {
+        master.clearNodes();
+    }
+
+    @Override
+    public List<String> getGroupNames() {
+        return master.getGroupNames();
+    }
+
+    @Override
+    public List<String> getLocalGroups(@NonNull String server, @NonNull String world) {
+        return master.getLocalGroups(checkServer(server), world);
+    }
+
+    @Override
+    public List<String> getLocalGroups(@NonNull String server) {
+        return master.getLocalGroups(checkServer(server));
+    }
+}
@@ -0,0 +1,125 @@
+/*
+ * 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.implementation.internal;
+
+import lombok.AllArgsConstructor;
+import me.lucko.luckperms.api.LPConfiguration;
+import me.lucko.luckperms.api.data.DatastoreConfiguration;
+import me.lucko.luckperms.api.data.MySQLConfiguration;
+
+import java.util.Map;
+
+/**
+ * Provides a link between {@link LPConfiguration} and {@link me.lucko.luckperms.core.LPConfiguration}
+ */
+@AllArgsConstructor
+public class LPConfigurationLink implements LPConfiguration {
+    private final me.lucko.luckperms.core.LPConfiguration master;
+
+    @Override
+    public String getServer() {
+        return master.getServer();
+    }
+
+    @Override
+    public int getSyncTime() {
+        return master.getSyncTime();
+    }
+
+    @Override
+    public String getDefaultGroupNode() {
+        return master.getDefaultGroupNode();
+    }
+
+    @Override
+    public String getDefaultGroupName() {
+        return master.getDefaultGroupName();
+    }
+
+    @Override
+    public boolean getIncludeGlobalPerms() {
+        return master.getIncludeGlobalPerms();
+    }
+
+    @Override
+    public boolean getOnlineMode() {
+        return master.getOnlineMode();
+    }
+
+    @Override
+    public boolean getApplyWildcards() {
+        return master.getApplyWildcards();
+    }
+
+    @Override
+    public boolean getApplyRegex() {
+        return master.getApplyRegex();
+    }
+
+    @Override
+    public boolean getApplyShorthand() {
+        return master.getApplyShorthand();
+    }
+
+    @Override
+    public boolean getLogNotify() {
+        return master.getLogNotify();
+    }
+
+    @Override
+    public String getVaultServer() {
+        return master.getVaultServer();
+    }
+
+    @Override
+    public boolean getVaultIncludeGlobal() {
+        return master.getVaultIncludeGlobal();
+    }
+
+    @SuppressWarnings("deprecation")
+    @Override
+    public MySQLConfiguration getDatabaseValues() {
+        return getDatastoreConfig();
+    }
+
+    @Override
+    public DatastoreConfiguration getDatastoreConfig() {
+        return master.getDatabaseValues();
+    }
+
+    @Override
+    public String getStorageMethod() {
+        return master.getStorageMethod();
+    }
+
+    @Override
+    public boolean getSplitStorage() {
+        return master.getSplitStorage();
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public Map<String, String> getSplitStorageOptions() {
+        return master.getSplitStorageOptions();
+    }
+}
@@ -0,0 +1,137 @@
+/*
+ * 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.implementation.internal;
+
+import lombok.AllArgsConstructor;
+import lombok.NonNull;
+import me.lucko.luckperms.api.Log;
+import me.lucko.luckperms.api.LogEntry;
+
+import java.util.SortedMap;
+import java.util.SortedSet;
+import java.util.UUID;
+
+import static me.lucko.luckperms.api.implementation.internal.Utils.checkName;
+
+/**
+ * Provides a link between {@link Log} and {@link me.lucko.luckperms.data.Log}
+ */
+@AllArgsConstructor
+public class LogLink implements Log {
+    private final me.lucko.luckperms.data.Log master;
+    
+    @Override
+    public SortedSet<LogEntry> getContent() {
+        return master.getContent();
+    }
+
+    @Override
+    public SortedSet<LogEntry> getRecent() {
+        return master.getRecent();
+    }
+
+    @Override
+    public SortedMap<Integer, LogEntry> getRecent(int pageNo) {
+        return master.getRecent(pageNo);
+    }
+
+    @Override
+    public int getRecentMaxPages() {
+        return master.getRecentMaxPages();
+    }
+
+    @Override
+    public SortedSet<LogEntry> getRecent(@NonNull UUID actor) {
+        return master.getRecent(actor);
+    }
+
+    @Override
+    public SortedMap<Integer, LogEntry> getRecent(int pageNo, @NonNull UUID actor) {
+        return master.getRecent(pageNo, actor);
+    }
+
+    @Override
+    public int getRecentMaxPages(@NonNull UUID actor) {
+        return master.getRecentMaxPages(actor);
+    }
+
+    @Override
+    public SortedSet<LogEntry> getUserHistory(@NonNull UUID uuid) {
+        return master.getUserHistory(uuid);
+    }
+
+    @Override
+    public SortedMap<Integer, LogEntry> getUserHistory(int pageNo, @NonNull UUID uuid) {
+        return master.getUserHistory(pageNo, uuid);
+    }
+
+    @Override
+    public int getUserHistoryMaxPages(@NonNull UUID uuid) {
+        return master.getUserHistoryMaxPages(uuid);
+    }
+
+    @Override
+    public SortedSet<LogEntry> getGroupHistory(@NonNull String name) {
+        return master.getGroupHistory(checkName(name));
+    }
+
+    @Override
+    public SortedMap<Integer, LogEntry> getGroupHistory(int pageNo, @NonNull String name) {
+        return master.getGroupHistory(pageNo, checkName(name));
+    }
+
+    @Override
+    public int getGroupHistoryMaxPages(@NonNull String name) {
+        return master.getGroupHistoryMaxPages(checkName(name));
+    }
+
+    @Override
+    public SortedSet<LogEntry> getTrackHistory(@NonNull String name) {
+        return master.getTrackHistory(checkName(name));
+    }
+
+    @Override
+    public SortedMap<Integer, LogEntry> getTrackHistory(int pageNo, @NonNull String name) {
+        return master.getTrackHistory(pageNo, checkName(name));
+    }
+
+    @Override
+    public int getTrackHistoryMaxPages(@NonNull String name) {
+        return master.getTrackHistoryMaxPages(checkName(name));
+    }
+
+    @Override
+    public SortedSet<LogEntry> getSearch(@NonNull String query) {
+        return master.getSearch(query);
+    }
+
+    @Override
+    public SortedMap<Integer, LogEntry> getSearch(int pageNo, @NonNull String query) {
+        return master.getSearch(pageNo, query);
+    }
+
+    @Override
+    public int getSearchMaxPages(@NonNull String query) {
+        return master.getSearchMaxPages(query);
+    }
+}
@@ -0,0 +1,289 @@
+/*
+ * 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.implementation.internal;
+
+import lombok.AllArgsConstructor;
+import lombok.NonNull;
+import me.lucko.luckperms.api.Node;
+import me.lucko.luckperms.api.PermissionHolder;
+import me.lucko.luckperms.api.Tristate;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
+
+import java.util.*;
+
+import static me.lucko.luckperms.api.implementation.internal.Utils.*;
+import static me.lucko.luckperms.core.PermissionHolder.exportToLegacy;
+
+/**
+ * Provides a link between {@link PermissionHolder} and {@link me.lucko.luckperms.core.PermissionHolder}
+ */
+@SuppressWarnings({"unused", "deprecation"})
+@AllArgsConstructor
+public class PermissionHolderLink implements PermissionHolder {
+
+    @NonNull
+    private final me.lucko.luckperms.core.PermissionHolder master;
+
+    @Override
+    public String getObjectName() {
+        return master.getObjectName();
+    }
+
+    @Override
+    public SortedSet<Node> getPermissions() {
+        return Collections.unmodifiableSortedSet(master.getPermissions());
+    }
+
+    @Override
+    public Set<Node> getEnduringPermissions() {
+        return Collections.unmodifiableSet(master.getNodes());
+    }
+
+    @Override
+    public Set<Node> getTransientPermissions() {
+        return Collections.unmodifiableSet(master.getTransientNodes());
+    }
+
+    @Override
+    public Set<Node> getAllNodes() {
+        return Collections.unmodifiableSet(master.getAllNodes(null));
+    }
+
+    @Override
+    public Map<String, Boolean> getNodes() {
+        return exportToLegacy(master.getNodes());
+    }
+
+    @Override
+    public Tristate hasPermission(@NonNull Node node) {
+        return master.hasPermission(node, false);
+    }
+
+    @Override
+    public Tristate hasTransientPermission(@NonNull Node node) {
+        return master.hasPermission(node, true);
+    }
+
+    @Override
+    public boolean hasPermission(@NonNull String node, @NonNull boolean b) {
+        return master.hasPermission(node, b);
+    }
+
+    @Override
+    public boolean hasPermission(@NonNull String node, @NonNull boolean b, @NonNull String server) {
+        return master.hasPermission(node, b, checkServer(server));
+    }
+
+    @Override
+    public boolean hasPermission(@NonNull String node, @NonNull boolean b, @NonNull String server, @NonNull String world) {
+        return master.hasPermission(node, b, checkServer(server), world);
+    }
+
+    @Override
+    public boolean hasPermission(@NonNull String node, @NonNull boolean b, @NonNull boolean temporary) {
+        return master.hasPermission(node, b, temporary);
+    }
+
+    @Override
+    public boolean hasPermission(@NonNull String node, @NonNull boolean b, @NonNull String server, @NonNull boolean temporary) {
+        return master.hasPermission(node, b, checkServer(server), temporary);
+    }
+
+    @Override
+    public boolean hasPermission(@NonNull String node, @NonNull boolean b, @NonNull String server, @NonNull String world, @NonNull boolean temporary) {
+        return master.hasPermission(node, b, checkServer(server), world, temporary);
+    }
+
+    @Override
+    public Tristate inheritsPermission(@NonNull Node node) {
+        return master.inheritsPermission(node);
+    }
+
+    @Override
+    public boolean inheritsPermission(@NonNull String node, @NonNull boolean b) {
+        return master.inheritsPermission(node, b);
+    }
+
+    @Override
+    public boolean inheritsPermission(@NonNull String node, @NonNull boolean b, @NonNull String server) {
+        return master.inheritsPermission(node, b, checkServer(server));
+    }
+
+    @Override
+    public boolean inheritsPermission(@NonNull String node, @NonNull boolean b, @NonNull String server, @NonNull String world) {
+        return master.inheritsPermission(node, b, checkServer(server), world);
+    }
+
+    @Override
+    public boolean inheritsPermission(@NonNull String node, @NonNull boolean b, @NonNull boolean temporary) {
+        return master.inheritsPermission(node, b, temporary);
+    }
+
+    @Override
+    public boolean inheritsPermission(@NonNull String node, @NonNull boolean b, @NonNull String server, @NonNull boolean temporary) {
+        return master.inheritsPermission(node, b, checkServer(server), temporary);
+    }
+
+    @Override
+    public boolean inheritsPermission(@NonNull String node, @NonNull boolean b, @NonNull String server, @NonNull String world, @NonNull boolean temporary) {
+        return master.inheritsPermission(node, b, checkServer(server), world, temporary);
+    }
+
+    @Override
+    public void setPermission(@NonNull Node node) throws ObjectAlreadyHasException {
+        master.setPermission(node);
+    }
+
+    @Override
+    public void setTransientPermission(@NonNull Node node) throws ObjectAlreadyHasException {
+        master.setTransientPermission(node);
+    }
+
+    @Override
+    public void setPermission(@NonNull String node, @NonNull boolean value) throws ObjectAlreadyHasException {
+        master.setPermission(checkNode(node), value);
+    }
+
+    @Override
+    public void setPermission(@NonNull String node, @NonNull boolean value, @NonNull String server) throws ObjectAlreadyHasException {
+        master.setPermission(checkNode(node), value, checkServer(server));
+    }
+
+    @Override
+    public void setPermission(@NonNull String node, @NonNull boolean value, @NonNull String server, @NonNull String world) throws ObjectAlreadyHasException {
+        master.setPermission(checkNode(node), value, checkServer(server), world);
+    }
+
+    @Override
+    public void setPermission(@NonNull String node, @NonNull boolean value, @NonNull long expireAt) throws ObjectAlreadyHasException {
+        master.setPermission(checkNode(node), value, checkTime(expireAt));
+    }
+
+    @Override
+    public void setPermission(@NonNull String node, @NonNull boolean value, @NonNull String server, @NonNull long expireAt) throws ObjectAlreadyHasException {
+        master.setPermission(checkNode(node), value, checkServer(server), checkTime(expireAt));
+    }
+
+    @Override
+    public void setPermission(@NonNull String node, @NonNull boolean value, @NonNull String server, @NonNull String world, @NonNull long expireAt) throws ObjectAlreadyHasException {
+        master.setPermission(checkNode(node), value, checkServer(server), world, checkTime(expireAt));
+    }
+
+    @Override
+    public void unsetPermission(@NonNull Node node) throws ObjectLacksException {
+        master.unsetPermission(node);
+    }
+
+    @Override
+    public void unsetTransientPermission(@NonNull Node node) throws ObjectLacksException {
+        master.unsetTransientPermission(node);
+    }
+
+    @Override
+    public void unsetPermission(@NonNull String node, @NonNull boolean temporary) throws ObjectLacksException {
+        master.unsetPermission(checkNode(node), temporary);
+    }
+
+    @Override
+    public void unsetPermission(@NonNull String node) throws ObjectLacksException {
+        master.unsetPermission(checkNode(node));
+    }
+
+    @Override
+    public void unsetPermission(@NonNull String node, @NonNull String server) throws ObjectLacksException {
+        master.unsetPermission(checkNode(node), checkServer(server));
+    }
+
+    @Override
+    public void unsetPermission(@NonNull String node, @NonNull String server, @NonNull String world) throws ObjectLacksException {
+        master.unsetPermission(checkNode(node), checkServer(server), world);
+    }
+
+    @Override
+    public void unsetPermission(@NonNull String node, @NonNull String server, @NonNull boolean temporary) throws ObjectLacksException {
+        master.unsetPermission(checkNode(node), checkServer(server), temporary);
+    }
+
+    @Override
+    public void unsetPermission(@NonNull String node, @NonNull String server, @NonNull String world, @NonNull boolean temporary) throws ObjectLacksException {
+        master.unsetPermission(checkNode(node), checkServer(server), world, temporary);
+    }
+
+    @Override
+    public Map<String, Boolean> getLocalPermissions(String server, String world, List<String> excludedGroups, List<String> possibleNodes) {
+        return master.getLocalPermissions(server, world, excludedGroups, possibleNodes);
+    }
+
+    @Override
+    public Map<String, Boolean> getLocalPermissions(String server, String world, List<String> excludedGroups) {
+        return master.getLocalPermissions(server, world, excludedGroups);
+    }
+
+    @Override
+    public Map<String, Boolean> getLocalPermissions(String server, List<String> excludedGroups, List<String> possibleNodes) {
+        return master.getLocalPermissions(server, excludedGroups, possibleNodes);
+    }
+
+    @Override
+    public Map<String, Boolean> getLocalPermissions(String server, List<String> excludedGroups) {
+        return master.getLocalPermissions(server, excludedGroups);
+    }
+
+    @Override
+    public Map<String, Boolean> getPermissions(String server, String world, Map<String, String> extraContext, boolean includeGlobal, List<String> possibleNodes, boolean applyGroups) {
+        return master.exportNodes(server, world, extraContext, includeGlobal, applyGroups, possibleNodes);
+    }
+
+    @Override
+    public Map<Map.Entry<String, Boolean>, Long> getTemporaryNodes() {
+        Map<Map.Entry<String, Boolean>, Long> m = new HashMap<>();
+
+        for (Node node : master.getTemporaryNodes()) {
+            m.put(new AbstractMap.SimpleEntry<>(node.getKey(), node.getValue()), node.getExpiryUnixTime());
+        }
+
+        return m;
+    }
+
+    @Override
+    public Set<Node> getTemporaryPermissionNodes() {
+        return master.getTemporaryNodes();
+    }
+
+    @Override
+    public Map<String, Boolean> getPermanentNodes() {
+        return exportToLegacy(master.getPermanentNodes());
+    }
+
+    @Override
+    public Set<Node> getPermanentPermissionNodes() {
+        return master.getPermanentNodes();
+    }
+
+    @Override
+    public void auditTemporaryPermissions() {
+        master.auditTemporaryPermissions();
+    }
+
+}
@@ -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.api.implementation.internal;
+
+import lombok.AccessLevel;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NonNull;
+import me.lucko.luckperms.api.Group;
+import me.lucko.luckperms.api.Track;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
+
+import java.util.List;
+
+import static me.lucko.luckperms.api.implementation.internal.Utils.checkGroup;
+
+/**
+ * Provides a link between {@link Track} and {@link me.lucko.luckperms.tracks.Track}
+ */
+@EqualsAndHashCode(of = {"name"})
+@SuppressWarnings("unused")
+public class TrackLink implements Track {
+
+    @Getter(AccessLevel.PACKAGE)
+    private final me.lucko.luckperms.tracks.Track master;
+
+    @Getter
+    private final String name;
+
+    public TrackLink(@NonNull me.lucko.luckperms.tracks.Track master) {
+        this.master = master;
+        this.name = master.getName();
+    }
+
+    @Override
+    public List<String> getGroups() {
+        return master.getGroups();
+    }
+
+    @Override
+    public int getSize() {
+        return master.getSize();
+    }
+
+    @Override
+    public String getNext(@NonNull Group current) throws ObjectLacksException {
+        checkGroup(current);
+        return master.getNext(((GroupLink) current).getMaster());
+    }
+
+    @Override
+    public String getPrevious(@NonNull Group current) throws ObjectLacksException {
+        checkGroup(current);
+        return master.getPrevious(((GroupLink) current).getMaster());
+    }
+
+    @Override
+    public void appendGroup(@NonNull Group group) throws ObjectAlreadyHasException {
+        checkGroup(group);
+        master.appendGroup(((GroupLink) group).getMaster());
+    }
+
+    @Override
+    public void insertGroup(@NonNull Group group, @NonNull int position) throws ObjectAlreadyHasException, IndexOutOfBoundsException {
+        checkGroup(group);
+        master.insertGroup(((GroupLink) group).getMaster(), position);
+    }
+
+    @Override
+    public void removeGroup(@NonNull Group group) throws ObjectLacksException {
+        checkGroup(group);
+        master.removeGroup(((GroupLink) group).getMaster());
+    }
+
+    @Override
+    public void removeGroup(@NonNull String group) throws ObjectLacksException {
+        master.removeGroup(group);
+    }
+
+    @Override
+    public boolean containsGroup(@NonNull Group group) {
+        checkGroup(group);
+        return master.containsGroup(((GroupLink) group).getMaster());
+    }
+
+    @Override
+    public boolean containsGroup(@NonNull String group) {
+        return master.containsGroup(group);
+    }
+
+    @Override
+    public void clearGroups() {
+        master.clearGroups();
+    }
+}
@@ -0,0 +1,195 @@
+/*
+ * 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.implementation.internal;
+
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NonNull;
+import me.lucko.luckperms.api.Group;
+import me.lucko.luckperms.api.User;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
+
+import java.util.List;
+import java.util.UUID;
+
+import static me.lucko.luckperms.api.implementation.internal.Utils.*;
+
+/**
+ * Provides a link between {@link User} and {@link me.lucko.luckperms.users.User}
+ */
+@EqualsAndHashCode(of = {"uuid"}, callSuper = false)
+@SuppressWarnings("unused")
+public class UserLink extends PermissionHolderLink implements User {
+
+    @Getter
+    private final me.lucko.luckperms.users.User master;
+
+    @Getter
+    private final UUID uuid;
+
+    public UserLink(@NonNull me.lucko.luckperms.users.User master) {
+        super(master);
+        this.master = master;
+        this.uuid = master.getUuid();
+    }
+
+    @Override
+    public String getName() {
+        return master.getName();
+    }
+
+    @Override
+    public String getPrimaryGroup() {
+        return master.getPrimaryGroup();
+    }
+
+    @Override
+    public void setPrimaryGroup(@NonNull String s) throws ObjectAlreadyHasException {
+        if (getPrimaryGroup().equalsIgnoreCase(s)) {
+            throw new ObjectAlreadyHasException();
+        }
+
+        if (!getGroupNames().contains(s.toLowerCase())) {
+            throw new IllegalStateException("User is not a member of that group.");
+        }
+
+        master.setPrimaryGroup(s.toLowerCase());
+    }
+
+    @Override
+    public void refreshPermissions() {
+        master.refreshPermissions();
+    }
+
+    @Override
+    public boolean isInGroup(@NonNull Group group) {
+        checkGroup(group);
+        return master.isInGroup(((GroupLink) group).getMaster());
+    }
+
+    @Override
+    public boolean isInGroup(@NonNull Group group, @NonNull String server) {
+        checkGroup(group);
+        return master.isInGroup(((GroupLink) group).getMaster(), server);
+    }
+
+    @Override
+    public boolean isInGroup(@NonNull Group group, @NonNull String server, @NonNull String world) {
+        checkGroup(group);
+        return master.isInGroup(((GroupLink) group).getMaster(), server, world);
+    }
+
+    @Override
+    public void addGroup(@NonNull Group group) throws ObjectAlreadyHasException {
+        checkGroup(group);
+        master.addGroup(((GroupLink) group).getMaster());
+    }
+
+    @Override
+    public void addGroup(@NonNull Group group, @NonNull String server) throws ObjectAlreadyHasException {
+        checkGroup(group);
+        master.addGroup(((GroupLink) group).getMaster(), checkServer(server));
+    }
+
+    @Override
+    public void addGroup(@NonNull Group group, @NonNull String server, @NonNull String world) throws ObjectAlreadyHasException {
+        checkGroup(group);
+        master.addGroup(((GroupLink) group).getMaster(), checkServer(server), world);
+    }
+
+    @Override
+    public void addGroup(@NonNull Group group, @NonNull long expireAt) throws ObjectAlreadyHasException {
+        checkGroup(group);
+        master.addGroup(((GroupLink) group).getMaster(), checkTime(expireAt));
+    }
+
+    @Override
+    public void addGroup(@NonNull Group group, @NonNull String server, @NonNull long expireAt) throws ObjectAlreadyHasException {
+        checkGroup(group);
+        master.addGroup(((GroupLink) group).getMaster(), checkServer(server), checkTime(expireAt));
+    }
+
+    @Override
+    public void addGroup(@NonNull Group group, @NonNull String server, @NonNull String world, @NonNull long expireAt) throws ObjectAlreadyHasException {
+        checkGroup(group);
+        master.addGroup(((GroupLink) group).getMaster(), checkServer(server), world, checkTime(expireAt));
+    }
+
+    @Override
+    public void removeGroup(@NonNull Group group) throws ObjectLacksException {
+        checkGroup(group);
+        master.removeGroup(((GroupLink) group).getMaster());
+    }
+
+    @Override
+    public void removeGroup(@NonNull Group group, @NonNull boolean temporary) throws ObjectLacksException {
+        checkGroup(group);
+        master.removeGroup(((GroupLink) group).getMaster(), temporary);
+    }
+
+    @Override
+    public void removeGroup(@NonNull Group group, @NonNull String server) throws ObjectLacksException {
+        checkGroup(group);
+        master.removeGroup(((GroupLink) group).getMaster(), checkServer(server));
+    }
+
+    @Override
+    public void removeGroup(@NonNull Group group, @NonNull String server, @NonNull String world) throws ObjectLacksException {
+        checkGroup(group);
+        master.removeGroup(((GroupLink) group).getMaster(), checkServer(server), world);
+    }
+
+    @Override
+    public void removeGroup(@NonNull Group group, @NonNull String server, @NonNull boolean temporary) throws ObjectLacksException {
+        checkGroup(group);
+        master.removeGroup(((GroupLink) group).getMaster(), checkServer(server), temporary);
+    }
+
+    @Override
+    public void removeGroup(@NonNull Group group, @NonNull String server, @NonNull String world, @NonNull boolean temporary) throws ObjectLacksException {
+        checkGroup(group);
+        master.removeGroup(((GroupLink) group).getMaster(), checkServer(server), world, temporary);
+    }
+
+    @Override
+    public void clearNodes() {
+        master.clearNodes();
+    }
+
+    @Override
+    public List<String> getGroupNames() {
+        return master.getGroupNames();
+    }
+
+    @Override
+    public List<String> getLocalGroups(@NonNull String server, @NonNull String world) {
+        return master.getLocalGroups(checkServer(server), world);
+    }
+
+    @Override
+    public List<String> getLocalGroups(@NonNull String server) {
+        return master.getLocalGroups(checkServer(server));
+    }
+
+}
@@ -0,0 +1,89 @@
+/*
+ * 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.implementation.internal;
+
+import lombok.experimental.UtilityClass;
+import me.lucko.luckperms.api.Group;
+import me.lucko.luckperms.api.Track;
+import me.lucko.luckperms.api.User;
+import me.lucko.luckperms.utils.ArgumentChecker;
+
+@UtilityClass
+public class Utils {
+
+    public static void checkUser(User user) {
+        if (!(user instanceof UserLink)) {
+            throw new IllegalStateException("User instance cannot be handled by this implementation.");
+        }
+    }
+
+    public static void checkGroup(Group group) {
+        if (!(group instanceof GroupLink)) {
+            throw new IllegalStateException("Group instance cannot be handled by this implementation.");
+        }
+    }
+
+    public static void checkTrack(Track track) {
+        if (!(track instanceof TrackLink)) {
+            throw new IllegalStateException("Track instance cannot be handled by this implementation.");
+        }
+    }
+
+    public static String checkUsername(String s) {
+        if (ArgumentChecker.checkUsername(s)) {
+            throw new IllegalArgumentException("Invalid username entry '" + s + "'. Usernames must be less than 16 chars" +
+                    " and only contain 'a-z A-Z 1-9 _'.");
+        }
+        return s;
+    }
+
+    public static String checkName(String s) {
+        if (ArgumentChecker.checkName(s)) {
+            throw new IllegalArgumentException("Invalid name entry '" + s + "'. Names must be less than 37 chars" +
+                    " and only contain 'a-z A-Z 1-9'.");
+        }
+        return s.toLowerCase();
+    }
+
+    public static String checkServer(String s) {
+        if (ArgumentChecker.checkServer(s)) {
+            throw new IllegalArgumentException("Invalid server entry '" + s + "'. Server names can only contain alphanumeric characters.");
+        }
+        return s;
+    }
+
+    public static String checkNode(String s) {
+        if (ArgumentChecker.checkNode(s)) {
+            throw new IllegalArgumentException("Invalid node entry '" + s + "'. Nodes cannot contain '/' or '$' characters.");
+        }
+        return s;
+    }
+
+    public static long checkTime(long l) {
+        if (ArgumentChecker.checkTime(l)) {
+            throw new IllegalArgumentException("Unix time '" + l + "' is invalid, as it has already passed.");
+        }
+        return l;
+    }
+
+}
@@ -0,0 +1,46 @@
+/*
+ * 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.implementation.internal;
+
+import lombok.AllArgsConstructor;
+import me.lucko.luckperms.api.UuidCache;
+
+import java.util.UUID;
+
+/**
+ * Provides a link between {@link UuidCache} and {@link me.lucko.luckperms.core.UuidCache}
+ */
+@AllArgsConstructor
+public class UuidCacheLink implements UuidCache {
+    private final me.lucko.luckperms.core.UuidCache master;
+
+    @Override
+    public UUID getUUID(UUID external) {
+        return master.getUUID(external);
+    }
+
+    @Override
+    public UUID getExternalUUID(UUID internal) {
+        return master.getExternalUUID(internal);
+    }
+}
@@ -1,136 +1,141 @@
+/*
+ * 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.commands;

+import com.google.common.collect.ImmutableList;
+import lombok.AllArgsConstructor;
 import lombok.Getter;
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.api.data.Callback;
 import me.lucko.luckperms.commands.group.CreateGroup;
 import me.lucko.luckperms.commands.group.DeleteGroup;
 import me.lucko.luckperms.commands.group.GroupMainCommand;
 import me.lucko.luckperms.commands.group.ListGroups;
-import me.lucko.luckperms.commands.group.subcommands.*;
-import me.lucko.luckperms.commands.misc.DebugCommand;
-import me.lucko.luckperms.commands.misc.InfoCommand;
-import me.lucko.luckperms.commands.misc.SyncCommand;
+import me.lucko.luckperms.commands.log.LogMainCommand;
+import me.lucko.luckperms.commands.migration.MigrationMainCommand;
+import me.lucko.luckperms.commands.misc.*;
 import me.lucko.luckperms.commands.track.CreateTrack;
 import me.lucko.luckperms.commands.track.DeleteTrack;
 import me.lucko.luckperms.commands.track.ListTracks;
 import me.lucko.luckperms.commands.track.TrackMainCommand;
-import me.lucko.luckperms.commands.track.subcommands.*;
 import me.lucko.luckperms.commands.user.UserMainCommand;
-import me.lucko.luckperms.commands.user.subcommands.*;
 import me.lucko.luckperms.constants.Message;

 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.Optional;
-import java.util.logging.Level;
 import java.util.stream.Collectors;

+@AllArgsConstructor
 public class CommandManager {
    private final LuckPermsPlugin plugin;

    @Getter
-    private final List<MainCommand> mainCommands = new ArrayList<>();
+    private final List<MainCommand> mainCommands = ImmutableList.<MainCommand>builder()
+            .add(new UserMainCommand())
+            .add(new GroupMainCommand())
+            .add(new TrackMainCommand())
+            .add(new LogMainCommand())
+            .add(new SyncCommand())
+            .add(new InfoCommand())
+            .add(new DebugCommand())
+            .add(new ImportCommand())
+            .add(new QueueCommand())
+            .add(new MigrationMainCommand())
+            .add(new CreateGroup())
+            .add(new DeleteGroup())
+            .add(new ListGroups())
+            .add(new CreateTrack())
+            .add(new DeleteTrack())
+            .add(new ListTracks())
+            .build();

-    public CommandManager(LuckPermsPlugin plugin) {
-        this.plugin = plugin;

-        UserMainCommand userCommand = new UserMainCommand();
-        this.registerMainCommand(userCommand);
-        userCommand.registerSubCommand(new UserInfo());
-        userCommand.registerSubCommand(new UserGetUUID());
-        userCommand.registerSubCommand(new UserListNodes());
-        userCommand.registerSubCommand(new UserHasPerm());
-        userCommand.registerSubCommand(new UserInheritsPerm());
-        userCommand.registerSubCommand(new UserSetPermission());
-        userCommand.registerSubCommand(new UserUnSetPermission());
-        userCommand.registerSubCommand(new UserAddGroup());
-        userCommand.registerSubCommand(new UserRemoveGroup());
-        userCommand.registerSubCommand(new UserSetTempPermission());
-        userCommand.registerSubCommand(new UserUnsetTempPermission());
-        userCommand.registerSubCommand(new UserAddTempGroup());
-        userCommand.registerSubCommand(new UserRemoveTempGroup());
-        userCommand.registerSubCommand(new UserSetPrimaryGroup());
-        userCommand.registerSubCommand(new UserShowTracks());
-        userCommand.registerSubCommand(new UserPromote());
-        userCommand.registerSubCommand(new UserDemote());
-        userCommand.registerSubCommand(new UserShowPos());
-        userCommand.registerSubCommand(new UserClear());
-
-        GroupMainCommand groupCommand = new GroupMainCommand();
-        this.registerMainCommand(groupCommand);
-        groupCommand.registerSubCommand(new GroupInfo());
-        groupCommand.registerSubCommand(new GroupListNodes());
-        groupCommand.registerSubCommand(new GroupHasPerm());
-        groupCommand.registerSubCommand(new GroupInheritsPerm());
-        groupCommand.registerSubCommand(new GroupSetPermission());
-        groupCommand.registerSubCommand(new GroupUnSetPermission());
-        groupCommand.registerSubCommand(new GroupSetInherit());
-        groupCommand.registerSubCommand(new GroupUnsetInherit());
-        groupCommand.registerSubCommand(new GroupSetTempPermission());
-        groupCommand.registerSubCommand(new GroupUnsetTempPermission());
-        groupCommand.registerSubCommand(new GroupSetTempInherit());
-        groupCommand.registerSubCommand(new GroupUnsetTempInherit());
-        groupCommand.registerSubCommand(new GroupShowTracks());
-        groupCommand.registerSubCommand(new GroupClear());
-
-        TrackMainCommand trackCommand = new TrackMainCommand();
-        this.registerMainCommand(trackCommand);
-        trackCommand.registerSubCommand(new TrackInfo());
-        trackCommand.registerSubCommand(new TrackAppend());
-        trackCommand.registerSubCommand(new TrackInsert());
-        trackCommand.registerSubCommand(new TrackRemove());
-        trackCommand.registerSubCommand(new TrackClear());
-
-        this.registerMainCommand(new SyncCommand());
-        this.registerMainCommand(new InfoCommand());
-        this.registerMainCommand(new DebugCommand());
-        this.registerMainCommand(new CreateGroup());
-        this.registerMainCommand(new DeleteGroup());
-        this.registerMainCommand(new ListGroups());
-        this.registerMainCommand(new CreateTrack());
-        this.registerMainCommand(new DeleteTrack());
-        this.registerMainCommand(new ListTracks());
+    /**
+     * Generic on command method to be called from the command executor object of the platform
+     * Unlike {@link #onCommand(Sender, String, List)}, this method is called in a new thread
+     * @param sender who sent the command
+     * @param label the command label used
+     * @param args the arguments provided
+     * @param result the callback to be called when the command has fully executed
+     */
+    public void onCommand(Sender sender, String label, List<String> args, Callback<CommandResult> result) {
+        plugin.doAsync(() -> {
+            CommandResult r = onCommand(sender, label, args);
+            plugin.doSync(() -> result.onComplete(r));
+        });
    }

    /**
     * Generic on command method to be called from the command executor object of the platform
     * @param sender who sent the command
+     * @param label the command label used
     * @param args the arguments provided
-     * @return if the command was successful (hint: it always is :> )
+     * @return if the command was successful
     */
-    public boolean onCommand(Sender sender, String label, List<String> args) {
+    public CommandResult onCommand(Sender sender, String label, List<String> args) {
        if (args.size() == 0) {
            sendCommandUsage(sender, label);
-            return true;
+            return CommandResult.INVALID_ARGS;
        }

-        Optional<MainCommand> o = mainCommands.stream().filter(m -> m.getName().equalsIgnoreCase(args.get(0))).limit(1).findAny();
+        Optional<MainCommand> o = mainCommands.stream()
+                .filter(m -> m.getName().equalsIgnoreCase(args.get(0)))
+                .limit(1)
+                .findAny();

        if (!o.isPresent()) {
            sendCommandUsage(sender, label);
-            return true;
+            return CommandResult.INVALID_ARGS;
        }

        final MainCommand main = o.get();
-        if (!main.canUse(sender)) {
+        if (!main.isAuthorized(sender)) {
            sendCommandUsage(sender, label);
-            return true;
+            return CommandResult.NO_PERMISSION;
        }

        if (main.getRequiredArgsLength() == 0) {
-            main.execute(plugin, sender, null, label);
-            return true;
+            try {
+                return main.execute(plugin, sender, null, label);
+            } catch (Exception e) {
+                e.printStackTrace();
+                return CommandResult.FAILURE;
+            }
        }

        if (args.size() == 1) {
            main.sendUsage(sender, label);
-            return true;
+            return CommandResult.INVALID_ARGS;
        }

-        main.execute(plugin, sender, new ArrayList<>(args.subList(1, args.size())), label);
-        return true;
-
+        try {
+            return main.execute(plugin, sender, new ArrayList<>(args.subList(1, args.size())), label);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return CommandResult.FAILURE;
+        }
    }

    /**
@@ -139,18 +144,30 @@ public class CommandManager {
     * @param args the arguments provided so far
     * @return a list of suggestions
     */
+    @SuppressWarnings("unchecked")
    public List<String> onTabComplete(Sender sender, List<String> args) {
-        final List<MainCommand> mains = mainCommands.stream().filter(m -> m.canUse(sender)).collect(Collectors.toList());
+        final List<MainCommand> mains = mainCommands.stream()
+                .filter(m -> m.isAuthorized(sender))
+                .collect(Collectors.toList());

        if (args.size() <= 1) {
            if (args.isEmpty() || args.get(0).equalsIgnoreCase("")) {
-                return mains.stream().map(MainCommand::getName).map(String::toLowerCase).collect(Collectors.toList());
+                return mains.stream()
+                        .map(m -> m.getName().toLowerCase())
+                        .collect(Collectors.toList());
            }

-            return mains.stream().map(MainCommand::getName).map(String::toLowerCase).filter(s -> s.startsWith(args.get(0).toLowerCase())).collect(Collectors.toList());
+            return mains.stream()
+                    .map(m -> m.getName().toLowerCase())
+                    .filter(s -> s.startsWith(args.get(0).toLowerCase()))
+                    .collect(Collectors.toList());
        }

-        Optional<MainCommand> o = mains.stream().filter(m -> m.getName().equalsIgnoreCase(args.get(0))).limit(1).findAny();
+        Optional<MainCommand> o = mains.stream()
+                .filter(m -> m.getName().equalsIgnoreCase(args.get(0)))
+                .limit(1)
+                .findAny();
+
        if (!o.isPresent()) {
            return Collections.emptyList();
        }
@@ -158,16 +175,11 @@ public class CommandManager {
        return o.get().onTabComplete(sender, args.subList(1, args.size()), plugin);
    }

-    private void registerMainCommand(MainCommand command) {
-        plugin.getLogger().log(Level.INFO, "[CommandManager] Registered main command '" + command.getName() + "'");
-        mainCommands.add(command);
-    }
-
    private void sendCommandUsage(Sender sender, String label) {
        Message.INFO_BRIEF.send(sender, plugin.getVersion());

        mainCommands.stream()
-                .filter(c -> c.canUse(sender))
+                .filter(c -> c.isAuthorized(sender))
                .forEach(c -> Util.sendPluginMessage(sender, "&e-> &d" + String.format(c.getUsage(), label)));
    }
 }
@@ -0,0 +1,47 @@
+/*
+ * 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.commands;
+
+import lombok.AllArgsConstructor;
+
+@AllArgsConstructor
+public enum CommandResult {
+    SUCCESS(true),
+    FAILURE(false),
+
+    LOADING_ERROR(false),
+    STATE_ERROR(false),
+    INVALID_ARGS(false),
+    NO_PERMISSION(false);
+
+    private boolean booleanValue;
+
+    public boolean booleanValue() {
+        return booleanValue;
+    }
+
+    static CommandResult of(boolean b) {
+        return b ? SUCCESS : FAILURE;
+    }
+
+}
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.commands;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Executes commands consecutively
+ */
+@RequiredArgsConstructor
+public class ConsecutiveExecutor implements Runnable {
+    private final CommandManager manager;
+
+    private final List<QueuedCommand> commands = new ArrayList<>();
+
+    public void queueCommand(QueuedCommand command) {
+        synchronized (commands) {
+            commands.add(command);
+        }
+    }
+
+    @Override
+    public void run() {
+        final List<QueuedCommand> toExecute = new ArrayList<>();
+        synchronized (commands) {
+            toExecute.addAll(commands);
+            commands.clear();
+        }
+
+        if (toExecute.isEmpty()) {
+            return;
+        }
+
+        for (QueuedCommand command : toExecute) {
+            manager.onCommand(command.getSender(), "perms", command.getArgs());
+        }
+
+    }
+
+    @Getter
+    @AllArgsConstructor
+    public static class QueuedCommand {
+        private final Sender sender;
+        private final List<String> args;
+    }
+
+}
@@ -1,10 +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.commands;

+import com.google.common.collect.ImmutableList;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 import me.lucko.luckperms.LuckPermsPlugin;
 import me.lucko.luckperms.constants.Message;

+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.Optional;
@@ -12,23 +36,115 @@ import java.util.stream.Collectors;

@Getter
@AllArgsConstructor
-public abstract class MainCommand {
+public abstract class MainCommand<T> {

+    /**
+     * The name of the main command
+     */
    private final String name;
+
+    /**
+     * The command usage
+     */
    private final String usage;
+
+    /**
+     * How many arguments are required for the command to run
+     */
    private final int requiredArgsLength;

-    protected abstract void execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label);
-    protected abstract List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin);
-    public abstract List<? extends SubCommand> getSubCommands();
+    /**
+     * A list of the sub commands under this main command
+     */
+    @Getter
+    private final List<SubCommand<T>> subCommands;

+    MainCommand(String name, String usage, int requiredArgsLength) {
+        this(name, usage, requiredArgsLength, ImmutableList.of());
+    }
+
+    /**
+     * Called when this main command is ran
+     * @param plugin a link to the main plugin instance
+     * @param sender the sender to executed the command
+     * @param args the stripped arguments given
+     * @param label the command label used
+     */
+    protected CommandResult execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
+        if (args.size() < requiredArgsLength) {
+            sendUsage(sender, label);
+            return CommandResult.INVALID_ARGS;
+        }
+
+        Optional<SubCommand<T>> o = getSubCommands().stream()
+                .filter(s -> s.getName().equalsIgnoreCase(args.get(requiredArgsLength - 1)))
+                .limit(1)
+                .findAny();
+
+        if (!o.isPresent()) {
+            Message.COMMAND_NOT_RECOGNISED.send(sender);
+            return CommandResult.INVALID_ARGS;
+        }
+
+        final SubCommand<T> sub = o.get();
+        if (!sub.isAuthorized(sender)) {
+            Message.COMMAND_NO_PERMISSION.send(sender);
+            return CommandResult.NO_PERMISSION;
+        }
+
+        List<String> strippedArgs = new ArrayList<>();
+        if (args.size() > requiredArgsLength) {
+            strippedArgs.addAll(args.subList(requiredArgsLength, args.size()));
+        }
+
+        if (sub.getIsArgumentInvalid().test(strippedArgs.size())) {
+            sub.sendUsage(sender, label);
+            return CommandResult.INVALID_ARGS;
+        }
+
+        final String name = args.get(0).toLowerCase();
+        T t = getTarget(name, plugin, sender);
+        if (t != null) {
+            CommandResult result = sub.execute(plugin, sender, t, strippedArgs, label);
+            cleanup(t, plugin);
+            return result;
+        }
+
+        return CommandResult.LOADING_ERROR;
+    }
+
+    /**
+     * Gets the object the command is acting upon, and runs the callback if successful
+     * @param target the name of the object to be looked up
+     * @param plugin a link to the main plugin instance
+     * @param sender the user who send the command (used to send error messages if the lookup was unsuccessful)
+     */
+    protected abstract T getTarget(String target, LuckPermsPlugin plugin, Sender sender);
+
+    protected abstract void cleanup(T t, LuckPermsPlugin plugin);
+
+    /**
+     * Get a list of {@link T} objects for tab completion
+     * @param plugin a link to the main plugin instance
+     * @return a list of strings
+     */
+    protected abstract List<String> getObjects(LuckPermsPlugin plugin);
+
+    /**
+     * Send the command usage to a sender
+     * @param sender the sender to send the usage to
+     * @param label the command label used
+     */
    protected void sendUsage(Sender sender, String label) {
        if (getSubCommands().isEmpty()) {
            Util.sendPluginMessage(sender, "&e-> &d" + String.format(getUsage(), label));
            return;
        }

-        List<SubCommand> subs = getSubCommands().stream().filter(s -> s.isAuthorized(sender)).collect(Collectors.toList());
+        List<SubCommand> subs = getSubCommands().stream()
+                .filter(s -> s.isAuthorized(sender))
+                .collect(Collectors.toList());
+
        if (subs.size() > 0) {
            Util.sendPluginMessage(sender, "&e" + getName() + " Sub Commands:");

@@ -41,26 +157,54 @@ public abstract class MainCommand {
        }
    }

-    protected boolean canUse(Sender sender) {
+    /**
+     * If a sender has permission to use this command
+     * @param sender the sender trying to use the command
+     * @return true if the sender can use the command
+     */
+    protected boolean isAuthorized(Sender sender) {
        return getSubCommands().stream().filter(sc -> sc.isAuthorized(sender)).count() != 0;
    }

-    protected List<String> onAbstractTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
-        final List<SubCommand> subs = getSubCommands().stream().filter(s -> s.isAuthorized(sender)).collect(Collectors.toList());
-        if (args.size() == 2) {
-            if (args.get(1).equalsIgnoreCase("")) {
-                return subs.stream().map(SubCommand::getName).map(String::toLowerCase).collect(Collectors.toList());
+    protected List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+        final List<String> objects = getObjects(plugin);
+
+        if (args.size() <= 1) {
+            if (args.isEmpty() || args.get(0).equalsIgnoreCase("")) {
+                return objects;
            }

-            return subs.stream().map(SubCommand::getName).map(String::toLowerCase)
-                    .filter(s -> s.toLowerCase().startsWith(args.get(1).toLowerCase())).collect(Collectors.toList());
+            return objects.stream()
+                    .filter(s -> s.toLowerCase().startsWith(args.get(0).toLowerCase()))
+                    .collect(Collectors.toList());
        }

-        Optional<SubCommand> o = subs.stream().filter(s -> s.getName().equalsIgnoreCase(args.get(1))).limit(1).findAny();
+        final List<SubCommand<T>> subs = getSubCommands().stream()
+                .filter(s -> s.isAuthorized(sender))
+                .collect(Collectors.toList());
+
+        if (args.size() == 2) {
+            if (args.get(1).equalsIgnoreCase("")) {
+                return subs.stream()
+                        .map(m -> m.getName().toLowerCase())
+                        .collect(Collectors.toList());
+            }
+
+            return subs.stream()
+                    .map(m -> m.getName().toLowerCase())
+                    .filter(s -> s.toLowerCase().startsWith(args.get(1).toLowerCase()))
+                    .collect(Collectors.toList());
+        }
+
+        Optional<SubCommand<T>> o = subs.stream()
+                .filter(s -> s.getName().equalsIgnoreCase(args.get(1)))
+                .limit(1)
+                .findAny();
+
        if (!o.isPresent()) {
            return Collections.emptyList();
        }

-        return o.get().onTabComplete(sender, args.subList(2, args.size()), plugin);
+        return o.get().onTabComplete(plugin, sender, args.subList(2, args.size()));
    }
 }
@@ -0,0 +1,76 @@
+/*
+ * 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.commands;
+
+import lombok.experimental.UtilityClass;
+
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+@SuppressWarnings({"WeakerAccess", "unused"})
+@UtilityClass
+public class Predicate {
+    public static <T> java.util.function.Predicate<T> alwaysFalse() {
+        return t -> false;
+    }
+
+    public static <T> java.util.function.Predicate<T> alwaysTrue() {
+        return t -> true;
+    }
+
+    public static java.util.function.Predicate<Integer> notInRange(Integer start, Integer end) {
+        return inverse(inRange(start, end));
+    }
+
+    public static java.util.function.Predicate<Integer> inRange(Integer start, Integer end) {
+        return isOneOf(IntStream.rangeClosed(start, end).boxed().collect(Collectors.toSet()));
+    }
+
+    public static <T> java.util.function.Predicate<T> notOneOf(Set<T> ts) {
+        return inverse(isOneOf(ts));
+    }
+
+    public static <T> java.util.function.Predicate<T> isOneOf(Set<T> ta) {
+        return t -> {
+            for (T i : ta) {
+                if (i == t) {
+                    return true;
+                }
+            }
+            return false;
+        };
+    }
+
+    public static <T> java.util.function.Predicate<T> not(T t) {
+        return inverse(is(t));
+    }
+
+    public static <T> java.util.function.Predicate<T> is(T t) {
+        return t2 -> t == t2;
+    }
+
+    public static <T> java.util.function.Predicate<T> inverse(java.util.function.Predicate<T> t) {
+        return t2 -> !t.test(t2);
+    }
+}
@@ -1,8 +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.commands;

+import me.lucko.luckperms.constants.Permission;
+
+import java.util.UUID;
+
+/**
+ * Wrapper interface to represent a CommandSender/CommandSource within the luckperms-common command implementations.
+ */
 public interface Sender {

+    String getName();
+    UUID getUuid();
    void sendMessage(String s);
-    boolean hasPermission(String node);
+    boolean hasPermission(Permission permission);

 }
Author	SHA1	Message	Date
Luck	60bcd5f643	Release 2.7	2016-09-05 20:00:01 +01:00
Luck	ba04fb320b	Remove unnecessary reflection	2016-09-05 16:44:59 +01:00
Luck	770b7dc282	Fix permissions not being removed on Sponge	2016-09-04 17:59:01 +01:00
Luck	ed85eee36c	Fix inherited permissions not applying on Sponge	2016-09-04 16:25:10 +01:00
Luck	23df8a2df8	Some small fixes	2016-09-04 16:24:36 +01:00
Luck	36cd388607	Slight re-wording	2016-09-03 21:34:35 +01:00
Luck	4d48ef1939	Add comment about Paper's "bungee-online-mode" option. Resolves #6	2016-09-03 21:30:37 +01:00
Luck	7970e2a1c6	Add bPermissions migration	2016-09-03 18:15:52 +01:00
Luck	cee96d7daa	make SenderFactory nicer & maybe faster	2016-09-03 00:14:40 +01:00
Luck	861c1ddd69	remove #childInit	2016-09-02 19:19:22 +01:00
Luck	5dec5a54cb	Add YAML storage support	2016-09-02 19:15:31 +01:00
Luck	5c760aabd4	Fire PermissionRefreshEvent after the nodes have actually updated	2016-09-01 13:00:22 +01:00
Luck	1a2fa5d8c3	Fix log notify	2016-08-31 21:02:06 +01:00
Luck	ef0c53da82	fix formatting	2016-08-31 09:38:47 +01:00
Luck	3fd62a80e2	Add support for split storage	2016-08-31 09:30:19 +01:00
Luck	5c19dd8b15	.-.	2016-08-30 22:38:08 +01:00
Luck	1fc88e147f	Make output of listnodes nicer	2016-08-30 18:04:30 +01:00
Luck	9b4bbe0500	Make log notifications toggleable	2016-08-30 16:02:01 +01:00
Luck	b37fdd3619	Add user to group instead of failing in setprimarygroup command	2016-08-30 13:23:48 +01:00
Luck	ab00c41452	Fix NPE, and properly send possible permissions in BukkitUser	2016-08-30 13:06:36 +01:00
Luck	c15727377b	Apply single '*' wildcard	2016-08-30 12:49:46 +01:00
Luck	1e6f32bdc4	Add extra disallowed character	2016-08-30 11:54:18 +01:00
Luck	42e69c98a7	Change name limitation to be more flexible	2016-08-30 11:52:32 +01:00
Luck	a217727bb4	Match negative priorities and fix PEX weight migration	2016-08-30 11:04:34 +01:00
Luck	ba10b1c06e	Fix removal of temporary nodes	2016-08-30 10:22:55 +01:00
Luck	075ba33e8b	Add prefix/suffix/meta commands	2016-08-30 10:22:25 +01:00
Luck	19dbc7d90a	formatting pls	2016-08-30 07:47:52 +01:00
Boomclaw	ade70bb7ba	PEX migration carries weights of prefixes/suffixes of groups and individuals (#5 ) * PEX migration carries weights of prefixes/suffixes of groups and individuals. * Forgot to increase maxGroupWeight.	2016-08-29 22:45:19 +01:00
Luck	4b67913eee	getGroup methods should not include inherited groups	2016-08-29 22:03:10 +01:00
Luck	75858c1555	Use new Node system in #getGroups	2016-08-29 21:38:47 +01:00
Luck	659baaf5fb	Make #getPlayerGroups return global too	2016-08-29 21:35:11 +01:00
Luck	3c83c578eb	Fix typo	2016-08-29 18:40:37 +01:00
Luck	3ddbf1da87	Migrate PEX primary groups	2016-08-29 17:57:47 +01:00
Luck	35cb5b81dc	hopefully fix server stopped responding error with SkipListSet	2016-08-29 16:28:36 +01:00
Luck	02d9b996a7	woops	2016-08-29 15:51:19 +01:00
Luck	d4cf6a5ad7	Remove subjects from cache when they leave the server	2016-08-29 13:32:21 +01:00
Luck	9fdb4fa25f	Maybe fix sponge permissions not expiring	2016-08-29 13:02:56 +01:00
Luck	d5bc1cdf5d	Fix not clearing user's permissions, and issue with unsetting permissions	2016-08-29 12:53:05 +01:00
Luck	f5995c0afa	Fix usernames showing as "null" and NPE related to primaryGroup not copying correctly	2016-08-29 12:11:03 +01:00
Luck	2cc65160b4	Bump release version	2016-08-28 22:12:34 +01:00
Luck	57f5a7c4cd	Release 1.6	2016-08-28 22:05:10 +01:00
Luck	6aea3b53f3	Only save unique users	2016-08-28 21:36:16 +01:00
Luck	9f5e194a6e	bug fixes	2016-08-28 17:43:02 +01:00
Luck	0831585a27	Fix SQL datastore	2016-08-28 15:43:21 +01:00
Luck	b2cf6dce2d	Prepare for 1.6 release	2016-08-28 15:29:02 +01:00
Luck	a3ebf86f6b	More progress towards 1.6: implement PermissionService	2016-08-28 14:57:03 +01:00
Luck	2a305b1c55	More progress towards 1.6: add transient permissions	2016-08-27 22:01:17 +01:00
Luck	2ea9b36c77	Build against Sponge API 5.0.0	2016-08-27 16:59:00 +01:00
Luck	edaf174ebf	Complete refactor of permissions/nodes. progress towards 1.6	2016-08-27 00:32:39 +01:00
Luck	c4497db06c	progress towards permissionservice	2016-08-26 16:58:47 +01:00
Luck	9873415303	Fix NPE	2016-08-25 18:07:50 +01:00
Luck	2b71476cfe	Implement ConsecutiveExecutor	2016-08-25 18:07:32 +01:00
Luck	44d14001e1	Partially implement PermissionService	2016-08-25 17:23:27 +01:00
Luck	de5fda6a18	Add some extra debugging output to PP migration	2016-08-25 01:31:38 +01:00
Luck	8b83a1d9a2	Fix sponge startup exception	2016-08-24 22:38:52 +01:00
Luck	c0a0239eeb	Update readme	2016-08-24 10:24:37 +01:00
Luck	84f377451e	Make placeholder identifier lowercase	2016-08-23 20:11:53 +01:00
Luck	21d0c9ab0e	Add some PlaceholderAPI placeholders	2016-08-23 19:32:58 +01:00
Luck	f9c1cdb4bd	Add group and track rename commands	2016-08-23 15:52:51 +01:00
Luck	e89444141b	Add logging for the migration processes	2016-08-23 15:18:20 +01:00
Luck	9cd4e01d8e	Copy prefixes and suffixes during migration processes	2016-08-23 12:36:20 +01:00
Luck	f7fa08d5e9	Call #recalculatePermissions on the main thread	2016-08-23 12:10:11 +01:00
Luck	7a4135319f	Convert PermissionAttachment to use ConcurrentMap, and do refreshPermissions async	2016-08-22 22:39:40 +01:00
Luck	41fca40a36	Add some null / arg checks to Vault chat impl	2016-08-22 21:12:42 +01:00
Luck	9dbfa76b26	Add Vault chat support using permission nodes	2016-08-22 20:59:52 +01:00
Luck	20eeade06f	Migration for BungeePerms	2016-08-22 19:46:37 +01:00
Luck	cd9f18ffdb	Properly close DB objects once PP migration is complete	2016-08-22 17:01:41 +01:00
Luck	f7baf67985	Improvements to the JavaDocs in the API	2016-08-22 15:50:20 +01:00
Luck	692bf30cf5	Attempt to fix PermissionsEx migration	2016-08-22 07:07:13 +01:00
Luck	41b33fbd7a	Fix typo	2016-08-22 00:22:06 +01:00
Luck	5dc551c05d	Complete the migration system	2016-08-21 23:31:38 +01:00
Luck	dd7aee9d15	Partially add migration support	2016-08-21 22:20:14 +01:00
Luck	bbeed1e4ed	A few small fixes	2016-08-20 17:49:23 +01:00
Luck	471084a9ef	Fix NPE	2016-08-20 16:29:59 +01:00
Luck	6fc00976a0	Fire PermRefreshEvent in sponge too	2016-08-20 16:26:32 +01:00
Luck	4aa753515d	Add events	2016-08-20 15:43:54 +01:00
Luck	7e933966cf	revert remove sources	2016-08-20 02:19:03 +01:00
Luck	b4d179f7b2	use a proper repo instead of the rubbish jenkins one	2016-08-20 01:39:19 +01:00
Luck	a51acdbc88	remove sources	2016-08-19 22:23:28 +01:00
Luck	52e63a228d	Update readme	2016-08-19 21:54:40 +01:00
Luck	9424d2d2ba	Process shorthand in server/world names	2016-08-19 19:36:04 +01:00
Luck	0c12eebe6f	Check temporary permissions separately to the sync task	2016-08-19 19:10:36 +01:00
Luck	a15a0752f4	Add support for MongoDB and H2 database formats	2016-08-19 18:21:16 +01:00
Luck	31cef46b56	Fix sponge tab complete, fix bungee listeners & change some messages	2016-08-18 20:14:12 +01:00
Luck	bfe0126816	fix format	2016-08-18 13:52:38 +01:00
Luck	98b56691dd	Allow expiry timestamp for temporary assignment args	2016-08-18 13:51:31 +01:00
Luck	6451175d0e	Fix some broken messages	2016-08-18 12:47:33 +01:00
Luck	9b4319c42d	fix readme	2016-08-18 12:33:46 +01:00
Luck	e9e7d81ddf	Add import/export support	2016-08-18 12:30:51 +01:00
Luck	84afbf26f8	refactor LogEntry & cleanup stream formatting	2016-08-18 00:07:56 +01:00
Luck	ca9037461a	remove lombok from api and attach sources	2016-08-15 16:09:16 +02:00
Luck	9a3eeca411	idk	2016-08-15 12:06:36 +02:00
Luck	e216c235ce	Add logging, prepare for import/export system	2016-08-15 01:51:38 +02:00
Luck	fbf062933f	Fix build	2016-08-09 13:52:25 +02:00
Luck	cf85f31da8	Bump minor version	2016-08-09 11:13:01 +02:00
Luck	b70b6f8af1	Add support for regex permissions/servers/worlds and shorthand permissions	2016-08-09 11:09:45 +02:00
Luck	90e074d3ab	Apply bukkit permissions directly, fix sponge listener, other misc changes/fixes	2016-08-07 17:10:37 +02:00
Luck	e14ea73626	Add wildcard permissions	2016-08-07 01:16:05 +02:00
Luck	e07b677632	Update readme	2016-08-06 19:47:39 +02:00
Luck	4e7547c92e	Add proper versioning, bump to 2.0	2016-08-06 18:28:38 +02:00
Luck	8483e78082	Add license headers	2016-08-06 14:36:56 +02:00
Luck	4ca1e26f0f	Set version on build in sponge plugin	2016-08-06 12:25:23 +02:00
Luck	d88657f369	Add more stuff to api	2016-08-06 11:04:06 +02:00
Luck	caf03379f2	Move stuff into commons, rename PermissionObject, add more javadocs to api	2016-08-06 00:11:00 +02:00
Luck	03450c3339	Sponge support	2016-08-05 12:58:27 +02:00
Luck	56e11b8b85	Various small changes	2016-08-03 12:08:10 +02:00
Luck	5e23b6961e	Use generics for sub commands, fix user lookup bugs	2016-08-03 00:54:50 +02:00
Luck	98c5a91beb	Update readme	2016-08-02 15:12:06 +02:00
Luck	d6cd0b162b	Update vault version	2016-08-02 11:17:52 +02:00
Luck	1c064daccb	Fix build	2016-08-02 10:56:15 +02:00
Luck	0cfdd8c862	Remove slow vault-repo, fix long build time	2016-08-02 10:54:16 +02:00
Luck	a9619bc08c	small fix	2016-08-02 00:50:47 +02:00
Luck	a7a84952fe	Update readme	2016-08-02 00:20:49 +02:00
Luck	9c867dee28	Revert message colorization	2016-07-26 15:53:15 +01:00
Luck	db862b38c9	Fix version tags	2016-07-26 10:19:33 +01:00
Luck	cba12c3e78	Update readme	2016-07-26 03:39:56 +01:00
Luck	0ecd899ec5	Fix bad javadoc issues	2016-07-26 03:12:27 +01:00
Luck	e9805b7532	Remove travis	2016-07-26 02:23:16 +01:00
Luck	c000b9c009	Update build	2016-07-26 02:21:51 +01:00
Luck	8f6435b9e8	Try to add travis	2016-07-25 22:08:08 +01:00
Luck	a3604c7464	Bump version, and make future version changes easier	2016-07-25 21:05:09 +01:00
Luck	10574748ff	Add inheritance methods to Group	2016-07-25 20:44:01 +01:00
Luck	c7336dbcad	Change Vault hook to use new per-world perms system	2016-07-25 20:20:51 +01:00
Luck	ebeb69dd3a	Per-world permissions	2016-07-25 18:19:36 +01:00
Luck	9ad40be210	Add complete offline-mode support	2016-07-25 11:18:35 +01:00
Luck	df209f6515	Fix possible race condition	2016-07-23 22:34:42 +01:00
Luck	d32d6b5474	Generics are cool	2016-07-23 21:57:19 +01:00
Luck	623b7b775c	Fix readme markdown	2016-07-22 12:27:50 +01:00
Luck	b3b687d9b7	Add Api	2016-07-21 21:40:24 +01:00
Luck	a413c0a50a	Cleanup & multiple small fixes	2016-07-21 14:15:14 +01:00
Luck	1870893fe1	Fix promotions/demotions	2016-07-19 17:10:40 +01:00
Luck	f24562c642	Fix compile	2016-07-19 13:02:54 +01:00