Add API methods to load users/groups/tracks and return a future encapsulating the resultant object instead of a success flag

2018-01-30 15:55:36 +00:00
parent 7f7116e1c7
commit fe200ca1ec
19 changed files with 837 additions and 297 deletions
@@ -32,6 +32,10 @@ import me.lucko.luckperms.common.storage.DataConstraints;
 public final class ApiUtils {

    public static String checkUsername(String s) {
+        if (s == null) {
+            return null;
+        }
+
        Preconditions.checkArgument(
                DataConstraints.PLAYER_USERNAME_TEST.test(s),
                "Invalid username entry '" + s + "'. Usernames must be less than 16 chars and only contain 'a-z A-Z 1-9 _'."
@@ -40,6 +44,10 @@ public final class ApiUtils {
    }

    public static String checkName(String s) {
+        if (s == null) {
+            return null;
+        }
+
        Preconditions.checkArgument(
                DataConstraints.GROUP_NAME_TEST.test(s),
                "Invalid name entry '" + s + "'. Names must be less than 37 chars and only contain 'a-z A-Z 1-9'."
@@ -78,9 +78,9 @@ public class LuckPermsApiProvider implements LuckPermsApi {
        this.plugin = plugin;

        this.platformInfo = new ApiPlatformInfo(plugin);
-        this.userManager = new ApiUserManager(plugin.getUserManager());
-        this.groupManager = new ApiGroupManager(plugin.getGroupManager());
-        this.trackManager = new ApiTrackManager(plugin.getTrackManager());
+        this.userManager = new ApiUserManager(plugin, plugin.getUserManager());
+        this.groupManager = new ApiGroupManager(plugin, plugin.getGroupManager());
+        this.trackManager = new ApiTrackManager(plugin, plugin.getTrackManager());
        this.actionLogger = new ApiActionLogger(plugin);
        this.contextManager = new ApiContextManager(plugin, plugin.getContextManager());
        this.metaStackFactory = new ApiMetaStackFactory(plugin);
@@ -0,0 +1,41 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.common.api.delegates.manager;
+
+import me.lucko.luckperms.common.plugin.LuckPermsPlugin;
+
+public abstract class ApiAbstractManager<I, E, H> {
+    protected final LuckPermsPlugin plugin;
+    protected final H handle;
+
+    protected ApiAbstractManager(LuckPermsPlugin plugin, H handle) {
+        this.plugin = plugin;
+        this.handle = handle;
+    }
+
+    protected abstract E getDelegateFor(I internal);
+
+}
@@ -28,10 +28,10 @@ package me.lucko.luckperms.common.api.delegates.manager;
 import me.lucko.luckperms.api.Contexts;
 import me.lucko.luckperms.api.User;
 import me.lucko.luckperms.api.context.ContextCalculator;
-import me.lucko.luckperms.api.context.ContextManager;
 import me.lucko.luckperms.api.context.ImmutableContextSet;
 import me.lucko.luckperms.api.context.StaticContextCalculator;
 import me.lucko.luckperms.common.api.delegates.model.ApiUser;
+import me.lucko.luckperms.common.contexts.ContextManager;
 import me.lucko.luckperms.common.plugin.LuckPermsPlugin;

 import java.util.Objects;
@@ -40,11 +40,11 @@ import java.util.Optional;
 import javax.annotation.Nonnull;

@SuppressWarnings("unchecked")
-public class ApiContextManager implements ContextManager {
+public class ApiContextManager implements me.lucko.luckperms.api.context.ContextManager {
    private final LuckPermsPlugin plugin;
-    private final me.lucko.luckperms.common.contexts.ContextManager handle;
+    private final ContextManager handle;

-    public ApiContextManager(LuckPermsPlugin plugin, me.lucko.luckperms.common.contexts.ContextManager handle) {
+    public ApiContextManager(LuckPermsPlugin plugin, ContextManager handle) {
        this.plugin = plugin;
        this.handle = handle;
    }
@@ -25,33 +25,87 @@

 package me.lucko.luckperms.common.api.delegates.manager;

-import me.lucko.luckperms.api.Group;
-import me.lucko.luckperms.api.manager.GroupManager;
+import me.lucko.luckperms.api.event.cause.CreationCause;
+import me.lucko.luckperms.api.event.cause.DeletionCause;
+import me.lucko.luckperms.common.api.ApiUtils;
+import me.lucko.luckperms.common.api.delegates.model.ApiGroup;
+import me.lucko.luckperms.common.managers.group.GroupManager;
+import me.lucko.luckperms.common.model.Group;
+import me.lucko.luckperms.common.node.NodeFactory;
+import me.lucko.luckperms.common.plugin.LuckPermsPlugin;
+import me.lucko.luckperms.common.utils.ImmutableCollectors;

 import java.util.Objects;
+import java.util.Optional;
 import java.util.Set;
-import java.util.stream.Collectors;
+import java.util.concurrent.CompletableFuture;

 import javax.annotation.Nonnull;

-public class ApiGroupManager implements GroupManager {
-    private final me.lucko.luckperms.common.managers.group.GroupManager<?> handle;
-
-    public ApiGroupManager(me.lucko.luckperms.common.managers.group.GroupManager<?> handle) {
-        this.handle = handle;
+public class ApiGroupManager extends ApiAbstractManager<Group, me.lucko.luckperms.api.Group, GroupManager<?>> implements me.lucko.luckperms.api.manager.GroupManager {
+    public ApiGroupManager(LuckPermsPlugin plugin, GroupManager<?> handle) {
+        super(plugin, handle);
    }

    @Override
-    public Group getGroup(@Nonnull String name) {
-        Objects.requireNonNull(name, "name");
-        me.lucko.luckperms.common.model.Group group = this.handle.getIfLoaded(name);
-        return group == null ? null : group.getApiDelegate();
+    protected me.lucko.luckperms.api.Group getDelegateFor(me.lucko.luckperms.common.model.Group internal) {
+        if (internal == null) {
+            return null;
+        }
+
+        return internal.getApiDelegate();
    }

    @Nonnull
    @Override
-    public Set<Group> getLoadedGroups() {
-        return this.handle.getAll().values().stream().map(me.lucko.luckperms.common.model.Group::getApiDelegate).collect(Collectors.toSet());
+    public CompletableFuture<me.lucko.luckperms.api.Group> createAndLoadGroup(@Nonnull String name) {
+        name = ApiUtils.checkName(Objects.requireNonNull(name, "name"));
+        return this.plugin.getStorage().noBuffer().createAndLoadGroup(name, CreationCause.API)
+                .thenApply(this::getDelegateFor);
+    }
+
+    @Nonnull
+    @Override
+    public CompletableFuture<Optional<me.lucko.luckperms.api.Group>> loadGroup(@Nonnull String name) {
+        name = ApiUtils.checkName(Objects.requireNonNull(name, "name"));
+        return this.plugin.getStorage().noBuffer().loadGroup(name).thenApply(opt -> opt.map(this::getDelegateFor));
+    }
+
+    @Nonnull
+    @Override
+    public CompletableFuture<Void> saveGroup(@Nonnull me.lucko.luckperms.api.Group group) {
+        Objects.requireNonNull(group, "group");
+        return this.plugin.getStorage().noBuffer().saveGroup(ApiGroup.cast(group));
+    }
+
+    @Nonnull
+    @Override
+    public CompletableFuture<Void> deleteGroup(@Nonnull me.lucko.luckperms.api.Group group) {
+        Objects.requireNonNull(group, "group");
+        if (group.getName().equalsIgnoreCase(NodeFactory.DEFAULT_GROUP_NAME)) {
+            throw new IllegalArgumentException("Cannot delete the default group.");
+        }
+        return this.plugin.getStorage().noBuffer().deleteGroup(ApiGroup.cast(group), DeletionCause.API);
+    }
+
+    @Nonnull
+    @Override
+    public CompletableFuture<Void> loadAllGroups() {
+        return this.plugin.getStorage().noBuffer().loadAllGroups();
+    }
+
+    @Override
+    public me.lucko.luckperms.api.Group getGroup(@Nonnull String name) {
+        Objects.requireNonNull(name, "name");
+        return getDelegateFor(this.handle.getIfLoaded(name));
+    }
+
+    @Nonnull
+    @Override
+    public Set<me.lucko.luckperms.api.Group> getLoadedGroups() {
+        return this.handle.getAll().values().stream()
+                .map(this::getDelegateFor)
+                .collect(ImmutableCollectors.toSet());
    }

    @Override
@@ -25,33 +25,83 @@

 package me.lucko.luckperms.common.api.delegates.manager;

-import me.lucko.luckperms.api.Track;
-import me.lucko.luckperms.api.manager.TrackManager;
+import me.lucko.luckperms.api.event.cause.CreationCause;
+import me.lucko.luckperms.api.event.cause.DeletionCause;
+import me.lucko.luckperms.common.api.ApiUtils;
+import me.lucko.luckperms.common.api.delegates.model.ApiTrack;
+import me.lucko.luckperms.common.managers.track.TrackManager;
+import me.lucko.luckperms.common.model.Track;
+import me.lucko.luckperms.common.plugin.LuckPermsPlugin;
+import me.lucko.luckperms.common.utils.ImmutableCollectors;

 import java.util.Objects;
+import java.util.Optional;
 import java.util.Set;
-import java.util.stream.Collectors;
+import java.util.concurrent.CompletableFuture;

 import javax.annotation.Nonnull;

-public class ApiTrackManager implements TrackManager {
-    private final me.lucko.luckperms.common.managers.track.TrackManager<?> handle;
-
-    public ApiTrackManager(me.lucko.luckperms.common.managers.track.TrackManager<?> handle) {
-        this.handle = handle;
+public class ApiTrackManager extends ApiAbstractManager<Track, me.lucko.luckperms.api.Track, TrackManager<?>> implements me.lucko.luckperms.api.manager.TrackManager {
+    public ApiTrackManager(LuckPermsPlugin plugin, TrackManager<?> handle) {
+        super(plugin, handle);
    }

    @Override
-    public Track getTrack(@Nonnull String name) {
-        Objects.requireNonNull(name, "name");
-        me.lucko.luckperms.common.model.Track track = this.handle.getIfLoaded(name);
-        return track == null ? null : track.getApiDelegate();
+    protected me.lucko.luckperms.api.Track getDelegateFor(Track internal) {
+        if (internal == null) {
+            return null;
+        }
+
+        return internal.getApiDelegate();
    }

    @Nonnull
    @Override
-    public Set<Track> getLoadedTracks() {
-        return this.handle.getAll().values().stream().map(me.lucko.luckperms.common.model.Track::getApiDelegate).collect(Collectors.toSet());
+    public CompletableFuture<me.lucko.luckperms.api.Track> createAndLoadTrack(@Nonnull String name) {
+        name = ApiUtils.checkName(Objects.requireNonNull(name, "name"));
+        return this.plugin.getStorage().noBuffer().createAndLoadTrack(name, CreationCause.API)
+                .thenApply(this::getDelegateFor);
+    }
+
+    @Nonnull
+    @Override
+    public CompletableFuture<Optional<me.lucko.luckperms.api.Track>> loadTrack(@Nonnull String name) {
+        name = ApiUtils.checkName(Objects.requireNonNull(name, "name"));
+        return this.plugin.getStorage().noBuffer().loadTrack(name).thenApply(opt -> opt.map(this::getDelegateFor));
+    }
+
+    @Nonnull
+    @Override
+    public CompletableFuture<Void> saveTrack(@Nonnull me.lucko.luckperms.api.Track track) {
+        Objects.requireNonNull(track, "track");
+        return this.plugin.getStorage().noBuffer().saveTrack(ApiTrack.cast(track));
+    }
+
+    @Nonnull
+    @Override
+    public CompletableFuture<Void> deleteTrack(@Nonnull me.lucko.luckperms.api.Track track) {
+        Objects.requireNonNull(track, "track");
+        return this.plugin.getStorage().noBuffer().deleteTrack(ApiTrack.cast(track), DeletionCause.API);
+    }
+
+    @Nonnull
+    @Override
+    public CompletableFuture<Void> loadAllTracks() {
+        return this.plugin.getStorage().noBuffer().loadAllTracks();
+    }
+
+    @Override
+    public me.lucko.luckperms.api.Track getTrack(@Nonnull String name) {
+        Objects.requireNonNull(name, "name");
+        return getDelegateFor(this.handle.getIfLoaded(name));
+    }
+
+    @Nonnull
+    @Override
+    public Set<me.lucko.luckperms.api.Track> getLoadedTracks() {
+        return this.handle.getAll().values().stream()
+                .map(this::getDelegateFor)
+                .collect(ImmutableCollectors.toSet());
    }

    @Override
@@ -25,43 +25,74 @@

 package me.lucko.luckperms.common.api.delegates.manager;

-import me.lucko.luckperms.api.User;
-import me.lucko.luckperms.api.manager.UserManager;
+import me.lucko.luckperms.common.api.ApiUtils;
 import me.lucko.luckperms.common.api.delegates.model.ApiUser;
+import me.lucko.luckperms.common.managers.user.UserManager;
+import me.lucko.luckperms.common.model.User;
+import me.lucko.luckperms.common.plugin.LuckPermsPlugin;
 import me.lucko.luckperms.common.references.UserIdentifier;
+import me.lucko.luckperms.common.utils.ImmutableCollectors;

 import java.util.Objects;
 import java.util.Set;
 import java.util.UUID;
-import java.util.stream.Collectors;
+import java.util.concurrent.CompletableFuture;

 import javax.annotation.Nonnull;
+import javax.annotation.Nullable;

-public class ApiUserManager implements UserManager {
-    private final me.lucko.luckperms.common.managers.user.UserManager<?> handle;
-
-    public ApiUserManager(me.lucko.luckperms.common.managers.user.UserManager<?> handle) {
-        this.handle = handle;
+public class ApiUserManager extends ApiAbstractManager<User, me.lucko.luckperms.api.User, UserManager<?>> implements me.lucko.luckperms.api.manager.UserManager {
+    public ApiUserManager(LuckPermsPlugin plugin, UserManager<?> handle) {
+        super(plugin, handle);
    }

    @Override
-    public User getUser(@Nonnull UUID uuid) {
-        Objects.requireNonNull(uuid, "uuid");
-        me.lucko.luckperms.common.model.User user = this.handle.getIfLoaded(uuid);
-        return user == null ? null : new ApiUser(user);
-    }
-
-    @Override
-    public User getUser(@Nonnull String name) {
-        Objects.requireNonNull(name, "name");
-        me.lucko.luckperms.common.model.User user = this.handle.getByUsername(name);
-        return user == null ? null : new ApiUser(user);
+    protected me.lucko.luckperms.api.User getDelegateFor(User internal) {
+        if (internal == null) {
+            return null;
+        }
+        return new ApiUser(internal);
    }

    @Nonnull
    @Override
-    public Set<User> getLoadedUsers() {
-        return this.handle.getAll().values().stream().map(ApiUser::new).collect(Collectors.toSet());
+    public CompletableFuture<me.lucko.luckperms.api.User> loadUser(@Nonnull UUID uuid, @Nullable String username) {
+        Objects.requireNonNull(uuid, "uuid");
+        ApiUtils.checkUsername(username);
+
+        if (this.plugin.getUserManager().getIfLoaded(uuid) == null) {
+            this.plugin.getUserManager().getHouseKeeper().registerApiUsage(uuid);
+        }
+
+        return this.plugin.getStorage().noBuffer().loadUser(uuid, username)
+                .thenApply(this::getDelegateFor);
+    }
+
+    @Nonnull
+    @Override
+    public CompletableFuture<Void> saveUser(@Nonnull me.lucko.luckperms.api.User user) {
+        Objects.requireNonNull(user, "user");
+        return this.plugin.getStorage().noBuffer().saveUser(ApiUser.cast(user));
+    }
+
+    @Override
+    public me.lucko.luckperms.api.User getUser(@Nonnull UUID uuid) {
+        Objects.requireNonNull(uuid, "uuid");
+        return getDelegateFor(this.handle.getIfLoaded(uuid));
+    }
+
+    @Override
+    public me.lucko.luckperms.api.User getUser(@Nonnull String name) {
+        Objects.requireNonNull(name, "name");
+        return getDelegateFor(this.handle.getByUsername(name));
+    }
+
+    @Nonnull
+    @Override
+    public Set<me.lucko.luckperms.api.User> getLoadedUsers() {
+        return this.handle.getAll().values().stream()
+                .map(this::getDelegateFor)
+                .collect(ImmutableCollectors.toSet());
    }

    @Override
@@ -71,7 +102,7 @@ public class ApiUserManager implements UserManager {
    }

    @Override
-    public void cleanupUser(@Nonnull User user) {
+    public void cleanupUser(@Nonnull me.lucko.luckperms.api.User user) {
        Objects.requireNonNull(user, "user");
        this.handle.getHouseKeeper().clearApiUsage(ApiUser.cast(user).getUuid());
    }
@@ -52,7 +52,7 @@ public class ApiActionLogger implements ActionLogger {
    @Nonnull
    @Override
    public CompletableFuture<Log> getLog() {
-        return this.plugin.getStorage().noBuffer().getLog().thenApply(log -> log == null ? null : new ApiLog(log));
+        return this.plugin.getStorage().noBuffer().getLog().thenApply(ApiLog::new);
    }

    @Nonnull
@@ -27,30 +27,30 @@ package me.lucko.luckperms.common.api.delegates.model;

 import com.google.common.base.Preconditions;

-import me.lucko.luckperms.api.Group;
 import me.lucko.luckperms.api.caching.GroupData;
+import me.lucko.luckperms.common.model.Group;

 import java.util.Objects;
 import java.util.OptionalInt;

 import javax.annotation.Nonnull;

-public final class ApiGroup extends ApiPermissionHolder implements Group {
-    public static me.lucko.luckperms.common.model.Group cast(Group group) {
+public final class ApiGroup extends ApiPermissionHolder implements me.lucko.luckperms.api.Group {
+    public static Group cast(me.lucko.luckperms.api.Group group) {
        Objects.requireNonNull(group, "group");
        Preconditions.checkState(group instanceof ApiGroup, "Illegal instance " + group.getClass() + " cannot be handled by this implementation.");
        return ((ApiGroup) group).getHandle();
    }

-    private final me.lucko.luckperms.common.model.Group handle;
+    private final Group handle;

-    public ApiGroup(me.lucko.luckperms.common.model.Group handle) {
+    public ApiGroup(Group handle) {
        super(handle);
        this.handle = handle;
    }

    @Override
-    me.lucko.luckperms.common.model.Group getHandle() {
+    Group getHandle() {
        return this.handle;
    }

@@ -25,8 +25,9 @@

 package me.lucko.luckperms.common.api.delegates.model;

-import me.lucko.luckperms.api.Log;
+
 import me.lucko.luckperms.api.LogEntry;
+import me.lucko.luckperms.common.actionlog.Log;

 import java.util.Objects;
 import java.util.SortedMap;
@@ -38,11 +39,11 @@ import javax.annotation.Nonnull;
 import static me.lucko.luckperms.common.api.ApiUtils.checkName;

@SuppressWarnings("unchecked")
-public class ApiLog implements Log {
+public class ApiLog implements me.lucko.luckperms.api.Log {
    private static final int ENTRIES_PER_PAGE = 5;
-    private final me.lucko.luckperms.common.actionlog.Log handle;
+    private final Log handle;

-    public ApiLog(me.lucko.luckperms.common.actionlog.Log handle) {
+    public ApiLog(Log handle) {
        this.handle = handle;
    }

@@ -35,13 +35,13 @@ import me.lucko.luckperms.api.Contexts;
 import me.lucko.luckperms.api.DataMutateResult;
 import me.lucko.luckperms.api.LocalizedNode;
 import me.lucko.luckperms.api.Node;
-import me.lucko.luckperms.api.PermissionHolder;
 import me.lucko.luckperms.api.Tristate;
 import me.lucko.luckperms.api.caching.CachedData;
 import me.lucko.luckperms.api.context.ContextSet;
 import me.lucko.luckperms.api.context.ImmutableContextSet;
 import me.lucko.luckperms.common.model.Group;
 import me.lucko.luckperms.common.model.NodeMapType;
+import me.lucko.luckperms.common.model.PermissionHolder;
 import me.lucko.luckperms.common.model.User;
 import me.lucko.luckperms.common.node.MetaType;
 import me.lucko.luckperms.common.utils.ImmutableCollectors;
@@ -56,14 +56,14 @@ import java.util.function.Predicate;

 import javax.annotation.Nonnull;

-public class ApiPermissionHolder implements PermissionHolder {
-    private final me.lucko.luckperms.common.model.PermissionHolder handle;
+public class ApiPermissionHolder implements me.lucko.luckperms.api.PermissionHolder {
+    private final PermissionHolder handle;

-    ApiPermissionHolder(me.lucko.luckperms.common.model.PermissionHolder handle) {
+    ApiPermissionHolder(PermissionHolder handle) {
        this.handle = Objects.requireNonNull(handle, "handle");
    }

-    me.lucko.luckperms.common.model.PermissionHolder getHandle() {
+    PermissionHolder getHandle() {
        return this.handle;
    }

@@ -29,13 +29,13 @@ import me.lucko.luckperms.api.Group;
 import me.lucko.luckperms.api.HeldPermission;
 import me.lucko.luckperms.api.Log;
 import me.lucko.luckperms.api.LogEntry;
-import me.lucko.luckperms.api.Storage;
 import me.lucko.luckperms.api.Track;
 import me.lucko.luckperms.api.User;
 import me.lucko.luckperms.api.event.cause.CreationCause;
 import me.lucko.luckperms.api.event.cause.DeletionCause;
 import me.lucko.luckperms.common.node.NodeFactory;
 import me.lucko.luckperms.common.plugin.LuckPermsPlugin;
+import me.lucko.luckperms.common.storage.Storage;

 import java.util.List;
 import java.util.Objects;
@@ -44,17 +44,34 @@ import java.util.Set;
 import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.Executor;
+import java.util.function.Function;

 import javax.annotation.Nonnull;

 import static me.lucko.luckperms.common.api.ApiUtils.checkName;
 import static me.lucko.luckperms.common.api.ApiUtils.checkUsername;

-public class ApiStorage implements Storage {
-    private final LuckPermsPlugin plugin;
-    private final me.lucko.luckperms.common.storage.Storage handle;
+public class ApiStorage implements me.lucko.luckperms.api.Storage {
+    private static final Function<Throwable, Boolean> CONSUME_EXCEPTION = throwable -> {
+        throwable.printStackTrace();
+        return false;
+    };
+
+    private static Function<Throwable, Boolean> consumeExceptionToFalse() {
+        return CONSUME_EXCEPTION;
+    }
+
+    private static <T> Function<Throwable, T> consumeExceptionToNull() {
+        return throwable -> {
+            throwable.printStackTrace();
+            return null;
+        };
+    }
    
-    public ApiStorage(LuckPermsPlugin plugin, me.lucko.luckperms.common.storage.Storage handle) {
+    private final LuckPermsPlugin plugin;
+    private final Storage handle;
+    
+    public ApiStorage(LuckPermsPlugin plugin, Storage handle) {
        this.plugin = plugin;
        this.handle = handle;
    }
@@ -86,72 +103,87 @@ public class ApiStorage implements Storage {
    @Override
    public CompletableFuture<Boolean> logAction(@Nonnull LogEntry entry) {
        Objects.requireNonNull(entry, "entry");
-        return this.handle.noBuffer().logAction(entry).thenApply(x -> true);
+        return this.handle.noBuffer().logAction(entry)
+                .thenApply(r -> true)
+                .exceptionally(consumeExceptionToFalse());
    }

    @Nonnull
    @Override
    public CompletableFuture<Log> getLog() {
-        return this.handle.noBuffer().getLog().thenApply(log -> log == null ? null : new ApiLog(log));
+        return this.handle.noBuffer().getLog().<Log>thenApply(ApiLog::new).exceptionally(consumeExceptionToNull());
    }

    @Nonnull
    @Override
    public CompletableFuture<Boolean> loadUser(@Nonnull UUID uuid, String username) {
        Objects.requireNonNull(uuid, "uuid");
+        username = checkUsername(username);

        if (this.plugin.getUserManager().getIfLoaded(uuid) == null) {
            this.plugin.getUserManager().getHouseKeeper().registerApiUsage(uuid);
        }

-        return this.handle.noBuffer().loadUser(uuid, username == null ? null : checkUsername(username)).thenApply(Objects::nonNull);
+        return this.handle.noBuffer().loadUser(uuid, username)
+                .thenApply(r -> true)
+                .exceptionally(consumeExceptionToFalse());
    }

    @Nonnull
    @Override
    public CompletableFuture<Boolean> saveUser(@Nonnull User user) {
        Objects.requireNonNull(user, "user");
-        return this.handle.noBuffer().saveUser(ApiUser.cast(user)).thenApply(x -> true);
+        return this.handle.noBuffer().saveUser(ApiUser.cast(user))
+                .thenApply(r -> true)
+                .exceptionally(consumeExceptionToFalse());
    }

    @Nonnull
    @Override
    public CompletableFuture<Set<UUID>> getUniqueUsers() {
-        return this.handle.noBuffer().getUniqueUsers();
+        return this.handle.noBuffer().getUniqueUsers().exceptionally(consumeExceptionToNull());
    }

    @Nonnull
    @Override
    public CompletableFuture<List<HeldPermission<UUID>>> getUsersWithPermission(@Nonnull String permission) {
        Objects.requireNonNull(permission, "permission");
-        return this.handle.noBuffer().getUsersWithPermission(permission);
+        return this.handle.noBuffer().getUsersWithPermission(permission).exceptionally(consumeExceptionToNull());
    }

    @Nonnull
    @Override
    public CompletableFuture<Boolean> createAndLoadGroup(@Nonnull String name) {
        Objects.requireNonNull(name, "name");
-        return this.handle.noBuffer().createAndLoadGroup(checkName(name), CreationCause.API).thenApply(Objects::nonNull);
+        return this.handle.noBuffer().createAndLoadGroup(checkName(name), CreationCause.API)
+                .thenApply(r -> true)
+                .exceptionally(consumeExceptionToFalse());
    }

    @Nonnull
    @Override
    public CompletableFuture<Boolean> loadGroup(@Nonnull String name) {
        Objects.requireNonNull(name, "name");
-        return this.handle.noBuffer().loadGroup(checkName(name)).thenApply(Optional::isPresent);
+        return this.handle.noBuffer().loadGroup(checkName(name))
+                .thenApply(Optional::isPresent)
+                .exceptionally(consumeExceptionToFalse());
    }

    @Nonnull
    @Override
    public CompletableFuture<Boolean> loadAllGroups() {
-        return this.handle.noBuffer().loadAllGroups().thenApply(x -> true);
+        return this.handle.noBuffer().loadAllGroups()
+                .thenApply(r -> true)
+                .exceptionally(consumeExceptionToFalse());
    }

    @Nonnull
    @Override
    public CompletableFuture<Boolean> saveGroup(@Nonnull Group group) {
        Objects.requireNonNull(group, "group");
-        return this.handle.noBuffer().saveGroup(ApiGroup.cast(group)).thenApply(x -> true);
+        return this.handle.noBuffer().saveGroup(ApiGroup.cast(group))
+                .thenApply(r -> true)
+                .exceptionally(consumeExceptionToFalse());
    }

    @Nonnull
@@ -161,48 +193,60 @@ public class ApiStorage implements Storage {
        if (group.getName().equalsIgnoreCase(NodeFactory.DEFAULT_GROUP_NAME)) {
            throw new IllegalArgumentException("Cannot delete the default group.");
        }
-        return this.handle.noBuffer().deleteGroup(ApiGroup.cast(group), DeletionCause.API).thenApply(x -> true);
+        return this.handle.noBuffer().deleteGroup(ApiGroup.cast(group), DeletionCause.API)
+                .thenApply(r -> true)
+                .exceptionally(consumeExceptionToFalse());
    }

    @Nonnull
    @Override
    public CompletableFuture<List<HeldPermission<String>>> getGroupsWithPermission(@Nonnull String permission) {
        Objects.requireNonNull(permission, "permission");
-        return this.handle.noBuffer().getGroupsWithPermission(permission);
+        return this.handle.noBuffer().getGroupsWithPermission(permission).exceptionally(consumeExceptionToNull());
    }

    @Nonnull
    @Override
    public CompletableFuture<Boolean> createAndLoadTrack(@Nonnull String name) {
        Objects.requireNonNull(name, "name");
-        return this.handle.noBuffer().createAndLoadTrack(checkName(name), CreationCause.API).thenApply(Objects::nonNull);
+        return this.handle.noBuffer().createAndLoadTrack(checkName(name), CreationCause.API)
+                .thenApply(r -> true)
+                .exceptionally(consumeExceptionToFalse());
    }

    @Nonnull
    @Override
    public CompletableFuture<Boolean> loadTrack(@Nonnull String name) {
        Objects.requireNonNull(name, "name");
-        return this.handle.noBuffer().loadTrack(checkName(name)).thenApply(Optional::isPresent);
+        return this.handle.noBuffer().loadTrack(checkName(name))
+                .thenApply(Optional::isPresent)
+                .exceptionally(consumeExceptionToFalse());
    }

    @Nonnull
    @Override
    public CompletableFuture<Boolean> loadAllTracks() {
-        return this.handle.noBuffer().loadAllTracks().thenApply(x -> true);
+        return this.handle.noBuffer().loadAllTracks()
+                .thenApply(r -> true)
+                .exceptionally(consumeExceptionToFalse());
    }

    @Nonnull
    @Override
    public CompletableFuture<Boolean> saveTrack(@Nonnull Track track) {
        Objects.requireNonNull(track, "track");
-        return this.handle.noBuffer().saveTrack(ApiTrack.cast(track)).thenApply(x -> true);
+        return this.handle.noBuffer().saveTrack(ApiTrack.cast(track))
+                .thenApply(r -> true)
+                .exceptionally(consumeExceptionToFalse());
    }

    @Nonnull
    @Override
    public CompletableFuture<Boolean> deleteTrack(@Nonnull Track track) {
        Objects.requireNonNull(track, "track");
-        return this.handle.noBuffer().deleteTrack(ApiTrack.cast(track), DeletionCause.API).thenApply(x -> true);
+        return this.handle.noBuffer().deleteTrack(ApiTrack.cast(track), DeletionCause.API)
+                .thenApply(r -> true)
+                .exceptionally(consumeExceptionToFalse());
    }

    @Nonnull
@@ -210,7 +254,9 @@ public class ApiStorage implements Storage {
    public CompletableFuture<Boolean> saveUUIDData(@Nonnull String username, @Nonnull UUID uuid) {
        Objects.requireNonNull(username, "username");
        Objects.requireNonNull(uuid, "uuid");
-        return this.handle.noBuffer().saveUUIDData(uuid, checkUsername(username)).thenApply(x -> true);
+        return this.handle.noBuffer().saveUUIDData(uuid, checkUsername(username))
+                .thenApply(r -> true)
+                .exceptionally(consumeExceptionToFalse());
    }

    @Nonnull
@@ -29,27 +29,27 @@ import com.google.common.base.Preconditions;

 import me.lucko.luckperms.api.DataMutateResult;
 import me.lucko.luckperms.api.Group;
-import me.lucko.luckperms.api.Track;
+import me.lucko.luckperms.common.model.Track;

 import java.util.List;
 import java.util.Objects;

 import javax.annotation.Nonnull;

-public final class ApiTrack implements Track {
-    public static me.lucko.luckperms.common.model.Track cast(Track track) {
+public final class ApiTrack implements me.lucko.luckperms.api.Track {
+    public static Track cast(me.lucko.luckperms.api.Track track) {
        Objects.requireNonNull(track, "track");
        Preconditions.checkState(track instanceof ApiTrack, "Illegal instance " + track.getClass() + " cannot be handled by this implementation.");
        return ((ApiTrack) track).getHandle();
    }

-    private final me.lucko.luckperms.common.model.Track handle;
+    private final Track handle;
    
-    public ApiTrack(me.lucko.luckperms.common.model.Track handle) {
+    public ApiTrack(Track handle) {
        this.handle = handle;
    }

-    me.lucko.luckperms.common.model.Track getHandle() {
+    Track getHandle() {
        return this.handle;
    }

@@ -28,8 +28,8 @@ package me.lucko.luckperms.common.api.delegates.model;
 import com.google.common.base.Preconditions;

 import me.lucko.luckperms.api.DataMutateResult;
-import me.lucko.luckperms.api.User;
 import me.lucko.luckperms.api.caching.UserData;
+import me.lucko.luckperms.common.model.User;
 import me.lucko.luckperms.common.node.NodeFactory;

 import java.util.Objects;
@@ -37,21 +37,21 @@ import java.util.UUID;

 import javax.annotation.Nonnull;

-public final class ApiUser extends ApiPermissionHolder implements User {
-    public static me.lucko.luckperms.common.model.User cast(User u) {
+public final class ApiUser extends ApiPermissionHolder implements me.lucko.luckperms.api.User {
+    public static User cast(me.lucko.luckperms.api.User u) {
        Preconditions.checkState(u instanceof ApiUser, "Illegal instance " + u.getClass() + " cannot be handled by this implementation.");
        return ((ApiUser) u).getHandle();
    }

-    private final me.lucko.luckperms.common.model.User handle;
+    private final User handle;

-    public ApiUser(me.lucko.luckperms.common.model.User handle) {
+    public ApiUser(User handle) {
        super(handle);
        this.handle = handle;
    }

    @Override
-    me.lucko.luckperms.common.model.User getHandle() {
+    User getHandle() {
        return this.handle;
    }

@@ -77,8 +77,8 @@ public class LuckPermsEventBus implements EventBus {
    }

    @Nonnull
-    @SuppressWarnings("unchecked")
    @Override
+    @SuppressWarnings("unchecked")
    public <T extends LuckPermsEvent> Set<EventHandler<T>> getHandlers(@Nonnull Class<T> eventClass) {
        Set<LuckPermsEventHandler<?>> handlers = this.handlerMap.get(eventClass);
        if (handlers == null) {