Add support for MongoDB and H2 database formats

README.md

@@ -8,6 +8,7 @@ A permissions implementation for Bukkit/Spigot, BungeeCord and Sponge.
 ## 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.
@@ -16,8 +17,12 @@ A permissions implementation for Bukkit/Spigot, BungeeCord and Sponge.
 * **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
+* **Easily switch between storage systems** - export a log file from one datastore and import it into another
 * **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.
@@ -25,7 +30,7 @@ A permissions implementation for Bukkit/Spigot, BungeeCord and Sponge.
 * **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)
+* **Support for MySQL, MongoDB, SQLite, H2 & Flatfile (JSON)** - other storage methods coming soon (maybe)
 
 ## Setup
 All configuration options are in the **config.yml/luckperms.conf** file, which is generated automagically when the plugin first starts.
@@ -34,38 +39,89 @@ You can define the settings for per-server permissions, the storage method and c
 
 ## Info
 ### Permission Calculation
-Permissions are calculated based on a priority system as follows.
+#### Permissions are calculated based on a priority system as follows.
 
-* Temporary permissions will override non-temporary permissions.
+* **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.
+* **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.
+* **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.
+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.
+* **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 (provided they're on that server).
+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
+// 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
-final LuckPermsApi api = Bukkit.getServicesManager().getRegistration(LuckPermsApi.class).getProvider();
+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);
@@ -93,7 +149,7 @@ You can add LuckPerms as a Maven dependency by adding the following to your proj
     <dependency>
         <groupId>me.lucko.luckperms</groupId>
         <artifactId>luckperms-api</artifactId>
-        <version>2.0</version>
+        <version>2.3</version>
     </dependency>
 </dependencies>
 ````
@@ -101,7 +157,7 @@ You can add LuckPerms as a Maven dependency by adding the following to your proj
 ## Versioning
 As of version 2.0, LuckPerms roughly follows the standards set out in Semantic Versioning.
 
-The only difference is that 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)
+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.
 
@@ -126,12 +182,14 @@ Additionally, you can use wildcards to grant users access to a selection of comm
 * **All user commands** - luckperms.user.*
 * **All group commands** - luckperms.group.*
 * **All track commands** - luckperms.track.*
+* **All log commands** - luckperms.log.*
 
 ### General
 *  /perms - n/a
 *  /perms sync - luckperms.sync
 *  /perms info - luckperms.info
 *  /perms debug - luckperms.debug
+*  /perms import \<file\> - luckperms.import
 *  /perms creategroup \<group\> - luckperms.creategroup
 *  /perms deletegroup \<group\> - luckperms.deletegroup
 *  /perms listgroups - luckperms.listgroups
@@ -183,5 +241,14 @@ Additionally, you can use wildcards to grant users access to a selection of comm
 *  /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 export \<file\> - luckperms.log.export
+*  /perms log userhistory \<user\> [page] - luckperms.log.userhistory
+*  /perms log grouphistory \<group\> [page] - luckperms.log.grouphistory
+*  /perms log trackhistory \<track\> [page] - luckperms.log.trackhistory
+
 ## License
 See LICENSE.md.

api/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>luckperms</artifactId>
         <groupId>me.lucko.luckperms</groupId>
-        <version>2.0</version>
+        <version>2.4</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
@@ -21,6 +21,19 @@
                     <target>1.8</target>
                 </configuration>
             </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-source-plugin</artifactId>
+                <version>3.0.1</version>
+                <executions>
+                    <execution>
+                        <id>attach-sources</id>
+                        <goals>
+                            <goal>jar-no-fork</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
         </plugins>
     </build>
 </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

@@ -28,7 +28,8 @@ import java.util.UUID;
 
 /**
  * Wrapper interface for the internal Datastore instance
- * The implementations of this interface limit access to the datastore and add parameter checks to further prevent
+ *
+ * <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")
@@ -39,8 +40,11 @@ public interface Datastore {
 
     Async async();
     Sync sync();
+    Future future();
 
     interface Async {
+        void logAction(LogEntry entry, Callback<Boolean> callback);
+        void getLog(Callback<Log> callback);
         void loadOrCreateUser(UUID uuid, String username, Callback<Boolean> callback);
         void loadUser(UUID uuid, Callback<Boolean> callback);
         void saveUser(User user, Callback<Boolean> callback);
@@ -59,6 +63,8 @@ public interface Datastore {
     }
 
     interface Sync {
+        boolean logAction(LogEntry entry);
+        Log getLog();
         boolean loadOrCreateUser(UUID uuid, String username);
         boolean loadUser(UUID uuid);
         boolean saveUser(User user);
@@ -75,4 +81,24 @@ public interface Datastore {
         boolean saveUUIDData(String username, UUID uuid);
         UUID getUUID(String username);
     }
+
+    interface Future {
+        java.util.concurrent.Future<Boolean> logAction(LogEntry entry);
+        java.util.concurrent.Future<Log> getLog();
+        java.util.concurrent.Future<Boolean> loadOrCreateUser(UUID uuid, String username);
+        java.util.concurrent.Future<Boolean> loadUser(UUID uuid);
+        java.util.concurrent.Future<Boolean> saveUser(User user);
+        java.util.concurrent.Future<Boolean> createAndLoadGroup(String name);
+        java.util.concurrent.Future<Boolean> loadGroup(String name);
+        java.util.concurrent.Future<Boolean> loadAllGroups();
+        java.util.concurrent.Future<Boolean> saveGroup(Group group);
+        java.util.concurrent.Future<Boolean> deleteGroup(Group group);
+        java.util.concurrent.Future<Boolean> createAndLoadTrack(String name);
+        java.util.concurrent.Future<Boolean> loadTrack(String name);
+        java.util.concurrent.Future<Boolean> loadAllTracks();
+        java.util.concurrent.Future<Boolean> saveTrack(Track track);
+        java.util.concurrent.Future<Boolean> deleteTrack(Track track);
+        java.util.concurrent.Future<Boolean> saveUUIDData(String username, UUID uuid);
+        java.util.concurrent.Future<UUID> getUUID(String username);
+    }
 }

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

@@ -29,7 +29,8 @@ import java.util.List;
 
 /**
  * Wrapper interface for internal Group instances
- * The implementations of this interface limit access to the Group and add parameter checks to further prevent
+ *
+ * <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")

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

@@ -22,6 +22,7 @@
 
 package me.lucko.luckperms.api;
 
+import me.lucko.luckperms.api.data.DatastoreConfiguration;
 import me.lucko.luckperms.api.data.MySQLConfiguration;
 
 /**
@@ -60,10 +61,33 @@ public interface LPConfiguration {
     boolean getOnlineMode();
 
     /**
-     * @return the database values set in the configuration
+     * @return if LuckPerms is applying wildcard permissions
      */
+    boolean getApplyWildcards();
+
+    /**
+     * @return if LuckPerms is resolving and applying regex permissions
+     */
+    boolean getApplyRegex();
+
+    /**
+     * @return if LuckPerms is expanding shorthand permissions
+     */
+    boolean getApplyShorthand();
+
+    /**
+     * @return the database values set in the configuration
+     * @deprecated use {@link #getDatastoreConfig()}
+     */
+    @SuppressWarnings("deprecation")
+    @Deprecated
     MySQLConfiguration getDatabaseValues();
 
+    /**
+     * @return the values set for data storage in the configuration
+     */
+    DatastoreConfiguration getDatastoreConfig();
+
     /**
      * @return the storage method string from the configuration
      */

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

@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api;
+
+import java.util.SortedMap;
+import java.util.SortedSet;
+import java.util.UUID;
+
+/**
+ * Represents the internal LuckPerms log.
+ * All content is immutable. You can add to the log using the {@link Datastore}, and then request an updated copy.
+ */
+@SuppressWarnings("unused")
+public interface Log {
+
+    /**
+     * @return a {@link SortedSet} of all of the {@link LogEntry} objects in this {@link Log}
+     */
+    SortedSet<LogEntry> getContent();
+
+    SortedSet<LogEntry> getRecent();
+    SortedMap<Integer, LogEntry> getRecent(int pageNo);
+    int getRecentMaxPages();
+
+    SortedSet<LogEntry> getRecent(UUID actor);
+    SortedMap<Integer, LogEntry> getRecent(int pageNo, UUID actor);
+    int getRecentMaxPages(UUID actor);
+
+    SortedSet<LogEntry> getUserHistory(UUID uuid);
+    SortedMap<Integer, LogEntry> getUserHistory(int pageNo, UUID uuid);
+    int getUserHistoryMaxPages(UUID uuid);
+
+    SortedSet<LogEntry> getGroupHistory(String name);
+    SortedMap<Integer, LogEntry> getGroupHistory(int pageNo, String name);
+    int getGroupHistoryMaxPages(String name);
+
+    SortedSet<LogEntry> getTrackHistory(String name);
+    SortedMap<Integer, LogEntry> getTrackHistory(int pageNo, String name);
+    int getTrackHistoryMaxPages(String name);
+
+    SortedSet<LogEntry> getSearch(String query);
+    SortedMap<Integer, LogEntry> getSearch(int pageNo, String query);
+    int getSearchMaxPages(String query);
+}

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

@@ -0,0 +1,315 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api;
+
+import java.util.UUID;
+
+public class LogEntry implements Comparable<LogEntry> {
+    public static LogEntryBuilder builder() {
+        return new LogEntryBuilder();
+    }
+
+    private static final String FORMAT = "&8(&e%s&8) [&a%s&8] (&b%s&8) &7--> &f%s";
+
+    private long timestamp;
+    private UUID actor;
+    private String actorName;
+    private char type;
+    private UUID acted;
+    private String actedName;
+    private String action;
+
+    public LogEntry(long timestamp, UUID actor, String actorName, char type, UUID acted, String actedName, String action) {
+        if (actor == null) {
+            throw new NullPointerException("actor");
+        }
+        if (actorName == null) {
+            throw new NullPointerException("actorName");
+        }
+        if (actedName == null) {
+            throw new NullPointerException("actedName");
+        }
+        if (action == null) {
+            throw new NullPointerException("action");
+        }
+
+        this.timestamp = timestamp;
+        this.actor = actor;
+        this.actorName = actorName;
+        this.type = type;
+        this.acted = acted;
+        this.actedName = actedName;
+        this.action = action;
+    }
+
+    protected LogEntry() {
+        this.timestamp = 0L;
+        this.actor = null;
+        this.actorName = null;
+        this.type = Character.MIN_VALUE;
+        this.acted = null;
+        this.actedName = null;
+        this.action = null;
+    }
+
+    @Override
+    public int compareTo(LogEntry o) {
+        return equals(o) ? 0 : (Long.compare(timestamp, o.getTimestamp()) == 0 ? 1 : Long.compare(timestamp, o.getTimestamp()));
+    }
+
+    public boolean matchesSearch(String query) {
+        query = query.toLowerCase();
+        return actorName.toLowerCase().contains(query) || actedName.toLowerCase().contains(query)
+                || action.toLowerCase().contains(query);
+    }
+
+    public String getFormatted() {
+        return String.format(FORMAT,
+                actorName,
+                Character.toString(type),
+                actedName,
+                action
+        );
+    }
+
+    public long getTimestamp() {
+        return timestamp;
+    }
+
+    public UUID getActor() {
+        return actor;
+    }
+
+    public String getActorName() {
+        return actorName;
+    }
+
+    public char getType() {
+        return type;
+    }
+
+    public UUID getActed() {
+        return acted;
+    }
+
+    public String getActedName() {
+        return actedName;
+    }
+
+    public String getAction() {
+        return action;
+    }
+
+    void setTimestamp(long timestamp) {
+        this.timestamp = timestamp;
+    }
+
+    void setActor(UUID actor) {
+        this.actor = actor;
+    }
+
+    void setActorName(String actorName) {
+        this.actorName = actorName;
+    }
+
+    void setType(char type) {
+        this.type = type;
+    }
+
+    void setActed(UUID acted) {
+        this.acted = acted;
+    }
+
+    void setActedName(String actedName) {
+        this.actedName = actedName;
+    }
+
+    void setAction(String action) {
+        this.action = action;
+    }
+
+    @Override
+    public String toString() {
+        return "LogEntry(timestamp=" + this.getTimestamp() + ", actor=" + this.getActor() + ", actorName=" +
+                this.getActorName() + ", type=" + this.getType() + ", acted=" + this.getActed() + ", actedName=" +
+                this.getActedName() + ", action=" + this.getAction() + ")";
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o == this) return true;
+        if (!(o instanceof LogEntry)) return false;
+        final LogEntry other = (LogEntry) o;
+        if (this.getTimestamp() != other.getTimestamp()) return false;
+        final Object this$actor = this.getActor();
+        final Object other$actor = other.getActor();
+        if (this$actor == null ? other$actor != null : !this$actor.equals(other$actor)) return false;
+        final Object this$actorName = this.getActorName();
+        final Object other$actorName = other.getActorName();
+        if (this$actorName == null ? other$actorName != null : !this$actorName.equals(other$actorName)) return false;
+        if (this.getType() != other.getType()) return false;
+        final Object this$acted = this.getActed();
+        final Object other$acted = other.getActed();
+        if (this$acted == null ? other$acted != null : !this$acted.equals(other$acted)) return false;
+        final Object this$actedName = this.getActedName();
+        final Object other$actedName = other.getActedName();
+        if (this$actedName == null ? other$actedName != null : !this$actedName.equals(other$actedName)) return false;
+        final Object this$action = this.getAction();
+        final Object other$action = other.getAction();
+        return this$action == null ? other$action == null : this$action.equals(other$action);
+    }
+
+    @Override
+    public int hashCode() {
+        final int PRIME = 59;
+        int result = 1;
+        final long $timestamp = this.getTimestamp();
+        result = result * PRIME + (int) ($timestamp >>> 32 ^ $timestamp);
+        final Object $actor = this.getActor();
+        result = result * PRIME + ($actor == null ? 43 : $actor.hashCode());
+        final Object $actorName = this.getActorName();
+        result = result * PRIME + ($actorName == null ? 43 : $actorName.hashCode());
+        result = result * PRIME + this.getType();
+        final Object $acted = this.getActed();
+        result = result * PRIME + ($acted == null ? 43 : $acted.hashCode());
+        final Object $actedName = this.getActedName();
+        result = result * PRIME + ($actedName == null ? 43 : $actedName.hashCode());
+        final Object $action = this.getAction();
+        result = result * PRIME + ($action == null ? 43 : $action.hashCode());
+        return result;
+    }
+
+    public static class LogEntryBuilder extends AbstractLogEntryBuilder<LogEntry, LogEntry.LogEntryBuilder> {
+
+        @Override
+        protected LogEntry createObj() {
+            return new LogEntry();
+        }
+
+        @Override
+        protected LogEntryBuilder getThis() {
+            return this;
+        }
+    }
+
+    public static abstract class AbstractLogEntryBuilder<T extends LogEntry, B extends AbstractLogEntryBuilder<T, B>> {
+        private T obj;
+        private B thisObj;
+
+        public AbstractLogEntryBuilder() {
+            obj = createObj();
+            thisObj = getThis();
+        }
+
+        protected abstract T createObj();
+        protected abstract B getThis();
+
+        public long getTimestamp() {
+            return obj.getTimestamp();
+        }
+
+        public UUID getActor() {
+            return obj.getActor();
+        }
+
+        public String getActorName() {
+            return obj.getActorName();
+        }
+
+        public char getType() {
+            return obj.getType();
+        }
+
+        public UUID getActed() {
+            return obj.getActed();
+        }
+
+        public String getActedName() {
+            return obj.getActedName();
+        }
+
+        public String getAction() {
+            return obj.getAction();
+        }
+
+        public B timestamp(long timestamp) {
+            obj.setTimestamp(timestamp);
+            return thisObj;
+        }
+
+        public B actor(UUID actor) {
+            obj.setActor(actor);
+            return thisObj;
+        }
+
+        public B actorName(String actorName) {
+            obj.setActorName(actorName);
+            return thisObj;
+        }
+
+        public B type(char type) {
+            obj.setType(type);
+            return thisObj;
+        }
+
+        public B acted(UUID acted) {
+            obj.setActed(acted);
+            return thisObj;
+        }
+
+        public B actedName(String actedName) {
+            obj.setActedName(actedName);
+            return thisObj;
+        }
+
+        public B action(String action) {
+            obj.setAction(action);
+            return thisObj;
+        }
+
+        public T build() {
+            if (getActor() == null) {
+                throw new NullPointerException("actor");
+            }
+            if (getActorName() == null) {
+                throw new NullPointerException("actorName");
+            }
+            if (getActedName() == null) {
+                throw new NullPointerException("actedName");
+            }
+            if (getAction() == null) {
+                throw new NullPointerException("action");
+            }
+
+            return obj;
+        }
+
+        @Override
+        public String toString() {
+            return "LogEntry.LogEntryBuilder(timestamp=" + getTimestamp() + ", actor=" + getActor() + ", actorName=" +
+                    getActorName() + ", type=" + getType() + ", acted=" + getActed() + ", actedName=" + getActedName() +
+                    ", action=" + getAction() + ")";
+        }
+    }
+
+}

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

