Release 1.6

README.md

@@ -4,247 +4,14 @@ A permissions implementation for Bukkit/Spigot, BungeeCord and Sponge.
 ## Links
 * **Development Builds** - <https://ci.lucko.me/job/LuckPerms>
 * **Javadocs** - <https://jd.lucko.me/LuckPerms>
+* **Wiki** - <https://github.com/lucko/LuckPerms/wiki>
 
-## Features
-* **Group inheritance** - users can be members of multiple groups, groups can inherit other groups
-* **Temporary permissions** - users/groups can be given permissions that expire after a given time
-* **Wildcard permissions** - users/groups can be given wildcard permissions (e.g. "minecraft.command.*"), even when plugins haven't implemented their own wildcards.
-* **Temporary groups** - users/groups can be added to/inherit other groups temporarily
-* **Multi-server support** - data is synced across all servers/platforms
-* **Full offline-mode/mixed-mode support** - player permissions are synced properly over offline-mode or mixed online/offline-mode networks.
-* **Per-server permissions/groups** - define user/group permissions that only apply on certain servers
-* **Per-world permissions/groups** - define user/group permissions that only apply on certain worlds (on BungeeCord, a connected Bukkit/Spigot instance is treated as a world)
-* **Tracks / paths / ladders** - users can be promoted/demoted along multiple group tracks
-* **Vault Support** - hooks into Vault to integrate with other plugins
-* **Developer API** - easily integrate LuckPerms into your own projects
-* **Advanced action logging** - keep track of permission changes over time
-* **Easy and simple setup and configuration using commands** - no editing yml files, yuck
-* **Negated permissions and groups** - define special rules for certain users/groups
-* **Regex permissions** - define special permissions using regex
-* **Shorthand nodes** - add nodes using the LuckPerms shorthand system
-* **Full support for UUIDs, even in Offline Mode** - users can change their usernames without losing permissions. In offline mode, a single user has the same internal UUID across a network.
-* **Permission data stored within MySQL in a json format** - easily integrate the LuckPerms backend into your other projects
-* **Well documented** - API methods have comprehensive Java docs, it's clear what each method does.
-* **Efficient/lightweight** - maybe? Who knows, it might be.
-* **Open Sourced, Free...** - you shouldn't have to pay $10+ for a "powerful" permissions plugin.
-* **BungeeCord compatible** - permissions, users and groups are synced across all LuckPerms instances
-* **Sponge compatible** - permissions, users and groups are synced across all LuckPerms instances (bukkit --> sponge, for example)
-* **Support for MySQL, SQLite & Flatfile (JSON)** - other storage methods coming soon (maybe)
+## 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.
 
