Release 1.6

LICENSE.md

@@ -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

README.md

@@ -1,28 +1,17 @@
-# LuckPerms
-A quite possibly shit™ permissions implementation for Bukkit/BungeeCord.
+# 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.
 
-### Why?
-Yeah, I don't know. There are other more advanced, optimized, better programmed and thoroughly tested alternative plugins around, you should probably use those instead. I just wanted some specific features, and something that was compatible with BungeeCord.
+## Links
+* **Development Builds** - <https://ci.lucko.me/job/LuckPerms>
+* **Javadocs** - <https://jd.lucko.me/LuckPerms>
+* **Wiki** - <https://github.com/lucko/LuckPerms/wiki>
 
-### Features
- - **Group inheritance** - users can be members of multiple groups, groups can inherit other groups
- - **Multi-server support** - data is synced across all servers/platforms
- - **Per-server permissions/groups** - define permissions that only apply on certain servers
- - **Vault Support** - hooks into Vault to integrate with other plugins
- - **Everything is configured using commands** - no editing yml files, yuck
- - **Efficient** - maybe? Who knows, it might be.
- - **BungeeCord compatible** - my main motive for making this was that all other Bungee/Bukkit compatible perms plugins are utter aids. (At least, I couldn't find any decent ones)
+## 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.
 
-### Caveats
- - Only supports MySQL
- - Not at all tested and could be super unreliable
- - It's quite possibly shit™
+## 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._
 
-So, not anything major, really ¯\ _(ツ)_ /¯
-
-### Commands
-Command usage is printed when you supply too little arguments.
-
-Bukkit: `/luckperms` `/perms` `/permissions` `/lp` `/perm`
-
-Bungee: `/luckpermsbungee` `/bperms` `/bpermissions` `/lpb` `/bperm`
+## License
+See LICENSE.md.

api/pom.xml

@@ -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.6-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>

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

@@ -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.");
+    }
+
+}

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

@@ -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;
+
+/**
+ * Wrapper 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 1.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 1.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 1.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);
+    }
+}

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

@@ -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;
+
+/**
+ * Wrapper 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);
+}

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

@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api;
+
+import me.lucko.luckperms.api.data.DatastoreConfiguration;
+import me.lucko.luckperms.api.data.MySQLConfiguration;
+
+/**
+ * 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 1.6, the default group is always "default"
+     */
+    @Deprecated
+    String getDefaultGroupNode();
+
+    /**
+     * @return the name of the default group
+     * @deprecated as of 1.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 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();
+
+}

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

@@ -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);
+}

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

@@ -0,0 +1,318 @@
+/*
+ * 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
+ */
+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() + ")";
+        }
+    }
+
+}

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

@@ -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 class 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);
+
+}

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

@@ -0,0 +1,215 @@
+/*
+ * 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 1.6
+     */
+    double getApiVersion();
+
+    /**
+     * @return the version of the plugin running on the platform
+     */
+    String getVersion();
+
+    /**
+     * 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 1.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 1.6
+     */
+    Node.Builder buildNode(String permission) throws IllegalArgumentException;
+
+}

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

@@ -0,0 +1,281 @@
+/*
+ * 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 1.6
+ */
+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);
+
+    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();
+    }
+
+}

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

@@ -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;
+
+/**
+ * Wrapper 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 1.6
+     */
+    SortedSet<Node> getPermissions();
+
+    /**
+     * Similar to {@link #getPermissions()}, except excluding transient permissions
+     * @return a set of nodes
+     * @since 1.6
+     */
+    Set<Node> getEnduringPermissions();
+
+    /**
+     * Similar to {@link #getPermissions()}, except excluding non-transient permissions
+     * @return a set of nodes
+     * @since 1.6
+     */
+    Set<Node> getTransientPermissions();
+
+
+    /**
+     * Gets an immutable set of the nodes that this object has and inherits
+     * @return an immutable set of permissions
+     * @since 1.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 1.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 1.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 1.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 1.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 1.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 1.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 1.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 1.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 1.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 1.6
+     */
+    Set<Node> getPermanentPermissionNodes();
+
+    /**
+     * Removes temporary permissions that have expired
+     */
+    void auditTemporaryPermissions();
+
+}

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

@@ -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;
+
+/**
+ * Wrapper 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();
+
+}

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

@@ -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;
+    }
+}

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

@@ -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;
+
+/**
+ * Wrapper 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);
+
+}

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

@@ -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;
+
+import java.util.UUID;
+
+/**
+ * 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.
+ */
+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);
+
+}

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

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.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;
+    }
+
+}

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

@@ -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();
+
+}

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

@@ -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();
+}

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

@@ -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;
+    }
+}

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

@@ -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 1.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;
+    }
+}

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

@@ -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;
+    }
+
+}

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

@@ -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;
+    }
+}

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

@@ -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;
+    }
+
+}

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

@@ -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 {
+}

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

@@ -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;
+    }
+}

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

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.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;
+    }
+}

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

@@ -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;
+    }
+}

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

@@ -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;
+    }
+}

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

@@ -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;
+    }
+}

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

@@ -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;
+    }
+
+}

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

@@ -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;
+    }
+}

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

@@ -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 1.6
+ */
+public class PermissionNodeExpireEvent extends AbstractPermissionEvent {
+    public PermissionNodeExpireEvent(PermissionHolder target, Node node) {
+        super("Permission Node Expire Event", target, node);
+    }
+}

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

@@ -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 1.6
+ */
+public class PermissionNodeSetEvent extends AbstractPermissionEvent {
+    public PermissionNodeSetEvent(PermissionHolder target, Node node) {
+        super("Permission Node Set Event", target, node);
+    }
+}

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

@@ -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 1.6
+ */
+public class PermissionNodeUnsetEvent extends AbstractPermissionEvent {
+    public PermissionNodeUnsetEvent(PermissionHolder target, Node node) {
+        super("Permission Node Unset Event", target, node);
+    }
+}

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

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.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);
+    }
+}

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

@@ -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;
+    }
+}

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

@@ -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");
+    }
+
+}

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

@@ -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");
+    }
+
+}

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

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.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);
+    }
+
+}

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

@@ -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;
+    }
+}

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

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.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);
+    }
+
+}

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

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.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);
+    }
+
+}

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

@@ -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 Exception {
+}

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

@@ -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 Exception {
+}

bukkit-placeholders/pom.xml

@@ -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.6-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>${project.version}</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>

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

@@ -0,0 +1,248 @@
+/*
+ * 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>
+ */
+@SuppressWarnings("deprecation")
+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 api == null ? "null" : api.getVersion();
+    }
+
+    @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);
+    }
+}

bukkit/pom.xml

@@ -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.0-SNAPSHOT</version>
+        <groupId>me.lucko.luckperms</groupId>
+        <version>2.6-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
     <artifactId>luckperms-bukkit</artifactId>
-    <version>1.0-SNAPSHOT</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>
@@ -28,7 +26,7 @@
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>
-                <version>3.2</version>
+                <version>3.5.1</version>
                 <configuration>
                     <source>1.8</source>
                     <target>1.8</target>
@@ -37,7 +35,7 @@
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-shade-plugin</artifactId>
-                <version>2.3</version>
+                <version>2.4.3</version>
                 <executions>
                     <execution>
                         <phase>package</phase>
@@ -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>

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

@@ -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));
+    }
+}

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

@@ -1,71 +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");
     }
 