@@ -24,7 +24,8 @@ package me.lucko.luckperms.api;
 
 /**
  * A wrapper class for platform logger instances.
- * Bukkit/Bungee both use java.util.logging, and Sponge uses org.slf4j. This class wraps those classes so the commons
+ *
+ * <p> Bukkit/Bungee both use java.util.logging, and Sponge uses org.slf4j. This class wraps those classes so the commons
  * module can access a logger.
  */
 public interface Logger {

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

@@ -23,6 +23,7 @@
 package me.lucko.luckperms.api;
 
 import java.util.Optional;
+import java.util.Set;
 import java.util.UUID;
 
 /**
@@ -82,7 +83,7 @@ public interface LuckPermsApi {
     /**
      * Gets a wrapped user object from the user storage
      * @param name the username of the user to get
-     * @return a a {@link User} object, if one matching the uuid is loaded, or null if not
+     * @return a {@link User} object, if one matching the uuid is loaded, or null if not
      */
     User getUser(String name);
 
@@ -93,6 +94,12 @@ public interface LuckPermsApi {
      */
     Optional<User> getUserSafe(String name);
 
+    /**
+     * Gets a set of all loaded users.
+     * @return a {@link Set} of {@link User} objects
+     */
+    Set<User> getUsers();
+
     /**
      * Check if a user is loaded in memory
      * @param uuid the uuid to check for
@@ -114,6 +121,12 @@ public interface LuckPermsApi {
      */
     Optional<Group> getGroupSafe(String name);
 
+    /**
+     * Gets a set of all loaded groups.
+     * @return a {@link Set} of {@link Group} objects
+     */
+    Set<Group> getGroups();
+
     /**
      * Check if a group is loaded in memory
      * @param name the name to check for
@@ -135,6 +148,12 @@ public interface LuckPermsApi {
      */
     Optional<Track> getTrackSafe(String name);
 
+    /**
+     * Gets a set of all loaded tracks.
+     * @return a {@link Set} of {@link Track} objects
+     */
+    Set<Track> getTracks();
+
     /**
      * Check if a track is loaded in memory
      * @param name the name to check for

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

@@ -30,7 +30,8 @@ import java.util.Map;
 
 /**
  * Wrapper interface for internal PermissionHolder (user/group) instances
- * The implementations of this interface limit access to the object and add parameter checks to further prevent
+ *
+ * <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")
@@ -262,6 +263,16 @@ public interface PermissionHolder {
      */
     void unsetPermission(String node, String server, String world, boolean temporary) throws ObjectLacksException;
 
+    /**
+     * Gets the permissions and inherited permissions that apply to a specific server
+     * @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
+     */
+    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
      * @param server The server to get nodes for
@@ -273,8 +284,17 @@ public interface PermissionHolder {
 
     /**
      * Gets the permissions and inherited permissions that apply to a specific server
-     * @param server The server to get nodes for (can be null)
-     * @param excludedGroups Groups that shouldn't be inherited, can be null (to prevent circular inheritance issues)
+     * @param server The server to get nodes for
+     * @param excludedGroups Groups that shouldn't be inherited (to prevent circular inheritance issues)
+     * @param possibleNodes A list of possible permission nodes for wildcard permission handling
+     * @return a {@link Map} of the permissions
+     */
+    Map<String, Boolean> getLocalPermissions(String server, List<String> excludedGroups, List<String> possibleNodes);
+
+    /**
+     * Gets the permissions and inherited permissions that apply to a specific server
+     * @param server The server to get nodes for
+     * @param excludedGroups Groups that shouldn't be inherited (to prevent circular inheritance issues)
      * @return a {@link Map} of the permissions
      */
     Map<String, Boolean> getLocalPermissions(String server, List<String> excludedGroups);

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

@@ -29,7 +29,8 @@ import java.util.List;
 
 /**
  * Wrapper interface for internal Track instances
- * The implementations of this interface limit access to the Track and add parameter checks to further prevent
+ *
+ * <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")

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

@@ -30,7 +30,8 @@ import java.util.UUID;
 
 /**
  * Wrapper interface for internal User instances
- * The implementations of this interface limit access to the User and add parameter checks to further prevent
+ *
+ * <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")

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

@@ -30,10 +30,10 @@ import java.util.UUID;
  * they first join the server, but this UUID will then not be consistent across the network. LuckPerms will instead check
  * the datastore cache, to get a UUID for a user that is consistent across an entire network.
  *
- * If you want to get a user object from the datastore using the api on a server in offline mode, you will need to use this cache,
+ * <p> If you want to get a user object from the datastore using the api on a server in offline mode, you will need to use this cache,
  * OR use Datastore#getUUID, for users that are not online.
  *
- * WARNING: THIS IS ONLY EFFECTIVE FOR ONLINE PLAYERS. USE THE DATASTORE METHODS FOR OFFLINE PLAYERS.
+ * <p> WARNING: THIS IS ONLY EFFECTIVE FOR ONLINE PLAYERS. USE THE DATASTORE METHODS FOR OFFLINE PLAYERS.
  */
 public interface UuidCache {
 

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

@@ -22,8 +22,28 @@
 
 package me.lucko.luckperms.api.data;
 
+import java.util.function.Consumer;
+
 public interface Callback<T> {
 
     void onComplete(T t);
 
+    static <T> Callback<T> empty() {
+        return t -> {};
+    }
+
+    static <T> Callback<T> of(Runnable runnable) {
+        if (runnable == null) {
+            throw new NullPointerException("runnable");
+        }
+        return t -> runnable.run();
+    }
+
+    static <T> Callback<T> of(Consumer<T> consumer) {
+        if (consumer == null) {
+            throw new NullPointerException("consumer");
+        }
+        return consumer::accept;
+    }
+
 }

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

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

bukkit/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>luckperms</artifactId>
         <groupId>me.lucko.luckperms</groupId>
-        <version>2.0</version>
+        <version>2.4</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
@@ -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/BukkitCommand.java

@@ -22,8 +22,8 @@
 
 package me.lucko.luckperms;
 
+import me.lucko.luckperms.api.data.Callback;
 import me.lucko.luckperms.commands.CommandManager;
-import me.lucko.luckperms.commands.SenderFactory;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
@@ -33,33 +33,19 @@ import java.util.Arrays;
 import java.util.List;
 
 class BukkitCommand extends CommandManager implements CommandExecutor, TabExecutor {
-    private static final Factory FACTORY = new Factory();
-
     BukkitCommand(LuckPermsPlugin plugin) {
         super(plugin);
     }
 
     @Override
     public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        return onCommand(FACTORY.wrap(sender), label, Arrays.asList(args));
+        onCommand(BukkitSenderFactory.get().wrap(sender), label, Arrays.asList(args), Callback.empty());
+        return true;
     }
 
 
     @Override
     public List<String> onTabComplete(CommandSender sender, Command command, String label, String[] args) {
-        return onTabComplete(FACTORY.wrap(sender), Arrays.asList(args));
-    }
-
-    private static class Factory extends SenderFactory<CommandSender> {
-
-        @Override
-        protected void sendMessage(CommandSender sender, String s) {
-            sender.sendMessage(s);
-        }
-
-        @Override
-        protected boolean hasPermission(CommandSender sender, String node) {
-            return sender.hasPermission(node);
-        }
+        return onTabComplete(BukkitSenderFactory.get().wrap(sender), Arrays.asList(args));
     }
 }

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

@@ -22,7 +22,7 @@
 
 package me.lucko.luckperms;
 
-import me.lucko.luckperms.utils.LPConfiguration;
+import me.lucko.luckperms.core.LPConfiguration;
 import org.bukkit.configuration.InvalidConfigurationException;
 import org.bukkit.configuration.file.YamlConfiguration;
 

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

@@ -53,7 +53,7 @@ class BukkitListener extends AbstractListener implements Listener {
     @EventHandler
     public void onPlayerLogin(PlayerLoginEvent e) {
         final Player player = e.getPlayer();
-        final User user = plugin.getUserManager().getUser(plugin.getUuidCache().getUUID(player.getUniqueId()));
+        final User user = plugin.getUserManager().get(plugin.getUuidCache().getUUID(player.getUniqueId()));
 
         if (user == null) {
             e.disallow(PlayerLoginEvent.Result.KICK_OTHER, Message.LOADING_ERROR.toString());

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

@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms;
+
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+import me.lucko.luckperms.commands.SenderFactory;
+import me.lucko.luckperms.constants.Constants;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.UUID;
+
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+public class BukkitSenderFactory extends SenderFactory<CommandSender> {
+    private static BukkitSenderFactory instance = null;
+    public static BukkitSenderFactory get() {
+        if (instance == null){
+            instance = new BukkitSenderFactory();
+        }
+        return instance;
+    }
+
+    @Override
+    protected String getName(CommandSender sender) {
+        if (sender instanceof Player) {
+            return sender.getName();
+        }
+        return Constants.getConsoleName();
+    }
+
+    @Override
+    protected UUID getUuid(CommandSender sender) {
+        if (sender instanceof Player) {
+            return ((Player) sender).getUniqueId();
+        }
+        return Constants.getConsoleUUID();
+    }
+
+    @Override
+    protected void sendMessage(CommandSender sender, String s) {
+        sender.sendMessage(s);
+    }
+
+    @Override
+    protected boolean hasPermission(CommandSender sender, String node) {
+        return sender.hasPermission(node);
+    }
+}

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

@@ -27,20 +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.Sender;
 import me.lucko.luckperms.constants.Message;
-import me.lucko.luckperms.data.Datastore;
-import me.lucko.luckperms.data.methods.FlatfileDatastore;
-import me.lucko.luckperms.data.methods.MySQLDatastore;
-import me.lucko.luckperms.data.methods.SQLiteDatastore;
+import me.lucko.luckperms.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.UpdateTask;
+import me.lucko.luckperms.storage.Datastore;
+import me.lucko.luckperms.storage.StorageFactory;
 import me.lucko.luckperms.tracks.TrackManager;
 import me.lucko.luckperms.users.BukkitUserManager;
 import me.lucko.luckperms.users.UserManager;
-import me.lucko.luckperms.utils.LPConfiguration;
-import me.lucko.luckperms.utils.LogUtil;
-import me.lucko.luckperms.utils.UuidCache;
-import org.bukkit.Bukkit;
+import me.lucko.luckperms.utils.LogFactory;
 import org.bukkit.command.PluginCommand;
 import org.bukkit.entity.Player;
 import org.bukkit.plugin.PluginManager;
@@ -48,13 +47,12 @@ import org.bukkit.plugin.ServicePriority;
 import org.bukkit.plugin.java.JavaPlugin;
 
 import java.io.File;
-import java.util.Arrays;
-import java.util.List;
-import java.util.UUID;
+import java.util.*;
 import java.util.stream.Collectors;
 
 @Getter
 public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
+    private final Set<UUID> ignoringLogs = new HashSet<>();
     private LPConfiguration configuration;
     private UserManager userManager;
     private GroupManager groupManager;
@@ -62,16 +60,17 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
     private Datastore datastore;
     private UuidCache uuidCache;
     private Logger log;
+    private Importer importer;
 
     @Override
     public void onEnable() {
-        log = LogUtil.wrap(getLogger());
+        log = LogFactory.wrap(getLogger());
 
         getLog().info("Loading configuration...");
         configuration = new BukkitConfig(this);
 
         // register events
-        PluginManager pm = Bukkit.getPluginManager();
+        PluginManager pm = getServer().getPluginManager();
         pm.registerEvents(new BukkitListener(this), this);
 
         // register commands
@@ -82,30 +81,14 @@ 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, "sqlite");
 
         getLog().info("Loading internal permission managers...");
         uuidCache = new UuidCache(getConfiguration().getOnlineMode());
         userManager = new BukkitUserManager(this);
         groupManager = new GroupManager(this);
         trackManager = new TrackManager();
+        importer = new Importer(commandManager);
 
         // Run update task to refresh any online users
         getLog().info("Scheduling Update Task to refresh any online users.");
@@ -121,6 +104,8 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
             getServer().getScheduler().runTaskTimerAsynchronously(this, new UpdateTask(this), ticks, ticks);
         }
 
+        getServer().getScheduler().runTaskTimer(this, BukkitSenderFactory.get(), 1L, 1L);
+
         // Provide vault support
         getLog().info("Attempting to hook into Vault...");
         try {
@@ -155,12 +140,12 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
 
     @Override
     public void doAsync(Runnable r) {
-        Bukkit.getScheduler().runTaskAsynchronously(this, r);
+        getServer().getScheduler().runTaskAsynchronously(this, r);
     }
 
     @Override
     public void doSync(Runnable r) {
-        Bukkit.getScheduler().runTask(this, r);
+        getServer().getScheduler().runTask(this, r);
     }
 
     @Override
@@ -168,6 +153,11 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
         return getDescription().getVersion();
     }
 
+    @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;
@@ -183,6 +173,28 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
         return getServer().getOnlinePlayers().stream().map(Player::getName).collect(Collectors.toList());
     }
 
+    @Override
+    public List<Sender> getSenders() {
+        return getServer().getOnlinePlayers().stream().map(p -> BukkitSenderFactory.get().wrap(p)).collect(Collectors.toList());
+    }
+
+    @Override
+    public Sender getConsoleSender() {
+        return BukkitSenderFactory.get().wrap(getServer().getConsoleSender());
+    }
+
+    @Override
+    public List<String> getPossiblePermissions() {
+        final List<String> perms = new ArrayList<>();
+
+        getServer().getPluginManager().getPermissions().forEach(p -> {
+            perms.add(p.getName());
+            p.getChildren().keySet().forEach(perms::add);
+        });
+
+        return perms;
+    }
+
     @Override
     public void runUpdateTask() {
         getServer().getScheduler().runTaskAsynchronously(this, new UpdateTask(this));

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

@@ -25,11 +25,12 @@ package me.lucko.luckperms.api.vault;
 import lombok.NonNull;
 import lombok.Setter;
 import me.lucko.luckperms.LPBukkitPlugin;
+import me.lucko.luckperms.api.data.Callback;
+import me.lucko.luckperms.core.PermissionHolder;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
 import me.lucko.luckperms.groups.Group;
 import me.lucko.luckperms.users.User;
-import me.lucko.luckperms.utils.PermissionHolder;
 import net.milkbowl.vault.permission.Permission;
 
 class VaultPermissionHook extends Permission {
@@ -95,54 +96,54 @@ class VaultPermissionHook extends Permission {
     private void objectSave(PermissionHolder t) {
         if (t instanceof User) {
             ((User) t).refreshPermissions();
-            plugin.getDatastore().saveUser(((User) t), aBoolean -> {});
+            plugin.getDatastore().saveUser(((User) t), Callback.empty());
         }
         if (t instanceof Group) {
-            plugin.getDatastore().saveGroup(((Group) t), aBoolean -> plugin.runUpdateTask());
+            plugin.getDatastore().saveGroup(((Group) t), c -> plugin.runUpdateTask());
         }
     }
 
     @Override
     public boolean playerHas(String world, @NonNull String player, @NonNull String permission) {
-        return objectHas(world, plugin.getUserManager().getUser(player), permission);
+        return objectHas(world, plugin.getUserManager().get(player), permission);
     }
 
     @Override
     public boolean playerAdd(String world, @NonNull String player, @NonNull String permission) {
-        final User user = plugin.getUserManager().getUser(player);
+        final User user = plugin.getUserManager().get(player);
         return objectAdd(world, user, permission);
     }
 
     @Override
     public boolean playerRemove(String world, @NonNull String player, @NonNull String permission) {
-        final User user = plugin.getUserManager().getUser(player);
+        final User user = plugin.getUserManager().get(player);
         return objectRemove(world, user, permission);
     }
 
     @Override
     public boolean groupHas(String world, @NonNull String groupName, @NonNull String permission) {
-        final Group group = plugin.getGroupManager().getGroup(groupName);
+        final Group group = plugin.getGroupManager().get(groupName);
         return objectHas(world, group, permission);
     }
 
     @Override
     public boolean groupAdd(String world, @NonNull String groupName, @NonNull String permission) {
-        final Group group = plugin.getGroupManager().getGroup(groupName);
+        final Group group = plugin.getGroupManager().get(groupName);
         return objectAdd(world, group, permission);
     }
 
     @Override
     public boolean groupRemove(String world, @NonNull String groupName, @NonNull String permission) {
-        final Group group = plugin.getGroupManager().getGroup(groupName);
+        final Group group = plugin.getGroupManager().get(groupName);
         return objectRemove(world, group, permission);
     }
 
     @Override
     public boolean playerInGroup(String world, @NonNull String player, @NonNull String group) {
-        final User user = plugin.getUserManager().getUser(player);
+        final User user = plugin.getUserManager().get(player);
         if (user == null) return false;
 
-        final Group group1 = plugin.getGroupManager().getGroup(group);
+        final Group group1 = plugin.getGroupManager().get(group);
         if (group1 == null) return false;
 
         if (world != null && !world.equals("")) {
@@ -154,10 +155,10 @@ class VaultPermissionHook extends Permission {
 
     @Override
     public boolean playerAddGroup(String world, @NonNull String player, @NonNull String groupName) {
-        final User user = plugin.getUserManager().getUser(player);
+        final User user = plugin.getUserManager().get(player);
         if (user == null) return false;
 
-        final Group group = plugin.getGroupManager().getGroup(groupName);
+        final Group group = plugin.getGroupManager().get(groupName);
         if (group == null) return false;
 
         try {
@@ -173,10 +174,10 @@ class VaultPermissionHook extends Permission {
 
     @Override
     public boolean playerRemoveGroup(String world, @NonNull String player, @NonNull String groupName) {
-        final User user = plugin.getUserManager().getUser(player);
+        final User user = plugin.getUserManager().get(player);
         if (user == null) return false;
 
-        final Group group = plugin.getGroupManager().getGroup(groupName);
+        final Group group = plugin.getGroupManager().get(groupName);
         if (group == null) return false;
 
         try {
@@ -192,7 +193,7 @@ class VaultPermissionHook extends Permission {
 
     @Override
     public String[] getPlayerGroups(String world, @NonNull String player) {
-        final User user = plugin.getUserManager().getUser(player);
+        final User user = plugin.getUserManager().get(player);
         return (user == null) ? new String[0] :
                 world != null && !world.equals("") ? user.getLocalGroups("global", world).toArray(new String[0]) :
                         user.getGroupNames().toArray(new String[0]);
@@ -200,13 +201,13 @@ class VaultPermissionHook extends Permission {
 
     @Override
     public String getPrimaryGroup(String world, @NonNull String player) {
-        final User user = plugin.getUserManager().getUser(player);
+        final User user = plugin.getUserManager().get(player);
         return (user == null) ? null : user.getPrimaryGroup();
     }
 
     @Override
     public String[] getGroups() {
-        return plugin.getGroupManager().getGroups().keySet().toArray(new String[0]);
+        return plugin.getGroupManager().getAll().keySet().toArray(new String[0]);
     }
 
     @Override

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

@@ -28,10 +28,24 @@ import me.lucko.luckperms.LPBukkitPlugin;
 import org.bukkit.entity.Player;
 import org.bukkit.permissions.PermissionAttachment;
 
+import java.lang.reflect.Field;
 import java.util.Map;
 import java.util.UUID;
 
 public class BukkitUser extends User {
+    private static Field permissionsField = null;
+    private static Field getPermissionsField() {
+        if (permissionsField == null) {
+            try {
+                permissionsField = PermissionAttachment.class.getDeclaredField("permissions");
+                permissionsField.setAccessible(true);
+            } catch (SecurityException | NoSuchFieldException e) {
+                e.printStackTrace();
+            }
+        }
+        return permissionsField;
+    }
+
 
     private final LPBukkitPlugin plugin;
 
@@ -49,6 +63,7 @@ public class BukkitUser extends User {
         this.plugin = plugin;
     }
 
+    @SuppressWarnings("unchecked")
     @Override
     public void refreshPermissions() {
         plugin.doSync(() -> {
@@ -60,12 +75,35 @@ public class BukkitUser extends User {
                 setAttachment(player.addAttachment(plugin));
             }
 
-            // Clear existing permissions
-            attachment.getPermissions().keySet().forEach(p -> attachment.setPermission(p, false));
+            // Calculate the permissions that should be applied
+            Map<String, Boolean> toApply = getLocalPermissions(getPlugin().getConfiguration().getServer(), player.getWorld().getName(), null);
 
-            // Re-add all defined permissions for the user
-            Map<String, Boolean> local = getLocalPermissions(getPlugin().getConfiguration().getServer(), player.getWorld().getName(), null);
-            local.entrySet().forEach(e -> attachment.setPermission(e.getKey(), e.getValue()));
+            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;
+                    }
+                }
+
+                if (!different) return;
+
+                // Faster than recalculating permissions after each PermissionAttachment#setPermission
+                existing.clear();
+                existing.putAll(toApply);
+                attachment.getPermissible().recalculatePermissions();
+
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
         });
     }
 }

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

@@ -38,7 +38,7 @@ public class BukkitUserManager extends UserManager {
     }
 
     @Override
-    public void unloadUser(User user) {
+    public void unload(User user) {
         if (user != null) {
 
             if (user instanceof BukkitUser) {
@@ -54,24 +54,24 @@ public class BukkitUserManager extends UserManager {
                 }
             }
 
-            getUsers().remove(user.getUuid());
+            getAll().remove(user.getUuid());
         }
     }
 
     @Override
-    public void cleanupUser(User user) {
+    public void cleanup(User user) {
         if (plugin.getServer().getPlayer(plugin.getUuidCache().getExternalUUID(user.getUuid())) == null) {
-            unloadUser(user);
+            unload(user);
         }
     }
 
     @Override
-    public User makeUser(UUID uuid) {
+    public User make(UUID uuid) {
         return new BukkitUser(uuid, plugin);
     }
 
     @Override
-    public User makeUser(UUID uuid, String username) {
+    public User make(UUID uuid, String username) {
         return new BukkitUser(uuid, username, plugin);
     }
 

bukkit/src/main/resources/config.yml

@@ -1,4 +1,9 @@
-# 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
@@ -22,14 +27,32 @@ include-global: true
 #    In this case, set online-mode to true no matter what is set in server.properties. (we can just fallback to the servers uuid cache)
 online-mode: true
 
-# Which storage method the plugin should use.
-# Currently supported: mysql, sqlite, flatfile
-# Fill out connection info below if you're using MySQL
-storage-method: sqlite
+# If the plugin should apply wildcard permissions.
+# If set to true, LuckPerms will detect wildcard permissions, and resolve & apply all registered permissions matching
+# the wildcard. This will only work for plugins that define all of their permissions to the server.
+apply-wildcards: true
 
-sql:
+# If the plugin should parse regex permissions.
+# If set to true, LuckPerms will detect regex permissions, marked with "r=" at the start of the node, and resolve &
+# apply all registered permissions matching the regex. This will only work for plugins that define all of their
+# permissions to the server.
+apply-regex: true
+
+# If the plugin should complete and apply shorthand permissions.
+# If set to true, LuckPerms will detect and expand shorthand node patterns.
+apply-shorthand: true
+
+# Which storage method the plugin should use.
+# Currently supported: mysql, sqlite, h2, flatfile, mongodb
+# Fill out connection info below if you're using MySQL or MongoDB
+storage-method: h2
+
+data:
   address: localhost:3306
   database: minecraft
   username: root
   password: ''
+
+  # Set to -1 to disable. If this is the only instance accessing the datastore, you can disable syncing.
+  # e.g. if you're using sqlite or flatfile, this can be set to -1 to save resources.
   sync-minutes: 3

bukkit/src/main/resources/plugin.yml

@@ -7,4 +7,120 @@ description: A permissions plugin
 commands:
   luckperms:
     description: Manage permissions
-    aliases: [perms, permissions, lp, p, perm]
+    aliases: [perms, permissions, lp, p, perm]
+permissions:
+  luckperms.*:
+    description: Gives access to all LuckPerms commands
+    children:
+      luckperms.sync: true
+      luckperms.info: true
+      luckperms.debug: true
+      luckperms.import: true
+      luckperms.creategroup: true
+      luckperms.deletegroup: true
+      luckperms.listgroups: true
+      luckperms.createtrack: true
+      luckperms.deletetrack: true
+      luckperms.listtracks: true
+      luckperms.user.info: true
+      luckperms.user.getuuid: true
+      luckperms.user.listnodes: true
+      luckperms.user.haspermission: true
+      luckperms.user.inheritspermission: true
+      luckperms.user.setpermission: true
+      luckperms.user.unsetpermission: true
+      luckperms.user.addgroup: true
+      luckperms.user.removegroup: true
+      luckperms.user.settemppermission: true
+      luckperms.user.unsettemppermission: true
+      luckperms.user.addtempgroup: true
+      luckperms.user.removetempgroup: true
+      luckperms.user.setprimarygroup: true
+      luckperms.user.showtracks: true
+      luckperms.user.promote: true
+      luckperms.user.demote: true
+      luckperms.user.showpos: true
+      luckperms.user.clear: true
+      luckperms.group.info: true
+      luckperms.group.listnodes: true
+      luckperms.group.haspermission: true
+      luckperms.group.inheritspermission: true
+      luckperms.group.setpermission: true
+      luckperms.group.unsetpermission: true
+      luckperms.group.setinherit: true
+      luckperms.group.unsetinherit: true
+      luckperms.group.settemppermission: true
+      luckperms.group.unsettemppermission: true
+      luckperms.group.settempinherit: true
+      luckperms.group.unsettempinherit: true
+      luckperms.group.showtracks: true
+      luckperms.group.clear: true
+      luckperms.track.info: true
+      luckperms.track.append: true
+      luckperms.track.insert: true
+      luckperms.track.remove: true
+      luckperms.track.clear: true
+      luckperms.log.export: true
+      luckperms.log.userhistory: true
+      luckperms.log.grouphistory: true
+      luckperms.log.trackhistory: true
+      luckperms.log.notify: true
+      luckperms.log.recent: true
+      luckperms.log.search: true
+  luckperms.user.*:
+    description: Gives access to all LuckPerms user commands
+    children:
+      luckperms.user.info: true
+      luckperms.user.getuuid: true
+      luckperms.user.listnodes: true
+      luckperms.user.haspermission: true
+      luckperms.user.inheritspermission: true
+      luckperms.user.setpermission: true
+      luckperms.user.unsetpermission: true
+      luckperms.user.addgroup: true
+      luckperms.user.removegroup: true
+      luckperms.user.settemppermission: true
+      luckperms.user.unsettemppermission: true
+      luckperms.user.addtempgroup: true
+      luckperms.user.removetempgroup: true
+      luckperms.user.setprimarygroup: true
+      luckperms.user.showtracks: true
+      luckperms.user.promote: true
+      luckperms.user.demote: true
+      luckperms.user.showpos: true
+      luckperms.user.clear: true
+  luckperms.group.*:
+    description: Gives access to all LuckPerms group commands
+    children:
+      luckperms.group.info: true
+      luckperms.group.listnodes: true
+      luckperms.group.haspermission: true
+      luckperms.group.inheritspermission: true
+      luckperms.group.setpermission: true
+      luckperms.group.unsetpermission: true
+      luckperms.group.setinherit: true
+      luckperms.group.unsetinherit: true
+      luckperms.group.settemppermission: true
+      luckperms.group.unsettemppermission: true
+      luckperms.group.settempinherit: true
+      luckperms.group.unsettempinherit: true
+      luckperms.group.showtracks: true
+      luckperms.group.clear: true
+  luckperms.track.*:
+    description: Gives access to all LuckPerms track commands
+    children:
+      luckperms.track.info: true
+      luckperms.track.append: true
+      luckperms.track.insert: true
+      luckperms.track.remove: true
+      luckperms.track.clear: true
+  luckperms.log.*:
+    description: Gives access to all LuckPerms log commands
+    children:
+      luckperms.log.export: true
+      luckperms.log.userhistory: true
+      luckperms.log.grouphistory: true
+      luckperms.log.trackhistory: true
+      luckperms.log.notify: true
+      luckperms.log.recent: true
+      luckperms.log.search: true

bungee/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>luckperms</artifactId>
         <groupId>me.lucko.luckperms</groupId>
-        <version>2.0</version>
+        <version>2.4</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
@@ -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/BungeeCommand.java

@@ -22,44 +22,29 @@
 
 package me.lucko.luckperms;
 
+import me.lucko.luckperms.api.data.Callback;
 import me.lucko.luckperms.commands.CommandManager;
-import me.lucko.luckperms.commands.SenderFactory;
 import net.md_5.bungee.api.CommandSender;
-import net.md_5.bungee.api.chat.TextComponent;
 import net.md_5.bungee.api.plugin.Command;
 import net.md_5.bungee.api.plugin.TabExecutor;
 
 import java.util.Arrays;
 
 class BungeeCommand extends Command implements TabExecutor {
-    private static final Factory FACTORY = new Factory();
     private final CommandManager manager;
 
-    public BungeeCommand(CommandManager manager) {
+    BungeeCommand(CommandManager manager) {
         super("luckpermsbungee", null, "bperms", "lpb", "bpermissions", "bp", "bperm");
         this.manager = manager;
     }
 
     @Override
     public void execute(CommandSender sender, String[] args) {
-        manager.onCommand(FACTORY.wrap(sender), "bperms", Arrays.asList(args));
+        manager.onCommand(BungeeSenderFactory.get().wrap(sender), "bperms", Arrays.asList(args), Callback.empty());
     }
 
     @Override
     public Iterable<String> onTabComplete(CommandSender sender, String[] args) {
-        return manager.onTabComplete(FACTORY.wrap(sender), Arrays.asList(args));
-    }
-
-    private static class Factory extends SenderFactory<CommandSender> {
-
-        @Override
-        protected void sendMessage(CommandSender sender, String s) {
-            sender.sendMessage(new TextComponent(s));
-        }
-
-        @Override
-        protected boolean hasPermission(CommandSender sender, String node) {
-            return sender.hasPermission(node);
-        }
+        return manager.onTabComplete(BungeeSenderFactory.get().wrap(sender), Arrays.asList(args));
     }
 }

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

@@ -22,7 +22,7 @@
 
 package me.lucko.luckperms;
 
-import me.lucko.luckperms.utils.LPConfiguration;
+import me.lucko.luckperms.core.LPConfiguration;
 import net.md_5.bungee.config.Configuration;
 import net.md_5.bungee.config.ConfigurationProvider;
 import net.md_5.bungee.config.YamlConfiguration;

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

@@ -23,24 +23,24 @@
 package me.lucko.luckperms;
 
 import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.core.UuidCache;
 import me.lucko.luckperms.users.User;
 import me.lucko.luckperms.utils.AbstractListener;
-import me.lucko.luckperms.utils.UuidCache;
 import net.md_5.bungee.api.chat.TextComponent;
 import net.md_5.bungee.api.connection.PendingConnection;
 import net.md_5.bungee.api.connection.ProxiedPlayer;
-import net.md_5.bungee.api.event.LoginEvent;
-import net.md_5.bungee.api.event.PlayerDisconnectEvent;
-import net.md_5.bungee.api.event.PostLoginEvent;
-import net.md_5.bungee.api.event.ServerSwitchEvent;
+import net.md_5.bungee.api.event.*;
 import net.md_5.bungee.api.plugin.Listener;
 import net.md_5.bungee.event.EventHandler;
 
 import java.lang.ref.WeakReference;
+import java.util.Collections;
+import java.util.Map;
 import java.util.UUID;
 import java.util.concurrent.TimeUnit;
 
-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;
 
@@ -49,6 +49,27 @@ class BungeeListener extends AbstractListener implements Listener {
         this.plugin = plugin;
     }
 
+    @EventHandler
+    public void onPlayerPermissionCheck(PermissionCheckEvent e) {
+        if (!(e.getSender() instanceof ProxiedPlayer)) {
+            return;
+        }
+
+        final ProxiedPlayer player = ((ProxiedPlayer) e.getSender());
+        final User user = plugin.getUserManager().get(plugin.getUuidCache().getUUID(player.getUniqueId()));
+        if (user == null) return;
+
+
+        final String server = player.getServer() == null ? null : (player.getServer().getInfo() == null ? null : player.getServer().getInfo().getName());
+        Map<String, Boolean> local = user.getLocalPermissions(plugin.getConfiguration().getServer(), server, null, Collections.singletonList(e.getPermission()));
+        for (Map.Entry<String, Boolean> en : local.entrySet()) {
+            if (en.getKey().equalsIgnoreCase(e.getPermission())) {
+                e.setHasPermission(en.getValue());
+                return;
+            }
+        }
+    }
+
     @EventHandler
     public void onPlayerLogin(LoginEvent e) {
         /* Delay the login here, as we want to cache UUID data before the player is connected to a backend bukkit server.
@@ -90,7 +111,7 @@ class BungeeListener extends AbstractListener implements Listener {
         final ProxiedPlayer player = e.getPlayer();
         final WeakReference<ProxiedPlayer> p = new WeakReference<>(player);
 
-        final User user = plugin.getUserManager().getUser(plugin.getUuidCache().getUUID(e.getPlayer().getUniqueId()));
+        final User user = plugin.getUserManager().get(plugin.getUuidCache().getUUID(e.getPlayer().getUniqueId()));
         if (user == null) {
             plugin.getProxy().getScheduler().schedule(plugin, () -> {
                 final ProxiedPlayer pl = p.get();

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

@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms;
+
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+import me.lucko.luckperms.commands.SenderFactory;
+import me.lucko.luckperms.constants.Constants;
+import net.md_5.bungee.api.CommandSender;
+import net.md_5.bungee.api.chat.TextComponent;
+import net.md_5.bungee.api.connection.ProxiedPlayer;
+
+import java.util.UUID;
+
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+public class BungeeSenderFactory extends SenderFactory<CommandSender> {
+    private static BungeeSenderFactory instance = null;
+    public static BungeeSenderFactory get() {
+        if (instance == null){
+            instance = new BungeeSenderFactory();
+        }
+        return instance;
+    }
+
+    @Override
+    protected String getName(CommandSender sender) {
+        if (sender instanceof ProxiedPlayer) {
+            return sender.getName();
+        }
+        return Constants.getConsoleName();
+    }
+
+    @Override
+    protected UUID getUuid(CommandSender sender) {
+        if (sender instanceof ProxiedPlayer) {
+            return ((ProxiedPlayer) sender).getUniqueId();
+        }
+        return Constants.getConsoleUUID();
+    }
+
+    @Override
+    protected void sendMessage(CommandSender sender, String s) {
+        sender.sendMessage(new TextComponent(s));
+    }
+
+    @Override
+    protected boolean hasPermission(CommandSender sender, String node) {
+        return sender.hasPermission(node);
+    }
+}

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

@@ -26,28 +26,30 @@ 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.Sender;
 import me.lucko.luckperms.constants.Message;
-import me.lucko.luckperms.data.Datastore;
-import me.lucko.luckperms.data.methods.FlatfileDatastore;
-import me.lucko.luckperms.data.methods.MySQLDatastore;
+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.UpdateTask;
+import me.lucko.luckperms.storage.Datastore;
+import me.lucko.luckperms.storage.StorageFactory;
 import me.lucko.luckperms.tracks.TrackManager;
 import me.lucko.luckperms.users.BungeeUserManager;
 import me.lucko.luckperms.users.UserManager;
-import me.lucko.luckperms.utils.LPConfiguration;
-import me.lucko.luckperms.utils.LogUtil;
-import me.lucko.luckperms.utils.UuidCache;
+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.List;
-import java.util.UUID;
+import java.io.File;
+import java.util.*;
 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 LPConfiguration configuration;
     private UserManager userManager;
     private GroupManager groupManager;
@@ -55,10 +57,11 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
     private Datastore datastore;
     private UuidCache uuidCache;
     private Logger log;
+    private Importer importer;
 
     @Override
     public void onEnable() {
-        log = LogUtil.wrap(getLogger());
+        log = LogFactory.wrap(getLogger());
 
         getLog().info("Loading configuration...");
         configuration = new BungeeConfig(this);
@@ -68,32 +71,20 @@ 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();
+        importer = new Importer(commandManager);
 
         // Run update task to refresh any online users
         getLog().info("Scheduling Update Task to refresh any online users.");
@@ -108,6 +99,9 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
             getProxy().getScheduler().schedule(this, new UpdateTask(this), mins, mins, TimeUnit.MINUTES);
         }
 
+        // 20 times per second (once per "tick")
+        getProxy().getScheduler().schedule(this, BungeeSenderFactory.get(), 50L, 50L, TimeUnit.MILLISECONDS);
+
         getLog().info("Registering API...");
         LuckPerms.registerProvider(new ApiProvider(this));
 
@@ -128,6 +122,11 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
         return getDescription().getVersion();
     }
 
+    @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;
@@ -143,6 +142,22 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin {
         return getProxy().getPlayers().stream().map(ProxiedPlayer::getName).collect(Collectors.toList());
     }
 
+    @Override
+    public List<Sender> getSenders() {
+        return getProxy().getPlayers().stream().map(p -> BungeeSenderFactory.get().wrap(p)).collect(Collectors.toList());
+    }
+
+    @Override
+    public Sender getConsoleSender() {
+        return BungeeSenderFactory.get().wrap(getProxy().getConsole());
+    }
+
+    @Override
+    public List<String> getPossiblePermissions() {
+        // No such thing on Bungee. Wildcards are processed in the listener instead.
+        return Collections.emptyList();
+    }
+
     @Override
     public void runUpdateTask() {
         doAsync(new UpdateTask(this));

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

@@ -23,38 +23,20 @@
 package me.lucko.luckperms.users;
 
 import me.lucko.luckperms.LPBungeePlugin;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
 
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Map;
 import java.util.UUID;
 
 public class BungeeUser extends User {
-    private final LPBungeePlugin plugin;
-
     BungeeUser(UUID uuid, LPBungeePlugin plugin) {
         super(uuid, plugin);
-        this.plugin = plugin;
     }
 
     BungeeUser(UUID uuid, String username, LPBungeePlugin plugin) {
         super(uuid, username, plugin);
-        this.plugin = plugin;
     }
 
     @Override
     public void refreshPermissions() {
-        ProxiedPlayer player = plugin.getProxy().getPlayer(plugin.getUuidCache().getExternalUUID(getUuid()));
-        if (player == null) return;
-
-        // Clear existing permissions
-        Collection<String> perms = new ArrayList<>(player.getPermissions());
-        perms.forEach(p -> player.setPermission(p, false));
-
-        // Re-add all defined permissions for the user
-        final String server = player.getServer() == null ? null : (player.getServer().getInfo() == null ? null : player.getServer().getInfo().getName());
-        Map<String, Boolean> local = getLocalPermissions(getPlugin().getConfiguration().getServer(), server, null);
-        local.entrySet().forEach(e -> player.setPermission(e.getKey(), e.getValue()));
+        // Do nothing. Permissions are applied when needed in a listener.
     }
 }

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

@@ -35,28 +35,28 @@ public class BungeeUserManager extends UserManager {
     }
 
     @Override
-    public void unloadUser(User user) {
+    public void unload(User user) {
         if (user != null) {
             // Cannot clear the ProxiedPlayer's permission map, they're leaving so that will get GCed anyway
             // Calling getPermissions.clear() throws an UnsupportedOperationException
-            getUsers().remove(user.getUuid());
+            getAll().remove(user.getUuid());
         }
     }
 
     @Override
-    public void cleanupUser(User user) {
+    public void cleanup(User user) {
         if (plugin.getProxy().getPlayer(plugin.getUuidCache().getExternalUUID(user.getUuid())) == null) {
-            unloadUser(user);
+            unload(user);
         }
     }
 
     @Override
-    public User makeUser(UUID uuid) {
+    public User make(UUID uuid) {
         return new BungeeUser(uuid, plugin);
     }
 
     @Override
-    public User makeUser(UUID uuid, String username) {
+    public User make(UUID uuid, String username) {
         return new BungeeUser(uuid, username, plugin);
     }
 

bungee/src/main/resources/config.yml

@@ -1,4 +1,9 @@
-# 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
@@ -22,14 +27,32 @@ include-global: false
 #    In this case, set online-mode to true no matter what is set in server.properties. (we can just fallback to the servers uuid cache)
 online-mode: true
 
-# Which storage method the plugin should use.
-# Currently supported: mysql & flatfile
-# Fill out connection info below if you're using MySQL
-storage-method: flatfile
+# If the plugin should apply wildcard permissions.
+# If set to true, LuckPerms will detect wildcard permissions, and resolve & apply all registered permissions matching
+# the wildcard. This will only work for plugins that define all of their permissions to the server.
+apply-wildcards: true
 
-sql:
+# If the plugin should parse regex permissions.
+# If set to true, LuckPerms will detect regex permissions, marked with "r=" at the start of the node, and resolve &
+# apply all registered permissions matching the regex. This will only work for plugins that define all of their
+# permissions to the server.
+apply-regex: true
+
+# If the plugin should complete and apply shorthand permissions.
+# If set to true, LuckPerms will detect and expand shorthand node patterns.
+apply-shorthand: true
+
+# Which storage method the plugin should use.
+# Currently supported: mysql, sqlite, h2, flatfile, mongodb
+# Fill out connection info below if you're using MySQL or MongoDB
+storage-method: h2
+
+data:
   address: localhost:3306
   database: minecraft
   username: root
   password: ''
+
+  # Set to -1 to disable. If this is the only instance accessing the datastore, you can disable syncing.
+  # e.g. if you're using sqlite or flatfile, this can be set to -1 to save resources.
   sync-minutes: 3

common/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>luckperms</artifactId>
         <groupId>me.lucko.luckperms</groupId>
-        <version>2.0</version>
+        <version>2.4</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>
@@ -53,6 +74,20 @@
             <version>2.7</version>
             <scope>provided</scope>
         </dependency>
+        <!-- guava -->
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>19.0</version>
+            <scope>provided</scope>
+        </dependency>
+        <!-- Lombok -->
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>1.16.10</version>
+            <scope>provided</scope>
+        </dependency>
     </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.commands.Sender;
 import me.lucko.luckperms.constants.Message;
-import me.lucko.luckperms.data.Datastore;
+import me.lucko.luckperms.core.LPConfiguration;
+import me.lucko.luckperms.core.UuidCache;
+import me.lucko.luckperms.data.Importer;
 import me.lucko.luckperms.groups.GroupManager;
+import me.lucko.luckperms.storage.Datastore;
 import me.lucko.luckperms.tracks.TrackManager;
 import me.lucko.luckperms.users.UserManager;
-import me.lucko.luckperms.utils.LPConfiguration;
-import me.lucko.luckperms.utils.UuidCache;
 
+import java.io.File;
 import java.util.List;
+import java.util.Set;
 import java.util.UUID;
 
 /**
@@ -87,6 +91,21 @@ public interface LuckPermsPlugin {
      */
     String getVersion();
 
+    /**
+     * @return the main plugin directory
+     */
+    File getMainDir();
+
+    /**
+     * @return the platforms data folder
+     */
+    File getDataFolder();
+
+    /**
+     * @return the importer instance for the platform
+     */
+    Importer getImporter();
+
     /**
      * Returns a colored string indicating the status of a player
      * @param uuid The player's uuid
@@ -106,6 +125,30 @@ public interface LuckPermsPlugin {
      */
     List<String> getPlayerList();
 
+    /**
+     * Gets a list of all Senders online on the platform
+     * @return a {@link List} of senders
+     */
+    List<Sender> getSenders();
+
+    /**
+     * Gets the console sender of the instance
+     * @return a the console sender of the instance
+     */
+    Sender getConsoleSender();
+
+    /**
+     * Gets all possible permission nodes, used for resolving wildcards
+     * @return a {@link List} of permission nodes
+     */
+    List<String> getPossiblePermissions();
+
+    /**
+     * Gets a set of players ignoring logging output
+     * @return a {@link Set} of uuids
+     */
+    Set<UUID> getIgnoringLogs();
+
     /**
      * Runs an update task
      */

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

@@ -29,7 +29,9 @@ import me.lucko.luckperms.api.*;
 import me.lucko.luckperms.api.implementation.internal.*;
 
 import java.util.Optional;
+import java.util.Set;
 import java.util.UUID;
+import java.util.stream.Collectors;
 
 /**
  * Provides static access to LuckPerms
@@ -55,7 +57,7 @@ public class ApiProvider implements LuckPermsApi {
 
     @Override
     public Datastore getDatastore() {
-        return new DatastoreLink(plugin.getDatastore());
+        return new DatastoreLink(plugin, plugin.getDatastore());
     }
 
     @Override
@@ -70,7 +72,7 @@ public class ApiProvider implements LuckPermsApi {
 
     @Override
     public User getUser(@NonNull UUID uuid) {
-        final me.lucko.luckperms.users.User user = plugin.getUserManager().getUser(uuid);
+        final me.lucko.luckperms.users.User user = plugin.getUserManager().get(uuid);
         if (user == null) {
             return null;
         }
@@ -85,7 +87,7 @@ public class ApiProvider implements LuckPermsApi {
 
     @Override
     public User getUser(@NonNull String name) {
-        final me.lucko.luckperms.users.User user = plugin.getUserManager().getUser(name);
+        final me.lucko.luckperms.users.User user = plugin.getUserManager().get(name);
         if (user == null) {
             return null;
         }
@@ -98,6 +100,11 @@ public class ApiProvider implements LuckPermsApi {
         return Optional.ofNullable(getUser(name));
     }
 
+    @Override
+    public Set<User> getUsers() {
+        return plugin.getUserManager().getAll().values().stream().map(UserLink::new).collect(Collectors.toSet());
+    }
+
     @Override
     public boolean isUserLoaded(@NonNull UUID uuid) {
         return plugin.getUserManager().isLoaded(uuid);
@@ -105,7 +112,7 @@ public class ApiProvider implements LuckPermsApi {
 
     @Override
     public Group getGroup(@NonNull String name) {
-        final me.lucko.luckperms.groups.Group group = plugin.getGroupManager().getGroup(name);
+        final me.lucko.luckperms.groups.Group group = plugin.getGroupManager().get(name);
         if (group == null) {
             return null;
         }
@@ -118,6 +125,11 @@ public class ApiProvider implements LuckPermsApi {
         return Optional.ofNullable(getGroup(name));
     }
 
+    @Override
+    public Set<Group> getGroups() {
+        return plugin.getGroupManager().getAll().values().stream().map(GroupLink::new).collect(Collectors.toSet());
+    }
+
     @Override
     public boolean isGroupLoaded(@NonNull String name) {
         return plugin.getGroupManager().isLoaded(name);
@@ -125,7 +137,7 @@ public class ApiProvider implements LuckPermsApi {
 
     @Override
     public Track getTrack(@NonNull String name) {
-        final me.lucko.luckperms.tracks.Track track = plugin.getTrackManager().getTrack(name);
+        final me.lucko.luckperms.tracks.Track track = plugin.getTrackManager().get(name);
         if (track == null) {
             return null;
         }
@@ -138,6 +150,11 @@ public class ApiProvider implements LuckPermsApi {
         return Optional.ofNullable(getTrack(name));
     }
 
+    @Override
+    public Set<Track> getTracks() {
+        return plugin.getTrackManager().getAll().values().stream().map(TrackLink::new).collect(Collectors.toSet());
+    }
+
     @Override
     public boolean isTrackLoaded(@NonNull String name) {
         return plugin.getTrackManager().isLoaded(name);

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

@@ -22,38 +22,45 @@
 
 package me.lucko.luckperms.api.implementation.internal;
 
+import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
+import lombok.NoArgsConstructor;
 import lombok.NonNull;
-import me.lucko.luckperms.api.Datastore;
-import me.lucko.luckperms.api.Group;
-import me.lucko.luckperms.api.Track;
-import me.lucko.luckperms.api.User;
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.api.*;
 import me.lucko.luckperms.api.data.Callback;
 
 import java.util.UUID;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
 
 import static me.lucko.luckperms.api.implementation.internal.Utils.*;
 
 /**
- * Provides a link between {@link Datastore} and {@link me.lucko.luckperms.data.Datastore}
+ * Provides a link between {@link Datastore} and {@link me.lucko.luckperms.storage.Datastore}
  */
 @SuppressWarnings({"unused", "WeakerAccess"})
 public class DatastoreLink implements Datastore {
 
-    private final me.lucko.luckperms.data.Datastore master;
+    private final LuckPermsPlugin plugin;
+    private final me.lucko.luckperms.storage.Datastore master;
     private final Async async;
     private final Sync sync;
+    private final Future future;
 
-    public DatastoreLink(@NonNull me.lucko.luckperms.data.Datastore master) {
+    public DatastoreLink(@NonNull LuckPermsPlugin plugin, @NonNull me.lucko.luckperms.storage.Datastore master) {
+        this.plugin = plugin;
         this.master = master;
         this.async = new Async(master);
         this.sync = new Sync(master);
+        this.future = new Future(master);
     }
 
     private static <T> Callback<T> checkCallback(Callback<T> c) {
         // If no callback was given, just send an empty one
         if (c == null) {
-            c = t -> {};
+            c = Callback.empty();
         }
         return c;
     }
@@ -69,18 +76,33 @@ public class DatastoreLink implements Datastore {
     }
 
     @Override
-    public Async async() {
+    public Datastore.Async async() {
         return async;
     }
 
     @Override
-    public Sync sync() {
+    public Datastore.Sync sync() {
         return sync;
     }
 
+    @Override
+    public Datastore.Future future() {
+        return future;
+    }
+
     @AllArgsConstructor
     public class Async implements Datastore.Async {
-        private final me.lucko.luckperms.data.Datastore master;
+        private final me.lucko.luckperms.storage.Datastore master;
+
+        @Override
+        public void logAction(@NonNull LogEntry entry, Callback<Boolean> callback) {
+            master.logAction(entry, checkCallback(callback));
+        }
+
+        @Override
+        public void getLog(Callback<Log> callback) {
+            master.getLog(log -> callback.onComplete(new LogLink(log)));
+        }
 
         @Override
         public void loadOrCreateUser(@NonNull UUID uuid, @NonNull String username, Callback<Boolean> callback) {
@@ -122,6 +144,9 @@ public class DatastoreLink implements Datastore {
         @Override
         public void deleteGroup(@NonNull Group group, Callback<Boolean> callback) {
             checkGroup(group);
+            if (group.getName().equalsIgnoreCase(plugin.getConfiguration().getDefaultGroupName())) {
+                throw new IllegalArgumentException("Cannot delete the default group.");
+            }
             master.deleteGroup(((GroupLink) group).getMaster(), checkCallback(callback));
         }
 
@@ -165,7 +190,17 @@ public class DatastoreLink implements Datastore {
 
     @AllArgsConstructor
     public class Sync implements Datastore.Sync {
-        private final me.lucko.luckperms.data.Datastore master;
+        private final me.lucko.luckperms.storage.Datastore master;
+
+        @Override
+        public boolean logAction(@NonNull LogEntry entry) {
+            return master.logAction(entry);
+        }
+
+        @Override
+        public Log getLog() {
+            return new LogLink(master.getLog());
+        }
 
         @Override
         public boolean loadOrCreateUser(@NonNull UUID uuid, @NonNull String username) {
@@ -207,6 +242,9 @@ public class DatastoreLink implements Datastore {
         @Override
         public boolean deleteGroup(@NonNull Group group) {
             checkGroup(group);
+            if (group.getName().equalsIgnoreCase(plugin.getConfiguration().getDefaultGroupName())) {
+                throw new IllegalArgumentException("Cannot delete the default group.");
+            }
             return master.deleteGroup(((GroupLink) group).getMaster());
         }
 
@@ -248,4 +286,179 @@ public class DatastoreLink implements Datastore {
         }
     }
 
+    @AllArgsConstructor
+    public class Future implements Datastore.Future {
+        private final me.lucko.luckperms.storage.Datastore master;
+
+        @Override
+        public java.util.concurrent.Future<Boolean> logAction(@NonNull LogEntry entry) {
+            LPFuture<Boolean> lpf = new LPFuture<>();
+            master.logAction(entry, lpf);
+            return lpf;
+        }
+
+        @Override
+        public java.util.concurrent.Future<Log> getLog() {
+            LPFuture<Log> lpf = new LPFuture<>();
+            master.getLog(log -> lpf.onComplete(new LogLink(log)));
+            return lpf;
+        }
+
+        @Override
+        public java.util.concurrent.Future<Boolean> loadOrCreateUser(@NonNull UUID uuid, @NonNull String username) {
+            LPFuture<Boolean> lpf = new LPFuture<>();
+            master.loadOrCreateUser(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);
+            return lpf;
+        }
+
+        @Override
+        public java.util.concurrent.Future<Boolean> saveUser(@NonNull User user) {
+            LPFuture<Boolean> lpf = new LPFuture<>();
+            checkUser(user);
+            master.saveUser(((UserLink) user).getMaster(), lpf);
+            return lpf;
+        }
+
+        @Override
+        public java.util.concurrent.Future<Boolean> createAndLoadGroup(@NonNull String name) {
+            LPFuture<Boolean> lpf = new LPFuture<>();
+            master.createAndLoadGroup(checkName(name), lpf);
+            return lpf;
+        }
+
+        @Override
+        public java.util.concurrent.Future<Boolean> loadGroup(@NonNull String name) {
+            LPFuture<Boolean> lpf = new LPFuture<>();
+            master.loadGroup(checkName(name), lpf);
+            return lpf;
+        }
+
+        @Override
+        public java.util.concurrent.Future<Boolean> loadAllGroups() {
+            LPFuture<Boolean> lpf = new LPFuture<>();
+            master.loadAllGroups(lpf);
+            return lpf;
+        }
+
+        @Override
+        public java.util.concurrent.Future<Boolean> saveGroup(@NonNull Group group) {
+            LPFuture<Boolean> lpf = new LPFuture<>();
+            checkGroup(group);
+            master.saveGroup(((GroupLink) group).getMaster(), lpf);
+            return lpf;
+        }
+
+        @Override
+        public java.util.concurrent.Future<Boolean> deleteGroup(@NonNull Group group) {
+            LPFuture<Boolean> lpf = new LPFuture<>();
+            checkGroup(group);
+            if (group.getName().equalsIgnoreCase(plugin.getConfiguration().getDefaultGroupName())) {
+                throw new IllegalArgumentException("Cannot delete the default group.");
+            }
+            master.deleteGroup(((GroupLink) group).getMaster(), lpf);
+            return lpf;
+        }
+
+        @Override
+        public java.util.concurrent.Future<Boolean> createAndLoadTrack(@NonNull String name) {
+            LPFuture<Boolean> lpf = new LPFuture<>();
+            master.createAndLoadTrack(checkName(name), lpf);
+            return lpf;
+        }
+
+        @Override
+        public java.util.concurrent.Future<Boolean> loadTrack(@NonNull String name) {
+            LPFuture<Boolean> lpf = new LPFuture<>();
+            master.loadTrack(checkName(name), lpf);
+            return lpf;
+        }
+
+        @Override
+        public java.util.concurrent.Future<Boolean> loadAllTracks() {
+            LPFuture<Boolean> lpf = new LPFuture<>();
+            master.loadAllTracks(lpf);
+            return lpf;
+        }
+
+        @Override
+        public java.util.concurrent.Future<Boolean> saveTrack(@NonNull Track track) {
+            LPFuture<Boolean> lpf = new LPFuture<>();
+            checkTrack(track);
+            master.saveTrack(((TrackLink) track).getMaster(), lpf);
+            return lpf;
+        }
+
+        @Override
+        public java.util.concurrent.Future<Boolean> deleteTrack(@NonNull Track track) {
+            LPFuture<Boolean> lpf = new LPFuture<>();
+            checkTrack(track);
+            master.deleteTrack(((TrackLink) track).getMaster(), lpf);
+            return lpf;
+        }
+
+        @Override
+        public java.util.concurrent.Future<Boolean> saveUUIDData(@NonNull String username, @NonNull UUID uuid) {
+            LPFuture<Boolean> lpf = new LPFuture<>();
+            master.saveUUIDData(checkUsername(username), uuid, lpf);
+            return lpf;
+        }
+
+        @Override
+        public java.util.concurrent.Future<UUID> getUUID(@NonNull String username) {
+            LPFuture<UUID> lpf = new LPFuture<>();
+            master.getUUID(checkUsername(username), lpf);
+            return lpf;
+        }
+    }
+
+    @NoArgsConstructor(access = AccessLevel.PRIVATE)
+    public static class LPFuture<T> implements Callback<T>, java.util.concurrent.Future<T> {
+        private final CountDownLatch latch = new CountDownLatch(1);
+        private T value;
+
+        @Override
+        public void onComplete(T t) {
+            value = t;
+            latch.countDown();
+        }
+
+        @Override
+        public boolean cancel(boolean mayInterruptIfRunning) {
+            // Not supported
+            return false;
+        }
+
+        @Override
+        public boolean isCancelled() {
+            return false;
+        }
+
+        @Override
+        public boolean isDone() {
+            return latch.getCount() == 0;
+        }
+
+        @Override
+        public T get() throws InterruptedException {
+            latch.await();
+            return value;
+        }
+
+        @Override
+        public T get(long timeout, TimeUnit unit) throws InterruptedException, TimeoutException {
+            if (latch.await(timeout, unit)) {
+                return value;
+            } else {
+                throw new TimeoutException();
+            }
+        }
+    }
+
 }

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

@@ -23,6 +23,7 @@
 package me.lucko.luckperms.api.implementation.internal;
 
 import lombok.AccessLevel;
+import lombok.EqualsAndHashCode;
 import lombok.Getter;
 import lombok.NonNull;
 import me.lucko.luckperms.api.Group;
@@ -36,20 +37,20 @@ import static me.lucko.luckperms.api.implementation.internal.Utils.*;
 /**
  * Provides a link between {@link Group} and {@link me.lucko.luckperms.groups.Group}
  */
+@EqualsAndHashCode(of = {"name"}, callSuper = false)
 @SuppressWarnings("unused")
 public class GroupLink extends PermissionHolderLink implements Group {
 
     @Getter(AccessLevel.PACKAGE)
     private final me.lucko.luckperms.groups.Group master;
 
+    @Getter
+    private final String name;
+
     public GroupLink(@NonNull me.lucko.luckperms.groups.Group master) {
         super(master);
         this.master = master;
-    }
-
-    @Override
-    public String getName() {
-        return master.getName();
+        this.name = master.getName();
     }
 
     @Override

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

@@ -24,14 +24,15 @@ package me.lucko.luckperms.api.implementation.internal;
 
 import lombok.AllArgsConstructor;
 import me.lucko.luckperms.api.LPConfiguration;
+import me.lucko.luckperms.api.data.DatastoreConfiguration;
 import me.lucko.luckperms.api.data.MySQLConfiguration;
 
 /**
- * Provides a link between {@link me.lucko.luckperms.api.LPConfiguration} and {@link me.lucko.luckperms.utils.LPConfiguration}
+ * Provides a link between {@link LPConfiguration} and {@link me.lucko.luckperms.core.LPConfiguration}
  */
 @AllArgsConstructor
 public class LPConfigurationLink implements LPConfiguration {
-    private final me.lucko.luckperms.utils.LPConfiguration master;
+    private final me.lucko.luckperms.core.LPConfiguration master;
 
     @Override
     public String getServer() {
@@ -63,8 +64,29 @@ public class LPConfigurationLink implements LPConfiguration {
         return master.getOnlineMode();
     }
 
+    @Override
+    public boolean getApplyWildcards() {
+        return master.getApplyWildcards();
+    }
+
+    @Override
+    public boolean getApplyRegex() {
+        return master.getApplyRegex();
+    }
+
+    @Override
+    public boolean getApplyShorthand() {
+        return master.getApplyShorthand();
+    }
+
+    @SuppressWarnings("deprecation")
     @Override
     public MySQLConfiguration getDatabaseValues() {
+        return getDatastoreConfig();
+    }
+
+    @Override
+    public DatastoreConfiguration getDatastoreConfig() {
         return master.getDatabaseValues();
     }
 

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

@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.implementation.internal;
+
+import lombok.AllArgsConstructor;
+import lombok.NonNull;
+import me.lucko.luckperms.api.Log;
+import me.lucko.luckperms.api.LogEntry;
+
+import java.util.SortedMap;
+import java.util.SortedSet;
+import java.util.UUID;
+
+import static me.lucko.luckperms.api.implementation.internal.Utils.checkName;
+
+/**
+ * Provides a link between {@link Log} and {@link me.lucko.luckperms.data.Log}
+ */
+@AllArgsConstructor
+public class LogLink implements Log {
+    private final me.lucko.luckperms.data.Log master;
+    
+    @Override
+    public SortedSet<LogEntry> getContent() {
+        return master.getContent();
+    }
+
+    @Override
+    public SortedSet<LogEntry> getRecent() {
+        return master.getRecent();
+    }
+
+    @Override
+    public SortedMap<Integer, LogEntry> getRecent(int pageNo) {
+        return master.getRecent(pageNo);
+    }
+
+    @Override
+    public int getRecentMaxPages() {
+        return master.getRecentMaxPages();
+    }
+
+    @Override
+    public SortedSet<LogEntry> getRecent(@NonNull UUID actor) {
+        return master.getRecent(actor);
+    }
+
+    @Override
+    public SortedMap<Integer, LogEntry> getRecent(int pageNo, @NonNull UUID actor) {
+        return master.getRecent(pageNo, actor);
+    }
+
+    @Override
+    public int getRecentMaxPages(@NonNull UUID actor) {
+        return master.getRecentMaxPages(actor);
+    }
+
+    @Override
+    public SortedSet<LogEntry> getUserHistory(@NonNull UUID uuid) {
+        return master.getUserHistory(uuid);
+    }
+
+    @Override
+    public SortedMap<Integer, LogEntry> getUserHistory(int pageNo, @NonNull UUID uuid) {
+        return master.getUserHistory(pageNo, uuid);
+    }
+
+    @Override
+    public int getUserHistoryMaxPages(@NonNull UUID uuid) {
+        return master.getUserHistoryMaxPages(uuid);
+    }
+
+    @Override
+    public SortedSet<LogEntry> getGroupHistory(@NonNull String name) {
+        return master.getGroupHistory(checkName(name));
+    }
+
+    @Override
+    public SortedMap<Integer, LogEntry> getGroupHistory(int pageNo, @NonNull String name) {
+        return master.getGroupHistory(pageNo, checkName(name));
+    }
+
+    @Override
+    public int getGroupHistoryMaxPages(@NonNull String name) {
+        return master.getGroupHistoryMaxPages(checkName(name));
+    }
+
+    @Override
+    public SortedSet<LogEntry> getTrackHistory(@NonNull String name) {
+        return master.getTrackHistory(checkName(name));
+    }
+
+    @Override
+    public SortedMap<Integer, LogEntry> getTrackHistory(int pageNo, @NonNull String name) {
+        return master.getTrackHistory(pageNo, checkName(name));
+    }
+
+    @Override
+    public int getTrackHistoryMaxPages(@NonNull String name) {
+        return master.getTrackHistoryMaxPages(checkName(name));
+    }
+
+    @Override
+    public SortedSet<LogEntry> getSearch(@NonNull String query) {
+        return master.getSearch(query);
+    }
+
+    @Override
+    public SortedMap<Integer, LogEntry> getSearch(int pageNo, @NonNull String query) {
+        return master.getSearch(pageNo, query);
+    }
+
+    @Override
+    public int getSearchMaxPages(@NonNull String query) {
+        return master.getSearchMaxPages(query);
+    }
+}

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

@@ -36,14 +36,14 @@ import java.util.Map;
 import static me.lucko.luckperms.api.implementation.internal.Utils.*;
 
 /**
- * Provides a link between {@link PermissionHolder} and {@link me.lucko.luckperms.utils.PermissionHolder}
+ * Provides a link between {@link PermissionHolder} and {@link me.lucko.luckperms.core.PermissionHolder}
  */
 @SuppressWarnings("unused")
 @AllArgsConstructor(access = AccessLevel.PACKAGE)
 class PermissionHolderLink implements PermissionHolder {
 
     @NonNull
-    private final me.lucko.luckperms.utils.PermissionHolder master;
+    private final me.lucko.luckperms.core.PermissionHolder master;
 
     @Override
     public String getObjectName() {
@@ -175,11 +175,21 @@ class PermissionHolderLink implements PermissionHolder {
         master.unsetPermission(checkNode(node), checkServer(server), world, temporary);
     }
 
+    @Override
+    public Map<String, Boolean> getLocalPermissions(String server, String world, List<String> excludedGroups, List<String> possibleNodes) {
+        return master.getLocalPermissions(server, world, excludedGroups, possibleNodes);
+    }
+
     @Override
     public Map<String, Boolean> getLocalPermissions(String server, String world, List<String> excludedGroups) {
         return master.getLocalPermissions(server, world, excludedGroups);
     }
 
+    @Override
+    public Map<String, Boolean> getLocalPermissions(String server, List<String> excludedGroups, List<String> possibleNodes) {
+        return master.getLocalPermissions(server, excludedGroups, possibleNodes);
+    }
+
     @Override
     public Map<String, Boolean> getLocalPermissions(String server, List<String> excludedGroups) {
         return master.getLocalPermissions(server, excludedGroups);

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

@@ -23,7 +23,7 @@
 package me.lucko.luckperms.api.implementation.internal;
 
 import lombok.AccessLevel;
-import lombok.AllArgsConstructor;
+import lombok.EqualsAndHashCode;
 import lombok.Getter;
 import lombok.NonNull;
 import me.lucko.luckperms.api.Group;
@@ -38,17 +38,19 @@ import static me.lucko.luckperms.api.implementation.internal.Utils.checkGroup;
 /**
  * Provides a link between {@link Track} and {@link me.lucko.luckperms.tracks.Track}
  */
+@EqualsAndHashCode(of = {"name"})
 @SuppressWarnings("unused")
-@AllArgsConstructor
 public class TrackLink implements Track {
 
-    @NonNull
     @Getter(AccessLevel.PACKAGE)
     private final me.lucko.luckperms.tracks.Track master;
 
-    @Override
-    public String getName() {
-        return master.getName();
+    @Getter
+    private final String name;
+
+    public TrackLink(@NonNull me.lucko.luckperms.tracks.Track master) {
+        this.master = master;
+        this.name = master.getName();
     }
 
     @Override

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

@@ -23,6 +23,7 @@
 package me.lucko.luckperms.api.implementation.internal;
 
 import lombok.AccessLevel;
+import lombok.EqualsAndHashCode;
 import lombok.Getter;
 import lombok.NonNull;
 import me.lucko.luckperms.api.Group;
@@ -38,20 +39,20 @@ import static me.lucko.luckperms.api.implementation.internal.Utils.*;
 /**
  * Provides a link between {@link User} and {@link me.lucko.luckperms.users.User}
  */
+@EqualsAndHashCode(of = {"uuid"}, callSuper = false)
 @SuppressWarnings("unused")
 public class UserLink extends PermissionHolderLink implements User {
 
     @Getter(AccessLevel.PACKAGE)
     private final me.lucko.luckperms.users.User master;
 
+    @Getter
+    private final UUID uuid;
+
     public UserLink(@NonNull me.lucko.luckperms.users.User master) {
         super(master);
         this.master = master;
-    }
-
-    @Override
-    public UUID getUuid() {
-        return master.getUuid();
+        this.uuid = master.getUuid();
     }
 
     @Override

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

@@ -26,8 +26,7 @@ import lombok.experimental.UtilityClass;
 import me.lucko.luckperms.api.Group;
 import me.lucko.luckperms.api.Track;
 import me.lucko.luckperms.api.User;
-import me.lucko.luckperms.utils.DateUtil;
-import me.lucko.luckperms.utils.Patterns;
+import me.lucko.luckperms.utils.ArgumentChecker;
 
 @UtilityClass
 class Utils {
@@ -51,7 +50,7 @@ class Utils {
     }
 
     static String checkUsername(String s) {
-        if (s.length() > 16 || Patterns.NON_USERNAME.matcher(s).find()) {
+        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 _'.");
         }
@@ -59,7 +58,7 @@ class Utils {
     }
 
     static String checkName(String s) {
-        if (s.length() > 36 || Patterns.NON_ALPHA_NUMERIC.matcher(s).find()) {
+        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'.");
         }
@@ -67,21 +66,21 @@ class Utils {
     }
 
     static String checkServer(String s) {
-        if (Patterns.NON_ALPHA_NUMERIC.matcher(s).find()) {
+        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) {
-        if (s.contains("/") || s.contains("$")) {
+        if (ArgumentChecker.checkNode(s)) {
             throw new IllegalArgumentException("Invalid node entry '" + s + "'. Nodes cannot contain '/' or '$' characters.");
         }
         return s;
     }
 
     static long checkTime(long l) {
-        if (DateUtil.shouldExpire(l)) {
+        if (ArgumentChecker.checkTime(l)) {
             throw new IllegalArgumentException("Unix time '" + l + "' is invalid, as it has already passed.");
         }
         return l;

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

@@ -28,11 +28,11 @@ import me.lucko.luckperms.api.UuidCache;
 import java.util.UUID;
 
 /**
- * Provides a link between {@link me.lucko.luckperms.api.UuidCache} and {@link me.lucko.luckperms.utils.UuidCache}
+ * Provides a link between {@link UuidCache} and {@link me.lucko.luckperms.core.UuidCache}
  */
 @AllArgsConstructor
 public class UuidCacheLink implements UuidCache {
-    private final me.lucko.luckperms.utils.UuidCache master;
+    private final me.lucko.luckperms.core.UuidCache master;
 
     @Override
     public UUID getUUID(UUID external) {

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

@@ -22,23 +22,25 @@
 
 package me.lucko.luckperms.commands;
 
+import com.google.common.collect.ImmutableList;
+import lombok.AllArgsConstructor;
 import lombok.Getter;
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.api.data.Callback;
 import me.lucko.luckperms.commands.group.CreateGroup;
 import me.lucko.luckperms.commands.group.DeleteGroup;
 import me.lucko.luckperms.commands.group.GroupMainCommand;
 import me.lucko.luckperms.commands.group.ListGroups;
-import me.lucko.luckperms.commands.group.subcommands.*;
+import me.lucko.luckperms.commands.log.LogMainCommand;
 import me.lucko.luckperms.commands.misc.DebugCommand;
+import me.lucko.luckperms.commands.misc.ImportCommand;
 import me.lucko.luckperms.commands.misc.InfoCommand;
 import me.lucko.luckperms.commands.misc.SyncCommand;
 import me.lucko.luckperms.commands.track.CreateTrack;
 import me.lucko.luckperms.commands.track.DeleteTrack;
 import me.lucko.luckperms.commands.track.ListTracks;
 import me.lucko.luckperms.commands.track.TrackMainCommand;
-import me.lucko.luckperms.commands.track.subcommands.*;
 import me.lucko.luckperms.commands.user.UserMainCommand;
-import me.lucko.luckperms.commands.user.subcommands.*;
 import me.lucko.luckperms.constants.Message;
 
 import java.util.ArrayList;
@@ -47,71 +49,42 @@ import java.util.List;
 import java.util.Optional;
 import java.util.stream.Collectors;
 
+@AllArgsConstructor
 public class CommandManager {
     private final LuckPermsPlugin plugin;
 
     @Getter
-    private final List<MainCommand> mainCommands = new ArrayList<>();
+    private final List<MainCommand> mainCommands = ImmutableList.<MainCommand>builder()
+            .add(new UserMainCommand())
+            .add(new GroupMainCommand())
+            .add(new TrackMainCommand())
+            .add(new LogMainCommand())
+            .add(new SyncCommand())
+            .add(new InfoCommand())
+            .add(new DebugCommand())
+            .add(new ImportCommand())
+            .add(new CreateGroup())
+            .add(new DeleteGroup())
+            .add(new ListGroups())
+            .add(new CreateTrack())
+            .add(new DeleteTrack())
+            .add(new ListTracks())
+            .build();
 
-    public CommandManager(LuckPermsPlugin plugin) {
-        this.plugin = plugin;
 
-        UserMainCommand userCommand = new UserMainCommand();
-        this.registerMainCommand(userCommand);
-        userCommand.registerSubCommand(new UserInfo());
-        userCommand.registerSubCommand(new UserGetUUID());
-        userCommand.registerSubCommand(new UserListNodes());
-        userCommand.registerSubCommand(new UserHasPerm());
-        userCommand.registerSubCommand(new UserInheritsPerm());
-        userCommand.registerSubCommand(new UserSetPermission());
-        userCommand.registerSubCommand(new UserUnSetPermission());
-        userCommand.registerSubCommand(new UserAddGroup());
-        userCommand.registerSubCommand(new UserRemoveGroup());
-        userCommand.registerSubCommand(new UserSetTempPermission());
-        userCommand.registerSubCommand(new UserUnsetTempPermission());
-        userCommand.registerSubCommand(new UserAddTempGroup());
-        userCommand.registerSubCommand(new UserRemoveTempGroup());
-        userCommand.registerSubCommand(new UserSetPrimaryGroup());
-        userCommand.registerSubCommand(new UserShowTracks());
-        userCommand.registerSubCommand(new UserPromote());
-        userCommand.registerSubCommand(new UserDemote());
-        userCommand.registerSubCommand(new UserShowPos());
-        userCommand.registerSubCommand(new UserClear());
-
-        GroupMainCommand groupCommand = new GroupMainCommand();
-        this.registerMainCommand(groupCommand);
-        groupCommand.registerSubCommand(new GroupInfo());
-        groupCommand.registerSubCommand(new GroupListNodes());
-        groupCommand.registerSubCommand(new GroupHasPerm());
-        groupCommand.registerSubCommand(new GroupInheritsPerm());
-        groupCommand.registerSubCommand(new GroupSetPermission());
-        groupCommand.registerSubCommand(new GroupUnSetPermission());
-        groupCommand.registerSubCommand(new GroupSetInherit());
-        groupCommand.registerSubCommand(new GroupUnsetInherit());
-        groupCommand.registerSubCommand(new GroupSetTempPermission());
-        groupCommand.registerSubCommand(new GroupUnsetTempPermission());
-        groupCommand.registerSubCommand(new GroupSetTempInherit());
-        groupCommand.registerSubCommand(new GroupUnsetTempInherit());
-        groupCommand.registerSubCommand(new GroupShowTracks());
-        groupCommand.registerSubCommand(new GroupClear());
-
-        TrackMainCommand trackCommand = new TrackMainCommand();
-        this.registerMainCommand(trackCommand);
-        trackCommand.registerSubCommand(new TrackInfo());
-        trackCommand.registerSubCommand(new TrackAppend());
-        trackCommand.registerSubCommand(new TrackInsert());
-        trackCommand.registerSubCommand(new TrackRemove());
-        trackCommand.registerSubCommand(new TrackClear());
-
-        this.registerMainCommand(new SyncCommand());
-        this.registerMainCommand(new InfoCommand());
-        this.registerMainCommand(new DebugCommand());
-        this.registerMainCommand(new CreateGroup());
-        this.registerMainCommand(new DeleteGroup());
-        this.registerMainCommand(new ListGroups());
-        this.registerMainCommand(new CreateTrack());
-        this.registerMainCommand(new DeleteTrack());
-        this.registerMainCommand(new ListTracks());
+    /**
+     * Generic on command method to be called from the command executor object of the platform
+     * Unlike {@link #onCommand(Sender, String, List)}, this method is called in a new thread
+     * @param sender who sent the command
+     * @param label the command label used
+     * @param args the arguments provided
+     * @param result the callback to be called when the command has fully executed
+     */
+    public void onCommand(Sender sender, String label, List<String> args, Callback<CommandResult> result) {
+        plugin.doAsync(() -> {
+            CommandResult r = onCommand(sender, label, args);
+            plugin.doSync(() -> result.onComplete(r));
+        });
     }
 
     /**
@@ -121,38 +94,48 @@ public class CommandManager {
      * @param args the arguments provided
      * @return if the command was successful
      */
-    public boolean onCommand(Sender sender, String label, List<String> args) {
+    public CommandResult onCommand(Sender sender, String label, List<String> args) {
         if (args.size() == 0) {
             sendCommandUsage(sender, label);
-            return true;
+            return CommandResult.INVALID_ARGS;
         }
 
-        Optional<MainCommand> o = mainCommands.stream().filter(m -> m.getName().equalsIgnoreCase(args.get(0))).limit(1).findAny();
+        Optional<MainCommand> o = mainCommands.stream()
+                .filter(m -> m.getName().equalsIgnoreCase(args.get(0)))
+                .limit(1)
+                .findAny();
 
         if (!o.isPresent()) {
             sendCommandUsage(sender, label);
-            return true;
+            return CommandResult.INVALID_ARGS;
         }
 
         final MainCommand main = o.get();
         if (!main.isAuthorized(sender)) {
             sendCommandUsage(sender, label);
-            return true;
+            return CommandResult.NO_PERMISSION;
         }
 
         if (main.getRequiredArgsLength() == 0) {
-            main.execute(plugin, sender, null, label);
-            return true;
+            try {
+                return main.execute(plugin, sender, null, label);
+            } catch (Exception e) {
+                e.printStackTrace();
+                return CommandResult.FAILURE;
+            }
         }
 
         if (args.size() == 1) {
             main.sendUsage(sender, label);
-            return true;
+            return CommandResult.INVALID_ARGS;
         }
 
-        main.execute(plugin, sender, new ArrayList<>(args.subList(1, args.size())), label);
-        return true;
-
+        try {
+            return main.execute(plugin, sender, new ArrayList<>(args.subList(1, args.size())), label);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return CommandResult.FAILURE;
+        }
     }
 
     /**
@@ -163,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();
         }
@@ -182,11 +175,6 @@ public class CommandManager {
         return o.get().onTabComplete(sender, args.subList(1, args.size()), plugin);
     }
 
-    private void registerMainCommand(MainCommand command) {
-        plugin.getLog().info("[CommandManager] Registered main command '" + command.getName() + "'");
-        mainCommands.add(command);
-    }
-
     private void sendCommandUsage(Sender sender, String label) {
         Message.INFO_BRIEF.send(sender, plugin.getVersion());
 

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

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

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

@@ -22,10 +22,10 @@
 
 package me.lucko.luckperms.commands;
 
+import com.google.common.collect.ImmutableList;
+import lombok.AllArgsConstructor;
 import lombok.Getter;
-import lombok.RequiredArgsConstructor;
 import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.api.data.Callback;
 import me.lucko.luckperms.constants.Message;
 
 import java.util.ArrayList;
@@ -35,7 +35,7 @@ import java.util.Optional;
 import java.util.stream.Collectors;
 
 @Getter
-@RequiredArgsConstructor
+@AllArgsConstructor
 public abstract class MainCommand<T> {
 
     /**
@@ -57,7 +57,11 @@ public abstract class MainCommand<T> {
      * A list of the sub commands under this main command
      */
     @Getter
-    private final List<SubCommand<T>> subCommands = new ArrayList<>();
+    private final List<SubCommand<T>> subCommands;
+
+    MainCommand(String name, String usage, int requiredArgsLength) {
+        this(name, usage, requiredArgsLength, ImmutableList.of());
+    }
 
     /**
      * Called when this main command is ran
@@ -66,37 +70,47 @@ public abstract class MainCommand<T> {
      * @param args the stripped arguments given
      * @param label the command label used
      */
-    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
-        if (args.size() < 2) {
+    protected CommandResult execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
+        if (args.size() < requiredArgsLength) {
             sendUsage(sender, label);
-            return;
+            return CommandResult.INVALID_ARGS;
         }
 
-        Optional<SubCommand<T>> o = subCommands.stream().filter(s -> s.getName().equalsIgnoreCase(args.get(1))).limit(1).findAny();
+        Optional<SubCommand<T>> o = subCommands.stream()
+                .filter(s -> s.getName().equalsIgnoreCase(args.get(requiredArgsLength - 1)))
+                .limit(1)
+                .findAny();
 
         if (!o.isPresent()) {
             Message.COMMAND_NOT_RECOGNISED.send(sender);
-            return;
+            return CommandResult.INVALID_ARGS;
         }
 
         final SubCommand<T> sub = o.get();
         if (!sub.isAuthorized(sender)) {
             Message.COMMAND_NO_PERMISSION.send(sender);
-            return;
+            return CommandResult.NO_PERMISSION;
         }
 
         List<String> strippedArgs = new ArrayList<>();
-        if (args.size() > 2) {
-            strippedArgs.addAll(args.subList(2, args.size()));
+        if (args.size() > requiredArgsLength) {
+            strippedArgs.addAll(args.subList(requiredArgsLength, args.size()));
         }
 
         if (sub.getIsArgumentInvalid().test(strippedArgs.size())) {
             sub.sendUsage(sender, label);
-            return;
+            return CommandResult.INVALID_ARGS;
         }
 
         final String name = args.get(0).toLowerCase();
-        getTarget(name, plugin, sender, t -> sub.execute(plugin, sender, t, strippedArgs, label));
+        T t = getTarget(name, plugin, sender);
+        if (t != null) {
+            CommandResult result = sub.execute(plugin, sender, t, strippedArgs, label);
+            cleanup(t, plugin);
+            return result;
+        }
+
+        return CommandResult.LOADING_ERROR;
     }
 
     /**
@@ -104,12 +118,13 @@ public abstract class MainCommand<T> {
      * @param target the name of the object to be looked up
      * @param plugin a link to the main plugin instance
      * @param sender the user who send the command (used to send error messages if the lookup was unsuccessful)
-     * @param onSuccess the callback to run when the lookup is completed
      */
-    protected abstract void getTarget(String target, LuckPermsPlugin plugin, Sender sender, Callback<T> onSuccess);
+    protected abstract T getTarget(String target, LuckPermsPlugin plugin, Sender sender);
+
+    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
      */
@@ -126,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:");
 
@@ -156,28 +174,37 @@ 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();
         }
 
-        return o.get().onTabComplete(sender, args.subList(2, args.size()), plugin);
-    }
-
-    public void registerSubCommand(SubCommand<T> subCommand) {
-        subCommands.add(subCommand);
+        return o.get().onTabComplete(plugin, sender, args.subList(2, args.size()));
     }
 }

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

@@ -28,6 +28,7 @@ import java.util.Set;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
+@SuppressWarnings({"WeakerAccess", "unused"})
 @UtilityClass
 public class Predicate {
     public static <T> java.util.function.Predicate<T> alwaysFalse() {

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

@@ -22,12 +22,18 @@
 
 package me.lucko.luckperms.commands;
 
+import me.lucko.luckperms.constants.Permission;
+
+import java.util.UUID;
+
 /**
- * Wrapper class to represent a CommandSender in Bukkit/Bungee within the luckperms-common command implementations.
+ * Wrapper interface to represent a CommandSender/CommandSource within the luckperms-common command implementations.
  */
 public interface Sender {
 
+    String getName();
+    UUID getUuid();
     void sendMessage(String s);
-    boolean hasPermission(String node);
+    boolean hasPermission(Permission permission);
 
 }

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

@@ -22,31 +22,69 @@
 
 package me.lucko.luckperms.commands;
 
+import lombok.Getter;
+import me.lucko.luckperms.constants.Permission;
+
 import java.lang.ref.WeakReference;
+import java.util.*;
+import java.util.stream.Collectors;
 
-public abstract class SenderFactory<T> {
+/**
+ * Factory class to make a thread-safe sender instance
+ * @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 SenderFactory<T> factory = this;
+
+    protected abstract String getName(T t);
+    protected abstract UUID getUuid(T t);
     protected abstract void sendMessage(T t, String s);
     protected abstract boolean hasPermission(T t, String node);
 
-    public Sender wrap(T t) {
-        final SenderFactory<T> factory = this;
+    public final Sender wrap(T t) {
         return new Sender() {
-            final WeakReference<T> cs = new WeakReference<>(t);
+            final WeakReference<T> tRef = new WeakReference<>(t);
+
+            // Cache these permissions, so they can be accessed async
+            final Map<Permission, Boolean> perms = Arrays.stream(Permission.values())
+                    .map(p -> new AbstractMap.SimpleEntry<>(p, factory.hasPermission(t, p.getNode())))
+                    .collect(Collectors.toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue));
+
+            @Getter
+            final String name = factory.getName(t);
+
+            @Getter
+            final UUID uuid = factory.getUuid(t);
 
             @Override
             public void sendMessage(String s) {
-                final T c = cs.get();
-                if (c != null) {
-                    factory.sendMessage(c, s);
+                final T t = tRef.get();
+                if (t != null) {
+                    synchronized (tasks) {
+                        tasks.add(() -> factory.sendMessage(t, s));
+                    }
                 }
             }
 
             @Override
-            public boolean hasPermission(String node) {
-                final T c = cs.get();
-                return c != null && factory.hasPermission(c, node);
+            public boolean hasPermission(Permission permission) {
+                synchronized (perms) {
+                    return perms.get(permission);
+                }
             }
         };
     }
+
+    @Override
+    public final void run() {
+        synchronized (tasks) {
+            if (!tasks.isEmpty()) {
+                tasks.forEach(Runnable::run);
+                tasks.clear();
+            }
+        }
+    }
 }

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

@@ -23,7 +23,6 @@
 package me.lucko.luckperms.commands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.api.data.Callback;
 import me.lucko.luckperms.constants.Permission;
 
 import java.util.Collections;
@@ -41,13 +40,19 @@ public class SingleMainCommand extends MainCommand<Object> {
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
+    protected CommandResult execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
         // Do nothing, allow the implementation to override this
+        return null;
     }
 
     @Override
-    protected void getTarget(String target, LuckPermsPlugin plugin, Sender sender, Callback onSuccess) {
-        // Do nothing, don't run callback
+    protected Object getTarget(String target, LuckPermsPlugin plugin, Sender sender) {
+        return null;
+    }
+
+    @Override
+    protected void cleanup(Object o, LuckPermsPlugin plugin) {
+        // Do nothing
     }
 
     @Override

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

@@ -78,7 +78,19 @@ public abstract class SubCommand<T> {
      * @param args the stripped arguments given
      * @param label the command label used
      */
-    public abstract void execute(LuckPermsPlugin plugin, Sender sender, T t, List<String> args, String label);
+    public abstract CommandResult execute(LuckPermsPlugin plugin, Sender sender, T t, List<String> args, String label);
+
+    /**
+     * Returns a list of suggestions, which are empty by default. Sub classes that give tab complete suggestions override
+     * this method to give their own list.
+     * @param plugin the plugin instance
+     * @param sender who is tab completing
+     * @param args the arguments so far
+     * @return a list of suggestions
+     */
+    public List<String> onTabComplete(LuckPermsPlugin plugin, Sender sender, List<String> args) {
+        return Collections.emptyList();
+    }
 
     /**
      * Send the command usage to a sender
@@ -98,18 +110,6 @@ public abstract class SubCommand<T> {
         return permission.isAuthorized(sender);
     }
 
-    /**
-     * Returns a list of suggestions, which are empty by default. Sub classes that give tab complete suggestions override
-     * this method to give their own list.
-     * @param sender who is tab completing
-     * @param args the arguments so far
-     * @param plugin the plugin instance
-     * @return a list of suggestions
-     */
-    public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
-        return Collections.emptyList();
-    }
-
     /*
         ----------------------------------------------------------------------------------
         Utility methods used by #onTabComplete and #execute implementations in sub classes
@@ -117,11 +117,11 @@ public abstract class SubCommand<T> {
      */
 
     protected static List<String> getGroupTabComplete(List<String> args, LuckPermsPlugin plugin) {
-        return getTabComplete(new ArrayList<>(plugin.getGroupManager().getGroups().keySet()), args);
+        return getTabComplete(new ArrayList<>(plugin.getGroupManager().getAll().keySet()), args);
     }
 
     protected static List<String> getTrackTabComplete(List<String> args, LuckPermsPlugin plugin) {
-        return getTabComplete(new ArrayList<>(plugin.getTrackManager().getTracks().keySet()), args);
+        return getTabComplete(new ArrayList<>(plugin.getTrackManager().getAll().keySet()), args);
     }
 
     protected static List<String> getBoolTabComplete(List<String> args) {
@@ -144,39 +144,33 @@ public abstract class SubCommand<T> {
         return Collections.emptyList();
     }
 
-    protected static void saveUser(User user, Sender sender, LuckPermsPlugin plugin) {
+    protected static void save(User user, Sender sender, LuckPermsPlugin plugin) {
         user.refreshPermissions();
 
-        plugin.getDatastore().saveUser(user, success -> {
-            if (success) {
-                Message.USER_SAVE_SUCCESS.send(sender);
-            } else {
-                Message.USER_SAVE_ERROR.send(sender);
-            }
-        });
+        if (plugin.getDatastore().saveUser(user)) {
+            Message.USER_SAVE_SUCCESS.send(sender);
+        } else {
+            Message.USER_SAVE_ERROR.send(sender);
+        }
     }
 
-    protected static void saveGroup(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);
-            }
+    protected static void save(Group group, Sender sender, LuckPermsPlugin plugin) {
+        if (plugin.getDatastore().saveGroup(group)) {
+            Message.GROUP_SAVE_SUCCESS.send(sender);
+        } else {
+            Message.GROUP_SAVE_ERROR.send(sender);
+        }
 
-            plugin.runUpdateTask();
-        });
+        plugin.runUpdateTask();
     }
 
-    protected static void saveTrack(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);
-            }
+    protected static void save(Track track, Sender sender, LuckPermsPlugin plugin) {
+        if (plugin.getDatastore().saveTrack(track)) {
+            Message.TRACK_SAVE_SUCCESS.send(sender);
+        } else {
+            Message.TRACK_SAVE_ERROR.send(sender);
+        }
 
-            plugin.runUpdateTask();
-        });
+        plugin.runUpdateTask();
     }
 }

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

@@ -24,6 +24,7 @@ package me.lucko.luckperms.commands;
 
 import lombok.experimental.UtilityClass;
 import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.constants.Patterns;
 import me.lucko.luckperms.utils.DateUtil;
 
 import java.util.List;
@@ -55,12 +56,16 @@ public class Util {
         return new String(b);
     }
 
+    public static String stripColor(String s) {
+        return s == null ? null : Patterns.STRIP_COLOR_PATTERN.matcher(s).replaceAll("");
+    }
+
+    public static String formatBoolean(boolean b) {
+        return b ? "&atrue" : "&cfalse";
+    }
+
     public static void sendBoolean(Sender sender, String node, boolean b) {
-        if (b) {
-            sender.sendMessage(Util.color("&b" + node + ": &atrue"));
-        } else {
-            sender.sendMessage(Util.color("&b" + node + ": &cfalse"));
-        }
+        sender.sendMessage(Util.color("&b" + node + ": " + formatBoolean(b)));
     }
 
     public static String listToCommaSep(List<String> strings) {

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

@@ -23,11 +23,13 @@
 package me.lucko.luckperms.commands.group;
 
 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.utils.Patterns;
+import me.lucko.luckperms.data.LogEntry;
+import me.lucko.luckperms.utils.ArgumentChecker;
 
 import java.util.List;
 
@@ -37,37 +39,31 @@ public class CreateGroup extends SingleMainCommand {
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
+    protected CommandResult execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
         if (args.size() == 0) {
             sendUsage(sender, label);
-            return;
+            return CommandResult.INVALID_ARGS;
         }
 
         String groupName = args.get(0).toLowerCase();
-
-        if (groupName.length() > 36) {
-            Message.GROUP_NAME_TOO_LONG.send(sender, groupName);
-            return;
-        }
-
-        if (Patterns.NON_ALPHA_NUMERIC.matcher(groupName).find()) {
+        if (ArgumentChecker.checkName(groupName)) {
             Message.GROUP_INVALID_ENTRY.send(sender);
-            return;
+            return CommandResult.INVALID_ARGS;
         }
 
-        plugin.getDatastore().loadGroup(groupName, success -> {
-            if (success) {
-                Message.GROUP_ALREADY_EXISTS.send(sender);
-            } else {
-                plugin.getDatastore().createAndLoadGroup(groupName, success1 -> {
-                    if (!success1) {
-                        Message.CREATE_GROUP_ERROR.send(sender);
-                    } else {
-                        Message.CREATE_SUCCESS.send(sender, groupName);
-                        plugin.runUpdateTask();
-                    }
-                });
-            }
-        });
+        if (plugin.getDatastore().loadGroup(groupName)) {
+            Message.GROUP_ALREADY_EXISTS.send(sender);
+            return CommandResult.INVALID_ARGS;
+        }
+
+        if (!plugin.getDatastore().createAndLoadGroup(groupName)) {
+            Message.CREATE_GROUP_ERROR.send(sender);
+            return CommandResult.FAILURE;
+        }
+
+        Message.CREATE_SUCCESS.send(sender, groupName);
+        LogEntry.build().actor(sender).actedName(groupName).type('G').action("create").build().submit(plugin);
+        plugin.runUpdateTask();
+        return CommandResult.SUCCESS;
     }
 }

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

@@ -23,12 +23,14 @@
 package me.lucko.luckperms.commands.group;
 
 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.LogEntry;
 import me.lucko.luckperms.groups.Group;
-import me.lucko.luckperms.utils.Patterns;
+import me.lucko.luckperms.utils.ArgumentChecker;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -41,56 +43,57 @@ public class DeleteGroup extends SingleMainCommand {
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
+    protected CommandResult execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
         if (args.size() == 0) {
             sendUsage(sender, label);
-            return;
+            return CommandResult.INVALID_ARGS;
         }
 
         String groupName = args.get(0).toLowerCase();
 
         if (groupName.equalsIgnoreCase(plugin.getConfiguration().getDefaultGroupName())) {
             Message.DELETE_GROUP_ERROR_DEFAULT.send(sender);
-            return;
+            return CommandResult.INVALID_ARGS;
         }
 
-        if (Patterns.NON_ALPHA_NUMERIC.matcher(groupName).find()) {
+        if (ArgumentChecker.checkName(groupName)) {
             Message.GROUP_INVALID_ENTRY.send(sender);
-            return;
+            return CommandResult.INVALID_ARGS;
         }
 
-        plugin.getDatastore().loadGroup(groupName, success -> {
-            if (!success) {
-                Message.GROUP_DOES_NOT_EXIST.send(sender);
-            } else {
+        if (!plugin.getDatastore().loadGroup(groupName)) {
+            Message.GROUP_DOES_NOT_EXIST.send(sender);
+            return CommandResult.INVALID_ARGS;
+        }
 
-                Group group = plugin.getGroupManager().getGroup(groupName);
-                if (group == null) {
-                    Message.GROUP_LOAD_ERROR.send(sender);
-                } else {
-                    plugin.getDatastore().deleteGroup(group, success1 -> {
-                        if (!success1) {
-                            Message.DELETE_GROUP_ERROR.send(sender);
-                        } else {
-                            Message.DELETE_SUCCESS.send(sender, groupName);
-                            plugin.runUpdateTask();
-                        }
-                    });
-                }
-            }
-        });
+        Group group = plugin.getGroupManager().get(groupName);
+        if (group == 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;
+        }
+
+        Message.DELETE_SUCCESS.send(sender, groupName);
+        LogEntry.build().actor(sender).actedName(groupName).type('G').action("delete").build().submit(plugin);
+        plugin.runUpdateTask();
+        return CommandResult.SUCCESS;
     }
 
     @Override
     protected List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
-        final List<String> groups = new ArrayList<>(plugin.getGroupManager().getGroups().keySet());
+        final List<String> groups = new ArrayList<>(plugin.getGroupManager().getAll().keySet());
 
         if (args.size() <= 1) {
             if (args.isEmpty() || args.get(0).equalsIgnoreCase("")) {
                 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

@@ -22,47 +22,68 @@
 
 package me.lucko.luckperms.commands.group;
 
+import com.google.common.collect.ImmutableList;
 import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.api.data.Callback;
 import me.lucko.luckperms.commands.MainCommand;
 import me.lucko.luckperms.commands.Sender;
+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.Patterns;
+import me.lucko.luckperms.utils.ArgumentChecker;
 
 import java.util.ArrayList;
 import java.util.List;
 
 public class GroupMainCommand extends MainCommand<Group> {
     public GroupMainCommand() {
-        super("Group", "/%s group <group>", 2);
+        super("Group", "/%s group <group>", 2, ImmutableList.<SubCommand<Group>>builder()
+            .add(new GroupInfo())
+            .add(new GroupListNodes())
+            .add(new GroupHasPerm())
+            .add(new GroupInheritsPerm())
+            .add(new GroupSetPermission())
+            .add(new GroupUnSetPermission())
+            .add(new GroupSetInherit())
+            .add(new GroupUnsetInherit())
+            .add(new GroupSetTempPermission())
+            .add(new GroupUnsetTempPermission())
+            .add(new GroupSetTempInherit())
+            .add(new GroupUnsetTempInherit())
+            .add(new GroupShowTracks())
+            .add(new GroupClear())
+            .build()
+        );
     }
 
     @Override
-    protected void getTarget(String target, LuckPermsPlugin plugin, Sender sender, Callback<Group> onSuccess) {
-        if (Patterns.NON_ALPHA_NUMERIC.matcher(target).find()) {
+    protected Group getTarget(String target, LuckPermsPlugin plugin, Sender sender) {
+        if (ArgumentChecker.checkName(target)) {
             Message.GROUP_INVALID_ENTRY.send(sender);
-            return;
+            return null;
         }
 
-        plugin.getDatastore().loadGroup(target, success -> {
-            if (!success) {
-                Message.GROUP_NOT_FOUND.send(sender);
-                return;
-            }
+        if (!plugin.getDatastore().loadGroup(target)) {
+            Message.GROUP_NOT_FOUND.send(sender);
+            return null;
+        }
 
-            Group group = plugin.getGroupManager().getGroup(target);
-            if (group == null) {
-                Message.GROUP_NOT_FOUND.send(sender);
-                return;
-            }
+        Group group = plugin.getGroupManager().get(target);
+
+        if (group == null) {
+            Message.GROUP_NOT_FOUND.send(sender);
+        }
+
+        return group;
+    }
+
+    @Override
+    protected void cleanup(Group group, LuckPermsPlugin plugin) {
 
-            onSuccess.onComplete(group);
-        });
     }
 
     @Override
     protected List<String> getObjects(LuckPermsPlugin plugin) {
-        return new ArrayList<>(plugin.getGroupManager().getGroups().keySet());
+        return new ArrayList<>(plugin.getGroupManager().getAll().keySet());
     }
 }

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

@@ -23,6 +23,7 @@
 package me.lucko.luckperms.commands.group;
 
 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.commands.Util;
@@ -38,13 +39,13 @@ public class ListGroups extends SingleMainCommand {
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
-        plugin.getDatastore().loadAllGroups(success -> {
-            if (!success) {
-                Message.GROUPS_LOAD_ERROR.send(sender);
-            } else {
-                Message.GROUPS_LIST.send(sender, Util.listToCommaSep(new ArrayList<>(plugin.getGroupManager().getGroups().keySet())));
-            }
-        });
+    protected CommandResult execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
+        if (!plugin.getDatastore().loadAllGroups()) {
+            Message.GROUPS_LOAD_ERROR.send(sender);
+            return CommandResult.LOADING_ERROR;
+        }
+
+        Message.GROUPS_LIST.send(sender, Util.listToCommaSep(new ArrayList<>(plugin.getGroupManager().getAll().keySet())));
+        return CommandResult.SUCCESS;
     }
 }

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

@@ -23,11 +23,13 @@
 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 java.util.List;
@@ -39,10 +41,11 @@ public class GroupClear extends SubCommand<Group> {
     }
 
     @Override
-    public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
         group.clearNodes();
         Message.CLEAR_SUCCESS.send(sender, group.getName());
-
-        saveGroup(group, sender, plugin);
+        LogEntry.build().actor(sender).acted(group).action("clear").build().submit(plugin);
+        save(group, sender, plugin);
+        return CommandResult.SUCCESS;
     }
 }

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

@@ -23,14 +23,11 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.commands.Predicate;
-import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
-import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.*;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.groups.Group;
-import me.lucko.luckperms.utils.Patterns;
+import me.lucko.luckperms.utils.ArgumentChecker;
 
 import java.util.List;
 
@@ -42,11 +39,11 @@ public class GroupHasPerm extends SubCommand<Group> {
     }
 
     @Override
-    public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
         if (args.size() >= 2) {
-            if (Patterns.NON_ALPHA_NUMERIC.matcher(args.get(1)).find()) {
+            if (ArgumentChecker.checkServer(args.get(1))) {
                 Message.SERVER_INVALID_ENTRY.send(sender);
-                return;
+                return CommandResult.INVALID_ARGS;
             }
 
             if (args.size() == 2) {
@@ -58,5 +55,6 @@ public class GroupHasPerm extends SubCommand<Group> {
         } else {
             Util.sendBoolean(sender, args.get(0), group.hasPermission(args.get(0), true, "global"));
         }
+        return CommandResult.SUCCESS;
     }
 }

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

@@ -23,6 +23,7 @@
 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;
@@ -39,8 +40,14 @@ public class GroupInfo extends SubCommand<Group> {
     }
 
     @Override
-    public void 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(), label, group.getName());
+    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(),
+                label,
+                group.getName()
+        );
+        return CommandResult.SUCCESS;
     }
 }

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

@@ -23,14 +23,11 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.commands.Predicate;
-import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
-import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.*;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.groups.Group;
-import me.lucko.luckperms.utils.Patterns;
+import me.lucko.luckperms.utils.ArgumentChecker;
 
 import java.util.List;
 
@@ -42,11 +39,11 @@ public class GroupInheritsPerm extends SubCommand<Group> {
     }
 
     @Override
-    public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
         if (args.size() >= 2) {
-            if (Patterns.NON_ALPHA_NUMERIC.matcher(args.get(1)).find()) {
+            if (ArgumentChecker.checkServer(args.get(1))) {
                 Message.SERVER_INVALID_ENTRY.send(sender);
-                return;
+                return CommandResult.INVALID_ARGS;
             }
 
             if (args.size() == 2) {
@@ -58,5 +55,6 @@ public class GroupInheritsPerm extends SubCommand<Group> {
         } else {
             Util.sendBoolean(sender, args.get(0), group.inheritsPermission(args.get(0), true));
         }
+        return CommandResult.SUCCESS;
     }
 }

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

@@ -23,10 +23,7 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.commands.Predicate;
-import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
-import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.*;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.groups.Group;
@@ -40,8 +37,9 @@ public class GroupListNodes extends SubCommand<Group> {
     }
 
     @Override
-    public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+    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()));
+        return CommandResult.SUCCESS;
     }
 }

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

@@ -23,14 +23,16 @@
 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.exceptions.ObjectAlreadyHasException;
 import me.lucko.luckperms.groups.Group;
-import me.lucko.luckperms.utils.Patterns;
+import me.lucko.luckperms.utils.ArgumentChecker;
 
 import java.util.List;
 
@@ -42,50 +44,66 @@ public class GroupSetInherit extends SubCommand<Group> {
     }
 
     @Override
-    public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
         String groupName = args.get(0).toLowerCase();
 
-        if (groupName.contains("/") || groupName.contains("$")) {
+        if (ArgumentChecker.checkNode(groupName)) {
             sendUsage(sender, label);
-            return;
+            return CommandResult.INVALID_ARGS;
         }
 
-        plugin.getDatastore().loadGroup(groupName, success -> {
-            if (!success) {
-                Message.GROUP_LOAD_ERROR.send(sender);
-            } else {
-                try {
-                    if (args.size() >= 2) {
-                        final String server = args.get(1).toLowerCase();
-                        if (Patterns.NON_ALPHA_NUMERIC.matcher(server).find()) {
-                            Message.SERVER_INVALID_ENTRY.send(sender);
-                            return;
-                        }
+        if (!plugin.getDatastore().loadGroup(groupName)) {
+            Message.GROUP_DOES_NOT_EXIST.send(sender);
+            return CommandResult.INVALID_ARGS;
+        }
 
-                        if (args.size() == 2) {
-                            group.setPermission("group." + groupName, true, server);
-                            Message.GROUP_SETINHERIT_SERVER_SUCCESS.send(sender, group.getName(), groupName, server);
-                        } else {
-                            final String world = args.get(2).toLowerCase();
-                            group.setPermission("group." + groupName, true, server, world);
-                            Message.GROUP_SETINHERIT_SERVER_WORLD_SUCCESS.send(sender, group.getName(), groupName, server, world);
-                        }
+        Group group1 = plugin.getGroupManager().get(groupName);
+        if (group1 == null) {
+            Message.GROUP_DOES_NOT_EXIST.send(sender);
+            return CommandResult.LOADING_ERROR;
+        }
 
-                    } else {
-                        group.setPermission("group." + groupName, true);
-                        Message.GROUP_SETINHERIT_SUCCESS.send(sender, group.getName(), groupName);
-                    }
-
-                    saveGroup(group, sender, plugin);
-                } catch (ObjectAlreadyHasException e) {
-                    Message.GROUP_ALREADY_INHERITS.send(sender, group.getName(), groupName);
+        try {
+            if (args.size() >= 2) {
+                final String server = args.get(1).toLowerCase();
+                if (ArgumentChecker.checkServer(server)) {
+                    Message.SERVER_INVALID_ENTRY.send(sender);
+                    return CommandResult.INVALID_ARGS;
                 }
+
+                if (args.size() == 2) {
+                    group.setInheritGroup(group1, server);
+                    Message.GROUP_SETINHERIT_SERVER_SUCCESS.send(sender, group.getName(), group1.getName(), server);
+                    LogEntry.build().actor(sender).acted(group)
+                            .action("setinherit " + group1.getName() + " " + server)
+                            .build().submit(plugin);
+                } 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);
+                    LogEntry.build().actor(sender).acted(group)
+                            .action("setinherit " + group1.getName() + " " + server + " " + world)
+                            .build().submit(plugin);
+                }
+
+            } else {
+                group.setInheritGroup(group1);
+                Message.GROUP_SETINHERIT_SUCCESS.send(sender, group.getName(), group1.getName());
+                LogEntry.build().actor(sender).acted(group)
+                        .action("setinherit " + group1.getName())
+                        .build().submit(plugin);
             }
-        });
+
+            save(group, sender, plugin);
+            return CommandResult.SUCCESS;
+        } catch (ObjectAlreadyHasException e) {
+            Message.GROUP_ALREADY_INHERITS.send(sender, group.getName(), group1.getName());
+            return CommandResult.STATE_ERROR;
+        }
     }
 
     @Override
-    public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+    public List<String> onTabComplete(LuckPermsPlugin plugin, Sender sender, List<String> args) {
         return getGroupTabComplete(args, plugin);
     }
 }

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

@@ -23,14 +23,17 @@
 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.Patterns;
 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.utils.Patterns;
+import me.lucko.luckperms.utils.ArgumentChecker;
 
 import java.util.List;
 
@@ -41,23 +44,23 @@ public class GroupSetPermission extends SubCommand<Group> {
     }
 
     @Override
-    public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
         String node = args.get(0);
         String bool = args.get(1).toLowerCase();
 
-        if (node.contains("/") || node.contains("$")) {
+        if (ArgumentChecker.checkNode(node)) {
             sendUsage(sender, label);
-            return;
+            return CommandResult.INVALID_ARGS;
         }
 
         if (Patterns.GROUP_MATCH.matcher(node).matches()) {
             Message.GROUP_USE_INHERIT.send(sender);
-            return;
+            return CommandResult.INVALID_ARGS;
         }
 
         if (!bool.equalsIgnoreCase("true") && !bool.equalsIgnoreCase("false")) {
             sendUsage(sender, label);
-            return;
+            return CommandResult.INVALID_ARGS;
         }
 
         boolean b = Boolean.parseBoolean(bool);
@@ -65,33 +68,44 @@ public class GroupSetPermission extends SubCommand<Group> {
         try {
             if (args.size() >= 3) {
                 final String server = args.get(2).toLowerCase();
-                if (Patterns.NON_ALPHA_NUMERIC.matcher(server).find()) {
+                if (ArgumentChecker.checkServer(server)) {
                     Message.SERVER_INVALID_ENTRY.send(sender);
-                    return;
+                    return CommandResult.INVALID_ARGS;
                 }
 
                 if (args.size() == 3) {
                     group.setPermission(node, b, server);
                     Message.SETPERMISSION_SERVER_SUCCESS.send(sender, node, bool, group.getName(), server);
+                    LogEntry.build().actor(sender).acted(group)
+                            .action("set " + node + " " + b + " " + server)
+                            .build().submit(plugin);
                 } 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);
+                    LogEntry.build().actor(sender).acted(group)
+                            .action("set " + node + " " + b + " " + server + " " + world)
+                            .build().submit(plugin);
                 }
 
             } else {
                 group.setPermission(node, b);
                 Message.SETPERMISSION_SUCCESS.send(sender, node, bool, group.getName());
+                LogEntry.build().actor(sender).acted(group)
+                        .action("set " + node + " " + b)
+                        .build().submit(plugin);
             }
 
-            saveGroup(group, sender, plugin);
+            save(group, sender, plugin);
+            return CommandResult.SUCCESS;
         } catch (ObjectAlreadyHasException e) {
             Message.ALREADY_HASPERMISSION.send(sender, group.getName());
+            return CommandResult.STATE_ERROR;
         }
     }
 
     @Override
-    public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+    public List<String> onTabComplete(LuckPermsPlugin plugin, Sender sender, List<String> args) {
         return getBoolTabComplete(args);
     }
 }

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

@@ -23,15 +23,17 @@
 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.exceptions.ObjectAlreadyHasException;
 import me.lucko.luckperms.groups.Group;
+import me.lucko.luckperms.utils.ArgumentChecker;
 import me.lucko.luckperms.utils.DateUtil;
-import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
@@ -43,65 +45,85 @@ public class GroupSetTempInherit extends SubCommand<Group> {
     }
 
     @Override
-    public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
         String groupName = args.get(0).toLowerCase();
 
-        if (groupName.contains("/") || groupName.contains("$")) {
+        if (ArgumentChecker.checkNode(groupName)) {
             sendUsage(sender, label);
-            return;
+            return CommandResult.INVALID_ARGS;
         }
 
         long duration;
         try {
-            duration = DateUtil.parseDateDiff(args.get(1), true);
-        } catch (DateUtil.IllegalDateException e) {
-            Message.ILLEGAL_DATE_ERROR.send(sender, args.get(1));
-            return;
+            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)) {
             Message.PAST_DATE_ERROR.send(sender);
-            return;
+            return CommandResult.INVALID_ARGS;
         }
 
-        plugin.getDatastore().loadGroup(groupName, success -> {
-            if (!success) {
-                Message.GROUP_LOAD_ERROR.send(sender);
-            } else {
-                try {
-                    if (args.size() >= 3) {
-                        final String server = args.get(2).toLowerCase();
-                        if (Patterns.NON_ALPHA_NUMERIC.matcher(server).find()) {
-                            Message.SERVER_INVALID_ENTRY.send(sender);
-                            return;
-                        }
+        if (!plugin.getDatastore().loadGroup(groupName)) {
+            Message.GROUP_DOES_NOT_EXIST.send(sender);
+            return CommandResult.INVALID_ARGS;
+        }
 
-                        if (args.size() == 3) {
-                            group.setPermission("group." + groupName, true, server, duration);
-                            Message.GROUP_SET_TEMP_INHERIT_SERVER_SUCCESS.send(sender, group.getName(), groupName, server,
-                                    DateUtil.formatDateDiff(duration));
-                        } else {
-                            final String world = args.get(3).toLowerCase();
-                            group.setPermission("group." + groupName, true, server, world, duration);
-                            Message.GROUP_SET_TEMP_INHERIT_SERVER_WORLD_SUCCESS.send(sender, group.getName(), groupName, server,
-                                    world, DateUtil.formatDateDiff(duration));
-                        }
+        Group group1 = plugin.getGroupManager().get(groupName);
+        if (group1 == null) {
+            Message.GROUP_DOES_NOT_EXIST.send(sender);
+            return CommandResult.INVALID_ARGS;
+        }
 
-                    } else {
-                        group.setPermission("group." + groupName, true, duration);
-                        Message.GROUP_SET_TEMP_INHERIT_SUCCESS.send(sender, group.getName(), groupName, DateUtil.formatDateDiff(duration));
-                    }
-
-                    saveGroup(group, sender, plugin);
-                } catch (ObjectAlreadyHasException e) {
-                    Message.GROUP_ALREADY_TEMP_INHERITS.send(sender, group.getName(), groupName);
+        try {
+            if (args.size() >= 3) {
+                final String server = args.get(2).toLowerCase();
+                if (ArgumentChecker.checkServer(server)) {
+                    Message.SERVER_INVALID_ENTRY.send(sender);
+                    return CommandResult.INVALID_ARGS;
                 }
+
+                if (args.size() == 3) {
+                    group.setInheritGroup(group1, server, duration);
+                    Message.GROUP_SET_TEMP_INHERIT_SERVER_SUCCESS.send(sender, group.getName(), group1.getName(), server,
+                            DateUtil.formatDateDiff(duration));
+                    LogEntry.build().actor(sender).acted(group)
+                            .action("settempinherit " + group1.getName() + " " + duration + " " + server)
+                            .build().submit(plugin);
+                } 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));
+                    LogEntry.build().actor(sender).acted(group)
+                            .action("settempinherit " + group1.getName() + " " + duration + " " + server + " " + world)
+                            .build().submit(plugin);
+                }
+
+            } else {
+                group.setInheritGroup(group1, duration);
+                Message.GROUP_SET_TEMP_INHERIT_SUCCESS.send(sender, group.getName(), group1.getName(), DateUtil.formatDateDiff(duration));
+                LogEntry.build().actor(sender).acted(group)
+                        .action("settempinherit " + group1.getName() + " " + duration)
+                        .build().submit(plugin);
             }
-        });
+
+            save(group, sender, plugin);
+            return CommandResult.SUCCESS;
+        } catch (ObjectAlreadyHasException e) {
+            Message.USER_ALREADY_TEMP_MEMBER_OF.send(sender, group.getName(), group1.getName());
+            return CommandResult.STATE_ERROR;
+        }
     }
 
     @Override
-    public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+    public List<String> onTabComplete(LuckPermsPlugin plugin, Sender sender, List<String> args) {
         return getGroupTabComplete(args, plugin);
     }
 }

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

@@ -23,15 +23,18 @@
 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.Patterns;
 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.utils.ArgumentChecker;
 import me.lucko.luckperms.utils.DateUtil;
-import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
@@ -43,72 +46,87 @@ public class GroupSetTempPermission extends SubCommand<Group> {
     }
 
     @Override
-    public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
         String node = args.get(0);
         String bool = args.get(1).toLowerCase();
 
-        if (node.contains("/") || node.contains("$")) {
+        if (ArgumentChecker.checkNode(node)) {
             sendUsage(sender, label);
-            return;
+            return CommandResult.INVALID_ARGS;
         }
 
         if (Patterns.GROUP_MATCH.matcher(node).matches()) {
             Message.GROUP_USE_INHERIT.send(sender);
-            return;
+            return CommandResult.INVALID_ARGS;
         }
 
         if (!bool.equalsIgnoreCase("true") && !bool.equalsIgnoreCase("false")) {
             sendUsage(sender, label);
-            return;
+            return CommandResult.INVALID_ARGS;
         }
 
         boolean b = Boolean.parseBoolean(bool);
 
         long duration;
         try {
-            duration = DateUtil.parseDateDiff(args.get(2), true);
-        } catch (DateUtil.IllegalDateException e) {
-            Message.ILLEGAL_DATE_ERROR.send(sender, args.get(2));
-            return;
+            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)) {
             Message.PAST_DATE_ERROR.send(sender);
-            return;
+            return CommandResult.INVALID_ARGS;
         }
 
         try {
             if (args.size() >= 4) {
                 final String server = args.get(3).toLowerCase();
-                if (Patterns.NON_ALPHA_NUMERIC.matcher(server).find()) {
+                if (ArgumentChecker.checkServer(server)) {
                     Message.SERVER_INVALID_ENTRY.send(sender);
-                    return;
+                    return CommandResult.INVALID_ARGS;
                 }
 
                 if (args.size() == 4) {
                     group.setPermission(node, b, server, duration);
                     Message.SETPERMISSION_TEMP_SERVER_SUCCESS.send(sender, node, bool, group.getName(), server,
                             DateUtil.formatDateDiff(duration));
+                    LogEntry.build().actor(sender).acted(group)
+                            .action("settemp " + node + " " + b + " " + duration + " " + server)
+                            .build().submit(plugin);
                 } 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));
+                    LogEntry.build().actor(sender).acted(group)
+                            .action("settemp " + node + " " + b + " " + duration + " " + server + " " + world)
+                            .build().submit(plugin);
                 }
 
             } else {
                 group.setPermission(node, b, duration);
                 Message.SETPERMISSION_TEMP_SUCCESS.send(sender, node, bool, group.getName(), DateUtil.formatDateDiff(duration));
+                LogEntry.build().actor(sender).acted(group)
+                        .action("settemp " + node + " " + b + " " + duration)
+                        .build().submit(plugin);
             }
 
-            saveGroup(group, sender, plugin);
+            save(group, sender, plugin);
+            return CommandResult.SUCCESS;
         } catch (ObjectAlreadyHasException e) {
             Message.ALREADY_HAS_TEMP_PERMISSION.send(sender, group.getName());
+            return CommandResult.STATE_ERROR;
         }
     }
 
     @Override
-    public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+    public List<String> onTabComplete(LuckPermsPlugin plugin, Sender sender, List<String> args) {
         return getBoolTabComplete(args);
     }
 }

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

@@ -23,10 +23,7 @@
 package me.lucko.luckperms.commands.group.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.commands.Predicate;
-import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
-import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.*;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.groups.Group;
@@ -42,15 +39,19 @@ public class GroupShowTracks extends SubCommand<Group> {
     }
 
     @Override
-    public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
-        plugin.getDatastore().loadAllTracks(success -> {
-            if (!success) {
-                Message.TRACKS_LOAD_ERROR.send(sender);
-                return;
-            }
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+        if (!plugin.getDatastore().loadAllTracks()) {
+            Message.TRACKS_LOAD_ERROR.send(sender);
+            return CommandResult.LOADING_ERROR;
+        }
 
-            Message.TRACKS_LIST.send(sender, Util.listToCommaSep(
-                    plugin.getTrackManager().getApplicableTracks(group.getName()).stream().map(Track::getName).collect(Collectors.toList())));
-        });
+        Message.TRACKS_LIST.send(sender,
+                Util.listToCommaSep(plugin.getTrackManager().getApplicableTracks(group.getName()).stream()
+                        .map(Track::getName)
+                        .collect(Collectors.toList())
+                )
+        );
+
+        return CommandResult.SUCCESS;
     }
 }

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

@@ -23,14 +23,17 @@
 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.Patterns;
 import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.data.LogEntry;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
 import me.lucko.luckperms.groups.Group;
-import me.lucko.luckperms.utils.Patterns;
+import me.lucko.luckperms.utils.ArgumentChecker;
 
 import java.util.List;
 
@@ -41,44 +44,55 @@ public class GroupUnSetPermission extends SubCommand<Group> {
     }
 
     @Override
-    public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
         String node = args.get(0);
 
-        if (node.contains("/") || node.contains("$")) {
+        if (ArgumentChecker.checkNode(node)) {
             sendUsage(sender, label);
-            return;
+            return CommandResult.INVALID_ARGS;
         }
 
         if (Patterns.GROUP_MATCH.matcher(node).matches()) {
             Message.GROUP_USE_UNINHERIT.send(sender);
-            return;
+            return CommandResult.INVALID_ARGS;
         }
 
         try {
             if (args.size() >= 2) {
                 final String server = args.get(1).toLowerCase();
-                if (Patterns.NON_ALPHA_NUMERIC.matcher(server).find()) {
+                if (ArgumentChecker.checkServer(server)) {
                     Message.SERVER_INVALID_ENTRY.send(sender);
-                    return;
+                    return CommandResult.INVALID_ARGS;
                 }
 
                 if (args.size() == 2) {
                     group.unsetPermission(node, server);
                     Message.UNSETPERMISSION_SERVER_SUCCESS.send(sender, node, group.getName(), server);
+                    LogEntry.build().actor(sender).acted(group)
+                            .action("unset " + node + " " + server)
+                            .build().submit(plugin);
                 } 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);
+                    LogEntry.build().actor(sender).acted(group)
+                            .action("unset " + node + " " + server + " " + world)
+                            .build().submit(plugin);
                 }
 
             } else {
                 group.unsetPermission(node);
                 Message.UNSETPERMISSION_SUCCESS.send(sender, node, group.getName());
+                LogEntry.build().actor(sender).acted(group)
+                        .action("unset " + node)
+                        .build().submit(plugin);
             }
 
-            saveGroup(group, sender, plugin);
+            save(group, sender, plugin);
+            return CommandResult.SUCCESS;
         } catch (ObjectLacksException e) {
             Message.DOES_NOT_HAVEPERMISSION.send(sender, group.getName());
+            return CommandResult.STATE_ERROR;
         }
     }
 }

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

@@ -23,14 +23,16 @@
 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.exceptions.ObjectLacksException;
 import me.lucko.luckperms.groups.Group;
-import me.lucko.luckperms.utils.Patterns;
+import me.lucko.luckperms.utils.ArgumentChecker;
 
 import java.util.List;
 
@@ -42,44 +44,55 @@ public class GroupUnsetInherit extends SubCommand<Group> {
     }
 
     @Override
-    public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
         String groupName = args.get(0).toLowerCase();
 
-        if (groupName.contains("/") || groupName.contains("$")) {
+        if (ArgumentChecker.checkNode(groupName)) {
             sendUsage(sender, label);
-            return;
+            return CommandResult.INVALID_ARGS;
         }
 
         try {
             if (args.size() >= 2) {
                 final String server = args.get(1).toLowerCase();
-                if (Patterns.NON_ALPHA_NUMERIC.matcher(server).find()) {
+                if (ArgumentChecker.checkServer(server)) {
                     Message.SERVER_INVALID_ENTRY.send(sender);
-                    return;
+                    return CommandResult.INVALID_ARGS;
                 }
 
                 if (args.size() == 2) {
                     group.unsetPermission("group." + groupName, server);
                     Message.GROUP_UNSETINHERIT_SERVER_SUCCESS.send(sender, group.getName(), groupName, server);
+                    LogEntry.build().actor(sender).acted(group)
+                            .action("unsetinherit " + groupName + " " + server)
+                            .build().submit(plugin);
                 } 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);
+                    LogEntry.build().actor(sender).acted(group)
+                            .action("unsetinherit " + groupName + " " + server + " " + world)
+                            .build().submit(plugin);
                 }
 
             } else {
                 group.unsetPermission("group." + groupName);
                 Message.GROUP_UNSETINHERIT_SUCCESS.send(sender, group.getName(), groupName);
+                LogEntry.build().actor(sender).acted(group)
+                        .action("unsetinherit " + groupName)
+                        .build().submit(plugin);
             }
 
-            saveGroup(group, sender, plugin);
+            save(group, sender, plugin);
+            return CommandResult.SUCCESS;
         } catch (ObjectLacksException e) {
             Message.GROUP_DOES_NOT_INHERIT.send(sender, group.getName(), groupName);
+            return CommandResult.STATE_ERROR;
         }
     }
 
     @Override
-    public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+    public List<String> onTabComplete(LuckPermsPlugin plugin, Sender sender, List<String> args) {
         return getGroupTabComplete(args, plugin);
     }
 }

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

@@ -23,14 +23,16 @@
 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.exceptions.ObjectLacksException;
 import me.lucko.luckperms.groups.Group;
-import me.lucko.luckperms.utils.Patterns;
+import me.lucko.luckperms.utils.ArgumentChecker;
 
 import java.util.List;
 
@@ -42,44 +44,55 @@ public class GroupUnsetTempInherit extends SubCommand<Group> {
     }
 
     @Override
-    public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
         String groupName = args.get(0).toLowerCase();
 
-        if (groupName.contains("/") || groupName.contains("$")) {
+        if (ArgumentChecker.checkNode(groupName)) {
             sendUsage(sender, label);
-            return;
+            return CommandResult.INVALID_ARGS;
         }
 
         try {
             if (args.size() >= 2) {
                 final String server = args.get(1).toLowerCase();
-                if (Patterns.NON_ALPHA_NUMERIC.matcher(server).find()) {
+                if (ArgumentChecker.checkServer(server)) {
                     Message.SERVER_INVALID_ENTRY.send(sender);
-                    return;
+                    return CommandResult.INVALID_ARGS;
                 }
 
                 if (args.size() == 2) {
                     group.unsetPermission("group." + groupName, server, true);
                     Message.GROUP_UNSET_TEMP_INHERIT_SERVER_SUCCESS.send(sender, group.getName(), groupName, server);
+                    LogEntry.build().actor(sender).acted(group)
+                            .action("unsettempinherit " + groupName + " " + server)
+                            .build().submit(plugin);
                 } 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);
+                    LogEntry.build().actor(sender).acted(group)
+                            .action("unsettempinherit " + groupName + " " + server + " " + world)
+                            .build().submit(plugin);
                 }
 
             } else {
                 group.unsetPermission("group." + groupName, true);
                 Message.GROUP_UNSET_TEMP_INHERIT_SUCCESS.send(sender, group.getName(), groupName);
+                LogEntry.build().actor(sender).acted(group)
+                        .action("unsettempinherit " + groupName)
+                        .build().submit(plugin);
             }
 
-            saveGroup(group, sender, plugin);
+            save(group, sender, plugin);
+            return CommandResult.SUCCESS;
         } catch (ObjectLacksException e) {
             Message.GROUP_DOES_NOT_TEMP_INHERIT.send(sender, group.getName(), groupName);
+            return CommandResult.STATE_ERROR;
         }
     }
 
     @Override
-    public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+    public List<String> onTabComplete(LuckPermsPlugin plugin, Sender sender, List<String> args) {
         return getGroupTabComplete(args, plugin);
     }
 }

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

@@ -23,14 +23,17 @@
 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.Patterns;
 import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.data.LogEntry;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
 import me.lucko.luckperms.groups.Group;
-import me.lucko.luckperms.utils.Patterns;
+import me.lucko.luckperms.utils.ArgumentChecker;
 
 import java.util.List;
 
@@ -42,44 +45,55 @@ public class GroupUnsetTempPermission extends SubCommand<Group> {
     }
 
     @Override
-    public void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args, String label) {
         String node = args.get(0);
 
-        if (node.contains("/") || node.contains("$")) {
+        if (ArgumentChecker.checkNode(node)) {
             sendUsage(sender, label);
-            return;
+            return CommandResult.INVALID_ARGS;
         }
 
         if (Patterns.GROUP_MATCH.matcher(node).matches()) {
             Message.GROUP_USE_UNINHERIT.send(sender);
-            return;
+            return CommandResult.INVALID_ARGS;
         }
 
         try {
             if (args.size() >= 2) {
                 final String server = args.get(1).toLowerCase();
-                if (Patterns.NON_ALPHA_NUMERIC.matcher(server).find()) {
+                if (ArgumentChecker.checkServer(server)) {
                     Message.SERVER_INVALID_ENTRY.send(sender);
-                    return;
+                    return CommandResult.INVALID_ARGS;
                 }
 
                 if (args.size() == 2) {
                     group.unsetPermission(node, server);
                     Message.UNSET_TEMP_PERMISSION_SERVER_SUCCESS.send(sender, node, group.getName(), server);
+                    LogEntry.build().actor(sender).acted(group)
+                            .action("unsettemp " + node + " " + server)
+                            .build().submit(plugin);
                 } 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);
+                    LogEntry.build().actor(sender).acted(group)
+                            .action("unsettemp " + node + " " + server + " " + world)
+                            .build().submit(plugin);
                 }
 
             } else {
                 group.unsetPermission(node, true);
                 Message.UNSET_TEMP_PERMISSION_SUCCESS.send(sender, node, group.getName());
+                LogEntry.build().actor(sender).acted(group)
+                        .action("unsettemp " + node)
+                        .build().submit(plugin);
             }
 
-            saveGroup(group, sender, plugin);
+            save(group, sender, plugin);
+            return CommandResult.SUCCESS;
         } catch (ObjectLacksException e) {
             Message.DOES_NOT_HAVE_TEMP_PERMISSION.send(sender, group.getName());
+            return CommandResult.STATE_ERROR;
         }
     }
 }

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

@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 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.log;
+
+import com.google.common.collect.ImmutableList;
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.MainCommand;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
+import me.lucko.luckperms.commands.log.subcommands.*;
+import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.data.Log;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+public class LogMainCommand extends MainCommand<Log> {
+    public LogMainCommand() {
+        super("Log", "/%s log", 1, ImmutableList.<SubCommand<Log>>builder()
+            .add(new LogRecent())
+            .add(new LogSearch())
+            .add(new LogNotify())
+            .add(new LogExport())
+            .add(new LogUserHistory())
+            .add(new LogGroupHistory())
+            .add(new LogTrackHistory())
+            .build()
+        );
+    }
+
+    @Override
+    protected Log getTarget(String target, LuckPermsPlugin plugin, Sender sender) {
+        Log log = plugin.getDatastore().getLog();
+
+        if (log == null) {
+            Message.LOG_LOAD_ERROR.send(sender);
+        }
+
+        return log;
+    }
+
+    @Override
+    protected void cleanup(Log log, LuckPermsPlugin plugin) {
+
+    }
+
+    @Override
+    protected List<String> getObjects(LuckPermsPlugin plugin) {
+        return null;
+    }
+
+    @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());
+
+        if (args.size() <= 1) {
+            if (args.isEmpty() || args.get(0).equalsIgnoreCase("")) {
+                return subs.stream()
+                        .map(m -> m.getName().toLowerCase())
+                        .collect(Collectors.toList());
+            }
+
+            return subs.stream()
+                    .map(m -> m.getName().toLowerCase())
+                    .filter(s -> s.toLowerCase().startsWith(args.get(0).toLowerCase()))
+                    .collect(Collectors.toList());
+        }
+
+        Optional<SubCommand<Log>> o = subs.stream()
+                .filter(s -> s.getName().equalsIgnoreCase(args.get(0)))
+                .limit(1)
+                .findAny();
+
+        if (!o.isPresent()) {
+            return Collections.emptyList();
+        }
+
+        return o.get().onTabComplete(plugin, sender, args.subList(1, args.size()));
+    }
+}

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

@@ -0,0 +1,128 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 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.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> {
+    public LogExport() {
+        super("export", "Export the log to a file", "/%s log export <file>", Permission.LOG_EXPORT, Predicate.not(1));
+    }
+
+    @Override
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Log log, List<String> args, String label) {
+        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

@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.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 me.lucko.luckperms.utils.ArgumentChecker;
+import me.lucko.luckperms.utils.DateUtil;
+
+import java.util.List;
+import java.util.Map;
+import java.util.SortedMap;
+
+public class LogGroupHistory extends SubCommand<Log> {
+    public LogGroupHistory() {
+        super("grouphistory", "View an objects history", "/%s log grouphistory <group> [page]", Permission.LOG_GROUP_HISTORY,
+                Predicate.notInRange(1, 2));
+    }
+
+    @Override
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Log log, List<String> args, String label) {
+        String group = args.get(0);
+        int page = -999;
+
+        if (args.size() == 2) {
+            try {
+                page = Integer.parseInt(args.get(1));
+            } catch (NumberFormatException e) {
+                // invalid page
+                Message.LOG_INVALID_PAGE.send(sender);
+                return CommandResult.INVALID_ARGS;
+            }
+        }
+
+        if (ArgumentChecker.checkName(group)) {
+            Message.GROUP_INVALID_ENTRY.send(sender);
+            return CommandResult.INVALID_ARGS;
+        }
+
+        int maxPage = log.getGroupHistoryMaxPages(group);
+        if (maxPage == 0) {
+            Message.LOG_NO_ENTRIES.send(sender);
+            return CommandResult.STATE_ERROR;
+        }
+
+        if (page == -999) {
+            page = maxPage;
+        }
+
+        if (page < 1 || page > maxPage) {
+            Message.LOG_INVALID_PAGE_RANGE.send(sender, maxPage);
+            return CommandResult.INVALID_ARGS;
+        }
+
+        SortedMap<Integer, LogEntry> entries = log.getGroupHistory(page, group);
+        String name = entries.values().stream().findAny().get().getActedName();
+        Message.LOG_HISTORY_GROUP_HEADER.send(sender, name, page, maxPage);
+
+        for (Map.Entry<Integer, LogEntry> e : entries.entrySet()) {
+            Message.LOG_ENTRY.send(sender, e.getKey(), DateUtil.formatDateDiff(e.getValue().getTimestamp()), e.getValue().getFormatted());
+        }
+
+        return CommandResult.SUCCESS;
+    }
+}

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

@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 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.log.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.Log;
+
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+
+public class LogNotify extends SubCommand<Log> {
+    public LogNotify() {
+        super("notify", "Toggle notifications", "/%s log notify [on|off]", Permission.LOG_NOTIFY,
+                Predicate.notInRange(0, 1));
+    }
+
+    @Override
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Log log, List<String> args, String label) {
+        final Set<UUID> ignoring = plugin.getIgnoringLogs();
+        final UUID uuid = sender.getUuid();
+        if (args.size() == 0) {
+            if (ignoring.contains(uuid)) {
+                // toggle on
+                ignoring.remove(uuid);
+                Message.LOG_NOTIFY_TOGGLE_ON.send(sender);
+                return CommandResult.SUCCESS;
+            }
+            // toggle off
+            ignoring.add(uuid);
+            Message.LOG_NOTIFY_TOGGLE_OFF.send(sender);
+            return CommandResult.SUCCESS;
+        }
+
+        if (args.get(0).equalsIgnoreCase("on")) {
+            if (!ignoring.contains(uuid)) {
+                // already on
+                Message.LOG_NOTIFY_ALREADY_ON.send(sender);
+                return CommandResult.STATE_ERROR;
+            }
+
+            // toggle on
+            ignoring.remove(uuid);
+            Message.LOG_NOTIFY_TOGGLE_ON.send(sender);
+            return CommandResult.SUCCESS;
+        }
+
+        if (args.get(0).equalsIgnoreCase("off")) {
+            if (ignoring.contains(uuid)) {
+                // already off
+                Message.LOG_NOTIFY_ALREADY_OFF.send(sender);
+                return CommandResult.STATE_ERROR;
+            }
+
+            // toggle off
+            ignoring.add(uuid);
+            Message.LOG_NOTIFY_TOGGLE_OFF.send(sender);
+            return CommandResult.SUCCESS;
+        }
+
+        // not recognised
+        Message.LOG_NOTIFY_UNKNOWN.send(sender);
+        return CommandResult.INVALID_ARGS;
+    }
+}

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

@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.commands.log.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.api.LogEntry;
+import me.lucko.luckperms.commands.*;
+import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.constants.Patterns;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.data.Log;
+import me.lucko.luckperms.utils.DateUtil;
+
+import java.util.List;
+import java.util.Map;
+import java.util.SortedMap;
+import java.util.UUID;
+
+public class LogRecent extends SubCommand<Log> {
+    public LogRecent() {
+        super("recent", "View recent actions", "/%s log recent [user] [page]", Permission.LOG_RECENT,
+                Predicate.notInRange(0, 2));
+    }
+
+    @Override
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Log log, List<String> args, String label) {
+        if (args.size() == 0) {
+            // No page or user
+            return showLog(log.getRecentMaxPages(), null, sender, log);
+        }
+
+        if (args.size() == 1) {
+            // Page or user
+            try {
+                int p = Integer.parseInt(args.get(0));
+                // page
+                return showLog(p, null, sender, log);
+            } catch (NumberFormatException ignored) {}
+        }
+
+        // User and possibly page
+        final String s = args.get(0);
+        UUID u = null;
+
+        u = Util.parseUuid(s);
+        if (u == null) {
+            if (s.length() <= 16) {
+                if (Patterns.NON_USERNAME.matcher(s).find()) {
+                    Message.USER_INVALID_ENTRY.send(sender, s);
+                    return CommandResult.INVALID_ARGS;
+                }
+
+                Message.USER_ATTEMPTING_LOOKUP.send(sender);
+
+                UUID uuid = plugin.getDatastore().getUUID(s);
+
+                if (uuid == null) {
+                    Message.USER_NOT_FOUND.send(sender);
+                    return CommandResult.INVALID_ARGS;
+                }
+
+                if (args.size() != 2) {
+                    // Just user
+                    return showLog(log.getRecentMaxPages(uuid), uuid, sender, log);
+                }
+
+                try {
+                    int p = Integer.parseInt(args.get(1));
+                    // User and page
+                    return showLog(p, uuid, sender, log);
+                } catch (NumberFormatException e) {
+                    // Invalid page
+                    return showLog(-1, null, null, null);
+                }
+            }
+
+            Message.USER_INVALID_ENTRY.send(sender, s);
+            return CommandResult.INVALID_ARGS;
+        }
+
+        if (args.size() != 2) {
+            // Just user
+            return showLog(log.getRecentMaxPages(u), u, sender, log);
+        } else {
+            try {
+                int p = Integer.parseInt(args.get(1));
+                // User and page
+                return showLog(p, u, sender, log);
+            } catch (NumberFormatException e) {
+                // Invalid page
+                return showLog(-1, null, null, null);
+            }
+        }
+    }
+
+    private static CommandResult showLog(int page, UUID filter, Sender sender, Log log) {
+        int maxPage = (filter != null) ? log.getRecentMaxPages(filter) : log.getRecentMaxPages();
+        if (maxPage == 0) {
+            Message.LOG_NO_ENTRIES.send(sender);
+            return CommandResult.STATE_ERROR;
+        }
+
+        if (page < 1 || page > maxPage) {
+            Message.LOG_INVALID_PAGE_RANGE.send(sender, maxPage);
+            return CommandResult.INVALID_ARGS;
+        }
+
+        SortedMap<Integer, LogEntry> entries = (filter != null) ? log.getRecent(page, filter) : log.getRecent(page);
+        if (filter != null) {
+            String name = entries.values().stream().findAny().get().getActorName();
+            Message.LOG_RECENT_BY_HEADER.send(sender, name, page, maxPage);
+        } else {
+            Message.LOG_RECENT_HEADER.send(sender, page, maxPage);
+        }
+
+        for (Map.Entry<Integer, LogEntry> e : entries.entrySet()) {
+            Message.LOG_ENTRY.send(sender, e.getKey(), DateUtil.formatDateDiff(e.getValue().getTimestamp()), e.getValue().getFormatted());
+        }
+        return CommandResult.SUCCESS;
+    }
+}

common/src/main/java/me/lucko/luckperms/commands/log/subcommands/LogSearch.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.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 me.lucko.luckperms.utils.DateUtil;
+
+import java.util.List;
+import java.util.Map;
+import java.util.SortedMap;
+import java.util.stream.Collectors;
+
+public class LogSearch extends SubCommand<Log> {
+    public LogSearch() {
+        super("search", "Search the log for an entry", "/%s log search <query> [page]", Permission.LOG_SEARCH,
+                Predicate.is(0));
+    }
+
+    @Override
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Log log, List<String> args, String label) {
+        int page = -999;
+        if (args.size() > 1) {
+            try {
+                page = Integer.parseInt(args.get(args.size() - 1));
+                args.remove(args.size() - 1);
+            } catch (NumberFormatException ignored) {}
+        }
+
+        final String query = args.stream().collect(Collectors.joining(" "));
+
+        int maxPage = log.getSearchMaxPages(query);
+        if (maxPage == 0) {
+            Message.LOG_NO_ENTRIES.send(sender);
+            return CommandResult.STATE_ERROR;
+        }
+
+        if (page == -999) {
+            page = maxPage;
+        }
+
+        if (page < 1 || page > maxPage) {
+            Message.LOG_INVALID_PAGE_RANGE.send(sender, maxPage);
+            return CommandResult.INVALID_ARGS;
+        }
+
+        SortedMap<Integer, LogEntry> entries = log.getSearch(page, query);
+        Message.LOG_SEARCH_HEADER.send(sender, query, page, maxPage);
+
+        for (Map.Entry<Integer, LogEntry> e : entries.entrySet()) {
+            Message.LOG_ENTRY.send(sender, e.getKey(), DateUtil.formatDateDiff(e.getValue().getTimestamp()), e.getValue().getFormatted());
+        }
+
+        return CommandResult.SUCCESS;
+    }
+}

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

@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.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 me.lucko.luckperms.utils.ArgumentChecker;
+import me.lucko.luckperms.utils.DateUtil;
+
+import java.util.List;
+import java.util.Map;
+import java.util.SortedMap;
+
+public class LogTrackHistory extends SubCommand<Log> {
+    public LogTrackHistory() {
+        super("trackhistory", "View an objects history", "/%s log trackhistory <track> [page]", Permission.LOG_TRACK_HISTORY,
+                Predicate.notInRange(1, 2));
+    }
+
+    @Override
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Log log, List<String> args, String label) {
+        String track = args.get(0);
+        int page = -999;
+
+        if (args.size() == 2) {
+            try {
+                page = Integer.parseInt(args.get(1));
+            } catch (NumberFormatException e) {
+                // invalid page
+                Message.LOG_INVALID_PAGE.send(sender);
+                return CommandResult.INVALID_ARGS;
+            }
+        }
+
+        if (ArgumentChecker.checkName(track)) {
+            Message.TRACK_INVALID_ENTRY.send(sender);
+            return CommandResult.INVALID_ARGS;
+        }
+
+        int maxPage = log.getTrackHistoryMaxPages(track);
+        if (maxPage == 0) {
+            Message.LOG_NO_ENTRIES.send(sender);
+            return CommandResult.STATE_ERROR;
+        }
+
+        if (page == -999) {
+            page = maxPage;
+        }
+
+        if (page < 1 || page > maxPage) {
+            Message.LOG_INVALID_PAGE_RANGE.send(sender, maxPage);
+            return CommandResult.INVALID_ARGS;
+        }
+
+        SortedMap<Integer, LogEntry> entries = log.getTrackHistory(page, track);
+        String name = entries.values().stream().findAny().get().getActedName();
+        Message.LOG_HISTORY_TRACK_HEADER.send(sender, name, page, maxPage);
+
+        for (Map.Entry<Integer, LogEntry> e : entries.entrySet()) {
+            Message.LOG_ENTRY.send(sender, e.getKey(), DateUtil.formatDateDiff(e.getValue().getTimestamp()), e.getValue().getFormatted());
+        }
+
+        return CommandResult.SUCCESS;
+    }
+}

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

@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 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.log.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.api.LogEntry;
+import me.lucko.luckperms.commands.*;
+import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.constants.Patterns;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.data.Log;
+import me.lucko.luckperms.utils.DateUtil;
+
+import java.util.List;
+import java.util.Map;
+import java.util.SortedMap;
+import java.util.UUID;
+
+public class LogUserHistory extends SubCommand<Log> {
+    public LogUserHistory() {
+        super("userhistory", "View an objects history", "/%s log userhistory <user> [page]", Permission.LOG_USER_HISTORY,
+                Predicate.notInRange(1, 2));
+    }
+
+    @Override
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Log log, List<String> args, String label) {
+        String user = args.get(0);
+        int page = -999;
+
+        if (args.size() == 2) {
+            try {
+                page = Integer.parseInt(args.get(1));
+            } catch (NumberFormatException e) {
+                // invalid page
+                return showLog(-1, null, null, null);
+            }
+        }
+
+        UUID uuid = Util.parseUuid(user);
+        if (uuid != null) {
+            if (page == -999) {
+                page = log.getUserHistoryMaxPages(uuid);
+            }
+
+            return showLog(page, uuid, sender, log);
+
+        }
+
+        if (user.length() <= 16) {
+            if (Patterns.NON_USERNAME.matcher(user).find()) {
+                Message.USER_INVALID_ENTRY.send(sender, user);
+                return CommandResult.INVALID_ARGS;
+            }
+
+            Message.USER_ATTEMPTING_LOOKUP.send(sender);
+
+            UUID uuid1 = plugin.getDatastore().getUUID(user);
+
+            if (uuid1 == null) {
+                Message.USER_NOT_FOUND.send(sender);
+                return CommandResult.INVALID_ARGS;
+            }
+
+            if (page == -999) {
+                page = log.getUserHistoryMaxPages(uuid1);
+            }
+
+            return showLog(page, uuid1, sender, log);
+        }
+
+        Message.USER_INVALID_ENTRY.send(sender, user);
+        return CommandResult.INVALID_ARGS;
+    }
+
+    private static CommandResult showLog(int page, UUID user, Sender sender, Log log) {
+        int maxPage = log.getUserHistoryMaxPages(user);
+        if (maxPage == 0) {
+            Message.LOG_NO_ENTRIES.send(sender);
+            return CommandResult.STATE_ERROR;
+        }
+
+        if (page < 1 || page > maxPage) {
+            Message.LOG_INVALID_PAGE_RANGE.send(sender, maxPage);
+            return CommandResult.INVALID_ARGS;
+        }
+
+        SortedMap<Integer, LogEntry> entries = log.getUserHistory(page, user);
+        String name = entries.values().stream().findAny().get().getActedName();
+        Message.LOG_HISTORY_USER_HEADER.send(sender, name, page, maxPage);
+
+        for (Map.Entry<Integer, LogEntry> e : entries.entrySet()) {
+            Message.LOG_ENTRY.send(sender, e.getKey(), DateUtil.formatDateDiff(e.getValue().getTimestamp()), e.getValue().getFormatted());
+        }
+
+        return CommandResult.SUCCESS;
+    }
+}

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

@@ -23,6 +23,7 @@
 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;
@@ -36,9 +37,13 @@ public class DebugCommand extends SingleMainCommand {
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
-        Message.DEBUG.send(sender, plugin.getPlayerCount(), plugin.getUserManager().getUsers().size(),
-                plugin.getGroupManager().getGroups().size(), plugin.getTrackManager().getTracks().size()
+    protected CommandResult execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
+        Message.DEBUG.send(sender,
+                plugin.getPlayerCount(),
+                plugin.getUserManager().getAll().size(),
+                plugin.getGroupManager().getAll().size(),
+                plugin.getTrackManager().getAll().size()
         );
+        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

@@ -23,23 +23,38 @@
 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.utils.LPConfiguration;
+import me.lucko.luckperms.core.LPConfiguration;
 
 import java.util.List;
 
+import static me.lucko.luckperms.commands.Util.formatBoolean;
+
 public class InfoCommand extends SingleMainCommand {
     public InfoCommand() {
         super("Info", "/%s info", 0, Permission.INFO);
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
+    protected CommandResult execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
         final LPConfiguration c = plugin.getConfiguration();
-        Message.INFO.send(sender, plugin.getVersion(), plugin.getDatastore().getName(), c.getServer(),
-                c.getDefaultGroupName(), c.getSyncTime(), c.getIncludeGlobalPerms(), c.getOnlineMode());
+        Message.INFO.send(sender,
+                plugin.getVersion(),
+                plugin.getDatastore().getName(),
+                c.getServer(),
+                c.getDefaultGroupName(),
+                c.getSyncTime(),
+                formatBoolean(c.getIncludeGlobalPerms()),
+                formatBoolean(c.getOnlineMode()),
+                formatBoolean(c.getApplyWildcards()),
+                formatBoolean(c.getApplyRegex()),
+                formatBoolean(c.getApplyShorthand())
+        );
+
+        return CommandResult.SUCCESS;
     }
 }

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

@@ -23,6 +23,7 @@
 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;
@@ -36,8 +37,9 @@ public class SyncCommand extends SingleMainCommand {
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
+    protected CommandResult execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
         Message.UPDATE_TASK_RUN.send(sender);
         plugin.runUpdateTask();
+        return CommandResult.SUCCESS;
     }
 }

common/src/main/java/me/lucko/luckperms/commands/track/CreateTrack.java

@@ -23,11 +23,13 @@
 package me.lucko.luckperms.commands.track;
 
 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.utils.Patterns;
+import me.lucko.luckperms.data.LogEntry;
+import me.lucko.luckperms.utils.ArgumentChecker;
 
 import java.util.List;
 
@@ -37,37 +39,31 @@ public class CreateTrack extends SingleMainCommand {
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
+    protected CommandResult execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
         if (args.size() == 0) {
             sendUsage(sender, label);
-            return;
+            return CommandResult.INVALID_ARGS;
         }
 
         String trackName = args.get(0).toLowerCase();
-
-        if (trackName.length() > 36) {
-            Message.TRACK_NAME_TOO_LONG.send(sender, trackName);
-            return;
-        }
-
-        if (Patterns.NON_ALPHA_NUMERIC.matcher(trackName).find()) {
+        if (ArgumentChecker.checkName(trackName)) {
             Message.TRACK_INVALID_ENTRY.send(sender);
-            return;
+            return CommandResult.INVALID_ARGS;
         }
 
-        plugin.getDatastore().loadTrack(trackName, success -> {
-            if (success) {
-                Message.TRACK_ALREADY_EXISTS.send(sender);
-            } else {
-                plugin.getDatastore().createAndLoadTrack(trackName, success1 -> {
-                    if (!success1) {
-                        Message.CREATE_TRACK_ERROR.send(sender);
-                    } else {
-                        Message.CREATE_SUCCESS.send(sender, trackName);
-                        plugin.runUpdateTask();
-                    }
-                });
-            }
-        });
+        if (plugin.getDatastore().loadTrack(trackName)) {
+            Message.TRACK_ALREADY_EXISTS.send(sender);
+            return CommandResult.INVALID_ARGS;
+        }
+
+        if (!plugin.getDatastore().createAndLoadTrack(trackName)) {
+            Message.CREATE_TRACK_ERROR.send(sender);
+            return CommandResult.FAILURE;
+        }
+
+        Message.CREATE_SUCCESS.send(sender, trackName);
+        LogEntry.build().actor(sender).actedName(trackName).type('T').action("create").build().submit(plugin);
+        plugin.runUpdateTask();
+        return CommandResult.SUCCESS;
     }
 }

common/src/main/java/me/lucko/luckperms/commands/track/DeleteTrack.java

@@ -23,12 +23,14 @@
 package me.lucko.luckperms.commands.track;
 
 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.LogEntry;
 import me.lucko.luckperms.tracks.Track;
-import me.lucko.luckperms.utils.Patterns;
+import me.lucko.luckperms.utils.ArgumentChecker;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -41,51 +43,52 @@ public class DeleteTrack extends SingleMainCommand {
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
+    protected CommandResult execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
         if (args.size() == 0) {
             sendUsage(sender, label);
-            return;
+            return CommandResult.INVALID_ARGS;
         }
 
         String trackName = args.get(0).toLowerCase();
-
-        if (Patterns.NON_ALPHA_NUMERIC.matcher(trackName).find()) {
+        if (ArgumentChecker.checkName(trackName)) {
             Message.TRACK_INVALID_ENTRY.send(sender);
-            return;
+            return CommandResult.INVALID_ARGS;
         }
 
-        plugin.getDatastore().loadTrack(trackName, success -> {
-            if (!success) {
-                Message.TRACK_DOES_NOT_EXIST.send(sender);
-            } else {
+        if (!plugin.getDatastore().loadTrack(trackName)) {
+            Message.TRACK_DOES_NOT_EXIST.send(sender);
+            return CommandResult.INVALID_ARGS;
+        }
 
-                Track track = plugin.getTrackManager().getTrack(trackName);
-                if (track == null) {
-                    Message.TRACK_LOAD_ERROR.send(sender);
-                } else {
-                    plugin.getDatastore().deleteTrack(track, success1 -> {
-                        if (!success1) {
-                            Message.DELETE_TRACK_ERROR.send(sender);
-                        } else {
-                            Message.DELETE_SUCCESS.send(sender, trackName);
-                            plugin.runUpdateTask();
-                        }
-                    });
-                }
-            }
-        });
+        Track track = plugin.getTrackManager().get(trackName);
+        if (track == null) {
+            Message.TRACK_LOAD_ERROR.send(sender);
+            return CommandResult.LOADING_ERROR;
+        }
+
+        if (!plugin.getDatastore().deleteTrack(track)) {
+            Message.DELETE_TRACK_ERROR.send(sender);
+            return CommandResult.FAILURE;
+        }
+
+        Message.DELETE_SUCCESS.send(sender, trackName);
+        LogEntry.build().actor(sender).actedName(trackName).type('T').action("delete").build().submit(plugin);
+        plugin.runUpdateTask();
+        return CommandResult.SUCCESS;
     }
 
     @Override
     protected List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
-        final List<String> tracks = new ArrayList<>(plugin.getTrackManager().getTracks().keySet());
+        final List<String> tracks = new ArrayList<>(plugin.getTrackManager().getAll().keySet());
 
         if (args.size() <= 1) {
             if (args.isEmpty() || args.get(0).equalsIgnoreCase("")) {
                 return tracks;
             }
 
-            return tracks.stream().filter(s -> s.toLowerCase().startsWith(args.get(0).toLowerCase())).collect(Collectors.toList());
+            return tracks.stream()
+                    .filter(s -> s.toLowerCase().startsWith(args.get(0).toLowerCase()))
+                    .collect(Collectors.toList());
         }
 
         return Collections.emptyList();

common/src/main/java/me/lucko/luckperms/commands/track/ListTracks.java

@@ -23,6 +23,7 @@
 package me.lucko.luckperms.commands.track;
 
 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.commands.Util;
@@ -38,13 +39,13 @@ public class ListTracks extends SingleMainCommand {
     }
 
     @Override
-    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
-        plugin.getDatastore().loadAllTracks(success -> {
-            if (!success) {
-                Message.TRACKS_LOAD_ERROR.send(sender);
-            } else {
-                Message.TRACKS_LIST.send(sender, Util.listToCommaSep(new ArrayList<>(plugin.getTrackManager().getTracks().keySet())));
-            }
-        });
+    protected CommandResult execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
+        if (!plugin.getDatastore().loadAllTracks()) {
+            Message.TRACKS_LOAD_ERROR.send(sender);
+            return CommandResult.LOADING_ERROR;
+        }
+
+        Message.TRACKS_LIST.send(sender, Util.listToCommaSep(new ArrayList<>(plugin.getTrackManager().getAll().keySet())));
+        return CommandResult.SUCCESS;
     }
 }

common/src/main/java/me/lucko/luckperms/commands/track/TrackMainCommand.java

@@ -22,41 +22,59 @@
 
 package me.lucko.luckperms.commands.track;
 
+import com.google.common.collect.ImmutableList;
 import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.api.data.Callback;
 import me.lucko.luckperms.commands.MainCommand;
 import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
+import me.lucko.luckperms.commands.track.subcommands.*;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.tracks.Track;
+import me.lucko.luckperms.utils.ArgumentChecker;
 
 import java.util.ArrayList;
 import java.util.List;
 
 public class TrackMainCommand extends MainCommand<Track> {
     public TrackMainCommand() {
-        super("Track", "/%s track <track>", 2);
+        super("Track", "/%s track <track>", 2, ImmutableList.<SubCommand<Track>>builder()
+            .add(new TrackInfo())
+            .add(new TrackAppend())
+            .add(new TrackInsert())
+            .add(new TrackRemove())
+            .add(new TrackClear())
+            .build()
+        );
     }
 
     @Override
-    protected void getTarget(String target, LuckPermsPlugin plugin, Sender sender, Callback<Track> onSuccess) {
-        plugin.getDatastore().loadTrack(target, success -> {
-            if (!success) {
-                Message.TRACK_NOT_FOUND.send(sender);
-                return;
-            }
+    protected Track getTarget(String target, LuckPermsPlugin plugin, Sender sender) {
+        if (ArgumentChecker.checkName(target)) {
+            Message.TRACK_INVALID_ENTRY.send(sender);
+            return null;
+        }
 
-            Track track = plugin.getTrackManager().getTrack(target);
-            if (track == null) {
-                Message.TRACK_NOT_FOUND.send(sender);
-                return;
-            }
+        if (!plugin.getDatastore().loadTrack(target)) {
+            Message.TRACK_NOT_FOUND.send(sender);
+            return null;
+        }
+
+        Track track = plugin.getTrackManager().get(target);
+        if (track == null) {
+            Message.TRACK_NOT_FOUND.send(sender);
+            return null;
+        }
+
+        return track;
+    }
+
+    @Override
+    protected void cleanup(Track track, LuckPermsPlugin plugin) {
 
-            onSuccess.onComplete(track);
-        });
     }
 
     @Override
     protected List<String> getObjects(LuckPermsPlugin plugin) {
-        return new ArrayList<>(plugin.getTrackManager().getTracks().keySet());
+        return new ArrayList<>(plugin.getTrackManager().getAll().keySet());
     }
 }

common/src/main/java/me/lucko/luckperms/commands/track/subcommands/TrackAppend.java

@@ -23,15 +23,14 @@
 package me.lucko.luckperms.commands.track.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.commands.Predicate;
-import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
-import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.*;
 import me.lucko.luckperms.constants.Message;
 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.utils.ArgumentChecker;
 
 import java.util.List;
 
@@ -42,33 +41,42 @@ public class TrackAppend extends SubCommand<Track> {
     }
 
     @Override
-    public void execute(LuckPermsPlugin plugin, Sender sender, Track track, List<String> args, String label) {
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Track track, List<String> args, String label) {
         String groupName = args.get(0).toLowerCase();
 
-        plugin.getDatastore().loadGroup(groupName, success -> {
-            if (!success) {
-                Message.GROUP_DOES_NOT_EXIST.send(sender);
-            } else {
-                Group group = plugin.getGroupManager().getGroup(groupName);
-                if (group == null) {
-                    Message.GROUP_DOES_NOT_EXIST.send(sender);
-                    return;
-                }
+        if (ArgumentChecker.checkNode(groupName)) {
+            sendUsage(sender, label);
+            return CommandResult.INVALID_ARGS;
+        }
 
-                try {
-                    track.appendGroup(group);
-                    Message.TRACK_APPEND_SUCCESS.send(sender, group.getName(), track.getName());
-                    Message.EMPTY.send(sender, Util.listToArrowSep(track.getGroups(), group.getName()));
-                    saveTrack(track, sender, plugin);
-                } catch (ObjectAlreadyHasException e) {
-                    Message.TRACK_ALREADY_CONTAINS.send(sender, track.getName(), group.getName());
-                }
-            }
-        });
+        if (!plugin.getDatastore().loadGroup(groupName)) {
+            Message.GROUP_DOES_NOT_EXIST.send(sender);
+            return CommandResult.INVALID_ARGS;
+        }
+
+        Group group = plugin.getGroupManager().get(groupName);
+        if (group == null) {
+            Message.GROUP_DOES_NOT_EXIST.send(sender);
+            return CommandResult.LOADING_ERROR;
+        }
+
+        try {
+            track.appendGroup(group);
+            Message.TRACK_APPEND_SUCCESS.send(sender, group.getName(), track.getName());
+            Message.EMPTY.send(sender, Util.listToArrowSep(track.getGroups(), group.getName()));
+            LogEntry.build().actor(sender).acted(track)
+                    .action("append " + group.getName())
+                    .build().submit(plugin);
+            save(track, sender, plugin);
+            return CommandResult.SUCCESS;
+        } catch (ObjectAlreadyHasException e) {
+            Message.TRACK_ALREADY_CONTAINS.send(sender, track.getName(), group.getName());
+            return CommandResult.STATE_ERROR;
+        }
     }
 
     @Override
-    public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+    public List<String> onTabComplete(LuckPermsPlugin plugin, Sender sender, List<String> args) {
         return getGroupTabComplete(args, plugin);
     }
 }

common/src/main/java/me/lucko/luckperms/commands/track/subcommands/TrackClear.java

@@ -23,11 +23,13 @@
 package me.lucko.luckperms.commands.track.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.tracks.Track;
 
 import java.util.List;
@@ -39,9 +41,11 @@ public class TrackClear extends SubCommand<Track> {
     }
 
     @Override
-    public void execute(LuckPermsPlugin plugin, Sender sender, Track track, List<String> args, String label) {
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Track track, List<String> args, String label) {
         track.clearGroups();
         Message.TRACK_CLEAR.send(sender, track.getName());
-        saveTrack(track, sender, plugin);
+        LogEntry.build().actor(sender).acted(track).action("clear").build().submit(plugin);
+        save(track, sender, plugin);
+        return CommandResult.SUCCESS;
     }
 }

common/src/main/java/me/lucko/luckperms/commands/track/subcommands/TrackInfo.java

@@ -23,10 +23,7 @@
 package me.lucko.luckperms.commands.track.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.commands.Predicate;
-import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
-import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.*;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
 import me.lucko.luckperms.tracks.Track;
@@ -40,7 +37,8 @@ public class TrackInfo extends SubCommand<Track> {
     }
 
     @Override
-    public void execute(LuckPermsPlugin plugin, Sender sender, Track track, List<String> args, String label) {
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Track track, List<String> args, String label) {
         Message.TRACK_INFO.send(sender, track.getName(), Util.listToArrowSep(track.getGroups()));
+        return CommandResult.SUCCESS;
     }
 }

common/src/main/java/me/lucko/luckperms/commands/track/subcommands/TrackInsert.java

@@ -23,15 +23,14 @@
 package me.lucko.luckperms.commands.track.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.commands.Predicate;
-import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
-import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.*;
 import me.lucko.luckperms.constants.Message;
 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.utils.ArgumentChecker;
 
 import java.util.List;
 
@@ -42,42 +41,53 @@ public class TrackInsert extends SubCommand<Track> {
     }
 
     @Override
-    public void execute(LuckPermsPlugin plugin, Sender sender, Track track, List<String> args, String label) {
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Track track, List<String> args, String label) {
         String groupName = args.get(0).toLowerCase();
+
+        if (ArgumentChecker.checkNode(groupName)) {
+            sendUsage(sender, label);
+            return CommandResult.INVALID_ARGS;
+        }
+
         int pos;
         try {
             pos = Integer.parseInt(args.get(1));
         } catch (NumberFormatException e) {
             Message.TRACK_INSERT_ERROR_NUMBER.send(sender, args.get(1));
-            return;
+            return CommandResult.INVALID_ARGS;
         }
 
-        plugin.getDatastore().loadGroup(groupName, success -> {
-            if (!success) {
-                Message.GROUP_DOES_NOT_EXIST.send(sender);
-            } else {
-                Group group = plugin.getGroupManager().getGroup(groupName);
-                if (group == null) {
-                    Message.GROUP_DOES_NOT_EXIST.send(sender);
-                    return;
-                }
+        if (!plugin.getDatastore().loadGroup(groupName)) {
+            Message.GROUP_DOES_NOT_EXIST.send(sender);
+            return CommandResult.INVALID_ARGS;
+        }
 
-                try {
-                    track.insertGroup(group, pos - 1);
-                    Message.TRACK_INSERT_SUCCESS.send(sender, group.getName(), track.getName(), pos);
-                    Message.EMPTY.send(sender, Util.listToArrowSep(track.getGroups(), group.getName()));
-                    saveTrack(track, sender, plugin);
-                } catch (ObjectAlreadyHasException e) {
-                    Message.TRACK_ALREADY_CONTAINS.send(sender, track.getName(), group.getName());
-                } catch (IndexOutOfBoundsException e) {
-                    Message.TRACK_INSERT_ERROR_INVALID_POS.send(sender, pos);
-                }
-            }
-        });
+        Group group = plugin.getGroupManager().get(groupName);
+        if (group == null) {
+            Message.GROUP_DOES_NOT_EXIST.send(sender);
+            return CommandResult.LOADING_ERROR;
+        }
+
+        try {
+            track.insertGroup(group, pos - 1);
+            Message.TRACK_INSERT_SUCCESS.send(sender, group.getName(), track.getName(), pos);
+            Message.EMPTY.send(sender, Util.listToArrowSep(track.getGroups(), group.getName()));
+            LogEntry.build().actor(sender).acted(track)
+                    .action("insert " + group.getName() + " " + pos)
+                    .build().submit(plugin);
+            save(track, sender, plugin);
+            return CommandResult.SUCCESS;
+        } catch (ObjectAlreadyHasException e) {
+            Message.TRACK_ALREADY_CONTAINS.send(sender, track.getName(), group.getName());
+            return CommandResult.STATE_ERROR;
+        } catch (IndexOutOfBoundsException e) {
+            Message.TRACK_INSERT_ERROR_INVALID_POS.send(sender, pos);
+            return CommandResult.INVALID_ARGS;
+        }
     }
 
     @Override
-    public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+    public List<String> onTabComplete(LuckPermsPlugin plugin, Sender sender, List<String> args) {
         return getGroupTabComplete(args, plugin);
     }
 }

common/src/main/java/me/lucko/luckperms/commands/track/subcommands/TrackRemove.java

@@ -23,13 +23,13 @@
 package me.lucko.luckperms.commands.track.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.commands.Predicate;
-import me.lucko.luckperms.commands.Sender;
-import me.lucko.luckperms.commands.SubCommand;
+import me.lucko.luckperms.commands.*;
 import me.lucko.luckperms.constants.Message;
 import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.data.LogEntry;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
 import me.lucko.luckperms.tracks.Track;
+import me.lucko.luckperms.utils.ArgumentChecker;
 
 import java.util.List;
 
@@ -40,19 +40,31 @@ public class TrackRemove extends SubCommand<Track> {
     }
 
     @Override
-    public void execute(LuckPermsPlugin plugin, Sender sender, Track track, List<String> args, String label) {
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Track track, List<String> args, String label) {
         String groupName = args.get(0).toLowerCase();
+
+        if (ArgumentChecker.checkNode(groupName)) {
+            sendUsage(sender, label);
+            return CommandResult.INVALID_ARGS;
+        }
+
         try {
             track.removeGroup(groupName);
             Message.TRACK_REMOVE_SUCCESS.send(sender, groupName, track.getName());
-            saveTrack(track, sender, plugin);
+            Message.EMPTY.send(sender, Util.listToArrowSep(track.getGroups()));
+            LogEntry.build().actor(sender).acted(track)
+                    .action("remove " + groupName)
+                    .build().submit(plugin);
+            save(track, sender, plugin);
+            return CommandResult.SUCCESS;
         } catch (ObjectLacksException e) {
             Message.TRACK_DOES_NOT_CONTAIN.send(sender, track.getName(), groupName);
+            return CommandResult.STATE_ERROR;
         }
     }
 
     @Override
-    public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+    public List<String> onTabComplete(LuckPermsPlugin plugin, Sender sender, List<String> args) {
         return getGroupTabComplete(args, plugin);
     }
 }

common/src/main/java/me/lucko/luckperms/commands/user/UserMainCommand.java

@@ -22,69 +22,105 @@
 
 package me.lucko.luckperms.commands.user;
 
+import com.google.common.collect.ImmutableList;
 import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.api.data.Callback;
 import me.lucko.luckperms.commands.MainCommand;
 import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.user.subcommands.*;
 import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.constants.Patterns;
 import me.lucko.luckperms.users.User;
-import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 import java.util.UUID;
 
 public class UserMainCommand extends MainCommand<User> {
     public UserMainCommand() {
-        super("User", "/%s user <user>", 2);
+        super("User", "/%s user <user>", 2, ImmutableList.<SubCommand<User>>builder()
+            .add(new UserInfo())
+            .add(new UserGetUUID())
+            .add(new UserListNodes())
+            .add(new UserHasPerm())
+            .add(new UserInheritsPerm())
+            .add(new UserSetPermission())
+            .add(new UserUnSetPermission())
+            .add(new UserAddGroup())
+            .add(new UserRemoveGroup())
+            .add(new UserSetTempPermission())
+            .add(new UserUnsetTempPermission())
+            .add(new UserAddTempGroup())
+            .add(new UserRemoveTempGroup())
+            .add(new UserSetPrimaryGroup())
+            .add(new UserShowTracks())
+            .add(new UserPromote())
+            .add(new UserDemote())
+            .add(new UserShowPos())
+            .add(new UserClear())
+            .build()
+        );
     }
 
     @Override
-    protected void getTarget(String target, LuckPermsPlugin plugin, Sender sender, Callback<User> onSuccess) {
+    protected User getTarget(String target, LuckPermsPlugin plugin, Sender sender) {
         UUID u = Util.parseUuid(target);
         if (u != null) {
-            runSub(plugin, sender, u, onSuccess);
-            return;
+            User user = getUser(plugin, u);
+            if (user == null) {
+
+                Message.USER_NEVER_JOINED.send(sender);
+                if (!plugin.getDatastore().loadOrCreateUser(u, "null")) {
+                    Message.USER_CREATE_FAIL.send(sender);
+                    return null;
+                }
+
+                user = getUser(plugin, u);
+            }
+            return user;
         }
 
         if (target.length() <= 16) {
             if (Patterns.NON_USERNAME.matcher(target).find()) {
                 Message.USER_INVALID_ENTRY.send(sender, target);
-                return;
+                return null;
             }
 
             Message.USER_ATTEMPTING_LOOKUP.send(sender);
 
-            plugin.getDatastore().getUUID(target, uuid -> {
-                if (uuid == null) {
-                    Message.USER_NOT_FOUND.send(sender);
-                    return;
-                }
+            UUID uuid = plugin.getDatastore().getUUID(target);
+            if (uuid == null) {
+                Message.USER_NOT_FOUND.send(sender);
+                return null;
+            }
 
-                runSub(plugin, sender, uuid, onSuccess);
-            });
-            return;
+            User user = getUser(plugin, uuid);
+            if (user == null) {
+                Message.USER_NOT_FOUND.send(sender);
+            }
+            return user;
         }
 
         Message.USER_INVALID_ENTRY.send(sender, target);
+        return null;
     }
 
-    private void runSub(LuckPermsPlugin plugin, Sender sender, UUID uuid, Callback<User> onSuccess) {
-        plugin.getDatastore().loadUser(uuid, success -> {
-            if (!success) {
-                Message.USER_NOT_FOUND.send(sender);
-                return;
-            }
+    @Override
+    protected void cleanup(User user, LuckPermsPlugin plugin) {
+        plugin.getUserManager().cleanup(user);
+    }
 
-            User user = plugin.getUserManager().getUser(uuid);
-            if (user == null) {
-                Message.USER_NOT_FOUND.send(sender);
-                return;
-            }
+    private User getUser(LuckPermsPlugin plugin, UUID uuid) {
+        if (!plugin.getDatastore().loadUser(uuid)) {
+            return null;
+        }
 
-            onSuccess.onComplete(user);
-            plugin.getUserManager().cleanupUser(user);
-        });
+        User user = plugin.getUserManager().get(uuid);
+        if (user == null) {
+            return null;
+        }
+
+        return user;
     }
 
     @Override

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserAddGroup.java

@@ -23,15 +23,17 @@
 package me.lucko.luckperms.commands.user.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.exceptions.ObjectAlreadyHasException;
 import me.lucko.luckperms.groups.Group;
 import me.lucko.luckperms.users.User;
-import me.lucko.luckperms.utils.Patterns;
+import me.lucko.luckperms.utils.ArgumentChecker;
 
 import java.util.List;
 
@@ -42,56 +44,66 @@ public class UserAddGroup extends SubCommand<User> {
     }
 
     @Override
-    public void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
         String groupName = args.get(0).toLowerCase();
 
-        if (groupName.contains("/") || groupName.contains("$")) {
+        if (ArgumentChecker.checkNode(groupName)) {
             sendUsage(sender, label);
-            return;
+            return CommandResult.INVALID_ARGS;
         }
 
-        plugin.getDatastore().loadGroup(groupName, success -> {
-            if (!success) {
-                Message.GROUP_DOES_NOT_EXIST.send(sender);
+        if (!plugin.getDatastore().loadGroup(groupName)) {
+            Message.GROUP_DOES_NOT_EXIST.send(sender);
+            return CommandResult.INVALID_ARGS;
+        }
+
+        Group group = plugin.getGroupManager().get(groupName);
+        if (group == null) {
+            Message.GROUP_DOES_NOT_EXIST.send(sender);
+            return CommandResult.LOADING_ERROR;
+        }
+
+        try {
+            if (args.size() >= 2) {
+                final String server = args.get(1).toLowerCase();
+                if (ArgumentChecker.checkServer(server)) {
+                    Message.SERVER_INVALID_ENTRY.send(sender);
+                    return CommandResult.INVALID_ARGS;
+                }
+
+                if (args.size() == 2) {
+                    user.addGroup(group, server);
+                    Message.USER_ADDGROUP_SERVER_SUCCESS.send(sender, user.getName(), groupName, server);
+                    LogEntry.build().actor(sender).acted(user)
+                            .action("addgroup " + group.getName() + " " + server)
+                            .build().submit(plugin);
+                } else {
+                    final String world = args.get(2).toLowerCase();
+                    user.addGroup(group, server, world);
+                    Message.USER_ADDGROUP_SERVER_WORLD_SUCCESS.send(sender, user.getName(), groupName, server, world);
+                    LogEntry.build().actor(sender).acted(user)
+                            .action("addgroup " + group.getName() + " " + server + " " + world)
+                            .build().submit(plugin);
+                }
+
             } else {
-                Group group = plugin.getGroupManager().getGroup(groupName);
-                if (group == null) {
-                    Message.GROUP_DOES_NOT_EXIST.send(sender);
-                    return;
-                }
-
-                try {
-                    if (args.size() >= 2) {
-                        final String server = args.get(1).toLowerCase();
-                        if (Patterns.NON_ALPHA_NUMERIC.matcher(server).find()) {
-                            Message.SERVER_INVALID_ENTRY.send(sender);
-                            return;
-                        }
-
-                        if (args.size() == 2) {
-                            user.addGroup(group, server);
-                            Message.USER_ADDGROUP_SERVER_SUCCESS.send(sender, user.getName(), groupName, server);
-                        } else {
-                            final String world = args.get(2).toLowerCase();
-                            user.addGroup(group, server, world);
-                            Message.USER_ADDGROUP_SERVER_WORLD_SUCCESS.send(sender, user.getName(), groupName, server, world);
-                        }
-
-                    } else {
-                        user.addGroup(group);
-                        Message.USER_ADDGROUP_SUCCESS.send(sender, user.getName(), groupName);
-                    }
-
-                    saveUser(user, sender, plugin);
-                } catch (ObjectAlreadyHasException e) {
-                    Message.USER_ALREADY_MEMBER_OF.send(sender, user.getName(), group.getName());
-                }
+                user.addGroup(group);
+                Message.USER_ADDGROUP_SUCCESS.send(sender, user.getName(), groupName);
+                LogEntry.build().actor(sender).acted(user)
+                        .action("addgroup " + group.getName())
+                        .build().submit(plugin);
             }
-        });
+
+            save(user, sender, plugin);
+            return CommandResult.SUCCESS;
+        } catch (ObjectAlreadyHasException e) {
+            Message.USER_ALREADY_MEMBER_OF.send(sender, user.getName(), group.getName());
+            return CommandResult.STATE_ERROR;
+        }
     }
 
     @Override
-    public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+    public List<String> onTabComplete(LuckPermsPlugin plugin, Sender sender, List<String> args) {
         return getGroupTabComplete(args, plugin);
     }
 }

common/src/main/java/me/lucko/luckperms/commands/user/subcommands/UserAddTempGroup.java

@@ -23,16 +23,18 @@
 package me.lucko.luckperms.commands.user.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.exceptions.ObjectAlreadyHasException;
 import me.lucko.luckperms.groups.Group;
 import me.lucko.luckperms.users.User;
+import me.lucko.luckperms.utils.ArgumentChecker;
 import me.lucko.luckperms.utils.DateUtil;
-import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
@@ -44,71 +46,85 @@ public class UserAddTempGroup extends SubCommand<User> {
     }
 
     @Override
-    public void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
         String groupName = args.get(0).toLowerCase();
 
-        if (groupName.contains("/") || groupName.contains("$")) {
+        if (ArgumentChecker.checkNode(groupName)) {
             sendUsage(sender, label);
-            return;
+            return CommandResult.INVALID_ARGS;
         }
 
         long duration;
         try {
-            duration = DateUtil.parseDateDiff(args.get(1), true);
-        } catch (DateUtil.IllegalDateException e) {
-            Message.ILLEGAL_DATE_ERROR.send(sender, args.get(1));
-            return;
+            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)) {
             Message.PAST_DATE_ERROR.send(sender);
-            return;
+            return CommandResult.INVALID_ARGS;
         }
 
-        plugin.getDatastore().loadGroup(groupName, success -> {
-            if (!success) {
-                Message.GROUP_DOES_NOT_EXIST.send(sender);
+        if (!plugin.getDatastore().loadGroup(groupName)) {
+            Message.GROUP_DOES_NOT_EXIST.send(sender);
+            return CommandResult.INVALID_ARGS;
+        }
+
+        Group group = plugin.getGroupManager().get(groupName);
+        if (group == null) {
+            Message.GROUP_DOES_NOT_EXIST.send(sender);
+            return CommandResult.LOADING_ERROR;
+        }
+
+        try {
+            if (args.size() >= 3) {
+                final String server = args.get(2).toLowerCase();
+                if (ArgumentChecker.checkServer(server)) {
+                    Message.SERVER_INVALID_ENTRY.send(sender);
+                    return CommandResult.INVALID_ARGS;
+                }
+
+                if (args.size() == 3) {
+                    user.addGroup(group, server, duration);
+                    Message.USER_ADDTEMPGROUP_SERVER_SUCCESS.send(sender, user.getName(), groupName, server,
+                            DateUtil.formatDateDiff(duration));
+                    LogEntry.build().actor(sender).acted(user)
+                            .action("addtempgroup " + group.getName() + " " + duration + " " + server)
+                            .build().submit(plugin);
+                } else {
+                    final String world = args.get(3).toLowerCase();
+                    user.addGroup(group, server, world, duration);
+                    Message.USER_ADDTEMPGROUP_SERVER_WORLD_SUCCESS.send(sender, user.getName(), groupName, server,
+                            world, DateUtil.formatDateDiff(duration));
+                    LogEntry.build().actor(sender).acted(user)
+                            .action("addtempgroup " + group.getName() + " " + duration + " " + server + " " + world)
+                            .build().submit(plugin);
+                }
+
             } else {
-                Group group = plugin.getGroupManager().getGroup(groupName);
-                if (group == null) {
-                    Message.GROUP_DOES_NOT_EXIST.send(sender);
-                    return;
-                }
-
-                try {
-                    if (args.size() >= 3) {
-                        final String server = args.get(2).toLowerCase();
-                        if (Patterns.NON_ALPHA_NUMERIC.matcher(server).find()) {
-                            Message.SERVER_INVALID_ENTRY.send(sender);
-                            return;
-                        }
-
-                        if (args.size() == 3) {
-                            user.addGroup(group, server, duration);
-                            Message.USER_ADDTEMPGROUP_SERVER_SUCCESS.send(sender, user.getName(), groupName, server,
-                                    DateUtil.formatDateDiff(duration));
-                        } else {
-                            final String world = args.get(3).toLowerCase();
-                            user.addGroup(group, server, world, duration);
-                            Message.USER_ADDTEMPGROUP_SERVER_WORLD_SUCCESS.send(sender, user.getName(), groupName, server,
-                                    world, DateUtil.formatDateDiff(duration));
-                        }
-
-                    } else {
-                        user.addGroup(group, duration);
-                        Message.USER_ADDTEMPGROUP_SUCCESS.send(sender, user.getName(), groupName, DateUtil.formatDateDiff(duration));
-                    }
-
-                    saveUser(user, sender, plugin);
-                } catch (ObjectAlreadyHasException e) {
-                    Message.USER_ALREADY_TEMP_MEMBER_OF.send(sender, user.getName(), group.getName());
-                }
+                user.addGroup(group, duration);
+                Message.USER_ADDTEMPGROUP_SUCCESS.send(sender, user.getName(), groupName, DateUtil.formatDateDiff(duration));
+                LogEntry.build().actor(sender).acted(user)
+                        .action("addtempgroup " + group.getName() + " " + duration)
+                        .build().submit(plugin);
             }
-        });
+
+            save(user, sender, plugin);
+            return CommandResult.SUCCESS;
+        } catch (ObjectAlreadyHasException e) {
+            Message.USER_ALREADY_TEMP_MEMBER_OF.send(sender, user.getName(), group.getName());
+            return CommandResult.STATE_ERROR;
+        }
     }
 
     @Override
-    public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+    public List<String> onTabComplete(LuckPermsPlugin plugin, Sender sender, List<String> args) {
         return getGroupTabComplete(args, plugin);
     }
 }