Initial commit

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

@@ -0,0 +1,77 @@
+package me.lucko.luckperms;
+
+import me.lucko.luckperms.data.Datastore;
+import me.lucko.luckperms.groups.GroupManager;
+import me.lucko.luckperms.users.UserManager;
+import me.lucko.luckperms.utils.LPConfiguration;
+
+import java.util.UUID;
+import java.util.logging.Logger;
+
+public interface LuckPermsPlugin {
+
+    /**
+     * Retrieves the {@link UserManager} used to manage users and their permissions/groups
+     * @return the {@link UserManager} object
+     */
+    UserManager getUserManager();
+
+    /**
+     * Retrieves the {@link GroupManager} used to manage the loaded groups and modify their permissions
+     * @return the {@link GroupManager} object
+     */
+    GroupManager getGroupManager();
+
+    /**
+     * Retrieves the {@link LPConfiguration} for getting values from the config
+     * @return the {@link LPConfiguration} implementation for the platform
+     */
+    LPConfiguration getConfiguration();
+
+    /**
+     * Retrieves the {@link Datastore} for loading/saving plugin data
+     * @return the {@link Datastore} object
+     */
+    Datastore getDatastore();
+
+    /**
+     * Retrieves the {@link Logger} for the plugin
+     * @return the plugin's {@link Logger}
+     */
+    Logger getLogger();
+
+    /**
+     * @return the version of the plugin
+     */
+    String getVersion();
+
+    /**
+     * Returns a colored string indicating the status of a player
+     * @param uuid The player's uuid
+     * @return a formatted status string
+     */
+    String getPlayerStatus(UUID uuid);
+
+    /**
+     * Gets the number of users online on the platform
+     * @return the number of users
+     */
+    int getPlayerCount();
+
+    /**
+     * Runs an update task
+     */
+    void runUpdateTask();
+
+    /**
+     * Execute a runnable asynchronously
+     * @param r the task to run
+     */
+    void doAsync(Runnable r);
+
+    /**
+     * Execute a runnable synchronously
+     * @param r the task to run
+     */
+    void doSync(Runnable r);
+}

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

@@ -0,0 +1,113 @@
+package me.lucko.luckperms.commands;
+
+import lombok.Getter;
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.group.CreateGroupCommand;
+import me.lucko.luckperms.commands.group.DeleteGroupCommand;
+import me.lucko.luckperms.commands.group.GroupMainCommand;
+import me.lucko.luckperms.commands.group.ListGroupsCommand;
+import me.lucko.luckperms.commands.group.subcommands.*;
+import me.lucko.luckperms.commands.misc.DebugCommand;
+import me.lucko.luckperms.commands.misc.InfoCommand;
+import me.lucko.luckperms.commands.misc.SyncCommand;
+import me.lucko.luckperms.commands.user.UserMainCommand;
+import me.lucko.luckperms.commands.user.subcommands.*;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.logging.Level;
+
+public class CommandManager {
+    private final LuckPermsPlugin plugin;
+
+    @Getter
+    private final List<MainCommand> mainCommands = new ArrayList<>();
+
+    public CommandManager(LuckPermsPlugin plugin) {
+        this.plugin = plugin;
+
+        UserMainCommand userCommand = new UserMainCommand();
+        this.registerMainCommand(userCommand);
+        userCommand.registerSubCommand(new UserAddGroupCommand());
+        userCommand.registerSubCommand(new UserClearCommand());
+        userCommand.registerSubCommand(new UserGetUUIDCommand());
+        userCommand.registerSubCommand(new UserHasPermCommand());
+        userCommand.registerSubCommand(new UserInfoCommand());
+        userCommand.registerSubCommand(new UserListNodesCommand());
+        userCommand.registerSubCommand(new UserRemoveGroupCommand());
+        userCommand.registerSubCommand(new UserSetPermissionCommand());
+        userCommand.registerSubCommand(new UserUnSetPermissionCommand());
+
+        GroupMainCommand groupCommand = new GroupMainCommand();
+        this.registerMainCommand(groupCommand);
+        groupCommand.registerSubCommand(new GroupClearCommand());
+        groupCommand.registerSubCommand(new GroupHasPermCommand());
+        groupCommand.registerSubCommand(new GroupInfoCommand());
+        groupCommand.registerSubCommand(new GroupListNodesCommand());
+        groupCommand.registerSubCommand(new GroupSetInheritCommand());
+        groupCommand.registerSubCommand(new GroupSetPermissionCommand());
+        groupCommand.registerSubCommand(new GroupUnsetInheritCommand());
+        groupCommand.registerSubCommand(new GroupUnSetPermissionCommand());
+
+        this.registerMainCommand(new CreateGroupCommand());
+        this.registerMainCommand(new DeleteGroupCommand());
+        this.registerMainCommand(new ListGroupsCommand());
+        this.registerMainCommand(new DebugCommand());
+        this.registerMainCommand(new InfoCommand());
+        this.registerMainCommand(new SyncCommand());
+    }
+
+    /**
+     * Generic on command method to be called from the command executor object of the platform
+     * @param sender who sent the command
+     * @param args the arguments provided
+     * @return if the command was successful (hint: it always is :> )
+     */
+    public boolean onCommand(Sender sender, List<String> args) {
+        if (args.size() == 0) {
+            Util.sendPluginMessage(sender, "&6Running &bLuckPerms " + plugin.getVersion() + "&6.");
+
+            if (sender.hasPermission("luckperms.info")) {
+                for (MainCommand c : mainCommands) {
+                    Util.sendPluginMessage(sender, "&e-> &d" + c.getUsage());
+                }
+            }
+
+        } else {
+            String c = args.get(0);
+            MainCommand main = null;
+
+            for (MainCommand mainCommand : mainCommands) {
+                if (mainCommand.getName().equalsIgnoreCase(c)) {
+                    main = mainCommand;
+                    break;
+                }
+            }
+
+            if (main == null) {
+                Util.sendPluginMessage(sender, "Command not recognised.");
+                return true;
+            }
+
+            if (main.getRequiredArgsLength() == 0) {
+                main.execute(plugin, sender, null);
+                return true;
+            }
+
+            if (args.size() == 1) {
+                main.sendUsage(sender);
+                return true;
+            }
+
+            main.execute(plugin, sender, new ArrayList<>(args.subList(1, args.size())));
+        }
+        return true;
+
+    }
+
+    public void registerMainCommand(MainCommand command) {
+        plugin.getLogger().log(Level.INFO, "[CommandManager] Registered main command '" + command.getName() + "'");
+        mainCommands.add(command);
+    }
+
+}

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

@@ -0,0 +1,42 @@
+package me.lucko.luckperms.commands;
+
+import lombok.Getter;
+import me.lucko.luckperms.LuckPermsPlugin;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public abstract class MainCommand {
+
+    @Getter
+    private final String name;
+
+    @Getter
+    private final String usage;
+
+    @Getter
+    private final int requiredArgsLength;
+
+    public MainCommand(String name, String usage, int requiredArgsLength) {
+        this.name = name;
+        this.usage = usage;
+        this.requiredArgsLength = requiredArgsLength;
+    }
+
+    protected abstract void execute(LuckPermsPlugin plugin, Sender sender, List<String> args);
+    public abstract List<? extends SubCommand> getSubCommands();
+
+    protected void sendUsage(Sender sender) {
+        List<SubCommand> subs = getSubCommands().stream().filter(s -> s.isAuthorized(sender)).collect(Collectors.toList());
+        if (subs.size() > 0) {
+            Util.sendPluginMessage(sender, "&e" + getName() + " Sub Commands:");
+
+            for (SubCommand s : subs) {
+                s.sendUsage(sender);
+            }
+
+        } else {
+            Util.sendPluginMessage(sender, "You do not have permission to use this command!");
+        }
+    }
+}

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

@@ -0,0 +1,8 @@
+package me.lucko.luckperms.commands;
+
+public interface Sender {
+
+    void sendMessage(String s);
+    boolean hasPermission(String node);
+
+}

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

@@ -0,0 +1,35 @@
+package me.lucko.luckperms.commands;
+
+import lombok.Getter;
+
+public abstract class SubCommand {
+
+    @Getter
+    private final String name;
+
+    @Getter
+    private final String description;
+
+    @Getter
+    private final String usage;
+
+    @Getter
+    private final String permission;
+
+    public SubCommand(String name, String description, String usage, String permission) {
+        this.name = name;
+        this.description = description;
+        this.usage = usage;
+        this.permission = permission;
+    }
+
+    public boolean isAuthorized(Sender sender) {
+        return sender.hasPermission(permission);
+    }
+
+    public void sendUsage(Sender sender) {
+        Util.sendPluginMessage(sender, "&e-> &d" + getUsage());
+    }
+
+    public abstract boolean isArgLengthInvalid(int argLength);
+}

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