-    private void create() {
-        File configFile = new File(plugin.getDataFolder(), "config.yml");
+    @SuppressWarnings("ResultOfMethodCallIgnored")
+    @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");
+    protected void set(String path, Object value) {
+        configuration.set(path, value);
     }
 
     @Override
-    public String getPrefix() {
-        return configuration.getString("prefix");
+    protected String getString(String path, String def) {
+        return configuration.getString(path, def);
     }
 
     @Override
-    public int getSyncTime() {
-        return configuration.getInt("sql.sync-minutes");
+    protected int getInt(String path, int def) {
+        return configuration.getInt(path, def);
     }
 
     @Override
-    public String getDefaultGroupNode() {
-        return "luckperms.group." + configuration.getString("default-group");
-    }
-
-    @Override
-    public String getDefaultGroupName() {
-        return configuration.getString("default-group");
-    }
-
-    @Override
-    public boolean getIncludeGlobalPerms() {
-        return configuration.getBoolean("include-global");
-    }
-
-    @Override
-    public String getDatabaseValue(String value) {
-        return configuration.getString("sql." + value);
+    protected boolean getBoolean(String path, boolean def) {
+        return configuration.getBoolean(path, def);
     }
 }

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

@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms;
+
+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.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()) {
+            // 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);
+            try {
+                BukkitUser.getPermissionsField().set(attachment, new ConcurrentHashMap<>());
+            } catch (Throwable t) {
+                t.printStackTrace();
+            }
+
+            u.setAttachment(attachment);
+        }
+
+        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());
+    }
+}

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

@@ -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);
+    }
+}

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

@@ -1,30 +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 java.util.Arrays;
-
-class CommandManagerBukkit extends CommandManager implements CommandExecutor {
-    CommandManagerBukkit(LuckPermsPlugin plugin) {
-        super(plugin);
-    }
-
-    @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        return onCommand(new Sender() {
-            @Override
-            public void sendMessage(String s) {
-                sender.sendMessage(s);
-            }
-
-            @Override
-            public boolean hasPermission(String node) {
-                return sender.hasPermission(node);
-            }
-        }, Arrays.asList(args));
-    }
-}

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

