Add logging, prepare for import/export system

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

@@ -23,15 +23,17 @@
 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.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.util.List;
+import java.util.Set;
 import java.util.UUID;
 
 /**
@@ -106,12 +108,24 @@ 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 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
@@ -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

@@ -27,11 +27,11 @@ import me.lucko.luckperms.api.LPConfiguration;
 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() {

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,13 +22,16 @@
 
 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.InfoCommand;
 import me.lucko.luckperms.commands.misc.SyncCommand;
@@ -36,9 +39,7 @@ 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 +48,41 @@ 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 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 +92,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;
+        }
     }
 
     /**
@@ -182,11 +163,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,44 @@ 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,9 +115,10 @@ 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
@@ -174,10 +186,6 @@ public abstract class MainCommand<T> {
             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,7 +144,7 @@ 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 -> {
@@ -156,7 +156,7 @@ public abstract class SubCommand<T> {
         });
     }
 
-    protected static void saveGroup(Group group, Sender sender, LuckPermsPlugin plugin) {
+    protected static void save(Group group, Sender sender, LuckPermsPlugin plugin) {
         plugin.getDatastore().saveGroup(group, success -> {
             if (success) {
                 Message.GROUP_SAVE_SUCCESS.send(sender);
@@ -168,7 +168,7 @@ public abstract class SubCommand<T> {
         });
     }
 
-    protected static void saveTrack(Track track, Sender sender, LuckPermsPlugin plugin) {
+    protected static void save(Track track, Sender sender, LuckPermsPlugin plugin) {
         plugin.getDatastore().saveTrack(track, success -> {
             if (success) {
                 Message.TRACK_SAVE_SUCCESS.send(sender);

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.LogEntryBuilder;
 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);
+        LogEntryBuilder.get().actor(sender).actedName(groupName).type('G').action("create").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.LogEntryBuilder;
 import me.lucko.luckperms.groups.Group;
 import me.lucko.luckperms.utils.ArgumentChecker;
 
@@ -41,49 +43,49 @@ 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);
+        LogEntryBuilder.get().actor(sender).actedName(groupName).type('G').action("delete").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("")) {

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.LogEntryBuilder;
 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);
+        LogEntryBuilder.get().actor(sender).acted(group).action("clear").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.LogEntryBuilder;
 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);
+                    LogEntryBuilder.get().actor(sender).acted(group)
+                            .action("setinherit " + group1.getName() + " " + server)
+                            .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);
+                    LogEntryBuilder.get().actor(sender).acted(group)
+                            .action("setinherit " + group1.getName() + " " + server + " " + world)
+                            .submit(plugin);
+                }
+
+            } else {
+                group.setInheritGroup(group1);
+                Message.GROUP_SETINHERIT_SUCCESS.send(sender, group.getName(), group1.getName());
+                LogEntryBuilder.get().actor(sender).acted(group)
+                        .action("setinherit " + group1.getName())
+                        .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.LogEntryBuilder;
 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);
+                    LogEntryBuilder.get().actor(sender).acted(group)
+                            .action("set " + node + " " + b + " " + server)
+                            .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);
+                    LogEntryBuilder.get().actor(sender).acted(group)
+                            .action("set " + node + " " + b + " " + server + " " + world)
+                            .submit(plugin);
                 }
 
             } else {
                 group.setPermission(node, b);
                 Message.SETPERMISSION_SUCCESS.send(sender, node, bool, group.getName());
+                LogEntryBuilder.get().actor(sender).acted(group)
+                        .action("set " + node + " " + b)
+                        .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.LogEntryBuilder;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
 import me.lucko.luckperms.groups.Group;
 import me.lucko.luckperms.utils.ArgumentChecker;
@@ -43,12 +45,12 @@ 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;
@@ -56,52 +58,68 @@ public class GroupSetTempInherit extends SubCommand<Group> {
             duration = DateUtil.parseDateDiff(args.get(1), true);
         } catch (DateUtil.IllegalDateException e) {
             Message.ILLEGAL_DATE_ERROR.send(sender, args.get(1));
-            return;
+            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));
+                    LogEntryBuilder.get().actor(sender).acted(group)
+                            .action("settempinherit " + group1.getName() + " " + duration + " " + server)
+                            .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));
+                    LogEntryBuilder.get().actor(sender).acted(group)
+                            .action("settempinherit " + group1.getName() + " " + duration + " " + server + " " + world)
+                            .submit(plugin);
+                }
+
+            } else {
+                group.setInheritGroup(group1, duration);
+                Message.GROUP_SET_TEMP_INHERIT_SUCCESS.send(sender, group.getName(), group1.getName(), DateUtil.formatDateDiff(duration));
+                LogEntryBuilder.get().actor(sender).acted(group)
+                        .action("settempinherit " + group1.getName() + " " + duration)
+                        .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.LogEntryBuilder;
 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,23 +46,23 @@ 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);
@@ -70,46 +72,57 @@ public class GroupSetTempPermission extends SubCommand<Group> {
             duration = DateUtil.parseDateDiff(args.get(2), true);
         } catch (DateUtil.IllegalDateException e) {
             Message.ILLEGAL_DATE_ERROR.send(sender, args.get(2));
-            return;
+            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));
+                    LogEntryBuilder.get().actor(sender).acted(group)
+                            .action("settemp " + node + " " + b + " " + duration + " " + server)
+                            .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));
+                    LogEntryBuilder.get().actor(sender).acted(group)
+                            .action("settemp " + node + " " + b + " " + duration + " " + server + " " + world)
+                            .submit(plugin);
                 }
 
             } else {
                 group.setPermission(node, b, duration);
                 Message.SETPERMISSION_TEMP_SUCCESS.send(sender, node, bool, group.getName(), DateUtil.formatDateDiff(duration));
+                LogEntryBuilder.get().actor(sender).acted(group)
+                        .action("settemp " + node + " " + b + " " + duration)
+                        .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.LogEntryBuilder;
 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);
+                    LogEntryBuilder.get().actor(sender).acted(group)
+                            .action("unset " + node + " " + server)
+                            .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);
+                    LogEntryBuilder.get().actor(sender).acted(group)
+                            .action("unset " + node + " " + server + " " + world)
+                            .submit(plugin);
                 }
 
             } else {
                 group.unsetPermission(node);
                 Message.UNSETPERMISSION_SUCCESS.send(sender, node, group.getName());
+                LogEntryBuilder.get().actor(sender).acted(group)
+                        .action("unset " + node)
+                        .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.LogEntryBuilder;
 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);
+                    LogEntryBuilder.get().actor(sender).acted(group)
+                            .action("unsetinherit " + groupName + " " + server)
+                            .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);
+                    LogEntryBuilder.get().actor(sender).acted(group)
+                            .action("unsetinherit " + groupName + " " + server + " " + world)
+                            .submit(plugin);
                 }
 
             } else {
                 group.unsetPermission("group." + groupName);
                 Message.GROUP_UNSETINHERIT_SUCCESS.send(sender, group.getName(), groupName);
+                LogEntryBuilder.get().actor(sender).acted(group)
+                        .action("unsetinherit " + groupName)
+                        .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.LogEntryBuilder;
 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);
+                    LogEntryBuilder.get().actor(sender).acted(group)
+                            .action("unsettempinherit " + groupName + " " + server)
+                            .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);
+                    LogEntryBuilder.get().actor(sender).acted(group)
+                            .action("unsettempinherit " + groupName + " " + server + " " + world)
+                            .submit(plugin);
                 }
 
             } else {
                 group.unsetPermission("group." + groupName, true);
                 Message.GROUP_UNSET_TEMP_INHERIT_SUCCESS.send(sender, group.getName(), groupName);
+                LogEntryBuilder.get().actor(sender).acted(group)
+                        .action("unsettempinherit " + groupName)
+                        .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.LogEntryBuilder;
 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);
+                    LogEntryBuilder.get().actor(sender).acted(group)
+                            .action("unsettemp " + node + " " + server)
+                            .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);
+                    LogEntryBuilder.get().actor(sender).acted(group)
+                            .action("unsettemp " + node + " " + server + " " + world)
+                            .submit(plugin);
                 }
 
             } else {
                 group.unsetPermission(node, true);
                 Message.UNSET_TEMP_PERMISSION_SUCCESS.send(sender, node, group.getName());
+                LogEntryBuilder.get().actor(sender).acted(group)
+                        .action("unsettemp " + node)
+                        .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,93 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.commands.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(SubCommand::getName).map(String::toLowerCase).collect(Collectors.toList());
+            }
+
+            return subs.stream().map(SubCommand::getName).map(String::toLowerCase)
+                    .filter(s -> s.toLowerCase().startsWith(args.get(0).toLowerCase())).collect(Collectors.toList());
+        }
+
+        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,45 @@
+/*
+ * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.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.Permission;
+import me.lucko.luckperms.data.Log;
+
+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) {
+        // TODO: implement this
+        return CommandResult.SUCCESS;
+    }
+}

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);
+        final int[] page = {-999};
+
+        if (args.size() == 2) {
+            try {
+                page[0] = 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[0] == -999) {
+                page[0] = log.getUserHistoryMaxPages(uuid);
+            }
+
+            return showLog(page[0], 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[0] == -999) {
+                page[0] = log.getUserHistoryMaxPages(uuid1);
+            }
+
+            return showLog(page[0], 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/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.LogEntryBuilder;
 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);
+        LogEntryBuilder.get().actor(sender).actedName(trackName).type('T').action("create").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.LogEntryBuilder;
 import me.lucko.luckperms.tracks.Track;
 import me.lucko.luckperms.utils.ArgumentChecker;
 
@@ -41,43 +43,43 @@ 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);
+        LogEntryBuilder.get().actor(sender).actedName(trackName).type('T').action("delete").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("")) {

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.LogEntryBuilder;
 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()));
+            LogEntryBuilder.get().actor(sender).acted(track)
+                    .action("append " + group.getName())
+                    .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.LogEntryBuilder;
 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);
+        LogEntryBuilder.get().actor(sender).acted(track).action("clear").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.LogEntryBuilder;
 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()));
+            LogEntryBuilder.get().actor(sender).acted(track)
+                    .action("insert " + group.getName() + " " + pos)
+                    .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.LogEntryBuilder;
 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()));
+            LogEntryBuilder.get().actor(sender).acted(track)
+                    .action("remove " + groupName)
+                    .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.LogEntryBuilder;
 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);
+                    LogEntryBuilder.get().actor(sender).acted(user)
+                            .action("addgroup " + group.getName() + " " + server)
+                            .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);
+                    LogEntryBuilder.get().actor(sender).acted(user)
+                            .action("addgroup " + group.getName() + " " + server + " " + world)
+                            .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);
+                LogEntryBuilder.get().actor(sender).acted(user)
+                        .action("addgroup " + group.getName())
+                        .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.LogEntryBuilder;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
 import me.lucko.luckperms.groups.Group;
 import me.lucko.luckperms.users.User;
@@ -44,12 +46,12 @@ 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;
@@ -57,58 +59,68 @@ public class UserAddTempGroup extends SubCommand<User> {
             duration = DateUtil.parseDateDiff(args.get(1), true);
         } catch (DateUtil.IllegalDateException e) {
             Message.ILLEGAL_DATE_ERROR.send(sender, args.get(1));
-            return;
+            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));
+                    LogEntryBuilder.get().actor(sender).acted(user)
+                            .action("addtempgroup " + group.getName() + " " + duration + " " + server)
+                            .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));
+                    LogEntryBuilder.get().actor(sender).acted(user)
+                            .action("addtempgroup " + group.getName() + " " + duration + " " + server + " " + world)
+                            .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));
+                LogEntryBuilder.get().actor(sender).acted(user)
+                        .action("addtempgroup " + group.getName() + " " + duration)
+                        .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.LogEntryBuilder;
 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());
+        LogEntryBuilder.get().actor(sender).acted(user).action("clear").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.LogEntryBuilder;
 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));
+        LogEntryBuilder.get().actor(sender).acted(user)
+                .action("demote " + track.getName() + "(from " + old + " to " + previousGroup.getName() + ")")
+                .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.LogEntryBuilder;
 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));
+        LogEntryBuilder.get().actor(sender).acted(user)
+                .action("promote " + track.getName() + "(from " + old + " to " + nextGroup.getName() + ")")
+                .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/UserRemoveGroup.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.LogEntryBuilder;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
 import me.lucko.luckperms.users.User;
 import me.lucko.luckperms.utils.ArgumentChecker;
@@ -41,50 +43,61 @@ public class UserRemoveGroup 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;
         }
 
         if ((args.size() == 1 || (args.size() == 2 && args.get(1).equalsIgnoreCase("global")))
                 && user.getPrimaryGroup().equalsIgnoreCase(groupName)) {
             Message.USER_REMOVEGROUP_ERROR_PRIMARY.send(sender);
-            return;
+            return CommandResult.STATE_ERROR;
         }
 
         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) {
                     user.unsetPermission("group." + groupName, server);
                     Message.USER_REMOVEGROUP_SERVER_SUCCESS.send(sender, user.getName(), groupName, server);
+                    LogEntryBuilder.get().actor(sender).acted(user)
+                            .action("removegroup " + groupName + " " + server)
+                            .submit(plugin);
                 } else {
                     final String world = args.get(2).toLowerCase();
                     user.unsetPermission("group." + groupName, server, world);
                     Message.USER_REMOVEGROUP_SERVER_WORLD_SUCCESS.send(sender, user.getName(), groupName, server, world);
+                    LogEntryBuilder.get().actor(sender).acted(user)
+                            .action("removegroup " + groupName + " " + server + " " + world)
+                            .submit(plugin);
                 }
 
             } else {
                 user.unsetPermission("group." + groupName);
                 Message.USER_REMOVEGROUP_SUCCESS.send(sender, user.getName(), groupName);
+                LogEntryBuilder.get().actor(sender).acted(user)
+                        .action("removegroup " + groupName)
+                        .submit(plugin);
             }
 
-            saveUser(user, sender, plugin);
+            save(user, sender, plugin);
+            return CommandResult.SUCCESS;
         } catch (ObjectLacksException e) {
             Message.USER_NOT_MEMBER_OF.send(sender, user.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/subcommands/UserRemoveTempGroup.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.LogEntryBuilder;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
 import me.lucko.luckperms.users.User;
 import me.lucko.luckperms.utils.ArgumentChecker;
@@ -42,44 +44,55 @@ public class UserRemoveTempGroup 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;
         }
 
         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) {
                     user.unsetPermission("group." + groupName, server, true);
                     Message.USER_REMOVETEMPGROUP_SERVER_SUCCESS.send(sender, user.getName(), groupName, server);
+                    LogEntryBuilder.get().actor(sender).acted(user)
+                            .action("removetempgroup " + groupName + " " + server)
+                            .submit(plugin);
                 } else {
                     final String world = args.get(2).toLowerCase();
                     user.unsetPermission("group." + groupName, server, world, true);
                     Message.USER_REMOVETEMPGROUP_SERVER_WORLD_SUCCESS.send(sender, user.getName(), groupName, server, world);
+                    LogEntryBuilder.get().actor(sender).acted(user)
+                            .action("removetempgroup " + groupName + " " + server + " " + world)
+                            .submit(plugin);
                 }
 
             } else {
                 user.unsetPermission("group." + groupName, true);
                 Message.USER_REMOVETEMPGROUP_SUCCESS.send(sender, user.getName(), groupName);
+                LogEntryBuilder.get().actor(sender).acted(user)
+                        .action("removetempgroup " + groupName)
+                        .submit(plugin);
             }
 
-            saveUser(user, sender, plugin);
+            save(user, sender, plugin);
+            return CommandResult.SUCCESS;
         } catch (ObjectLacksException e) {
             Message.USER_NOT_TEMP_MEMBER_OF.send(sender, user.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/subcommands/UserSetPermission.java

@@ -23,15 +23,17 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.CommandResult;
 import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
 import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.constants.Patterns;
 import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.data.LogEntryBuilder;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
 import me.lucko.luckperms.users.User;
 import me.lucko.luckperms.utils.ArgumentChecker;
-import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
@@ -43,23 +45,23 @@ public class UserSetPermission 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 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.USER_USE_ADDGROUP.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);
@@ -67,33 +69,44 @@ public class UserSetPermission extends SubCommand<User> {
         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) {
                     user.setPermission(node, b, server);
                     Message.SETPERMISSION_SERVER_SUCCESS.send(sender, node, bool, user.getName(), server);
+                    LogEntryBuilder.get().actor(sender).acted(user)
+                            .action("set " + node + " " + b + " " + server)
+                            .submit(plugin);
                 } else {
                     final String world = args.get(3).toLowerCase();
                     user.setPermission(node, b, server, world);
                     Message.SETPERMISSION_SERVER_WORLD_SUCCESS.send(sender, node, bool, user.getName(), server, world);
+                    LogEntryBuilder.get().actor(sender).acted(user)
+                            .action("set " + node + " " + b + " " + server + " " + world)
+                            .submit(plugin);
                 }
 
             } else {
                 user.setPermission(node, b);
                 Message.SETPERMISSION_SUCCESS.send(sender, node, bool, user.getName());
+                LogEntryBuilder.get().actor(sender).acted(user)
+                        .action("set " + node + " " + b)
+                        .submit(plugin);
             }
 
-            saveUser(user, sender, plugin);
+            save(user, sender, plugin);
+            return CommandResult.SUCCESS;
         } catch (ObjectAlreadyHasException e) {
             Message.ALREADY_HASPERMISSION.send(sender, user.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/user/subcommands/UserSetPrimaryGroup.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.LogEntryBuilder;
 import me.lucko.luckperms.groups.Group;
 import me.lucko.luckperms.users.User;
 
@@ -40,31 +42,35 @@ public class UserSetPrimaryGroup extends SubCommand<User> {
     }
 
     @Override
-    public void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
-        Group group = plugin.getGroupManager().getGroup(args.get(0).toLowerCase());
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args, String label) {
+        Group group = plugin.getGroupManager().get(args.get(0).toLowerCase());
         if (group == null) {
             Message.GROUP_DOES_NOT_EXIST.send(sender);
-            return;
+            return CommandResult.INVALID_ARGS;
         }
 
         if (user.getPrimaryGroup().equalsIgnoreCase(group.getName())) {
             Message.USER_PRIMARYGROUP_ERROR_ALREADYHAS.send(sender);
-            return;
+            return CommandResult.STATE_ERROR;
         }
 
         if (!user.isInGroup(group)) {
             Message.USER_PRIMARYGROUP_ERROR_NOTMEMBER.send(sender, label);
-            return;
+            return CommandResult.STATE_ERROR;
         }
 
         user.setPrimaryGroup(group.getName());
         Message.USER_PRIMARYGROUP_SUCCESS.send(sender, user.getName(), group.getName());
+        LogEntryBuilder.get().actor(sender).acted(user)
+                .action("setprimarygroup " + group.getName())
+                .submit(plugin);
 
-        saveUser(user, sender, 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 getGroupTabComplete(args, plugin);
     }
 }

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

@@ -23,16 +23,18 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.CommandResult;
 import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
 import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.constants.Patterns;
 import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.data.LogEntryBuilder;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
 import me.lucko.luckperms.users.User;
 import me.lucko.luckperms.utils.ArgumentChecker;
 import me.lucko.luckperms.utils.DateUtil;
-import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
@@ -44,23 +46,23 @@ public class UserSetTempPermission 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 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.USER_USE_ADDGROUP.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);
@@ -70,44 +72,55 @@ public class UserSetTempPermission extends SubCommand<User> {
             duration = DateUtil.parseDateDiff(args.get(2), true);
         } catch (DateUtil.IllegalDateException e) {
             Message.ILLEGAL_DATE_ERROR.send(sender, args.get(2));
-            return;
+            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) {
                     user.setPermission(node, b, server, duration);
                     Message.SETPERMISSION_TEMP_SERVER_SUCCESS.send(sender, node, bool, user.getName(), server, DateUtil.formatDateDiff(duration));
+                    LogEntryBuilder.get().actor(sender).acted(user)
+                            .action("settemp " + node + " " + b + " " + duration + " " + server)
+                            .submit(plugin);
                 } else {
                     final String world = args.get(4).toLowerCase();
                     user.setPermission(node, b, server, world, duration);
                     Message.SETPERMISSION_TEMP_SERVER_WORLD_SUCCESS.send(sender, node, bool, user.getName(), server, world, DateUtil.formatDateDiff(duration));
+                    LogEntryBuilder.get().actor(sender).acted(user)
+                            .action("settemp " + node + " " + b + " " + duration + " " + server + " " + world)
+                            .submit(plugin);
                 }
 
             } else {
                 user.setPermission(node, b, duration);
                 Message.SETPERMISSION_TEMP_SUCCESS.send(sender, node, bool, user.getName(), DateUtil.formatDateDiff(duration));
+                LogEntryBuilder.get().actor(sender).acted(user)
+                        .action("settemp " + node + " " + b + " " + duration)
+                        .submit(plugin);
             }
 
-            saveUser(user, sender, plugin);
+            save(user, sender, plugin);
+            return CommandResult.SUCCESS;
         } catch (ObjectAlreadyHasException e) {
             Message.ALREADY_HAS_TEMP_PERMISSION.send(sender, user.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/user/subcommands/UserShowPos.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.tracks.Track;
@@ -42,40 +39,40 @@ public class UserShowPos 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;
+        }
 
-                if (!track.containsGroup(user.getPrimaryGroup())) {
-                    Message.TRACK_DOES_NOT_CONTAIN.send(sender, track.getName(), user.getPrimaryGroup());
-                    return;
-                }
+        if (track.getSize() <= 1) {
+            Message.TRACK_EMPTY.send(sender);
+            return CommandResult.STATE_ERROR;
+        }
 
-                Message.USER_SHOWPOS.send(sender, user.getName(), track.getName(), Util.listToArrowSep(track.getGroups(), user.getPrimaryGroup()));
-            }
-        });
+        if (!track.containsGroup(user.getPrimaryGroup())) {
+            Message.TRACK_DOES_NOT_CONTAIN.send(sender, track.getName(), user.getPrimaryGroup());
+            return CommandResult.STATE_ERROR;
+        }
+
+        Message.USER_SHOWPOS.send(sender, user.getName(), track.getName(), Util.listToArrowSep(track.getGroups(), user.getPrimaryGroup()));
+        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/UserShowTracks.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.tracks.Track;
@@ -42,16 +39,20 @@ public class UserShowTracks extends SubCommand<User> {
     }
 
     @Override
-    public void execute(LuckPermsPlugin plugin, Sender sender, User user, 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, User user, List<String> args, String label) {
+        if (!plugin.getDatastore().loadAllTracks()) {
+            Message.TRACKS_LOAD_ERROR.send(sender);
+            return CommandResult.LOADING_ERROR;
+        }
 
-            Message.USER_SHOWTRACKS_INFO.send(sender, user.getPrimaryGroup(), user.getName());
-            Message.TRACKS_LIST.send(sender, Util.listToCommaSep(
-                    plugin.getTrackManager().getApplicableTracks(user.getPrimaryGroup()).stream().map(Track::getName).collect(Collectors.toList())));
-        });
+        Message.USER_SHOWTRACKS_INFO.send(sender, user.getPrimaryGroup(), user.getName());
+        Message.TRACKS_LIST.send(sender,
+                Util.listToCommaSep(plugin.getTrackManager().getApplicableTracks(user.getPrimaryGroup()).stream()
+                        .map(Track::getName)
+                        .collect(Collectors.toList())
+                )
+        );
+
+        return CommandResult.SUCCESS;
     }
 }

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

@@ -23,15 +23,17 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.CommandResult;
 import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
 import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.constants.Patterns;
 import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.data.LogEntryBuilder;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
 import me.lucko.luckperms.users.User;
 import me.lucko.luckperms.utils.ArgumentChecker;
-import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
@@ -42,44 +44,55 @@ public class UserUnSetPermission 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 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.USER_USE_REMOVEGROUP.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) {
                     user.unsetPermission(node, server);
                     Message.UNSETPERMISSION_SERVER_SUCCESS.send(sender, node, user.getName(), server);
+                    LogEntryBuilder.get().actor(sender).acted(user)
+                            .action("unset " + node + " " + server)
+                            .submit(plugin);
                 } else {
                     final String world = args.get(2).toLowerCase();
                     user.unsetPermission(node, server, world);
                     Message.UNSETPERMISSION_SERVER_WORLD_SUCCESS.send(sender, node, user.getName(), server, world);
+                    LogEntryBuilder.get().actor(sender).acted(user)
+                            .action("unset " + node + " " + server + " " + world)
+                            .submit(plugin);
                 }
 
             } else {
                 user.unsetPermission(node);
                 Message.UNSETPERMISSION_SUCCESS.send(sender, node, user.getName());
+                LogEntryBuilder.get().actor(sender).acted(user)
+                        .action("unset " + node)
+                        .submit(plugin);
             }
 
-            saveUser(user, sender, plugin);
+            save(user, sender, plugin);
+            return CommandResult.SUCCESS;
         } catch (ObjectLacksException e) {
             Message.DOES_NOT_HAVEPERMISSION.send(sender, user.getName());
+            return CommandResult.STATE_ERROR;
         }
     }
 }

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

@@ -23,15 +23,17 @@
 package me.lucko.luckperms.commands.user.subcommands;
 
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.CommandResult;
 import me.lucko.luckperms.commands.Predicate;
 import me.lucko.luckperms.commands.Sender;
 import me.lucko.luckperms.commands.SubCommand;
 import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.constants.Patterns;
 import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.data.LogEntryBuilder;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
 import me.lucko.luckperms.users.User;
 import me.lucko.luckperms.utils.ArgumentChecker;
-import me.lucko.luckperms.utils.Patterns;
 
 import java.util.List;
 
@@ -43,44 +45,55 @@ public class UserUnsetTempPermission 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 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.USER_USE_REMOVEGROUP.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) {
                     user.unsetPermission(node, server, true);
                     Message.UNSET_TEMP_PERMISSION_SERVER_SUCCESS.send(sender, node, user.getName(), server);
+                    LogEntryBuilder.get().actor(sender).acted(user)
+                            .action("unsettemp " + node + " " + server)
+                            .submit(plugin);
                 } else {
                     final String world = args.get(2).toLowerCase();
                     user.unsetPermission(node, server, world, true);
                     Message.UNSET_TEMP_PERMISSION_SERVER_WORLD_SUCCESS.send(sender, node, user.getName(), server, world);
+                    LogEntryBuilder.get().actor(sender).acted(user)
+                            .action("unsettemp " + node + " " + server + " " + world)
+                            .submit(plugin);
                 }
 
             } else {
                 user.unsetPermission(node, true);
                 Message.UNSET_TEMP_PERMISSION_SUCCESS.send(sender, node, user.getName());
+                LogEntryBuilder.get().actor(sender).acted(user)
+                        .action("unsettemp " + node)
+                        .submit(plugin);
             }
 
-            saveUser(user, sender, plugin);
+            save(user, sender, plugin);
+            return CommandResult.SUCCESS;
         } catch (ObjectLacksException e) {
             Message.DOES_NOT_HAVE_TEMP_PERMISSION.send(sender, user.getName());
+            return CommandResult.STATE_ERROR;
         }
     }
 }

common/src/main/java/me/lucko/luckperms/constants/Constants.java

@@ -0,0 +1,48 @@
+/*
+ * 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.constants;
+
+import lombok.Getter;
+import lombok.experimental.UtilityClass;
+
+import java.util.UUID;
+
+@UtilityClass
+public class Constants {
+
+    @Getter
+    private static final UUID consoleUUID = UUID.fromString("00000000-0000-0000-0000-000000000000");
+
+    @Getter
+    private static final String consoleName = "Console";
+
+    @Getter
+    private static final UUID importerUUID = UUID.fromString("11111111-1111-1111-1111-111111111111");
+
+    @Getter
+    private static final String importerName = "Import";
+
+    @Getter
+    private static final String logFormat = "&8(&e%s&8)  [&a%s&8] (&b%s&8) &7--> &f%s";
+
+}

common/src/main/java/me/lucko/luckperms/constants/Message.java

@@ -38,6 +38,7 @@ public enum Message {
     PLAYER_ONLINE("&aOnline", false),
     PLAYER_OFFLINE("&cOffline", false),
     LOADING_ERROR("Permissions data could not be loaded. Please contact an administrator.", true),
+    LOG("&3LOG &3&l> %s", true),
 
     COMMAND_NOT_RECOGNISED("Command not recognised.", true),
     COMMAND_NO_PERMISSION("You do not have permission to use this command!", true),
@@ -57,6 +58,8 @@ public enum Message {
     USER_SAVE_SUCCESS("&7(User data was saved to the datastore)", true),
     USER_SAVE_ERROR("There was an error whilst saving the user.", true),
     USER_ATTEMPTING_LOOKUP("&7(Attempting UUID lookup, since you specified a username)", true),
+    USER_NEVER_JOINED("&6(&e&lWARNING: &cA user with that UUID has not joined the server before.&6)", true),
+    USER_CREATE_FAIL("There was an error whilst creating a new user.", true),
 
     GROUP_NOT_FOUND("&eGroup could not be found.", true),
     GROUP_SAVE_SUCCESS("&7(Group data was saved to the datastore)", true),
@@ -124,7 +127,9 @@ public enum Message {
             PREFIX + "&eSync Interval: &6%s minutes" + "\n" +
             PREFIX + "&eInclude Global Perms: &6%s" + "\n" +
             PREFIX + "&eOnline Mode: &6%s" + "\n" +
-            PREFIX + "&eApply Wildcards: &6%s",
+            PREFIX + "&eApply Wildcards: &6%s" + "\n" +
+            PREFIX + "&eApply Regex: &6%s" + "\n" +
+            PREFIX + "&eApply Shorthand: &6%s",
             false
     ),
     DEBUG(
@@ -242,7 +247,45 @@ public enum Message {
     TRACK_INSERT_SUCCESS("&aGroup &b%s&a was successfully inserted into track &b%s&a at position &b%s&a.", true),
     TRACK_INSERT_ERROR_NUMBER("Expected number but instead received: %s", true),
     TRACK_INSERT_ERROR_INVALID_POS("Unable to insert at position %s. Index out of bounds.", true),
-    TRACK_REMOVE_SUCCESS("&aGroup &b%s&a was successfully removed from track &b%s&a.", true);
+    TRACK_REMOVE_SUCCESS("&aGroup &b%s&a was successfully removed from track &b%s&a.", true),
+
+    LOG_LOAD_ERROR("The log could not be loaded.", true),
+    LOG_INVALID_PAGE("Invalid page number.", true),
+    LOG_INVALID_PAGE_RANGE("Invalid page number. Please enter a value between 1 and %s.", true),
+    LOG_NO_ENTRIES("&eNo log entries to show.", true),
+    LOG_ENTRY("&e#%s -> &8(&7%s ago&8) %s", true),
+
+    LOG_NOTIFY_TOGGLE_ON("&aEnabled&b logging output.", true),
+    LOG_NOTIFY_TOGGLE_OFF("&cDisabled&b logging output.", true),
+    LOG_NOTIFY_ALREADY_ON("You are already receiving notifications.", true),
+    LOG_NOTIFY_ALREADY_OFF("You aren't currently receiving notifications.", true),
+    LOG_NOTIFY_UNKNOWN("State unknown. Expecting \"on\" or \"off\".", true),
+
+    LOG_SEARCH_HEADER("&aShowing recent actions for query &b%s &a(page &f%s&a of &f%s&a)", true),
+
+    LOG_RECENT_HEADER("&aShowing recent actions (page &f%s&a of &f%s&a)", true),
+    LOG_RECENT_BY_HEADER("&aShowing recent actions by &b%s &a(page &f%s&a of &f%s&a)", true),
+
+    LOG_HISTORY_USER_HEADER("&aShowing history for user &b%s &a(page &f%s&a of &f%s&a)", true),
+    LOG_HISTORY_GROUP_HEADER("&aShowing history for group &b%s &a(page &f%s&a of &f%s&a)", true),
+    LOG_HISTORY_TRACK_HEADER("&aShowing history for track &b%s &a(page &f%s&a of &f%s&a)", true),
+
+    IMPORT_PROGRESS("&e(Import) &d-> &6%s% complete &7- &e%s&6/&e%s &6operations complete with &c%s &6errors.", true),
+    IMPORT_PROGRESS_SIN("&e(Import) &d-> &6%s% complete &7- &e%s&6/&e%s &6operations complete with &c%s &6error.", true),
+    IMPORT_START("&e(Import) &d-> &6Starting import process.", true),
+
+    IMPORT_END_COMPLETE("&e(Import) &a&lCOMPLETED &7- took &e%s &7seconds - &7No errors.", true),
+    IMPORT_END_COMPLETE_ERR("&e(Import) &a&lCOMPLETED &7- took &e%s &7seconds - &c%s errors.", true),
+    IMPORT_END_COMPLETE_ERR_SIN("&e(Import) &a&lCOMPLETED &7- took &e%s &7seconds - &c%s error.", true),
+    IMPORT_END_ERROR_HEADER(
+            PREFIX + "&e(Import) &7-----> &6Showing Error #&e%s &7<-----" + "\n" +
+            PREFIX + "&e(Import) &6Whilst executing: &fCommand #%s" + "\n" +
+            PREFIX + "&e(Import) &6Output:s",
+            false
+    ),
+
+    IMPORT_END_ERROR_CONTENT("&e(Import) &7-> &c%s", true),
+    IMPORT_END_ERROR_FOOTER("&e(Import) &7<---------------------------->", true);
 
     private String message;
     private boolean showPrefix;

common/src/main/java/me/lucko/luckperms/constants/Patterns.java

@@ -20,7 +20,7 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.utils;
+package me.lucko.luckperms.constants;
 
 import lombok.experimental.UtilityClass;
 
@@ -43,6 +43,7 @@ public class Patterns {
     public static final Pattern NON_ALPHA_NUMERIC = Pattern.compile("[^A-Za-z0-9]");
     public static final Pattern NON_USERNAME = Pattern.compile("[^A-Za-z0-9_]");
     public static final Pattern SHORTHAND_NODE = Pattern.compile("\\.\\([^.]+\\)");
+    public static final Pattern STRIP_COLOR_PATTERN = Pattern.compile("(?i)" + String.valueOf('§') + "[0-9A-FK-OR]");
 
     public static Pattern compile(String regex) throws PatternSyntaxException {
         if (!CACHE.containsKey(regex)) {

common/src/main/java/me/lucko/luckperms/constants/Permission.java

@@ -80,17 +80,29 @@ public enum Permission {
     TRACK_APPEND("append", "track"),
     TRACK_INSERT("insert", "track"),
     TRACK_REMOVE("remove", "track"),
-    TRACK_CLEAR("clear", "track");
+    TRACK_CLEAR("clear", "track"),
+
+    LOG_RECENT("recent", "log"),
+    LOG_USER_HISTORY("userhistory", "log"),
+    LOG_GROUP_HISTORY("grouphistory", "log"),
+    LOG_TRACK_HISTORY("trackhistory", "log"),
+    LOG_SEARCH("search", "log"),
+    LOG_NOTIFY("notify", "log"),
+    LOG_EXPORT("export", "log");
 
     private String node;
     private String group;
 
-    public boolean isAuthorized(Sender sender) {
+    public String getNode() {
         if (group != null) {
-            return sender.hasPermission("luckperms." + group + "." + node);
+            return "luckperms." + group + "." + node;
         }
 
-        return sender.hasPermission("luckperms." + node);
+        return "luckperms." + node;
+    }
+
+    public boolean isAuthorized(Sender sender) {
+        return sender.hasPermission(this);
     }
 
 }

common/src/main/java/me/lucko/luckperms/core/LPConfiguration.java

@@ -20,12 +20,13 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.utils;
+package me.lucko.luckperms.core;
 
 import lombok.AccessLevel;
 import lombok.Getter;
 import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.data.MySQLConfiguration;
+import me.lucko.luckperms.constants.Patterns;
+import me.lucko.luckperms.storage.MySQLConfiguration;
 
 public abstract class LPConfiguration<T extends LuckPermsPlugin> {
 

common/src/main/java/me/lucko/luckperms/core/PermissionHolder.java

@@ -20,15 +20,17 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.utils;
+package me.lucko.luckperms.core;
 
 import lombok.AccessLevel;
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.constants.Patterns;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
 import me.lucko.luckperms.groups.Group;
+import me.lucko.luckperms.utils.DateUtil;
 
 import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
@@ -622,7 +624,7 @@ public abstract class PermissionHolder {
 
             String groupName = Patterns.DOT.split(groupNode.getKey(), 2)[1];
             if (!excludedGroups.contains(groupName)) {
-                Group group = plugin.getGroupManager().getGroup(groupName);
+                Group group = plugin.getGroupManager().get(groupName);
                 if (group != null) {
                     perms.putAll(group.getLocalPermissions(server, excludedGroups));
                 } else {
@@ -647,7 +649,7 @@ public abstract class PermissionHolder {
 
                 String groupName = Patterns.DOT.split(rawNode, 2)[1];
                 if (!excludedGroups.contains(groupName)) {
-                    Group group = plugin.getGroupManager().getGroup(groupName);
+                    Group group = plugin.getGroupManager().get(groupName);
                     if (group != null) {
                         perms.putAll(group.getLocalPermissions(server, excludedGroups));
                     } else {

common/src/main/java/me/lucko/luckperms/core/UuidCache.java

@@ -20,7 +20,7 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.utils;
+package me.lucko.luckperms.core;
 
 import lombok.Getter;
 
@@ -30,13 +30,7 @@ import java.util.UUID;
 import java.util.concurrent.ConcurrentHashMap;
 
 /**
- * This UuidCache is a means of allowing users to have the same internal UUID across a network of offline mode servers
- * or mixed offline mode and online mode servers. Platforms running in offline mode generate a random UUID for a user when
- * they first join the server, but this UUID will then not be consistent across the network. LuckPerms will instead check
- * the datastore cache, to get a UUID for a user that is consistent across an entire network.
- *
- * If you want to get a user object from the datastore using the api on a server in offline mode, you will need to use this cache,
- * OR use Datastore#getUUID, for users that are not online.
+ * @see me.lucko.luckperms.api.UuidCache
  */
 public class UuidCache {
 

common/src/main/java/me/lucko/luckperms/data/Importer.java

@@ -0,0 +1,209 @@
+/*
+ * 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.data;
+
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import lombok.Setter;
+import me.lucko.luckperms.commands.CommandManager;
+import me.lucko.luckperms.commands.CommandResult;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.constants.Constants;
+import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.constants.Patterns;
+import me.lucko.luckperms.constants.Permission;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * Executes a list of commands sequentially in a single thread.
+ */
+@RequiredArgsConstructor
+public class Importer { // TODO: implement this
+
+    @Getter
+    private boolean running = false;
+
+    private final CommandManager commandManager;
+
+    private Sender executor = null;
+    private List<String> commands = null;
+    private Map<Integer, Result> cmdResult = null;
+
+    private long lastMsg = 0;
+    private int executing = -1;
+
+    public synchronized void start(Sender executor, List<String> commands) {
+        if (isRunning()) {
+            throw new IllegalStateException("Import already running.");
+        }
+
+        running = true;
+        this.executor = executor;
+        this.commands = commands.stream()
+                .map(s -> s.startsWith("/") ? s.substring(1) : s)
+                .map(s -> s.startsWith("perms ") ? s.substring(5) : s)
+                .collect(Collectors.toList());
+
+        cmdResult = new HashMap<>();
+
+        run();
+    }
+
+    private void cleanup() {
+        executor = null;
+        commands = null;
+        cmdResult = null;
+        lastMsg = 0;
+        executing = -1;
+        running = false;
+    }
+
+    public void run() {
+        long startTime = System.currentTimeMillis();
+        Message.IMPORT_START.send(executor);
+        final Sender fake = new FakeSender(this);
+
+        int index = 0;
+        for (String command : commands) {
+            if (lastMsg < (System.currentTimeMillis() / 1000) - 5) {
+                lastMsg = System.currentTimeMillis() / 1000;
+
+                sendProgress(index);
+            }
+
+            executing = index;
+            try {
+                CommandResult result = commandManager.onCommand(fake, "perms", Arrays.asList(Patterns.SPACE.split(command)));
+                getResult(index).setResult(result);
+
+            } catch (Exception e) {
+                getResult(index).setResult(CommandResult.FAILURE);
+                e.printStackTrace();
+            }
+            index++;
+        }
+
+        long endTime = System.currentTimeMillis();
+        double seconds = (endTime - startTime) / 1000.0;
+
+        int errors = 0;
+        for (Map.Entry<Integer, Result> e : cmdResult.entrySet()) {
+            if (e.getValue().getResult() != null && !e.getValue().getResult().booleanValue()) {
+                errors++;
+            }
+        }
+
+        if (errors == 0) {
+            Message.IMPORT_END_COMPLETE.send(executor, seconds);
+        } else if (errors == 1) {
+            Message.IMPORT_END_COMPLETE_ERR_SIN.send(executor, seconds, errors);
+        } else {
+            Message.IMPORT_END_COMPLETE_ERR.send(executor, seconds, errors);
+        }
+
+        int errIndex = 1;
+        for (Map.Entry<Integer, Result> e : cmdResult.entrySet()) {
+            if (e.getValue().getResult() != null && !e.getValue().getResult().booleanValue()) {
+                Message.IMPORT_END_ERROR_HEADER.send(executor, errIndex, e.getKey());
+                for (String s : e.getValue().getOutput()) {
+                    Message.IMPORT_END_ERROR_CONTENT.send(executor, s);
+                }
+                Message.IMPORT_END_ERROR_FOOTER.send(executor);
+                errIndex++;
+            }
+        }
+
+        cleanup();
+    }
+
+    private void sendProgress(int executing) {
+        int percent = (executing / commands.size()) * 100;
+        int errors = 0;
+
+        for (Map.Entry<Integer, Result> e : cmdResult.entrySet()) {
+            if (e.getValue().getResult() != null && !e.getValue().getResult().booleanValue()) {
+                errors++;
+            }
+        }
+
+        if (errors == 1) {
+            Message.IMPORT_PROGRESS_SIN.send(executor, percent, executing, commands.size(), errors);
+        } else {
+            Message.IMPORT_PROGRESS.send(executor, percent, executing, commands.size(), errors);
+        }
+    }
+
+    private Result getResult(int executing) {
+        if (!cmdResult.containsKey(executing)) {
+            cmdResult.put(executing, new Result());
+        }
+
+        return cmdResult.get(executing);
+    }
+
+    private void logMessage(String msg) {
+        getResult(executing).getOutput().add(Util.stripColor(msg));
+    }
+
+    private static class FakeSender implements Sender {
+        private final Importer instance;
+
+        public FakeSender(Importer instance) {
+            this.instance = instance;
+        }
+
+        @Override
+        public String getName() {
+            return Constants.getImporterName();
+        }
+
+        @Override
+        public UUID getUuid() {
+            return Constants.getImporterUUID();
+        }
+
+        @Override
+        public void sendMessage(String s) {
+            instance.logMessage(s);
+        }
+
+        @Override
+        public boolean hasPermission(Permission permission) {
+            return true;
+        }
+    }
+
+    private static class Result {
+
+        @Getter
+        private final List<String> output = new ArrayList<>();
+
+        @Getter
+        @Setter
+        private CommandResult result = CommandResult.FAILURE;
+    }
+
+}

common/src/main/java/me/lucko/luckperms/data/Log.java

@@ -0,0 +1,194 @@
+/*
+ * 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.data;
+
+import com.google.common.collect.ImmutableSortedSet;
+import lombok.Getter;
+import me.lucko.luckperms.api.LogEntry;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class Log {
+    public static Builder builder() {
+        return new Builder();
+    }
+
+    private static final int PAGE_ENTRIES = 5;
+
+    @Getter
+    private final SortedSet<LogEntry> content;
+
+    public Log(SortedSet<LogEntry> content) {
+        this.content = ImmutableSortedSet.copyOf(content);
+    }
+
+    public SortedSet<LogEntry> getRecent() {
+        return content;
+    }
+
+    public SortedMap<Integer, LogEntry> getRecent(int pageNo) {
+        return getPage(content, pageNo, PAGE_ENTRIES);
+    }
+
+    public int getRecentMaxPages() {
+        return getMaxPages(content.size(), PAGE_ENTRIES);
+    }
+
+    public SortedSet<LogEntry> getRecent(UUID actor) {
+        return content.stream()
+                .filter(e -> e.getActor().equals(actor))
+                .collect(Collectors.toCollection(TreeSet::new));
+    }
+
+    public SortedMap<Integer, LogEntry> getRecent(int pageNo, UUID actor) {
+        return getPage(getRecent(actor), pageNo, PAGE_ENTRIES);
+    }
+
+    public int getRecentMaxPages(UUID actor) {
+        return getMaxPages(content.stream()
+                .filter(e -> e.getActor().equals(actor))
+                .count(), PAGE_ENTRIES);
+    }
+
+    public SortedSet<LogEntry> getUserHistory(UUID uuid) {
+        return content.stream()
+                .filter(e -> e.getType() == 'U')
+                .filter(e -> e.getActed().equals(uuid))
+                .collect(Collectors.toCollection(TreeSet::new));
+    }
+
+    public SortedMap<Integer, LogEntry> getUserHistory(int pageNo, UUID uuid) {
+        return getPage(getUserHistory(uuid), pageNo, PAGE_ENTRIES);
+    }
+
+    public int getUserHistoryMaxPages(UUID uuid) {
+        return getMaxPages(content.stream()
+                .filter(e -> e.getType() == 'U')
+                .filter(e -> e.getActed().equals(uuid))
+                .count(), PAGE_ENTRIES);
+    }
+
+    public SortedSet<LogEntry> getGroupHistory(String name) {
+        return content.stream()
+                .filter(e -> e.getType() == 'G')
+                .filter(e -> e.getActedName().equals(name))
+                .collect(Collectors.toCollection(TreeSet::new));
+    }
+
+    public SortedMap<Integer, LogEntry> getGroupHistory(int pageNo, String name) {
+        return getPage(getGroupHistory(name), pageNo, PAGE_ENTRIES);
+    }
+
+    public int getGroupHistoryMaxPages(String name) {
+        return getMaxPages(content.stream()
+                .filter(e -> e.getType() == 'G')
+                .filter(e -> e.getActedName().equals(name))
+                .count(), PAGE_ENTRIES);
+    }
+
+    public SortedSet<LogEntry> getTrackHistory(String name) {
+        return content.stream()
+                .filter(e -> e.getType() == 'T')
+                .filter(e -> e.getActedName().equals(name))
+                .collect(Collectors.toCollection(TreeSet::new));
+    }
+
+    public SortedMap<Integer, LogEntry> getTrackHistory(int pageNo, String name) {
+        return getPage(getTrackHistory(name), pageNo, PAGE_ENTRIES);
+    }
+
+    public int getTrackHistoryMaxPages(String name) {
+        return getMaxPages(content.stream()
+                .filter(e -> e.getType() == 'T')
+                .filter(e -> e.getActedName().equals(name))
+                .count(), PAGE_ENTRIES);
+    }
+
+    public SortedSet<LogEntry> getSearch(String query) {
+        return content.stream()
+                .filter(e -> e.matchesSearch(query))
+                .collect(Collectors.toCollection(TreeSet::new));
+    }
+
+    public SortedMap<Integer, LogEntry> getSearch(int pageNo, String query) {
+        return getPage(getSearch(query), pageNo, PAGE_ENTRIES);
+    }
+
+    public int getSearchMaxPages(String query) {
+        return getMaxPages(content.stream()
+                .filter(e -> e.matchesSearch(query))
+                .count(), PAGE_ENTRIES);
+    }
+
+    private static SortedMap<Integer, LogEntry> getPage(Set<LogEntry> set, int pageNo, int entries) {
+        if (pageNo < 1) {
+            throw new IllegalArgumentException("pageNo cannot be less than 1: " + pageNo);
+        }
+
+        int minimumEntries = ((pageNo * 5) - entries) + 1;
+        if (set.size() < minimumEntries) {
+            throw new IllegalStateException("Log does not contain that many entries. " +
+                    "Requested: " + minimumEntries + ", Log Count: " + set.size());
+        }
+
+        final SortedMap<Integer, LogEntry> out = new TreeMap<>();
+
+        final int max = minimumEntries + entries - 1;
+        int index = 0;
+        for (LogEntry e : set) {
+            index++;
+            if (index >= minimumEntries) {
+                out.put(index, e);
+            }
+            if (index == max) {
+                break;
+            }
+        }
+
+        return out;
+    }
+
+    private static int getMaxPages(int size, int entries) {
+        return (int) Math.ceil((double) size / entries);
+    }
+
+    private static int getMaxPages(long size, int entries) {
+        return (int) Math.ceil((double) size / entries);
+    }
+
+    @SuppressWarnings("WeakerAccess")
+    public static class Builder {
+        private final SortedSet<LogEntry> content = new TreeSet<>();
+
+        public Builder add(LogEntry e) {
+            content.add(e);
+            return this;
+        }
+
+        public Log build() {
+            return new Log(content);
+        }
+    }
+
+}

common/src/main/java/me/lucko/luckperms/data/LogEntryBuilder.java

@@ -0,0 +1,173 @@
+/*
+ * 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.data;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.api.LogEntry;
+import me.lucko.luckperms.api.data.Callback;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.constants.Message;
+import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.core.PermissionHolder;
+import me.lucko.luckperms.groups.Group;
+import me.lucko.luckperms.tracks.Track;
+import me.lucko.luckperms.users.User;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.UUID;
+
+public class LogEntryBuilder {
+    private long timestamp = 0L;
+    private UUID actor = null;
+    private String actorName = null;
+    private char type = Character.MIN_VALUE;
+    private UUID acted = null;
+    private String actedName = null;
+    private String action = null;
+
+    public static LogEntryBuilder get() {
+        return new LogEntryBuilder();
+    }
+
+    public LogEntryBuilder timestamp(long timestamp) {
+        this.timestamp = timestamp;
+        return this;
+    }
+
+    public LogEntryBuilder actor(UUID actor) {
+        this.actor = actor;
+        return this;
+    }
+
+    public LogEntryBuilder actorName(String actorName) {
+        this.actorName = actorName;
+        return this;
+    }
+
+    public LogEntryBuilder actor(Sender actor) {
+        this.actorName = actor.getName();
+        this.actor = actor.getUuid();
+        return this;
+    }
+
+    public LogEntryBuilder type(char type) {
+        this.type = type;
+        return this;
+    }
+
+    public LogEntryBuilder type(String type) {
+        this.type = type.toCharArray()[0];
+        return this;
+    }
+
+    public LogEntryBuilder type(Object object) {
+        if (object instanceof User) {
+            this.type = 'U';
+        } else if (object instanceof Group) {
+            this.type = 'G';
+        } else if (object instanceof Track) {
+            this.type = 'T';
+        } else {
+            throw new IllegalArgumentException();
+        }
+        return this;
+    }
+
+    public LogEntryBuilder acted(UUID acted) {
+        this.acted = acted;
+        return this;
+    }
+
+    public LogEntryBuilder actedName(String actedName) {
+        this.actedName = actedName;
+        return this;
+    }
+
+    public LogEntryBuilder acted(PermissionHolder acted) {
+        if (acted instanceof User) {
+            this.actedName = ((User) acted).getName();
+            this.acted = ((User) acted).getUuid();
+            this.type = 'U';
+        } else if (acted instanceof Group) {
+            this.actedName = ((Group) acted).getName();
+            this.type = 'G';
+        }
+        return this;
+    }
+
+    public LogEntryBuilder acted(Track track) {
+        this.actedName = track.getName();
+        this.type = 'T';
+        return this;
+    }
+
+    public LogEntryBuilder action(String action) {
+        this.action = action;
+        return this;
+    }
+
+    private Set<String> getEmpty() {
+        Set<String> s = new HashSet<>();
+        if (actor == null) {
+            s.add("actor");
+        }
+        if (actorName == null) {
+            s.add("actorname");
+        }
+        if (type == Character.MIN_VALUE) {
+            s.add("type");
+        }
+        if (actedName == null) {
+            s.add("actedname");
+        }
+        if (action == null) {
+            s.add("action");
+        }
+        return s;
+    }
+
+    public void submit(LuckPermsPlugin plugin) {
+        final LogEntry entry = build();
+        plugin.getDatastore().logAction(entry, Callback.empty());
+
+        final String msg = entry.getFormatted();
+
+        plugin.getSenders().stream()
+                .filter(Permission.LOG_NOTIFY::isAuthorized)
+                .filter(s -> !plugin.getIgnoringLogs().contains(s.getUuid()))
+                .forEach(s -> Message.LOG.send(s, msg));
+    }
+
+    public LogEntry build() {
+        if (timestamp == 0L) {
+            timestamp = System.currentTimeMillis() / 1000;
+        }
+
+        if (!getEmpty().isEmpty()) {
+            throw new IllegalStateException("Missing values: " + getEmpty().toString());
+        }
+
+        return new LogEntry(timestamp, actor, actorName, type, acted, actedName, action);
+    }
+}

common/src/main/java/me/lucko/luckperms/groups/Group.java

@@ -26,10 +26,11 @@ import lombok.EqualsAndHashCode;
 import lombok.Getter;
 import lombok.ToString;
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.constants.Patterns;
+import me.lucko.luckperms.core.PermissionHolder;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
-import me.lucko.luckperms.utils.Patterns;
-import me.lucko.luckperms.utils.PermissionHolder;
+import me.lucko.luckperms.utils.Identifiable;
 
 import java.util.List;
 import java.util.Map;
@@ -37,7 +38,7 @@ import java.util.stream.Collectors;
 
 @ToString(of = {"name"})
 @EqualsAndHashCode(of = {"name"}, callSuper = false)
-public class Group extends PermissionHolder {
+public class Group extends PermissionHolder implements Identifiable<String> {
 
     /**
      * The name of the group
@@ -56,7 +57,7 @@ public class Group extends PermissionHolder {
      * @return true if the user is a member of the group
      */
     public boolean inheritsGroup(Group group) {
-        return inheritsGroup(group, "global");
+        return group.getName().equalsIgnoreCase(this.getName()) || inheritsGroup(group, "global");
     }
 
     /**
@@ -66,7 +67,7 @@ public class Group extends PermissionHolder {
      * @return true if the group inherits the group
      */
     public boolean inheritsGroup(Group group, String server) {
-        return hasPermission("group." + group.getName(), true, server);
+        return group.getName().equalsIgnoreCase(this.getName()) || hasPermission("group." + group.getName(), true, server);
     }
 
     /**
@@ -77,7 +78,7 @@ public class Group extends PermissionHolder {
      * @return true if the group inherits the group
      */
     public boolean inheritsGroup(Group group, String server, String world) {
-        return hasPermission("group." + group.getName(), true, server, world);
+        return group.getName().equalsIgnoreCase(this.getName()) || hasPermission("group." + group.getName(), true, server, world);
     }
 
     /**
@@ -96,6 +97,10 @@ public class Group extends PermissionHolder {
      * @throws ObjectAlreadyHasException if the group already inherits the group on that server
      */
     public void setInheritGroup(Group group, String server) throws ObjectAlreadyHasException {
+        if (group.getName().equalsIgnoreCase(this.getName())) {
+            throw new ObjectAlreadyHasException();
+        }
+
         if (server == null) {
             server = "global";
         }
@@ -111,6 +116,10 @@ public class Group extends PermissionHolder {
      * @throws ObjectAlreadyHasException if the group already inherits the group on that server
      */
     public void setInheritGroup(Group group, String server, String world) throws ObjectAlreadyHasException {
+        if (group.getName().equalsIgnoreCase(this.getName())) {
+            throw new ObjectAlreadyHasException();
+        }
+
         if (server == null) {
             server = "global";
         }
@@ -125,6 +134,10 @@ public class Group extends PermissionHolder {
      * @throws ObjectAlreadyHasException if the group already inherits the group on that server
      */
     public void setInheritGroup(Group group, long expireAt) throws ObjectAlreadyHasException {
+        if (group.getName().equalsIgnoreCase(this.getName())) {
+            throw new ObjectAlreadyHasException();
+        }
+
         setPermission("group." + group.getName(), true, expireAt);
     }
 
@@ -136,6 +149,10 @@ public class Group extends PermissionHolder {
      * @throws ObjectAlreadyHasException if the group already inherits the group on that server
      */
     public void setInheritGroup(Group group, String server, long expireAt) throws ObjectAlreadyHasException {
+        if (group.getName().equalsIgnoreCase(this.getName())) {
+            throw new ObjectAlreadyHasException();
+        }
+
         if (server == null) {
             server = "global";
         }
@@ -152,6 +169,10 @@ public class Group extends PermissionHolder {
      * @throws ObjectAlreadyHasException if the group already inherits the group on that server
      */
     public void setInheritGroup(Group group, String server, String world, long expireAt) throws ObjectAlreadyHasException {
+        if (group.getName().equalsIgnoreCase(this.getName())) {
+            throw new ObjectAlreadyHasException();
+        }
+
         if (server == null) {
             server = "global";
         }
@@ -288,4 +309,9 @@ public class Group extends PermissionHolder {
                 .map(s -> Patterns.DOT.split(s, 2)[1])
                 .collect(Collectors.toList());
     }
+
+    @Override
+    public String getId() {
+        return name;
+    }
 }

common/src/main/java/me/lucko/luckperms/groups/GroupManager.java

@@ -22,77 +22,17 @@
 
 package me.lucko.luckperms.groups;
 
-import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import me.lucko.luckperms.LuckPermsPlugin;
-
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
+import me.lucko.luckperms.utils.AbstractManager;
 
 @RequiredArgsConstructor
-public class GroupManager {
+public class GroupManager extends AbstractManager<String, Group> {
     private final LuckPermsPlugin plugin;
 
-    /**
-     * A {@link Map} containing all loaded groups
-     */
-    @Getter
-    private final Map<String, Group> groups = new ConcurrentHashMap<>();
-
-    /**
-     * Get a group object by name
-     * @param name The name to search by
-     * @return a {@link Group} object if the group is loaded, returns null if the group is not loaded
-     */
-    public Group getGroup(String name) {
-        return groups.get(name);
-    }
-
-    /**
-     * Add a group to the loaded groups map
-     * @param group The group to add
-     */
-    public void setGroup(Group group) {
-        groups.put(group.getName(), group);
-    }
-
-    /**
-     * Updates (or sets if the group wasn't already loaded) a group in the groups map
-     * @param group The group to update or set
-     */
-    public void updateOrSetGroup(Group group) {
-        if (!isLoaded(group.getName())) {
-            // The group isn't already loaded
-            groups.put(group.getName(), group);
-        } else {
-            groups.get(group.getName()).setNodes(group.getNodes());
-        }
-    }
-
-    /**
-     * Check to see if a group is loaded or not
-     * @param name The name of the group
-     * @return true if the group is loaded
-     */
-    public boolean isLoaded(String name) {
-        return groups.containsKey(name);
-    }
-
-    /**
-     * Removes and unloads the group from the plugins internal storage
-     * @param group The group to unload
-     */
-    public void unloadGroup(Group group) {
-        if (group != null) {
-            groups.remove(group.getName());
-        }
-    }
-
-    /**
-     * Unloads all groups from the manager
-     */
-    public void unloadAll() {
-        groups.clear();
+    @Override
+    protected void copy(Group from, Group to) {
+        to.setNodes(from.getNodes());
     }
 
     /**
@@ -100,7 +40,8 @@ public class GroupManager {
      * @param name The name of the group
      * @return a new {@link Group} object
      */
-    public Group makeGroup(String name) {
+    @Override
+    public Group make(String name) {
         return new Group(name, plugin);
     }
 }

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

@@ -31,8 +31,6 @@ public class UpdateTask implements Runnable {
 
     @Override
     public void run() {
-        plugin.getLog().info("Running update task.");
-
         // Reload all of the groups
         plugin.getDatastore().loadAllGroups();
         String defaultGroup = plugin.getConfiguration().getDefaultGroupName();

common/src/main/java/me/lucko/luckperms/storage/Datastore.java

@@ -20,14 +20,16 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.data;
+package me.lucko.luckperms.storage;
 
 import lombok.AccessLevel;
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import lombok.Setter;
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.api.LogEntry;
 import me.lucko.luckperms.api.data.Callback;
+import me.lucko.luckperms.data.Log;
 import me.lucko.luckperms.groups.Group;
 import me.lucko.luckperms.tracks.Track;
 import me.lucko.luckperms.users.User;
@@ -61,15 +63,13 @@ public abstract class Datastore {
         plugin.doSync(r);
     }
 
-    private <T> void runCallback(T t, Callback<T> callback) {
-        doSync(() -> callback.onComplete(t));
-    }
-
     /*
         These methods are called immediately and in the same thread as they are called in.
      */
     public abstract void init();
     public abstract void shutdown();
+    public abstract boolean logAction(LogEntry entry);
+    public abstract Log getLog();
     public abstract boolean loadOrCreateUser(UUID uuid, String username);
     public abstract boolean loadUser(UUID uuid);
     public abstract boolean saveUser(User user);
@@ -92,63 +92,122 @@ public abstract class Datastore {
         These methods will schedule the operation to run async. The callback will be ran when the task is complete.
         Callbacks are ran on the main Bukkit server thread (if applicable)
      */
+    public void logAction(LogEntry entry, Callback<Boolean> callback) {
+        doAsync(() -> {
+            boolean result = logAction(entry);
+            doSync(() -> callback.onComplete(result));
+        });
+    }
+
+    public void getLog(Callback<Log> callback) {
+        doAsync(() -> {
+            Log result = getLog();
+            doSync(() -> callback.onComplete(result));
+        });
+    }
+
     public void loadOrCreateUser(UUID uuid, String username, Callback<Boolean> callback) {
-        doAsync(() -> runCallback(loadOrCreateUser(uuid, username), callback));
+        doAsync(() -> {
+            boolean result = loadOrCreateUser(uuid, username);
+            doSync(() -> callback.onComplete(result));
+        });
     }
 
     public void loadUser(UUID uuid, Callback<Boolean> callback) {
-        doAsync(() -> runCallback(loadUser(uuid), callback));
+        doAsync(() -> {
+            boolean result = loadUser(uuid);
+            doSync(() -> callback.onComplete(result));
+        });
     }
 
     public void saveUser(User user, Callback<Boolean> callback) {
-        doAsync(() -> runCallback(saveUser(user), callback));
+        doAsync(() -> {
+            boolean result = saveUser(user);
+            doSync(() -> callback.onComplete(result));
+        });
     }
 
     public void createAndLoadGroup(String name, Callback<Boolean> callback) {
-        doAsync(() -> runCallback(createAndLoadGroup(name), callback));
+        doAsync(() -> {
+            boolean result = createAndLoadGroup(name);
+            doSync(() -> callback.onComplete(result));
+        });
     }
 
     public void loadGroup(String name, Callback<Boolean> callback) {
-        doAsync(() -> runCallback(loadGroup(name), callback));
+        doAsync(() -> {
+            boolean result = loadGroup(name);
+            doSync(() -> callback.onComplete(result));
+        });
     }
 
     public void loadAllGroups(Callback<Boolean> callback) {
-        doAsync(() -> runCallback(loadAllGroups(), callback));
+        doAsync(() -> {
+            boolean result = loadAllGroups();
+            doSync(() -> callback.onComplete(result));
+        });
     }
 
     public void saveGroup(Group group, Callback<Boolean> callback) {
-        doAsync(() -> runCallback(saveGroup(group), callback));
+        doAsync(() -> {
+            boolean result = saveGroup(group);
+            doSync(() -> callback.onComplete(result));
+        });
     }
 
     public void deleteGroup(Group group, Callback<Boolean> callback) {
-        doAsync(() -> runCallback(deleteGroup(group), callback));
+        doAsync(() -> {
+            boolean result = deleteGroup(group);
+            doSync(() -> callback.onComplete(result));
+        });
     }
 
     public void createAndLoadTrack(String name, Callback<Boolean> callback) {
-        doAsync(() -> runCallback(createAndLoadTrack(name), callback));
+        doAsync(() -> {
+            boolean result = createAndLoadTrack(name);
+            doSync(() -> callback.onComplete(result));
+        });
     }
 
     public void loadTrack(String name, Callback<Boolean> callback) {
-        doAsync(() -> runCallback(loadTrack(name), callback));
+        doAsync(() -> {
+            boolean result = loadTrack(name);
+            doSync(() -> callback.onComplete(result));
+        });
     }
 
     public void loadAllTracks(Callback<Boolean> callback) {
-        doAsync(() -> runCallback(loadAllTracks(), callback));
+        doAsync(() -> {
+            boolean result = loadAllTracks();
+            doSync(() -> callback.onComplete(result));
+        });
     }
 
     public void saveTrack(Track track, Callback<Boolean> callback) {
-        doAsync(() -> runCallback(saveTrack(track), callback));
+        doAsync(() -> {
+            boolean result = saveTrack(track);
+            doSync(() -> callback.onComplete(result));
+        });
     }
 
     public void deleteTrack(Track track, Callback<Boolean> callback) {
-        doAsync(() -> runCallback(deleteTrack(track), callback));
+        doAsync(() -> {
+            boolean result = deleteTrack(track);
+            doSync(() -> callback.onComplete(result));
+        });
     }
 
     public void saveUUIDData(String username, UUID uuid, Callback<Boolean> callback) {
-        doAsync(() -> runCallback(saveUUIDData(username, uuid), callback));
+        doAsync(() -> {
+            boolean result = saveUUIDData(username, uuid);
+            doSync(() -> callback.onComplete(result));
+        });
     }
 
     public void getUUID(String username, Callback<UUID> callback) {
-        doAsync(() -> runCallback(getUUID(username), callback));
+        doAsync(() -> {
+            UUID result = getUUID(username);
+            doSync(() -> callback.onComplete(result));
+        });
     }
 }

common/src/main/java/me/lucko/luckperms/storage/MySQLConfiguration.java

@@ -20,7 +20,7 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.data;
+package me.lucko.luckperms.storage;
 
 import lombok.AllArgsConstructor;
 import lombok.Getter;

common/src/main/java/me/lucko/luckperms/storage/methods/FlatfileDatastore.java

@@ -20,25 +20,32 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.data.methods;
+package me.lucko.luckperms.storage.methods;
 
 import com.google.gson.stream.JsonReader;
 import com.google.gson.stream.JsonWriter;
 import lombok.Cleanup;
 import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.data.Datastore;
+import me.lucko.luckperms.api.LogEntry;
+import me.lucko.luckperms.constants.Constants;
+import me.lucko.luckperms.data.Log;
 import me.lucko.luckperms.groups.Group;
+import me.lucko.luckperms.storage.Datastore;
 import me.lucko.luckperms.tracks.Track;
 import me.lucko.luckperms.users.User;
 
 import java.io.*;
 import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.logging.*;
+import java.util.logging.Formatter;
 import java.util.stream.Collectors;
 
 @SuppressWarnings({"ResultOfMethodCallIgnored", "UnnecessaryLocalVariable"})
 public class FlatfileDatastore extends Datastore {
+    private static final String LOG_FORMAT = "%s(%s): [%s] %s(%s) --> %s";
 
+    private final Logger actionLogger = Logger.getLogger("lp_actions");
     private Map<String, String> uuidCache = new ConcurrentHashMap<>();
 
     private final File pluginDir;
@@ -46,6 +53,7 @@ public class FlatfileDatastore extends Datastore {
     private File groupsDir;
     private File tracksDir;
     private File uuidData;
+    private File actionLog;
 
     public FlatfileDatastore(LuckPermsPlugin plugin, File pluginDir) {
         super(plugin, "Flatfile - JSON");
@@ -90,6 +98,23 @@ public class FlatfileDatastore extends Datastore {
         }
 
         uuidCache.putAll(getUUIDCache());
+
+        try {
+            FileHandler fh = new FileHandler(actionLog.getAbsolutePath(), 0, 1, true);
+            fh.setFormatter(new Formatter() {
+                @Override
+                public String format(LogRecord record) {
+                    return new Date(record.getMillis()).toString() + ": " + record.getMessage() + "\n";
+                }
+            });
+            actionLogger.addHandler(fh);
+            actionLogger.setUseParentHandlers(false);
+            actionLogger.setLevel(Level.ALL);
+            actionLogger.setFilter(record -> true);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
         setAcceptingLogins(true);
     }
 
@@ -108,6 +133,9 @@ public class FlatfileDatastore extends Datastore {
 
         uuidData = new File(data, "uuidcache.txt");
         uuidData.createNewFile();
+
+        actionLog = new File(data, "actions.log");
+        actionLog.createNewFile();
     }
 
     @Override
@@ -115,9 +143,28 @@ public class FlatfileDatastore extends Datastore {
         saveUUIDCache(uuidCache);
     }
 
+    @Override
+    public boolean logAction(LogEntry entry) {
+        actionLogger.info(String.format(LOG_FORMAT,
+                (entry.getActor().equals(Constants.getConsoleUUID()) ? "" : entry.getActor() + " "),
+                entry.getActorName(),
+                Character.toString(entry.getType()),
+                (entry.getActed() == null ? "" : entry.getActed().toString() + " "),
+                entry.getActedName(),
+                entry.getAction())
+        );
+        return true;
+    }
+
+    @Override
+    public Log getLog() {
+        // TODO Add log viewing support for flatfile D:
+        return Log.builder().build();
+    }
+
     @Override
     public boolean loadOrCreateUser(UUID uuid, String username) {
-        User user = plugin.getUserManager().makeUser(uuid, username);
+        User user = plugin.getUserManager().make(uuid, username);
 
         File userFile = new File(usersDir, uuid.toString() + ".json");
         if (!userFile.exists()) {
@@ -148,12 +195,13 @@ public class FlatfileDatastore extends Datastore {
             if (!success) return false;
         }
 
+        final String[] name = new String[1];
         boolean success = doRead(userFile, reader -> {
             reader.beginObject();
             reader.nextName(); // uuid record
             reader.nextString(); // uuid
             reader.nextName(); // name record
-            reader.nextString(); // name
+            name[0] = reader.nextString(); // name
             reader.nextName(); // primaryGroup record
             user.setPrimaryGroup(reader.nextString()); // primaryGroup
             reader.nextName(); //perms
@@ -169,13 +217,30 @@ public class FlatfileDatastore extends Datastore {
             return true;
         });
 
-        if (success) plugin.getUserManager().updateOrSetUser(user);
+        if (!name[0].equals(user.getName())) {
+            doWrite(userFile, writer -> {
+                writer.beginObject();
+                writer.name("uuid").value(user.getUuid().toString());
+                writer.name("name").value(user.getName());
+                writer.name("primaryGroup").value(user.getPrimaryGroup());
+                writer.name("perms");
+                writer.beginObject();
+                for (Map.Entry<String, Boolean> e : user.getNodes().entrySet()) {
+                    writer.name(e.getKey()).value(e.getValue().booleanValue());
+                }
+                writer.endObject();
+                writer.endObject();
+                return true;
+            });
+        }
+
+        if (success) plugin.getUserManager().updateOrSet(user);
         return success;
     }
 
     @Override
     public boolean loadUser(UUID uuid) {
-        User user = plugin.getUserManager().makeUser(uuid);
+        User user = plugin.getUserManager().make(uuid);
 
         File userFile = new File(usersDir, uuid.toString() + ".json");
         if (!userFile.exists()) {
@@ -203,7 +268,7 @@ public class FlatfileDatastore extends Datastore {
             return true;
         });
 
-        if (success) plugin.getUserManager().updateOrSetUser(user);
+        if (success) plugin.getUserManager().updateOrSet(user);
         return success;
     }
 
@@ -238,7 +303,7 @@ public class FlatfileDatastore extends Datastore {
 
     @Override
     public boolean createAndLoadGroup(String name) {
-        Group group = plugin.getGroupManager().makeGroup(name);
+        Group group = plugin.getGroupManager().make(name);
 
         File groupFile = new File(groupsDir, name + ".json");
         if (!groupFile.exists()) {
@@ -282,13 +347,13 @@ public class FlatfileDatastore extends Datastore {
             return true;
         });
 
-        if (success) plugin.getGroupManager().updateOrSetGroup(group);
+        if (success) plugin.getGroupManager().updateOrSet(group);
         return success;
     }
 
     @Override
     public boolean loadGroup(String name) {
-        Group group = plugin.getGroupManager().makeGroup(name);
+        Group group = plugin.getGroupManager().make(name);
 
         File groupFile = new File(groupsDir, name + ".json");
         if (!groupFile.exists()) {
@@ -312,7 +377,7 @@ public class FlatfileDatastore extends Datastore {
             return true;
         });
 
-        if (success) plugin.getGroupManager().updateOrSetGroup(group);
+        if (success) plugin.getGroupManager().updateOrSet(group);
         return success;
     }
 
@@ -366,7 +431,7 @@ public class FlatfileDatastore extends Datastore {
 
     @Override
     public boolean createAndLoadTrack(String name) {
-        Track track = plugin.getTrackManager().makeTrack(name);
+        Track track = plugin.getTrackManager().make(name);
         List<String> groups = new ArrayList<>();
 
         File trackFile = new File(tracksDir, name + ".json");
@@ -409,13 +474,13 @@ public class FlatfileDatastore extends Datastore {
         });
 
         track.setGroups(groups);
-        if (success) plugin.getTrackManager().updateOrSetTrack(track);
+        if (success) plugin.getTrackManager().updateOrSet(track);
         return success;
     }
 
     @Override
     public boolean loadTrack(String name) {
-        Track track = plugin.getTrackManager().makeTrack(name);
+        Track track = plugin.getTrackManager().make(name);
         List<String> groups = new ArrayList<>();
 
         File trackFile = new File(tracksDir, name + ".json");
@@ -438,7 +503,7 @@ public class FlatfileDatastore extends Datastore {
         });
 
         track.setGroups(groups);
-        if (success) plugin.getTrackManager().updateOrSetTrack(track);
+        if (success) plugin.getTrackManager().updateOrSet(track);
         return success;
     }
 

common/src/main/java/me/lucko/luckperms/storage/methods/MySQLDatastore.java

@@ -20,12 +20,12 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.data.methods;
+package me.lucko.luckperms.storage.methods;
 
 import com.zaxxer.hikari.HikariDataSource;
 import lombok.Cleanup;
 import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.data.MySQLConfiguration;
+import me.lucko.luckperms.storage.MySQLConfiguration;
 
 import java.sql.Connection;
 import java.sql.PreparedStatement;
@@ -38,6 +38,7 @@ public class MySQLDatastore extends SQLDatastore {
     private static final String CREATETABLE_USERS = "CREATE TABLE IF NOT EXISTS `lp_users` (`uuid` VARCHAR(36) NOT NULL, `name` VARCHAR(16) NOT NULL, `primary_group` VARCHAR(36) NOT NULL, `perms` TEXT NOT NULL, PRIMARY KEY (`uuid`)) ENGINE=InnoDB DEFAULT CHARSET=latin1;";
     private static final String CREATETABLE_GROUPS = "CREATE TABLE IF NOT EXISTS `lp_groups` (`name` VARCHAR(36) NOT NULL, `perms` TEXT NULL, PRIMARY KEY (`name`)) ENGINE=InnoDB DEFAULT CHARSET=latin1;";
     private static final String CREATETABLE_TRACKS = "CREATE TABLE IF NOT EXISTS `lp_tracks` (`name` VARCHAR(36) NOT NULL, `groups` TEXT NULL, PRIMARY KEY (`name`)) ENGINE=InnoDB DEFAULT CHARSET=latin1;";
+    private static final String CREATETABLE_ACTION = "CREATE TABLE IF NOT EXISTS `lp_actions` (`id` INT AUTO_INCREMENT NOT NULL, `time` BIG INT NOT NULL, `actor_uuid` VARCHAR(36) NOT NULL, `actor_name` VARCHAR(16) NOT NULL, `type` CHAR(1) NOT NULL, `acted_uuid` VARCHAR(36) NOT NULL, `acted_name` VARCHAR(36) NOT NULL, `action` VARCHAR(256) NOT NULL, PRIMARY KEY (`id`)) ENGINE=InnoDB DEFAULT CHARSET=latin1;";
 
     private final MySQLConfiguration configuration;
     private HikariDataSource hikari;
@@ -64,7 +65,7 @@ public class MySQLDatastore extends SQLDatastore {
         hikari.addDataSourceProperty("user", username);
         hikari.addDataSourceProperty("password", password);
 
-        if (!setupTables(CREATETABLE_UUID, CREATETABLE_USERS, CREATETABLE_GROUPS, CREATETABLE_TRACKS)) {
+        if (!setupTables(CREATETABLE_UUID, CREATETABLE_USERS, CREATETABLE_GROUPS, CREATETABLE_TRACKS, CREATETABLE_ACTION)) {
             plugin.getLog().severe("Error occurred whilst initialising the database. All connections are disallowed.");
             shutdown();
         } else {

common/src/main/java/me/lucko/luckperms/storage/methods/SQLDatastore.java

@@ -20,16 +20,18 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.data.methods;
+package me.lucko.luckperms.storage.methods;
 
 import com.google.gson.Gson;
 import com.google.gson.reflect.TypeToken;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.data.Datastore;
+import me.lucko.luckperms.api.LogEntry;
+import me.lucko.luckperms.data.Log;
 import me.lucko.luckperms.groups.Group;
 import me.lucko.luckperms.groups.GroupManager;
+import me.lucko.luckperms.storage.Datastore;
 import me.lucko.luckperms.tracks.Track;
 import me.lucko.luckperms.tracks.TrackManager;
 import me.lucko.luckperms.users.User;
@@ -70,6 +72,9 @@ abstract class SQLDatastore extends Datastore {
     private static final String UUIDCACHE_SELECT = "SELECT uuid FROM lp_uuid WHERE name=?";
     private static final String UUIDCACHE_UPDATE = "UPDATE lp_uuid SET uuid=? WHERE name=?";
 
+    private static final String ACTION_INSERT = "INSERT INTO lp_actions(`time`, `actor_uuid`, `actor_name`, `type`, `acted_uuid`, `acted_name`, `action`) VALUES(?, ?, ?, ?, ?, ?, ?)";
+    private static final String ACTION_SELECT_ALL = "SELECT * FROM lp_actions";
+
     private final Gson gson;
 
     SQLDatastore(LuckPermsPlugin plugin, String name) {
@@ -93,7 +98,7 @@ abstract class SQLDatastore extends Datastore {
 
     @Override
     public boolean loadUser(UUID uuid) {
-        User user = plugin.getUserManager().makeUser(uuid);
+        User user = plugin.getUserManager().make(uuid);
         boolean success = runQuery(new QueryRS(USER_SELECT) {
             @Override
             void onRun(PreparedStatement preparedStatement) throws SQLException {
@@ -112,13 +117,60 @@ abstract class SQLDatastore extends Datastore {
             }
         });
 
-        if (success) plugin.getUserManager().updateOrSetUser(user);
+        if (success) plugin.getUserManager().updateOrSet(user);
         return success;
     }
 
+    @Override
+    public boolean logAction(LogEntry entry) {
+        boolean success = runQuery(new QueryPS(ACTION_INSERT) {
+            @Override
+            void onRun(PreparedStatement preparedStatement) throws SQLException {
+                preparedStatement.setLong(1, entry.getTimestamp());
+                preparedStatement.setString(2, entry.getActor().toString());
+                preparedStatement.setString(3, entry.getActorName());
+                preparedStatement.setString(4, Character.toString(entry.getType()));
+                preparedStatement.setString(5, entry.getActed() == null ? "null" : entry.getActed().toString());
+                preparedStatement.setString(6, entry.getActedName());
+                preparedStatement.setString(7, entry.getAction());
+            }
+        });
+        return success;
+    }
+
+    @Override
+    public Log getLog() {
+        final Log.Builder log = Log.builder();
+        boolean success = runQuery(new QueryRS(ACTION_SELECT_ALL) {
+            @Override
+            void onRun(PreparedStatement preparedStatement) throws SQLException {
+
+            }
+
+            @Override
+            boolean onResult(ResultSet resultSet) throws SQLException {
+                while (resultSet.next()) {
+                    final String actedUuid = resultSet.getString("acted_uuid");
+                    LogEntry e = new LogEntry(
+                            resultSet.getLong("time"),
+                            UUID.fromString(resultSet.getString("actor_uuid")),
+                            resultSet.getString("actor_name"),
+                            resultSet.getString("type").toCharArray()[0],
+                            actedUuid.equals("null") ? null : UUID.fromString(actedUuid),
+                            resultSet.getString("acted_name"),
+                            resultSet.getString("action")
+                    );
+                    log.add(e);
+                }
+                return true;
+            }
+        });
+        return success ? log.build() : null;
+    }
+
     @Override
     public boolean loadOrCreateUser(UUID uuid, String username) {
-        User user = plugin.getUserManager().makeUser(uuid, username);
+        User user = plugin.getUserManager().make(uuid, username);
         boolean success = runQuery(new QueryRS(USER_SELECT) {
             @Override
             void onRun(PreparedStatement preparedStatement) throws SQLException {
@@ -143,12 +195,24 @@ abstract class SQLDatastore extends Datastore {
                 } else {
                     user.getNodes().putAll(gson.fromJson(resultSet.getString("perms"), NM_TYPE));
                     user.setPrimaryGroup(resultSet.getString("primary_group"));
+
+                    if (!resultSet.getString("name").equals(user.getName())) {
+                        runQuery(new QueryPS(USER_UPDATE) {
+                            @Override
+                            void onRun(PreparedStatement preparedStatement) throws SQLException {
+                                preparedStatement.setString(1, user.getName());
+                                preparedStatement.setString(2, user.getPrimaryGroup());
+                                preparedStatement.setString(3, gson.toJson(user.getNodes()));
+                                preparedStatement.setString(4, user.getUuid().toString());
+                            }
+                        });
+                    }
                 }
                 return success;
             }
         });
 
-        if (success) plugin.getUserManager().updateOrSetUser(user);
+        if (success) plugin.getUserManager().updateOrSet(user);
         return success;
     }
 
@@ -168,7 +232,7 @@ abstract class SQLDatastore extends Datastore {
 
     @Override
     public boolean createAndLoadGroup(String name) {
-        Group group = plugin.getGroupManager().makeGroup(name);
+        Group group = plugin.getGroupManager().make(name);
         boolean success = runQuery(new QueryRS(GROUP_SELECT) {
             @Override
             void onRun(PreparedStatement preparedStatement) throws SQLException {
@@ -193,13 +257,13 @@ abstract class SQLDatastore extends Datastore {
             }
         });
 
-        if (success) plugin.getGroupManager().updateOrSetGroup(group);
+        if (success) plugin.getGroupManager().updateOrSet(group);
         return success;
     }
 
     @Override
     public boolean loadGroup(String name) {
-        Group group = plugin.getGroupManager().makeGroup(name);
+        Group group = plugin.getGroupManager().make(name);
         boolean success = runQuery(new QueryRS(GROUP_SELECT) {
             @Override
             void onRun(PreparedStatement preparedStatement) throws SQLException {
@@ -216,7 +280,7 @@ abstract class SQLDatastore extends Datastore {
             }
         });
 
-        if (success) plugin.getGroupManager().updateOrSetGroup(group);
+        if (success) plugin.getGroupManager().updateOrSet(group);
         return success;
     }
 
@@ -232,7 +296,7 @@ abstract class SQLDatastore extends Datastore {
             @Override
             boolean onResult(ResultSet resultSet) throws SQLException {
                 while (resultSet.next()) {
-                    Group group = plugin.getGroupManager().makeGroup(resultSet.getString("name"));
+                    Group group = plugin.getGroupManager().make(resultSet.getString("name"));
                     group.getNodes().putAll(gson.fromJson(resultSet.getString("perms"), NM_TYPE));
                     groups.add(group);
                 }
@@ -243,7 +307,7 @@ abstract class SQLDatastore extends Datastore {
         if (success) {
             GroupManager gm = plugin.getGroupManager();
             gm.unloadAll();
-            groups.forEach(gm::setGroup);
+            groups.forEach(gm::set);
         }
         return success;
     }
@@ -269,13 +333,13 @@ abstract class SQLDatastore extends Datastore {
             }
         });
 
-        if (success) plugin.getGroupManager().unloadGroup(group);
+        if (success) plugin.getGroupManager().unload(group);
         return success;
     }
 
     @Override
     public boolean createAndLoadTrack(String name) {
-        Track track = plugin.getTrackManager().makeTrack(name);
+        Track track = plugin.getTrackManager().make(name);
         boolean success = runQuery(new QueryRS(TRACK_SELECT) {
             @Override
             void onRun(PreparedStatement preparedStatement) throws SQLException {
@@ -300,13 +364,13 @@ abstract class SQLDatastore extends Datastore {
             }
         });
 
-        if (success) plugin.getTrackManager().updateOrSetTrack(track);
+        if (success) plugin.getTrackManager().updateOrSet(track);
         return success;
     }
 
     @Override
     public boolean loadTrack(String name) {
-        Track track = plugin.getTrackManager().makeTrack(name);
+        Track track = plugin.getTrackManager().make(name);
         boolean success = runQuery(new QueryRS(TRACK_SELECT) {
             @Override
             void onRun(PreparedStatement preparedStatement) throws SQLException {
@@ -323,7 +387,7 @@ abstract class SQLDatastore extends Datastore {
             }
         });
 
-        if (success) plugin.getTrackManager().updateOrSetTrack(track);
+        if (success) plugin.getTrackManager().updateOrSet(track);
         return success;
     }
 
@@ -339,7 +403,7 @@ abstract class SQLDatastore extends Datastore {
             @Override
             boolean onResult(ResultSet resultSet) throws SQLException {
                 while (resultSet.next()) {
-                    Track track = plugin.getTrackManager().makeTrack(resultSet.getString("name"));
+                    Track track = plugin.getTrackManager().make(resultSet.getString("name"));
                     track.setGroups(gson.fromJson(resultSet.getString("groups"), T_TYPE));
                     tracks.add(track);
                 }
@@ -350,7 +414,7 @@ abstract class SQLDatastore extends Datastore {
         if (success) {
             TrackManager tm = plugin.getTrackManager();
             tm.unloadAll();
-            tracks.forEach(tm::setTrack);
+            tracks.forEach(tm::set);
         }
         return success;
     }
@@ -376,7 +440,7 @@ abstract class SQLDatastore extends Datastore {
             }
         });
 
-        if (success) plugin.getTrackManager().unloadTrack(track);
+        if (success) plugin.getTrackManager().unload(track);
         return success;
     }
 

common/src/main/java/me/lucko/luckperms/storage/methods/SQLiteDatastore.java

@@ -20,7 +20,7 @@
  *  SOFTWARE.
  */
 
-package me.lucko.luckperms.data.methods;
+package me.lucko.luckperms.storage.methods;
 
 import lombok.Cleanup;
 import me.lucko.luckperms.LuckPermsPlugin;
@@ -34,6 +34,7 @@ public class SQLiteDatastore extends SQLDatastore {
     private static final String CREATETABLE_USERS = "CREATE TABLE IF NOT EXISTS `lp_users` (`uuid` VARCHAR(36) NOT NULL, `name` VARCHAR(16) NOT NULL, `primary_group` VARCHAR(36) NOT NULL, `perms` TEXT NOT NULL, PRIMARY KEY (`uuid`));";
     private static final String CREATETABLE_GROUPS = "CREATE TABLE IF NOT EXISTS `lp_groups` (`name` VARCHAR(36) NOT NULL, `perms` TEXT NULL, PRIMARY KEY (`name`));";
     private static final String CREATETABLE_TRACKS = "CREATE TABLE IF NOT EXISTS `lp_tracks` (`name` VARCHAR(36) NOT NULL, `groups` TEXT NULL, PRIMARY KEY (`name`));";
+    private static final String CREATETABLE_ACTION = "CREATE TABLE IF NOT EXISTS `lp_actions` (`id` INTEGER PRIMARY KEY NOT NULL, `time` BIG INT NOT NULL, `actor_uuid` VARCHAR(36) NOT NULL, `actor_name` VARCHAR(16) NOT NULL, `type` CHAR(1) NOT NULL, `acted_uuid` VARCHAR(36) NOT NULL, `acted_name` VARCHAR(36) NOT NULL, `action` VARCHAR(256) NOT NULL);";
 
     private final File file;
     private Connection connection = null;
@@ -45,7 +46,7 @@ public class SQLiteDatastore extends SQLDatastore {
 
     @Override
     public void init() {
-        if (!setupTables(CREATETABLE_UUID, CREATETABLE_USERS, CREATETABLE_GROUPS, CREATETABLE_TRACKS)) {
+        if (!setupTables(CREATETABLE_UUID, CREATETABLE_USERS, CREATETABLE_GROUPS, CREATETABLE_TRACKS, CREATETABLE_ACTION)) {
             plugin.getLog().severe("Error occurred whilst initialising the database. All connections are disallowed.");
             shutdown();
         } else {

common/src/main/java/me/lucko/luckperms/tracks/Track.java

@@ -29,15 +29,16 @@ import lombok.ToString;
 import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
 import me.lucko.luckperms.exceptions.ObjectLacksException;
 import me.lucko.luckperms.groups.Group;
+import me.lucko.luckperms.utils.Identifiable;
 
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
-@ToString(of = {"name"})
-@EqualsAndHashCode(of = {"name"}, callSuper = false)
+@ToString
+@EqualsAndHashCode(of = {"name"})
 @RequiredArgsConstructor
-public class Track {
+public class Track implements Identifiable<String> {
 
     /**
      * The name of the track
@@ -200,4 +201,9 @@ public class Track {
             throw new ObjectLacksException();
         }
     }
+
+    @Override
+    public String getId() {
+        return name;
+    }
 }

common/src/main/java/me/lucko/luckperms/tracks/TrackManager.java

@@ -22,29 +22,12 @@
 
 package me.lucko.luckperms.tracks;
 
-import lombok.Getter;
+import me.lucko.luckperms.utils.AbstractManager;
 
-import java.util.Map;
 import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
 import java.util.stream.Collectors;
 
-public class TrackManager {
-
-    /**
-     * A {@link Map} containing all loaded tracks
-     */
-    @Getter
-    private final Map<String, Track> tracks = new ConcurrentHashMap<>();
-
-    /**
-     * Get a track object by name
-     * @param name the name to search by
-     * @return a {@link Track} object if the track is loaded, else returns null
-     */
-    public Track getTrack(String name) {
-        return tracks.get(name);
-    }
+public class TrackManager extends AbstractManager<String, Track> {
 
     /**
      * Returns a set of tracks that contain at least one of the groups from the Set provided
@@ -52,54 +35,12 @@ public class TrackManager {
      * @return a set of tracks that the groups could be a member of
      */
     public Set<Track> getApplicableTracks(String group) {
-        return tracks.values().stream().filter(t -> t.containsGroup(group)).collect(Collectors.toSet());
+        return objects.values().stream().filter(t -> t.containsGroup(group)).collect(Collectors.toSet());
     }
 
-    /**
-     * Add a track to the loaded tracks map
-     * @param track The track to add
-     */
-    public void setTrack(Track track) {
-        tracks.put(track.getName(), track);
-    }
-
-    /**
-     * Updates (or sets if the track wasn't already loaded) a track in the tracks map
-     * @param track The track to update or set
-     */
-    public void updateOrSetTrack(Track track) {
-        if (!isLoaded(track.getName())) {
-            // The track isn't already loaded
-            tracks.put(track.getName(), track);
-        } else {
-            tracks.get(track.getName()).setGroups(track.getGroups());
-        }
-    }
-
-    /**
-     * Check to see if a track is loaded or not
-     * @param name The name of the track
-     * @return true if the track is loaded
-     */
-    public boolean isLoaded(String name) {
-        return tracks.containsKey(name);
-    }
-
-    /**
-     * Removes and unloads the track from the plugins internal storage
-     * @param track The track to unload
-     */
-    public void unloadTrack(Track track) {
-        if (track != null) {
-            tracks.remove(track.getName());
-        }
-    }
-
-    /**
-     * Unloads all tracks from the manager
-     */
-    public void unloadAll() {
-        tracks.clear();
+    @Override
+    protected void copy(Track from, Track to) {
+        to.setGroups(from.getGroups());
     }
 
     /**
@@ -107,7 +48,8 @@ public class TrackManager {
      * @param name The name of the track
      * @return a new {@link Track} object
      */
-    public Track makeTrack(String name) {
+    @Override
+    public Track make(String name) {
         return new Track(name);
     }
 }

common/src/main/java/me/lucko/luckperms/users/User.java

@@ -27,11 +27,12 @@ import lombok.Getter;
 import lombok.Setter;
 import lombok.ToString;
 import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.constants.Patterns;
+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.utils.Patterns;
-import me.lucko.luckperms.utils.PermissionHolder;
+import me.lucko.luckperms.utils.Identifiable;
 
 import java.util.List;
 import java.util.Map;
@@ -40,7 +41,7 @@ import java.util.stream.Collectors;
 
 @ToString(of = {"uuid"})
 @EqualsAndHashCode(of = {"uuid"}, callSuper = false)
-public abstract class User extends PermissionHolder {
+public abstract class User extends PermissionHolder implements Identifiable<UUID> {
 
     /**
      * The users Mojang UUID
@@ -319,4 +320,9 @@ public abstract class User extends PermissionHolder {
                 .map(s -> Patterns.DOT.split(s, 2)[1])
                 .collect(Collectors.toList());
     }
+
+    @Override
+    public UUID getId() {
+        return uuid;
+    }
 }