Add support for MongoDB and H2 database formats

README.md

@@ -17,6 +17,8 @@ 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
@@ -28,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.
@@ -147,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.1</version>
+        <version>2.3</version>
     </dependency>
 </dependencies>
 ````
@@ -180,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
@@ -237,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.2</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

@@ -40,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);
@@ -60,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);
@@ -76,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/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;
 
 /**
@@ -76,9 +77,17 @@ public interface LPConfiguration {
 
     /**
      * @return the database values set in the configuration
+     * @deprecated use {@link #getDatastoreConfig()}
      */
+    @SuppressWarnings("deprecation")
+    @Deprecated
     MySQLConfiguration getDatabaseValues();
 
+    /**
+     * @return the values set for data storage in the configuration
+     */
+    DatastoreConfiguration getDatastoreConfig();
+
     /**
      * @return the storage method string from the configuration
      */

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

@@ -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/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/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.2</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,19 +27,19 @@ import me.lucko.luckperms.api.Logger;
 import me.lucko.luckperms.api.LuckPermsApi;
 import me.lucko.luckperms.api.implementation.ApiProvider;
 import me.lucko.luckperms.api.vault.VaultHook;
+import me.lucko.luckperms.commands.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 me.lucko.luckperms.utils.LogFactory;
 import org.bukkit.command.PluginCommand;
 import org.bukkit.entity.Player;
 import org.bukkit.plugin.PluginManager;
@@ -47,14 +47,12 @@ import org.bukkit.plugin.ServicePriority;
 import org.bukkit.plugin.java.JavaPlugin;
 
 import java.io.File;
-import java.util.ArrayList;
-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,10 +60,11 @@ 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);
@@ -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 {
@@ -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,16 @@ 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<>();

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/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
@@ -38,13 +43,16 @@ apply-regex: true
 apply-shorthand: true
 
 # Which storage method the plugin should use.
-# Currently supported: mysql, sqlite, flatfile
-# Fill out connection info below if you're using MySQL
-storage-method: sqlite
+# Currently supported: mysql, sqlite, h2, flatfile, mongodb
+# Fill out connection info below if you're using MySQL or MongoDB
+storage-method: h2
 
-sql:
+data:
   address: localhost:3306
   database: minecraft
   username: root
   password: ''
+
+  # Set to -1 to disable. If this is the only instance accessing the datastore, you can disable syncing.
+  # e.g. if you're using sqlite or flatfile, this can be set to -1 to save resources.
   sync-minutes: 3

bukkit/src/main/resources/plugin.yml

@@ -15,6 +15,7 @@ permissions:
       luckperms.sync: true
       luckperms.info: true
       luckperms.debug: true
+      luckperms.import: true
       luckperms.creategroup: true
       luckperms.deletegroup: true
       luckperms.listgroups: true
@@ -59,6 +60,13 @@ permissions:
       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:
@@ -105,4 +113,14 @@ permissions:
       luckperms.track.append: true
       luckperms.track.insert: true
       luckperms.track.remove: true
-      luckperms.track.clear: 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.2</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,9 +23,9 @@
 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;
@@ -39,7 +39,8 @@ import java.util.Map;
 import java.util.UUID;
 import java.util.concurrent.TimeUnit;
 
-class BungeeListener extends AbstractListener implements Listener {
+@SuppressWarnings("WeakerAccess")
+public class BungeeListener extends AbstractListener implements Listener {
     private static final TextComponent WARN_MESSAGE = new TextComponent(Message.LOADING_ERROR.toString());
     private final LPBungeePlugin plugin;
 
@@ -55,7 +56,7 @@ class BungeeListener extends AbstractListener implements Listener {
         }
 
         final ProxiedPlayer player = ((ProxiedPlayer) e.getSender());
-        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) return;
 
 
@@ -110,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,29 +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.Collections;
-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;
@@ -56,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);
@@ -69,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.");
@@ -109,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));
 
@@ -129,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;
@@ -144,6 +142,16 @@ 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.

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
@@ -38,13 +43,16 @@ apply-regex: true
 apply-shorthand: true
 
 # Which storage method the plugin should use.
-# Currently supported: mysql & flatfile
-# Fill out connection info below if you're using MySQL
-storage-method: flatfile
+# Currently supported: mysql, sqlite, h2, flatfile, mongodb
+# Fill out connection info below if you're using MySQL or MongoDB
+storage-method: h2
 