@@ -1,100 +1,178 @@
+/*
+ * 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.DatastoreConfiguration;
-import me.lucko.luckperms.data.HikariDatastore;
+import me.lucko.luckperms.api.Logger;
+import me.lucko.luckperms.api.LuckPermsApi;
+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 net.milkbowl.vault.permission.Permission;
-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.RegisteredServiceProvider;
 import org.bukkit.plugin.ServicePriority;
 import org.bukkit.plugin.java.JavaPlugin;
 
-import java.util.Arrays;
-import java.util.UUID;
+import java.io.File;
+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.0";
-
+    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"));
 
-        datastore = new HikariDatastore(this);
-        datastore.init(new DatastoreConfiguration(
-                configuration.getDatabaseValue("address"),
-                configuration.getDatabaseValue("database"),
-                configuration.getDatabaseValue("username"),
-                configuration.getDatabaseValue("password")
-        ));
+        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();
+        importer = new Importer(commandManager);
+        consecutiveExecutor = new ConsecutiveExecutor(commandManager);
 
         int mins = getConfiguration().getSyncTime();
         if (mins > 0) {
             long ticks = mins * 60 * 20;
-            new UpdateTask(this).runTaskTimer(this, ticks, ticks);
+            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
+        getLog().info("Attempting to hook into Vault...");
         try {
             if (getServer().getPluginManager().isPluginEnabled("Vault")) {
-                getServer().getServicesManager().register(Permission.class, new VaultHook(this), this, ServicePriority.High);
-                getLogger().info("Registered Vault permission hook.");
+                VaultHook.hook(this);
+                getLog().info("Registered Vault permission & chat hook.");
             } else {
-                getLogger().info("Vault not found.");
+                getLog().info("Vault not found.");
             }
         } catch (Exception e) {
-            getLogger().warning("Error whilst hooking into Vault.");
+            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) {
-        if (getServer().getPlayer(uuid) != null) return "&aOnline";
-        return "&cOffline";
+    public Type getType() {
+        return Type.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
@@ -102,8 +180,50 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
         return getServer().getOnlinePlayers().size();
     }
 
+    @Override
+    public List<String> getPlayerList() {
+        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);
+    }
+
+    @Override
+    public boolean isPluginLoaded(String name) {
+        return getServer().getPluginManager().isPluginEnabled(name);
+    }
+
     @Override
     public void runUpdateTask() {
-        new UpdateTask(this).runTask(this);
+        getServer().getScheduler().runTaskAsynchronously(this, new UpdateTask(this));
     }
 }

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

@@ -1,150 +0,0 @@
-package me.lucko.luckperms;
-
-import lombok.AllArgsConstructor;
-import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
-import me.lucko.luckperms.exceptions.ObjectLacksPermissionException;
-import me.lucko.luckperms.groups.Group;
-import me.lucko.luckperms.users.User;
-import net.milkbowl.vault.permission.Permission;
-
-@AllArgsConstructor
-public class VaultHook extends Permission {
-    private final 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 (ObjectLacksPermissionException 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 (ObjectLacksPermissionException 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;
-
-        return user.getGroupNames().contains(group);
-    }
-
-    @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 (ObjectLacksPermissionException ignored) {}
-        plugin.getUserManager().saveUser(user, plugin.getDatastore());
-        return true;
-    }
-
-    @Override
-    public String[] getPlayerGroups(String world, String player) {
-        final User user = plugin.getUserManager().getUser(player);
-        if (user == null) return new String[0];
-
-        return user.getGroupNames().toArray(new String[0]);
-    }
-
-    @Override
-    public String getPrimaryGroup(String world, String player) {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public String[] getGroups() {
-        return plugin.getGroupManager().getGroups().keySet().toArray(new String[0]);
-    }
-
-    @Override
-    public boolean hasGroupSupport() {
-        return true;
-    }
-}

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

@@ -0,0 +1,410 @@
+/*
+ * 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.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);
+
+        if (world == null || world.equals("")) {
+            try {
+                holder.setPermission("meta." + node + "." + value, true);
+            } catch (ObjectAlreadyHasException ignored) {}
+
+        } else {
+            try {
+                holder.setPermission("meta." + node + "." + value, true, "global", world);
+            } catch (ObjectAlreadyHasException ignored) {}
+        }
+        
+        perms.objectSave(holder);
+    }
+
+    private static int getMeta(PermissionHolder holder, String world, String node, int defaultValue) {
+        if (holder == null) return defaultValue;
+        if (node.equals("")) return defaultValue;
+        node = escapeCharacters(node);
+
+        for (Node n : holder.getPermissions()) {
+            if (!n.isMeta()) {
+                continue;
+            }
+
+            if (!n.shouldApplyOnWorld(world, true, false)) {
+                continue;
+            }
+
+            Map.Entry<String, String> meta = n.getMeta();
+            if (meta.getKey().equalsIgnoreCase(node)) {
+
+                try {
+                    return Integer.parseInt(unescapeCharacters(meta.getValue()));
+                } catch (Throwable t) {
+                    return defaultValue;
+                }
+
+            }
+        }
+
+        return defaultValue;
+    }
+
+    private static double getMeta(PermissionHolder holder, String world, String node, double defaultValue) {
+        if (holder == null) return defaultValue;
+        if (node.equals("")) return defaultValue;
+        node = escapeCharacters(node);
+
+        for (Node n : holder.getPermissions()) {
+            if (!n.isMeta()) {
+                continue;
+            }
+
+            if (!n.shouldApplyOnWorld(world, true, false)) {
+                continue;
+            }
+
+            Map.Entry<String, String> meta = n.getMeta();
+            if (meta.getKey().equalsIgnoreCase(node)) {
+
+                try {
+                    return Double.parseDouble(unescapeCharacters(meta.getValue()));
+                } catch (Throwable t) {
+                    return defaultValue;
+                }
+
+            }
+        }
+
+        return defaultValue;
+    }
+
+    private static boolean getMeta(PermissionHolder holder, String world, String node, boolean defaultValue) {
+        if (holder == null) return defaultValue;
+        if (node.equals("")) return defaultValue;
+        node = escapeCharacters(node);
+
+        for (Node n : holder.getPermissions()) {
+            if (!n.isMeta()) {
+                continue;
+            }
+
+            if (!n.shouldApplyOnWorld(world, true, false)) {
+                continue;
+            }
+
+            Map.Entry<String, String> meta = n.getMeta();
+            if (meta.getKey().equalsIgnoreCase(node)) {
+
+                try {
+                    return Boolean.parseBoolean(unescapeCharacters(meta.getValue()));
+                } catch (Throwable t) {
+                    return defaultValue;
+                }
+
+            }
+        }
+
+        return defaultValue;
+    }
+
+    private static 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 (!n.shouldApplyOnWorld(world, true, false)) {
+                continue;
+            }
+
+            Map.Entry<String, String> meta = n.getMeta();
+            if (meta.getKey().equalsIgnoreCase(node)) {
+
+                try {
+                    return unescapeCharacters(meta.getValue());
+                } catch (Throwable t) {
+                    return defaultValue;
+                }
+
+            }
+        }
+
+        return defaultValue;
+    }
+
+    private static String getChatMeta(boolean prefix, PermissionHolder holder, String world) {
+        if (holder == null) return "";
+
+        int priority = -1000;
+        String meta = null;
+
+        for (Node n : holder.getAllNodes(null)) {
+            if (!n.getValue()) {
+                continue;
+            }
+
+            if (!n.shouldApplyOnWorld(world, true, false)) {
+                continue;
+            }
+
+            if (prefix) {
+                if (!n.isPrefix()) {
+                    continue;
+                }
+
+                Map.Entry<Integer, String> prefixValue = n.getPrefix();
+                if (prefixValue.getKey() > priority) {
+                    meta = prefixValue.getValue();
+                    priority = prefixValue.getKey();
+                }
+            } else {
+                if (!n.isSuffix()) {
+                    continue;
+                }
+
+                Map.Entry<Integer, String> suffixValue = n.getSuffix();
+                if (suffixValue.getKey() > priority) {
+                    meta = suffixValue.getValue();
+                    priority = suffixValue.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);
+        if (user == null) return;
+
+        if (prefix.equals("")) return;
+
+        try {
+            user.setPermission("prefix.1000." + escapeCharacters(prefix), true);
+        } catch (ObjectAlreadyHasException ignored) {}
+
+        perms.objectSave(user);
+    }
+
+    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);
+        if (user == null) return;
+
+        if (suffix.equals("")) return;
+
+        try {
+            user.setPermission("suffix.1000." + escapeCharacters(suffix), true);
+        } catch (ObjectAlreadyHasException ignored) {}
+
+        perms.objectSave(user);
+    }
+
+    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);
+        if (g == null) return;
+
+        if (prefix.equals("")) return;
+
+        try {
+            g.setPermission("prefix.1000." + escapeCharacters(prefix), true);
+        } catch (ObjectAlreadyHasException ignored) {}
+
+        perms.objectSave(g);
+    }
+
+    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);
+        if (g == null) return;
+
+        if (suffix.equals("")) return;
+
+        try {
+            g.setPermission("suffix.1000." + escapeCharacters(suffix), true);
+        } catch (ObjectAlreadyHasException ignored) {}
+
+        perms.objectSave(g);
+    }
+
+    public int getPlayerInfoInteger(String world, @NonNull String player, @NonNull String node, int defaultValue) {
+        final User user = plugin.getUserManager().get(player);
+        return getMeta(user, world, node, 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);
+        return getMeta(g, world, node, 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);
+        return getMeta(user, world, node, 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);
+        return getMeta(g, world, node, 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);
+        return getMeta(user, world, node, defaultValue);
+    }
+
+    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);
+        return getMeta(g, world, node, defaultValue);
+    }
+
+    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);
+    }
+
+}

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

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.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);
+
+            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();
+        }
+
+    }
+
+}

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

@@ -0,0 +1,217 @@
+/*
+ * 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.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;
+
+    @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, "global", world);
+        } else {
+            return object.hasPermission(permission, true);
+        }
+    }
+
+    private boolean objectAdd(String world, PermissionHolder object, String permission) {
+        if (object == null) return false;
+
+        try {
+            if (world != null && !world.equals("")) {
+                object.setPermission(permission, true, "global", world);
+            } else {
+                object.setPermission(permission, true);
+            }
+        } 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, "global", world);
+            } else {
+                object.unsetPermission(permission);
+            }
+        } 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, "global", 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, "global", 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, "global", 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.getLocalGroups("global", world).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;
+    }
+}

bukkit/src/main/java/me/lucko/luckperms/listeners/PlayerListener.java

@@ -1,75 +0,0 @@
-package me.lucko.luckperms.listeners;
-
-import lombok.AllArgsConstructor;
-import me.lucko.luckperms.LPBukkitPlugin;
-import me.lucko.luckperms.users.BukkitUser;
-import me.lucko.luckperms.users.User;
-import org.bukkit.ChatColor;
-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, color(plugin.getConfiguration().getPrefix() +
-                    "&cError 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, color(plugin.getConfiguration().getPrefix() +
-                    "&cUser 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);
-    }
-
-    public static String color(String string) {
-        return ChatColor.translateAlternateColorCodes('&', string);
-    }
-
-}

bukkit/src/main/java/me/lucko/luckperms/runnables/UpdateTask.java

@@ -1,25 +0,0 @@
-package me.lucko.luckperms.runnables;
-
-import lombok.AllArgsConstructor;
-import me.lucko.luckperms.LPBukkitPlugin;
-import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
-import org.bukkit.scheduler.BukkitRunnable;
-
-@AllArgsConstructor
-public class UpdateTask extends BukkitRunnable {
-    private final LPBukkitPlugin plugin;
-
-    @Override
-    public void run() {
-        plugin.getLogger().info("Running update task.");
-
-        // Re-load all of the groups
-        plugin.getGroupManager().loadAllGroups();
-
-        // Refresh all online users.
-        for (Player p : Bukkit.getOnlinePlayers()) {
-            plugin.getDatastore().loadUser(p.getUniqueId(), success -> {});
-        }
-    }
-}

bukkit/src/main/java/me/lucko/luckperms/users/BukkitUser.java

@@ -1,16 +1,52 @@
+/*
+ * 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 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;
 
@@ -18,35 +54,57 @@ public class BukkitUser extends User {
     @Setter
     private PermissionAttachment attachment = null;
 
-    public BukkitUser(UUID uuid, LPBukkitPlugin plugin) {
+    BukkitUser(UUID uuid, LPBukkitPlugin plugin) {
         super(uuid, plugin);
         this.plugin = plugin;
     }
 
-    public BukkitUser(UUID uuid, String username, LPBukkitPlugin plugin) {
+    BukkitUser(UUID uuid, String username, LPBukkitPlugin plugin) {
         super(uuid, username, plugin);
         this.plugin = plugin;
     }
 
+    @SuppressWarnings("unchecked")
     @Override
     public void refreshPermissions() {
-        Player player = Bukkit.getPlayer(getUuid());
-        if (player == null) return;
-
         if (attachment == null) {
-            getPlugin().getLogger().warning("User " + getName() + " does not have a permissions attachment defined.");
-            setAttachment(player.addAttachment(plugin));
+            return;
         }
 
-        // Clear existing permissions
-        for (String p : attachment.getPermissions().keySet()) {
-            attachment.setPermission(p, false);
+        // 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 = getLocalPermissions(getPlugin().getConfiguration().getServer(), plugin.getUserManager().getWorldCache().get(getUuid()), null);
+
+        try {
+            // The map in the LP PermissionAttachment is a ConcurrentHashMap. We can modify it's contents async.
+            Map<String, Boolean> existing = (Map<String, Boolean>) getPermissionsField().get(attachment);
+
+            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;
+                }
+            }
+
+            if (!different) return;
+
+            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.getPermissible().recalculatePermissions());
+
+        } catch (Exception e) {
+            e.printStackTrace();
         }
 
-        // Re-add all defined permissions for the user
-        Map<String, Boolean> local = getLocalPermissions(getPlugin().getConfiguration().getServer(), null);
-        for (String node : local.keySet()) {
-            attachment.setPermission(node, local.get(node));
-        }
+        plugin.getApiProvider().fireEventAsync(new UserPermissionRefreshEvent(new UserLink(this)));
     }
 }

bukkit/src/main/java/me/lucko/luckperms/users/BukkitUserManager.java

@@ -1,27 +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.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) {
+    public void unload(User user) {
         if (user != null) {
 
             if (user instanceof BukkitUser) {
                 BukkitUser u = (BukkitUser) user;
 
                 if (u.getAttachment() != null) {
-                    Player player = Bukkit.getPlayer(u.getUuid());
+                    Player player = plugin.getServer().getPlayer(plugin.getUuidCache().getExternalUUID(u.getUuid()));
 
                     if (player != null) {
                         player.removeAttachment(u.getAttachment());
@@ -30,24 +60,35 @@ public class BukkitUserManager extends UserManager {
                 }
             }
 
-            getUsers().remove(user.getUuid());
+            getAll().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() {
+        // 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")));
+        });
+    }
 }

bukkit/src/main/resources/config.yml

@@ -1,19 +1,55 @@
-# 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 user on join. e.g. a value of "default" = luckperms.group.default
-default-group: default
-
 # If users on this server should have their global permissions/groups applied.
 include-global: true
 
-prefix: '&7&l[&b&lL&a&lP&7&l] &c'
+# 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)
+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
+
+# Which storage method the plugin should use.
+# Currently supported: mysql, sqlite, h2, flatfile, mongodb
+# Fill out connection info below if you're using MySQL or MongoDB
+storage-method: 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

bukkit/src/main/resources/plugin.yml

@@ -1,10 +1,130 @@
 name: LuckPerms
 author: Luck
-version: 1.0
+version: ${release.version}.${git.closest.tag.commit.count}
 main: me.lucko.luckperms.LPBukkitPlugin
-softdepend: [Vault]
+softdepend: [Vault, PermissionsEx, GroupManager, PowerfulPerms, zPermissions] # For migration
 description: A permissions plugin
 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.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.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.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.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

bungee/pom.xml

@@ -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.0-SNAPSHOT</version>
+        <groupId>me.lucko.luckperms</groupId>
+        <version>2.6-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
     <artifactId>luckperms-bungee</artifactId>
-    <version>1.0-SNAPSHOT</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>
@@ -28,7 +26,7 @@
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>
-                <version>3.2</version>
+                <version>3.5.1</version>
                 <configuration>
                     <source>1.8</source>
                     <target>1.8</target>
@@ -37,7 +35,7 @@
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-shade-plugin</artifactId>
-                <version>2.3</version>
+                <version>2.4.3</version>
                 <executions>
                     <execution>
                         <phase>package</phase>
@@ -45,11 +43,48 @@
                             <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>
+                            </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>
 
@@ -59,16 +94,29 @@
             <groupId>net.md-5</groupId>
             <artifactId>bungeecord-api</artifactId>
             <version>1.9-SNAPSHOT</version>
-            <type>jar</type>
             <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>

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

@@ -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));
+    }
+}

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

@@ -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,29 +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());
             }
         }
@@ -40,39 +53,32 @@ public class BungeeConfig implements LPConfiguration {
         return cfg;
     }
 
-
     @Override
-    public String getServer() {
-        return configuration.getString("server");
+    protected void init() {
+        try {
+            configuration = ConfigurationProvider.getProvider(YamlConfiguration.class).load(makeFile("config.yml"));
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
     }
 
     @Override
-    public String getPrefix() {
-        return configuration.getString("prefix");
+    protected void set(String path, Object value) {
+        configuration.set(path, value);
     }
 
     @Override
-    public int getSyncTime() {
-        return configuration.getInt("sql.sync-minutes");
+    protected String getString(String path, String def) {
+        return configuration.getString(path, def);
     }
 
     @Override
-    public String getDefaultGroupNode() {
-        return "luckperms.group." + configuration.getString("default-group");
+    protected int getInt(String path, int def) {
+        return configuration.getInt(path, def);
     }
 
     @Override
-    public String getDefaultGroupName() {
-        return configuration.getString("default-group");
-    }
-
-    @Override
-    public boolean getIncludeGlobalPerms() {
-        return configuration.getBoolean("include-global");
-    }
-
-    @Override
-    public String getDatabaseValue(String value) {
-        return configuration.getString("sql." + value);
+    protected boolean getBoolean(String path, boolean def) {
+        return configuration.getBoolean(path, def);
     }
 }

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

@@ -0,0 +1,136 @@
+/*
+ * 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.lang.ref.WeakReference;
+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 WeakReference<ProxiedPlayer> p = new WeakReference<>(player);
+
+        final User user = plugin.getUserManager().get(plugin.getUuidCache().getUUID(e.getPlayer().getUniqueId()));
+        if (user == null) {
+            plugin.getProxy().getScheduler().schedule(plugin, () -> {
+                final ProxiedPlayer pl = p.get();
+                if (pl != null) {
+                    pl.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());
+    }
+}

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

@@ -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);
+    }
+}

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

@@ -1,83 +1,152 @@
+/*
+ * 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.implementation.ApiProvider;
 import me.lucko.luckperms.commands.CommandManager;
-import me.lucko.luckperms.data.Datastore;
-import me.lucko.luckperms.data.DatastoreConfiguration;
-import me.lucko.luckperms.data.HikariDatastore;
+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.0";
-
-    @Getter
-    LPConfiguration configuration;
-
-    @Getter
-    UserManager userManager;
-
-    @Getter
-    GroupManager groupManager;
-
-    @Getter
-    Datastore datastore;
+    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));
 
-        datastore = new HikariDatastore(this);
-        datastore.init(new DatastoreConfiguration(
-                configuration.getDatabaseValue("address"),
-                configuration.getDatabaseValue("database"),
-                configuration.getDatabaseValue("username"),
-                configuration.getDatabaseValue("password")
-        ));
+        // disable the default Bungee /perms command so it gets handled by the Bukkit plugin
+        getProxy().getDisabledCommands().add("perms");
 
+        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();
+        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);
 
-    @Override
-    public UserManager getUserManager() {
-        return userManager;
+        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 GroupManager getGroupManager() {
-        return groupManager;
+    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) {
-        if (getProxy().getPlayer(uuid) != null) return "&aOnline";
-        return "&cOffline";
+    public Type getType() {
+        return Type.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
@@ -86,18 +155,47 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
     }
 
     @Override
-    public LPConfiguration getConfiguration() {
-        return configuration;
+    public List<String> getPlayerList() {
+        return getProxy().getPlayers().stream().map(ProxiedPlayer::getName).collect(Collectors.toList());
     }
 
     @Override
-    public Datastore getDatastore() {
-        return datastore;
+    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 boolean isPluginLoaded(String name) {
+        return getProxy().getPluginManager().getPlugins().stream()
+                .filter(p -> p.getDescription().getName().equalsIgnoreCase(name))
+                .findAny()
+                .isPresent();
     }
 
     @Override
     public void runUpdateTask() {
-        new UpdateTask(this).run();
+        doAsync(new UpdateTask(this));
     }
 
     @Override

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

@@ -1,34 +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 java.util.Arrays;
-
-public class MainCommand extends Command {
-    private final CommandManager manager;
-
-    public MainCommand(CommandManager manager) {
-        super("luckpermsbungee", "luckperms.use", "bperms", "lpb", "bpermissions", "bp", "bperm");
-        this.manager = manager;
-
-    }
-
-    @Override
-    public void execute(CommandSender sender, String[] args) {
-        manager.onCommand(new Sender() {
-            @Override
-            public void sendMessage(String s) {
-                sender.sendMessage(new TextComponent(s));
-            }
-
-            @Override
-            public boolean hasPermission(String node) {
-                return sender.hasPermission(node);
-            }
-        }, Arrays.asList(args));
-    }
-}

bungee/src/main/java/me/lucko/luckperms/listeners/PlayerListener.java

@@ -1,44 +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.data.Datastore;
-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;
-
-@AllArgsConstructor
-public class PlayerListener implements Listener {
-
-    private final LPBungeePlugin plugin;
-
-    @EventHandler
-    public void onPlayerPostLogin(PostLoginEvent e) {
-        final ProxiedPlayer player = e.getPlayer();
-
-        plugin.getDatastore().loadOrCreateUser(player.getUniqueId(), player.getName(), success -> {
-            if (!success) {
-                e.getPlayer().sendMessage(new TextComponent(Util.color("&e&l[LP] &cPermissions data could not be loaded. Please contact an administrator.")));
-            } else {
-                User user = plugin.getUserManager().getUser(player.getUniqueId());
-                user.refreshPermissions();
-            }
-        });
-
-        plugin.getDatastore().saveUUIDData(e.getPlayer().getName(), e.getPlayer().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);
-    }
-}

bungee/src/main/java/me/lucko/luckperms/runnables/UpdateTask.java

@@ -1,23 +0,0 @@
-package me.lucko.luckperms.runnables;
-
-import lombok.AllArgsConstructor;
-import me.lucko.luckperms.LPBungeePlugin;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-
-@AllArgsConstructor
-public class UpdateTask implements Runnable {
-    private final LPBungeePlugin plugin;
-
-    @Override
-    public void run() {
-        plugin.getLogger().info("Running update task.");
-
-        // Re-load all of the groups
-        plugin.getGroupManager().loadAllGroups();
-
-        // Refresh all online users.
-        for (ProxiedPlayer p : plugin.getProxy().getPlayers()) {
-            plugin.getDatastore().loadUser(p.getUniqueId(), success -> {});
-        }
-    }
-}

bungee/src/main/java/me/lucko/luckperms/users/BungeeUser.java

@@ -1,42 +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;
-
-    public BungeeUser(UUID uuid, LPBungeePlugin plugin) {
+    BungeeUser(UUID uuid, LPBungeePlugin plugin) {
         super(uuid, plugin);
-        this.plugin = plugin;
     }
 
-    public BungeeUser(UUID uuid, String username, LPBungeePlugin 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());
-        for (String p : perms) {
-            player.setPermission(p, false);
-        }
-
-        // Re-add all defined permissions for the user
-        Map<String, Boolean> local = getLocalPermissions(getPlugin().getConfiguration().getServer(), null);
-        for (String node : local.keySet()) {
-            player.setPermission(node, local.get(node));
-        }
+        // Do nothing. Permissions are applied when needed in a listener.
     }
 }

bungee/src/main/java/me/lucko/luckperms/users/BungeeUserManager.java

@@ -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;
 
@@ -9,36 +30,40 @@ public class BungeeUserManager extends UserManager {
     private final LPBungeePlugin plugin;
 
     public BungeeUserManager(LPBungeePlugin plugin) {
+        super(plugin);
         this.plugin = plugin;
     }
 
     @Override
-    public void unloadUser(User user) {
+    public void unload(User user) {
         if (user != null) {
-
-            ProxiedPlayer player = plugin.getProxy().getPlayer(user.getUuid());
-            if (player != null) {
-                player.getPermissions().clear();
-            }
-
-            getUsers().remove(user.getUuid());
+            // Cannot clear the ProxiedPlayer's permission map, they're leaving so that will get GCed anyway
+            // Calling getPermissions.clear() throws an UnsupportedOperationException
+            getAll().remove(user.getUuid());
         }
     }
 
     @Override
-    public void cleanupUser(User user) {
-        if (plugin.getProxy().getPlayer(user.getUuid()) == null) {
-            unloadUser(user);
+    public void cleanup(User user) {
+        if (plugin.getProxy().getPlayer(plugin.getUuidCache().getExternalUUID(user.getUuid())) == null) {
+            unload(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(p -> plugin.getUuidCache().getUUID(p.getUniqueId()))
+                .forEach(u -> plugin.getDatastore().loadUser(u, "null"));
+    }
 }

bungee/src/main/resources/config.yml

@@ -1,19 +1,55 @@
-# 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 user on join. e.g. a value of "default" = luckperms.group.default
-default-group: default
-
 # If users on this server should have their global permissions/groups applied.
 include-global: false
 
-prefix: '&7&l[&b&lL&a&lP&7&l] &c'
+# 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)
+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
+
+# Which storage method the plugin should use.
+# Currently supported: mysql, sqlite, h2, flatfile, mongodb
+# Fill out connection info below if you're using MySQL or MongoDB
+storage-method: 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

bungee/src/main/resources/plugin.yml

@@ -1,3 +1,6 @@
 name: LuckPerms
+author: Luck
+version: ${release.version}.${git.closest.tag.commit.count}
 main: me.lucko.luckperms.LPBungeePlugin
-author: Luck
+softdepend: [PowerfulPerms] # For migration
+description: A permissions plugin

common/pom.xml

@@ -4,8 +4,8 @@
          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.0-SNAPSHOT</version>
+        <groupId>me.lucko.luckperms</groupId>
+        <version>2.6-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
@@ -15,7 +15,7 @@
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>
-                <version>3.2</version>
+                <version>3.5.1</version>
                 <configuration>
                     <source>1.8</source>
                     <target>1.8</target>
@@ -23,4 +23,108 @@
             </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>
+        <!-- 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>
+    </dependencies>
+
+</project>

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

@@ -1,56 +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.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} object
+    /*
+     * 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} object
-     */
     GroupManager getGroupManager();