@@ -0,0 +1,81 @@
+package me.lucko.luckperms.commands;
+
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+public class Util {
+
+    public static void sendPluginMessage(Sender sender, String message) {
+        // TODO: Pull the prefix from the config somehow
+        sender.sendMessage(color("&7&l[&b&lL&a&lP&7&l] &c" + message));
+    }
+
+    public static String color(String s) {
+        return translateAlternateColorCodes('&', s);
+    }
+
+    public static String translateAlternateColorCodes(char altColorChar, String textToTranslate) {
+        // Stolen from Bukkit :>
+        char[] b = textToTranslate.toCharArray();
+
+        for(int i = 0; i < b.length - 1; ++i) {
+            if(b[i] == altColorChar && "0123456789AaBbCcDdEeFfKkLlMmNnOoRr".indexOf(b[i + 1]) > -1) {
+                b[i] = 167;
+                b[i + 1] = Character.toLowerCase(b[i + 1]);
+            }
+        }
+
+        return new String(b);
+    }
+
+    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"));
+        }
+    }
+
+    public static String listToCommaSep(List<String> strings) {
+        if (strings.isEmpty()) return "&6None";
+
+        StringBuilder sb = new StringBuilder();
+
+        for (String s : strings) {
+            sb.append("&6").append(s).append("&7, ");
+        }
+
+        return sb.delete(sb.length() - 2, sb.length()).toString();
+    }
+
+    public static String nodesToString(Map<String, Boolean> nodes) {
+        if (nodes.isEmpty()) return "&6None";
+
+        StringBuilder sb = new StringBuilder();
+
+        for (String node : nodes.keySet()) {
+            if (nodes.get(node)) {
+                sb.append("&a").append(node).append("&7, ");
+            } else {
+                sb.append("&c").append(node).append("&7, ");
+            }
+        }
+
+        return sb.delete(sb.length() - 2, sb.length()).toString();
+    }
+
+    public static UUID parseUuid(String s) {
+        try {
+            return UUID.fromString(s);
+        } catch (IllegalArgumentException e) {
+            try {
+                return UUID.fromString(s.replaceAll(
+                        "(\\w{8})(\\w{4})(\\w{4})(\\w{4})(\\w{12})",
+                        "$1-$2-$3-$4-$5"));
+            } catch (IllegalArgumentException e1) {
+                return null;
+            }
+        }
+    }
+}

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

@@ -0,0 +1,51 @@
+package me.lucko.luckperms.commands.group;
+
+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.Util;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class CreateGroupCommand extends MainCommand {
+    public CreateGroupCommand() {
+        super("CreateGroup", "/perms creategroup <group>", 1);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args) {
+        if (!sender.hasPermission("luckperms.creategroup")) {
+            Util.sendPluginMessage(sender, "You do not have permission to use this command!");
+            return;
+        }
+
+        if (args.size() == 0) {
+            sendUsage(sender);
+            return;
+        }
+
+        String groupName = args.get(0).toLowerCase();
+
+        plugin.getDatastore().loadGroup(groupName, success -> {
+            if (success) {
+                Util.sendPluginMessage(sender, "That group already exists!");
+            } else {
+                plugin.getDatastore().createAndLoadGroup(groupName, success1 -> {
+                    if (!success1) {
+                        Util.sendPluginMessage(sender, "There was an error whilst creating the group.");
+                    } else {
+                        Util.sendPluginMessage(sender, "&b" + groupName + "&a was successfully created.");
+                        plugin.runUpdateTask();
+                    }
+                });
+            }
+        });
+    }
+
+    @Override
+    public List<SubCommand> getSubCommands() {
+        return new ArrayList<>();
+    }
+}

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

@@ -0,0 +1,63 @@
+package me.lucko.luckperms.commands.group;
+
+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.Util;
+import me.lucko.luckperms.groups.Group;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class DeleteGroupCommand extends MainCommand {
+    public DeleteGroupCommand() {
+        super("DeleteGroup", "/perms deletegroup <group>", 1);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args) {
+        if (!sender.hasPermission("luckperms.deletegroup")) {
+            Util.sendPluginMessage(sender, "You do not have permission to use this command!");
+            return;
+        }
+
+        if (args.size() == 0) {
+            sendUsage(sender);
+            return;
+        }
+
+        String groupName = args.get(0).toLowerCase();
+
+        if (groupName.equalsIgnoreCase(plugin.getConfiguration().getDefaultGroupName())) {
+            Util.sendPluginMessage(sender, "You cannot delete the default group.");
+            return;
+        }
+
+        plugin.getDatastore().loadGroup(groupName, success -> {
+            if (!success) {
+                Util.sendPluginMessage(sender, "That group does not exist!");
+            } else {
+
+                Group group = plugin.getGroupManager().getGroup(groupName);
+                if (group == null) {
+                    Util.sendPluginMessage(sender, "An unexpected error occurred.");
+                } else {
+                    plugin.getDatastore().deleteGroup(group, success1 -> {
+                        if (!success1) {
+                            Util.sendPluginMessage(sender, "There was an error whilst creating the group.");
+                        } else {
+                            Util.sendPluginMessage(sender, "&b" + groupName + "&a was successfully deleted.");
+                            plugin.runUpdateTask();
+                        }
+                    });
+                }
+            }
+        });
+    }
+
+    @Override
+    public List<SubCommand> getSubCommands() {
+        return new ArrayList<>();
+    }
+}

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

@@ -0,0 +1,103 @@
+package me.lucko.luckperms.commands.group;
+
+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.Util;
+import me.lucko.luckperms.groups.Group;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class GroupMainCommand extends MainCommand {
+
+    private final List<GroupSubCommand> subCommands = new ArrayList<>();
+
+    public GroupMainCommand() {
+        super("Group", "/perms group <group>", 2);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args) {
+        if (args.size() <= 1) {
+            sendUsage(sender);
+            return;
+        }
+
+        List<String> strippedArgs = new ArrayList<>();
+        if (args.size() > 2) {
+            strippedArgs.addAll(args.subList(2, args.size()));
+        }
+
+        String c = args.get(1);
+        GroupSubCommand tempSub = null;
+
+        for (GroupSubCommand s : subCommands) {
+            if (s.getName().equalsIgnoreCase(c)) {
+                tempSub = s;
+                break;
+            }
+        }
+
+        final GroupSubCommand sub = tempSub;
+
+        if (sub == null) {
+            Util.sendPluginMessage(sender, "Command not recognised.");
+            return;
+        }
+
+
+        if (!sub.isAuthorized(sender)) {
+            Util.sendPluginMessage(sender, "You do not have permission to use this command!");
+            return;
+        }
+
+        String g = args.get(0).toLowerCase();
+
+        plugin.getDatastore().loadGroup(g, success -> {
+            if (!success) {
+                Util.sendPluginMessage(sender, "&eGroup could not be found.");
+                return;
+            }
+
+            Group group = plugin.getGroupManager().getGroup(g);
+            if (group == null) {
+                Util.sendPluginMessage(sender, "&eGroup could not be found.");
+                return;
+            }
+
+            if (sub.isArgLengthInvalid(strippedArgs.size())) {
+                sub.sendUsage(sender);
+                return;
+            }
+
+            sub.execute(plugin, sender, group, strippedArgs);
+        });
+    }
+
+    @Override
+    public List<? extends SubCommand> getSubCommands() {
+        return subCommands;
+    }
+
+    public void registerSubCommand(GroupSubCommand subCommand) {
+        subCommands.add(subCommand);
+    }
+
+    @Override
+    protected void sendUsage(Sender sender) {
+        List<SubCommand> subs = getSubCommands().stream().filter(s -> s.isAuthorized(sender)).collect(Collectors.toList());
+        if (subs.size() > 0) {
+            Util.sendPluginMessage(sender, "&e" + getName() + " Sub Commands:");
+
+            for (SubCommand s : subs) {
+                s.sendUsage(sender);
+            }
+
+        } else {
+            Util.sendPluginMessage(sender, "You do not have permission to use this command!");
+        }
+    }
+}

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

@@ -0,0 +1,29 @@
+package me.lucko.luckperms.commands.group;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.groups.Group;
+
+import java.util.List;
+
+public abstract class GroupSubCommand extends SubCommand {
+    public GroupSubCommand(String name, String description, String usage, String permission) {
+        super(name, description, usage, permission);
+    }
+
+    protected abstract void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args);
+
+    protected void saveGroup(Group group, Sender sender, LuckPermsPlugin plugin) {
+        plugin.getDatastore().saveGroup(group, success -> {
+            if (success) {
+                Util.sendPluginMessage(sender, "&7(Group data was saved to the datastore)");
+            } else {
+                Util.sendPluginMessage(sender, "There was an error whilst saving the group.");
+            }
+
+            plugin.runUpdateTask();
+        });
+    }
+}

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

@@ -0,0 +1,37 @@
+package me.lucko.luckperms.commands.group;
+
+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.Util;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ListGroupsCommand extends MainCommand {
+    public ListGroupsCommand() {
+        super("ListGroups", "/perms listgroups", 0);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args) {
+        if (!sender.hasPermission("luckperms.listgroups")) {
+            Util.sendPluginMessage(sender, "You do not have permission to use this command!");
+            return;
+        }
+
+        plugin.getDatastore().loadAllGroups(success -> {
+            if (!success) {
+                Util.sendPluginMessage(sender, "Unable to load all groups.");
+            } else {
+                Util.sendPluginMessage(sender, "&aGroups: " + Util.listToCommaSep(new ArrayList<>(plugin.getGroupManager().getGroups().keySet())));
+            }
+        });
+    }
+
+    @Override
+    public List<SubCommand> getSubCommands() {
+        return null;
+    }
+}

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

@@ -0,0 +1,29 @@
+package me.lucko.luckperms.commands.group.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.groups.Group;
+
+import java.util.List;
+
+public class GroupClearCommand extends GroupSubCommand {
+    public GroupClearCommand() {
+        super("clear", "Clears a groups permissions",
+                "/perms group <group> clear", "luckperms.group.clear");
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args) {
+        group.clearNodes();
+        Util.sendPluginMessage(sender, "&b" + group.getName() + "&a's permissions were cleared.");
+
+        saveGroup(group, sender, plugin);
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return true;
+    }
+}

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