-sql:
+data:
   address: localhost:3306
   database: minecraft
   username: root
   password: ''
+
+  # Set to -1 to disable. If this is the only instance accessing the datastore, you can disable syncing.
+  # e.g. if you're using sqlite or flatfile, this can be set to -1 to save resources.
   sync-minutes: 3

common/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <artifactId>luckperms</artifactId>
         <groupId>me.lucko.luckperms</groupId>
-        <version>2.2</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,12 +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,41 +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.LuckPermsPlugin;
-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.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 LuckPermsPlugin plugin;
-    private final me.lucko.luckperms.data.Datastore master;
+    private final me.lucko.luckperms.storage.Datastore master;
     private final Async async;
     private final Sync sync;
+    private final Future future;
 
-    public DatastoreLink(@NonNull LuckPermsPlugin plugin, @NonNull me.lucko.luckperms.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;
     }
@@ -72,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) {
@@ -171,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) {
@@ -257,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 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() {
@@ -78,8 +79,14 @@ public class LPConfigurationLink implements LPConfiguration {
         return master.getApplyShorthand();
     }
 
+    @SuppressWarnings("deprecation")
     @Override
     public MySQLConfiguration getDatabaseValues() {
+        return getDatastoreConfig();
+    }
+
+    @Override
+    public DatastoreConfiguration getDatastoreConfig() {
         return master.getDatabaseValues();
     }
 

common/src/main/java/me/lucko/luckperms/api/implementation/internal/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() {

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

@@ -50,7 +50,7 @@ class Utils {
     }
 
     static String checkUsername(String s) {
-        if (!ArgumentChecker.checkUsername(s)) {
+        if (ArgumentChecker.checkUsername(s)) {
             throw new IllegalArgumentException("Invalid username entry '" + s + "'. Usernames must be less than 16 chars" +
                     " and only contain 'a-z A-Z 1-9 _'.");
         }
@@ -58,7 +58,7 @@ class Utils {
     }
 
     static String checkName(String s) {
-        if (!ArgumentChecker.checkName(s)) {
+        if (ArgumentChecker.checkName(s)) {
             throw new IllegalArgumentException("Invalid name entry '" + s + "'. Names must be less than 37 chars" +
                     " and only contain 'a-z A-Z 1-9'.");
         }
@@ -66,21 +66,21 @@ class Utils {
     }
 
     static String checkServer(String s) {
-        if (!ArgumentChecker.checkServer(s)) {
+        if (ArgumentChecker.checkServer(s)) {
             throw new IllegalArgumentException("Invalid server entry '" + s + "'. Server names can only contain alphanumeric characters.");
         }
         return s;
     }
 
     static String checkNode(String s) {
-        if (!ArgumentChecker.checkNode(s)) {
+        if (ArgumentChecker.checkNode(s)) {
             throw new IllegalArgumentException("Invalid node entry '" + s + "'. Nodes cannot contain '/' or '$' characters.");
         }
         return s;
     }
 
     static long checkTime(long l) {
-        if (!ArgumentChecker.checkTime(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 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,10 +23,12 @@
 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.utils.ArgumentChecker;
 
 import java.util.List;
@@ -37,31 +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 (!ArgumentChecker.checkName(groupName)) {
+        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,10 +23,12 @@
 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.ArgumentChecker;
 
@@ -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 (!ArgumentChecker.checkName(groupName)) {
+        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,10 +22,12 @@
 
 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.ArgumentChecker;
@@ -35,34 +37,53 @@ 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 (!ArgumentChecker.checkName(target)) {
+    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,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,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 (!ArgumentChecker.checkServer(args.get(1))) {
+            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,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,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 (!ArgumentChecker.checkServer(args.get(1))) {
+            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,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.exceptions.ObjectAlreadyHasException;
 import me.lucko.luckperms.groups.Group;
 import me.lucko.luckperms.utils.ArgumentChecker;
@@ -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 (!ArgumentChecker.checkNode(groupName)) {
+        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 (!ArgumentChecker.checkServer(server)) {
-                            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,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.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.Patterns;
 
 import java.util.List;
 
@@ -42,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 (!ArgumentChecker.checkNode(node)) {
+        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);
@@ -66,33 +68,44 @@ public class GroupSetPermission extends SubCommand<Group> {
         try {
             if (args.size() >= 3) {
                 final String server = args.get(2).toLowerCase();
-                if (!ArgumentChecker.checkServer(server)) {
+                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,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.exceptions.ObjectAlreadyHasException;
 import me.lucko.luckperms.groups.Group;
 import me.lucko.luckperms.utils.ArgumentChecker;
@@ -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 (!ArgumentChecker.checkNode(groupName)) {
+        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 (!ArgumentChecker.checkServer(server)) {
-                            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,16 +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;
 
@@ -44,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 (!ArgumentChecker.checkNode(node)) {
+        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 (!ArgumentChecker.checkServer(server)) {
+                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,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.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.ArgumentChecker;
-import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
@@ -42,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 (!ArgumentChecker.checkNode(node)) {
+        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 (!ArgumentChecker.checkServer(server)) {
+                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,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.exceptions.ObjectLacksException;
 import me.lucko.luckperms.groups.Group;
 import me.lucko.luckperms.utils.ArgumentChecker;
@@ -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 (!ArgumentChecker.checkNode(groupName)) {
+        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 (!ArgumentChecker.checkServer(server)) {
+                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,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.exceptions.ObjectLacksException;
 import me.lucko.luckperms.groups.Group;
 import me.lucko.luckperms.utils.ArgumentChecker;
@@ -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 (!ArgumentChecker.checkNode(groupName)) {
+        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 (!ArgumentChecker.checkServer(server)) {
+                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,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.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.ArgumentChecker;
-import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
@@ -43,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 (!ArgumentChecker.checkNode(node)) {
+        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 (!ArgumentChecker.checkServer(server)) {
+                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(), c.getApplyWildcards());
+        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,10 +23,12 @@
 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.utils.ArgumentChecker;
 
 import java.util.List;
@@ -37,31 +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 (!ArgumentChecker.checkName(trackName)) {
+        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,10 +23,12 @@
 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.ArgumentChecker;
 
@@ -41,50 +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 (!ArgumentChecker.checkName(trackName)) {
+        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,10 +22,12 @@
 
 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;
@@ -35,33 +37,44 @@ 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) {
-        if (!ArgumentChecker.checkName(target)) {
+    protected Track getTarget(String target, LuckPermsPlugin plugin, Sender sender) {
+        if (ArgumentChecker.checkName(target)) {
             Message.TRACK_INVALID_ENTRY.send(sender);
-            return;
+            return null;
         }
-        plugin.getDatastore().loadTrack(target, success -> {
-            if (!success) {
-                Message.TRACK_NOT_FOUND.send(sender);
-                return;
-            }
 
-            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,11 +23,13 @@
 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;
@@ -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 (!ArgumentChecker.checkNode(groupName)) {
+        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 (!ArgumentChecker.checkServer(server)) {
-                            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,11 +23,13 @@
 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;
@@ -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 (!ArgumentChecker.checkNode(groupName)) {
+        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 (!ArgumentChecker.checkServer(server)) {
-                            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);
     }
 }

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

@@ -23,11 +23,13 @@
 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.users.User;
 
 import java.util.List;
@@ -39,11 +41,13 @@ public class UserClear 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) {
         user.clearNodes();
         plugin.getUserManager().giveDefaults(user);
         Message.CLEAR_SUCCESS.send(sender, user.getName());
+        LogEntry.build().actor(sender).acted(user).action("clear").build().submit(plugin);
 
-        saveUser(user, sender, plugin);
+        save(user, sender, plugin);
+        return CommandResult.SUCCESS;
     }
 }

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

@@ -23,12 +23,10 @@
 package me.lucko.luckperms.commands.user.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.exceptions.ObjectLacksException;
 import me.lucko.luckperms.groups.Group;
@@ -45,73 +43,75 @@ public class UserDemote 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) {
         final String trackName = args.get(0).toLowerCase();
-        if (!ArgumentChecker.checkName(trackName)) {
+        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 {
-                Track track = plugin.getTrackManager().getTrack(trackName);
-                if (track == null) {
-                    Message.TRACK_DOES_NOT_EXIST.send(sender);
-                    return;
-                }
+        if (!plugin.getDatastore().loadTrack(trackName)) {
+            Message.TRACK_DOES_NOT_EXIST.send(sender);
+            return CommandResult.INVALID_ARGS;
+        }
 
-                if (track.getSize() <= 1) {
-                    Message.TRACK_EMPTY.send(sender);
-                    return;
-                }
+        Track track = plugin.getTrackManager().get(trackName);
+        if (track == null) {
+            Message.TRACK_DOES_NOT_EXIST.send(sender);
+            return CommandResult.LOADING_ERROR;
+        }
 
-                final String old = user.getPrimaryGroup();
-                final String previous;
-                try {
-                    previous = track.getPrevious(old);
-                } catch (ObjectLacksException e) {
-                    Message.TRACK_DOES_NOT_CONTAIN.send(sender, track.getName(), old);
-                    Message.USER_DEMOTE_ERROR_NOT_CONTAIN_GROUP.send(sender);
-                    return;
-                }
+        if (track.getSize() <= 1) {
+            Message.TRACK_EMPTY.send(sender);
+            return CommandResult.STATE_ERROR;
+        }
 
-                if (previous == null) {
-                    Message.USER_DEMOTE_ERROR_ENDOFTRACK.send(sender, track.getName());
-                    return;
-                }
+        final String old = user.getPrimaryGroup();
+        final String previous;
+        try {
+            previous = track.getPrevious(old);
+        } catch (ObjectLacksException e) {
+            Message.TRACK_DOES_NOT_CONTAIN.send(sender, track.getName(), old);
+            Message.USER_DEMOTE_ERROR_NOT_CONTAIN_GROUP.send(sender);
+            return CommandResult.STATE_ERROR;
+        }
 
-                plugin.getDatastore().loadGroup(previous, success1 -> {
-                    if (!success1) {
-                        Message.USER_DEMOTE_ERROR_MALFORMED.send(sender, previous);
-                    } else {
-                        Group previousGroup = plugin.getGroupManager().getGroup(previous);
-                        if (previousGroup == null) {
-                            Message.USER_DEMOTE_ERROR_MALFORMED.send(sender, previous);
-                            return;
-                        }
+        if (previous == null) {
+            Message.USER_DEMOTE_ERROR_ENDOFTRACK.send(sender, track.getName());
+            return CommandResult.STATE_ERROR;
+        }
 
-                        try {
-                            user.unsetPermission("group." + old);
-                        } catch (ObjectLacksException ignored) {}
-                        try {
-                            user.addGroup(previousGroup);
-                        } catch (ObjectAlreadyHasException ignored) {}
-                        user.setPrimaryGroup(previousGroup.getName());
+        if (!plugin.getDatastore().loadGroup(previous)) {
+            Message.USER_DEMOTE_ERROR_MALFORMED.send(sender, previous);
+            return CommandResult.STATE_ERROR;
+        }
 
-                        Message.USER_DEMOTE_SUCCESS_PROMOTE.send(sender, track.getName(), old, previousGroup.getName());
-                        Message.USER_DEMOTE_SUCCESS_REMOVE.send(sender, user.getName(), old, previousGroup.getName(), previousGroup.getName());
-                        Message.EMPTY.send(sender, Util.listToArrowSep(track.getGroups(), previousGroup.getName(), old, true));
-                        saveUser(user, sender, plugin);
-                    }
-                });
-            }
-        });
+        Group previousGroup = plugin.getGroupManager().get(previous);
+        if (previousGroup == null) {
+            Message.USER_DEMOTE_ERROR_MALFORMED.send(sender, previous);
+            return CommandResult.LOADING_ERROR;
+        }
+
+        try {
+            user.unsetPermission("group." + old);
+        } catch (ObjectLacksException ignored) {}
+        try {
+            user.addGroup(previousGroup);
+        } catch (ObjectAlreadyHasException ignored) {}
+        user.setPrimaryGroup(previousGroup.getName());
+
+        Message.USER_DEMOTE_SUCCESS_PROMOTE.send(sender, track.getName(), old, previousGroup.getName());
+        Message.USER_DEMOTE_SUCCESS_REMOVE.send(sender, user.getName(), old, previousGroup.getName(), previousGroup.getName());
+        Message.EMPTY.send(sender, Util.listToArrowSep(track.getGroups(), previousGroup.getName(), old, true));
+        LogEntry.build().actor(sender).acted(user)
+                .action("demote " + track.getName() + "(from " + old + " to " + previousGroup.getName() + ")")
+                .build().submit(plugin);
+        save(user, sender, plugin);
+        return CommandResult.SUCCESS;
     }
 
     @Override
-    public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+    public List<String> onTabComplete(LuckPermsPlugin plugin, Sender sender, List<String> args) {
         return getTrackTabComplete(args, plugin);
     }
 }

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

@@ -23,6 +23,7 @@
 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;
@@ -39,7 +40,8 @@ public class UserGetUUID 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) {
         Message.USER_GETUUID.send(sender, user.getName(), user.getUuid().toString());
+        return CommandResult.SUCCESS;
     }
 }

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

@@ -23,10 +23,7 @@
 package me.lucko.luckperms.commands.user.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.users.User;
@@ -42,11 +39,11 @@ public class UserHasPerm 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) {
         if (args.size() >= 2) {
-            if (!ArgumentChecker.checkServer(args.get(1))) {
+            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 UserHasPerm extends SubCommand<User> {
         } else {
             Util.sendBoolean(sender, args.get(0), user.hasPermission(args.get(0), true, "global"));
         }
+        return CommandResult.SUCCESS;
     }
 }

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

@@ -23,10 +23,7 @@
 package me.lucko.luckperms.commands.user.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.users.User;
@@ -39,10 +36,18 @@ public class UserInfo extends SubCommand<User> {
     }
 
     @Override
-    public void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
-        Message.USER_INFO.send(sender, user.getName(), user.getUuid(), plugin.getPlayerStatus(user.getUuid()),
-                Util.listToCommaSep(user.getGroupNames()), user.getPrimaryGroup(),
-                user.getPermanentNodes().keySet().size(), user.getTemporaryNodes().keySet().size(), label, user.getName()
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+        Message.USER_INFO.send(sender,
+                user.getName(),
+                user.getUuid(),
+                plugin.getPlayerStatus(user.getUuid()),
+                Util.listToCommaSep(user.getGroupNames()),
+                user.getPrimaryGroup(),
+                user.getPermanentNodes().keySet().size(),
+                user.getTemporaryNodes().keySet().size(),
+                label,
+                user.getName()
         );
+        return CommandResult.SUCCESS;
     }
 }

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

@@ -23,10 +23,7 @@
 package me.lucko.luckperms.commands.user.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.users.User;
@@ -42,11 +39,11 @@ public class UserInheritsPerm 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) {
         if (args.size() >= 2) {
-            if (!ArgumentChecker.checkServer(args.get(1))) {
+            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 UserInheritsPerm extends SubCommand<User> {
         } else {
             Util.sendBoolean(sender, args.get(0), user.inheritsPermission(args.get(0), true));
         }
+        return CommandResult.SUCCESS;
     }
 }

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

@@ -23,10 +23,7 @@
 package me.lucko.luckperms.commands.user.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.users.User;
@@ -40,8 +37,9 @@ public class UserListNodes 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) {
         Message.LISTNODES.send(sender, user.getName(), Util.permNodesToString(user.getPermanentNodes()));
         Message.LISTNODES_TEMP.send(sender, user.getName(), Util.tempNodesToString(user.getTemporaryNodes()));
+        return CommandResult.SUCCESS;
     }
 }

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

@@ -23,12 +23,10 @@
 package me.lucko.luckperms.commands.user.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.exceptions.ObjectLacksException;
 import me.lucko.luckperms.groups.Group;
@@ -45,73 +43,75 @@ public class UserPromote 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) {
         final String trackName = args.get(0).toLowerCase();
-        if (!ArgumentChecker.checkName(trackName)) {
+        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 {
-                Track track = plugin.getTrackManager().getTrack(trackName);
-                if (track == null) {
-                    Message.TRACK_DOES_NOT_EXIST.send(sender);
-                    return;
-                }
+        if (!plugin.getDatastore().loadTrack(trackName)) {
+            Message.TRACK_DOES_NOT_EXIST.send(sender);
+            return CommandResult.INVALID_ARGS;
+        }
 
-                if (track.getSize() <= 1) {
-                    Message.TRACK_EMPTY.send(sender);
-                    return;
-                }
+        Track track = plugin.getTrackManager().get(trackName);
+        if (track == null) {
+            Message.TRACK_DOES_NOT_EXIST.send(sender);
+            return CommandResult.LOADING_ERROR;
+        }
 
-                final String old = user.getPrimaryGroup();
-                final String next;
-                try {
-                    next = track.getNext(old);
-                } catch (ObjectLacksException e) {
-                    Message.TRACK_DOES_NOT_CONTAIN.send(sender, track.getName(), old);
-                    Message.USER_PROMOTE_ERROR_NOT_CONTAIN_GROUP.send(sender);
-                    return;
-                }
+        if (track.getSize() <= 1) {
+            Message.TRACK_EMPTY.send(sender);
+            return CommandResult.STATE_ERROR;
+        }
 
-                if (next == null) {
-                    Message.USER_PROMOTE_ERROR_ENDOFTRACK.send(sender, track.getName());
-                    return;
-                }
+        final String old = user.getPrimaryGroup();
+        final String next;
+        try {
+            next = track.getNext(old);
+        } catch (ObjectLacksException e) {
+            Message.TRACK_DOES_NOT_CONTAIN.send(sender, track.getName(), old);
+            Message.USER_PROMOTE_ERROR_NOT_CONTAIN_GROUP.send(sender);
+            return CommandResult.STATE_ERROR;
+        }
 
-                plugin.getDatastore().loadGroup(next, success1 -> {
-                    if (!success1) {
-                        Message.USER_PROMOTE_ERROR_MALFORMED.send(sender, next);
-                    } else {
-                        Group nextGroup = plugin.getGroupManager().getGroup(next);
-                        if (nextGroup == null) {
-                            Message.USER_PROMOTE_ERROR_MALFORMED.send(sender, next);
-                            return;
-                        }
+        if (next == null) {
+            Message.USER_PROMOTE_ERROR_ENDOFTRACK.send(sender, track.getName());
+            return CommandResult.STATE_ERROR;
+        }
 
-                        try {
-                            user.unsetPermission("group." + old);
-                        } catch (ObjectLacksException ignored) {}
-                        try {
-                            user.addGroup(nextGroup);
-                        } catch (ObjectAlreadyHasException ignored) {}
-                        user.setPrimaryGroup(nextGroup.getName());
+        if (!plugin.getDatastore().loadGroup(next)) {
+            Message.USER_PROMOTE_ERROR_MALFORMED.send(sender, next);
+            return CommandResult.STATE_ERROR;
+        }
 
-                        Message.USER_PROMOTE_SUCCESS_PROMOTE.send(sender, track.getName(), old, nextGroup.getName());
-                        Message.USER_PROMOTE_SUCCESS_REMOVE.send(sender, user.getName(), old, nextGroup.getName(), nextGroup.getName());
-                        Message.EMPTY.send(sender, Util.listToArrowSep(track.getGroups(), old, nextGroup.getName(), false));
-                        saveUser(user, sender, plugin);
-                    }
-                });
-            }
-        });
+        Group nextGroup = plugin.getGroupManager().get(next);
+        if (nextGroup == null) {
+            Message.USER_PROMOTE_ERROR_MALFORMED.send(sender, next);
+            return CommandResult.LOADING_ERROR;
+        }
+
+        try {
+            user.unsetPermission("group." + old);
+        } catch (ObjectLacksException ignored) {}
+        try {
+            user.addGroup(nextGroup);
+        } catch (ObjectAlreadyHasException ignored) {}
+        user.setPrimaryGroup(nextGroup.getName());
+
+        Message.USER_PROMOTE_SUCCESS_PROMOTE.send(sender, track.getName(), old, nextGroup.getName());
+        Message.USER_PROMOTE_SUCCESS_REMOVE.send(sender, user.getName(), old, nextGroup.getName(), nextGroup.getName());
+        Message.EMPTY.send(sender, Util.listToArrowSep(track.getGroups(), old, nextGroup.getName(), false));
+        LogEntry.build().actor(sender).acted(user)
+                .action("promote " + track.getName() + "(from " + old + " to " + nextGroup.getName() + ")")
+                .build().submit(plugin);
+        save(user, sender, plugin);
+        return CommandResult.SUCCESS;
     }
 
     @Override
-    public List<String> onTabComplete(Sender sender, List<String> args, LuckPermsPlugin plugin) {
+    public List<String> onTabComplete(LuckPermsPlugin plugin, Sender sender, List<String> args) {
         return getTrackTabComplete(args, plugin);
     }
 }