-
-    /**
-     * Retrieves the {@link LPConfiguration} for getting values from the config
-     * @return the {@link LPConfiguration} implementation for the platform
-     */
+    TrackManager getTrackManager();
     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
+     */
+    Type 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
@@ -58,6 +94,55 @@ public interface LuckPermsPlugin {
      */
     int getPlayerCount();
 
+    /**
+     * Gets the usernames of the users online on the platform
+     * @return a {@link List} of usernames
+     */
+    List<String> getPlayerList();
+
+    /**
+     * @return a {@link List} of senders online on the platform
+     */
+    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);
+
+    /**
+     * 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
      */
@@ -74,4 +159,9 @@ public interface LuckPermsPlugin {
      * @param r the task to run
      */
     void doSync(Runnable r);
+
+
+    enum Type {
+        BUKKIT, BUNGEE, SPONGE;
+    }
 }

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

@@ -0,0 +1,208 @@
+/*
+ * 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;
+
+/**
+ * Provides static access to LuckPerms
+ */
+@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 1.6;
+    }
+
+    @Override
+    public String getVersion() {
+        return plugin.getVersion();
+    }
+
+    @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));
+    }
+}

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

@@ -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();
+            }
+        }
+    }
+
+}

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

@@ -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));
+    }
+}

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