@@ -0,0 +1,30 @@
+package me.lucko.luckperms.commands.group.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.groups.Group;
+
+import java.util.List;
+
+public class GroupHasPermCommand extends GroupSubCommand {
+    public GroupHasPermCommand() {
+        super("haspermission", "Checks to see if a group has a certain permission node",
+                "/perms group <group> haspermission <node> [server]", "luckperms.group.haspermission");
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args) {
+        if (args.size() >= 2) {
+            Util.sendBoolean(sender, args.get(0), group.hasPermission(args.get(0), true, args.get(1)));
+        } else {
+            Util.sendBoolean(sender, args.get(0), group.hasPermission(args.get(0), true, "global"));
+        }
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return argLength == 0;
+    }
+}

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

@@ -0,0 +1,31 @@
+package me.lucko.luckperms.commands.group.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.groups.Group;
+
+import java.util.List;
+
+public class GroupInfoCommand extends GroupSubCommand {
+    public GroupInfoCommand() {
+        super("info", "Gives info about the group",
+                "/perms group <group> info", "luckperms.group.info");
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args) {
+        final String prefix = plugin.getConfiguration().getPrefix();
+        String sb = prefix + "&d-> &eGroup: &6" + group.getName() + "\n" +
+                prefix + "&d-> &ePermissions: &6" + group.getNodes().keySet().size() + "\n" +
+                prefix + "&d-> &bUse &a/perms group " + group.getName() + " listnodes &bto see all permissions.";
+
+        sender.sendMessage(Util.color(sb));
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return false;
+    }
+}

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

@@ -0,0 +1,27 @@
+package me.lucko.luckperms.commands.group.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.groups.Group;
+
+import java.util.List;
+
+public class GroupListNodesCommand extends GroupSubCommand {
+    public GroupListNodesCommand() {
+        super("listnodes", "Lists the permission nodes the group has",
+                "/perms group <group> listnodes", "luckperms.group.listnodes");
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args) {
+        Util.sendPluginMessage(sender, "&e" + group.getName() + "'s Nodes:");
+        sender.sendMessage(Util.color(Util.nodesToString(group.getNodes())));
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return false;
+    }
+}

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

@@ -0,0 +1,50 @@
+package me.lucko.luckperms.commands.group.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.groups.Group;
+
+import java.util.List;
+
+public class GroupSetInheritCommand extends GroupSubCommand {
+    public GroupSetInheritCommand() {
+        super("setinherit", "Sets another group for this group to inherit permissions from",
+                "/perms group <group> setinherit <group> [server]", "luckperms.group.setinherit");
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args) {
+        String groupName = args.get(0).toLowerCase();
+
+        plugin.getDatastore().loadGroup(groupName, success -> {
+            if (!success) {
+                Util.sendPluginMessage(sender, groupName + " does not exist!");
+            } else {
+                final String node = "luckperms.group." + groupName;
+
+                try {
+                    if (args.size() == 2) {
+                        final String server = args.get(1).toLowerCase();
+                        group.setPermission(node, true, server);
+                        Util.sendPluginMessage(sender, "&b" + group.getName() + "&a now inherits permissions from &b" + groupName + "&a on server &b" + server + "&a.");
+                    } else {
+                        group.setPermission(node, true);
+                        Util.sendPluginMessage(sender, "&b" + group.getName() + "&a now inherits permissions from &b" + groupName + "&a.");
+                    }
+
+                    saveGroup(group, sender, plugin);
+                } catch (ObjectAlreadyHasException e) {
+                    Util.sendPluginMessage(sender, group.getName() + " already inherits '" + groupName + "'.");
+                }
+            }
+        });
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return argLength == 0;
+    }
+}

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

@@ -0,0 +1,60 @@
+package me.lucko.luckperms.commands.group.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.groups.Group;
+
+import java.util.List;
+
+public class GroupSetPermissionCommand extends GroupSubCommand {
+    public GroupSetPermissionCommand() {
+        super("set", "Sets a permission for a group",
+                "/perms group <group> set <node> <true|false> [server]", "luckperms.group.setpermission");
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args) {
+        String node = args.get(0);
+        String bool = args.get(1);
+
+        if (node.contains("/")) {
+            sendUsage(sender);
+            return;
+        }
+
+        if (node.matches(".*luckperms\\.group\\..*")) {
+            Util.sendPluginMessage(sender, "Use the inherit command instead of specifying the node.");
+            return;
+        }
+
+        if (!bool.equalsIgnoreCase("true") && !bool.equalsIgnoreCase("false")) {
+            sendUsage(sender);
+            return;
+        }
+
+        boolean b = Boolean.parseBoolean(bool);
+
+        try {
+            if (args.size() == 3) {
+                final String server = args.get(2).toLowerCase();
+                group.setPermission(node, b, server);
+                Util.sendPluginMessage(sender, "&aSet &b" + node + "&a to &b" + bool + "&a for &b" + group.getName() + "&a on server &b" + server + "&a.");
+            } else {
+                group.setPermission(node, b);
+                Util.sendPluginMessage(sender, "&aSet &b" + node + "&a to " + bool + " for &b" + group.getName() + "&a.");
+            }
+
+            saveGroup(group, sender, plugin);
+        } catch (ObjectAlreadyHasException e) {
+            Util.sendPluginMessage(sender, group.getName() + " already has this permission!");
+        }
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return argLength < 2;
+    }
+}

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

@@ -0,0 +1,52 @@
+package me.lucko.luckperms.commands.group.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.exceptions.ObjectLacksPermissionException;
+import me.lucko.luckperms.groups.Group;
+
+import java.util.List;
+
+public class GroupUnSetPermissionCommand extends GroupSubCommand {
+    public GroupUnSetPermissionCommand() {
+        super("unset", "Unsets a permission for a group",
+                "/perms group <group> unset <node> [server]", "luckperms.group.unsetpermission");
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args) {
+        String node = args.get(0);
+
+        if (node.contains("/")) {
+            sendUsage(sender);
+            return;
+        }
+
+        if (node.matches(".*luckperms\\.group\\..*")) {
+            Util.sendPluginMessage(sender, "Use the uninherit command instead of specifying the node.");
+            return;
+        }
+
+        try {
+            if (args.size() == 2) {
+                final String server = args.get(1).toLowerCase();
+                group.unsetPermission(node, server);
+                Util.sendPluginMessage(sender, "&aUnset &b" + node + "&a for &b" + group.getName() + "&a on server &b" + server + "&a.");
+            } else {
+                group.unsetPermission(node);
+                Util.sendPluginMessage(sender, "&aUnset &b" + node + "&a for &b" + group.getName() + "&a.");
+            }
+
+            saveGroup(group, sender, plugin);
+        } catch (ObjectLacksPermissionException e) {
+            Util.sendPluginMessage(sender, "That group does not have this permission set.");
+        }
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return argLength == 0;
+    }
+}

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

@@ -0,0 +1,42 @@
+package me.lucko.luckperms.commands.group.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.group.GroupSubCommand;
+import me.lucko.luckperms.exceptions.ObjectLacksPermissionException;
+import me.lucko.luckperms.groups.Group;
+
+import java.util.List;
+
+public class GroupUnsetInheritCommand extends GroupSubCommand {
+    public GroupUnsetInheritCommand() {
+        super("unsetinherit", "Unsets another group for this group to inherit permissions from",
+                "/perms group <group> unsetinherit <group> [server]", "luckperms.group.unsetinherit");
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, Group group, List<String> args) {
+        String groupName = args.get(0).toLowerCase();
+
+        String server;
+        if (args.size() == 2) {
+            server = args.get(1).toLowerCase();
+        } else {
+            server = "global";
+        }
+
+        try {
+            group.unsetPermission("luckperms.group." + groupName, server);
+            Util.sendPluginMessage(sender, "&b" + group.getName() + "&a no longer inherits permissions from &b" + groupName + "&a on server &b" + server + "&a.");
+            saveGroup(group, sender, plugin);
+        } catch (ObjectLacksPermissionException e) {
+            Util.sendPluginMessage(sender, "That group does not inherit '" + groupName + "'.");
+        }
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return argLength == 0;
+    }
+}

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

@@ -0,0 +1,34 @@
+package me.lucko.luckperms.commands.misc;
+
+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.Util;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class DebugCommand extends MainCommand {
+    public DebugCommand() {
+        super("Debug", "/perms debug", 0);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args) {
+        if (!sender.hasPermission("luckperms.debug")) {
+            Util.sendPluginMessage(sender, "You do not have permission to use this command!");
+            return;
+        }
+
+        Util.sendPluginMessage(sender, "&d>> Debug Info");
+        Util.sendPluginMessage(sender, "&eOnline Players: &6" + plugin.getPlayerCount());
+        Util.sendPluginMessage(sender, "&eLoaded Users: &6" + plugin.getUserManager().getUsers().size());
+        Util.sendPluginMessage(sender, "&eLoaded Groups: &6" + plugin.getGroupManager().getGroups().size());
+    }
+
+    @Override
+    public List<? extends SubCommand> getSubCommands() {
+        return new ArrayList<>();
+    }
+}

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

@@ -0,0 +1,33 @@
+package me.lucko.luckperms.commands.misc;
+
+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.Util;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class InfoCommand extends MainCommand {
+    public InfoCommand() {
+        super("Info", "/perms info", 0);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args) {
+        if (!sender.hasPermission("luckperms.info")) {
+            Util.sendPluginMessage(sender, "You do not have permission to use this command!");
+            return;
+        }
+
+        Util.sendPluginMessage(sender, "&6Running &bLuckPerms " + plugin.getVersion() + "&6.");
+        Util.sendPluginMessage(sender, "&eAuthor: &6Luck");
+        Util.sendPluginMessage(sender, "&eStorage Method: &6" + plugin.getDatastore().getName());
+    }
+
+    @Override
+    public List<? extends SubCommand> getSubCommands() {
+        return new ArrayList<>();
+    }
+}

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