-## Setup
-All configuration options are in the **config.yml/luckperms.conf** file, which is generated automagically when the plugin first starts.
-
-You can define the settings for per-server permissions, the storage method and credentials within this file.
-
-## Info
-### Permission Calculation
-#### Permissions are calculated based on a priority system as follows.
-
-* **Non wildcard/regex permissions will be overridden by normal permissions**
-
-Example: if a user has a true permission set for "luckperms.\*", and a false permission set for "luckperms.something", the non-wildcard permission will override the wildcard, and "luckperms.something" will be set to false, despite the wildcard.
-
-* **More specific wildcards override less specific ones**
-
-Example: if a user has "luckperms.\*" set to true, but "luckperms.user.\*" set to false, all of the user permissions will be set to false, despite the more generic wildcard for "luckperms.*".
-
-* **Temporary permissions will override non-temporary permissions.**
-
-Example: if a user has a false permission set for "test.node", and a temporary true permission set for "test.node", the temporary permission will override the permanent one, and the user will be granted the true node.
-
-* **World specific permissions will override generic permissions.**
-
-Example: if a user has a global "fly.use" permission, and then has a negated "fly.use" permission in the "world_nether" world, the world specific permission will override the globally defined one, and the user will be granted the negated node (provided they're in that world, of course.).
-
-* **Server specific permissions will override generic/global permissions.**
-
-Example: if a user has a global "fly.use" permission, and then has a negated "fly.use" permission on the "factions" server, the server specific permission will override the globally defined one, and the user will be granted the negated node (provided they're on that server).
-
-* **Inherited permissions will be overridden by an objects own permissions.**
-
-Example: A user is a member of the default group, which grants "some.thing.perm", but the users own permissions has "some.thing.perm" set to false. The inherited permission will be overridden by the users own permissions, and the user will be granted the negative node.
-
-### Temporary Permissions
-Temporary permissions are checked each time a user/group is loaded, and when the sync task runs. This means if you set a temporary permission to expire after 30 seconds, it won't actually be removed until the sync task runs.
-
-The only way around this is to decrease the sync interval.
-
-### Shorthand Permissions
-LuckPerms has it's own system (although it's quite similar to PermissionsEx :P) that allows you to set permissions in a shorthand format.
-
-Using the LuckPerms permission nodes as an example, say for instance, you wanted to let a user set and unset permissions for both groups and users.
-
-Without shorthand, you would have to apply 4 nodes.
-```
-luckperms.user.setpermission
-luckperms.user.unsetpermission
-luckperms.group.setpermission
-luckperms.group.unsetpermission
-```
-However, with shorthand, you can just apply the following node:
-
-`luckperms.(user|group).(setpermission|unsetpermission)`
-
-You use brackets to define part of a node as a shorthand group, and then use the vertical bar `|` to separate entries.
-
-There are some limitations, firstly, you cannot use shorthand in the first part of the node. (The "luckperms" part in the example above)
-
-Additionally, you cannot combine shorthand and normal text in the same part of the node.
-For example, `luckperms.(user|group).(set|unset)permission` would not work.
-
-### Regex
-LuckPerms has support for regex when defining permission nodes and server/world names.
-
-Whenever regex is used, it MUST be prefixed with "R=", so LuckPerms knows to treat it as regex, and not as a normal string.
-
-For example, if you wanted to give all members of the default group, the `essentials.fly` permission on all of your hub servers, where the hub server names are hub1, hub2, hub3, etc.
-You would use the command `/perms group default set essentials.fly true R=hub\d+`.
-
-You can also use regex in permission nodes.
-Once again using LuckPerms permissions as an example, if you wanted a user to be able to create both groups and tracks, you would normally just add the two permission nodes. However with regex, you can just add one. `luckperms\.create.*` Remember to escape any characters, specifically dots, as the entire node will be parsed.
-
-## API
-LuckPerms has an extensive API, allowing for easy integration with other projects. To use the Api, you need to obtain an instance of the `LuckPermsApi` interface. This can be done in a number of ways.
-
-```java
-// On all platforms (throws IllegalStateException if the API is not loaded)
-final LuckPermsApi api = LuckPerms.getApi();
-
-// Or with Optional
-Optional<LuckPermsApi> provider = LuckPerms.getApiSafe();
-if (provider.isPresent()) {
-    final LuckPermsApi api = provider.get();
-}
-
-// On Bukkit/Spigot
-ServicesManager manager = Bukkit.getServicesManager();
-if (manager.isProvidedFor(LuckPermsApi.class)) {
-    final LuckPermsApi api = manager.getRegistration(LuckPermsApi.class).getProvider();
-}
-
-// On Sponge
-Optional<LuckPermsApi> provider = Sponge.getServiceManager().provide(LuckPermsApi.class);
-if (provider.isPresent()) {
-    final LuckPermsApi api = provider.get();
-}
-```
-
-If you want to use LuckPerms in your onEnable method, you need to add the following to your plugins `plugin.yml`.
-```yml
-depend: [LuckPerms]
-```
-All of the available methods can be seen in the various interfaces in the `luckperms-api` module.
-
-You can add LuckPerms as a Maven dependency by adding the following to your projects `pom.xml`.
-````xml
-<repositories>
-    <repository>
-        <id>luck-repo</id>
-        <url>https://repo.lucko.me/</url>
-    </repository>
-</repositories>
-
-<dependencies>
-    <dependency>
-        <groupId>me.lucko.luckperms</groupId>
-        <artifactId>luckperms-api</artifactId>
-        <version>2.1</version>
-    </dependency>
-</dependencies>
-````
-
-## Versioning
-As of version 2.0, LuckPerms roughly follows the standards set out in Semantic Versioning.
-
-The only difference is that the patch number is not included anywhere within the pom, and is calculated each build, based upon how may commits have been made since the last tag. (A new tag is made every minor version)
-
-This means that API versions do not have a patch number (as no API changes are made in patches). API versions will be x.y, and each individual build of LuckPerms will follow x.y.z.
-
-## Commands
-Command usage is printed to the console/chat whenever invalid arguments are provided. Simply typing /perms will list all commands a user has permission to use.
-
-### Aliases
-| Bukkit           | Bungee           |
-|------------------|------------------|
-| /luckperms       | /luckpermsbungee |
-| /perms           | /bperms          |
-| /permissions     | /bpermissions    |
-| /lp              | /lpb             |
-| /perm            | /bperm           |
-
-Arguments: \<required\> [optional]
-
-Users with OP have access to all commands.
-
-Additionally, you can use wildcards to grant users access to a selection of commands.
-* **All commands** - luckperms.*
-* **All user commands** - luckperms.user.*
-* **All group commands** - luckperms.group.*
-* **All track commands** - luckperms.track.*
-
-### General
-*  /perms - n/a
-*  /perms sync - luckperms.sync
-*  /perms info - luckperms.info
-*  /perms debug - luckperms.debug
-*  /perms creategroup \<group\> - luckperms.creategroup
-*  /perms deletegroup \<group\> - luckperms.deletegroup
-*  /perms listgroups - luckperms.listgroups
-*  /perms createtrack \<track\> - luckperms.createtrack
-*  /perms deletetrack \<track\> - luckperms.deletetrack
-*  /perms listtracks - luckperms.listtracks
-
-### User
-*  /perms user \<user\> info - luckperms.user.info
-*  /perms user \<user\> getuuid - luckperms.user.getuuid
-*  /perms user \<user\> listnodes - luckperms.user.listnodes
-*  /perms user \<user\> haspermission \<node\> [server] [world] - luckperms.user.haspermission
-*  /perms user \<user\> inheritspermission \<node\> [server] [world] - luckperms.user.inheritspermission
-*  /perms user \<user\> set \<node\> \<true/false\> [server] [world] - luckperms.user.setpermission
-*  /perms user \<user\> unset \<node\> [server] [world] -  luckperms.user.unsetpermission
-*  /perms user \<user\> addgroup \<group\> [server] [world] - luckperms.user.addgroup
-*  /perms user \<user\> removegroup \<group\> [server] [world] - luckperms.user.removegroup
-*  /perms user \<user\> settemp \<node\> \<true/false\> \<duration\> [server] [world] - luckperms.user.settemppermission
-*  /perms user \<user\> unsettemp \<node\> [server] [world] - luckperms.user.unsettemppermission
-*  /perms user \<user\> addtempgroup \<group\> \<duration\> [server] [world] - luckperms.user.addtempgroup
-*  /perms user \<user\> removetempgroup \<group\> [server] [world] - luckperms.user.removetempgroup
-*  /perms user \<user\> setprimarygroup \<group\> - luckperms.user.setprimarygroup
-*  /perms user \<user\> showtracks - luckperms.user.showtracks
-*  /perms user \<user\> promote \<track\> - luckperms.user.promote
-*  /perms user \<user\> demote \<track\> - luckperms.user.demote
-*  /perms user \<user\> showpos \<track\> - luckperms.user.showpos
-*  /perms user \<user\> clear - luckperms.user.clear
-
-### Group
-*  /perms group \<group\> info - 	luckperms.group.info
-*  /perms group \<group\> listnodes - luckperms.group.listnodes
-*  /perms group \<group\> haspermission \<node\> [server] [world] - luckperms.group.haspermission
-*  /perms group \<group\> inheritspermission \<node\> [server] [world] - luckperms.group.inheritspermission
-*  /perms group \<group\> set \<node\> \<true/false\> [server] [world] - luckperms.group.setpermission
-*  /perms group \<group\> unset \<node\> [server] [world] - luckperms.group.unsetpermission
-*  /perms group \<group\> setinherit \<group\> [server] [world] - luckperms.group.setinherit
-*  /perms group \<group\> unsetinherit \<group\> [server] [world] - luckperms.group.unsetinherit
-*  /perms group \<group\> settemp \<node\> \<true/false\> \<duration\> [server] [world] - settemppermission
-*  /perms group \<group\> unsettemp \<node\> [server] [world] - luckperms.group.unsettemppermission
-*  /perms group \<group\> settempinherit \<group\> \<duration\> [server] [world] - luckperms.group.settempinherit
-*  /perms group \<group\> unsettempinherit \<group\> [server] [world] - luckperms.group.unsettempinherit
-*  /perms group \<group\> showtracks - luckperms.group.showtracks
-*  /perms group \<group\> clear - luckperms.group.clear
-
-### Track
-*  /perms track \<track\> info - luckperms.track.info
-*  /perms track \<track\> append \<group\> - luckperms.track.append
-*  /perms track \<track\> insert \<group\> \<position\> - luckperms.track.insert
-*  /perms track \<track\> remove \<group\> - luckperms.track.remove
-*  /perms track \<track\> clear - luckperms.track.clear
-
-### Log
-*  /perms log recent [user] [page] - luckperms.log.recent
-*  /perms log search \<query\> [page] - luckperms.log.search
-*  /perms log notify [on|off] - luckperms.log.notify
-*  /perms log userhistory \<user\> [page] - luckperms.log.userhistory
-*  /perms log grouphistory \<group\> [page] - luckperms.log.grouphistory
-*  /perms log trackhistory \<track\> [page] - luckperms.log.trackhistory
+## LuckPerms vs Other Plugins
+![alt text](https://static.lucko.me/luckperms-compare-copy.png "Feature comparison")
+_Features checked on 23rd Aug 2016. If you find any inaccuracies, please do let me know. I tried to be as fair as possible, and copy all major features from the respective plugin pages._
 
 ## License
-See LICENSE.md.
+See LICENSE.md.

api/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>luckperms</artifactId>
         <groupId>me.lucko.luckperms</groupId>
-        <version>2.3</version>
+        <version>2.6-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
@@ -23,4 +23,15 @@
             </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

@@ -22,8 +22,6 @@
 
 package me.lucko.luckperms;
 
-import lombok.AccessLevel;
-import lombok.NoArgsConstructor;
 import me.lucko.luckperms.api.LuckPermsApi;
 
 import java.util.Optional;
@@ -31,12 +29,9 @@ import java.util.Optional;
 /**
  * Static access to LuckPerms
  */
-@NoArgsConstructor(access = AccessLevel.PRIVATE)
 public final class LuckPerms {
-
     private static LuckPermsApi api = null;
 
-
     /**
      * Gets an instance of {@link LuckPermsApi}
      * @return an api instance
@@ -66,4 +61,8 @@ public final class LuckPerms {
         api = null;
     }
 
+    private LuckPerms() {
+        throw new UnsupportedOperationException("This class cannot be instantiated.");
+    }
+
 }

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

@@ -24,13 +24,11 @@ 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
- *
- * <p> The implementations of this interface limit access to the datastore and add parameter checks to further prevent
- * errors and ensure all API interactions to not damage the state of the plugin.
  */
 @SuppressWarnings("unused")
 public interface Datastore {
@@ -38,16 +36,230 @@ public interface Datastore {
     String getName();
     boolean isAcceptingLogins();
 
-    Async async();
+    /**
+     * 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);
@@ -62,32 +274,24 @@ public interface Datastore {
         void getUUID(String username, Callback<UUID> callback);
     }
 
-    interface Sync {
-        boolean logAction(LogEntry entry);
-        Log getLog();
-        boolean loadOrCreateUser(UUID uuid, String username);
-        boolean loadUser(UUID uuid);
-        boolean saveUser(User user);
-        boolean createAndLoadGroup(String name);
-        boolean loadGroup(String name);
-        boolean loadAllGroups();
-        boolean saveGroup(Group group);
-        boolean deleteGroup(Group group);
-        boolean createAndLoadTrack(String name);
-        boolean loadTrack(String name);
-        boolean loadAllTracks();
-        boolean saveTrack(Track track);
-        boolean deleteTrack(Track track);
-        boolean saveUUIDData(String username, UUID uuid);
-        UUID getUUID(String username);
-    }
-
+    /**
+     * 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();

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

@@ -29,9 +29,6 @@ import java.util.List;
 
 /**
  * Wrapper interface for internal Group instances
- *
- * <p> The implementations of this interface limit access to the Group and add parameter checks to further prevent
- * errors and ensure all API interactions to not damage the state of the group.
  */
 @SuppressWarnings("unused")
 public interface Group extends PermissionHolder {
@@ -42,26 +39,34 @@ public interface Group extends PermissionHolder {
     String getName();
 
     /**
-     * check to see if a group inherits a group
+     * Check to see if a group inherits a group
      * @param group The group to check membership of
-     * @return true if the user is a member of the group
+     * @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
+     * 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
+     * @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
+     * 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
+     * @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);
 
@@ -69,101 +74,134 @@ public interface Group extends PermissionHolder {
      * 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 add the group on
+     * @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
+     * Make this group inherit another group on a specific server and world
      * @param group the group to be inherited
-     * @param server The server to add the group on
-     * @param world The world to add the group on
-     * @throws ObjectAlreadyHasException if the group already inherits the group on that server
+     * @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 on a specific server
+     * Make this group inherit another group temporarily
      * @param group the group to be inherited
-     * @param expireAt when the group should expire
-     * @throws ObjectAlreadyHasException if the group already inherits the group on that server
+     * @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
+     * Make this group inherit another group on a specific server temporarily
      * @param group the group to be inherited
-     * @param server The server to add the group on
+     * @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
+     * @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
+     * 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 add the group on
-     * @param world The world to add the group on
+     * @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
+     * @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
+     * 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
+     * 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
+     * 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
+     * @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
+     * 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
+     * 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
+     * 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 is temporary
+     * @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;
 
@@ -183,6 +221,8 @@ public interface Group extends PermissionHolder {
      * @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);
 
@@ -190,6 +230,8 @@ public interface Group extends PermissionHolder {
      * 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

@@ -22,11 +22,13 @@
 
 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 {
 
     /**
@@ -41,12 +43,16 @@ public interface LPConfiguration {
 
     /**
      * @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();
 
     /**
@@ -76,9 +82,17 @@ public interface LPConfiguration {
 
     /**
      * @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
      */

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

@@ -28,7 +28,7 @@ import java.util.UUID;
 
 /**
  * Represents the internal LuckPerms log.
- * All content is immutable. You can add to the log using the {@link Datastore}, and then request an updated copy.
+ * 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 {
@@ -38,27 +38,124 @@ public interface 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

@@ -22,29 +22,62 @@
 
 package me.lucko.luckperms.api;
 
-import lombok.*;
-
 import java.util.UUID;
 
-@Getter
-@Builder
-@ToString
-@EqualsAndHashCode
-@AllArgsConstructor
-public final class LogEntry implements Comparable<LogEntry> {
+/**
+ * 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";
 
-    @NonNull private final long timestamp;
-    @NonNull private final UUID actor;
-    @NonNull private final String actorName;
-    @NonNull private final char type;
-    private final UUID acted;
-    @NonNull private final String actedName;
-    @NonNull private final String action;
+    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 Long.compare(timestamp, o.getTimestamp());
+        return equals(o) ? 0 : (Long.compare(timestamp, o.getTimestamp()) == 0 ? 1 : Long.compare(timestamp, o.getTimestamp()));
     }
 
     public boolean matchesSearch(String query) {
@@ -55,10 +88,231 @@ public final class LogEntry implements Comparable<LogEntry> {
 
     public String getFormatted() {
         return String.format(FORMAT,
-                getActorName(),
-                Character.toString(getType()),
-                getActedName(),
-                getAction()
+                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/LuckPermsApi.java

@@ -22,12 +22,14 @@
 
 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
+ * The root API interface in LuckPerms
  */
 @SuppressWarnings("unused")
 public interface LuckPermsApi {
@@ -37,11 +39,31 @@ public interface LuckPermsApi {
      */
     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
@@ -70,6 +92,7 @@ public interface LuckPermsApi {
      * 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);
 
@@ -77,6 +100,7 @@ public interface LuckPermsApi {
      * Gets a wrapped user object from the user storage. This method does not return null, unlike {@link #getUser(UUID)}
      * @param uuid the uuid of the user to get
      * @return an optional {@link User} object
+     * @throws NullPointerException if the uuid is null
      */
     Optional<User> getUserSafe(UUID uuid);
 
@@ -84,6 +108,7 @@ public interface LuckPermsApi {
      * Gets a wrapped user object from the user storage
      * @param name the username of the user to get
      * @return a {@link User} object, if one matching the uuid is loaded, or null if not
+     * @throws NullPointerException if the name is null
      */
     User getUser(String name);
 
@@ -91,6 +116,7 @@ public interface LuckPermsApi {
      * 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);
 
@@ -104,13 +130,23 @@ public interface LuckPermsApi {
      * 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);
 
@@ -118,6 +154,7 @@ public interface LuckPermsApi {
      * Gets a wrapped group object from the group storage. This method does not return null, unlike {@link #getGroup}
      * @param name the name of the group to get
      * @return an optional {@link Group} object
+     * @throws NullPointerException if the name is null
      */
     Optional<Group> getGroupSafe(String name);
 
@@ -131,6 +168,7 @@ public interface LuckPermsApi {
      * 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);
 
@@ -138,6 +176,7 @@ public interface LuckPermsApi {
      * Gets a wrapped track object from the track storage
      * @param name the name of the track to get
      * @return a {@link Track} object, if one matching the name exists, or null if not
+     * @throws NullPointerException if the name is null
      */
     Track getTrack(String name);
 
@@ -145,6 +184,7 @@ public interface LuckPermsApi {
      * 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);
 
@@ -158,7 +198,18 @@ public interface LuckPermsApi {
      * 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

@@ -27,25 +27,83 @@ 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
- *
- * <p> The implementations of this interface limit access to the object and add parameter checks to further prevent
- * errors and ensure all API interactions to not damage the state of the object.
  */
 @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 user has the permission
+     * @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);
 
@@ -54,26 +112,32 @@ public interface PermissionHolder {
      * @param node The permission node
      * @param b If the node is true/false(negated)
      * @param server The server
-     * @return true if the user has the permission
+     * @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
+     * 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 user has the permission
+     * @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 on a certain server
+     * 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 user has the permission
+     * @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);
 
@@ -83,26 +147,41 @@ public interface PermissionHolder {
      * @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 user has the permission
+     * @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
+     * 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 user has the permission
+     * @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 user inherits the permission
+     * @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);
 
@@ -111,175 +190,282 @@ public interface PermissionHolder {
      * @param node The permission node
      * @param b If the node is true/false(negated)
      * @param server The server
-     * @return true if the user inherits the permission
+     * @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
+     * 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 user inherits the permission
+     * @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 certain permission
+     * 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 user inherits the permission
+     * @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 certain permission
+     * 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 user inherits the permission
+     * @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 certain permission
+     * 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 user inherits the permission
+     * @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
+     * 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
+     * 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 permission for the object
+     * 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 permission for the object
+     * 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 permission for the object
+     * 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
+     * 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
+     * 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
+     * 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
+     * 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
+     * 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
+     * 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);
 
     /**
@@ -288,7 +474,9 @@ public interface PermissionHolder {
      * @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);
 
     /**
@@ -296,21 +484,54 @@ public interface PermissionHolder {
      * @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);
 
     /**
-     * Processes the objects and returns the temporary ones.
-     * @return a map of temporary nodes
+     * 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 objects and returns the non-temporary ones.
-     * @return a map of permanent nodes
+     * 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
      */

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

@@ -29,18 +29,19 @@ import java.util.List;
 
 /**
  * Wrapper interface for internal Track instances
- *
- * <p> The implementations of this interface limit access to the Track and add parameter checks to further prevent
- * errors and ensure all API interactions to not damage the state of the track.
  */
 @SuppressWarnings("unused")
 public interface Track {
 
+    /**
+     * @return the name of this track
+     */
     String getName();
 
     /**
      * Gets an ordered list of the groups on this track
-     * @return am ordered {@link 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();
 
@@ -55,14 +56,18 @@ public interface Track {
      * @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 group before the group provided
+     * 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;
 
@@ -70,6 +75,8 @@ public interface Track {
      * 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;
 
@@ -79,6 +86,8 @@ public interface Track {
      * @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;
 
@@ -86,6 +95,8 @@ public interface Track {
      * 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;
 
@@ -93,6 +104,7 @@ public interface Track {
      * 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;
 
@@ -100,6 +112,8 @@ public interface Track {
      * Checks if a group features on this track
      * @param group the group to check
      * @return true if the group is on this track
+     * @throws NullPointerException if the group is null
+     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
      */
     boolean containsGroup(Group group);
 
@@ -107,6 +121,7 @@ public interface Track {
      * Checks if a group features on this track
      * @param group the group to check
      * @return true if the group is on this track
+     * @throws NullPointerException if the group is null
      */
     boolean containsGroup(String group);
 

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

@@ -30,9 +30,6 @@ import java.util.UUID;
 
 /**
  * Wrapper interface for internal User instances
- *
- * <p> The implementations of this interface limit access to the User and add parameter checks to further prevent
- * errors and ensure all API interactions to not damage the state of the user.
  */
 @SuppressWarnings("unused")
 public interface User extends PermissionHolder {
@@ -55,10 +52,12 @@ public interface User extends PermissionHolder {
 
     /**
      * Sets a users primary group
-     * @param s the new 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 s) throws ObjectAlreadyHasException;
+    void setPrimaryGroup(String group) throws ObjectAlreadyHasException;
 
     /**
      * Refresh and re-assign the users permissions
@@ -69,6 +68,7 @@ public interface User extends PermissionHolder {
      * 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);
 
@@ -77,15 +77,19 @@ public interface User extends PermissionHolder {
      * @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
+     * 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);
 
@@ -93,6 +97,8 @@ public interface User extends PermissionHolder {
      * 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;
 
@@ -101,42 +107,57 @@ public interface User extends PermissionHolder {
      * @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
+     * 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 on a specific server
+     * 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 on a specific server
+     * 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 on a specific server
+     * 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;
 
@@ -144,6 +165,8 @@ public interface User extends PermissionHolder {
      * 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;
 
@@ -152,42 +175,56 @@ public interface User extends PermissionHolder {
      * @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
+     * 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
+     * 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
+     * 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
+     * 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;
 
@@ -207,6 +244,8 @@ public interface User extends PermissionHolder {
      * @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);
 
@@ -214,6 +253,8 @@ public interface User extends PermissionHolder {
      * 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/data/Callback.java

@@ -22,23 +22,36 @@
 
 package me.lucko.luckperms.api.data;
 
-import lombok.NonNull;
-
 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(@NonNull Runnable runnable) {
+    static <T> Callback<T> of(Runnable runnable) {
+        if (runnable == null) {
+            throw new NullPointerException("runnable");
+        }
         return t -> runnable.run();
     }
 
-    static <T> Callback<T> of(@NonNull Consumer<T> consumer) {
+    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

@@ -22,6 +22,10 @@
 
 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();

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

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

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>luckperms</artifactId>
         <groupId>me.lucko.luckperms</groupId>
-        <version>2.3</version>
+        <version>2.6-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
@@ -14,7 +14,7 @@
 
     <build>
         <defaultGoal>clean package</defaultGoal>
-        <finalName>LuckPerms-${project.version}.${git.closest.tag.commit.count}</finalName>
+        <finalName>LuckPerms-${release.version}.${git.closest.tag.commit.count}</finalName>
         <sourceDirectory>${basedir}/src/main/java</sourceDirectory>
         <resources>
             <resource>
@@ -43,7 +43,12 @@
                             <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>
@@ -53,6 +58,18 @@
                                     <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>
@@ -105,19 +122,12 @@
             <version>${project.version}</version>
             <scope>compile</scope>
         </dependency>
-        <!-- HikariCP -->
+        <!-- Lombok -->
         <dependency>
-            <groupId>com.zaxxer</groupId>
-            <artifactId>HikariCP</artifactId>
-            <version>2.4.7</version>
-            <scope>compile</scope>
-        </dependency>
-        <!-- slf4j library -->
-        <dependency>
-            <groupId>org.slf4j</groupId>
-            <artifactId>slf4j-simple</artifactId>
-            <version>1.7.9</version>
-            <scope>compile</scope>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>1.16.10</version>
+            <scope>provided</scope>
         </dependency>
     </dependencies>
 </project>

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

@@ -30,6 +30,9 @@ 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;
@@ -62,25 +65,37 @@ class BukkitListener extends AbstractListener implements Listener {
 
         if (user instanceof BukkitUser) {
             BukkitUser u = (BukkitUser) user;
-            u.setAttachment(player.addAttachment(plugin));
+
+            PermissionAttachment attachment = player.addAttachment(plugin);
+            try {
+                BukkitUser.getPermissionsField().set(attachment, new ConcurrentHashMap<>());
+            } catch (Throwable t) {
+                t.printStackTrace();
+            }
+
+            u.setAttachment(attachment);
         }
 
-        user.refreshPermissions();
+        plugin.doAsync(user::refreshPermissions);
     }
 
     @EventHandler
     public void onPlayerJoin(PlayerJoinEvent e) {
         // Refresh permissions again
-        refreshPlayer(e.getPlayer().getUniqueId());
+        plugin.getUserManager().getWorldCache().put(e.getPlayer().getUniqueId(), e.getPlayer().getWorld().getName());
+        plugin.doAsync(() -> refreshPlayer(e.getPlayer().getUniqueId()));
     }
 
     @EventHandler
     public void onPlayerChangedWorld(PlayerChangedWorldEvent e) {
-        refreshPlayer(e.getPlayer().getUniqueId());
+        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/LPBukkitPlugin.java

@@ -27,19 +27,19 @@ 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.runnables.ExpireTemporaryTask;
 import me.lucko.luckperms.runnables.UpdateTask;
 import me.lucko.luckperms.storage.Datastore;
-import me.lucko.luckperms.storage.methods.FlatfileDatastore;
-import me.lucko.luckperms.storage.methods.MySQLDatastore;
-import me.lucko.luckperms.storage.methods.SQLiteDatastore;
+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.LogFactory;
 import org.bukkit.command.PluginCommand;
 import org.bukkit.entity.Player;
@@ -49,18 +49,22 @@ import org.bukkit.plugin.java.JavaPlugin;
 
 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 {
-    private final Set<UUID> ignoringLogs = new HashSet<>();
+    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() {
@@ -81,38 +85,15 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
         main.setTabCompleter(commandManager);
         main.setAliases(Arrays.asList("perms", "lp", "permissions", "p", "perm"));
 
-        getLog().info("Detecting storage method...");
-        final String storageMethod = configuration.getStorageMethod();
-        if (storageMethod.equalsIgnoreCase("mysql")) {
-            getLog().info("Using MySQL as storage method.");
-            datastore = new MySQLDatastore(this, configuration.getDatabaseValues());
-        } else if (storageMethod.equalsIgnoreCase("sqlite")) {
-            getLog().info("Using SQLite as storage method.");
-            datastore = new SQLiteDatastore(this, new File(getDataFolder(), "luckperms.sqlite"));
-        } else if (storageMethod.equalsIgnoreCase("flatfile")) {
-            getLog().info("Using Flatfile (JSON) as storage method.");
-            datastore = new FlatfileDatastore(this, getDataFolder());
-        } else {
-            getLog().severe("Storage method '" + storageMethod + "' was not recognised. Using SQLite as fallback.");
-            datastore = new SQLiteDatastore(this, new File(getDataFolder(), "luckperms.sqlite"));
-        }
-
-        getLog().info("Initialising datastore...");
-        datastore.init();
+        datastore = StorageFactory.getDatastore(this, "h2");
 
         getLog().info("Loading internal permission managers...");
         uuidCache = new UuidCache(getConfiguration().getOnlineMode());
         userManager = new BukkitUserManager(this);
         groupManager = new GroupManager(this);
         trackManager = new TrackManager();
-
-        // 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();
-        }
+        importer = new Importer(commandManager);
+        consecutiveExecutor = new ConsecutiveExecutor(commandManager);
 
         int mins = getConfiguration().getSyncTime();
         if (mins > 0) {
@@ -121,6 +102,8 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
         }
 
         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...");
@@ -137,9 +120,17 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
         }
 
         getLog().info("Registering API...");
-        final ApiProvider provider = new ApiProvider(this);
-        LuckPerms.registerProvider(provider);
-        getServer().getServicesManager().register(LuckPermsApi.class, provider, this, ServicePriority.Normal);
+        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.");
     }
@@ -169,6 +160,16 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
         return getDescription().getVersion();
     }
 
+    @Override
+    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;
@@ -189,6 +190,11 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
         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<>();
@@ -201,6 +207,21 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
         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() {
         getServer().getScheduler().runTaskAsynchronously(this, new UpdateTask(this));

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

@@ -22,128 +22,389 @@
 
 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 net.milkbowl.vault.permission.Permission;
+
+import java.util.Map;
+
+import static me.lucko.luckperms.utils.ArgumentChecker.escapeCharacters;
+import static me.lucko.luckperms.utils.ArgumentChecker.unescapeCharacters;
 
 /**
- * Dummy class for hooking with Vault plugins that need both Chat + Perms
- * This doesn't return anything useful, or change anything internally
+ * Provides the Vault Chat service through the use of normal permission nodes.
  *
- * Registered on the lowest priority so other plugins can override
+ * 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.
  */
-class VaultChatHook extends Chat {
+public class VaultChatHook extends Chat {
 
-    VaultChatHook(Permission perms) {
+    @Setter
+    private LPBukkitPlugin plugin;
+    private final VaultPermissionHook perms;
+
+    VaultChatHook(VaultPermissionHook perms) {
         super(perms);
-    }
-
-    private void throwNotSupported() {
-        // throw new UnsupportedOperationException("LuckPerms cannot perform this operation.");
+        this.perms = perms;
     }
 
     public String getName() {
-        return "LuckPerms";
+        return perms.getName();
     }
 
-
     public boolean isEnabled() {
-        return true;
+        return perms.isEnabled();
     }
 
-    public String getPlayerPrefix(String world, String player) {
-        return "";
+    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);
     }
 
-    public void setPlayerPrefix(String world, String player, String prefix) {
-        throwNotSupported();
-    }
+    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);
 
-    public String getPlayerSuffix(String world, String player) {
-        return "";
-    }
+        for (Node n : holder.getPermissions()) {
+            if (!n.isMeta()) {
+                continue;
+            }
 
-    public void setPlayerSuffix(String world, String player, String suffix) {
-        throwNotSupported();
-    }
+            if (!n.shouldApplyOnWorld(world, true, false)) {
+                continue;
+            }
 
-    public String getGroupPrefix(String world, String group) {
-        return "";
-    }
+            Map.Entry<String, String> meta = n.getMeta();
+            if (meta.getKey().equalsIgnoreCase(node)) {
 
-    public void setGroupPrefix(String world, String group, String prefix) {
-        throwNotSupported();
-    }
+                try {
+                    return Integer.parseInt(unescapeCharacters(meta.getValue()));
+                } catch (Throwable t) {
+                    return defaultValue;
+                }
 
-    public String getGroupSuffix(String world, String group) {
-        return "";
-    }
+            }
+        }
 
-    public void setGroupSuffix(String world, String group, String suffix) {
-        throwNotSupported();
-    }
-
-    public int getPlayerInfoInteger(String world, String player, String node, int defaultValue) {
         return defaultValue;
     }
 
-    public void setPlayerInfoInteger(String world, String player, String node, int value) {
-        throwNotSupported();
-    }
+    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;
+                }
+
+            }
+        }
 
-    public int getGroupInfoInteger(String world, String group, String node, int defaultValue) {
         return defaultValue;
     }
 
-    public void setGroupInfoInteger(String world, String group, String node, int value) {
-        throwNotSupported();
-    }
+    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;
+                }
+
+            }
+        }
 
-    public double getPlayerInfoDouble(String world, String player, String node, double defaultValue) {
         return defaultValue;
     }
 
-    public void setPlayerInfoDouble(String world, String player, String node, double value) {
-        throwNotSupported();
-    }
+    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;
+                }
+
+            }
+        }
 
-    public double getGroupInfoDouble(String world, String group, String node, double defaultValue) {
         return defaultValue;
     }
 
-    public void setGroupInfoDouble(String world, String group, String node, double value) {
-        throwNotSupported();
+    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 boolean getPlayerInfoBoolean(String world, String player, String node, boolean defaultValue) {
-        return defaultValue;
+    public String getPlayerPrefix(String world, @NonNull String player) {
+        final User user = plugin.getUserManager().get(player);
+        return getChatMeta(true, user, world);
     }
 
-    public void setPlayerInfoBoolean(String world, String player, String node, boolean value) {
-        throwNotSupported();
+    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 boolean getGroupInfoBoolean(String world, String group, String node, boolean defaultValue) {
-        return defaultValue;
+    public String getPlayerSuffix(String world, @NonNull String player) {
+        final User user = plugin.getUserManager().get(player);
+        return getChatMeta(false, user, world);
     }
 
-    public void setGroupInfoBoolean(String world, String group, String node, boolean value) {
-        throwNotSupported();
+    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 getPlayerInfoString(String world, String player, String node, String defaultValue) {
-        return defaultValue;
+    public String getGroupPrefix(String world, @NonNull String group) {
+        final Group g = plugin.getGroupManager().get(group);
+        return getChatMeta(false, g, world);
     }
 
-    public void setPlayerInfoString(String world, String player, String node, String value) {
-        throwNotSupported();
+    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 getGroupInfoString(String world, String group, String node, String defaultValue) {
-        return defaultValue;
+    public String getGroupSuffix(String world, @NonNull String group) {
+        final Group g = plugin.getGroupManager().get(group);
+        return getChatMeta(false, g, world);
     }
 
-    public void setGroupInfoString(String world, String group, String node, String value) {
-        throwNotSupported();
+    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

@@ -43,11 +43,12 @@ public class VaultHook {
             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.Lowest);
+            sm.register(Chat.class, chatHook, plugin, ServicePriority.Low);
 
         } catch (Exception e) {
             e.printStackTrace();

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

@@ -33,7 +33,7 @@ import me.lucko.luckperms.groups.Group;
 import me.lucko.luckperms.users.User;
 import net.milkbowl.vault.permission.Permission;
 
-class VaultPermissionHook extends Permission {
+public class VaultPermissionHook extends Permission {
 
     @Setter
     private LPBukkitPlugin plugin;
@@ -93,7 +93,7 @@ class VaultPermissionHook extends Permission {
         return true;
     }
 
-    private void objectSave(PermissionHolder t) {
+    void objectSave(PermissionHolder t) {
         if (t instanceof User) {
             ((User) t).refreshPermissions();
             plugin.getDatastore().saveUser(((User) t), Callback.empty());

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

@@ -25,7 +25,8 @@ package me.lucko.luckperms.users;
 import lombok.Getter;
 import lombok.Setter;
 import me.lucko.luckperms.LPBukkitPlugin;
-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;
@@ -34,7 +35,7 @@ import java.util.UUID;
 
 public class BukkitUser extends User {
     private static Field permissionsField = null;
-    private static Field getPermissionsField() {
+    public static Field getPermissionsField() {
         if (permissionsField == null) {
             try {
                 permissionsField = PermissionAttachment.class.getDeclaredField("permissions");
@@ -66,44 +67,44 @@ public class BukkitUser extends User {
     @SuppressWarnings("unchecked")
     @Override
     public void refreshPermissions() {
-        plugin.doSync(() -> {
-            final Player player = plugin.getServer().getPlayer(plugin.getUuidCache().getExternalUUID(getUuid()));
-            if (player == null) return;
+        if (attachment == null) {
+            return;
+        }
 
-            if (attachment == null) {
-                getPlugin().getLog().warn("User " + getName() + " does not have a permissions attachment defined.");
-                setAttachment(player.addAttachment(plugin));
-            }
+        // Calculate the permissions that should be applied. This is done async, who cares about how long it takes or how often it's done.
+        Map<String, Boolean> toApply = getLocalPermissions(getPlugin().getConfiguration().getServer(), plugin.getUserManager().getWorldCache().get(getUuid()), null);
 
-            // Calculate the permissions that should be applied
-            Map<String, Boolean> toApply = getLocalPermissions(getPlugin().getConfiguration().getServer(), player.getWorld().getName(), 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);
 
-            try {
-                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;
+            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;
-
-                // Faster than recalculating permissions after each PermissionAttachment#setPermission
-                existing.clear();
-                existing.putAll(toApply);
-                attachment.getPermissible().recalculatePermissions();
-
-            } catch (Exception e) {
-                e.printStackTrace();
             }
-        });
+
+            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();
+        }
+
+        plugin.getApiProvider().fireEventAsync(new UserPermissionRefreshEvent(new UserLink(this)));
     }
 }

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

@@ -22,16 +22,22 @@
 
 package me.lucko.luckperms.users;
 
+import lombok.Getter;
 import me.lucko.luckperms.LPBukkitPlugin;
 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;
@@ -82,7 +88,7 @@ public class BukkitUserManager extends UserManager {
             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)));
+            plugin.doAsync(() -> players.forEach(u -> plugin.getDatastore().loadUser(u, "null")));
         });
     }
 }

bukkit/src/main/resources/config.yml

@@ -1,11 +1,13 @@
-# LuckPerms Configuration
+##############################################################################
+# +------------------------------------------------------------------------+ #
+# |                       LuckPerms Configuration                          | #
+# |                  https://github.com/lucko/LuckPerms                    | #
+# +------------------------------------------------------------------------+ #
+##############################################################################
 
 # The name of the server, used for server specific permissions. Set to 'global' to disable.
 server: global
 
-# The default group assigned to all users on their first join.
-default-group: default
-
 # If users on this server should have their global permissions/groups applied.
 include-global: true
 
@@ -38,13 +40,16 @@ apply-regex: true
 apply-shorthand: true
 
 # Which storage method the plugin should use.
-# Currently supported: mysql, sqlite, flatfile
-# Fill out connection info below if you're using MySQL
-storage-method: sqlite
+# Currently supported: mysql, sqlite, h2, flatfile, mongodb
+# Fill out connection info below if you're using MySQL or MongoDB
+storage-method: h2
 
-sql:
+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,8 +1,8 @@
 name: LuckPerms
 author: Luck
-version: ${project.version}.${git.closest.tag.commit.count}
+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:
@@ -15,6 +15,7 @@ permissions:
       luckperms.sync: true
       luckperms.info: true
       luckperms.debug: true
+      luckperms.import: true
       luckperms.creategroup: true
       luckperms.deletegroup: true
       luckperms.listgroups: true
@@ -54,11 +55,13 @@ permissions:
       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
@@ -105,6 +108,7 @@ permissions:
       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:
@@ -113,6 +117,7 @@ permissions:
       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:

bungee/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>luckperms</artifactId>
         <groupId>me.lucko.luckperms</groupId>
-        <version>2.3</version>
+        <version>2.6-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
@@ -14,7 +14,7 @@
 
     <build>
         <defaultGoal>clean package</defaultGoal>
-        <finalName>LuckPermsBungee-${project.version}.${git.closest.tag.commit.count}</finalName>
+        <finalName>LuckPermsBungee-${release.version}.${git.closest.tag.commit.count}</finalName>
         <sourceDirectory>${basedir}/src/main/java</sourceDirectory>
         <resources>
             <resource>
@@ -43,7 +43,7 @@
                             <goal>shade</goal>
                         </goals>
                         <configuration>
-                            <minimizeJar>true</minimizeJar>
+                            <minimizeJar>false</minimizeJar>
                             <relocations>
                                 <relocation>
                                     <pattern>org.slf4j</pattern>
@@ -53,6 +53,18 @@
                                     <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>
@@ -98,19 +110,12 @@
             <version>${project.version}</version>
             <scope>compile</scope>
         </dependency>
-        <!-- HikariCP -->
+        <!-- Lombok -->
         <dependency>
-            <groupId>com.zaxxer</groupId>
-            <artifactId>HikariCP</artifactId>
-            <version>2.4.7</version>
-            <scope>compile</scope>
-        </dependency>
-        <!-- slf4j library -->
-        <dependency>
-            <groupId>org.slf4j</groupId>
-            <artifactId>slf4j-simple</artifactId>
-            <version>1.7.9</version>
-            <scope>compile</scope>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>1.16.10</version>
+            <scope>provided</scope>
         </dependency>
     </dependencies>
 

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

@@ -39,7 +39,8 @@ import java.util.Map;
 import java.util.UUID;
 import java.util.concurrent.TimeUnit;
 
-class BungeeListener extends AbstractListener implements Listener {
+@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;
 
@@ -96,7 +97,7 @@ class BungeeListener extends AbstractListener implements Listener {
 
             // 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().loadOrCreateUser(cache.getUUID(c.getUniqueId()), c.getName());
+            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.");

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

@@ -26,15 +26,17 @@ 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.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.runnables.ExpireTemporaryTask;
 import me.lucko.luckperms.runnables.UpdateTask;
 import me.lucko.luckperms.storage.Datastore;
-import me.lucko.luckperms.storage.methods.FlatfileDatastore;
-import me.lucko.luckperms.storage.methods.MySQLDatastore;
+import me.lucko.luckperms.storage.StorageFactory;
 import me.lucko.luckperms.tracks.TrackManager;
 import me.lucko.luckperms.users.BungeeUserManager;
 import me.lucko.luckperms.users.UserManager;
@@ -42,20 +44,28 @@ import me.lucko.luckperms.utils.LogFactory;
 import net.md_5.bungee.api.connection.ProxiedPlayer;
 import net.md_5.bungee.api.plugin.Plugin;
 
-import java.util.*;
+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 {
-    private final Set<UUID> ignoringLogs = new HashSet<>();
+    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() {
@@ -69,40 +79,21 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
 
         // register commands
         getLog().info("Registering commands...");
-        getProxy().getPluginManager().registerCommand(this, new BungeeCommand(new CommandManager(this)));
+        CommandManager commandManager = new CommandManager(this);
+        getProxy().getPluginManager().registerCommand(this, new BungeeCommand(commandManager));
 
         // disable the default Bungee /perms command so it gets handled by the Bukkit plugin
         getProxy().getDisabledCommands().add("perms");
 
-        getLog().info("Detecting storage method...");
-        final String storageMethod = configuration.getStorageMethod();
-        if (storageMethod.equalsIgnoreCase("mysql")) {
-            getLog().info("Using MySQL as storage method.");
-            datastore = new MySQLDatastore(this, configuration.getDatabaseValues());
-        } else if (storageMethod.equalsIgnoreCase("flatfile")) {
-            getLog().info("Using Flatfile (JSON) as storage method.");
-            datastore = new FlatfileDatastore(this, getDataFolder());
-        } else {
-            getLog().severe("Storage method '" + storageMethod + "' was not recognised. Using Flatfile as fallback.");
-            datastore = new FlatfileDatastore(this, getDataFolder());
-        }
-
-        getLog().info("Initialising datastore...");
-        datastore.init();
+        datastore = StorageFactory.getDatastore(this, "h2");
 
         getLog().info("Loading internal permission managers...");
         uuidCache = new UuidCache(getConfiguration().getOnlineMode());
         userManager = new BungeeUserManager(this);
         groupManager = new GroupManager(this);
         trackManager = new TrackManager();
-
-        // 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();
-        }
+        importer = new Importer(commandManager);
+        consecutiveExecutor = new ConsecutiveExecutor(commandManager);
 
         int mins = getConfiguration().getSyncTime();
         if (mins > 0) {
@@ -111,9 +102,20 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
 
         // 20 times per second (once per "tick")
         getProxy().getScheduler().schedule(this, BungeeSenderFactory.get(), 50L, 50L, TimeUnit.MILLISECONDS);
+        getProxy().getScheduler().schedule(this, new ExpireTemporaryTask(this), 3L, 3L, TimeUnit.SECONDS);
+        getProxy().getScheduler().schedule(this, consecutiveExecutor, 1L, 1L, TimeUnit.SECONDS);
 
         getLog().info("Registering API...");
-        LuckPerms.registerProvider(new ApiProvider(this));
+        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.");
     }
@@ -132,6 +134,16 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
         return getDescription().getVersion();
     }
 
+    @Override
+    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;
@@ -152,12 +164,35 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
         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() {
         doAsync(new UpdateTask(this));

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

@@ -64,6 +64,6 @@ public class BungeeUserManager extends UserManager {
     public void updateAllUsers() {
         plugin.getProxy().getPlayers().stream()
                 .map(p -> plugin.getUuidCache().getUUID(p.getUniqueId()))
-                .forEach(u -> plugin.getDatastore().loadUser(u));
+                .forEach(u -> plugin.getDatastore().loadUser(u, "null"));
     }
 }

bungee/src/main/resources/config.yml

@@ -1,11 +1,13 @@
-# LuckPerms Configuration
+##############################################################################
+# +------------------------------------------------------------------------+ #
+# |                       LuckPerms Configuration                          | #
+# |                  https://github.com/lucko/LuckPerms                    | #
+# +------------------------------------------------------------------------+ #
+##############################################################################
 
 # The name of the server, used for server specific permissions. Set to 'global' to disable.
 server: bungee
 
-# The default group assigned to all users on their first join.
-default-group: default
-
 # If users on this server should have their global permissions/groups applied.
 include-global: false
 
@@ -38,13 +40,16 @@ apply-regex: true
 apply-shorthand: true
 
 # Which storage method the plugin should use.
-# Currently supported: mysql & flatfile
-# Fill out connection info below if you're using MySQL
-storage-method: flatfile
+# Currently supported: mysql, sqlite, h2, flatfile, mongodb
+# Fill out connection info below if you're using MySQL or MongoDB
+storage-method: h2
 
-sql:
+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,5 +1,6 @@
 name: LuckPerms
 author: Luck
-version: ${project.version}.${git.closest.tag.commit.count}
+version: ${release.version}.${git.closest.tag.commit.count}
 main: me.lucko.luckperms.LPBungeePlugin
-description: A permissions plugin
+softdepend: [PowerfulPerms] # For migration
+description: A permissions plugin

common/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>luckperms</artifactId>
         <groupId>me.lucko.luckperms</groupId>
-        <version>2.3</version>
+        <version>2.6-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
@@ -39,6 +39,27 @@
             <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>
@@ -60,6 +81,50 @@
             <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

@@ -23,15 +23,19 @@
 package me.lucko.luckperms;
 
 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 java.io.File;
 import java.util.List;
 import java.util.Set;
 import java.util.UUID;
@@ -42,53 +46,41 @@ import java.util.UUID;
  */
 public interface LuckPermsPlugin {
 
-    /**
-     * Retrieves the {@link UserManager} used to manage users and their permissions/groups
-     * @return the {@link UserManager} instance
+    /*
+     * Access to all of the main internal manager classes
      */
     UserManager getUserManager();
-
-    /**
-     * Retrieves the {@link GroupManager} used to manage the loaded groups and modify their permissions
-     * @return the {@link GroupManager} instance
-     */
     GroupManager getGroupManager();
-
-    /**
-     * Retrieves the {@link TrackManager} used to manage the loaded tracks
-     * @return the {@link TrackManager} instance
-     */
     TrackManager getTrackManager();
-
-    /**
-     * Retrieves the {@link LPConfiguration} for getting values from the config
-     * @return the {@link LPConfiguration} implementation for the platform
-     */
     LPConfiguration getConfiguration();
-
-    /**
-     * Retrieves the {@link Datastore} for loading/saving plugin data
-     * @return the {@link Datastore} object
-     */
     Datastore getDatastore();
-
-    /**
-     * Retrieves the {@link Logger} for the plugin
-     * @return the plugin's {@link Logger}
-     */
     Logger getLog();
-
-    /**
-     * Retrieves the {@link UuidCache} for the plugin
-     * @return the plugin's {@link UuidCache}
-     */
     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
@@ -109,11 +101,15 @@ public interface LuckPermsPlugin {
     List<String> getPlayerList();
 
     /**
-     * Gets a list of all Senders online on the platform
-     * @return a {@link List} of senders
+     * @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
@@ -126,6 +122,27 @@ public interface LuckPermsPlugin {
      */
     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
      */
@@ -142,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

@@ -22,10 +22,13 @@
 
 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;
@@ -33,23 +36,55 @@ 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());
@@ -81,7 +116,7 @@ public class ApiProvider implements LuckPermsApi {
     }
 
     @Override
-    public Optional<User> getUserSafe(UUID uuid) {
+    public Optional<User> getUserSafe(@NonNull UUID uuid) {
         return Optional.ofNullable(getUser(uuid));
     }
 
@@ -96,7 +131,7 @@ public class ApiProvider implements LuckPermsApi {
     }
 
     @Override
-    public Optional<User> getUserSafe(String name) {
+    public Optional<User> getUserSafe(@NonNull String name) {
         return Optional.ofNullable(getUser(name));
     }
 
@@ -110,6 +145,12 @@ public class ApiProvider implements LuckPermsApi {
         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);
@@ -121,7 +162,7 @@ public class ApiProvider implements LuckPermsApi {
     }
 
     @Override
-    public Optional<Group> getGroupSafe(String name) {
+    public Optional<Group> getGroupSafe(@NonNull String name) {
         return Optional.ofNullable(getGroup(name));
     }
 
@@ -146,7 +187,7 @@ public class ApiProvider implements LuckPermsApi {
     }
 
     @Override
-    public Optional<Track> getTrackSafe(String name) {
+    public Optional<Track> getTrackSafe(@NonNull String name) {
         return Optional.ofNullable(getTrack(name));
     }
 
@@ -159,4 +200,9 @@ public class ApiProvider implements LuckPermsApi {
     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

@@ -30,6 +30,7 @@ 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;
@@ -106,12 +107,17 @@ public class DatastoreLink implements Datastore {
 
         @Override
         public void loadOrCreateUser(@NonNull UUID uuid, @NonNull String username, Callback<Boolean> callback) {
-            master.loadOrCreateUser(uuid, checkUsername(username), checkCallback(callback));
+            master.loadUser(uuid, checkUsername(username), checkCallback(callback));
         }
 
         @Override
         public void loadUser(@NonNull UUID uuid, Callback<Boolean> callback) {
-            master.loadUser(uuid, checkCallback(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
@@ -120,6 +126,16 @@ public class DatastoreLink implements Datastore {
             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));
@@ -204,12 +220,17 @@ public class DatastoreLink implements Datastore {
 
         @Override
         public boolean loadOrCreateUser(@NonNull UUID uuid, @NonNull String username) {
-            return master.loadOrCreateUser(uuid, checkUsername(username));
+            return master.loadUser(uuid, checkUsername(username));
         }
 
         @Override
         public boolean loadUser(@NonNull UUID uuid) {
-            return master.loadUser(uuid);
+            return master.loadUser(uuid, "null");
+        }
+
+        @Override
+        public boolean loadUser(@NonNull UUID uuid, @NonNull String username) {
+            return master.loadUser(uuid, checkUsername(username));
         }
 
         @Override
@@ -218,6 +239,16 @@ public class DatastoreLink implements Datastore {
             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));
@@ -307,14 +338,21 @@ public class DatastoreLink implements Datastore {
         @Override
         public java.util.concurrent.Future<Boolean> loadOrCreateUser(@NonNull UUID uuid, @NonNull String username) {
             LPFuture<Boolean> lpf = new LPFuture<>();
-            master.loadOrCreateUser(uuid, checkUsername(username), lpf);
+            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, lpf);
+            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;
         }
 
@@ -326,6 +364,20 @@ public class DatastoreLink implements Datastore {
             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<>();

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

@@ -24,6 +24,7 @@ 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;
 
 /**
@@ -78,8 +79,14 @@ public class LPConfigurationLink implements LPConfiguration {
         return master.getApplyShorthand();
     }
 
+    @SuppressWarnings("deprecation")
     @Override
     public MySQLConfiguration getDatabaseValues() {
+        return getDatastoreConfig();
+    }
+
+    @Override
+    public DatastoreConfiguration getDatastoreConfig() {
         return master.getDatabaseValues();
     }
 

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

@@ -22,25 +22,25 @@
 
 package me.lucko.luckperms.api.implementation.internal;
 
-import lombok.AccessLevel;
 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.Collections;
-import java.util.List;
-import java.util.Map;
+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")
-@AllArgsConstructor(access = AccessLevel.PACKAGE)
-class PermissionHolderLink implements PermissionHolder {
+@SuppressWarnings({"unused", "deprecation"})
+@AllArgsConstructor
+public class PermissionHolderLink implements PermissionHolder {
 
     @NonNull
     private final me.lucko.luckperms.core.PermissionHolder master;
@@ -50,9 +50,39 @@ class PermissionHolderLink implements PermissionHolder {
         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 Collections.unmodifiableMap(master.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
@@ -85,6 +115,11 @@ class PermissionHolderLink implements PermissionHolder {
         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);
@@ -115,6 +150,16 @@ class PermissionHolderLink implements PermissionHolder {
         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);
@@ -145,6 +190,16 @@ class PermissionHolderLink implements PermissionHolder {
         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);
@@ -195,13 +250,34 @@ class PermissionHolderLink implements PermissionHolder {
         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();
     }
 

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

@@ -22,7 +22,6 @@
 
 package me.lucko.luckperms.api.implementation.internal;
 
-import lombok.AccessLevel;
 import lombok.EqualsAndHashCode;
 import lombok.Getter;
 import lombok.NonNull;
@@ -43,7 +42,7 @@ import static me.lucko.luckperms.api.implementation.internal.Utils.*;
 @SuppressWarnings("unused")
 public class UserLink extends PermissionHolderLink implements User {
 
-    @Getter(AccessLevel.PACKAGE)
+    @Getter
     private final me.lucko.luckperms.users.User master;
 
     @Getter
@@ -66,7 +65,7 @@ public class UserLink extends PermissionHolderLink implements User {
     }
 
     @Override
-    public void setPrimaryGroup(String s) throws ObjectAlreadyHasException {
+    public void setPrimaryGroup(@NonNull String s) throws ObjectAlreadyHasException {
         if (getPrimaryGroup().equalsIgnoreCase(s)) {
             throw new ObjectAlreadyHasException();
         }

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

@@ -29,27 +29,27 @@ import me.lucko.luckperms.api.User;
 import me.lucko.luckperms.utils.ArgumentChecker;
 
 @UtilityClass
-class Utils {
+public class Utils {
 
-    static void checkUser(User user) {
+    public static void checkUser(User user) {
         if (!(user instanceof UserLink)) {
-            throw new IllegalArgumentException("User instance cannot be handled by this implementation.");
+            throw new IllegalStateException("User instance cannot be handled by this implementation.");
         }
     }
 
-    static void checkGroup(Group group) {
+    public static void checkGroup(Group group) {
         if (!(group instanceof GroupLink)) {
-            throw new IllegalArgumentException("Group instance cannot be handled by this implementation.");
+            throw new IllegalStateException("Group instance cannot be handled by this implementation.");
         }
     }
 
-    static void checkTrack(Track track) {
+    public static void checkTrack(Track track) {
         if (!(track instanceof TrackLink)) {
-            throw new IllegalArgumentException("Track instance cannot be handled by this implementation.");
+            throw new IllegalStateException("Track instance cannot be handled by this implementation.");
         }
     }
 
-    static String checkUsername(String s) {
+    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 _'.");
@@ -57,7 +57,7 @@ class Utils {
         return s;
     }
 
-    static String checkName(String 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'.");
@@ -65,21 +65,21 @@ class Utils {
         return s.toLowerCase();
     }
 
-    static String checkServer(String s) {
+    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;
     }
 
-    static String checkNode(String 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;
     }
 
-    static long checkTime(long l) {
+    public static long checkTime(long l) {
         if (ArgumentChecker.checkTime(l)) {
             throw new IllegalArgumentException("Unix time '" + l + "' is invalid, as it has already passed.");
         }

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

@@ -32,9 +32,8 @@ import me.lucko.luckperms.commands.group.DeleteGroup;
 import me.lucko.luckperms.commands.group.GroupMainCommand;
 import me.lucko.luckperms.commands.group.ListGroups;
 import me.lucko.luckperms.commands.log.LogMainCommand;
-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.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;
@@ -61,6 +60,9 @@ public class CommandManager {
             .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())
@@ -144,18 +146,28 @@ public class CommandManager {
      */
     @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());
+        final List<MainCommand> mains = mainCommands.stream()
+                .filter(m -> m.isAuthorized(sender))
+                .collect(Collectors.toList());
 
         if (args.size() <= 1) {
             if (args.isEmpty() || args.get(0).equalsIgnoreCase("")) {
-                return mains.stream().map(MainCommand::getName).map(String::toLowerCase).collect(Collectors.toList());
+                return mains.stream()
+                        .map(m -> m.getName().toLowerCase())
+                        .collect(Collectors.toList());
             }
 
-            return mains.stream().map(MainCommand::getName).map(String::toLowerCase)
-                    .filter(s -> s.startsWith(args.get(0).toLowerCase())).collect(Collectors.toList());
+            return mains.stream()
+                    .map(m -> m.getName().toLowerCase())
+                    .filter(s -> s.startsWith(args.get(0).toLowerCase()))
+                    .collect(Collectors.toList());
         }
 
-        Optional<MainCommand> o = mains.stream().filter(m -> m.getName().equalsIgnoreCase(args.get(0))).limit(1).findAny();
+        Optional<MainCommand> o = mains.stream()
+                .filter(m -> m.getName().equalsIgnoreCase(args.get(0)))
+                .limit(1)
+                .findAny();
+
         if (!o.isPresent()) {
             return Collections.emptyList();
         }

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

@@ -76,7 +76,10 @@ public abstract class MainCommand<T> {
             return CommandResult.INVALID_ARGS;
         }
 
-        Optional<SubCommand<T>> o = subCommands.stream().filter(s -> s.getName().equalsIgnoreCase(args.get(requiredArgsLength - 1))).limit(1).findAny();
+        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);
@@ -121,7 +124,7 @@ public abstract class MainCommand<T> {
     protected abstract void cleanup(T t, LuckPermsPlugin plugin);
 
     /**
-     * Get a list of objects for tab completion
+     * Get a list of {@link T} objects for tab completion
      * @param plugin a link to the main plugin instance
      * @return a list of strings
      */
@@ -138,7 +141,10 @@ public abstract class MainCommand<T> {
             return;
         }
 
-        List<SubCommand> subs = getSubCommands().stream().filter(s -> s.isAuthorized(sender)).collect(Collectors.toList());
+        List<SubCommand> subs = getSubCommands().stream()
+                .filter(s -> s.isAuthorized(sender))
+                .collect(Collectors.toList());
+
         if (subs.size() > 0) {
             Util.sendPluginMessage(sender, "&e" + getName() + " Sub Commands:");
 
@@ -168,20 +174,33 @@ public abstract class MainCommand<T> {
                 return objects;
             }
 
-            return objects.stream().filter(s -> s.toLowerCase().startsWith(args.get(0).toLowerCase())).collect(Collectors.toList());
+            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());
+        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(SubCommand::getName).map(String::toLowerCase).collect(Collectors.toList());
+                return subs.stream()
+                        .map(m -> m.getName().toLowerCase())
+                        .collect(Collectors.toList());
             }
 
-            return subs.stream().map(SubCommand::getName).map(String::toLowerCase)
-                    .filter(s -> s.toLowerCase().startsWith(args.get(1).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();
+        Optional<SubCommand<T>> o = subs.stream()
+                .filter(s -> s.getName().equalsIgnoreCase(args.get(1)))
+                .limit(1)
+                .findAny();
+
         if (!o.isPresent()) {
             return Collections.emptyList();
         }

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

@@ -34,9 +34,8 @@ import java.util.stream.Collectors;
  * @param <T> the command sender type
  */
 public abstract class SenderFactory<T> implements Runnable {
-    // Ensures messages are sent in order, etc.
-    private final List<Runnable> tasks = new ArrayList<>();
-
+    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);
@@ -63,8 +62,12 @@ public abstract class SenderFactory<T> implements Runnable {
             public void sendMessage(String s) {
                 final T t = tRef.get();
                 if (t != null) {
-                    synchronized (tasks) {
-                        tasks.add(() -> factory.sendMessage(t, s));
+                    synchronized (messages) {
+                        if (!messages.containsKey(t)) {
+                            messages.put(t, new ArrayList<>());
+                        }
+
+                        messages.get(t).add(s);
                     }
                 }
             }
@@ -80,10 +83,10 @@ public abstract class SenderFactory<T> implements Runnable {
 
     @Override
     public final void run() {
-        synchronized (tasks) {
-            if (!tasks.isEmpty()) {
-                tasks.forEach(Runnable::run);
-                tasks.clear();
+        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/SubCommand.java

@@ -145,38 +145,32 @@ public abstract class SubCommand<T> {
     }
 
     protected static void save(User user, Sender sender, LuckPermsPlugin plugin) {
-        user.refreshPermissions();
+        if (plugin.getDatastore().saveUser(user)) {
+            Message.USER_SAVE_SUCCESS.send(sender);
+        } else {
+            Message.USER_SAVE_ERROR.send(sender);
+        }
 
-        plugin.getDatastore().saveUser(user, success -> {
-            if (success) {
-                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) {
-        plugin.getDatastore().saveGroup(group, success -> {
-            if (success) {
-                Message.GROUP_SAVE_SUCCESS.send(sender);
-            } else {
-                Message.GROUP_SAVE_ERROR.send(sender);
-            }
+        if (plugin.getDatastore().saveGroup(group)) {
+            Message.GROUP_SAVE_SUCCESS.send(sender);
+        } else {
+            Message.GROUP_SAVE_ERROR.send(sender);
+        }
 
-            plugin.runUpdateTask();
-        });
+        plugin.runUpdateTask();
     }
 
     protected static void save(Track track, Sender sender, LuckPermsPlugin plugin) {
-        plugin.getDatastore().saveTrack(track, success -> {
-            if (success) {
-                Message.TRACK_SAVE_SUCCESS.send(sender);
-            } else {
-                Message.TRACK_SAVE_ERROR.send(sender);
-            }
+        if (plugin.getDatastore().saveTrack(track)) {
+            Message.TRACK_SAVE_SUCCESS.send(sender);
+        } else {
+            Message.TRACK_SAVE_ERROR.send(sender);
+        }
 
-            plugin.runUpdateTask();
-        });
+        plugin.runUpdateTask();
     }
 }

common/src/main/java/me/lucko/luckperms/commands/group/CreateGroup.java

@@ -28,7 +28,7 @@ import me.lucko.luckperms.commands.Sender;
 import me.lucko.luckperms.commands.SingleMainCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
-import me.lucko.luckperms.data.LogEntryBuilder;
+import me.lucko.luckperms.data.LogEntry;
 import me.lucko.luckperms.utils.ArgumentChecker;
 
 import java.util.List;
@@ -62,7 +62,7 @@ public class CreateGroup extends SingleMainCommand {
         }
 
         Message.CREATE_SUCCESS.send(sender, groupName);
-        LogEntryBuilder.get().actor(sender).actedName(groupName).type('G').action("create").submit(plugin);
+        LogEntry.build().actor(sender).actedName(groupName).type('G').action("create").build().submit(plugin, sender);
         plugin.runUpdateTask();
         return CommandResult.SUCCESS;
     }

common/src/main/java/me/lucko/luckperms/commands/group/DeleteGroup.java

@@ -28,9 +28,8 @@ import me.lucko.luckperms.commands.Sender;
 import me.lucko.luckperms.commands.SingleMainCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
-import me.lucko.luckperms.data.LogEntryBuilder;
+import me.lucko.luckperms.data.LogEntry;
 import me.lucko.luckperms.groups.Group;
-import me.lucko.luckperms.utils.ArgumentChecker;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -56,11 +55,6 @@ public class DeleteGroup extends SingleMainCommand {
             return CommandResult.INVALID_ARGS;
         }
 
-        if (ArgumentChecker.checkName(groupName)) {
-            Message.GROUP_INVALID_ENTRY.send(sender);
-            return CommandResult.INVALID_ARGS;
-        }
-
         if (!plugin.getDatastore().loadGroup(groupName)) {
             Message.GROUP_DOES_NOT_EXIST.send(sender);
             return CommandResult.INVALID_ARGS;
@@ -78,7 +72,7 @@ public class DeleteGroup extends SingleMainCommand {
         }
 
         Message.DELETE_SUCCESS.send(sender, groupName);
-        LogEntryBuilder.get().actor(sender).actedName(groupName).type('G').action("delete").submit(plugin);
+        LogEntry.build().actor(sender).actedName(groupName).type('G').action("delete").build().submit(plugin, sender);
         plugin.runUpdateTask();
         return CommandResult.SUCCESS;
     }
@@ -92,7 +86,8 @@ public class DeleteGroup extends SingleMainCommand {
                 return groups;
             }
 
-            return groups.stream().filter(s -> s.toLowerCase().startsWith(args.get(0).toLowerCase())).collect(Collectors.toList());
+            return groups.stream().filter(s -> s.toLowerCase().startsWith(args.get(0).toLowerCase()))
+                    .collect(Collectors.toList());
         }
 
         return Collections.emptyList();

common/src/main/java/me/lucko/luckperms/commands/group/GroupMainCommand.java

@@ -30,7 +30,6 @@ import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.commands.group.subcommands.*;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.groups.Group;
-import me.lucko.luckperms.utils.ArgumentChecker;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -52,17 +51,13 @@ public class GroupMainCommand extends MainCommand<Group> {
             .add(new GroupUnsetTempInherit())
             .add(new GroupShowTracks())
             .add(new GroupClear())
+            .add(new GroupRename())
             .build()
         );
     }
 
     @Override
     protected Group getTarget(String target, LuckPermsPlugin plugin, Sender sender) {
-        if (ArgumentChecker.checkName(target)) {
-            Message.GROUP_INVALID_ENTRY.send(sender);
-            return null;
-        }
-
         if (!plugin.getDatastore().loadGroup(target)) {
             Message.GROUP_NOT_FOUND.send(sender);
             return null;

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupClear.java

@@ -29,7 +29,7 @@ import me.lucko.luckperms.commands.Sender;
 import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
-import me.lucko.luckperms.data.LogEntryBuilder;
+import me.lucko.luckperms.data.LogEntry;
 import me.lucko.luckperms.groups.Group;
 
 import java.util.List;
@@ -44,7 +44,7 @@ public class GroupClear extends SubCommand<Group> {
     public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
         group.clearNodes();
         Message.CLEAR_SUCCESS.send(sender, group.getName());
-        LogEntryBuilder.get().actor(sender).acted(group).action("clear").submit(plugin);
+        LogEntry.build().actor(sender).acted(group).action("clear").build().submit(plugin, sender);
         save(group, sender, plugin);
         return CommandResult.SUCCESS;
     }

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupInfo.java

@@ -43,8 +43,8 @@ public class GroupInfo extends SubCommand<Group> {
     public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
         Message.GROUP_INFO.send(sender,
                 group.getName(),
-                group.getPermanentNodes().keySet().size(),
-                group.getTemporaryNodes().keySet().size(),
+                group.getPermanentNodes().size(),
+                group.getTemporaryNodes().size(),
                 label,
                 group.getName()
         );

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupListNodes.java

@@ -30,6 +30,8 @@ import me.lucko.luckperms.groups.Group;
 
 import java.util.List;
 
+import static me.lucko.luckperms.core.PermissionHolder.exportToLegacy;
+
 public class GroupListNodes extends SubCommand<Group> {
     public GroupListNodes() {
         super("listnodes", "Lists the permission nodes the group has", "/%s group <group> listnodes",
@@ -38,8 +40,8 @@ public class GroupListNodes extends SubCommand<Group> {
 
     @Override
     public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
-        Message.LISTNODES.send(sender, group.getName(), Util.permNodesToString(group.getPermanentNodes()));
-        Message.LISTNODES_TEMP.send(sender, group.getName(), Util.tempNodesToString(group.getTemporaryNodes()));
+        Message.LISTNODES.send(sender, group.getName(), Util.permNodesToString(exportToLegacy(group.getPermanentNodes())));
+        Message.LISTNODES_TEMP.send(sender, group.getName(), Util.tempNodesToString(group.getTemporaryNodesLegacy()));
         return CommandResult.SUCCESS;
     }
 }

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupRename.java

@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 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.group.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.CommandResult;
+import me.lucko.luckperms.commands.Predicate;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
+import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.data.LogEntry;
+import me.lucko.luckperms.groups.Group;
+import me.lucko.luckperms.utils.ArgumentChecker;
+
+import java.util.List;
+
+public class GroupRename extends SubCommand<Group> {
+    public GroupRename() {
+        super("rename", "Rename this group", "/%s group <group> rename <new name>",
+                Permission.TRACK_APPEND, Predicate.not(1));
+    }
+
+    @Override
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+        String newGroupName = args.get(0).toLowerCase();
+        if (ArgumentChecker.checkName(newGroupName)) {
+            Message.GROUP_INVALID_ENTRY.send(sender);
+            return CommandResult.INVALID_ARGS;
+        }
+
+        if (plugin.getDatastore().loadGroup(newGroupName)) {
+            Message.GROUP_ALREADY_EXISTS.send(sender);
+            return CommandResult.INVALID_ARGS;
+        }
+
+        if (!plugin.getDatastore().createAndLoadGroup(newGroupName)) {
+            Message.CREATE_GROUP_ERROR.send(sender);
+            return CommandResult.FAILURE;
+        }
+
+        Group newGroup = plugin.getGroupManager().get(newGroupName);
+        if (newGroup == null) {
+            Message.GROUP_LOAD_ERROR.send(sender);
+            return CommandResult.LOADING_ERROR;
+        }
+
+        if (!plugin.getDatastore().deleteGroup(group)) {
+            Message.DELETE_GROUP_ERROR.send(sender);
+            return CommandResult.FAILURE;
+        }
+
+        plugin.getGroupManager().copy(group, newGroup);
+
+        Message.RENAME_SUCCESS.send(sender, group.getName(), newGroup.getName());
+        LogEntry.build().actor(sender).acted(group).action("rename " + newGroup.getName()).build().submit(plugin, sender);
+        save(newGroup, sender, plugin);
+        return CommandResult.SUCCESS;
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupSetInherit.java

@@ -29,7 +29,7 @@ import me.lucko.luckperms.commands.Sender;
 import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
-import me.lucko.luckperms.data.LogEntryBuilder;
+import me.lucko.luckperms.data.LogEntry;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
 import me.lucko.luckperms.groups.Group;
 import me.lucko.luckperms.utils.ArgumentChecker;
@@ -74,24 +74,24 @@ public class GroupSetInherit extends SubCommand<Group> {
                 if (args.size() == 2) {
                     group.setInheritGroup(group1, server);
                     Message.GROUP_SETINHERIT_SERVER_SUCCESS.send(sender, group.getName(), group1.getName(), server);
-                    LogEntryBuilder.get().actor(sender).acted(group)
+                    LogEntry.build().actor(sender).acted(group)
                             .action("setinherit " + group1.getName() + " " + server)
-                            .submit(plugin);
+                            .build().submit(plugin, sender);
                 } else {
                     final String world = args.get(2).toLowerCase();
                     group.setInheritGroup(group1, server, world);
                     Message.GROUP_SETINHERIT_SERVER_WORLD_SUCCESS.send(sender, group.getName(), group1.getName(), server, world);
-                    LogEntryBuilder.get().actor(sender).acted(group)
+                    LogEntry.build().actor(sender).acted(group)
                             .action("setinherit " + group1.getName() + " " + server + " " + world)
-                            .submit(plugin);
+                            .build().submit(plugin, sender);
                 }
 
             } else {
                 group.setInheritGroup(group1);
                 Message.GROUP_SETINHERIT_SUCCESS.send(sender, group.getName(), group1.getName());
-                LogEntryBuilder.get().actor(sender).acted(group)
+                LogEntry.build().actor(sender).acted(group)
                         .action("setinherit " + group1.getName())
-                        .submit(plugin);
+                        .build().submit(plugin, sender);
             }
 
             save(group, sender, plugin);

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupSetPermission.java

@@ -30,7 +30,7 @@ import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Patterns;
 import me.lucko.luckperms.constants.Permission;
-import me.lucko.luckperms.data.LogEntryBuilder;
+import me.lucko.luckperms.data.LogEntry;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
 import me.lucko.luckperms.groups.Group;
 import me.lucko.luckperms.utils.ArgumentChecker;
@@ -45,7 +45,7 @@ public class GroupSetPermission extends SubCommand<Group> {
 
     @Override
     public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
-        String node = args.get(0);
+        String node = args.get(0).replace("{SPACE}", " ");
         String bool = args.get(1).toLowerCase();
 
         if (ArgumentChecker.checkNode(node)) {
@@ -76,24 +76,24 @@ public class GroupSetPermission extends SubCommand<Group> {
                 if (args.size() == 3) {
                     group.setPermission(node, b, server);
                     Message.SETPERMISSION_SERVER_SUCCESS.send(sender, node, bool, group.getName(), server);
-                    LogEntryBuilder.get().actor(sender).acted(group)
+                    LogEntry.build().actor(sender).acted(group)
                             .action("set " + node + " " + b + " " + server)
-                            .submit(plugin);
+                            .build().submit(plugin, sender);
                 } else {
                     final String world = args.get(3).toLowerCase();
                     group.setPermission(node, b, server, world);
                     Message.SETPERMISSION_SERVER_WORLD_SUCCESS.send(sender, node, bool, group.getName(), server, world);
-                    LogEntryBuilder.get().actor(sender).acted(group)
+                    LogEntry.build().actor(sender).acted(group)
                             .action("set " + node + " " + b + " " + server + " " + world)
-                            .submit(plugin);
+                            .build().submit(plugin, sender);
                 }
 
             } else {
                 group.setPermission(node, b);
                 Message.SETPERMISSION_SUCCESS.send(sender, node, bool, group.getName());
-                LogEntryBuilder.get().actor(sender).acted(group)
+                LogEntry.build().actor(sender).acted(group)
                         .action("set " + node + " " + b)
-                        .submit(plugin);
+                        .build().submit(plugin, sender);
             }
 
             save(group, sender, plugin);

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupSetTempInherit.java

@@ -29,7 +29,7 @@ import me.lucko.luckperms.commands.Sender;
 import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
-import me.lucko.luckperms.data.LogEntryBuilder;
+import me.lucko.luckperms.data.LogEntry;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
 import me.lucko.luckperms.groups.Group;
 import me.lucko.luckperms.utils.ArgumentChecker;
@@ -55,10 +55,14 @@ public class GroupSetTempInherit extends SubCommand<Group> {
 
         long duration;
         try {
-            duration = DateUtil.parseDateDiff(args.get(1), true);
-        } catch (DateUtil.IllegalDateException e) {
-            Message.ILLEGAL_DATE_ERROR.send(sender, args.get(1));
-            return CommandResult.INVALID_ARGS;
+            duration = Long.parseLong(args.get(1));
+        } catch (NumberFormatException e) {
+            try {
+                duration = DateUtil.parseDateDiff(args.get(1), true);
+            } catch (DateUtil.IllegalDateException e1) {
+                Message.ILLEGAL_DATE_ERROR.send(sender, args.get(1));
+                return CommandResult.INVALID_ARGS;
+            }
         }
 
         if (DateUtil.shouldExpire(duration)) {
@@ -89,25 +93,25 @@ public class GroupSetTempInherit extends SubCommand<Group> {
                     group.setInheritGroup(group1, server, duration);
                     Message.GROUP_SET_TEMP_INHERIT_SERVER_SUCCESS.send(sender, group.getName(), group1.getName(), server,
                             DateUtil.formatDateDiff(duration));
-                    LogEntryBuilder.get().actor(sender).acted(group)
+                    LogEntry.build().actor(sender).acted(group)
                             .action("settempinherit " + group1.getName() + " " + duration + " " + server)
-                            .submit(plugin);
+                            .build().submit(plugin, sender);
                 } else {
                     final String world = args.get(3).toLowerCase();
                     group.setInheritGroup(group1, server, world, duration);
                     Message.GROUP_SET_TEMP_INHERIT_SERVER_WORLD_SUCCESS.send(sender, group.getName(), group1.getName(), server,
                             world, DateUtil.formatDateDiff(duration));
-                    LogEntryBuilder.get().actor(sender).acted(group)
+                    LogEntry.build().actor(sender).acted(group)
                             .action("settempinherit " + group1.getName() + " " + duration + " " + server + " " + world)
-                            .submit(plugin);
+                            .build().submit(plugin, sender);
                 }
 
             } else {
                 group.setInheritGroup(group1, duration);
                 Message.GROUP_SET_TEMP_INHERIT_SUCCESS.send(sender, group.getName(), group1.getName(), DateUtil.formatDateDiff(duration));
-                LogEntryBuilder.get().actor(sender).acted(group)
+                LogEntry.build().actor(sender).acted(group)
                         .action("settempinherit " + group1.getName() + " " + duration)
-                        .submit(plugin);
+                        .build().submit(plugin, sender);
             }
 
             save(group, sender, plugin);

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupSetTempPermission.java

@@ -30,7 +30,7 @@ import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Patterns;
 import me.lucko.luckperms.constants.Permission;
-import me.lucko.luckperms.data.LogEntryBuilder;
+import me.lucko.luckperms.data.LogEntry;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
 import me.lucko.luckperms.groups.Group;
 import me.lucko.luckperms.utils.ArgumentChecker;
@@ -47,7 +47,7 @@ public class GroupSetTempPermission extends SubCommand<Group> {
 
     @Override
     public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
-        String node = args.get(0);
+        String node = args.get(0).replace("{SPACE}", " ");
         String bool = args.get(1).toLowerCase();
 
         if (ArgumentChecker.checkNode(node)) {
@@ -69,10 +69,14 @@ public class GroupSetTempPermission extends SubCommand<Group> {
 
         long duration;
         try {
-            duration = DateUtil.parseDateDiff(args.get(2), true);
-        } catch (DateUtil.IllegalDateException e) {
-            Message.ILLEGAL_DATE_ERROR.send(sender, args.get(2));
-            return CommandResult.INVALID_ARGS;
+            duration = Long.parseLong(args.get(2));
+        } catch (NumberFormatException e) {
+            try {
+                duration = DateUtil.parseDateDiff(args.get(2), true);
+            } catch (DateUtil.IllegalDateException e1) {
+                Message.ILLEGAL_DATE_ERROR.send(sender, args.get(2));
+                return CommandResult.INVALID_ARGS;
+            }
         }
 
         if (DateUtil.shouldExpire(duration)) {
@@ -92,25 +96,25 @@ public class GroupSetTempPermission extends SubCommand<Group> {
                     group.setPermission(node, b, server, duration);
                     Message.SETPERMISSION_TEMP_SERVER_SUCCESS.send(sender, node, bool, group.getName(), server,
                             DateUtil.formatDateDiff(duration));
-                    LogEntryBuilder.get().actor(sender).acted(group)
+                    LogEntry.build().actor(sender).acted(group)
                             .action("settemp " + node + " " + b + " " + duration + " " + server)
-                            .submit(plugin);
+                            .build().submit(plugin, sender);
                 } else {
                     final String world = args.get(4).toLowerCase();
                     group.setPermission(node, b, server, world, duration);
                     Message.SETPERMISSION_TEMP_SERVER_WORLD_SUCCESS.send(sender, node, bool, group.getName(), server,
                             world, DateUtil.formatDateDiff(duration));
-                    LogEntryBuilder.get().actor(sender).acted(group)
+                    LogEntry.build().actor(sender).acted(group)
                             .action("settemp " + node + " " + b + " " + duration + " " + server + " " + world)
-                            .submit(plugin);
+                            .build().submit(plugin, sender);
                 }
 
             } else {
                 group.setPermission(node, b, duration);
                 Message.SETPERMISSION_TEMP_SUCCESS.send(sender, node, bool, group.getName(), DateUtil.formatDateDiff(duration));
-                LogEntryBuilder.get().actor(sender).acted(group)
+                LogEntry.build().actor(sender).acted(group)
                         .action("settemp " + node + " " + b + " " + duration)
-                        .submit(plugin);
+                        .build().submit(plugin, sender);
             }
 
             save(group, sender, plugin);

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupUnSetPermission.java

@@ -30,7 +30,7 @@ import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Patterns;
 import me.lucko.luckperms.constants.Permission;
-import me.lucko.luckperms.data.LogEntryBuilder;
+import me.lucko.luckperms.data.LogEntry;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
 import me.lucko.luckperms.groups.Group;
 import me.lucko.luckperms.utils.ArgumentChecker;
@@ -45,7 +45,7 @@ public class GroupUnSetPermission extends SubCommand<Group> {
 
     @Override
     public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
-        String node = args.get(0);
+        String node = args.get(0).replace("{SPACE}", " ");
 
         if (ArgumentChecker.checkNode(node)) {
             sendUsage(sender, label);
@@ -68,24 +68,24 @@ public class GroupUnSetPermission extends SubCommand<Group> {
                 if (args.size() == 2) {
                     group.unsetPermission(node, server);
                     Message.UNSETPERMISSION_SERVER_SUCCESS.send(sender, node, group.getName(), server);
-                    LogEntryBuilder.get().actor(sender).acted(group)
+                    LogEntry.build().actor(sender).acted(group)
                             .action("unset " + node + " " + server)
-                            .submit(plugin);
+                            .build().submit(plugin, sender);
                 } else {
                     final String world = args.get(2).toLowerCase();
                     group.unsetPermission(node, server, world);
                     Message.UNSETPERMISSION_SERVER_WORLD_SUCCESS.send(sender, node, group.getName(), server, world);
-                    LogEntryBuilder.get().actor(sender).acted(group)
+                    LogEntry.build().actor(sender).acted(group)
                             .action("unset " + node + " " + server + " " + world)
-                            .submit(plugin);
+                            .build().submit(plugin, sender);
                 }
 
             } else {
                 group.unsetPermission(node);
                 Message.UNSETPERMISSION_SUCCESS.send(sender, node, group.getName());
-                LogEntryBuilder.get().actor(sender).acted(group)
+                LogEntry.build().actor(sender).acted(group)
                         .action("unset " + node)
-                        .submit(plugin);
+                        .build().submit(plugin, sender);
             }
 
             save(group, sender, plugin);

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupUnsetInherit.java

@@ -29,7 +29,7 @@ import me.lucko.luckperms.commands.Sender;
 import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
-import me.lucko.luckperms.data.LogEntryBuilder;
+import me.lucko.luckperms.data.LogEntry;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
 import me.lucko.luckperms.groups.Group;
 import me.lucko.luckperms.utils.ArgumentChecker;
@@ -63,24 +63,24 @@ public class GroupUnsetInherit extends SubCommand<Group> {
                 if (args.size() == 2) {
                     group.unsetPermission("group." + groupName, server);
                     Message.GROUP_UNSETINHERIT_SERVER_SUCCESS.send(sender, group.getName(), groupName, server);
-                    LogEntryBuilder.get().actor(sender).acted(group)
+                    LogEntry.build().actor(sender).acted(group)
                             .action("unsetinherit " + groupName + " " + server)
-                            .submit(plugin);
+                            .build().submit(plugin, sender);
                 } else {
                     final String world = args.get(2).toLowerCase();
                     group.unsetPermission("group." + groupName, server, world);
                     Message.GROUP_UNSETINHERIT_SERVER_WORLD_SUCCESS.send(sender, group.getName(), groupName, server, world);
-                    LogEntryBuilder.get().actor(sender).acted(group)
+                    LogEntry.build().actor(sender).acted(group)
                             .action("unsetinherit " + groupName + " " + server + " " + world)
-                            .submit(plugin);
+                            .build().submit(plugin, sender);
                 }
 
             } else {
                 group.unsetPermission("group." + groupName);
                 Message.GROUP_UNSETINHERIT_SUCCESS.send(sender, group.getName(), groupName);
-                LogEntryBuilder.get().actor(sender).acted(group)
+                LogEntry.build().actor(sender).acted(group)
                         .action("unsetinherit " + groupName)
-                        .submit(plugin);
+                        .build().submit(plugin, sender);
             }
 
             save(group, sender, plugin);

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupUnsetTempInherit.java

@@ -29,7 +29,7 @@ import me.lucko.luckperms.commands.Sender;
 import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
-import me.lucko.luckperms.data.LogEntryBuilder;
+import me.lucko.luckperms.data.LogEntry;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
 import me.lucko.luckperms.groups.Group;
 import me.lucko.luckperms.utils.ArgumentChecker;
@@ -63,24 +63,24 @@ public class GroupUnsetTempInherit extends SubCommand<Group> {
                 if (args.size() == 2) {
                     group.unsetPermission("group." + groupName, server, true);
                     Message.GROUP_UNSET_TEMP_INHERIT_SERVER_SUCCESS.send(sender, group.getName(), groupName, server);
-                    LogEntryBuilder.get().actor(sender).acted(group)
+                    LogEntry.build().actor(sender).acted(group)
                             .action("unsettempinherit " + groupName + " " + server)
-                            .submit(plugin);
+                            .build().submit(plugin, sender);
                 } else {
                     final String world = args.get(2).toLowerCase();
                     group.unsetPermission("group." + groupName, server, world, true);
                     Message.GROUP_UNSET_TEMP_INHERIT_SERVER_WORLD_SUCCESS.send(sender, group.getName(), groupName, server, world);
-                    LogEntryBuilder.get().actor(sender).acted(group)
+                    LogEntry.build().actor(sender).acted(group)
                             .action("unsettempinherit " + groupName + " " + server + " " + world)
-                            .submit(plugin);
+                            .build().submit(plugin, sender);
                 }
 
             } else {
                 group.unsetPermission("group." + groupName, true);
                 Message.GROUP_UNSET_TEMP_INHERIT_SUCCESS.send(sender, group.getName(), groupName);
-                LogEntryBuilder.get().actor(sender).acted(group)
+                LogEntry.build().actor(sender).acted(group)
                         .action("unsettempinherit " + groupName)
-                        .submit(plugin);
+                        .build().submit(plugin, sender);
             }
 
             save(group, sender, plugin);

common/src/main/java/me/lucko/luckperms/commands/group/subcommands/GroupUnsetTempPermission.java

@@ -30,7 +30,7 @@ import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Patterns;
 import me.lucko.luckperms.constants.Permission;
-import me.lucko.luckperms.data.LogEntryBuilder;
+import me.lucko.luckperms.data.LogEntry;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
 import me.lucko.luckperms.groups.Group;
 import me.lucko.luckperms.utils.ArgumentChecker;
@@ -46,7 +46,7 @@ public class GroupUnsetTempPermission extends SubCommand<Group> {
 
     @Override
     public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
-        String node = args.get(0);
+        String node = args.get(0).replace("{SPACE}", " ");
 
         if (ArgumentChecker.checkNode(node)) {
             sendUsage(sender, label);
@@ -69,24 +69,24 @@ public class GroupUnsetTempPermission extends SubCommand<Group> {
                 if (args.size() == 2) {
                     group.unsetPermission(node, server);
                     Message.UNSET_TEMP_PERMISSION_SERVER_SUCCESS.send(sender, node, group.getName(), server);
-                    LogEntryBuilder.get().actor(sender).acted(group)
+                    LogEntry.build().actor(sender).acted(group)
                             .action("unsettemp " + node + " " + server)
-                            .submit(plugin);
+                            .build().submit(plugin, sender);
                 } else {
                     final String world = args.get(2).toLowerCase();
                     group.unsetPermission(node, server, world);
                     Message.UNSET_TEMP_PERMISSION_SERVER_WORLD_SUCCESS.send(sender, node, group.getName(), server, world);
-                    LogEntryBuilder.get().actor(sender).acted(group)
+                    LogEntry.build().actor(sender).acted(group)
                             .action("unsettemp " + node + " " + server + " " + world)
-                            .submit(plugin);
+                            .build().submit(plugin, sender);
                 }
 
             } else {
                 group.unsetPermission(node, true);
                 Message.UNSET_TEMP_PERMISSION_SUCCESS.send(sender, node, group.getName());
-                LogEntryBuilder.get().actor(sender).acted(group)
+                LogEntry.build().actor(sender).acted(group)
                         .action("unsettemp " + node)
-                        .submit(plugin);
+                        .build().submit(plugin, sender);
             }
 
             save(group, sender, plugin);

common/src/main/java/me/lucko/luckperms/commands/log/LogMainCommand.java

@@ -42,7 +42,7 @@ public class LogMainCommand extends MainCommand<Log> {
             .add(new LogRecent())
             .add(new LogSearch())
             .add(new LogNotify())
-            // .add(new LogExport())
+            .add(new LogExport())
             .add(new LogUserHistory())
             .add(new LogGroupHistory())
             .add(new LogTrackHistory())
@@ -73,17 +73,28 @@ public class LogMainCommand extends MainCommand<Log> {
 
     @Override
     protected List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
-        final List<SubCommand<Log>> subs = getSubCommands().stream().filter(s -> s.isAuthorized(sender)).collect(Collectors.toList());
+        final List<SubCommand<Log>> subs = getSubCommands().stream()
+                .filter(s -> s.isAuthorized(sender))
+                .collect(Collectors.toList());
+
         if (args.size() <= 1) {
             if (args.isEmpty() || args.get(0).equalsIgnoreCase("")) {
-                return subs.stream().map(SubCommand::getName).map(String::toLowerCase).collect(Collectors.toList());
+                return subs.stream()
+                        .map(m -> m.getName().toLowerCase())
+                        .collect(Collectors.toList());
             }
 
-            return subs.stream().map(SubCommand::getName).map(String::toLowerCase)
-                    .filter(s -> s.toLowerCase().startsWith(args.get(0).toLowerCase())).collect(Collectors.toList());
+            return subs.stream()
+                    .map(m -> m.getName().toLowerCase())
+                    .filter(s -> s.toLowerCase().startsWith(args.get(0).toLowerCase()))
+                    .collect(Collectors.toList());
         }
 
-        Optional<SubCommand<Log>> o = subs.stream().filter(s -> s.getName().equalsIgnoreCase(args.get(0))).limit(1).findAny();
+        Optional<SubCommand<Log>> o = subs.stream()
+                .filter(s -> s.getName().equalsIgnoreCase(args.get(0)))
+                .limit(1)
+                .findAny();
+
         if (!o.isPresent()) {
             return Collections.emptyList();
         }

common/src/main/java/me/lucko/luckperms/commands/log/subcommands/LogExport.java

@@ -23,13 +23,20 @@
 package me.lucko.luckperms.commands.log.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.api.LogEntry;
 import me.lucko.luckperms.commands.CommandResult;
 import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
 import me.lucko.luckperms.commands.SubCommand;
+import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.data.Log;
 
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.util.ArrayList;
 import java.util.List;
 
 public class LogExport extends SubCommand<Log> {
@@ -39,7 +46,83 @@ public class LogExport extends SubCommand<Log> {
 
     @Override
     public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Log log, List<String> args, String label) {
-        // TODO: implement this
-        return CommandResult.SUCCESS;
+        File f = new File(plugin.getMainDir(), args.get(0));
+        if (f.exists()) {
+            Message.LOG_EXPORT_ALREADY_EXISTS.send(sender, f.getAbsolutePath());
+            return CommandResult.INVALID_ARGS;
+        }
+
+        if (log.getContent().isEmpty()) {
+            Message.LOG_EXPORT_EMPTY.send(sender);
+            return CommandResult.STATE_ERROR;
+        }
+
+        try {
+            f.createNewFile();
+        } catch (IOException e) {
+            Message.LOG_EXPORT_FAILURE.send(sender);
+            e.printStackTrace();
+            return CommandResult.FAILURE;
+        }
+
+        if (!Files.isWritable(f.toPath())) {
+            Message.LOG_EXPORT_NOT_WRITABLE.send(sender, f.getAbsolutePath());
+            return CommandResult.FAILURE;
+        }
+
+        List<String> data = new ArrayList<>();
+
+        StringBuilder b = new StringBuilder();
+        for (LogEntry e : log.getContent()) {
+            b.setLength(0);
+            b.append("/luckperms ");
+
+            if (e.getType() == 'U') {
+                b.append("user ").append(e.getActed().toString()).append(" ").append(e.getAction());
+            }
+
+            group:
+            if (e.getType() == 'G') {
+                if (e.getAction().equalsIgnoreCase("create")) {
+                    b.append("creategroup ").append(e.getActedName());
+                    break group;
+                }
+
+                if (e.getAction().equalsIgnoreCase("delete")) {
+                    b.append("deletegroup ").append(e.getActedName());
+                    break group;
+                }
+
+                b.append("group ").append(e.getActedName()).append(" ").append(e.getAction());
+            }
+
+            track:
+            if (e.getType() == 'T') {
+                if (e.getAction().equalsIgnoreCase("create")) {
+                    b.append("createtrack ").append(e.getActedName());
+                    break track;
+                }
+
+                if (e.getAction().equalsIgnoreCase("delete")) {
+                    b.append("deletetrack ").append(e.getActedName());
+                    break track;
+                }
+
+                b.append("track ").append(e.getActedName()).append(" ").append(e.getAction());;
+            }
+
+            data.add(b.toString());
+        }
+
+
+        try {
+            Files.write(f.toPath(), data, Charset.defaultCharset());
+            Message.LOG_EXPORT_SUCCESS.send(sender, f.getAbsolutePath());
+            return CommandResult.SUCCESS;
+        } catch (IOException e) {
+            e.printStackTrace();
+            Message.LOG_EXPORT_FAILURE.send(sender);
+            return CommandResult.FAILURE;
+        }
     }
 }

common/src/main/java/me/lucko/luckperms/commands/log/subcommands/LogGroupHistory.java

@@ -46,7 +46,7 @@ public class LogGroupHistory extends SubCommand<Log> {
 
     @Override
     public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Log log, List<String> args, String label) {
-        String group = args.get(0);
+        String group = args.get(0).toLowerCase();
         int page = -999;
 
         if (args.size() == 2) {

common/src/main/java/me/lucko/luckperms/commands/log/subcommands/LogTrackHistory.java

@@ -46,7 +46,7 @@ public class LogTrackHistory extends SubCommand<Log> {
 
     @Override
     public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Log log, List<String> args, String label) {
-        String track = args.get(0);
+        String track = args.get(0).toLowerCase();
         int page = -999;
 
         if (args.size() == 2) {

common/src/main/java/me/lucko/luckperms/commands/log/subcommands/LogUserHistory.java

@@ -45,11 +45,11 @@ public class LogUserHistory extends SubCommand<Log> {
     @Override
     public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Log log, List<String> args, String label) {
         String user = args.get(0);
-        final int[] page = {-999};
+        int page = -999;
 
         if (args.size() == 2) {
             try {
-                page[0] = Integer.parseInt(args.get(1));
+                page = Integer.parseInt(args.get(1));
             } catch (NumberFormatException e) {
                 // invalid page
                 return showLog(-1, null, null, null);
@@ -58,11 +58,11 @@ public class LogUserHistory extends SubCommand<Log> {
 
         UUID uuid = Util.parseUuid(user);
         if (uuid != null) {
-            if (page[0] == -999) {
-                page[0] = log.getUserHistoryMaxPages(uuid);
+            if (page == -999) {
+                page = log.getUserHistoryMaxPages(uuid);
             }
 
-            return showLog(page[0], uuid, sender, log);
+            return showLog(page, uuid, sender, log);
 
         }
 
@@ -81,11 +81,11 @@ public class LogUserHistory extends SubCommand<Log> {
                 return CommandResult.INVALID_ARGS;
             }
 
-            if (page[0] == -999) {
-                page[0] = log.getUserHistoryMaxPages(uuid1);
+            if (page == -999) {
+                page = log.getUserHistoryMaxPages(uuid1);
             }
 
-            return showLog(page[0], uuid1, sender, log);
+            return showLog(page, uuid1, sender, log);
         }
 
         Message.USER_INVALID_ENTRY.send(sender, user);

common/src/main/java/me/lucko/luckperms/commands/migration/MigrationMainCommand.java

@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 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.migration;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.CommandResult;
+import me.lucko.luckperms.commands.MainCommand;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
+import me.lucko.luckperms.commands.migration.subcommands.*;
+import me.lucko.luckperms.constants.Constants;
+import me.lucko.luckperms.constants.Message;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class MigrationMainCommand extends MainCommand<Object> {
+    private final List<SubCommand<Object>> subCommands = new ArrayList<>();
+
+    public MigrationMainCommand() {
+        super("Migration", "/%s migration", 1, null);
+
+        try {
+            Class.forName("org.anjocaido.groupmanager.GroupManager");
+            subCommands.add(new MigrationGroupManager());
+        } catch (Throwable ignored) {}
+
+        try {
+            Class.forName("ru.tehkode.permissions.bukkit.PermissionsEx");
+            subCommands.add(new MigrationPermissionsEx());
+        } catch (Throwable ignored) {}
+
+        try {
+            Class.forName("com.github.cheesesoftware.PowerfulPermsAPI.PowerfulPermsPlugin");
+            subCommands.add(new MigrationPowerfulPerms());
+        } catch (Throwable ignored) {}
+
+        try {
+            Class.forName("org.tyrannyofheaven.bukkit.zPermissions.ZPermissionsService");
+            subCommands.add(new MigrationZPermissions());
+        } catch (Throwable ignored) {}
+
+        try {
+            Class.forName("net.alpenblock.bungeeperms.BungeePerms");
+            subCommands.add(new MigrationBungeePerms());
+        } catch (Throwable ignored) {}
+
+    }
+
+    @Override
+    public List<SubCommand<Object>> getSubCommands() {
+        return subCommands;
+    }
+
+    @Override
+    protected boolean isAuthorized(Sender sender) {
+        return sender.getUuid().equals(Constants.getConsoleUUID());
+    }
+
+    @Override
+    protected CommandResult execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
+        if (!sender.getUuid().equals(Constants.getConsoleUUID())) {
+            Message.MIGRATION_NOT_CONSOLE.send(sender);
+            return CommandResult.NO_PERMISSION;
+        }
+
+        return super.execute(plugin, sender, args, label);
+    }
+
+    @Override
+    protected Object getTarget(String target, LuckPermsPlugin plugin, Sender sender) {
+        return new Object();
+    }
+
+    @Override
+    protected void cleanup(Object object, LuckPermsPlugin plugin) {
+
+    }
+
+    @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();
+    }
+
+}

common/src/main/java/me/lucko/luckperms/commands/migration/subcommands/MigrationBungeePerms.java

@@ -0,0 +1,300 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 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.migration.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.api.Logger;
+import me.lucko.luckperms.commands.CommandResult;
+import me.lucko.luckperms.commands.Predicate;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
+import me.lucko.luckperms.constants.Constants;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.data.LogEntry;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.utils.ArgumentChecker;
+import net.alpenblock.bungeeperms.*;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * BungeePerms is actually pretty nice. huh.
+ */
+public class MigrationBungeePerms extends SubCommand<Object> {
+    public MigrationBungeePerms() {
+        super("bungeeperms", "Migration from BungeePerms", "/%s migration bungeeperms",
+                Permission.MIGRATION, Predicate.alwaysFalse());
+    }
+
+    @Override
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List<String> args, String label) {
+        final Logger log = plugin.getLog();
+
+        BungeePerms bp = BungeePerms.getInstance();
+        if (bp == null) {
+            log.severe("BungeePerms Migration: Error -> BungeePerms is not loaded.");
+            return CommandResult.STATE_ERROR;
+        }
+
+        // Migrate all groups.
+        log.info("BungeePerms Migration: Starting group migration.");
+        int groupCount = 0;
+        for (Group g : bp.getPermissionsManager().getBackEnd().loadGroups()) {
+            groupCount ++;
+
+            // Make a LuckPerms group for the one being migrated
+            plugin.getDatastore().createAndLoadGroup(g.getName().toLowerCase());
+            me.lucko.luckperms.groups.Group group = plugin.getGroupManager().get(g.getName().toLowerCase());
+            try {
+                LogEntry.build()
+                        .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                        .acted(group).action("create")
+                        .build().submit(plugin);
+            } catch (Exception ex) {
+                ex.printStackTrace();
+            }
+
+
+            // Migrate global perms
+            for (String perm : g.getPerms()) {
+                try {
+                    group.setPermission(perm, true);
+                    LogEntry.build()
+                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                            .acted(group).action("set " + perm + " true")
+                            .build().submit(plugin);
+                } catch (Exception ex) {
+                    if (!(ex instanceof ObjectAlreadyHasException)) {
+                        ex.printStackTrace();
+                    }
+                }
+            }
+
+            // Migrate per-server perms
+            for (Map.Entry<String, Server> e : g.getServers().entrySet()) {
+                for (String perm : e.getValue().getPerms()) {
+                    try {
+                        group.setPermission(perm, true, e.getKey());
+                        LogEntry.build()
+                                .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                                .acted(group).action("set " + perm + " true " + e.getKey())
+                                .build().submit(plugin);
+                    } catch (Exception ex) {
+                        if (!(ex instanceof ObjectAlreadyHasException)) {
+                            ex.printStackTrace();
+                        }
+                    }
+                }
+
+                // Migrate per-world perms
+                for (Map.Entry<String, World> we : e.getValue().getWorlds().entrySet()) {
+                    for (String perm : we.getValue().getPerms()) {
+                        try {
+                            group.setPermission(perm, true, e.getKey(), we.getKey());
+                            LogEntry.build()
+                                    .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                                    .acted(group).action("set " + perm + " true " + e.getKey() + " " + we.getKey())
+                                    .build().submit(plugin);
+                        } catch (Exception ex) {
+                            if (!(ex instanceof ObjectAlreadyHasException)) {
+                                ex.printStackTrace();
+                            }
+                        }
+                    }
+                }
+            }
+
+            // Migrate any parent groups
+            for (String inherit : g.getInheritances()) {
+                try {
+                    group.setPermission("group." + inherit, true);
+                    LogEntry.build()
+                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                            .acted(group).action("setinherit " + group)
+                            .build().submit(plugin);
+                } catch (Exception ex) {
+                    if (!(ex instanceof ObjectAlreadyHasException)) {
+                        ex.printStackTrace();
+                    }
+                }
+            }
+
+            // Migrate prefix and suffix
+            String prefix = g.getPrefix();
+            String suffix = g.getSuffix();
+
+            if (prefix != null && !prefix.equals("")) {
+                prefix = ArgumentChecker.escapeCharacters(prefix);
+                try {
+                    group.setPermission("prefix.50." + prefix, true);
+                    LogEntry.build()
+                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                            .acted(group).action("set prefix.50." + prefix + " true")
+                            .build().submit(plugin);
+                } catch (Exception ex) {
+                    if (!(ex instanceof ObjectAlreadyHasException)) {
+                        ex.printStackTrace();
+                    }
+                }
+            }
+
+            if (suffix != null && !suffix.equals("")) {
+                suffix = ArgumentChecker.escapeCharacters(suffix);
+                try {
+                    group.setPermission("suffix.50." + suffix, true);
+                    LogEntry.build()
+                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                            .acted(group).action("set suffix.50." + suffix + " true")
+                            .build().submit(plugin);
+                } catch (Exception ex) {
+                    if (!(ex instanceof ObjectAlreadyHasException)) {
+                        ex.printStackTrace();
+                    }
+                }
+            }
+
+            plugin.getDatastore().saveGroup(group);
+        }
+
+        log.info("BungeePerms Migration: Migrated " + groupCount + " groups");
+
+        // Migrate all users.
+        log.info("BungeePerms Migration: Starting user migration.");
+        int userCount = 0;
+        for (User u : bp.getPermissionsManager().getBackEnd().loadUsers()) {
+            if (u.getUUID() == null) continue;
+
+            userCount++;
+
+            // Make a LuckPerms user for the one being migrated.
+            plugin.getDatastore().loadUser(u.getUUID(), "null");
+            me.lucko.luckperms.users.User user = plugin.getUserManager().get(u.getUUID());
+
+            // Migrate global perms
+            for (String perm : u.getPerms()) {
+                try {
+                    user.setPermission(perm, true);
+                    LogEntry.build()
+                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                            .acted(user).action("set " + perm + " true")
+                            .build().submit(plugin);
+                } catch (Exception ex) {
+                    if (!(ex instanceof ObjectAlreadyHasException)) {
+                        ex.printStackTrace();
+                    }
+                }
+            }
+
+            // Migrate per-server perms
+            for (Map.Entry<String, Server> e : u.getServers().entrySet()) {
+                for (String perm : e.getValue().getPerms()) {
+                    try {
+                        user.setPermission(perm, true, e.getKey());
+                        LogEntry.build()
+                                .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                                .acted(user).action("set " + perm + " true " + e.getKey())
+                                .build().submit(plugin);
+                    } catch (Exception ex) {
+                        if (!(ex instanceof ObjectAlreadyHasException)) {
+                            ex.printStackTrace();
+                        }
+                    }
+                }
+
+                // Migrate per-world perms
+                for (Map.Entry<String, World> we : e.getValue().getWorlds().entrySet()) {
+                    for (String perm : we.getValue().getPerms()) {
+                        try {
+                            user.setPermission(perm, true, e.getKey(), we.getKey());
+                            LogEntry.build()
+                                    .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                                    .acted(user).action("set " + perm + " true " + e.getKey() + " " + we.getKey())
+                                    .build().submit(plugin);
+                        } catch (Exception ex) {
+                            if (!(ex instanceof ObjectAlreadyHasException)) {
+                                ex.printStackTrace();
+                            }
+                        }
+                    }
+                }
+            }
+
+            // Migrate groups
+            for (String group : u.getGroupsString()) {
+                try {
+                    user.setPermission("group." + group, true);
+                    LogEntry.build()
+                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                            .acted(user).action("addgroup " + group)
+                            .build().submit(plugin);
+                } catch (Exception ex) {
+                    if (!(ex instanceof ObjectAlreadyHasException)) {
+                        ex.printStackTrace();
+                    }
+                }
+            }
+
+            // Migrate prefix & suffix
+            String prefix = u.getPrefix();
+            String suffix = u.getSuffix();
+
+            if (prefix != null && !prefix.equals("")) {
+                prefix = ArgumentChecker.escapeCharacters(prefix);
+                try {
+                    user.setPermission("prefix.100." + prefix, true);
+                    LogEntry.build()
+                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                            .acted(user).action("set prefix.100." + prefix + " true")
+                            .build().submit(plugin);
+                } catch (Exception ex) {
+                    if (!(ex instanceof ObjectAlreadyHasException)) {
+                        ex.printStackTrace();
+                    }
+                }
+            }
+
+            if (suffix != null && !suffix.equals("")) {
+                suffix = ArgumentChecker.escapeCharacters(suffix);
+                try {
+                    user.setPermission("suffix.100." + suffix, true);
+                    LogEntry.build()
+                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                            .acted(user).action("set suffix.100." + suffix + " true")
+                            .build().submit(plugin);
+                } catch (Exception ex) {
+                    if (!(ex instanceof ObjectAlreadyHasException)) {
+                        ex.printStackTrace();
+                    }
+                }
+            }
+
+            plugin.getDatastore().saveUser(user);
+            plugin.getUserManager().cleanup(user);
+        }
+
+        log.info("BungeePerms Migration: Migrated " + userCount + " users.");
+        log.info("BungeePerms Migration: Success! Completed without any errors.");
+        return CommandResult.SUCCESS;
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/migration/subcommands/MigrationGroupManager.java

@@ -0,0 +1,286 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 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.migration.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.api.Logger;
+import me.lucko.luckperms.commands.CommandResult;
+import me.lucko.luckperms.commands.Predicate;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
+import me.lucko.luckperms.constants.Constants;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.data.LogEntry;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import org.anjocaido.groupmanager.GlobalGroups;
+import org.anjocaido.groupmanager.GroupManager;
+import org.anjocaido.groupmanager.data.Group;
+import org.anjocaido.groupmanager.data.User;
+import org.anjocaido.groupmanager.dataholder.WorldDataHolder;
+import org.anjocaido.groupmanager.dataholder.worlds.WorldsHolder;
+
+import java.lang.reflect.InvocationTargetException;
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class MigrationGroupManager extends SubCommand<Object> {
+    public MigrationGroupManager() {
+        super("groupmanager", "Migration from GroupManager", "/%s migration groupmanager [world names]",
+                Permission.MIGRATION, Predicate.is(0));
+    }
+
+    @Override
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List<String> args, String label) {
+        final Logger log = plugin.getLog();
+        if (!plugin.isPluginLoaded("GroupManager")) {
+            log.severe("GroupManager Migration: Error -> GroupManager is not loaded.");
+            return CommandResult.STATE_ERROR;
+        }
+
+        final List<String> worlds = args.stream()
+                .map(String::toLowerCase)
+                .collect(Collectors.toList());
+
+        GroupManager gm = (GroupManager) plugin.getPlugin("GroupManager");
+
+        // Migrate Global Groups
+        log.info("GroupManager Migration: Starting Global Group migration.");
+
+        GlobalGroups gg;
+        try {
+            gg = (GlobalGroups) GroupManager.class.getMethod("getGlobalGroups").invoke(gm);
+        } catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
+            e.printStackTrace();
+            return CommandResult.FAILURE;
+        }
+
+        for (Group g : gg.getGroupList()) {
+            plugin.getDatastore().createAndLoadGroup(g.getName().toLowerCase());
+            me.lucko.luckperms.groups.Group group = plugin.getGroupManager().get(g.getName().toLowerCase());
+            try {
+                LogEntry.build()
+                        .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                        .acted(group).action("create")
+                        .build().submit(plugin);
+            } catch (Exception ex) {
+                ex.printStackTrace();
+            }
+
+            for (String node : g.getPermissionList()) {
+                boolean value = true;
+                if (node.startsWith("!") || node.startsWith("-")) {
+                    node = node.substring(1);
+                    value = false;
+                } else if (node.startsWith("+")) {
+                    node = node.substring(1);
+                    value = true;
+                }
+
+                try {
+                    group.setPermission(node, value);
+                    LogEntry.build()
+                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                            .acted(group).action("set " + node + " " + value)
+                            .build().submit(plugin);
+                } catch (Exception ex) {
+                    if (!(ex instanceof ObjectAlreadyHasException)) {
+                        ex.printStackTrace();
+                    }
+                }
+            }
+
+            for (String s : g.getInherits()) {
+                try {
+                    group.setPermission("group." + s.toLowerCase(), true);
+                    LogEntry.build()
+                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                            .acted(group).action("setinherit " + s.toLowerCase())
+                            .build().submit(plugin);
+                } catch (Exception ex) {
+                    if (!(ex instanceof ObjectAlreadyHasException)) {
+                        ex.printStackTrace();
+                    }
+                }
+            }
+
+        }
+
+        Map<UUID, Map<Map.Entry<String, String>, Boolean>> users = new HashMap<>();
+        Map<String, Map<Map.Entry<String, String>, Boolean>> groups = new HashMap<>();
+
+        WorldsHolder wh;
+        try {
+            wh = (WorldsHolder) GroupManager.class.getMethod("getWorldsHolder").invoke(gm);
+        } catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
+            e.printStackTrace();
+            return CommandResult.FAILURE;
+        }
+
+        // Collect data for all users and groups.
+        log.info("GroupManager Migration: Starting user and group migration.");
+        for (String world : worlds) {
+            world = world.toLowerCase();
+
+            WorldDataHolder wdh;
+
+            try {
+                wdh = (WorldDataHolder) WorldsHolder.class.getMethod("getWorldData", String.class).invoke(wh, world);
+            } catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
+                e.printStackTrace();
+                return CommandResult.FAILURE;
+            }
+
+            for (Group g : wdh.getGroupList()) {
+                groups.putIfAbsent(g.getName().toLowerCase(), new HashMap<>());
+
+                for (String node : g.getPermissionList()) {
+                    boolean value = true;
+                    if (node.startsWith("!") || node.startsWith("-")) {
+                        node = node.substring(1);
+                        value = false;
+                    } else if (node.startsWith("+")) {
+                        node = node.substring(1);
+                        value = true;
+                    }
+
+                    groups.get(g.getName().toLowerCase()).put(new AbstractMap.SimpleEntry<>(world, node), value);
+                }
+
+                for (String s : g.getInherits()) {
+                    groups.get(g.getName().toLowerCase()).put(new AbstractMap.SimpleEntry<>(world, "group." + s.toLowerCase()), true);
+                }
+            }
+
+            for (User user : wdh.getUserList()) {
+                UUID uuid;
+                try {
+                    uuid = UUID.fromString(user.getUUID());
+                } catch (IllegalArgumentException e){
+                    continue;
+                }
+
+                users.putIfAbsent(uuid, new HashMap<>());
+
+                for (String node : user.getPermissionList()) {
+                    boolean value = true;
+                    if (node.startsWith("!") || node.startsWith("-")) {
+                        node = node.substring(1);
+                        value = false;
+                    } else if (node.startsWith("+")) {
+                        node = node.substring(1);
+                        value = true;
+                    }
+
+                    users.get(uuid).put(new AbstractMap.SimpleEntry<>(world, node), value);
+                }
+
+                users.get(uuid).put(new AbstractMap.SimpleEntry<>(world, "group." + user.getGroupName().toLowerCase()), true);
+            }
+
+        }
+
+        log.info("GroupManager Migration: All existing GroupManager data has been processed. Now beginning the import process.");
+        log.info("GroupManager Migration: Found a total of " + users.size() + " users and " + groups.size() + " groups.");
+
+        for (Map.Entry<String, Map<Map.Entry<String, String>, Boolean>> e : groups.entrySet()) {
+            plugin.getDatastore().createAndLoadGroup(e.getKey());
+            me.lucko.luckperms.groups.Group group = plugin.getGroupManager().get(e.getKey());
+            try {
+                LogEntry.build()
+                        .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                        .acted(group).action("create")
+                        .build().submit(plugin);
+            } catch (Exception ex) {
+                ex.printStackTrace();
+            }
+
+
+            for (Map.Entry<Map.Entry<String, String>, Boolean> n : e.getValue().entrySet()) {
+                // n.key.key = world
+                // n.key.value = node
+                // n.value = true/false
+                try {
+                    group.setPermission("global-" + n.getKey().getKey() + "/" + n.getKey().getValue(), n.getValue());
+
+                    if (n.getKey().getValue().startsWith("group.")) {
+                        String groupName = n.getKey().getValue().substring(6);
+                        LogEntry.build()
+                                .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                                .acted(group).action("setinherit " + groupName + " global " + n.getKey().getKey())
+                                .build().submit(plugin);
+                    } else {
+                        LogEntry.build()
+                                .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                                .acted(group).action("set " + n.getKey().getValue() + " " + n.getValue() + " global " + n.getKey().getKey())
+                                .build().submit(plugin);
+                    }
+
+                } catch (Exception ex) {
+                    if (!(ex instanceof ObjectAlreadyHasException)) {
+                        ex.printStackTrace();
+                    }
+                }
+            }
+
+            plugin.getDatastore().saveGroup(group);
+        }
+
+        for (Map.Entry<UUID, Map<Map.Entry<String, String>, Boolean>> e : users.entrySet()) {
+            plugin.getDatastore().loadUser(e.getKey(), "null");
+            me.lucko.luckperms.users.User user = plugin.getUserManager().get(e.getKey());
+
+            for (Map.Entry<Map.Entry<String, String>, Boolean> n : e.getValue().entrySet()) {
+                // n.key.key = world
+                // n.key.value = node
+                // n.value = true/false
+                try {
+                    user.setPermission("global-" + n.getKey().getKey() + "/" + n.getKey().getValue(), n.getValue());
+
+                    if (n.getKey().getValue().startsWith("group.")) {
+                        String group = n.getKey().getValue().substring(6);
+                        LogEntry.build()
+                                .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                                .acted(user).action("addgroup " + group + " global " + n.getKey().getKey())
+                                .build().submit(plugin);
+                    } else {
+                        LogEntry.build()
+                                .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                                .acted(user).action("set " + n.getKey().getValue() + " " + n.getValue() + " global " + n.getKey().getKey())
+                                .build().submit(plugin);
+                    }
+
+                } catch (Exception ex) {
+                    if (!(ex instanceof ObjectAlreadyHasException)) {
+                        ex.printStackTrace();
+                    }
+                }
+            }
+
+            plugin.getDatastore().saveUser(user);
+            plugin.getUserManager().cleanup(user);
+        }
+
+        log.info("GroupManager Migration: Success! Completed without any errors.");
+        return CommandResult.SUCCESS;
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/migration/subcommands/MigrationPermissionsEx.java

@@ -0,0 +1,413 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 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.migration.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.api.Logger;
+import me.lucko.luckperms.commands.CommandResult;
+import me.lucko.luckperms.commands.Predicate;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
+import me.lucko.luckperms.constants.Constants;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.data.LogEntry;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.groups.Group;
+import me.lucko.luckperms.users.User;
+import me.lucko.luckperms.utils.ArgumentChecker;
+import ru.tehkode.permissions.NativeInterface;
+import ru.tehkode.permissions.PermissionGroup;
+import ru.tehkode.permissions.PermissionManager;
+import ru.tehkode.permissions.PermissionUser;
+import ru.tehkode.permissions.bukkit.PermissionsEx;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.List;
+import java.util.UUID;
+import java.util.stream.Collectors;
+
+public class MigrationPermissionsEx extends SubCommand<Object> {
+
+    private static Class<?> bukkitPlayer = null;
+    private static Method getUniqueIdMethod = null;
+    private static Method getPlayerMethod = null;
+
+    static {
+        try {
+            bukkitPlayer = Class.forName("org.bukkit.entity.Player");
+        } catch (ClassNotFoundException e) {
+            e.printStackTrace();
+        }
+
+        if (bukkitPlayer != null) {
+            try {
+                getUniqueIdMethod = bukkitPlayer.getMethod("getUniqueId");
+                getUniqueIdMethod.setAccessible(true);
+            } catch (NoSuchMethodException e) {
+                e.printStackTrace();
+            }
+        }
+
+        try {
+            getPlayerMethod = PermissionUser.class.getMethod("getPlayer");
+            getPlayerMethod.setAccessible(true);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public MigrationPermissionsEx() {
+        super("permissionsex", "Migration from PermissionsEx", "/%s migration permissionsex [world names]",
+                Permission.MIGRATION, Predicate.alwaysFalse());
+    }
+
+    @SuppressWarnings("deprecation")
+    @Override
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List<String> args, String label) {
+        final Logger log = plugin.getLog();
+        if (!plugin.isPluginLoaded("PermissionsEx")) {
+            log.severe("PermissionsEx Migration: Error -> PermissionsEx is not loaded.");
+            return CommandResult.STATE_ERROR;
+        }
+
+        if (plugin.getType() != LuckPermsPlugin.Type.BUKKIT) {
+            // Sponge uses a completely different version of PEX.
+            log.severe("PEX import is not supported on this platform.");
+            return CommandResult.STATE_ERROR;
+        }
+
+        final List<String> worlds = args.stream()
+                .map(String::toLowerCase)
+                .collect(Collectors.toList());
+
+        PermissionsEx pex = (PermissionsEx) plugin.getPlugin("PermissionsEx");
+        PermissionManager manager; // The compiler complains if you call the method directly, as Bukkit is not in this module.
+        try {
+            manager = (PermissionManager) PermissionsEx.class.getMethod("getPermissionsManager").invoke(pex);
+        } catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
+            e.printStackTrace();
+            return CommandResult.FAILURE;
+        }
+
+        NativeInterface ni;
+        try {
+            Field f = manager.getClass().getDeclaredField("nativeI");
+            f.setAccessible(true);
+            ni = (NativeInterface) f.get(manager);
+        } catch (Throwable t) {
+            t.printStackTrace();
+            return CommandResult.FAILURE;
+        }
+
+        // Migrate all groups.
+        log.info("PermissionsEx Migration: Starting group migration.");
+        int groupCount = 0;
+        for (PermissionGroup group : manager.getGroupList()) {
+            groupCount ++;
+            final String name = group.getName().toLowerCase();
+            plugin.getDatastore().createAndLoadGroup(name);
+            Group lpGroup = plugin.getGroupManager().get(name);
+            try {
+                LogEntry.build()
+                        .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                        .acted(lpGroup).action("create")
+                        .build().submit(plugin);
+            } catch (Exception ex) {
+                ex.printStackTrace();
+            }
+
+            try {
+                for (String node : group.getOwnPermissions(null)) {
+                    boolean value = true;
+                    if (node.startsWith("!")) {
+                        node = node.substring(1);
+                        value = false;
+                    }
+
+                    try {
+                        lpGroup.setPermission(node, value);
+                        LogEntry.build()
+                                .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                                .acted(lpGroup).action("set " + node + " " + value)
+                                .build().submit(plugin);
+                    } catch (Exception ex) {
+                        if (!(ex instanceof ObjectAlreadyHasException)) {
+                            ex.printStackTrace();
+                        }
+                    }
+                }
+            } catch (NullPointerException ignored) {
+                // Probably won't happen. I have no API docs on getOwnPermissions#null though.
+            }
+
+            if (worlds != null && !worlds.isEmpty()) {
+                for (String world : worlds) {
+                    for (String node : group.getOwnPermissions(world)) {
+                        boolean value = true;
+                        if (node.startsWith("!")) {
+                            node = node.substring(1);
+                            value = false;
+                        }
+
+                        try {
+                            lpGroup.setPermission(node, value, "global", world);
+                            LogEntry.build()
+                                    .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                                    .acted(lpGroup).action("set " + node + " " + value + " global " + world)
+                                    .build().submit(plugin);
+                        } catch (Exception ex) {
+                            if (!(ex instanceof ObjectAlreadyHasException)) {
+                                ex.printStackTrace();
+                            }
+                        }
+                    }
+                }
+            }
+
+            for (PermissionGroup g : group.getParents()) {
+                try {
+                    lpGroup.setPermission("group." + g.getName().toLowerCase(), true);
+                    LogEntry.build()
+                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                            .acted(lpGroup).action("setinherit " + g.getName().toLowerCase())
+                            .build().submit(plugin);
+                } catch (Exception ex) {
+                    if (!(ex instanceof ObjectAlreadyHasException)) {
+                        ex.printStackTrace();
+                    }
+                }
+            }
+
+            if (worlds != null && !worlds.isEmpty()) {
+                for (String world : worlds) {
+                    for (PermissionGroup g : group.getParents(world)) {
+                        try {
+                            lpGroup.setPermission("group." + g.getName().toLowerCase(), true, "global", world);
+                            LogEntry.build()
+                                    .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                                    .acted(lpGroup).action("setinherit " + g.getName().toLowerCase() + " global " + world)
+                                    .build().submit(plugin);
+                        } catch (Exception ex) {
+                            if (!(ex instanceof ObjectAlreadyHasException)) {
+                                ex.printStackTrace();
+                            }
+                        }
+                    }
+                }
+            }
+
+            String prefix = group.getOwnPrefix();
+            String suffix = group.getOwnSuffix();
+
+            if (prefix != null && !prefix.equals("")) {
+                prefix = ArgumentChecker.escapeCharacters(prefix);
+                try {
+                    lpGroup.setPermission("prefix.50." + prefix, true);
+                    LogEntry.build()
+                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                            .acted(lpGroup).action("set prefix.50." + prefix + " true")
+                            .build().submit(plugin);
+                } catch (Exception ex) {
+                    if (!(ex instanceof ObjectAlreadyHasException)) {
+                        ex.printStackTrace();
+                    }
+                }
+            }
+
+            if (suffix != null && !suffix.equals("")) {
+                suffix = ArgumentChecker.escapeCharacters(suffix);
+                try {
+                    lpGroup.setPermission("suffix.50." + suffix, true);
+                    LogEntry.build()
+                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                            .acted(lpGroup).action("set suffix.50." + suffix + " true")
+                            .build().submit(plugin);
+                } catch (Exception ex) {
+                    if (!(ex instanceof ObjectAlreadyHasException)) {
+                        ex.printStackTrace();
+                    }
+                }
+            }
+
+        }
+
+        log.info("PermissionsEx Migration: Migrated " + groupCount + " groups");
+
+        // Migrate all users
+        log.info("PermissionsEx Migration: Starting user migration.");
+        int userCount = 0;
+        for (PermissionUser user : manager.getUsers()) {
+            UUID u = null;
+
+            try {
+                u = UUID.fromString(user.getIdentifier());
+            } catch (IllegalArgumentException e) {
+
+                u = ni.nameToUUID(user.getIdentifier());
+
+                if (u == null) {
+                    if (bukkitPlayer != null) {
+                        try {
+                            Object playerObj = getPlayerMethod.invoke(user);
+                            u = (UUID) getUniqueIdMethod.invoke(playerObj);
+
+                        } catch (Throwable t) {
+                            t.printStackTrace();
+                        }
+                    }
+                }
+            }
+
+            if (u == null) {
+                log.severe("Unable to get a UUID for user identifier: " + user.getIdentifier());
+                continue;
+            }
+
+            userCount++;
+            plugin.getDatastore().loadUser(u, "null");
+            User lpUser = plugin.getUserManager().get(u);
+
+            try {
+                for (String node : user.getOwnPermissions(null)) {
+                    boolean value = true;
+                    if (node.startsWith("!")) {
+                        node = node.substring(1);
+                        value = false;
+                    }
+
+                    try {
+                        lpUser.setPermission(node, value);
+                        LogEntry.build()
+                                .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                                .acted(lpUser).action("set " + node + " " + value)
+                                .build().submit(plugin);
+                    } catch (Exception ex) {
+                        if (!(ex instanceof ObjectAlreadyHasException)) {
+                            ex.printStackTrace();
+                        }
+                    }
+                }
+            } catch (NullPointerException ignored) {
+                // Probably won't happen. I have no API docs on getOwnPermissions#null though.
+            }
+
+            if (worlds != null && !worlds.isEmpty()) {
+                for (String world : worlds) {
+                    for (String node : user.getOwnPermissions(world)) {
+                        boolean value = true;
+                        if (node.startsWith("!")) {
+                            node = node.substring(1);
+                            value = false;
+                        }
+
+                        try {
+                            lpUser.setPermission(node, value, "global", world);
+                            LogEntry.build()
+                                    .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                                    .acted(lpUser).action("set " + node + " " + value + " global " + world)
+                                    .build().submit(plugin);
+                        } catch (Exception ex) {
+                            if (!(ex instanceof ObjectAlreadyHasException)) {
+                                ex.printStackTrace();
+                            }
+                        }
+                    }
+                }
+            }
+
+            for (String s : user.getGroupNames()) {
+                try {
+                    lpUser.setPermission("group." + s.toLowerCase(), true);
+                    LogEntry.build()
+                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                            .acted(lpUser).action("addgroup " + s.toLowerCase())
+                            .build().submit(plugin);
+                } catch (Exception ex) {
+                    if (!(ex instanceof ObjectAlreadyHasException)) {
+                        ex.printStackTrace();
+                    }
+                }
+            }
+
+            if (worlds != null && !worlds.isEmpty()) {
+                for (String world : worlds) {
+                    for (String s : user.getGroupNames(world)) {
+                        try {
+                            lpUser.setPermission("group." + s.toLowerCase(), true, "global", world);
+                            LogEntry.build()
+                                    .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                                    .acted(lpUser).action("addgroup " + s.toLowerCase() + " global " + world)
+                                    .build().submit(plugin);
+                        } catch (Exception ex) {
+                            if (!(ex instanceof ObjectAlreadyHasException)) {
+                                ex.printStackTrace();
+                            }
+                        }
+                    }
+                }
+            }
+
+            String prefix = user.getOwnPrefix();
+            String suffix = user.getOwnSuffix();
+
+            if (prefix != null && !prefix.equals("")) {
+                prefix = ArgumentChecker.escapeCharacters(prefix);
+                try {
+                    lpUser.setPermission("prefix.100." + prefix, true);
+                    LogEntry.build()
+                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                            .acted(lpUser).action("set prefix.100." + prefix + " true")
+                            .build().submit(plugin);
+                } catch (Exception ex) {
+                    if (!(ex instanceof ObjectAlreadyHasException)) {
+                        ex.printStackTrace();
+                    }
+                }
+            }
+
+            if (suffix != null && !suffix.equals("")) {
+                suffix = ArgumentChecker.escapeCharacters(suffix);
+                try {
+                    lpUser.setPermission("suffix.100." + suffix, true);
+                    LogEntry.build()
+                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                            .acted(lpUser).action("set suffix.100." + suffix + " true")
+                            .build().submit(plugin);
+                } catch (Exception ex) {
+                    if (!(ex instanceof ObjectAlreadyHasException)) {
+                        ex.printStackTrace();
+                    }
+                }
+            }
+
+            plugin.getUserManager().cleanup(lpUser);
+            plugin.getDatastore().saveUser(lpUser);
+        }
+
+        log.info("PermissionsEx Migration: Migrated " + userCount + " users.");
+        log.info("PermissionsEx Migration: Success! Completed without any errors.");
+        return CommandResult.SUCCESS;
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/migration/subcommands/MigrationPowerfulPerms.java

@@ -0,0 +1,529 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 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.migration.subcommands;
+
+import com.github.cheesesoftware.PowerfulPermsAPI.*;
+import com.zaxxer.hikari.HikariDataSource;
+import lombok.Cleanup;
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.api.Logger;
+import me.lucko.luckperms.commands.CommandResult;
+import me.lucko.luckperms.commands.Predicate;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
+import me.lucko.luckperms.constants.Constants;
+import me.lucko.luckperms.core.PermissionHolder;
+import me.lucko.luckperms.data.LogEntry;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.users.User;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.util.*;
+import java.util.concurrent.CountDownLatch;
+
+import static me.lucko.luckperms.constants.Permission.MIGRATION;
+
+public class MigrationPowerfulPerms extends SubCommand<Object> {
+    /* <sadness>
+        What kind of API requires reflection to function with multiple versions...
+        Doesn't that just defeat the whole god damn point of having an API in the first place?
+        Whatever happened to the concept of depreciation and responsible API creation?
+        I tried to keep reflection to a minimum, but in some places there's no other option.
+        This class is a complete fucking mess for that reason. I sad now :(
+       </sadness> */
+    private static Method getPlayerGroupsMethod = null;
+    private static Method getGroupMethod = null;
+    private static boolean legacy = false;
+
+    static {
+        try {
+            getPlayerGroupsMethod = PermissionManager.class.getMethod("getPlayerOwnGroups", UUID.class, ResultRunnable.class);
+            getPlayerGroupsMethod.setAccessible(true);
+        } catch (NoSuchMethodException e) {
+            try {
+                getPlayerGroupsMethod = PermissionManager.class.getMethod("getPlayerGroups", UUID.class, ResultRunnable.class);
+                getPlayerGroupsMethod.setAccessible(true);
+            } catch (NoSuchMethodException e1) {
+                e1.printStackTrace();
+            }
+        }
+
+        try {
+            getGroupMethod = CachedGroup.class.getMethod("getGroup");
+            getGroupMethod.setAccessible(true);
+            legacy = true;
+        } catch (NoSuchMethodException ignored) {
+        }
+    }
+
+
+    public MigrationPowerfulPerms() {
+        super("powerfulperms", "Migration from PowerfulPerms",
+                "/%s migration powerfulperms <address> <database> <username> <password> <db table>", MIGRATION, Predicate.not(5));
+    }
+
+    @Override
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List<String> args, String label) {
+        try {
+            return run(plugin, args);
+        } catch (Throwable t) {
+            t.printStackTrace();
+            return CommandResult.FAILURE;
+        }
+    }
+
+    private CommandResult run(LuckPermsPlugin plugin, List<String> args) {
+        final Logger log = plugin.getLog();
+        if (!plugin.isPluginLoaded("PowerfulPerms")) {
+            log.severe("PowerfulPerms Migration: Error -> PowerfulPerms is not loaded.");
+            return CommandResult.STATE_ERROR;
+        }
+
+        final String address = args.get(0);
+        final String database = args.get(1);
+        final String username = args.get(2);
+        final String password = args.get(3);
+        final String dbTable = args.get(4);
+
+        // Find a list of UUIDs
+        log.info("PowerfulPerms Migration: Getting a list of UUIDs to migrate.");
+
+        @Cleanup HikariDataSource hikari = new HikariDataSource();
+        hikari.setMaximumPoolSize(2);
+        hikari.setDataSourceClassName("com.mysql.jdbc.jdbc2.optional.MysqlDataSource");
+        hikari.addDataSourceProperty("serverName", address.split(":")[0]);
+        hikari.addDataSourceProperty("port", address.split(":")[1]);
+        hikari.addDataSourceProperty("databaseName", database);
+        hikari.addDataSourceProperty("user", username);
+        hikari.addDataSourceProperty("password", password);
+
+        Set<UUID> uuids = new HashSet<>();
+
+        try {
+            @Cleanup Connection connection = hikari.getConnection();
+            DatabaseMetaData meta = connection.getMetaData();
+
+            @Cleanup ResultSet tables = meta.getTables(null, null, dbTable, null);
+            if (!tables.next()) {
+                log.severe("PowerfulPerms Migration: Error - Couldn't find table.");
+                return CommandResult.FAILURE;
+
+            } else {
+                @Cleanup PreparedStatement columnPs = connection.prepareStatement("SELECT COLUMN_NAME, COLUMN_TYPE FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME=?");
+                columnPs.setString(1, dbTable);
+                @Cleanup ResultSet columnRs = columnPs.executeQuery();
+
+                log.info("Found table: " + dbTable);
+                while (columnRs.next()) {
+                    log.info("" + columnRs.getString("COLUMN_NAME") + " - " + columnRs.getString("COLUMN_TYPE"));
+                }
+
+                @Cleanup PreparedStatement preparedStatement = connection.prepareStatement("SELECT `uuid` FROM " + dbTable);
+                @Cleanup ResultSet resultSet = preparedStatement.executeQuery();
+
+                while (resultSet.next()) {
+                    uuids.add(UUID.fromString(resultSet.getString("uuid")));
+                }
+            }
+
+        } catch (Exception e) {
+            e.printStackTrace();
+            return CommandResult.FAILURE;
+        }
+
+        if (uuids.isEmpty()) {
+            log.severe("PowerfulPerms Migration: Error - Unable to find any UUIDs to migrate.");
+            return CommandResult.FAILURE;
+        }
+
+        log.info("PowerfulPerms Migration: Found " + uuids.size() + " uuids. Starting migration.");
+
+        PowerfulPermsPlugin ppPlugin = (PowerfulPermsPlugin) plugin.getPlugin("PowerfulPerms");
+        PermissionManager pm = ppPlugin.getPermissionManager();
+
+        // Groups first.
+        log.info("PowerfulPerms Migration: Starting group migration.");
+        Map<Integer, Group> groups = pm.getGroups();
+        for (Group g : groups.values()) {
+            plugin.getDatastore().createAndLoadGroup(g.getName().toLowerCase());
+            final me.lucko.luckperms.groups.Group group = plugin.getGroupManager().get(g.getName().toLowerCase());
+            try {
+                LogEntry.build()
+                        .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                        .acted(group).action("create")
+                        .build().submit(plugin);
+            } catch (Exception ex) {
+                ex.printStackTrace();
+            }
+
+            for (Permission p : g.getOwnPermissions()) {
+                applyPerm(group, p, plugin);
+            }
+
+            for (Group parent : g.getParents()) {
+                try {
+                    group.setPermission("group." + parent.getName().toLowerCase(), true);
+                    LogEntry.build()
+                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                            .acted(group).action("setinherit " + parent.getName().toLowerCase())
+                            .build().submit(plugin);
+                } catch (Exception ex) {
+                    if (!(ex instanceof ObjectAlreadyHasException)) {
+                        ex.printStackTrace();
+                    }
+                }
+            }
+
+            plugin.getDatastore().saveGroup(group);
+        }
+        log.info("PowerfulPerms Migration: Group migration complete.");
+
+        // Now users.
+        log.info("PowerfulPerms Migration: Starting user migration.");
+        final Map<UUID, CountDownLatch> progress = new HashMap<>();
+
+        // Migrate all users and their groups
+        for (UUID uuid : uuids) {
+            progress.put(uuid, new CountDownLatch(2));
+
+            // Create a LuckPerms user for the UUID
+            plugin.getDatastore().loadUser(uuid, "null");
+            User user = plugin.getUserManager().get(uuid);
+
+            // Get a list of Permissions held by the user from the PP API.
+            pm.getPlayerOwnPermissions(uuid, new LPResultRunnable<List<Permission>>() {
+                @Override
+                public void run() {
+                    List<Permission> perms = this.getResult();
+                    perms.forEach(p -> applyPerm(user, p, plugin));
+
+                    // Update the progress so the user can be saved and unloaded.
+                    synchronized (progress) {
+                        progress.get(uuid).countDown();
+                        if (progress.get(uuid).getCount() == 0) {
+                            plugin.getDatastore().saveUser(user);
+                            plugin.getUserManager().cleanup(user);
+                        }
+                    }
+
+                }
+            });
+
+            // Migrate the user's groups to LuckPerms from PP.
+            try {
+                getPlayerGroupsMethod.invoke(pm, uuid, new LPResultRunnable<LinkedHashMap<String, List<CachedGroup>>>() {
+                    @Override
+                    public void run() {
+                        Map<String, List<CachedGroup>> groups = getResult();
+
+                        for (Map.Entry<String, List<CachedGroup>> e : groups.entrySet()) {
+                            final String server;
+                            if (e.getKey() != null && (e.getKey().equals("") || e.getKey().equalsIgnoreCase("all"))) {
+                                server = null;
+                            } else {
+                                server = e.getKey();
+                            }
+
+                            // This is horrible. So many random API changes through versions, no depreciation.
+                            if (legacy) {
+                                e.getValue().stream()
+                                        .filter(cg -> !cg.isNegated())
+                                        .map(cg -> {
+                                            try {
+                                                return (Group) getGroupMethod.invoke(cg);
+                                            } catch (IllegalAccessException | InvocationTargetException e1) {
+                                                e1.printStackTrace();
+                                                return null;
+                                            }
+                                        })
+                                        .forEach(g -> {
+                                            if (g != null) {
+                                                if (server == null) {
+                                                    try {
+                                                        user.setPermission("group." + g.getName().toLowerCase(), true);
+                                                        LogEntry.build()
+                                                                .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                                                                .acted(user).action("addgroup " + g.getName().toLowerCase())
+                                                                .build().submit(plugin);
+                                                    } catch (Exception ex) {
+                                                        if (!(ex instanceof ObjectAlreadyHasException)) {
+                                                            ex.printStackTrace();
+                                                        }
+                                                    }
+                                                } else {
+                                                    try {
+                                                        user.setPermission("group." + g.getName().toLowerCase(), true, server);
+                                                        LogEntry.build()
+                                                                .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                                                                .acted(user).action("addgroup " + g.getName().toLowerCase() + " " + server)
+                                                                .build().submit(plugin);
+                                                    } catch (Exception ex) {
+                                                        if (!(ex instanceof ObjectAlreadyHasException)) {
+                                                            ex.printStackTrace();
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        });
+                            } else {
+                                e.getValue().stream()
+                                        .filter(g -> !g.hasExpired() && !g.isNegated())
+                                        .forEach(g -> {
+                                            final Group group = pm.getGroup(g.getGroupId());
+                                            if (g.willExpire()) {
+                                                if (server == null) {
+                                                    try {
+                                                        user.setPermission("group." + group.getName().toLowerCase(), true, g.getExpirationDate().getTime() / 1000L);
+                                                        LogEntry.build()
+                                                                .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                                                                .acted(user).action("addtempgroup " + group.getName().toLowerCase() + " " + g.getExpirationDate().getTime() / 1000L)
+                                                                .build().submit(plugin);
+                                                    } catch (Exception ex) {
+                                                        if (!(ex instanceof ObjectAlreadyHasException)) {
+                                                            ex.printStackTrace();
+                                                        }
+                                                    }
+                                                } else {
+                                                    try {
+                                                        user.setPermission("group." + group.getName().toLowerCase(), true, server, g.getExpirationDate().getTime() / 1000L);
+                                                        LogEntry.build()
+                                                                .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                                                                .acted(user).action("addtempgroup " + group.getName().toLowerCase() + " " + g.getExpirationDate().getTime() / 1000L + " " + server)
+                                                                .build().submit(plugin);
+                                                    } catch (Exception ex) {
+                                                        if (!(ex instanceof ObjectAlreadyHasException)) {
+                                                            ex.printStackTrace();
+                                                        }
+                                                    }
+                                                }
+
+                                            } else {
+                                                if (server == null) {
+                                                    try {
+                                                        user.setPermission("group." + group.getName().toLowerCase(), true);
+                                                        LogEntry.build()
+                                                                .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                                                                .acted(user).action("addgroup " + group.getName().toLowerCase())
+                                                                .build().submit(plugin);
+                                                    } catch (Exception ex) {
+                                                        if (!(ex instanceof ObjectAlreadyHasException)) {
+                                                            ex.printStackTrace();
+                                                        }
+                                                    }
+                                                } else {
+                                                    try {
+                                                        user.setPermission("group." + group.getName().toLowerCase(), true, server);
+                                                        LogEntry.build()
+                                                                .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                                                                .acted(user).action("addgroup " + group.getName().toLowerCase() + " " + server)
+                                                                .build().submit(plugin);
+                                                    } catch (Exception ex) {
+                                                        if (!(ex instanceof ObjectAlreadyHasException)) {
+                                                            ex.printStackTrace();
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        });
+                            }
+                        }
+
+                        // Update the progress so the user can be saved and unloaded.
+                        synchronized (progress) {
+                            progress.get(uuid).countDown();
+                            if (progress.get(uuid).getCount() == 0) {
+                                plugin.getDatastore().saveUser(user);
+                                plugin.getUserManager().cleanup(user);
+                            }
+                        }
+                    }
+                });
+            } catch (IllegalAccessException | InvocationTargetException e) {
+                log.info("PowerfulPerms Migration: Error");
+                e.printStackTrace();
+            }
+        }
+
+        // All groups are migrated, but there may still be some users being migrated.
+        // This block will wait for all users to be completed.
+        log.info("PowerfulPerms Migration: Waiting for user migration to complete. This may take some time");
+        boolean sleep = true;
+        while (sleep) {
+            sleep = false;
+
+            for (Map.Entry<UUID, CountDownLatch> e : progress.entrySet()) {
+                if (e.getValue().getCount() != 0) {
+                    sleep = true;
+                    break;
+                }
+            }
+
+            if (sleep) {
+                try {
+                    Thread.sleep(5000);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+
+        }
+
+        // We done.
+        log.info("PowerfulPerms Migration: Success! Completed without any errors.");
+        return CommandResult.SUCCESS;
+    }
+
+    private void applyPerm(PermissionHolder holder, Permission p, LuckPermsPlugin plugin) {
+        String node = p.getPermissionString();
+        boolean value = true;
+        if (node.startsWith("!")) {
+            node = node.substring(1);
+            value = false;
+        }
+
+        String server = p.getServer();
+        if (server != null && server.equalsIgnoreCase("all")) {
+            server = null;
+        }
+
+        String world = p.getWorld();
+        if (world != null && world.equalsIgnoreCase("all")) {
+            world = null;
+        }
+
+        long expireAt = 0L;
+        if (!legacy) {
+            if (p.willExpire()) {
+                expireAt = p.getExpirationDate().getTime() / 1000L;
+            }
+        }
+
+        if (world != null && server == null) {
+            server = "global";
+        }
+
+        if (world != null) {
+            if (expireAt == 0L) {
+                try {
+                    holder.setPermission(node, value, server, world);
+                    LogEntry.build()
+                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                            .acted(holder).action("set " + node + " " + value + " " + server + " " + world)
+                            .build().submit(plugin);
+                } catch (Exception ex) {
+                    if (!(ex instanceof ObjectAlreadyHasException)) {
+                        ex.printStackTrace();
+                    }
+                }
+            } else {
+                try {
+                    holder.setPermission(node, value, server, world, expireAt);
+                    LogEntry.build()
+                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                            .acted(holder).action("settemp " + node + " " + value + " " + expireAt + " " + server + " " + world)
+                            .build().submit(plugin);
+                } catch (Exception ex) {
+                    if (!(ex instanceof ObjectAlreadyHasException)) {
+                        ex.printStackTrace();
+                    }
+                }
+            }
+
+        } else if (server != null) {
+            if (expireAt == 0L) {
+                try {
+                    holder.setPermission(node, value, server);
+                    LogEntry.build()
+                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                            .acted(holder).action("set " + node + " " + value + " " + server)
+                            .build().submit(plugin);
+                } catch (Exception ex) {
+                    if (!(ex instanceof ObjectAlreadyHasException)) {
+                        ex.printStackTrace();
+                    }
+                }
+            } else {
+                try {
+                    holder.setPermission(node, value, server, expireAt);
+                    LogEntry.build()
+                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                            .acted(holder).action("settemp " + node + " " + value + " " + expireAt + " " + server)
+                            .build().submit(plugin);
+                } catch (Exception ex) {
+                    if (!(ex instanceof ObjectAlreadyHasException)) {
+                        ex.printStackTrace();
+                    }
+                }
+            }
+        } else {
+            if (expireAt == 0L) {
+                try {
+                    holder.setPermission(node, value);
+                    LogEntry.build()
+                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                            .acted(holder).action("set " + node + " " + value)
+                            .build().submit(plugin);
+                } catch (Exception ex) {
+                    if (!(ex instanceof ObjectAlreadyHasException)) {
+                        ex.printStackTrace();
+                    }
+                }
+            } else {
+                try {
+                    holder.setPermission(node, value, expireAt);
+                    LogEntry.build()
+                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                            .acted(holder).action("settemp " + node + " " + value + " " + expireAt)
+                            .build().submit(plugin);
+                } catch (Exception ex) {
+                    if (!(ex instanceof ObjectAlreadyHasException)) {
+                        ex.printStackTrace();
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Overrides the default ResultRunnable, callbacks will always run in the same thread. (an async one, hopefully.)
+     * @param <T> type
+     */
+    @SuppressWarnings("WeakerAccess")
+    public abstract class LPResultRunnable<T> extends ResultRunnable<T> {
+
+        public LPResultRunnable() {
+            super();
+            super.sameThread = true;
+        }
+
+        public T getResult() {
+            return super.result;
+        }
+
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/migration/subcommands/MigrationZPermissions.java

@@ -0,0 +1,254 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.commands.migration.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.api.Logger;
+import me.lucko.luckperms.commands.CommandResult;
+import me.lucko.luckperms.commands.Predicate;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
+import me.lucko.luckperms.constants.Constants;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.data.LogEntry;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.groups.Group;
+import me.lucko.luckperms.tracks.Track;
+import me.lucko.luckperms.users.User;
+import me.lucko.luckperms.utils.ArgumentChecker;
+import org.tyrannyofheaven.bukkit.zPermissions.ZPermissionsService;
+
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import java.util.stream.Collectors;
+
+/**
+ * <3 <3  zPermissions  <3 <3
+ * Finally a permissions plugin with a decent API. *sigh*
+ */
+public class MigrationZPermissions extends SubCommand<Object> {
+    public MigrationZPermissions() {
+        super("zpermissions", "Migration from zPermissions", "/%s migration zpermissions [world names]",
+                Permission.MIGRATION, Predicate.alwaysFalse());
+    }
+
+    @Override
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List<String> args, String label) {
+        final Logger log = plugin.getLog();
+        if (!plugin.isPluginLoaded("zPermissions")) {
+            log.severe("zPermissions Migration: Error -> zPermissions is not loaded.");
+            return CommandResult.STATE_ERROR;
+        }
+
+        ZPermissionsService service = (ZPermissionsService) plugin.getService(ZPermissionsService.class);
+        if (service == null) {
+            log.severe("zPermissions Migration: Error -> zPermissions is not loaded.");
+            return CommandResult.STATE_ERROR;
+        }
+
+        final List<String> worlds = args.stream()
+                .map(String::toLowerCase)
+                .collect(Collectors.toList());
+
+        // Migrate all groups
+        log.info("zPermissions Migration: Starting group migration.");
+        for (String g : service.getAllGroups()) {
+            plugin.getDatastore().createAndLoadGroup(g.toLowerCase());
+            Group group = plugin.getGroupManager().get(g.toLowerCase());
+            try {
+                LogEntry.build()
+                        .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                        .acted(group).action("create")
+                        .build().submit(plugin);
+            } catch (Exception ex) {
+                ex.printStackTrace();
+            }
+
+            for (Map.Entry<String, Boolean> e : service.getGroupPermissions(null, null, g).entrySet()) {
+                try {
+                    group.setPermission(e.getKey(), e.getValue());
+                    LogEntry.build()
+                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                            .acted(group).action("set " + e.getKey() + " " + e.getValue())
+                            .build().submit(plugin);
+                } catch (Exception ex) {
+                    if (!(ex instanceof ObjectAlreadyHasException)) {
+                        ex.printStackTrace();
+                    }
+                }
+            }
+
+            if (worlds != null && !worlds.isEmpty()) {
+                for (String world : worlds) {
+                    for (Map.Entry<String, Boolean> e : service.getGroupPermissions(world, null, g).entrySet()) {
+                        try {
+                            group.setPermission(e.getKey(), e.getValue(), "global", world);
+                            LogEntry.build()
+                                    .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                                    .acted(group).action("set " + e.getKey() + " true " + e.getValue() + " " + world)
+                                    .build().submit(plugin);
+                        } catch (Exception ex) {
+                            if (!(ex instanceof ObjectAlreadyHasException)) {
+                                ex.printStackTrace();
+                            }
+                        }
+                    }
+                }
+            }
+
+            plugin.getDatastore().saveGroup(group);
+        }
+
+        // Migrate all tracks
+        log.info("zPermissions Migration: Starting track migration.");
+        for (String t : service.getAllTracks()) {
+            plugin.getDatastore().createAndLoadTrack(t.toLowerCase());
+            Track track = plugin.getTrackManager().get(t.toLowerCase());
+            try {
+                LogEntry.build()
+                        .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                        .acted(track).action("create")
+                        .build().submit(plugin);
+            } catch (Exception ex) {
+                ex.printStackTrace();
+            }
+
+            track.setGroups(service.getTrackGroups(t));
+            for (String group : track.getGroups()) {
+                try {
+                    LogEntry.build()
+                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                            .acted(track).action("append " + group)
+                            .build().submit(plugin);
+                } catch (Exception ex) {
+                    ex.printStackTrace();
+                }
+            }
+
+            plugin.getDatastore().saveTrack(track);
+        }
+
+        // Migrate all users.
+        log.info("zPermissions Migration: Starting user migration.");
+        for (UUID u : service.getAllPlayersUUID()) {
+            plugin.getDatastore().loadUser(u, "null");
+            User user = plugin.getUserManager().get(u);
+
+            for (Map.Entry<String, Boolean> e : service.getPlayerPermissions(null, null, u).entrySet()) {
+                try {
+                    user.setPermission(e.getKey(), e.getValue());
+                    LogEntry.build()
+                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                            .acted(user).action("set " + e.getKey() + " " + e.getValue())
+                            .build().submit(plugin);
+                } catch (Exception ex) {
+                    if (!(ex instanceof ObjectAlreadyHasException)) {
+                        ex.printStackTrace();
+                    }
+                }
+            }
+
+            if (worlds != null && !worlds.isEmpty()) {
+                for (String world : worlds) {
+                    for (Map.Entry<String, Boolean> e : service.getPlayerPermissions(world, null, u).entrySet()) {
+                        try {
+                            user.setPermission(e.getKey(), e.getValue(), "global", world);
+                            LogEntry.build()
+                                    .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                                    .acted(user).action("set " + e.getKey() + " true " + e.getValue() + " " + world)
+                                    .build().submit(plugin);
+                        } catch (Exception ex) {
+                            if (!(ex instanceof ObjectAlreadyHasException)) {
+                                ex.printStackTrace();
+                            }
+                        }
+                    }
+                }
+            }
+
+            for (String g : service.getPlayerAssignedGroups(u)) {
+                try {
+                    user.setPermission("group." + g.toLowerCase(), true);
+                    LogEntry.build()
+                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                            .acted(user).action("addgroup " + g.toLowerCase())
+                            .build().submit(plugin);
+                } catch (Exception ex) {
+                    if (!(ex instanceof ObjectAlreadyHasException)) {
+                        ex.printStackTrace();
+                    }
+                }
+            }
+
+            user.setPrimaryGroup(service.getPlayerPrimaryGroup(u));
+            try {
+                LogEntry.build()
+                        .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                        .acted(user).action("setprimarygroup " + service.getPlayerPrimaryGroup(u))
+                        .build().submit(plugin);
+            } catch (Exception ex) {
+                ex.printStackTrace();
+            }
+
+            String prefix = service.getPlayerPrefix(u);
+            String suffix = service.getPlayerSuffix(u);
+
+            if (prefix != null && !prefix.equals("")) {
+                prefix = ArgumentChecker.escapeCharacters(prefix);
+                try {
+                    user.setPermission("prefix.100." + prefix, true);
+                    LogEntry.build()
+                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                            .acted(user).action("set prefix.100." + prefix + " true")
+                            .build().submit(plugin);
+                } catch (Exception ex) {
+                    if (!(ex instanceof ObjectAlreadyHasException)) {
+                        ex.printStackTrace();
+                    }
+                }
+            }
+
+            if (suffix != null && !suffix.equals("")) {
+                suffix = ArgumentChecker.escapeCharacters(suffix);
+                try {
+                    user.setPermission("suffix.100." + suffix, true);
+                    LogEntry.build()
+                            .actor(Constants.getConsoleUUID()).actorName(Constants.getConsoleName())
+                            .acted(user).action("set suffix.100." + suffix + " true")
+                            .build().submit(plugin);
+                } catch (Exception ex) {
+                    if (!(ex instanceof ObjectAlreadyHasException)) {
+                        ex.printStackTrace();
+                    }
+                }
+            }
+
+            plugin.getUserManager().cleanup(user);
+            plugin.getDatastore().saveUser(user);
+        }
+
+        log.info("zPermissions Migration: Success! Completed without any errors.");
+        return CommandResult.SUCCESS;
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/misc/ImportCommand.java

@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.commands.misc;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.CommandResult;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SingleMainCommand;
+import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.data.Importer;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.util.List;
+
+public class ImportCommand extends SingleMainCommand {
+    public ImportCommand() {
+        super("Import", "/%s import <file>", 1, Permission.IMPORT);
+    }
+
+    @Override
+    protected CommandResult execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
+        if (args.size() == 0) {
+            sendUsage(sender, label);
+            return CommandResult.INVALID_ARGS;
+        }
+
+        Importer importer = plugin.getImporter();
+
+        File f = new File(plugin.getMainDir(), args.get(0));
+        if (!f.exists()) {
+            Message.IMPORT_LOG_DOESNT_EXIST.send(sender, f.getAbsolutePath());
+            return CommandResult.INVALID_ARGS;
+        }
+
+        if (!Files.isReadable(f.toPath())) {
+            Message.IMPORT_LOG_NOT_READABLE.send(sender, f.getAbsolutePath());
+            return CommandResult.FAILURE;
+        }
+
+        List<String> commands;
+
+        try {
+            commands = Files.readAllLines(f.toPath(), Charset.defaultCharset());
+        } catch (IOException e) {
+            e.printStackTrace();
+            Message.IMPORT_LOG_FAILURE.send(sender);
+            return CommandResult.FAILURE;
+        }
+
+        if (!importer.startRun()) {
+            Message.IMPORT_ALREADY_RUNNING.send(sender);
+            return CommandResult.STATE_ERROR;
+        }
+
+        // Run the importer in its own thread.
+        plugin.doAsync(() -> importer.start(sender, commands));
+        return CommandResult.SUCCESS;
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/misc/InfoCommand.java

@@ -46,7 +46,6 @@ public class InfoCommand extends SingleMainCommand {
                 plugin.getVersion(),
                 plugin.getDatastore().getName(),
                 c.getServer(),
-                c.getDefaultGroupName(),
                 c.getSyncTime(),
                 formatBoolean(c.getIncludeGlobalPerms()),
                 formatBoolean(c.getOnlineMode()),