@@ -0,0 +1,97 @@
+/*
+ * 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;
+
+/**
+ * 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();
+    }
+
+    @SuppressWarnings("deprecation")
+    @Override
+    public MySQLConfiguration getDatabaseValues() {
+        return getDatastoreConfig();
+    }
+
+    @Override
+    public DatastoreConfiguration getDatastoreConfig() {
+        return master.getDatabaseValues();
+    }
+
+    @Override
+    public String getStorageMethod() {
+        return master.getStorageMethod();
+    }
+}

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

@@ -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);
+    }
+}

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

@@ -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();
+    }
+
+}

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

@@ -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();
+    }
+}

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

@@ -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));
+    }
+
+}

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

@@ -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;
+    }
+
+}

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

@@ -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);
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/CommandManager.java

@@ -1,113 +1,185 @@
+/*
+ * 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.commands.group.CreateGroupCommand;
-import me.lucko.luckperms.commands.group.DeleteGroupCommand;
+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.ListGroupsCommand;
-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.group.ListGroups;
+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.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.logging.Level;
+import java.util.Optional;
+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 UserAddGroupCommand());
-        userCommand.registerSubCommand(new UserClearCommand());
-        userCommand.registerSubCommand(new UserGetUUIDCommand());
-        userCommand.registerSubCommand(new UserHasPermCommand());
-        userCommand.registerSubCommand(new UserInfoCommand());
-        userCommand.registerSubCommand(new UserListNodesCommand());
-        userCommand.registerSubCommand(new UserRemoveGroupCommand());
-        userCommand.registerSubCommand(new UserSetPermissionCommand());
-        userCommand.registerSubCommand(new UserUnSetPermissionCommand());
-
-        GroupMainCommand groupCommand = new GroupMainCommand();
-        this.registerMainCommand(groupCommand);
-        groupCommand.registerSubCommand(new GroupClearCommand());
-        groupCommand.registerSubCommand(new GroupHasPermCommand());
-        groupCommand.registerSubCommand(new GroupInfoCommand());
-        groupCommand.registerSubCommand(new GroupListNodesCommand());
-        groupCommand.registerSubCommand(new GroupSetInheritCommand());
-        groupCommand.registerSubCommand(new GroupSetPermissionCommand());
-        groupCommand.registerSubCommand(new GroupUnsetInheritCommand());
-        groupCommand.registerSubCommand(new GroupUnSetPermissionCommand());
-
-        this.registerMainCommand(new CreateGroupCommand());
-        this.registerMainCommand(new DeleteGroupCommand());
-        this.registerMainCommand(new ListGroupsCommand());
-        this.registerMainCommand(new DebugCommand());
-        this.registerMainCommand(new InfoCommand());
-        this.registerMainCommand(new SyncCommand());
+    /**
+     * 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, List<String> args) {
+    public CommandResult onCommand(Sender sender, String label, List<String> args) {
         if (args.size() == 0) {
-            Util.sendPluginMessage(sender, "&6Running &bLuckPerms " + plugin.getVersion() + "&6.");
-
-            if (sender.hasPermission("luckperms.info")) {
-                for (MainCommand c : mainCommands) {
-                    Util.sendPluginMessage(sender, "&e-> &d" + c.getUsage());
-                }
-            }
-
-        } else {
-            String c = args.get(0);
-            MainCommand main = null;
-
-            for (MainCommand mainCommand : mainCommands) {
-                if (mainCommand.getName().equalsIgnoreCase(c)) {
-                    main = mainCommand;
-                    break;
-                }
-            }
-
-            if (main == null) {
-                Util.sendPluginMessage(sender, "Command not recognised.");
-                return true;
-            }
-
-            if (main.getRequiredArgsLength() == 0) {
-                main.execute(plugin, sender, null);
-                return true;
-            }
-
-            if (args.size() == 1) {
-                main.sendUsage(sender);
-                return true;
-            }
-
-            main.execute(plugin, sender, new ArrayList<>(args.subList(1, args.size())));
+            sendCommandUsage(sender, label);
+            return CommandResult.INVALID_ARGS;
         }
-        return true;
 
+        Optional<MainCommand> o = mainCommands.stream()
+                .filter(m -> m.getName().equalsIgnoreCase(args.get(0)))
+                .limit(1)
+                .findAny();
+
+        if (!o.isPresent()) {
+            sendCommandUsage(sender, label);
+            return CommandResult.INVALID_ARGS;
+        }
+
+        final MainCommand main = o.get();
+        if (!main.isAuthorized(sender)) {
+            sendCommandUsage(sender, label);
+            return CommandResult.NO_PERMISSION;
+        }
+
+        if (main.getRequiredArgsLength() == 0) {
+            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 CommandResult.INVALID_ARGS;
+        }
+
+        try {
+            return main.execute(plugin, sender, new ArrayList<>(args.subList(1, args.size())), label);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return CommandResult.FAILURE;
+        }
     }
 
-    public void registerMainCommand(MainCommand command) {
-        plugin.getLogger().log(Level.INFO, "[CommandManager] Registered main command '" + command.getName() + "'");
-        mainCommands.add(command);
+    /**
+     * Generic tab complete method to be called from the command executor object of the platform
+     * @param sender who is tab completing
+     * @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.isAuthorized(sender))
+                .collect(Collectors.toList());
+
+        if (args.size() <= 1) {
+            if (args.isEmpty() || args.get(0).equalsIgnoreCase("")) {
+                return mains.stream()
+                        .map(m -> m.getName().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();
+
+        if (!o.isPresent()) {
+            return Collections.emptyList();
+        }
+
+        return o.get().onTabComplete(sender, args.subList(1, args.size()), plugin);
     }
 
+    private void sendCommandUsage(Sender sender, String label) {
+        Message.INFO_BRIEF.send(sender, plugin.getVersion());
+
+        mainCommands.stream()
+                .filter(c -> c.isAuthorized(sender))
+                .forEach(c -> Util.sendPluginMessage(sender, "&e-> &d" + String.format(c.getUsage(), label)));
+    }
 }

common/src/main/java/me/lucko/luckperms/commands/CommandResult.java

@@ -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;
+    }
+
+}

common/src/main/java/me/lucko/luckperms/commands/ConsecutiveExecutor.java

@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.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;
+    }
+
+}

common/src/main/java/me/lucko/luckperms/commands/MainCommand.java

@@ -1,42 +1,210 @@
+/*
+ * 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;
 import java.util.stream.Collectors;
 
-public abstract class MainCommand {
+@Getter
+@AllArgsConstructor
+public abstract class MainCommand<T> {
 
-    @Getter
+    /**
+     * The name of the main command
+     */
     private final String name;
 