@@ -0,0 +1,32 @@
+package me.lucko.luckperms.commands.misc;
+
+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.Util;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class SyncCommand extends MainCommand {
+    public SyncCommand() {
+        super("Sync", "/perms sync", 0);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args) {
+        if (!sender.hasPermission("luckperms.sync")) {
+            Util.sendPluginMessage(sender, "You do not have permission to use this command!");
+            return;
+        }
+
+        Util.sendPluginMessage(sender, "&bRunning update task for all online users.");
+        plugin.runUpdateTask();
+    }
+
+    @Override
+    public List<? extends SubCommand> getSubCommands() {
+        return new ArrayList<>();
+    }
+}

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

@@ -0,0 +1,115 @@
+package me.lucko.luckperms.commands.user;
+
+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.Util;
+import me.lucko.luckperms.users.User;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+
+public class UserMainCommand extends MainCommand{
+
+    private final List<UserSubCommand> subCommands = new ArrayList<>();
+
+    public UserMainCommand() {
+        super("User", "/perms user <user>", 2);
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, List<String> args) {
+        if (args.size() <= 1) {
+            sendUsage(sender);
+            return;
+        }
+
+        // The first argument is the name of the user, the second is the command
+        String command = args.get(1);
+        UserSubCommand tempSub = null;
+
+        // Try to identify the command used
+        for (UserSubCommand s : subCommands) {
+            if (s.getName().equalsIgnoreCase(command)) {
+                tempSub = s;
+                break;
+            }
+        }
+
+        // The command the sender used
+        final UserSubCommand sub = tempSub;
+
+        if (sub == null) {
+            Util.sendPluginMessage(sender, "Command not recognised.");
+            return;
+        }
+
+        if (!sub.isAuthorized(sender)) {
+            Util.sendPluginMessage(sender, "You do not have permission to use this command!");
+            return;
+        }
+
+        // The arguments to be passed onto the sub command
+        List<String> strippedArgs = new ArrayList<>();
+        if (args.size() > 2) {
+            strippedArgs.addAll(args.subList(2, args.size()));
+        }
+
+        String user = args.get(0);
+
+        UUID u = Util.parseUuid(user);
+        if (u != null) {
+            runSub(plugin, sender, u, sub, strippedArgs);
+            return;
+        }
+
+        if (user.length() <= 16) {
+            Util.sendPluginMessage(sender, "&7(Attempting UUID lookup, since you specified a user)");
+
+            plugin.getDatastore().getUUID(user, uuid -> {
+                if (uuid == null) {
+                    Util.sendPluginMessage(sender, "&eUser could not be found.");
+                    return;
+                }
+                runSub(plugin, sender, uuid, sub, strippedArgs);
+            });
+            return;
+        }
+
+        Util.sendPluginMessage(sender, "&d" + user + "&c is not a valid username/uuid.");
+    }
+
+    private void runSub(LuckPermsPlugin plugin, Sender sender, UUID uuid, UserSubCommand command, List<String> strippedArgs) {
+        plugin.getDatastore().loadUser(uuid, success -> {
+            if (!success) {
+                Util.sendPluginMessage(sender, "&eUser could not be found.");
+                return;
+            }
+
+            User user1 = plugin.getUserManager().getUser(uuid);
+
+            if (user1 == null) {
+                Util.sendPluginMessage(sender, "&eUser could not be found.");
+            }
+
+            if (command.isArgLengthInvalid(strippedArgs.size())) {
+                command.sendUsage(sender);
+                return;
+            }
+
+            command.execute(plugin, sender, user1, strippedArgs);
+            plugin.getUserManager().cleanupUser(user1);
+        });
+    }
+
+    @Override
+    public List<? extends SubCommand> getSubCommands() {
+        return subCommands;
+    }
+
+    public void registerSubCommand(UserSubCommand subCommand) {
+        subCommands.add(subCommand);
+    }
+}

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

@@ -0,0 +1,29 @@
+package me.lucko.luckperms.commands.user;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.SubCommand;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.users.User;
+
+import java.util.List;
+
+public abstract class UserSubCommand extends SubCommand {
+    public UserSubCommand(String name, String description, String usage, String permission) {
+        super(name, description, usage, permission);
+    }
+
+    protected abstract void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args);
+
+    protected void saveUser(User user, Sender sender, LuckPermsPlugin plugin) {
+        user.refreshPermissions();
+
+        plugin.getDatastore().saveUser(user, success -> {
+            if (success) {
+                Util.sendPluginMessage(sender, "&7(User data was saved to the datastore)");
+            } else {
+                Util.sendPluginMessage(sender, "There was an error whilst saving the user.");
+            }
+        });
+    }
+}

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

@@ -0,0 +1,49 @@
+package me.lucko.luckperms.commands.user.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.groups.Group;
+import me.lucko.luckperms.users.User;
+
+import java.util.List;
+
+public class UserAddGroupCommand extends UserSubCommand {
+    public UserAddGroupCommand() {
+        super("addgroup", "Adds the user to a group",
+                "/perms user <user> addgroup <group> [server]", "luckperms.user.addgroup");
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args) {
+        String group = args.get(0).toLowerCase();
+
+        String server;
+        if (args.size() != 1) {
+            server = args.get(1);
+        } else {
+            server = "global";
+        }
+
+        Group group1 = plugin.getGroupManager().getGroup(group);
+        if (group1 == null) {
+            Util.sendPluginMessage(sender, "That group does not exist!");
+            return;
+        }
+
+        try {
+            user.addGroup(group1, server);
+            Util.sendPluginMessage(sender, "&b" + user.getName() + "&a successfully added to group &b" + group + "&a on the server &b" + server + "&a.");
+        } catch (ObjectAlreadyHasException e) {
+            Util.sendPluginMessage(sender, "The user is already a member of that group.");
+        }
+        saveUser(user, sender, plugin);
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return (argLength != 1 && argLength != 2);
+    }
+}

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

@@ -0,0 +1,30 @@
+package me.lucko.luckperms.commands.user.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.users.User;
+
+import java.util.List;
+
+public class UserClearCommand extends UserSubCommand {
+    public UserClearCommand() {
+        super("clear", "Clears a users permissions and groups",
+                "/perms user <user> clear", "luckperms.user.clear");
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args) {
+        user.clearNodes();
+        user.getNodes().put(plugin.getConfiguration().getDefaultGroupNode(), true);
+        Util.sendPluginMessage(sender, "&b" + user.getName() + "&a's permissions were cleared.");
+
+        saveUser(user, sender, plugin);
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return false;
+    }
+}

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

@@ -0,0 +1,25 @@
+package me.lucko.luckperms.commands.user.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.users.User;
+
+import java.util.List;
+
+public class UserGetUUIDCommand extends UserSubCommand {
+    public UserGetUUIDCommand() {
+        super("getuuid", "Get the UUID of a user", "/perms user <user> getuuid", "luckperms.user.getuuid");
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args) {
+        Util.sendPluginMessage(sender, "&bThe UUID of &e" + user.getName() + "&b is &e" + user.getUuid().toString() + "&b.");
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return false;
+    }
+}

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

@@ -0,0 +1,30 @@
+package me.lucko.luckperms.commands.user.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.users.User;
+
+import java.util.List;
+
+public class UserHasPermCommand extends UserSubCommand {
+    public UserHasPermCommand() {
+        super("haspermission", "Checks to see if a user has a certain permission node",
+                "/perms user <user> haspermission <node> [server]", "luckperms.user.haspermission");
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args) {
+        if (args.size() >= 2) {
+            Util.sendBoolean(sender, args.get(0), user.hasPermission(args.get(0), true, args.get(1)));
+        } else {
+            Util.sendBoolean(sender, args.get(0), user.hasPermission(args.get(0), true, "global"));
+        }
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return argLength == 0;
+    }
+}

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

@@ -0,0 +1,34 @@
+package me.lucko.luckperms.commands.user.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.users.User;
+
+import java.util.List;
+
+public class UserInfoCommand extends UserSubCommand {
+    public UserInfoCommand() {
+        super("info", "Gives info about the user",
+                "/perms user <user> info", "luckperms.user.info");
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args) {
+        final String prefix = plugin.getConfiguration().getPrefix();
+        String sb = prefix + "&d-> &eUser: &6" + user.getName() + "\n" +
+                prefix + "&d-> &eUUID: &6" + user.getUuid() + "\n" +
+                prefix + "&d-> &eStatus: " + plugin.getPlayerStatus(user.getUuid()) + "\n" +
+                prefix + "&d-> &eGroups: &6" + Util.listToCommaSep(user.getGroupNames()) + "\n" +
+                prefix + "&d-> &ePermissions: &6" + (user.getNodes().keySet().size() - user.getGroupNames().size()) + "\n" +
+                prefix + "&d-> &bUse &a/perms user " + user.getName() + " listnodes &bto see all permissions.";
+
+        sender.sendMessage(Util.color(sb));
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return false;
+    }
+}

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

@@ -0,0 +1,27 @@
+package me.lucko.luckperms.commands.user.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.users.User;
+
+import java.util.List;
+
+public class UserListNodesCommand extends UserSubCommand {
+    public UserListNodesCommand() {
+        super("listnodes", "Lists the permission nodes the user has",
+                "/perms user <user> listnodes", "luckperms.user.listnodes");
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args) {
+        Util.sendPluginMessage(sender, "&e" + user.getName() + "'s Nodes:");
+        sender.sendMessage(Util.color(Util.nodesToString(user.getNodes())));
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return false;
+    }
+}

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

@@ -0,0 +1,49 @@
+package me.lucko.luckperms.commands.user.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.exceptions.ObjectLacksPermissionException;
+import me.lucko.luckperms.groups.Group;
+import me.lucko.luckperms.users.User;
+
+import java.util.List;
+
+public class UserRemoveGroupCommand extends UserSubCommand {
+    public UserRemoveGroupCommand() {
+        super("removegroup", "Removes a user from a group",
+                "/perms user <user> removegroup <group> [server]", "luckperms.user.removegroup");
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args) {
+        String group = args.get(0).toLowerCase();
+
+        String server;
+        if (args.size() != 1) {
+            server = args.get(1);
+        } else {
+            server = "global";
+        }
+
+        Group group1 = plugin.getGroupManager().getGroup(group);
+        if (group1 == null) {
+            Util.sendPluginMessage(sender, "That group does not exist!");
+            return;
+        }
+
+        try {
+            user.removeGroup(group1, server);
+            Util.sendPluginMessage(sender, "&b" + user.getName() + "&a was removed from group &b" + group + "&a on server &b" + server + "&a.");
+        } catch (ObjectLacksPermissionException e) {
+            Util.sendPluginMessage(sender, "The user is not a member of that group.");
+        }
+        saveUser(user, sender, plugin);
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return (argLength != 1 && argLength != 2);
+    }
+}

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

@@ -0,0 +1,60 @@
+package me.lucko.luckperms.commands.user.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.users.User;
+
+import java.util.List;
+
+public class UserSetPermissionCommand extends UserSubCommand {
+    public UserSetPermissionCommand() {
+        super("set", "Sets a permission for a user",
+                "/perms user <user> set <node> <true|false> [server]", "luckperms.user.setpermission");
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args) {
+        String node = args.get(0);
+        String bool = args.get(1);
+
+        if (node.contains("/")) {
+            sendUsage(sender);
+            return;
+        }
+
+        if (node.matches(".*luckperms\\.group\\..*")) {
+            Util.sendPluginMessage(sender, "Use the addgroup command instead of specifying the node.");
+            return;
+        }
+
+        if (!bool.equalsIgnoreCase("true") && !bool.equalsIgnoreCase("false")) {
+            sendUsage(sender);
+            return;
+        }
+
+        boolean b = Boolean.parseBoolean(bool);
+
+        try {
+            if (args.size() == 3) {
+                final String server = args.get(2).toLowerCase();
+                user.setPermission(node, b, server);
+                Util.sendPluginMessage(sender, "&aSet &b" + node + "&a to " + bool + " for &b" + user.getName() + "&a on server &b" + server + "&a.");
+            } else {
+                user.setPermission(node, b);
+                Util.sendPluginMessage(sender, "&aSet &b" + node + "&a to " + bool + " for &b" + user.getName() + "&a.");
+            }
+        } catch (ObjectAlreadyHasException e) {
+            Util.sendPluginMessage(sender, "That user already has this permission!");
+        }
+
+        saveUser(user, sender, plugin);
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return argLength < 2;
+    }
+}

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

@@ -0,0 +1,51 @@
+package me.lucko.luckperms.commands.user.subcommands;
+
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.commands.user.UserSubCommand;
+import me.lucko.luckperms.exceptions.ObjectLacksPermissionException;
+import me.lucko.luckperms.users.User;
+
+import java.util.List;
+
+public class UserUnSetPermissionCommand extends UserSubCommand {
+    public UserUnSetPermissionCommand() {
+        super("unset", "Unsets a permission for a user",
+                "/perms user <user> unset <node> [server]", "luckperms.user.unsetpermission");
+    }
+
+    @Override
+    protected void execute(LuckPermsPlugin plugin, Sender sender, User user, List<String> args) {
+        String node = args.get(0);
+
+        if (node.contains("/")) {
+            sendUsage(sender);
+            return;
+        }
+
+        if (node.matches(".*luckperms\\.group\\..*")) {
+            Util.sendPluginMessage(sender, "Use the removegroup command instead of specifying the node.");
+            return;
+        }
+
+        try {
+            if (args.size() == 2) {
+                final String server = args.get(1).toLowerCase();
+                user.unsetPermission(node, server);
+                Util.sendPluginMessage(sender, "&aUnset &b" + node + "&a for &b" + user.getName() + "&a on server &b" + server + "&a.");
+            } else {
+                user.unsetPermission(node);
+                Util.sendPluginMessage(sender, "&aUnset &b" + node + "&a for &b" + user.getName() + "&a.");
+            }
+        } catch (ObjectLacksPermissionException e) {
+            Util.sendPluginMessage(sender, "That user does not have this permission set.");
+        }
+        saveUser(user, sender, plugin);
+    }
+
+    @Override
+    public boolean isArgLengthInvalid(int argLength) {
+        return argLength == 0;
+    }
+}

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

@@ -0,0 +1,117 @@
+package me.lucko.luckperms.data;
+
+import lombok.Getter;
+import lombok.Setter;
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.groups.Group;
+import me.lucko.luckperms.users.User;
+
+import java.util.UUID;
+
+public abstract class Datastore {
+    protected final LuckPermsPlugin plugin;
+
+    @Getter
+    public String name;
+
+    @Getter
+    @Setter
+    private boolean acceptingLogins;
+
+    public Datastore(LuckPermsPlugin plugin, String name) {
+        this.plugin = plugin;
+        this.name = name;
+        this.acceptingLogins = true;
+    }
+
+    /**
+     * Execute a runnable asynchronously
+     * @param r the task to run
+     */
+    private void doAsync(Runnable r) {
+        plugin.doAsync(r);
+    }
+
+    /**
+     * Execute a runnable synchronously
+     * @param r the task to run
+     */
+    private void doSync(Runnable r) {
+        plugin.doSync(r);
+    }
+
+    private void runCallback(boolean result, Callback callback) {
+        doSync(() -> callback.onComplete(result));
+    }
+
+    /*
+        These methods will block the thread that they're ran on.
+     */
+    public abstract void init(DatastoreConfiguration configuration);
+    public abstract boolean loadOrCreateUser(UUID uuid, String username);
+    public abstract boolean loadUser(UUID uuid);
+    public abstract boolean saveUser(User user);
+    public abstract boolean createAndLoadGroup(String name);
+    public abstract boolean loadGroup(String name);
+    public abstract boolean loadAllGroups();
+    public abstract boolean saveGroup(Group group);
+    public abstract boolean deleteGroup(Group group);
+    public abstract boolean saveUUIDData(String username, UUID uuid);
+    public abstract UUID getUUID(String username);
+
+
+
+    /*
+        These methods will return as soon as they are called. The callback will be ran when the task is complete
+        They therefore will not block the thread that they're ran on
+
+        Callbacks are ran on the main server thread (if applicable)
+     */
+    public void loadOrCreateUser(UUID uuid, String username, Callback callback) {
+        doAsync(() -> runCallback(loadOrCreateUser(uuid, username), callback));
+    }
+
+    public void loadUser(UUID uuid, Callback callback) {
+        doAsync(() -> runCallback(loadUser(uuid), callback));
+    }
+
+    public void saveUser(User user, Callback callback) {
+        doAsync(() -> runCallback(saveUser(user), callback));
+    }
+
+    public void createAndLoadGroup(String name, Callback callback) {
+        doAsync(() -> runCallback(createAndLoadGroup(name), callback));
+    }
+
+    public void loadGroup(String name, Callback callback) {
+        doAsync(() -> runCallback(loadGroup(name), callback));
+    }
+
+    public void loadAllGroups(Callback callback) {
+        doAsync(() -> runCallback(loadAllGroups(), callback));
+    }
+
+    public void saveGroup(Group group, Callback callback) {
+        doAsync(() -> runCallback(saveGroup(group), callback));
+    }
+
+    public void deleteGroup(Group group, Callback callback) {
+        doAsync(() -> runCallback(deleteGroup(group), callback));
+    }
+
+    public void saveUUIDData(String username, UUID uuid, Callback callback) {
+        doAsync(() -> runCallback(saveUUIDData(username, uuid), callback));
+    }
+
+    public void getUUID(String username, GetUUIDCallback callback) {
+        doAsync(() -> doSync(() -> callback.onComplete(getUUID(username))));
+    }
+
+    public interface Callback {
+        void onComplete(boolean success);
+    }
+
+    public interface GetUUIDCallback {
+        void onComplete(UUID uuid);
+    }
+}

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

@@ -0,0 +1,15 @@
+package me.lucko.luckperms.data;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class DatastoreConfiguration {
+
+    private final String address;
+    private final String database;
+    private final String username;
+    private final String password;
+
+}

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