-    @Getter
+    /**
+     * The command usage
+     */
     private final String usage;
 
-    @Getter
+    /**
+     * How many arguments are required for the command to run
+     */
     private final int requiredArgsLength;
 
-    public MainCommand(String name, String usage, int requiredArgsLength) {
-        this.name = name;
-        this.usage = usage;
-        this.requiredArgsLength = requiredArgsLength;
+    /**
+     * 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());
     }
 
-    protected abstract void execute(LuckPermsPlugin plugin, Sender sender, List<String> args);
-    public abstract List<? extends SubCommand> getSubCommands();
+    /**
+     * 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());
 
-    protected void sendUsage(Sender sender) {
-        List<SubCommand> subs = getSubCommands().stream().filter(s -> s.isAuthorized(sender)).collect(Collectors.toList());
         if (subs.size() > 0) {
             Util.sendPluginMessage(sender, "&e" + getName() + " Sub Commands:");
 
             for (SubCommand s : subs) {
-                s.sendUsage(sender);
+                s.sendUsage(sender, label);
             }
 
         } else {
-            Util.sendPluginMessage(sender, "You do not have permission to use this command!");
+            Message.COMMAND_NO_PERMISSION.send(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> 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 objects.stream()
+                    .filter(s -> s.toLowerCase().startsWith(args.get(0).toLowerCase()))
+                    .collect(Collectors.toList());
+        }
+
+        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(plugin, sender, args.subList(2, args.size()));
+    }
 }

common/src/main/java/me/lucko/luckperms/commands/Predicate.java

@@ -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);
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/Sender.java

@@ -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);
 
 }

common/src/main/java/me/lucko/luckperms/commands/SenderFactory.java

@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.commands;
+
+import lombok.Getter;
+import me.lucko.luckperms.constants.Permission;
+
+import java.lang.ref.WeakReference;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * Factory class to make a thread-safe sender instance
+ * @param <T> the command sender type
+ */
+public abstract class SenderFactory<T> implements Runnable {
+    private final Map<T, List<String>> messages = new HashMap<>();
+    //private final List<Map.Entry<T, String>> messages = new ArrayList<>();
+    private final SenderFactory<T> factory = this;
+
+    protected abstract String getName(T t);
+    protected abstract UUID getUuid(T t);
+    protected abstract void sendMessage(T t, String s);
+    protected abstract boolean hasPermission(T t, String node);
+
+    public final Sender wrap(T t) {
+        return new Sender() {
+            final WeakReference<T> tRef = new WeakReference<>(t);
+
+            // Cache these permissions, so they can be accessed async
+            final Map<Permission, Boolean> perms = Arrays.stream(Permission.values())
+                    .map(p -> new AbstractMap.SimpleEntry<>(p, factory.hasPermission(t, p.getNode())))
+                    .collect(Collectors.toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue));
+
+            @Getter
+            final String name = factory.getName(t);
+
+            @Getter
+            final UUID uuid = factory.getUuid(t);
+
+            @Override
+            public void sendMessage(String s) {
+                final T t = tRef.get();
+                if (t != null) {
+                    synchronized (messages) {
+                        if (!messages.containsKey(t)) {
+                            messages.put(t, new ArrayList<>());
+                        }
+
+                        messages.get(t).add(s);
+                    }
+                }
+            }
+
+            @Override
+            public boolean hasPermission(Permission permission) {
+                synchronized (perms) {
+                    return perms.get(permission);
+                }
+            }
+        };
+    }
+
+    @Override
+    public final void run() {
+        synchronized (messages) {
+            if (!messages.isEmpty()) {
+                messages.entrySet().forEach(e -> e.getValue().forEach(s -> factory.sendMessage(e.getKey(), s)));
+                messages.clear();
+            }
+        }
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/SingleMainCommand.java

@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.commands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.constants.Permission;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * An extension of {@link MainCommand} for implementations without any subcommands
+ */
+public class SingleMainCommand extends MainCommand<Object> {
+    private final Permission permission;
+
+    public SingleMainCommand(String name, String usage, int requiredArgsLength, Permission permission) {
+        super(name, usage, requiredArgsLength);
+        this.permission = permission;
+    }
+
+    @Override
+    protected CommandResult execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
+        // Do nothing, allow the implementation to override this
+        return null;
+    }
+
+    @Override
+    protected Object getTarget(String target, LuckPermsPlugin plugin, Sender sender) {
+        return null;
+    }
+
+    @Override
+    protected void cleanup(Object o, LuckPermsPlugin plugin) {
+        // Do nothing
+    }
+
+    @Override
+    protected List<String> getObjects(LuckPermsPlugin plugin) {
+        return Collections.emptyList();
+    }
+
+    @Override
+    protected List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<SubCommand<Object>> getSubCommands() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    protected boolean isAuthorized(Sender sender) {
+        return permission.isAuthorized(sender);
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/SubCommand.java

@@ -1,35 +1,176 @@
+/*
+ * 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 me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.groups.Group;
+import me.lucko.luckperms.tracks.Track;
+import me.lucko.luckperms.users.User;
 
-public abstract class SubCommand {
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
 
-    @Getter
+/**
+ * Abstract SubCommand class
+ */
+@Getter
+@AllArgsConstructor
+public abstract class SubCommand<T> {
+
+    /**
+     * The name of the sub command
+     */
     private final String name;
 
-    @Getter
+    /**
+     * A brief description of what the sub command does
+     */
     private final String description;
 
-    @Getter
+    /**
+     * The command usage
+     */
     private final String usage;
 
-    @Getter
-    private final String permission;
+    /**
+     * The permission needed to use this command
+     */
+    private final Permission permission;
 
-    public SubCommand(String name, String description, String usage, String permission) {
-        this.name = name;
-        this.description = description;
-        this.usage = usage;
-        this.permission = permission;
+    /**
+     * Predicate to test if the argument length given is invalid
+     */
+    private final Predicate<? super Integer> isArgumentInvalid;
+
+    /**
+     * Called when this sub command is ran
+     * @param plugin a link to the main plugin instance
+     * @param sender the sender to executed the command
+     * @param t the object the command is operating on
+     * @param args the stripped arguments given
+     * @param label the command label used
+     */
+    public abstract CommandResult execute(LuckPermsPlugin plugin, Sender sender, T t, List<String> args, String label);
+
+    /**
+     * Returns a list of suggestions, which are empty by default. Sub classes that give tab complete suggestions override
+     * this method to give their own list.
+     * @param plugin the plugin instance
+     * @param sender who is tab completing
+     * @param args the arguments so far
+     * @return a list of suggestions
+     */
+    public List<String> onTabComplete(LuckPermsPlugin plugin, Sender sender, List<String> args) {
+        return Collections.emptyList();
     }
 
+    /**
+     * Send the command usage to a sender
+     * @param sender the sender to send the usage to
+     * @param label the command label used
+     */
+    public void sendUsage(Sender sender, String label) {
+        Util.sendPluginMessage(sender, "&e-> &d" + String.format(getUsage(), label));
+    }
+
+    /**
+     * 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
+     */
     public boolean isAuthorized(Sender sender) {
-        return sender.hasPermission(permission);
+        return permission.isAuthorized(sender);
     }
 
-    public void sendUsage(Sender sender) {
-        Util.sendPluginMessage(sender, "&e-> &d" + getUsage());
+    /*
+        ----------------------------------------------------------------------------------
+        Utility methods used by #onTabComplete and #execute implementations in sub classes
+        ----------------------------------------------------------------------------------
+     */
+
+    protected static List<String> getGroupTabComplete(List<String> args, LuckPermsPlugin plugin) {
+        return getTabComplete(new ArrayList<>(plugin.getGroupManager().getAll().keySet()), args);
     }
 
-    public abstract boolean isArgLengthInvalid(int argLength);
+    protected static List<String> getTrackTabComplete(List<String> args, LuckPermsPlugin plugin) {
+        return getTabComplete(new ArrayList<>(plugin.getTrackManager().getAll().keySet()), args);
+    }
+
+    protected static List<String> getBoolTabComplete(List<String> args) {
+        if (args.size() == 2) {
+            return Arrays.asList("true", "false");
+        } else {
+            return Collections.emptyList();
+        }
+    }
+
+    private static List<String> getTabComplete(List<String> options, List<String> args) {
+        if (args.size() <= 1) {
+            if (args.isEmpty() || args.get(0).equalsIgnoreCase("")) {
+                return options;
+            }
+
+            return options.stream().filter(s -> s.toLowerCase().startsWith(args.get(0).toLowerCase())).collect(Collectors.toList());
+        }
+
+        return Collections.emptyList();
+    }
+
+    protected static void save(User user, Sender sender, LuckPermsPlugin plugin) {
+        if (plugin.getDatastore().saveUser(user)) {
+            Message.USER_SAVE_SUCCESS.send(sender);
+        } else {
+            Message.USER_SAVE_ERROR.send(sender);
+        }
+
+        user.refreshPermissions();
+    }
+
+    protected static void save(Group group, Sender sender, LuckPermsPlugin plugin) {
+        if (plugin.getDatastore().saveGroup(group)) {
+            Message.GROUP_SAVE_SUCCESS.send(sender);
+        } else {
+            Message.GROUP_SAVE_ERROR.send(sender);
+        }
+
+        plugin.runUpdateTask();
+    }
+
+    protected static void save(Track track, Sender sender, LuckPermsPlugin plugin) {
+        if (plugin.getDatastore().saveTrack(track)) {
+            Message.TRACK_SAVE_SUCCESS.send(sender);
+        } else {
+            Message.TRACK_SAVE_ERROR.send(sender);
+        }
+
+        plugin.runUpdateTask();
+    }
 }

common/src/main/java/me/lucko/luckperms/commands/Util.java

@@ -1,14 +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.commands;
 
+import lombok.experimental.UtilityClass;
+import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.constants.Patterns;
+import me.lucko.luckperms.utils.DateUtil;
+
 import java.util.List;
 import java.util.Map;
 import java.util.UUID;
 
+@UtilityClass
 public class Util {
 
     public static void sendPluginMessage(Sender sender, String message) {
-        // TODO: Pull the prefix from the config somehow
-        sender.sendMessage(color("&7&l[&b&lL&a&lP&7&l] &c" + message));
+        sender.sendMessage(color(Message.PREFIX + message));
     }
 
     public static String color(String s) {
@@ -19,8 +46,8 @@ public class Util {
         // Stolen from Bukkit :>
         char[] b = textToTranslate.toCharArray();
 
-        for(int i = 0; i < b.length - 1; ++i) {
-            if(b[i] == altColorChar && "0123456789AaBbCcDdEeFfKkLlMmNnOoRr".indexOf(b[i + 1]) > -1) {
+        for (int i = 0; i < b.length - 1; ++i) {
+            if (b[i] == altColorChar && "0123456789AaBbCcDdEeFfKkLlMmNnOoRr".indexOf(b[i + 1]) > -1) {
                 b[i] = 167;
                 b[i + 1] = Character.toLowerCase(b[i + 1]);
             }
@@ -29,40 +56,96 @@ public class Util {
         return new String(b);
     }
 
+    public static String stripColor(String s) {
+        return s == null ? null : Patterns.STRIP_COLOR_PATTERN.matcher(s).replaceAll("");
+    }
+
+    public static String formatBoolean(boolean b) {
+        return b ? "&atrue" : "&cfalse";
+    }
+
     public static void sendBoolean(Sender sender, String node, boolean b) {
-        if (b) {
-            sender.sendMessage(Util.color("&b" + node + ": &atrue"));
-        } else {
-            sender.sendMessage(Util.color("&b" + node + ": &cfalse"));
-        }
+        sender.sendMessage(Util.color("&b" + node + ": " + formatBoolean(b)));
     }
 
     public static String listToCommaSep(List<String> strings) {
         if (strings.isEmpty()) return "&6None";
 
         StringBuilder sb = new StringBuilder();
+        strings.forEach(s -> sb.append("&6").append(s).append("&7, "));
+        return sb.delete(sb.length() - 2, sb.length()).toString();
+    }
 
+    public static String listToArrowSep(List<String> strings, String highlight) {
+        if (strings.isEmpty()) return "&6None";
+
+        StringBuilder sb = new StringBuilder();
         for (String s : strings) {
-            sb.append("&6").append(s).append("&7, ");
+            if (s.equalsIgnoreCase(highlight)) {
+                sb.append("&e").append(s).append("&7 ---> ");
+            } else {
+                sb.append("&6").append(s).append("&7 ---> ");
+            }
+        }
+        return sb.delete(sb.length() - 6, sb.length()).toString();
+    }
+
+    public static String listToArrowSep(List<String> strings, String highlightFirst, String highlightSecond, boolean reversed) {
+        if (strings.isEmpty()) return "&6None";
+
+        StringBuilder sb = new StringBuilder();
+        for (String s : strings) {
+            if (s.equalsIgnoreCase(highlightFirst)) {
+                sb.append("&e").append(s).append("&4").append(reversed ? " <--- " : " ---> ");
+            } else if (s.equalsIgnoreCase(highlightSecond)) {
+                sb.append("&e").append(s).append("&7").append(reversed ? " <--- " : " ---> ");
+            } else {
+                sb.append("&6").append(s).append("&7").append(reversed ? " <--- " : " ---> ");
+            }
+        }
+        return sb.delete(sb.length() - 6, sb.length()).toString();
+    }
+
+    public static String listToArrowSep(List<String> strings) {
+        if (strings.isEmpty()) return "&6None";
+
+        StringBuilder sb = new StringBuilder();
+        strings.forEach(s -> sb.append("&6").append(s).append("&e ---> "));
+        return sb.delete(sb.length() - 6, sb.length()).toString();
+    }
+
+    public static String permNodesToString(Map<String, Boolean> nodes) {
+        if (nodes.isEmpty()) return "&6None";
+
+        StringBuilder sb = new StringBuilder();
+
+        for (Map.Entry<String, Boolean> e : nodes.entrySet()) {
+            if (e.getValue()) {
+                sb.append("&a").append(e.getKey()).append("&7, ");
+            } else {
+                sb.append("&c").append(e.getKey()).append("&7, ");
+            }
         }
 
         return sb.delete(sb.length() - 2, sb.length()).toString();
     }
 
-    public static String nodesToString(Map<String, Boolean> nodes) {
+    public static String tempNodesToString(Map<Map.Entry<String, Boolean>, Long> nodes) {
         if (nodes.isEmpty()) return "&6None";
 
         StringBuilder sb = new StringBuilder();
 
-        for (String node : nodes.keySet()) {
-            if (nodes.get(node)) {
-                sb.append("&a").append(node).append("&7, ");
+        for (Map.Entry<Map.Entry<String, Boolean>, Long> e : nodes.entrySet()) {
+            if (e.getKey().getValue()) {
+                sb.append("&a").append(e.getKey().getKey()).append("&6 - expires in ")
+                        .append(DateUtil.formatDateDiff(e.getValue())).append("\n");
             } else {
-                sb.append("&c").append(node).append("&7, ");
+                sb.append("&c").append(e.getKey().getKey()).append("&6 - expires in ")
+                        .append(DateUtil.formatDateDiff(e.getValue())).append("\n");
             }
         }
 
-        return sb.delete(sb.length() - 2, sb.length()).toString();
+        return sb.toString();
     }
 
     public static UUID parseUuid(String s) {