@@ -0,0 +1,338 @@
+package me.lucko.luckperms.data;
+
+import com.zaxxer.hikari.HikariDataSource;
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.groups.Group;
+import me.lucko.luckperms.groups.GroupManager;
+import me.lucko.luckperms.users.User;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.UUID;
+import java.util.logging.Level;
+
+public class HikariDatastore extends Datastore {
+
+    private static final String CREATETABLE_UUID = "CREATE TABLE IF NOT EXISTS `lp_uuid` (`name` VARCHAR(16) NOT NULL, `uuid` VARCHAR(36) NOT NULL, PRIMARY KEY (`name`)) ENGINE=InnoDB DEFAULT CHARSET=latin1;";
+    private static final String CREATETABLE_USERS = "CREATE TABLE IF NOT EXISTS `lp_users` (`uuid` VARCHAR(36) NOT NULL, `name` VARCHAR(16) 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 USER_INSERT = "INSERT INTO lp_users VALUES(?, ?, ?) ON DUPLICATE KEY UPDATE name=?";
+    private static final String USER_SELECT = "SELECT * FROM lp_users WHERE uuid=?";
+    private static final String USER_SAVE = "UPDATE lp_users SET name=?, perms=? WHERE uuid=?";
+
+    private static final String GROUP_INSERT = "INSERT INTO lp_groups VALUES(?, ?) ON DUPLICATE KEY UPDATE perms=?";
+    private static final String GROUP_SELECT = "SELECT perms FROM lp_groups WHERE name=?";
+    private static final String GROUP_SELECT_ALL = "SELECT * FROM lp_groups";
+    private static final String GROUP_SAVE = "UPDATE lp_groups SET perms=? WHERE name=?";
+    private static final String GROUP_DELETE = "DELETE FROM lp_groups WHERE name=?";
+
+    private static final String UUIDCACHE_INSERT = "INSERT INTO lp_uuid VALUES(?, ?) ON DUPLICATE KEY UPDATE uuid=?";
+    private static final String UUIDCACHE_SELECT = "SELECT uuid FROM lp_uuid WHERE name=?";
+
+    private HikariDataSource hikari;
+
+    public HikariDatastore(LuckPermsPlugin plugin) {
+        super(plugin, "MySQL");
+    }
+
+    private static void executeQuery(Connection connection, String query) throws SQLException {
+        PreparedStatement preparedStatement = connection.prepareStatement(query);
+        preparedStatement.execute();
+        preparedStatement.close();
+    }
+
+    private boolean runQuery(Query query) {
+        boolean success = false;
+
+        Connection connection = null;
+        try {
+            connection = hikari.getConnection();
+            success = query.onRun(connection);
+        } catch (SQLException e) {
+            e.printStackTrace();
+            success = false;
+        } finally {
+            if (connection != null) {
+                try {
+                    connection.close();
+                } catch (SQLException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+        return success;
+    }
+
+    private void setupTables() {
+        boolean success = runQuery(connection -> {
+            executeQuery(connection, CREATETABLE_UUID);
+            executeQuery(connection, CREATETABLE_USERS);
+            executeQuery(connection, CREATETABLE_GROUPS);
+            return true;
+        });
+
+        if (!success) {
+            plugin.getLogger().log(Level.SEVERE, "Error occurred whilst connecting to the database. All connections are disallowed.");
+            hikari.shutdown();
+            setAcceptingLogins(false);
+        }
+    }
+
+    @Override
+    public void init(DatastoreConfiguration configuration) {
+        hikari = new HikariDataSource();
+
+        final String address = configuration.getAddress();
+        final String database = configuration.getDatabase();
+        final String username = configuration.getUsername();
+        final String password = configuration.getPassword();
+
+        hikari.setMaximumPoolSize(10);
+        hikari.setDataSourceClassName("com.mysql.jdbc.jdbc2.optional.MysqlDataSource");
+        hikari.addDataSourceProperty("serverName", address.split(":")[0]);
+        hikari.addDataSourceProperty("port", address.split(":")[1]);
+        hikari.addDataSourceProperty("databaseName", database);
+        hikari.addDataSourceProperty("user", username);
+        hikari.addDataSourceProperty("password", password);
+
+        setupTables();
+    }
+
+    @Override
+    public boolean loadUser(UUID uuid) {
+        User user = plugin.getUserManager().makeUser(uuid);
+        boolean success = runQuery(connection -> {
+            PreparedStatement preparedStatement = connection.prepareStatement(USER_SELECT);
+            preparedStatement.setString(1, uuid.toString());
+
+            ResultSet resultSet = preparedStatement.executeQuery();
+            List<String> nodes = new ArrayList<>();
+
+            if (resultSet.next()) {
+                if (!resultSet.getString("perms").equals("#")) {
+                    nodes.addAll(Arrays.asList(resultSet.getString("perms").split(":")));
+                }
+                user.setName(resultSet.getString("name"));
+
+                user.loadNodes(nodes);
+                preparedStatement.close();
+                resultSet.close();
+                return true;
+            }
+            preparedStatement.close();
+            resultSet.close();
+            return false;
+        });
+
+        if (success) plugin.getUserManager().updateOrSetUser(user);
+        return success;
+    }
+
+    @Override
+    public boolean loadOrCreateUser(UUID uuid, String username) {
+        User user = plugin.getUserManager().makeUser(uuid, username);
+        boolean success = runQuery(connection -> {
+            PreparedStatement preparedStatement = connection.prepareStatement(USER_INSERT);
+            preparedStatement.setString(1, uuid.toString());
+            preparedStatement.setString(2, username);
+            preparedStatement.setString(3, plugin.getConfiguration().getDefaultGroupNode());
+            preparedStatement.setString(4, username);
+            preparedStatement.execute();
+            preparedStatement.close();
+
+            preparedStatement = connection.prepareStatement(USER_SELECT);
+            preparedStatement.setString(1, uuid.toString());
+
+            ResultSet resultSet = preparedStatement.executeQuery();
+            List<String> nodes = new ArrayList<>();
+
+            if (resultSet.next()) {
+                if (!resultSet.getString("perms").equals("#")) {
+                    nodes.addAll(Arrays.asList(resultSet.getString("perms").split(":")));
+                }
+                user.loadNodes(nodes);
+                preparedStatement.close();
+                resultSet.close();
+                return true;
+            }
+            preparedStatement.close();
+            resultSet.close();
+            return true;
+        });
+
+        if (success) plugin.getUserManager().updateOrSetUser(user);
+        return success;
+    }
+
+    @Override
+    public boolean saveUser(User user) {
+        boolean success = runQuery(connection -> {
+            PreparedStatement preparedStatement = connection.prepareStatement(USER_SAVE);
+            preparedStatement.setString(1, user.getName());
+            preparedStatement.setString(2, user.serializeNodes());
+            preparedStatement.setString(3, user.getUuid().toString());
+            preparedStatement.execute();
+            preparedStatement.close();
+            return true;
+        });
+        return success;
+    }
+
+    @Override
+    public boolean createAndLoadGroup(String name) {
+        Group group = plugin.getGroupManager().makeGroup(name);
+        boolean success = runQuery(connection -> {
+            PreparedStatement preparedStatement = connection.prepareStatement(GROUP_INSERT);
+            preparedStatement.setString(1, name);
+            preparedStatement.setString(2, "#");
+            preparedStatement.setString(3, "#");
+            preparedStatement.execute();
+            preparedStatement.close();
+
+            preparedStatement = connection.prepareStatement(GROUP_SELECT);
+            preparedStatement.setString(1, name);
+
+            ResultSet resultSet = preparedStatement.executeQuery();
+            List<String> nodes = new ArrayList<>();
+
+            if (resultSet.next()) {
+                if (!resultSet.getString("perms").equals("#")) {
+                    nodes.addAll(Arrays.asList(resultSet.getString("perms").split(":")));
+                }
+            }
+
+            group.loadNodes(nodes);
+            preparedStatement.close();
+            resultSet.close();
+            return true;
+        });
+        if (success) plugin.getGroupManager().updateOrSetGroup(group);
+        return success;
+    }
+
+    @Override
+    public boolean loadGroup(String name) {
+        Group group = plugin.getGroupManager().makeGroup(name);
+        boolean success = runQuery(connection -> {
+            PreparedStatement preparedStatement = connection.prepareStatement(GROUP_SELECT);
+            preparedStatement.setString(1, name);
+
+            ResultSet resultSet = preparedStatement.executeQuery();
+            List<String> nodes = new ArrayList<>();
+
+            if (resultSet.next()) {
+                if (!resultSet.getString("perms").equals("#")) {
+                    nodes.addAll(Arrays.asList(resultSet.getString("perms").split(":")));
+                }
+
+                group.loadNodes(nodes);
+                return true;
+            }
+            preparedStatement.close();
+            resultSet.close();
+            return false;
+        });
+        if (success) plugin.getGroupManager().updateOrSetGroup(group);
+        return success;
+    }
+
+    @Override
+    public boolean loadAllGroups() {
+        List<Group> groups = new ArrayList<>();
+        boolean success = runQuery(connection -> {
+            PreparedStatement preparedStatement = connection.prepareStatement(GROUP_SELECT_ALL);
+
+            ResultSet resultSet = preparedStatement.executeQuery();
+
+            while (resultSet.next()) {
+                Group group = plugin.getGroupManager().makeGroup(resultSet.getString("name"));
+                if (!resultSet.getString("perms").equals("#")) {
+                    group.loadNodes(Arrays.asList(resultSet.getString("perms").split(":")));
+                }
+                groups.add(group);
+            }
+            preparedStatement.close();
+            resultSet.close();
+            return true;
+        });
+
+        GroupManager gm = plugin.getGroupManager();
+        if (success) {
+            groups.forEach(gm::setGroup);
+        }
+        return success;
+    }
+
+    @Override
+    public boolean saveGroup(Group group) {
+        boolean success = runQuery(connection -> {
+            PreparedStatement preparedStatement = connection.prepareStatement(GROUP_SAVE);
+            preparedStatement.setString(1, group.serializeNodes());
+            preparedStatement.setString(2, group.getName());
+            preparedStatement.execute();
+            preparedStatement.close();
+            return true;
+        });
+        return success;
+    }
+
+    @Override
+    public boolean deleteGroup(Group group) {
+        boolean success = runQuery(connection -> {
+            PreparedStatement preparedStatement = connection.prepareStatement(GROUP_DELETE);
+            preparedStatement.setString(1, group.getName());
+            preparedStatement.execute();
+            preparedStatement.close();
+            return true;
+        });
+        if (success) plugin.getGroupManager().unloadGroup(group);
+        return success;
+    }
+
+    @Override
+    public boolean saveUUIDData(String username, UUID uuid) {
+        boolean success = runQuery(connection -> {
+            PreparedStatement preparedStatement = connection.prepareStatement(UUIDCACHE_INSERT);
+            preparedStatement.setString(1, username);
+            preparedStatement.setString(2, uuid.toString());
+            preparedStatement.setString(3, uuid.toString());
+            preparedStatement.execute();
+            preparedStatement.close();
+            return true;
+        });
+        return success;
+    }
+
+    @Override
+    public UUID getUUID(String username) {
+        final UUID[] uuid = {null};
+        boolean success = runQuery(connection -> {
+            PreparedStatement preparedStatement = connection.prepareStatement(UUIDCACHE_SELECT);
+            preparedStatement.setString(1, username);
+            ResultSet resultSet = preparedStatement.executeQuery();
+
+            if (resultSet.next()) {
+                uuid[0] = UUID.fromString(resultSet.getString("uuid"));
+                preparedStatement.close();
+                resultSet.close();
+                return true;
+            }
+
+            preparedStatement.close();
+            resultSet.close();
+            return false;
+        });
+
+        return success ? uuid[0] : null;
+    }
+
+    private interface Query {
+        boolean onRun(Connection connection) throws SQLException;
+    }
+}

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

@@ -0,0 +1,4 @@
+package me.lucko.luckperms.exceptions;
+
+public class ObjectAlreadyHasException extends Exception {
+}

common/src/main/java/me/lucko/luckperms/exceptions/ObjectLacksPermissionException.java

@@ -0,0 +1,4 @@
+package me.lucko.luckperms.exceptions;
+
+public class ObjectLacksPermissionException extends Exception {
+}

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

@@ -0,0 +1,31 @@
+package me.lucko.luckperms.groups;
+
+import lombok.Getter;
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.utils.PermissionObject;
+
+public class Group extends PermissionObject {
+
+    /**
+     * The name of the group
+     */
+    @Getter
+    private final String name;
+
+    public Group(String name, LuckPermsPlugin plugin) {
+        super(plugin, name);
+        this.name = name;
+    }
+
+    /**
+     * Clear all of the groups permission nodes
+     */
+    public void clearNodes() {
+        getNodes().clear();
+    }
+
+    @Override
+    public String toString() {
+        return getName();
+    }
+}

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

@@ -0,0 +1,93 @@
+package me.lucko.luckperms.groups;
+
+import lombok.Getter;
+import me.lucko.luckperms.LuckPermsPlugin;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class GroupManager {
+    private final LuckPermsPlugin plugin;
+
+    /**
+     * A {@link Map} containing all loaded groups
+     */
+    @Getter
+    private final Map<String, Group> groups = new ConcurrentHashMap<>();
+
+    public GroupManager(LuckPermsPlugin plugin) {
+        this.plugin = plugin;
+        loadAllGroups();
+    }
+
+    /**
+     * 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 (!groups.containsKey(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());
+        }
+    }
+
+    /**
+     * Load all groups from the datastore
+     */
+    public void loadAllGroups() {
+        plugin.getDatastore().loadAllGroups(success -> {
+            String defaultGroup = plugin.getConfiguration().getDefaultGroupName();
+
+            if (!groups.keySet().contains(defaultGroup)) {
+                plugin.getDatastore().createAndLoadGroup(defaultGroup, success1 -> {});
+            }
+        });
+    }
+
+    /**
+     * Makes a new group object
+     * @param name The name of the group
+     * @return a new {@link Group} object
+     */
+    public Group makeGroup(String name) {
+        return new Group(name, plugin);
+    }
+}

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

@@ -0,0 +1,197 @@
+package me.lucko.luckperms.users;
+
+import lombok.Getter;
+import lombok.Setter;
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.exceptions.ObjectLacksPermissionException;
+import me.lucko.luckperms.groups.Group;
+import me.lucko.luckperms.utils.PermissionObject;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+
+public abstract class User extends PermissionObject {
+
+    /**
+     * The users Mojang UUID
+     */
+    @Getter
+    private final UUID uuid;
+
+    /**
+     * The last known username of a player
+     */
+    @Getter
+    @Setter
+    private String name;
+
+    public User(UUID uuid, LuckPermsPlugin plugin) {
+        super(plugin, uuid.toString());
+        this.uuid = uuid;
+        this.name = null;
+    }
+
+    public User(UUID uuid, String name, LuckPermsPlugin plugin) {
+        super(plugin, uuid.toString());
+        this.uuid = uuid;
+        this.name = name;
+    }
+
+    /**
+     * Refresh and re-assign the users permissions
+     */
+    public abstract void refreshPermissions();
+
+    /**
+     * Check to see if the user is a member of a group
+     * @param group The group to check membership of
+     * @return true if the user is a member of the group
+     */
+    public boolean isInGroup(Group group) {
+        return isInGroup(group, "global");
+    }
+
+    /**
+     * Check to see if a user is a member of a group on a specific server
+     * @param group The group to check membership of
+     * @param server The server to check on
+     * @return true if the user is a member of the group
+     */
+    public boolean isInGroup(Group group, String server) {
+        return getLocalGroups(server).contains(group.getName());
+    }
+
+    /**
+     * Add a user to a group
+     * @param group The group to add the user to
+     * @throws ObjectAlreadyHasException if the user is already a member of the group
+     */
+    public void addGroup(Group group) throws ObjectAlreadyHasException {
+        addGroup(group, "global");
+    }
+
+    /**
+     * Add a user to a group on a specific server
+     * @param group The group to add the user to
+     * @param server The server to add the group on
+     * @throws ObjectAlreadyHasException if the user is already a member of the group on that server
+     */
+    public void addGroup(Group group, String server) throws ObjectAlreadyHasException {
+        if (server == null) {
+            server = "global";
+        }
+
+        if (isInGroup(group, server)) {
+            throw new ObjectAlreadyHasException();
+        }
+
+        if (server.equalsIgnoreCase("global")) {
+            getNodes().put("luckperms.group." + group.getName(), true);
+        } else {
+            getNodes().put(server + "/luckperms.group." + group.getName(), true);
+        }
+    }
+
+    /**
+     * Remove the user from a group
+     * @param group the group to remove the user from
+     * @throws ObjectLacksPermissionException
+     */
+    public void removeGroup(Group group) throws ObjectLacksPermissionException {
+        removeGroup(group, "global");
+    }
+
+    /**
+     * Remove the user from a group
+     * @param group The group to remove the user from
+     * @param server The server to remove the group on
+     * @throws ObjectLacksPermissionException if the user isn't a member of the group
+     */
+    public void removeGroup(Group group, String server) throws ObjectLacksPermissionException {
+        if (server == null) {
+            server = "global";
+        }
+
+        if (!getLocalGroups(server).contains(group.getName())) {
+            throw new ObjectLacksPermissionException();
+        }
+
+        if (server.equalsIgnoreCase("global")) {
+            getNodes().remove("luckperms.group." + group.getName());
+        } else {
+            getNodes().remove(server + "/luckperms.group." + group.getName());
+        }
+    }
+
+    /**
+     * Clear all of the users permission nodes
+     */
+    public void clearNodes() {
+        String defaultGroupNode = getPlugin().getConfiguration().getDefaultGroupNode();
+        getNodes().clear();
+        getNodes().put(defaultGroupNode, true);
+    }
+
+    /**
+     * Get a {@link List} of all of the groups the user is a member of, on all servers
+     * @return a {@link List} of group names
+     */
+    public List<String> getGroupNames() {
+        return getGroups(null, true, true);
+    }
+
+    /**
+     * Get a {@link List} of the groups the user is a member of on a specific server
+     * @param server the server to check
+     * @return a {@link List} of group names
+     */
+    public List<String> getLocalGroups(String server) {
+        return getGroups(server, false, false);
+    }
+
+    /**
+     * Get a {@link List} of the groups the user is a member of on a specific server with the option to include global groups or all groups
+     * @param server Which server to check on
+     * @param includeGlobal Whether to include global groups
+     * @param includeAll Whether to get all groups
+     * @return a {@link List} of group names
+     */
+    public List<String> getGroups(String server, boolean includeGlobal, boolean includeAll) {
+        List<String> groups = new ArrayList<>();
+
+        if (server == null || server.equals("")) {
+            server = "global";
+        }
+
+        for (String node : getNodes().keySet()) {
+            String originalNode = node;
+            // Has a defined server
+            if (node.contains("/")) {
+                String[] parts = node.split("\\/", 2);
+                if (!parts[0].equalsIgnoreCase(server) && !includeAll) {
+                    continue;
+                }
+                node = parts[1];
+            } else {
+                if (!includeGlobal) {
+                    continue;
+                }
+            }
+
+            if (node.matches("luckperms\\.group\\..*")) {
+                if (getNodes().get(originalNode)) {
+                    String groupName = node.split("\\.", 3)[2];
+                    groups.add(groupName);
+                }
+            }
+        }
+        return groups;
+    }
+
+    @Override
+    public String toString() {
+        return getUuid().toString();
+    }
+}

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

@@ -0,0 +1,120 @@
+package me.lucko.luckperms.users;
+
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.commands.Sender;
+import me.lucko.luckperms.commands.Util;
+import me.lucko.luckperms.data.Datastore;
+
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+
+@NoArgsConstructor
+public abstract class UserManager {
+
+    /**
+     * A {@link Map} containing all online/loaded users
+     */
+    @Getter
+    private final Map<UUID, User> users = new ConcurrentHashMap<>();
+
+    /**
+     * Get a user object by UUID
+     * @param uuid The uuid to search by
+     * @return a {@link User} object if the user is loaded, returns null if the user is not loaded
+     */
+    public User getUser(UUID uuid) {
+        return users.get(uuid);
+    }
+
+    /**
+     * Get a user object by name
+     * @param name The name to search by
+     * @return a {@link User} object if the user is loaded, returns null if the user is not loaded
+     */
+    public User getUser(String name) {
+        User user = null;
+
+        for (User u : users.values()) {
+            if (u.getName().equalsIgnoreCase(name)) {
+                user = u;
+                break;
+            }
+        }
+
+        return user;
+    }
+
+    /**
+     * Add a user to the {@link #getUsers()} map
+     * @param user the user to add
+     */
+    public void setUser(User user) {
+        users.put(user.getUuid(), user);
+    }
+
+    /**
+     * Updates (or sets if the user wasn't already loaded) a user in the {@link #getUsers()} map
+     * @param user The user to update or set
+     */
+    public void updateOrSetUser(User user) {
+        if (!users.containsKey(user.getUuid())) {
+            // The user isn't already loaded, so we can just add
+            users.put(user.getUuid(), user);
+            // They're probably not online, but in case they are...
+            user.refreshPermissions();
+        } else {
+            // Override the user's current loaded nodes, and force a refresh
+            users.get(user.getUuid()).setNodes(user.getNodes());
+            users.get(user.getUuid()).refreshPermissions();
+        }
+    }
+
+    /**
+     * Saves a user object in the datastore
+     * @param user the user to save
+     * @param datastore the datastore
+     */
+    public void saveUser(User user, Datastore datastore) {
+        user.refreshPermissions();
+        datastore.saveUser(user, success -> {});
+    }
+
+    /**
+     * Check to see if a user is loaded or not
+     * @param uuid the UUID of the user
+     * @return true if the user is loaded
+     */
+    public boolean isLoaded(UUID uuid) {
+        return users.containsKey(uuid);
+    }
+
+    /**
+     * Removes and unloads any permission links of the user from the internal storage
+     * @param user The user to unload
+     */
+    public abstract void unloadUser(User user);
+
+    /**
+     * Checks to see if the user is online, and if they are not, runs {@link #unloadUser(User)}
+     * @param user The user to be cleaned up
+     */
+    public abstract void cleanupUser(User user);
+
+    /**
+     * Makes a new {@link User} object
+     * @param uuid The UUID of the user
+     * @return a new {@link User} object
+     */
+    public abstract User makeUser(UUID uuid);
+
+    /**
+     * Makes a new {@link User} object
+     * @param uuid The UUID of the user
+     * @param username The username of the user
+     * @return a new {@link User} object
+     */
+    public abstract User makeUser(UUID uuid, String username);
+}

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

@@ -0,0 +1,13 @@
+package me.lucko.luckperms.utils;
+
+public interface LPConfiguration {
+
+    String getServer();
+    String getPrefix();
+    int getSyncTime();
+    String getDefaultGroupNode();
+    String getDefaultGroupName();
+    boolean getIncludeGlobalPerms();
+    String getDatabaseValue(String value);
+
+}

common/src/main/java/me/lucko/luckperms/utils/PermissionObject.java

@@ -0,0 +1,234 @@
+package me.lucko.luckperms.utils;
+
+import lombok.Getter;
+import lombok.Setter;
+import lombok.NonNull;
+import me.lucko.luckperms.LuckPermsPlugin;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.exceptions.ObjectLacksPermissionException;
+import me.lucko.luckperms.groups.Group;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+/**
+ * Represents an object that can hold permissions
+ * For example a User or a Group
+ */
+@Getter
+public abstract class PermissionObject {
+
+    /**
+     * The UUID of the user / name of the group.
+     * Used to prevent circular inheritance issues
+     */
+    private final String objectName;
+
+    /**
+     * Reference to the main plugin instance
+     */
+    private final LuckPermsPlugin plugin;
+
+    /**
+     * If false, only permissions specific to the server are applied
+     */
+    @Setter
+
+    private boolean includeGlobalPermissions;
+
+    /**
+     * The user/group's permissions
+     */
+    @Setter
+    private Map<String, Boolean> nodes = new HashMap<>();
+
+    public PermissionObject(LuckPermsPlugin plugin, String objectName) {
+        this.objectName = objectName;
+        this.plugin = plugin;
+        this.includeGlobalPermissions = plugin.getConfiguration().getIncludeGlobalPerms();
+    }
+
+    /**
+     * Checks to see if the object has a certain permission
+     * @param node The permission node
+     * @param b If the node is true/false(negated)
+     * @return true if the user has the permission
+     */
+    public boolean hasPermission(String node, Boolean b) {
+        if (node.startsWith("global/")) node = node.replace("global/", "");
+        if (b) {
+            return getNodes().containsKey(node) && getNodes().get(node);
+        }
+        return getNodes().containsKey(node) && !getNodes().get(node);
+    }
+
+    /**
+     * Checks to see the the object has a permission on a certain server
+     * @param node The permission node
+     * @param b If the node is true/false(negated)
+     * @param server The server
+     * @return true if the user has the permission
+     */
+    public boolean hasPermission(String node, Boolean b, String server) {
+        return hasPermission(server + "/" + node, b);
+    }
+
+    /**
+     * Sets a permission for the object
+     * @param node The node to be set
+     * @param value What to set the node to - true/false(negated)
+     * @throws ObjectAlreadyHasException if the object already has the permission
+     */
+    public void setPermission(String node, Boolean value) throws ObjectAlreadyHasException {
+        if (node.startsWith("global/")) node = node.replace("global/", "");
+        if (hasPermission(node, value)) {
+            throw new ObjectAlreadyHasException();
+        }
+        getNodes().put(node, value);
+    }
+
+    /**
+     * Sets a permission for the object
+     * @param node The node to set
+     * @param value What to set the node to - true/false(negated)
+     * @param server The server to set the permission on
+     * @throws ObjectAlreadyHasException if the object already has the permission
+     */
+    public void setPermission(String node, Boolean value, String server) throws ObjectAlreadyHasException {
+        setPermission(server + "/" + node, value);
+    }
+
+    /**
+     * Unsets a permission for the object
+     * @param node The node to be unset
+     * @throws ObjectLacksPermissionException if the node wasn't already set
+     */
+    public void unsetPermission(String node) throws ObjectLacksPermissionException {
+        if (node.startsWith("global/")) node = node.replace("global/", "");
+        if (!getNodes().containsKey(node)) {
+            throw new ObjectLacksPermissionException();
+        }
+
+        getNodes().remove(node);
+    }
+
+    /**
+     * Unsets a permission for the object
+     * @param node The node to be unset
+     * @param server The server to unset the node on
+     * @throws ObjectLacksPermissionException if the node wasn't already set
+     */
+    public void unsetPermission(String node, String server) throws ObjectLacksPermissionException {
+        unsetPermission(server + "/" + node);
+    }
+
+    /**
+     * Gets the permissions and inherited permissions that apply to a specific server
+     * @param server The server to get nodes for
+     * @param excludedGroups Groups that shouldn't be inherited (to prevent circular inheritance issues)
+     * @return a {@link Map} of the permissions
+     */
+    public Map<String, Boolean> getLocalPermissions(String server, List<String> excludedGroups) {
+        return getPermissions(server, excludedGroups, includeGlobalPermissions);
+
+    }
+
+    private Map<String, Boolean> getPermissions(String server, List<String> excludedGroups, boolean includeGlobal) {
+        if (excludedGroups == null) {
+            excludedGroups = new ArrayList<>();
+        }
+
+        excludedGroups.add(getObjectName());
+        Map<String, Boolean> perms = new HashMap<>();
+
+        if (server == null || server.equals("")) {
+            server = "global";
+        }
+
+        for (String node : getNodes().keySet()) {
+            String originalNode = node;
+            // Has a defined server
+            if (node.contains("/")) {
+                String[] parts = node.split("\\/", 2);
+                if (!parts[0].equalsIgnoreCase(server)) {
+                    continue;
+                }
+                node = parts[1];
+
+                perms.put(node, getNodes().get(originalNode));
+                continue;
+            }
+
+            if (node.matches("luckperms\\.group\\..*")) {
+                if (getNodes().get(originalNode)) {
+                    String groupName = node.split("\\.", 3)[2];
+                    Group group = plugin.getGroupManager().getGroup(groupName);
+
+                    if (!excludedGroups.contains(groupName)) {
+                        if (group != null) {
+                            perms.putAll(group.getLocalPermissions(server, excludedGroups));
+                        } else {
+                            plugin.getLogger().warning("Error whilst refreshing the permissions of '" + objectName + "'." +
+                            "\n The group '" + groupName + "' is not loaded.");
+                        }
+                    }
+                }
+
+                perms.put(node, getNodes().get(originalNode));
+                continue;
+            }
+
+            if (includeGlobal) perms.put(node, getNodes().get(originalNode));
+        }
+        return perms;
+    }
+
+    /**
+     * Loads a list of semi-serialised nodes into the object
+     * @param data The data to be loaded
+     */
+    public void loadNodes(List<String> data) {
+        // String is the node in format "server/plugin.command-false" or "plugin.command-false" or "server/plugin.command"
+        // or just "plugin.command"
+
+        for (String s : data) {
+            String[] parts = s.split("-", 2);
+
+            if (parts.length == 2) {
+                nodes.put(parts[0], Boolean.valueOf(parts[1]));
+            } else {
+                nodes.put(parts[0], true);
+            }
+        }
+    }
+
+    /**
+     * Convert the permission nodes map to a list of strings
+     * @return a {@link List} of nodes
+     */
+    public List<String> getNodesAsString() {
+        List<String> data = new ArrayList<>();
+
+        for (String node : nodes.keySet()) {
+            if (nodes.get(node)) {
+                data.add(node);
+            } else {
+                data.add(node + "-false");
+            }
+        }
+
+        return data;
+    }
+
+    /**
+     * Serialize the nodes in the object to be saved in the datastore
+     * @return A serialized string
+     */
+    public String serializeNodes() {
+        if (nodes.isEmpty()) return "#";
+        return getNodesAsString().stream().collect(Collectors.joining(":"));
+    }
+}