Upstream/LuckPerms
1
0
Fork 0
mirror of https://github.com/LuckPerms/LuckPerms.git synced 2024-09-14 06:48:01 +02:00
Code Issues Projects Releases Wiki Activity

Return the loaded objects from storage methods as opposed to success flags

Browse Source
This commit is contained in:
Luck 2017-12-18 17:03:59 +00:00
parent 765f140121
commit a415a2705f
No known key found for this signature in database
GPG Key ID: EFA9B3EC5FD90F8B
36 changed files with 414 additions and 366 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
api/src/main/java/me/lucko/luckperms/api/ChatMetaType.java
View File

@ -44,17 +44,18 @@ public enum ChatMetaType {
*/ */
PREFIX { PREFIX {
@Override @Override
public boolean matches(Node node) { public boolean matches(@Nonnull Node node) {
return Preconditions.checkNotNull(node, "node").isPrefix(); return Preconditions.checkNotNull(node, "node").isPrefix();
} }
@Override @Override
public boolean shouldIgnore(Node node) { public boolean shouldIgnore(@Nonnull Node node) {
return !Preconditions.checkNotNull(node, "node").isPrefix(); return !Preconditions.checkNotNull(node, "node").isPrefix();
} }
@Nonnull
@Override @Override
public Map.Entry<Integer, String> getEntry(Node node) { public Map.Entry<Integer, String> getEntry(@Nonnull Node node) {
return Preconditions.checkNotNull(node, "node").getPrefix(); return Preconditions.checkNotNull(node, "node").getPrefix();
} }
}, },
@ -64,17 +65,18 @@ public enum ChatMetaType {
*/ */
SUFFIX { SUFFIX {
@Override @Override
public boolean matches(Node node) { public boolean matches(@Nonnull Node node) {
return Preconditions.checkNotNull(node, "node").isSuffix(); return Preconditions.checkNotNull(node, "node").isSuffix();
} }
@Override @Override
public boolean shouldIgnore(Node node) { public boolean shouldIgnore(@Nonnull Node node) {
return !Preconditions.checkNotNull(node, "node").isSuffix(); return !Preconditions.checkNotNull(node, "node").isSuffix();
} }
@Nonnull
@Override @Override
public Map.Entry<Integer, String> getEntry(Node node) { public Map.Entry<Integer, String> getEntry(@Nonnull Node node) {
return Preconditions.checkNotNull(node, "node").getSuffix(); return Preconditions.checkNotNull(node, "node").getSuffix();
} }
}; };

30
common/src/main/java/me/lucko/luckperms/common/api/delegates/model/ApiStorage.java
View File

@ -41,6 +41,8 @@ import me.lucko.luckperms.common.config.ConfigKeys;
import me.lucko.luckperms.common.plugin.LuckPermsPlugin; import me.lucko.luckperms.common.plugin.LuckPermsPlugin;
import java.util.List; import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.Set; import java.util.Set;
import java.util.UUID; import java.util.UUID;
import java.util.concurrent.CompletableFuture; import java.util.concurrent.CompletableFuture;
@ -76,7 +78,7 @@ public class ApiStorage implements Storage {
@Override @Override
public CompletableFuture<Boolean> logAction(@NonNull LogEntry entry) { public CompletableFuture<Boolean> logAction(@NonNull LogEntry entry) {
return handle.noBuffer().logAction(entry); return handle.noBuffer().logAction(entry).thenApply(x -> true);
} }
@Override @Override
@ -86,12 +88,12 @@ public class ApiStorage implements Storage {
@Override @Override
public CompletableFuture<Boolean> loadUser(@NonNull UUID uuid, String username) { public CompletableFuture<Boolean> loadUser(@NonNull UUID uuid, String username) {
return handle.noBuffer().loadUser(uuid, username == null ? null : checkUsername(username)); return handle.noBuffer().loadUser(uuid, username == null ? null : checkUsername(username)).thenApply(Objects::nonNull);
} }
@Override @Override
public CompletableFuture<Boolean> saveUser(@NonNull User user) { public CompletableFuture<Boolean> saveUser(@NonNull User user) {
return handle.noBuffer().saveUser(ApiUser.cast(user)); return handle.noBuffer().saveUser(ApiUser.cast(user)).thenApply(x -> true);
} }
@Override @Override
@ -106,22 +108,22 @@ public class ApiStorage implements Storage {
@Override @Override
public CompletableFuture<Boolean> createAndLoadGroup(@NonNull String name) { public CompletableFuture<Boolean> createAndLoadGroup(@NonNull String name) {
return handle.noBuffer().createAndLoadGroup(checkName(name), CreationCause.API); return handle.noBuffer().createAndLoadGroup(checkName(name), CreationCause.API).thenApply(Objects::nonNull);
} }
@Override @Override
public CompletableFuture<Boolean> loadGroup(@NonNull String name) { public CompletableFuture<Boolean> loadGroup(@NonNull String name) {
return handle.noBuffer().loadGroup(checkName(name)); return handle.noBuffer().loadGroup(checkName(name)).thenApply(Optional::isPresent);
} }
@Override @Override
public CompletableFuture<Boolean> loadAllGroups() { public CompletableFuture<Boolean> loadAllGroups() {
return handle.noBuffer().loadAllGroups(); return handle.noBuffer().loadAllGroups().thenApply(x -> true);
} }
@Override @Override
public CompletableFuture<Boolean> saveGroup(@NonNull Group group) { public CompletableFuture<Boolean> saveGroup(@NonNull Group group) {
return handle.noBuffer().saveGroup(ApiGroup.cast(group)); return handle.noBuffer().saveGroup(ApiGroup.cast(group)).thenApply(x -> true);
} }
@Override @Override
@ -129,7 +131,7 @@ public class ApiStorage implements Storage {
if (group.getName().equalsIgnoreCase(plugin.getConfiguration().get(ConfigKeys.DEFAULT_GROUP_NAME))) { if (group.getName().equalsIgnoreCase(plugin.getConfiguration().get(ConfigKeys.DEFAULT_GROUP_NAME))) {
throw new IllegalArgumentException("Cannot delete the default group."); throw new IllegalArgumentException("Cannot delete the default group.");
} }
return handle.noBuffer().deleteGroup(ApiGroup.cast(group), DeletionCause.API); return handle.noBuffer().deleteGroup(ApiGroup.cast(group), DeletionCause.API).thenApply(x -> true);
} }
@Override @Override
@ -139,32 +141,32 @@ public class ApiStorage implements Storage {
@Override @Override
public CompletableFuture<Boolean> createAndLoadTrack(@NonNull String name) { public CompletableFuture<Boolean> createAndLoadTrack(@NonNull String name) {
return handle.noBuffer().createAndLoadTrack(checkName(name), CreationCause.API); return handle.noBuffer().createAndLoadTrack(checkName(name), CreationCause.API).thenApply(Objects::nonNull);
} }
@Override @Override
public CompletableFuture<Boolean> loadTrack(@NonNull String name) { public CompletableFuture<Boolean> loadTrack(@NonNull String name) {
return handle.noBuffer().loadTrack(checkName(name)); return handle.noBuffer().loadTrack(checkName(name)).thenApply(Optional::isPresent);
} }
@Override @Override
public CompletableFuture<Boolean> loadAllTracks() { public CompletableFuture<Boolean> loadAllTracks() {
return handle.noBuffer().loadAllTracks(); return handle.noBuffer().loadAllTracks().thenApply(x -> true);
} }
@Override @Override
public CompletableFuture<Boolean> saveTrack(@NonNull Track track) { public CompletableFuture<Boolean> saveTrack(@NonNull Track track) {
return handle.noBuffer().saveTrack(ApiTrack.cast(track)); return handle.noBuffer().saveTrack(ApiTrack.cast(track)).thenApply(x -> true);
} }
@Override @Override
public CompletableFuture<Boolean> deleteTrack(@NonNull Track track) { public CompletableFuture<Boolean> deleteTrack(@NonNull Track track) {
return handle.noBuffer().deleteTrack(ApiTrack.cast(track), DeletionCause.API); return handle.noBuffer().deleteTrack(ApiTrack.cast(track), DeletionCause.API).thenApply(x -> true);
} }
@Override @Override
public CompletableFuture<Boolean> saveUUIDData(@NonNull String username, @NonNull UUID uuid) { public CompletableFuture<Boolean> saveUUIDData(@NonNull String username, @NonNull UUID uuid) {
return handle.noBuffer().saveUUIDData(uuid, checkUsername(username)); return handle.noBuffer().saveUUIDData(uuid, checkUsername(username)).thenApply(x -> true);
} }
@Override @Override

36
common/src/main/java/me/lucko/luckperms/common/commands/abstraction/SubCommand.java
View File

@ -173,7 +173,13 @@ public abstract class SubCommand<T> extends Command<T, Void> {
} }
public static void save(User user, Sender sender, LuckPermsPlugin plugin) { public static void save(User user, Sender sender, LuckPermsPlugin plugin) {
boolean success = plugin.getStorage().noBuffer().saveUser(user).join(); try {
plugin.getStorage().noBuffer().saveUser(user).get();
} catch (Exception e) {
e.printStackTrace();
Message.USER_SAVE_ERROR.send(sender, user.getFriendlyName());
return;
}
if (sender.isImport()) { if (sender.isImport()) {
user.getRefreshBuffer().request(); user.getRefreshBuffer().request();
@ -187,14 +193,16 @@ public abstract class SubCommand<T> extends Command<T, Void> {
messagingService.get().getUpdateBuffer().request(); messagingService.get().getUpdateBuffer().request();
} }
} }
if (!success) {
Message.USER_SAVE_ERROR.send(sender, user.getFriendlyName());
}
} }
public static void save(Group group, Sender sender, LuckPermsPlugin plugin) { public static void save(Group group, Sender sender, LuckPermsPlugin plugin) {
boolean success = plugin.getStorage().noBuffer().saveGroup(group).join(); try {
plugin.getStorage().noBuffer().saveGroup(group).get();
} catch (Exception e) {
e.printStackTrace();
Message.GROUP_SAVE_ERROR.send(sender, group.getFriendlyName());
return;
}
if (sender.isImport()) { if (sender.isImport()) {
plugin.getUpdateTaskBuffer().request(); plugin.getUpdateTaskBuffer().request();
@ -208,14 +216,16 @@ public abstract class SubCommand<T> extends Command<T, Void> {
messagingService.get().getUpdateBuffer().request(); messagingService.get().getUpdateBuffer().request();
} }
} }
if (!success) {
Message.GROUP_SAVE_ERROR.send(sender, group.getFriendlyName());
}
} }
public static void save(Track track, Sender sender, LuckPermsPlugin plugin) { public static void save(Track track, Sender sender, LuckPermsPlugin plugin) {
boolean success = plugin.getStorage().noBuffer().saveTrack(track).join(); try {
plugin.getStorage().noBuffer().saveTrack(track).get();
} catch (Exception e) {
e.printStackTrace();
Message.TRACK_SAVE_ERROR.send(sender, track.getName());
return;
}
if (sender.isImport()) { if (sender.isImport()) {
plugin.getUpdateTaskBuffer().request(); plugin.getUpdateTaskBuffer().request();
@ -229,9 +239,5 @@ public abstract class SubCommand<T> extends Command<T, Void> {
messagingService.get().getUpdateBuffer().request(); messagingService.get().getUpdateBuffer().request();
} }
} }
if (!success) {
Message.TRACK_SAVE_ERROR.send(sender, track.getName());
}
} }
} }

5
common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/other/HolderShowTracks.java
View File

@ -61,7 +61,10 @@ public class HolderShowTracks<T extends PermissionHolder> extends SubCommand<T>
return CommandResult.NO_PERMISSION; return CommandResult.NO_PERMISSION;
} }
if (!plugin.getStorage().loadAllTracks().join()) { try {
plugin.getStorage().loadAllTracks().get();
} catch (Exception e) {
e.printStackTrace();
Message.TRACKS_LOAD_ERROR.send(sender); Message.TRACKS_LOAD_ERROR.send(sender);
return CommandResult.LOADING_ERROR; return CommandResult.LOADING_ERROR;
} }

2
common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/parent/ParentAdd.java
View File

@ -64,7 +64,7 @@ public class ParentAdd extends SharedSubCommand {
String groupName = ArgumentUtils.handleName(0, args); String groupName = ArgumentUtils.handleName(0, args);
MutableContextSet context = ArgumentUtils.handleContext(1, args, plugin); MutableContextSet context = ArgumentUtils.handleContext(1, args, plugin);
if (!plugin.getStorage().loadGroup(groupName).join()) { if (!plugin.getStorage().loadGroup(groupName).join().isPresent()) {
Message.DOES_NOT_EXIST.send(sender, groupName); Message.DOES_NOT_EXIST.send(sender, groupName);
return CommandResult.INVALID_ARGS; return CommandResult.INVALID_ARGS;
} }

2
common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/parent/ParentAddTemp.java
View File

@ -71,7 +71,7 @@ public class ParentAddTemp extends SharedSubCommand {
MutableContextSet context = ArgumentUtils.handleContext(2, args, plugin); MutableContextSet context = ArgumentUtils.handleContext(2, args, plugin);
TemporaryModifier modifier = plugin.getConfiguration().get(ConfigKeys.TEMPORARY_ADD_BEHAVIOUR); TemporaryModifier modifier = plugin.getConfiguration().get(ConfigKeys.TEMPORARY_ADD_BEHAVIOUR);
if (!plugin.getStorage().loadGroup(groupName).join()) { if (!plugin.getStorage().loadGroup(groupName).join().isPresent()) {
Message.DOES_NOT_EXIST.send(sender, groupName); Message.DOES_NOT_EXIST.send(sender, groupName);
return CommandResult.INVALID_ARGS; return CommandResult.INVALID_ARGS;
} }

2
common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/parent/ParentClearTrack.java
View File

@ -67,7 +67,7 @@ public class ParentClearTrack extends SharedSubCommand {
return CommandResult.INVALID_ARGS; return CommandResult.INVALID_ARGS;
} }
if (!plugin.getStorage().loadTrack(trackName).join()) { if (!plugin.getStorage().loadTrack(trackName).join().isPresent()) {
Message.DOES_NOT_EXIST.send(sender, trackName); Message.DOES_NOT_EXIST.send(sender, trackName);
return CommandResult.INVALID_ARGS; return CommandResult.INVALID_ARGS;
} }

2
common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/parent/ParentSet.java
View File

@ -64,7 +64,7 @@ public class ParentSet extends SharedSubCommand {
String groupName = ArgumentUtils.handleName(0, args); String groupName = ArgumentUtils.handleName(0, args);
MutableContextSet context = ArgumentUtils.handleContext(1, args, plugin); MutableContextSet context = ArgumentUtils.handleContext(1, args, plugin);
if (!plugin.getStorage().loadGroup(groupName).join()) { if (!plugin.getStorage().loadGroup(groupName).join().isPresent()) {
Message.DOES_NOT_EXIST.send(sender, groupName); Message.DOES_NOT_EXIST.send(sender, groupName);
return CommandResult.INVALID_ARGS; return CommandResult.INVALID_ARGS;
} }

4
common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/parent/ParentSetTrack.java
View File

@ -69,7 +69,7 @@ public class ParentSetTrack extends SharedSubCommand {
return CommandResult.INVALID_ARGS; return CommandResult.INVALID_ARGS;
} }
if (!plugin.getStorage().loadTrack(trackName).join()) { if (!plugin.getStorage().loadTrack(trackName).join().isPresent()) {
Message.DOES_NOT_EXIST.send(sender, trackName); Message.DOES_NOT_EXIST.send(sender, trackName);
return CommandResult.INVALID_ARGS; return CommandResult.INVALID_ARGS;
} }
@ -104,7 +104,7 @@ public class ParentSetTrack extends SharedSubCommand {
MutableContextSet context = ArgumentUtils.handleContext(2, args, plugin); MutableContextSet context = ArgumentUtils.handleContext(2, args, plugin);
if (!plugin.getStorage().loadGroup(groupName).join()) { if (!plugin.getStorage().loadGroup(groupName).join().isPresent()) {
Message.DOES_NOT_EXIST.send(sender, groupName); Message.DOES_NOT_EXIST.send(sender, groupName);
return CommandResult.INVALID_ARGS; return CommandResult.INVALID_ARGS;
} }

7
common/src/main/java/me/lucko/luckperms/common/commands/impl/group/CreateGroup.java
View File

@ -59,12 +59,15 @@ public class CreateGroup extends SingleCommand {
return CommandResult.INVALID_ARGS; return CommandResult.INVALID_ARGS;
} }
if (plugin.getStorage().loadGroup(groupName).join()) { if (plugin.getStorage().loadGroup(groupName).join().isPresent()) {
Message.ALREADY_EXISTS.send(sender, groupName); Message.ALREADY_EXISTS.send(sender, groupName);
return CommandResult.INVALID_ARGS; return CommandResult.INVALID_ARGS;
} }
if (!plugin.getStorage().createAndLoadGroup(groupName, CreationCause.COMMAND).join()) { try {
plugin.getStorage().createAndLoadGroup(groupName, CreationCause.COMMAND).get();
} catch (Exception e) {
e.printStackTrace();
Message.CREATE_ERROR.send(sender, groupName); Message.CREATE_ERROR.send(sender, groupName);
return CommandResult.FAILURE; return CommandResult.FAILURE;
} }

7
common/src/main/java/me/lucko/luckperms/common/commands/impl/group/DeleteGroup.java
View File

@ -62,7 +62,7 @@ public class DeleteGroup extends SingleCommand {
return CommandResult.INVALID_ARGS; return CommandResult.INVALID_ARGS;
} }
if (!plugin.getStorage().loadGroup(groupName).join()) { if (!plugin.getStorage().loadGroup(groupName).join().isPresent()) {
Message.DOES_NOT_EXIST.send(sender, groupName); Message.DOES_NOT_EXIST.send(sender, groupName);
return CommandResult.INVALID_ARGS; return CommandResult.INVALID_ARGS;
} }
@ -73,7 +73,10 @@ public class DeleteGroup extends SingleCommand {
return CommandResult.LOADING_ERROR; return CommandResult.LOADING_ERROR;
} }
if (!plugin.getStorage().deleteGroup(group, DeletionCause.COMMAND).join()) { try {
plugin.getStorage().deleteGroup(group, DeletionCause.COMMAND).get();
} catch (Exception e) {
e.printStackTrace();
Message.DELETE_ERROR.send(sender, group.getFriendlyName()); Message.DELETE_ERROR.send(sender, group.getFriendlyName());
return CommandResult.FAILURE; return CommandResult.FAILURE;
} }

2
common/src/main/java/me/lucko/luckperms/common/commands/impl/group/GroupMainCommand.java
View File

@ -84,7 +84,7 @@ public class GroupMainCommand extends MainCommand<Group, String> {
@Override @Override
protected Group getTarget(String target, LuckPermsPlugin plugin, Sender sender) { protected Group getTarget(String target, LuckPermsPlugin plugin, Sender sender) {
if (!plugin.getStorage().loadGroup(target).join()) { if (!plugin.getStorage().loadGroup(target).join().isPresent()) {
// failed to load, but it might be a display name. // failed to load, but it might be a display name.
// nope, not a display name // nope, not a display name

12
common/src/main/java/me/lucko/luckperms/common/commands/impl/group/GroupRename.java
View File

@ -56,12 +56,15 @@ public class GroupRename extends SubCommand<Group> {
return CommandResult.INVALID_ARGS; return CommandResult.INVALID_ARGS;
} }
if (plugin.getStorage().loadGroup(newGroupName).join()) { if (plugin.getStorage().loadGroup(newGroupName).join().isPresent()) {
Message.ALREADY_EXISTS.send(sender, newGroupName); Message.ALREADY_EXISTS.send(sender, newGroupName);
return CommandResult.INVALID_ARGS; return CommandResult.INVALID_ARGS;
} }
if (!plugin.getStorage().createAndLoadGroup(newGroupName, CreationCause.COMMAND).join()) { try {
plugin.getStorage().createAndLoadGroup(newGroupName, CreationCause.COMMAND).get();
} catch (Exception e) {
e.printStackTrace();
Message.CREATE_ERROR.send(sender, newGroupName); Message.CREATE_ERROR.send(sender, newGroupName);
return CommandResult.FAILURE; return CommandResult.FAILURE;
} }
@ -72,7 +75,10 @@ public class GroupRename extends SubCommand<Group> {
return CommandResult.LOADING_ERROR; return CommandResult.LOADING_ERROR;
} }
if (!plugin.getStorage().deleteGroup(group, DeletionCause.COMMAND).join()) { try {
plugin.getStorage().deleteGroup(group, DeletionCause.COMMAND).get();
} catch (Exception e) {
e.printStackTrace();
Message.DELETE_ERROR.send(sender, group.getFriendlyName()); Message.DELETE_ERROR.send(sender, group.getFriendlyName());
return CommandResult.FAILURE; return CommandResult.FAILURE;
} }

6
common/src/main/java/me/lucko/luckperms/common/commands/impl/group/ListGroups.java
View File

@ -54,7 +54,11 @@ public class ListGroups extends SingleCommand {
@Override @Override
public CommandResult execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) { public CommandResult execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
if (!plugin.getStorage().loadAllGroups().join()) {
try {
plugin.getStorage().loadAllGroups().get();
} catch (Exception e) {
e.printStackTrace();
Message.GROUPS_LOAD_ERROR.send(sender); Message.GROUPS_LOAD_ERROR.send(sender);
return CommandResult.LOADING_ERROR; return CommandResult.LOADING_ERROR;
} }

5
common/src/main/java/me/lucko/luckperms/common/commands/impl/misc/BulkUpdateCommand.java
View File

@ -72,11 +72,12 @@ public class BulkUpdateCommand extends SingleCommand {
} }
Message.BULK_UPDATE_STARTING.send(sender); Message.BULK_UPDATE_STARTING.send(sender);
plugin.getStorage().applyBulkUpdate(operation).thenAcceptAsync(b -> { plugin.getStorage().applyBulkUpdate(operation).whenCompleteAsync((v, ex) -> {
if (b) { if (ex == null) {
plugin.getUpdateTaskBuffer().requestDirectly(); plugin.getUpdateTaskBuffer().requestDirectly();
Message.BULK_UPDATE_SUCCESS.send(sender); Message.BULK_UPDATE_SUCCESS.send(sender);
} else { } else {
ex.printStackTrace();
Message.BULK_UPDATE_FAILURE.send(sender); Message.BULK_UPDATE_FAILURE.send(sender);
} }
}, plugin.getScheduler().async()); }, plugin.getScheduler().async());

7
common/src/main/java/me/lucko/luckperms/common/commands/impl/track/CreateTrack.java
View File

@ -59,12 +59,15 @@ public class CreateTrack extends SingleCommand {
return CommandResult.INVALID_ARGS; return CommandResult.INVALID_ARGS;
} }
if (plugin.getStorage().loadTrack(trackName).join()) { if (plugin.getStorage().loadTrack(trackName).join().isPresent()) {
Message.ALREADY_EXISTS.send(sender, trackName); Message.ALREADY_EXISTS.send(sender, trackName);
return CommandResult.INVALID_ARGS; return CommandResult.INVALID_ARGS;
} }
if (!plugin.getStorage().createAndLoadTrack(trackName, CreationCause.COMMAND).join()) { try {
plugin.getStorage().createAndLoadTrack(trackName, CreationCause.COMMAND).get();
} catch (Exception e) {
e.printStackTrace();
Message.CREATE_ERROR.send(sender, trackName); Message.CREATE_ERROR.send(sender, trackName);
return CommandResult.FAILURE; return CommandResult.FAILURE;
} }

7
common/src/main/java/me/lucko/luckperms/common/commands/impl/track/DeleteTrack.java
View File

@ -55,7 +55,7 @@ public class DeleteTrack extends SingleCommand {
} }
String trackName = args.get(0).toLowerCase(); String trackName = args.get(0).toLowerCase();
if (!plugin.getStorage().loadTrack(trackName).join()) { if (!plugin.getStorage().loadTrack(trackName).join().isPresent()) {
Message.DOES_NOT_EXIST.send(sender, trackName); Message.DOES_NOT_EXIST.send(sender, trackName);
return CommandResult.INVALID_ARGS; return CommandResult.INVALID_ARGS;
} }
@ -66,7 +66,10 @@ public class DeleteTrack extends SingleCommand {
return CommandResult.LOADING_ERROR; return CommandResult.LOADING_ERROR;
} }
if (!plugin.getStorage().deleteTrack(track, DeletionCause.COMMAND).join()) { try {
plugin.getStorage().deleteTrack(track, DeletionCause.COMMAND).get();
} catch (Exception e) {
e.printStackTrace();
Message.DELETE_ERROR.send(sender, track.getName()); Message.DELETE_ERROR.send(sender, track.getName());
return CommandResult.FAILURE; return CommandResult.FAILURE;
} }

5
common/src/main/java/me/lucko/luckperms/common/commands/impl/track/ListTracks.java
View File

@ -46,7 +46,10 @@ public class ListTracks extends SingleCommand {
@Override @Override
public CommandResult execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) { public CommandResult execute(LuckPermsPlugin plugin, Sender sender, List<String> args, String label) {
if (!plugin.getStorage().loadAllTracks().join()) { try {
plugin.getStorage().loadAllTracks().get();
} catch (Exception e) {
e.printStackTrace();
Message.TRACKS_LOAD_ERROR.send(sender); Message.TRACKS_LOAD_ERROR.send(sender);
return CommandResult.LOADING_ERROR; return CommandResult.LOADING_ERROR;
} }

2
common/src/main/java/me/lucko/luckperms/common/commands/impl/track/TrackAppend.java
View File

@ -57,7 +57,7 @@ public class TrackAppend extends SubCommand<Track> {
return CommandResult.INVALID_ARGS; return CommandResult.INVALID_ARGS;
} }
if (!plugin.getStorage().loadGroup(groupName).join()) { if (!plugin.getStorage().loadGroup(groupName).join().isPresent()) {
Message.DOES_NOT_EXIST.send(sender, groupName); Message.DOES_NOT_EXIST.send(sender, groupName);
return CommandResult.INVALID_ARGS; return CommandResult.INVALID_ARGS;
} }

2
common/src/main/java/me/lucko/luckperms/common/commands/impl/track/TrackInsert.java
View File

@ -65,7 +65,7 @@ public class TrackInsert extends SubCommand<Track> {
return CommandResult.INVALID_ARGS; return CommandResult.INVALID_ARGS;
} }
if (!plugin.getStorage().loadGroup(groupName).join()) { if (!plugin.getStorage().loadGroup(groupName).join().isPresent()) {
Message.DOES_NOT_EXIST.send(sender, groupName); Message.DOES_NOT_EXIST.send(sender, groupName);
return CommandResult.INVALID_ARGS; return CommandResult.INVALID_ARGS;
} }

2
common/src/main/java/me/lucko/luckperms/common/commands/impl/track/TrackMainCommand.java
View File

@ -73,7 +73,7 @@ public class TrackMainCommand extends MainCommand<Track, String> {
@Override @Override
protected Track getTarget(String target, LuckPermsPlugin plugin, Sender sender) { protected Track getTarget(String target, LuckPermsPlugin plugin, Sender sender) {
if (!plugin.getStorage().loadTrack(target).join()) { if (!plugin.getStorage().loadTrack(target).join().isPresent()) {
Message.TRACK_NOT_FOUND.send(sender, target); Message.TRACK_NOT_FOUND.send(sender, target);
return null; return null;
} }

12
common/src/main/java/me/lucko/luckperms/common/commands/impl/track/TrackRename.java
View File

@ -56,12 +56,15 @@ public class TrackRename extends SubCommand<Track> {
return CommandResult.INVALID_ARGS; return CommandResult.INVALID_ARGS;
} }
if (plugin.getStorage().loadTrack(newTrackName).join()) { if (plugin.getStorage().loadTrack(newTrackName).join().isPresent()) {
Message.ALREADY_EXISTS.send(sender, newTrackName); Message.ALREADY_EXISTS.send(sender, newTrackName);
return CommandResult.INVALID_ARGS; return CommandResult.INVALID_ARGS;
} }
if (!plugin.getStorage().createAndLoadTrack(newTrackName, CreationCause.COMMAND).join()) { try {
plugin.getStorage().createAndLoadTrack(newTrackName, CreationCause.COMMAND).get();
} catch (Exception e) {
e.printStackTrace();
Message.CREATE_ERROR.send(sender, newTrackName); Message.CREATE_ERROR.send(sender, newTrackName);
return CommandResult.FAILURE; return CommandResult.FAILURE;
} }
@ -72,7 +75,10 @@ public class TrackRename extends SubCommand<Track> {
return CommandResult.LOADING_ERROR; return CommandResult.LOADING_ERROR;
} }
if (!plugin.getStorage().deleteTrack(track, DeletionCause.COMMAND).join()) { try {
plugin.getStorage().deleteTrack(track, DeletionCause.COMMAND).get();
} catch (Exception e) {
e.printStackTrace();
Message.DELETE_ERROR.send(sender, track.getName()); Message.DELETE_ERROR.send(sender, track.getName());
return CommandResult.FAILURE; return CommandResult.FAILURE;
} }

4
common/src/main/java/me/lucko/luckperms/common/commands/impl/user/UserDemote.java
View File

@ -71,7 +71,7 @@ public class UserDemote extends SubCommand<User> {
return CommandResult.INVALID_ARGS; return CommandResult.INVALID_ARGS;
} }
if (!plugin.getStorage().loadTrack(trackName).join()) { if (!plugin.getStorage().loadTrack(trackName).join().isPresent()) {
Message.DOES_NOT_EXIST.send(sender, trackName); Message.DOES_NOT_EXIST.send(sender, trackName);
return CommandResult.INVALID_ARGS; return CommandResult.INVALID_ARGS;
} }
@ -142,7 +142,7 @@ public class UserDemote extends SubCommand<User> {
return CommandResult.SUCCESS; return CommandResult.SUCCESS;
} }
if (!plugin.getStorage().loadGroup(previous).join()) { if (!plugin.getStorage().loadGroup(previous).join().isPresent()) {
Message.USER_DEMOTE_ERROR_MALFORMED.send(sender, previous); Message.USER_DEMOTE_ERROR_MALFORMED.send(sender, previous);
return CommandResult.STATE_ERROR; return CommandResult.STATE_ERROR;
} }

6
common/src/main/java/me/lucko/luckperms/common/commands/impl/user/UserMainCommand.java
View File

@ -118,7 +118,11 @@ public class UserMainCommand extends MainCommand<User, UserIdentifier> {
@Override @Override
protected User getTarget(UserIdentifier target, LuckPermsPlugin plugin, Sender sender) { protected User getTarget(UserIdentifier target, LuckPermsPlugin plugin, Sender sender) {
if (!plugin.getStorage().loadUser(target.getUuid(), target.getUsername().orElse(null)).join()) {
try {
plugin.getStorage().loadUser(target.getUuid(), target.getUsername().orElse(null)).get();
} catch (Exception e) {
e.printStackTrace();
Message.LOADING_ERROR.send(sender); Message.LOADING_ERROR.send(sender);
return null; return null;
} }

4
common/src/main/java/me/lucko/luckperms/common/commands/impl/user/UserPromote.java
View File

@ -69,7 +69,7 @@ public class UserPromote extends SubCommand<User> {
return CommandResult.INVALID_ARGS; return CommandResult.INVALID_ARGS;
} }
if (!plugin.getStorage().loadTrack(trackName).join()) { if (!plugin.getStorage().loadTrack(trackName).join().isPresent()) {
Message.DOES_NOT_EXIST.send(sender, trackName); Message.DOES_NOT_EXIST.send(sender, trackName);
return CommandResult.INVALID_ARGS; return CommandResult.INVALID_ARGS;
} }
@ -149,7 +149,7 @@ public class UserPromote extends SubCommand<User> {
return CommandResult.STATE_ERROR; return CommandResult.STATE_ERROR;
} }
if (!plugin.getStorage().loadGroup(next).join()) { if (!plugin.getStorage().loadGroup(next).join().isPresent()) {
Message.USER_PROMOTE_ERROR_MALFORMED.send(sender, next); Message.USER_PROMOTE_ERROR_MALFORMED.send(sender, next);
return CommandResult.STATE_ERROR; return CommandResult.STATE_ERROR;
} }

129
common/src/main/java/me/lucko/luckperms/common/storage/AbstractStorage.java
View File

@ -48,6 +48,7 @@ import me.lucko.luckperms.common.storage.wrappings.PhasedStorage;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.Optional;
import java.util.Set; import java.util.Set;
import java.util.UUID; import java.util.UUID;
import java.util.concurrent.Callable; import java.util.concurrent.Callable;
@ -88,6 +89,21 @@ public class AbstractStorage implements Storage {
}, dao.getPlugin().getScheduler().async()); }, dao.getPlugin().getScheduler().async());
} }
private CompletableFuture<Void> makeFuture(ThrowingRunnable runnable) {
return CompletableFuture.runAsync(() -> {
try {
runnable.run();
} catch (Exception e) {
Throwables.propagateIfPossible(e);
throw new CompletionException(e);
}
}, dao.getPlugin().getScheduler().async());
}
private interface ThrowingRunnable {
void run() throws Exception;
}
@Override @Override
public String getName() { public String getName() {
return dao.getName(); return dao.getName();
@ -124,7 +140,7 @@ public class AbstractStorage implements Storage {
} }
@Override @Override
public CompletableFuture<Boolean> logAction(LogEntry entry) { public CompletableFuture<Void> logAction(LogEntry entry) {
return makeFuture(() -> dao.logAction(entry)); return makeFuture(() -> dao.logAction(entry));
} }
@ -134,26 +150,23 @@ public class AbstractStorage implements Storage {
} }
@Override @Override
public CompletableFuture<Boolean> applyBulkUpdate(BulkUpdate bulkUpdate) { public CompletableFuture<Void> applyBulkUpdate(BulkUpdate bulkUpdate) {
return makeFuture(() -> dao.applyBulkUpdate(bulkUpdate)); return makeFuture(() -> dao.applyBulkUpdate(bulkUpdate));
} }
@Override @Override
public CompletableFuture<Boolean> loadUser(UUID uuid, String username) { public CompletableFuture<User> loadUser(UUID uuid, String username) {
return makeFuture(() -> { return makeFuture(() -> {
if (dao.loadUser(uuid, username)) { User user = dao.loadUser(uuid, username);
User u = plugin.getUserManager().getIfLoaded(uuid); if (user != null) {
if (u != null) { plugin.getApiProvider().getEventFactory().handleUserLoad(user);
plugin.getApiProvider().getEventFactory().handleUserLoad(u);
}
return true;
} }
return false; return user;
}); });
} }
@Override @Override
public CompletableFuture<Boolean> saveUser(User user) { public CompletableFuture<Void> saveUser(User user) {
return makeFuture(() -> dao.saveUser(user)); return makeFuture(() -> dao.saveUser(user));
} }
@ -168,57 +181,45 @@ public class AbstractStorage implements Storage {
} }
@Override @Override
public CompletableFuture<Boolean> createAndLoadGroup(String name, CreationCause cause) { public CompletableFuture<Group> createAndLoadGroup(String name, CreationCause cause) {
return makeFuture(() -> { return makeFuture(() -> {
if (dao.createAndLoadGroup(name)) { Group group = dao.createAndLoadGroup(name);
Group g = plugin.getGroupManager().getIfLoaded(name); if (group != null) {
if (g != null) { plugin.getApiProvider().getEventFactory().handleGroupCreate(group, cause);
plugin.getApiProvider().getEventFactory().handleGroupCreate(g, cause);
}
return true;
} }
return false; return group;
}); });
} }
@Override @Override
public CompletableFuture<Boolean> loadGroup(String name) { public CompletableFuture<Optional<Group>> loadGroup(String name) {
return makeFuture(() -> { return makeFuture(() -> {
if (dao.loadGroup(name)) { Optional<Group> group = dao.loadGroup(name);
Group g = plugin.getGroupManager().getIfLoaded(name); if (group.isPresent()) {
if (g != null) { plugin.getApiProvider().getEventFactory().handleGroupLoad(group.get());
plugin.getApiProvider().getEventFactory().handleGroupLoad(g);
}
return true;
} }
return false; return group;
}); });
} }
@Override @Override
public CompletableFuture<Boolean> loadAllGroups() { public CompletableFuture<Void> loadAllGroups() {
return makeFuture(() -> { return makeFuture(() -> {
if (dao.loadAllGroups()) { dao.loadAllGroups();
plugin.getApiProvider().getEventFactory().handleGroupLoadAll(); plugin.getApiProvider().getEventFactory().handleGroupLoadAll();
return true;
}
return false;
}); });
} }
@Override @Override
public CompletableFuture<Boolean> saveGroup(Group group) { public CompletableFuture<Void> saveGroup(Group group) {
return makeFuture(() -> dao.saveGroup(group)); return makeFuture(() -> dao.saveGroup(group));
} }
@Override @Override
public CompletableFuture<Boolean> deleteGroup(Group group, DeletionCause cause) { public CompletableFuture<Void> deleteGroup(Group group, DeletionCause cause) {
return makeFuture(() -> { return makeFuture(() -> {
if (dao.deleteGroup(group)) { dao.deleteGroup(group);
plugin.getApiProvider().getEventFactory().handleGroupDelete(group, cause); plugin.getApiProvider().getEventFactory().handleGroupDelete(group, cause);
return true;
}
return false;
}); });
} }
@ -228,62 +229,50 @@ public class AbstractStorage implements Storage {
} }
@Override @Override
public CompletableFuture<Boolean> createAndLoadTrack(String name, CreationCause cause) { public CompletableFuture<Track> createAndLoadTrack(String name, CreationCause cause) {
return makeFuture(() -> { return makeFuture(() -> {
if (dao.createAndLoadTrack(name)) { Track track = dao.createAndLoadTrack(name);
Track t = plugin.getTrackManager().getIfLoaded(name); if (track != null) {
if (t != null) { plugin.getApiProvider().getEventFactory().handleTrackCreate(track, cause);
plugin.getApiProvider().getEventFactory().handleTrackCreate(t, cause);
}
return true;
} }
return false; return track;
}); });
} }
@Override @Override
public CompletableFuture<Boolean> loadTrack(String name) { public CompletableFuture<Optional<Track>> loadTrack(String name) {
return makeFuture(() -> { return makeFuture(() -> {
if (dao.loadTrack(name)) { Optional<Track> track = dao.loadTrack(name);
Track t = plugin.getTrackManager().getIfLoaded(name); if (track.isPresent()) {
if (t != null) { plugin.getApiProvider().getEventFactory().handleTrackLoad(track.get());
plugin.getApiProvider().getEventFactory().handleTrackLoad(t);
}
return true;
} }
return false; return track;
}); });
} }
@Override @Override
public CompletableFuture<Boolean> loadAllTracks() { public CompletableFuture<Void> loadAllTracks() {
return makeFuture(() -> { return makeFuture(() -> {
if (dao.loadAllTracks()) { dao.loadAllTracks();
plugin.getApiProvider().getEventFactory().handleTrackLoadAll(); plugin.getApiProvider().getEventFactory().handleTrackLoadAll();
return true;
}
return false;
}); });
} }
@Override @Override
public CompletableFuture<Boolean> saveTrack(Track track) { public CompletableFuture<Void> saveTrack(Track track) {
return makeFuture(() -> dao.saveTrack(track)); return makeFuture(() -> dao.saveTrack(track));
} }
@Override @Override
public CompletableFuture<Boolean> deleteTrack(Track track, DeletionCause cause) { public CompletableFuture<Void> deleteTrack(Track track, DeletionCause cause) {
return makeFuture(() -> { return makeFuture(() -> {
if (dao.deleteTrack(track)) { dao.deleteTrack(track);
plugin.getApiProvider().getEventFactory().handleTrackDelete(track, cause); plugin.getApiProvider().getEventFactory().handleTrackDelete(track, cause);
return true;
}
return false;
}); });
} }
@Override @Override
public CompletableFuture<Boolean> saveUUIDData(UUID uuid, String username) { public CompletableFuture<Void> saveUUIDData(UUID uuid, String username) {
return makeFuture(() -> dao.saveUUIDData(uuid, username)); return makeFuture(() -> dao.saveUUIDData(uuid, username));
} }

31
common/src/main/java/me/lucko/luckperms/common/storage/Storage.java
View File

@ -38,6 +38,7 @@ import me.lucko.luckperms.common.model.User;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.Optional;
import java.util.Set; import java.util.Set;
import java.util.UUID; import java.util.UUID;
import java.util.concurrent.CompletableFuture; import java.util.concurrent.CompletableFuture;
@ -59,43 +60,43 @@ public interface Storage {
Map<String, String> getMeta(); Map<String, String> getMeta();
CompletableFuture<Boolean> logAction(LogEntry entry); CompletableFuture<Void> logAction(LogEntry entry);
CompletableFuture<Log> getLog(); CompletableFuture<Log> getLog();
CompletableFuture<Boolean> applyBulkUpdate(BulkUpdate bulkUpdate); CompletableFuture<Void> applyBulkUpdate(BulkUpdate bulkUpdate);
CompletableFuture<Boolean> loadUser(UUID uuid, String username); CompletableFuture<User> loadUser(UUID uuid, String username);
CompletableFuture<Boolean> saveUser(User user); CompletableFuture<Void> saveUser(User user);
CompletableFuture<Set<UUID>> getUniqueUsers(); CompletableFuture<Set<UUID>> getUniqueUsers();
CompletableFuture<List<HeldPermission<UUID>>> getUsersWithPermission(String permission); CompletableFuture<List<HeldPermission<UUID>>> getUsersWithPermission(String permission);
CompletableFuture<Boolean> createAndLoadGroup(String name, CreationCause cause); CompletableFuture<Group> createAndLoadGroup(String name, CreationCause cause);
CompletableFuture<Boolean> loadGroup(String name); CompletableFuture<Optional<Group>> loadGroup(String name);
CompletableFuture<Boolean> loadAllGroups(); CompletableFuture<Void> loadAllGroups();
CompletableFuture<Boolean> saveGroup(Group group); CompletableFuture<Void> saveGroup(Group group);
CompletableFuture<Boolean> deleteGroup(Group group, DeletionCause cause); CompletableFuture<Void> deleteGroup(Group group, DeletionCause cause);
CompletableFuture<List<HeldPermission<String>>> getGroupsWithPermission(String permission); CompletableFuture<List<HeldPermission<String>>> getGroupsWithPermission(String permission);
CompletableFuture<Boolean> createAndLoadTrack(String name, CreationCause cause); CompletableFuture<Track> createAndLoadTrack(String name, CreationCause cause);
CompletableFuture<Boolean> loadTrack(String name); CompletableFuture<Optional<Track>> loadTrack(String name);
CompletableFuture<Boolean> loadAllTracks(); CompletableFuture<Void> loadAllTracks();
CompletableFuture<Boolean> saveTrack(Track track); CompletableFuture<Void> saveTrack(Track track);
CompletableFuture<Boolean> deleteTrack(Track track, DeletionCause cause); CompletableFuture<Void> deleteTrack(Track track, DeletionCause cause);
CompletableFuture<Boolean> saveUUIDData(UUID uuid, String username); CompletableFuture<Void> saveUUIDData(UUID uuid, String username);
CompletableFuture<UUID> getUUID(String username); CompletableFuture<UUID> getUUID(String username);

31
common/src/main/java/me/lucko/luckperms/common/storage/dao/AbstractDao.java
View File

@ -41,6 +41,7 @@ import me.lucko.luckperms.common.plugin.LuckPermsPlugin;
import java.util.Collections; import java.util.Collections;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.Optional;
import java.util.Set; import java.util.Set;
import java.util.UUID; import java.util.UUID;
@ -61,43 +62,43 @@ public abstract class AbstractDao {
return Collections.emptyMap(); return Collections.emptyMap();
} }
public abstract boolean logAction(LogEntry entry) throws Exception; public abstract void logAction(LogEntry entry) throws Exception;
public abstract Log getLog() throws Exception; public abstract Log getLog() throws Exception;
public abstract boolean applyBulkUpdate(BulkUpdate bulkUpdate) throws Exception; public abstract void applyBulkUpdate(BulkUpdate bulkUpdate) throws Exception;
public abstract boolean loadUser(UUID uuid, String username) throws Exception; public abstract User loadUser(UUID uuid, String username) throws Exception;
public abstract boolean saveUser(User user) throws Exception; public abstract void saveUser(User user) throws Exception;
public abstract Set<UUID> getUniqueUsers() throws Exception; public abstract Set<UUID> getUniqueUsers() throws Exception;
public abstract List<HeldPermission<UUID>> getUsersWithPermission(String permission) throws Exception; public abstract List<HeldPermission<UUID>> getUsersWithPermission(String permission) throws Exception;
public abstract boolean createAndLoadGroup(String name) throws Exception; public abstract Group createAndLoadGroup(String name) throws Exception;
public abstract boolean loadGroup(String name) throws Exception; public abstract Optional<Group> loadGroup(String name) throws Exception;
public abstract boolean loadAllGroups() throws Exception; public abstract void loadAllGroups() throws Exception;
public abstract boolean saveGroup(Group group) throws Exception; public abstract void saveGroup(Group group) throws Exception;
public abstract boolean deleteGroup(Group group) throws Exception; public abstract void deleteGroup(Group group) throws Exception;
public abstract List<HeldPermission<String>> getGroupsWithPermission(String permission) throws Exception; public abstract List<HeldPermission<String>> getGroupsWithPermission(String permission) throws Exception;
public abstract boolean createAndLoadTrack(String name) throws Exception; public abstract Track createAndLoadTrack(String name) throws Exception;
public abstract boolean loadTrack(String name) throws Exception; public abstract Optional<Track> loadTrack(String name) throws Exception;
public abstract boolean loadAllTracks() throws Exception; public abstract void loadAllTracks() throws Exception;
public abstract boolean saveTrack(Track track) throws Exception; public abstract void saveTrack(Track track) throws Exception;
public abstract boolean deleteTrack(Track track) throws Exception; public abstract void deleteTrack(Track track) throws Exception;
public abstract boolean saveUUIDData(UUID uuid, String username) throws Exception; public abstract void saveUUIDData(UUID uuid, String username) throws Exception;
public abstract UUID getUUID(String username) throws Exception; public abstract UUID getUUID(String username) throws Exception;

58
common/src/main/java/me/lucko/luckperms/common/storage/dao/SplitStorageDao.java
View File

@ -39,6 +39,7 @@ import me.lucko.luckperms.common.plugin.LuckPermsPlugin;
import java.util.LinkedHashMap; import java.util.LinkedHashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.Optional;
import java.util.Set; import java.util.Set;
import java.util.UUID; import java.util.UUID;
@ -90,8 +91,8 @@ public class SplitStorageDao extends AbstractDao {
} }
@Override @Override
public boolean logAction(LogEntry entry) throws Exception { public void logAction(LogEntry entry) throws Exception {
return backing.get(types.get("log")).logAction(entry); backing.get(types.get("log")).logAction(entry);
} }
@Override @Override
@ -100,27 +101,26 @@ public class SplitStorageDao extends AbstractDao {
} }
@Override @Override
public boolean applyBulkUpdate(BulkUpdate bulkUpdate) throws Exception { public void applyBulkUpdate(BulkUpdate bulkUpdate) throws Exception {
String userType = types.get("user"); String userType = types.get("user");
String groupType = types.get("group"); String groupType = types.get("group");
boolean ret = backing.get(userType).applyBulkUpdate(bulkUpdate); backing.get(userType).applyBulkUpdate(bulkUpdate);
// if differs
if (!userType.equals(groupType)) { if (!userType.equals(groupType)) {
if (!backing.get(groupType).applyBulkUpdate(bulkUpdate)) { backing.get(groupType).applyBulkUpdate(bulkUpdate);
ret = false;
}
} }
return ret;
} }
@Override @Override
public boolean loadUser(UUID uuid, String username) throws Exception { public User loadUser(UUID uuid, String username) throws Exception {
return backing.get(types.get("user")).loadUser(uuid, username); return backing.get(types.get("user")).loadUser(uuid, username);
} }
@Override @Override
public boolean saveUser(User user) throws Exception { public void saveUser(User user) throws Exception {
return backing.get(types.get("user")).saveUser(user); backing.get(types.get("user")).saveUser(user);
} }
@Override @Override
@ -134,28 +134,28 @@ public class SplitStorageDao extends AbstractDao {
} }
@Override @Override
public boolean createAndLoadGroup(String name) throws Exception { public Group createAndLoadGroup(String name) throws Exception {
return backing.get(types.get("group")).createAndLoadGroup(name); return backing.get(types.get("group")).createAndLoadGroup(name);
} }
@Override @Override
public boolean loadGroup(String name) throws Exception { public Optional<Group> loadGroup(String name) throws Exception {
return backing.get(types.get("group")).loadGroup(name); return backing.get(types.get("group")).loadGroup(name);
} }
@Override @Override
public boolean loadAllGroups() throws Exception { public void loadAllGroups() throws Exception {
return backing.get(types.get("group")).loadAllGroups(); backing.get(types.get("group")).loadAllGroups();
} }
@Override @Override
public boolean saveGroup(Group group) throws Exception { public void saveGroup(Group group) throws Exception {
return backing.get(types.get("group")).saveGroup(group); backing.get(types.get("group")).saveGroup(group);
} }
@Override @Override
public boolean deleteGroup(Group group) throws Exception { public void deleteGroup(Group group) throws Exception {
return backing.get(types.get("group")).deleteGroup(group); backing.get(types.get("group")).deleteGroup(group);
} }
@Override @Override
@ -164,33 +164,33 @@ public class SplitStorageDao extends AbstractDao {
} }
@Override @Override
public boolean createAndLoadTrack(String name) throws Exception { public Track createAndLoadTrack(String name) throws Exception {
return backing.get(types.get("track")).createAndLoadTrack(name); return backing.get(types.get("track")).createAndLoadTrack(name);
} }
@Override @Override
public boolean loadTrack(String name) throws Exception { public Optional<Track> loadTrack(String name) throws Exception {
return backing.get(types.get("track")).loadTrack(name); return backing.get(types.get("track")).loadTrack(name);
} }
@Override @Override
public boolean loadAllTracks() throws Exception { public void loadAllTracks() throws Exception {
return backing.get(types.get("track")).loadAllTracks(); backing.get(types.get("track")).loadAllTracks();
} }
@Override @Override
public boolean saveTrack(Track track) throws Exception { public void saveTrack(Track track) throws Exception {
return backing.get(types.get("track")).saveTrack(track); backing.get(types.get("track")).saveTrack(track);
} }
@Override @Override
public boolean deleteTrack(Track track) throws Exception { public void deleteTrack(Track track) throws Exception {
return backing.get(types.get("track")).deleteTrack(track); backing.get(types.get("track")).deleteTrack(track);
} }
@Override @Override
public boolean saveUUIDData(UUID uuid, String username) throws Exception { public void saveUUIDData(UUID uuid, String username) throws Exception {
return backing.get(types.get("uuid")).saveUUIDData(uuid, username); backing.get(types.get("uuid")).saveUUIDData(uuid, username);
} }
@Override @Override

67
common/src/main/java/me/lucko/luckperms/common/storage/dao/file/ConfigurateDao.java
View File

@ -73,6 +73,7 @@ import java.util.LinkedHashSet;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.Objects; import java.util.Objects;
import java.util.Optional;
import java.util.Set; import java.util.Set;
import java.util.UUID; import java.util.UUID;
import java.util.logging.FileHandler; import java.util.logging.FileHandler;
@ -303,7 +304,7 @@ public abstract class ConfigurateDao extends AbstractDao {
} }
@Override @Override
public boolean logAction(LogEntry entry) { public void logAction(LogEntry entry) {
actionLogger.info(String.format(LOG_FORMAT, actionLogger.info(String.format(LOG_FORMAT,
(entry.getActor().equals(Constants.CONSOLE_UUID) ? "" : entry.getActor() + " "), (entry.getActor().equals(Constants.CONSOLE_UUID) ? "" : entry.getActor() + " "),
entry.getActorName(), entry.getActorName(),
@ -312,7 +313,6 @@ public abstract class ConfigurateDao extends AbstractDao {
entry.getActedName(), entry.getActedName(),
entry.getAction()) entry.getAction())
); );
return true;
} }
@Override @Override
@ -322,7 +322,7 @@ public abstract class ConfigurateDao extends AbstractDao {
} }
@Override @Override
public boolean applyBulkUpdate(BulkUpdate bulkUpdate) throws Exception { public void applyBulkUpdate(BulkUpdate bulkUpdate) throws Exception {
if (bulkUpdate.getDataType().isIncludingUsers()) { if (bulkUpdate.getDataType().isIncludingUsers()) {
File[] files = getDirectory(StorageLocation.USER).listFiles(getFileTypeFilter()); File[] files = getDirectory(StorageLocation.USER).listFiles(getFileTypeFilter());
if (files == null) { if (files == null) {
@ -374,11 +374,10 @@ public abstract class ConfigurateDao extends AbstractDao {
} }
} }
} }
return true;
} }
@Override @Override
public boolean loadUser(UUID uuid, String username) throws Exception { public User loadUser(UUID uuid, String username) throws Exception {
User user = plugin.getUserManager().getOrMake(UserIdentifier.of(uuid, username)); User user = plugin.getUserManager().getOrMake(UserIdentifier.of(uuid, username));
user.getIoLock().lock(); user.getIoLock().lock();
try { try {
@ -412,11 +411,11 @@ public abstract class ConfigurateDao extends AbstractDao {
user.getIoLock().unlock(); user.getIoLock().unlock();
} }
user.getRefreshBuffer().requestDirectly(); user.getRefreshBuffer().requestDirectly();
return true; return user;
} }
@Override @Override
public boolean saveUser(User user) throws Exception { public void saveUser(User user) throws Exception {
user.getIoLock().lock(); user.getIoLock().lock();
try { try {
if (!GenericUserManager.shouldSave(user)) { if (!GenericUserManager.shouldSave(user)) {
@ -437,7 +436,6 @@ public abstract class ConfigurateDao extends AbstractDao {
} finally { } finally {
user.getIoLock().unlock(); user.getIoLock().unlock();
} }
return true;
} }
@Override @Override
@ -478,7 +476,7 @@ public abstract class ConfigurateDao extends AbstractDao {
} }
@Override @Override
public boolean createAndLoadGroup(String name) throws Exception { public Group createAndLoadGroup(String name) throws Exception {
Group group = plugin.getGroupManager().getOrMake(name); Group group = plugin.getGroupManager().getOrMake(name);
group.getIoLock().lock(); group.getIoLock().lock();
try { try {
@ -502,11 +500,11 @@ public abstract class ConfigurateDao extends AbstractDao {
group.getIoLock().unlock(); group.getIoLock().unlock();
} }
group.getRefreshBuffer().requestDirectly(); group.getRefreshBuffer().requestDirectly();
return true; return group;
} }
@Override @Override
public boolean loadGroup(String name) throws Exception { public Optional<Group> loadGroup(String name) throws Exception {
Group group = plugin.getGroupManager().getIfLoaded(name); Group group = plugin.getGroupManager().getIfLoaded(name);
if (group != null) { if (group != null) {
group.getIoLock().lock(); group.getIoLock().lock();
@ -516,7 +514,7 @@ public abstract class ConfigurateDao extends AbstractDao {
ConfigurationNode object = readFile(StorageLocation.GROUP, name); ConfigurationNode object = readFile(StorageLocation.GROUP, name);
if (object == null) { if (object == null) {
return false; return Optional.empty();
} }
if (group == null) { if (group == null) {
@ -536,13 +534,15 @@ public abstract class ConfigurateDao extends AbstractDao {
} }
} }
group.getRefreshBuffer().requestDirectly(); group.getRefreshBuffer().requestDirectly();
return true; return Optional.of(group);
} }
@Override @Override
public boolean loadAllGroups() { public void loadAllGroups() throws IOException {
String[] fileNames = groupsDirectory.list(getFileTypeFilter()); String[] fileNames = groupsDirectory.list(getFileTypeFilter());
if (fileNames == null) return false; if (fileNames == null) {
throw new IOException("Not a directory");
}
List<String> groups = Arrays.stream(fileNames) List<String> groups = Arrays.stream(fileNames)
.map(s -> s.substring(0, s.length() - fileExtension.length())) .map(s -> s.substring(0, s.length() - fileExtension.length()))
.collect(Collectors.toList()); .collect(Collectors.toList());
@ -565,12 +565,10 @@ public abstract class ConfigurateDao extends AbstractDao {
gm.getAll().values().stream() gm.getAll().values().stream()
.filter(g -> !groups.contains(g.getName())) .filter(g -> !groups.contains(g.getName()))
.forEach(gm::unload); .forEach(gm::unload);
return true;
} }
@Override @Override
public boolean saveGroup(Group group) throws Exception { public void saveGroup(Group group) throws Exception {
group.getIoLock().lock(); group.getIoLock().lock();
try { try {
ConfigurationNode data = SimpleConfigurationNode.root(); ConfigurationNode data = SimpleConfigurationNode.root();
@ -585,11 +583,10 @@ public abstract class ConfigurateDao extends AbstractDao {
} finally { } finally {
group.getIoLock().unlock(); group.getIoLock().unlock();
} }
return true;
} }
@Override @Override
public boolean deleteGroup(Group group) throws Exception { public void deleteGroup(Group group) throws Exception {
group.getIoLock().lock(); group.getIoLock().lock();
try { try {
File groupFile = new File(groupsDirectory, group.getName() + fileExtension); File groupFile = new File(groupsDirectory, group.getName() + fileExtension);
@ -603,7 +600,7 @@ public abstract class ConfigurateDao extends AbstractDao {
} finally { } finally {
group.getIoLock().unlock(); group.getIoLock().unlock();
} }
return true; plugin.getGroupManager().unload(group);
} }
@Override @Override
@ -634,7 +631,7 @@ public abstract class ConfigurateDao extends AbstractDao {
} }
@Override @Override
public boolean createAndLoadTrack(String name) throws Exception { public Track createAndLoadTrack(String name) throws Exception {
Track track = plugin.getTrackManager().getOrMake(name); Track track = plugin.getTrackManager().getOrMake(name);
track.getIoLock().lock(); track.getIoLock().lock();
try { try {
@ -658,11 +655,11 @@ public abstract class ConfigurateDao extends AbstractDao {
} finally { } finally {
track.getIoLock().unlock(); track.getIoLock().unlock();
} }
return true; return track;
} }
@Override @Override
public boolean loadTrack(String name) throws Exception { public Optional<Track> loadTrack(String name) throws Exception {
Track track = plugin.getTrackManager().getIfLoaded(name); Track track = plugin.getTrackManager().getIfLoaded(name);
if (track != null) { if (track != null) {
track.getIoLock().lock(); track.getIoLock().lock();
@ -672,7 +669,7 @@ public abstract class ConfigurateDao extends AbstractDao {
ConfigurationNode object = readFile(StorageLocation.TRACK, name); ConfigurationNode object = readFile(StorageLocation.TRACK, name);
if (object == null) { if (object == null) {
return false; return Optional.empty();
} }
if (track == null) { if (track == null) {
@ -693,13 +690,15 @@ public abstract class ConfigurateDao extends AbstractDao {
track.getIoLock().unlock(); track.getIoLock().unlock();
} }
} }
return true; return Optional.of(track);
} }
@Override @Override
public boolean loadAllTracks() { public void loadAllTracks() throws IOException {
String[] fileNames = tracksDirectory.list(getFileTypeFilter()); String[] fileNames = tracksDirectory.list(getFileTypeFilter());
if (fileNames == null) return false; if (fileNames == null) {
throw new IOException("Not a directory");
}
List<String> tracks = Arrays.stream(fileNames) List<String> tracks = Arrays.stream(fileNames)
.map(s -> s.substring(0, s.length() - fileExtension.length())) .map(s -> s.substring(0, s.length() - fileExtension.length()))
.collect(Collectors.toList()); .collect(Collectors.toList());
@ -722,12 +721,10 @@ public abstract class ConfigurateDao extends AbstractDao {
tm.getAll().values().stream() tm.getAll().values().stream()
.filter(t -> !tracks.contains(t.getName())) .filter(t -> !tracks.contains(t.getName()))
.forEach(tm::unload); .forEach(tm::unload);
return true;
} }
@Override @Override
public boolean saveTrack(Track track) throws Exception { public void saveTrack(Track track) throws Exception {
track.getIoLock().lock(); track.getIoLock().lock();
try { try {
ConfigurationNode data = SimpleConfigurationNode.root(); ConfigurationNode data = SimpleConfigurationNode.root();
@ -739,11 +736,10 @@ public abstract class ConfigurateDao extends AbstractDao {
} finally { } finally {
track.getIoLock().unlock(); track.getIoLock().unlock();
} }
return true;
} }
@Override @Override
public boolean deleteTrack(Track track) throws Exception { public void deleteTrack(Track track) throws Exception {
track.getIoLock().lock(); track.getIoLock().lock();
try { try {
File trackFile = new File(tracksDirectory, track.getName() + fileExtension); File trackFile = new File(tracksDirectory, track.getName() + fileExtension);
@ -757,13 +753,12 @@ public abstract class ConfigurateDao extends AbstractDao {
} finally { } finally {
track.getIoLock().unlock(); track.getIoLock().unlock();
} }
return true; plugin.getTrackManager().unload(track);
} }
@Override @Override
public boolean saveUUIDData(UUID uuid, String username) { public void saveUUIDData(UUID uuid, String username) {
uuidCache.addMapping(uuid, username); uuidCache.addMapping(uuid, username);
return true;
} }
@Override @Override

108
common/src/main/java/me/lucko/luckperms/common/storage/dao/mongodb/MongoDao.java
View File

@ -69,6 +69,7 @@ import java.util.LinkedHashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.Objects; import java.util.Objects;
import java.util.Optional;
import java.util.Set; import java.util.Set;
import java.util.UUID; import java.util.UUID;
import java.util.stream.Collectors; import java.util.stream.Collectors;
@ -144,7 +145,7 @@ public class MongoDao extends AbstractDao {
} }
@Override @Override
public boolean logAction(LogEntry entry) { public void logAction(LogEntry entry) {
MongoCollection<Document> c = database.getCollection(prefix + "action"); MongoCollection<Document> c = database.getCollection(prefix + "action");
Document doc = new Document() Document doc = new Document()
.append("timestamp", entry.getTimestamp()) .append("timestamp", entry.getTimestamp())
@ -159,7 +160,6 @@ public class MongoDao extends AbstractDao {
} }
c.insertOne(doc); c.insertOne(doc);
return true;
} }
@Override @Override
@ -192,7 +192,7 @@ public class MongoDao extends AbstractDao {
} }
@Override @Override
public boolean applyBulkUpdate(BulkUpdate bulkUpdate) { public void applyBulkUpdate(BulkUpdate bulkUpdate) {
if (bulkUpdate.getDataType().isIncludingUsers()) { if (bulkUpdate.getDataType().isIncludingUsers()) {
MongoCollection<Document> c = database.getCollection(prefix + "users"); MongoCollection<Document> c = database.getCollection(prefix + "users");
try (MongoCursor<Document> cursor = c.find().iterator()) { try (MongoCursor<Document> cursor = c.find().iterator()) {
@ -242,11 +242,10 @@ public class MongoDao extends AbstractDao {
} }
} }
} }
return true;
} }
@Override @Override
public boolean loadUser(UUID uuid, String username) { public User loadUser(UUID uuid, String username) {
User user = plugin.getUserManager().getOrMake(UserIdentifier.of(uuid, username)); User user = plugin.getUserManager().getOrMake(UserIdentifier.of(uuid, username));
user.getIoLock().lock(); user.getIoLock().lock();
try { try {
@ -283,18 +282,18 @@ public class MongoDao extends AbstractDao {
user.getIoLock().unlock(); user.getIoLock().unlock();
} }
user.getRefreshBuffer().requestDirectly(); user.getRefreshBuffer().requestDirectly();
return true; return user;
} }
@Override @Override
public boolean saveUser(User user) { public void saveUser(User user) {
user.getIoLock().lock(); user.getIoLock().lock();
try { try {
MongoCollection<Document> c = database.getCollection(prefix + "users"); MongoCollection<Document> c = database.getCollection(prefix + "users");
if (!GenericUserManager.shouldSave(user)) { if (!GenericUserManager.shouldSave(user)) {
return c.deleteOne(new Document("_id", user.getUuid())).wasAcknowledged(); c.deleteOne(new Document("_id", user.getUuid()));
} else { } else {
return c.replaceOne(new Document("_id", user.getUuid()), userToDoc(user), new UpdateOptions().upsert(true)).wasAcknowledged(); c.replaceOne(new Document("_id", user.getUuid()), userToDoc(user), new UpdateOptions().upsert(true));
} }
} finally { } finally {
user.getIoLock().unlock(); user.getIoLock().unlock();
@ -336,7 +335,7 @@ public class MongoDao extends AbstractDao {
} }
@Override @Override
public boolean createAndLoadGroup(String name) { public Group createAndLoadGroup(String name) {
Group group = plugin.getGroupManager().getOrMake(name); Group group = plugin.getGroupManager().getOrMake(name);
group.getIoLock().lock(); group.getIoLock().lock();
try { try {
@ -354,18 +353,25 @@ public class MongoDao extends AbstractDao {
group.getIoLock().unlock(); group.getIoLock().unlock();
} }
group.getRefreshBuffer().requestDirectly(); group.getRefreshBuffer().requestDirectly();
return true; return group;
} }
@Override @Override
public boolean loadGroup(String name) { public Optional<Group> loadGroup(String name) {
Group group = plugin.getGroupManager().getOrMake(name); Group group = plugin.getGroupManager().getIfLoaded(name);
group.getIoLock().lock(); if (group != null) {
group.getIoLock().lock();
}
try { try {
MongoCollection<Document> c = database.getCollection(prefix + "groups"); MongoCollection<Document> c = database.getCollection(prefix + "groups");
try (MongoCursor<Document> cursor = c.find(new Document("_id", group.getName())).iterator()) { try (MongoCursor<Document> cursor = c.find(new Document("_id", name)).iterator()) {
if (!cursor.hasNext()) { if (!cursor.hasNext()) {
return false; return Optional.empty();
}
if (group == null) {
group = plugin.getGroupManager().getOrMake(name);
group.getIoLock().lock();
} }
Document d = cursor.next(); Document d = cursor.next();
@ -373,14 +379,16 @@ public class MongoDao extends AbstractDao {
group.setEnduringNodes(nodes); group.setEnduringNodes(nodes);
} }
} finally { } finally {
group.getIoLock().unlock(); if (group != null) {
group.getIoLock().unlock();
}
} }
group.getRefreshBuffer().requestDirectly(); group.getRefreshBuffer().requestDirectly();
return true; return Optional.of(group);
} }
@Override @Override
public boolean loadAllGroups() { public void loadAllGroups() {
List<String> groups = new ArrayList<>(); List<String> groups = new ArrayList<>();
MongoCollection<Document> c = database.getCollection(prefix + "groups"); MongoCollection<Document> c = database.getCollection(prefix + "groups");
try (MongoCursor<Document> cursor = c.find().iterator()) { try (MongoCursor<Document> cursor = c.find().iterator()) {
@ -408,27 +416,25 @@ public class MongoDao extends AbstractDao {
gm.getAll().values().stream() gm.getAll().values().stream()
.filter(g -> !groups.contains(g.getName())) .filter(g -> !groups.contains(g.getName()))
.forEach(gm::unload); .forEach(gm::unload);
return true;
} }
@Override @Override
public boolean saveGroup(Group group) { public void saveGroup(Group group) {
group.getIoLock().lock(); group.getIoLock().lock();
try { try {
MongoCollection<Document> c = database.getCollection(prefix + "groups"); MongoCollection<Document> c = database.getCollection(prefix + "groups");
return c.replaceOne(new Document("_id", group.getName()), groupToDoc(group), new UpdateOptions().upsert(true)).wasAcknowledged(); c.replaceOne(new Document("_id", group.getName()), groupToDoc(group), new UpdateOptions().upsert(true));
} finally { } finally {
group.getIoLock().unlock(); group.getIoLock().unlock();
} }
} }
@Override @Override
public boolean deleteGroup(Group group) { public void deleteGroup(Group group) {
group.getIoLock().lock(); group.getIoLock().lock();
try { try {
MongoCollection<Document> c = database.getCollection(prefix + "groups"); MongoCollection<Document> c = database.getCollection(prefix + "groups");
return c.deleteOne(new Document("_id", group.getName())).wasAcknowledged(); c.deleteOne(new Document("_id", group.getName()));
} finally { } finally {
group.getIoLock().unlock(); group.getIoLock().unlock();
} }
@ -456,7 +462,7 @@ public class MongoDao extends AbstractDao {
} }
@Override @Override
public boolean createAndLoadTrack(String name) { public Track createAndLoadTrack(String name) {
Track track = plugin.getTrackManager().getOrMake(name); Track track = plugin.getTrackManager().getOrMake(name);
track.getIoLock().lock(); track.getIoLock().lock();
try { try {
@ -473,31 +479,42 @@ public class MongoDao extends AbstractDao {
} finally { } finally {
track.getIoLock().unlock(); track.getIoLock().unlock();
} }
return true; return track;
} }
@Override @Override
public boolean loadTrack(String name) { public Optional<Track> loadTrack(String name) {
Track track = plugin.getTrackManager().getOrMake(name); Track track = plugin.getTrackManager().getIfLoaded(name);
track.getIoLock().lock(); if (track != null) {
track.getIoLock().lock();
}
try { try {
MongoCollection<Document> c = database.getCollection(prefix + "tracks"); MongoCollection<Document> c = database.getCollection(prefix + "tracks");
try (MongoCursor<Document> cursor = c.find(new Document("_id", track.getName())).iterator()) { try (MongoCursor<Document> cursor = c.find(new Document("_id", name)).iterator()) {
if (cursor.hasNext()) { if (!cursor.hasNext()) {
Document d = cursor.next(); return Optional.empty();
//noinspection unchecked
track.setGroups((List<String>) d.get("groups"));
return true;
} }
return false;
if (track == null) {
track = plugin.getTrackManager().getOrMake(name);
track.getIoLock().lock();
}
Document d = cursor.next();
//noinspection unchecked
track.setGroups((List<String>) d.get("groups"));
} }
} finally { } finally {
track.getIoLock().unlock(); if (track != null) {
track.getIoLock().unlock();
}
} }
return Optional.of(track);
} }
@Override @Override
public boolean loadAllTracks() { public void loadAllTracks() {
List<String> tracks = new ArrayList<>(); List<String> tracks = new ArrayList<>();
MongoCollection<Document> c = database.getCollection(prefix + "tracks"); MongoCollection<Document> c = database.getCollection(prefix + "tracks");
try (MongoCursor<Document> cursor = c.find().iterator()) { try (MongoCursor<Document> cursor = c.find().iterator()) {
@ -525,37 +542,34 @@ public class MongoDao extends AbstractDao {
tm.getAll().values().stream() tm.getAll().values().stream()
.filter(t -> !tracks.contains(t.getName())) .filter(t -> !tracks.contains(t.getName()))
.forEach(tm::unload); .forEach(tm::unload);
return true;
} }
@Override @Override
public boolean saveTrack(Track track) { public void saveTrack(Track track) {
track.getIoLock().lock(); track.getIoLock().lock();
try { try {
MongoCollection<Document> c = database.getCollection(prefix + "tracks"); MongoCollection<Document> c = database.getCollection(prefix + "tracks");
return c.replaceOne(new Document("_id", track.getName()), trackToDoc(track)).wasAcknowledged(); c.replaceOne(new Document("_id", track.getName()), trackToDoc(track));
} finally { } finally {
track.getIoLock().unlock(); track.getIoLock().unlock();
} }
} }
@Override @Override
public boolean deleteTrack(Track track) { public void deleteTrack(Track track) {
track.getIoLock().lock(); track.getIoLock().lock();
try { try {
MongoCollection<Document> c = database.getCollection(prefix + "tracks"); MongoCollection<Document> c = database.getCollection(prefix + "tracks");
return c.deleteOne(new Document("_id", track.getName())).wasAcknowledged(); c.deleteOne(new Document("_id", track.getName()));
} finally { } finally {
track.getIoLock().unlock(); track.getIoLock().unlock();
} }
} }
@Override @Override
public boolean saveUUIDData(UUID uuid, String username) { public void saveUUIDData(UUID uuid, String username) {
MongoCollection<Document> c = database.getCollection(prefix + "uuid"); MongoCollection<Document> c = database.getCollection(prefix + "uuid");
c.replaceOne(new Document("_id", uuid), new Document("_id", uuid).append("name", username.toLowerCase()), new UpdateOptions().upsert(true)); c.replaceOne(new Document("_id", uuid), new Document("_id", uuid).append("name", username.toLowerCase()), new UpdateOptions().upsert(true));
return true;
} }
@Override @Override

89
common/src/main/java/me/lucko/luckperms/common/storage/dao/sql/SqlDao.java
View File

@ -69,6 +69,7 @@ import java.util.ArrayList;
import java.util.HashSet; import java.util.HashSet;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.Optional;
import java.util.Set; import java.util.Set;
import java.util.UUID; import java.util.UUID;
import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicBoolean;
@ -228,7 +229,7 @@ public class SqlDao extends AbstractDao {
} }
@Override @Override
public boolean logAction(LogEntry entry) throws SQLException { public void logAction(LogEntry entry) throws SQLException {
try (Connection c = provider.getConnection()) { try (Connection c = provider.getConnection()) {
try (PreparedStatement ps = c.prepareStatement(prefix.apply(ACTION_INSERT))) { try (PreparedStatement ps = c.prepareStatement(prefix.apply(ACTION_INSERT))) {
ps.setLong(1, entry.getTimestamp()); ps.setLong(1, entry.getTimestamp());
@ -239,7 +240,6 @@ public class SqlDao extends AbstractDao {
ps.setString(6, entry.getActedName()); ps.setString(6, entry.getActedName());
ps.setString(7, entry.getAction()); ps.setString(7, entry.getAction());
ps.execute(); ps.execute();
return true;
} }
} }
} }
@ -271,11 +271,10 @@ public class SqlDao extends AbstractDao {
} }
@Override @Override
public boolean applyBulkUpdate(BulkUpdate bulkUpdate) throws SQLException { public void applyBulkUpdate(BulkUpdate bulkUpdate) throws SQLException {
String queryString = bulkUpdate.buildAsSql(); String queryString = bulkUpdate.buildAsSql();
try (Connection c = provider.getConnection()) { try (Connection c = provider.getConnection()) {
if (bulkUpdate.getDataType().isIncludingUsers()) { if (bulkUpdate.getDataType().isIncludingUsers()) {
String table = prefix.apply("{prefix}user_permissions"); String table = prefix.apply("{prefix}user_permissions");
try (Statement s = c.createStatement()) { try (Statement s = c.createStatement()) {
@ -290,11 +289,10 @@ public class SqlDao extends AbstractDao {
} }
} }
} }
return true;
} }
@Override @Override
public boolean loadUser(UUID uuid, String username) throws SQLException { public User loadUser(UUID uuid, String username) throws SQLException {
User user = plugin.getUserManager().getOrMake(UserIdentifier.of(uuid, username)); User user = plugin.getUserManager().getOrMake(UserIdentifier.of(uuid, username));
user.getIoLock().lock(); user.getIoLock().lock();
try { try {
@ -368,11 +366,11 @@ public class SqlDao extends AbstractDao {
user.getIoLock().unlock(); user.getIoLock().unlock();
} }
user.getRefreshBuffer().requestDirectly(); user.getRefreshBuffer().requestDirectly();
return true; return user;
} }
@Override @Override
public boolean saveUser(User user) throws SQLException { public void saveUser(User user) throws SQLException {
user.getIoLock().lock(); user.getIoLock().lock();
try { try {
// Empty data - just delete from the DB. // Empty data - just delete from the DB.
@ -388,7 +386,7 @@ public class SqlDao extends AbstractDao {
ps.execute(); ps.execute();
} }
} }
return true; return;
} }
// Get a snapshot of current data. // Get a snapshot of current data.
@ -482,8 +480,6 @@ public class SqlDao extends AbstractDao {
} }
} }
return true;
} finally { } finally {
user.getIoLock().unlock(); user.getIoLock().unlock();
} }
@ -530,7 +526,7 @@ public class SqlDao extends AbstractDao {
} }
@Override @Override
public boolean createAndLoadGroup(String name) throws SQLException { public Group createAndLoadGroup(String name) throws SQLException {
String query; String query;
switch (provider.getName()) { switch (provider.getName()) {
case "H2": case "H2":
@ -554,11 +550,11 @@ public class SqlDao extends AbstractDao {
} }
} }
return loadGroup(name); return loadGroup(name).get();
} }
@Override @Override
public boolean loadGroup(String name) throws SQLException { public Optional<Group> loadGroup(String name) throws SQLException {
// Check the group actually exists // Check the group actually exists
List<String> groups = new ArrayList<>(); List<String> groups = new ArrayList<>();
try (Connection c = provider.getConnection()) { try (Connection c = provider.getConnection()) {
@ -573,7 +569,7 @@ public class SqlDao extends AbstractDao {
} }
if (!groups.contains(name)) { if (!groups.contains(name)) {
return false; return Optional.empty();
} }
Group group = plugin.getGroupManager().getOrMake(name); Group group = plugin.getGroupManager().getOrMake(name);
@ -609,11 +605,11 @@ public class SqlDao extends AbstractDao {
group.getIoLock().unlock(); group.getIoLock().unlock();
} }
group.getRefreshBuffer().requestDirectly(); group.getRefreshBuffer().requestDirectly();
return true; return Optional.of(group);
} }
@Override @Override
public boolean loadAllGroups() throws SQLException { public void loadAllGroups() throws SQLException {
List<String> groups = new ArrayList<>(); List<String> groups = new ArrayList<>();
try (Connection c = provider.getConnection()) { try (Connection c = provider.getConnection()) {
try (PreparedStatement ps = c.prepareStatement(prefix.apply(GROUP_SELECT_ALL))) { try (PreparedStatement ps = c.prepareStatement(prefix.apply(GROUP_SELECT_ALL))) {
@ -643,12 +639,10 @@ public class SqlDao extends AbstractDao {
gm.getAll().values().stream() gm.getAll().values().stream()
.filter(g -> !groups.contains(g.getName())) .filter(g -> !groups.contains(g.getName()))
.forEach(gm::unload); .forEach(gm::unload);
return true;
} }
@Override @Override
public boolean saveGroup(Group group) throws SQLException { public void saveGroup(Group group) throws SQLException {
group.getIoLock().lock(); group.getIoLock().lock();
try { try {
// Empty data, just delete. // Empty data, just delete.
@ -659,7 +653,7 @@ public class SqlDao extends AbstractDao {
ps.execute(); ps.execute();
} }
} }
return true; return;
} }
// Get a snapshot of current data // Get a snapshot of current data
@ -724,15 +718,13 @@ public class SqlDao extends AbstractDao {
} }
} }
} }
return true;
} finally { } finally {
group.getIoLock().unlock(); group.getIoLock().unlock();
} }
} }
@Override @Override
public boolean deleteGroup(Group group) throws SQLException { public void deleteGroup(Group group) throws SQLException {
group.getIoLock().lock(); group.getIoLock().lock();
try { try {
try (Connection c = provider.getConnection()) { try (Connection c = provider.getConnection()) {
@ -746,10 +738,11 @@ public class SqlDao extends AbstractDao {
ps.execute(); ps.execute();
} }
} }
return true;
} finally { } finally {
group.getIoLock().unlock(); group.getIoLock().unlock();
} }
plugin.getGroupManager().unload(group);
} }
@Override @Override
@ -777,7 +770,7 @@ public class SqlDao extends AbstractDao {
} }
@Override @Override
public boolean createAndLoadTrack(String name) throws SQLException { public Track createAndLoadTrack(String name) throws SQLException {
Track track = plugin.getTrackManager().getOrMake(name); Track track = plugin.getTrackManager().getOrMake(name);
track.getIoLock().lock(); track.getIoLock().lock();
try { try {
@ -799,7 +792,6 @@ public class SqlDao extends AbstractDao {
if (exists.get()) { if (exists.get()) {
// Track exists, let's load. // Track exists, let's load.
track.setGroups(gson.fromJson(groups.get(), LIST_STRING_TYPE)); track.setGroups(gson.fromJson(groups.get(), LIST_STRING_TYPE));
return true;
} else { } else {
String json = gson.toJson(track.getGroups()); String json = gson.toJson(track.getGroups());
try (Connection c = provider.getConnection()) { try (Connection c = provider.getConnection()) {
@ -809,43 +801,52 @@ public class SqlDao extends AbstractDao {
ps.execute(); ps.execute();
} }
} }
return true;
} }
} finally { } finally {
track.getIoLock().unlock(); track.getIoLock().unlock();
} }
return track;
} }
@Override @Override
public boolean loadTrack(String name) throws SQLException { public Optional<Track> loadTrack(String name) throws SQLException {
Track track = plugin.getTrackManager().getOrMake(name); Track track = plugin.getTrackManager().getIfLoaded(name);
track.getIoLock().lock(); if (track != null) {
track.getIoLock().lock();
}
try { try {
AtomicReference<String> groups = new AtomicReference<>(null); AtomicReference<String> groups = new AtomicReference<>(null);
try (Connection c = provider.getConnection()) { try (Connection c = provider.getConnection()) {
try (PreparedStatement ps = c.prepareStatement(prefix.apply(TRACK_SELECT))) { try (PreparedStatement ps = c.prepareStatement(prefix.apply(TRACK_SELECT))) {
ps.setString(1, track.getName()); ps.setString(1, name);
try (ResultSet rs = ps.executeQuery()) { try (ResultSet rs = ps.executeQuery()) {
if (rs.next()) { if (rs.next()) {
groups.set(rs.getString("groups")); groups.set(rs.getString("groups"));
} else { } else {
return false; return Optional.empty();
} }
} }
} }
} }
if (track == null) {
track = plugin.getTrackManager().getOrMake(name);
track.getIoLock().lock();
}
track.setGroups(gson.fromJson(groups.get(), LIST_STRING_TYPE)); track.setGroups(gson.fromJson(groups.get(), LIST_STRING_TYPE));
return true; return Optional.of(track);
} finally { } finally {
track.getIoLock().unlock(); if (track != null) {
track.getIoLock().unlock();
}
} }
} }
@Override @Override
public boolean loadAllTracks() throws SQLException { public void loadAllTracks() throws SQLException {
List<String> tracks = new ArrayList<>(); List<String> tracks = new ArrayList<>();
try (Connection c = provider.getConnection()) { try (Connection c = provider.getConnection()) {
try (PreparedStatement ps = c.prepareStatement(prefix.apply(TRACK_SELECT_ALL))) { try (PreparedStatement ps = c.prepareStatement(prefix.apply(TRACK_SELECT_ALL))) {
@ -875,12 +876,10 @@ public class SqlDao extends AbstractDao {
tm.getAll().values().stream() tm.getAll().values().stream()
.filter(t -> !tracks.contains(t.getName())) .filter(t -> !tracks.contains(t.getName()))
.forEach(tm::unload); .forEach(tm::unload);
return true;
} }
@Override @Override
public boolean saveTrack(Track track) throws SQLException { public void saveTrack(Track track) throws SQLException {
track.getIoLock().lock(); track.getIoLock().lock();
try { try {
String s = gson.toJson(track.getGroups()); String s = gson.toJson(track.getGroups());
@ -891,14 +890,13 @@ public class SqlDao extends AbstractDao {
ps.execute(); ps.execute();
} }
} }
return true;
} finally { } finally {
track.getIoLock().unlock(); track.getIoLock().unlock();
} }
} }
@Override @Override
public boolean deleteTrack(Track track) throws SQLException { public void deleteTrack(Track track) throws SQLException {
track.getIoLock().lock(); track.getIoLock().lock();
try { try {
try (Connection c = provider.getConnection()) { try (Connection c = provider.getConnection()) {
@ -912,11 +910,10 @@ public class SqlDao extends AbstractDao {
} }
plugin.getTrackManager().unload(track); plugin.getTrackManager().unload(track);
return true;
} }
@Override @Override
public boolean saveUUIDData(UUID uuid, String username) throws SQLException { public void saveUUIDData(UUID uuid, String username) throws SQLException {
final String u = username.toLowerCase(); final String u = username.toLowerCase();
AtomicReference<String> remoteUserName = new AtomicReference<>(null); AtomicReference<String> remoteUserName = new AtomicReference<>(null);
@ -943,7 +940,7 @@ public class SqlDao extends AbstractDao {
if (remoteUserName.get() != null) { if (remoteUserName.get() != null) {
// the value is already correct // the value is already correct
if (remoteUserName.get().equals(u)) { if (remoteUserName.get().equals(u)) {
return true; return;
} }
try (Connection c = provider.getConnection()) { try (Connection c = provider.getConnection()) {
@ -953,7 +950,6 @@ public class SqlDao extends AbstractDao {
ps.execute(); ps.execute();
} }
} }
return true;
} else { } else {
// first time we've seen this uuid // first time we've seen this uuid
try (Connection c = provider.getConnection()) { try (Connection c = provider.getConnection()) {
@ -964,7 +960,6 @@ public class SqlDao extends AbstractDao {
ps.execute(); ps.execute();
} }
} }
return true;
} }
} }

20
common/src/main/java/me/lucko/luckperms/common/storage/wrappings/BufferedOutputStorage.java
View File

@ -48,9 +48,9 @@ public class BufferedOutputStorage implements Storage, Runnable {
private final long flushTime; private final long flushTime;
private final Buffer<User, Boolean> userOutputBuffer = Buffer.of(user -> BufferedOutputStorage.this.delegate.saveUser(user).join()); private final Buffer<User, Void> userOutputBuffer = Buffer.of(user -> BufferedOutputStorage.this.delegate.saveUser(user).join());
private final Buffer<Group, Boolean> groupOutputBuffer = Buffer.of(group -> BufferedOutputStorage.this.delegate.saveGroup(group).join()); private final Buffer<Group, Void> groupOutputBuffer = Buffer.of(group -> BufferedOutputStorage.this.delegate.saveGroup(group).join());
private final Buffer<Track, Boolean> trackOutputBuffer = Buffer.of(track -> BufferedOutputStorage.this.delegate.saveTrack(track).join()); private final Buffer<Track, Void> trackOutputBuffer = Buffer.of(track -> BufferedOutputStorage.this.delegate.saveTrack(track).join());
@Override @Override
public void run() { public void run() {
@ -79,25 +79,25 @@ public class BufferedOutputStorage implements Storage, Runnable {
} }
@Override @Override
public CompletableFuture<Boolean> saveUser(User user) { public CompletableFuture<Void> saveUser(User user) {
return userOutputBuffer.enqueue(user); return userOutputBuffer.enqueue(user);
} }
@Override @Override
public CompletableFuture<Boolean> saveGroup(Group group) { public CompletableFuture<Void> saveGroup(Group group) {
return groupOutputBuffer.enqueue(group); return groupOutputBuffer.enqueue(group);
} }
@Override @Override
public CompletableFuture<Boolean> saveTrack(Track track) { public CompletableFuture<Void> saveTrack(Track track) {
return trackOutputBuffer.enqueue(track); return trackOutputBuffer.enqueue(track);
} }
private interface Exclude { private interface Exclude {
Storage noBuffer(); Storage noBuffer();
CompletableFuture<Void> shutdown(); void shutdown();
CompletableFuture<Boolean> saveUser(User user); CompletableFuture<Void> saveUser(User user);
CompletableFuture<Boolean> saveGroup(Group group); CompletableFuture<Void> saveGroup(Group group);
CompletableFuture<Boolean> saveTrack(Track track); CompletableFuture<Void> saveTrack(Track track);
} }
} }

31
common/src/main/java/me/lucko/luckperms/common/storage/wrappings/PhasedStorage.java
View File

@ -42,6 +42,7 @@ import me.lucko.luckperms.common.storage.Storage;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.Optional;
import java.util.Set; import java.util.Set;
import java.util.UUID; import java.util.UUID;
import java.util.concurrent.CompletableFuture; import java.util.concurrent.CompletableFuture;
@ -100,7 +101,7 @@ public class PhasedStorage implements Storage {
} }
@Override @Override
public CompletableFuture<Boolean> logAction(LogEntry entry) { public CompletableFuture<Void> logAction(LogEntry entry) {
phaser.register(); phaser.register();
try { try {
return delegate.logAction(entry); return delegate.logAction(entry);
@ -120,7 +121,7 @@ public class PhasedStorage implements Storage {
} }
@Override @Override
public CompletableFuture<Boolean> applyBulkUpdate(BulkUpdate bulkUpdate) { public CompletableFuture<Void> applyBulkUpdate(BulkUpdate bulkUpdate) {
phaser.register(); phaser.register();
try { try {
return delegate.applyBulkUpdate(bulkUpdate); return delegate.applyBulkUpdate(bulkUpdate);
@ -130,7 +131,7 @@ public class PhasedStorage implements Storage {
} }
@Override @Override
public CompletableFuture<Boolean> loadUser(UUID uuid, String username) { public CompletableFuture<User> loadUser(UUID uuid, String username) {
phaser.register(); phaser.register();
try { try {
return delegate.loadUser(uuid, username); return delegate.loadUser(uuid, username);
@ -140,7 +141,7 @@ public class PhasedStorage implements Storage {
} }
@Override @Override
public CompletableFuture<Boolean> saveUser(User user) { public CompletableFuture<Void> saveUser(User user) {
phaser.register(); phaser.register();
try { try {
return delegate.saveUser(user); return delegate.saveUser(user);
@ -170,7 +171,7 @@ public class PhasedStorage implements Storage {
} }
@Override @Override
public CompletableFuture<Boolean> createAndLoadGroup(String name, CreationCause cause) { public CompletableFuture<Group> createAndLoadGroup(String name, CreationCause cause) {
phaser.register(); phaser.register();
try { try {
return delegate.createAndLoadGroup(name, cause); return delegate.createAndLoadGroup(name, cause);
@ -180,7 +181,7 @@ public class PhasedStorage implements Storage {
} }
@Override @Override
public CompletableFuture<Boolean> loadGroup(String name) { public CompletableFuture<Optional<Group>> loadGroup(String name) {
phaser.register(); phaser.register();
try { try {
return delegate.loadGroup(name); return delegate.loadGroup(name);
@ -190,7 +191,7 @@ public class PhasedStorage implements Storage {
} }
@Override @Override
public CompletableFuture<Boolean> loadAllGroups() { public CompletableFuture<Void> loadAllGroups() {
phaser.register(); phaser.register();
try { try {
return delegate.loadAllGroups(); return delegate.loadAllGroups();
@ -200,7 +201,7 @@ public class PhasedStorage implements Storage {
} }
@Override @Override
public CompletableFuture<Boolean> saveGroup(Group group) { public CompletableFuture<Void> saveGroup(Group group) {
phaser.register(); phaser.register();
try { try {
return delegate.saveGroup(group); return delegate.saveGroup(group);
@ -210,7 +211,7 @@ public class PhasedStorage implements Storage {
} }
@Override @Override
public CompletableFuture<Boolean> deleteGroup(Group group, DeletionCause cause) { public CompletableFuture<Void> deleteGroup(Group group, DeletionCause cause) {
phaser.register(); phaser.register();
try { try {
return delegate.deleteGroup(group, cause); return delegate.deleteGroup(group, cause);
@ -230,7 +231,7 @@ public class PhasedStorage implements Storage {
} }
@Override @Override
public CompletableFuture<Boolean> createAndLoadTrack(String name, CreationCause cause) { public CompletableFuture<Track> createAndLoadTrack(String name, CreationCause cause) {
phaser.register(); phaser.register();
try { try {
return delegate.createAndLoadTrack(name, cause); return delegate.createAndLoadTrack(name, cause);
@ -240,7 +241,7 @@ public class PhasedStorage implements Storage {
} }
@Override @Override
public CompletableFuture<Boolean> loadTrack(String name) { public CompletableFuture<Optional<Track>> loadTrack(String name) {
phaser.register(); phaser.register();
try { try {
return delegate.loadTrack(name); return delegate.loadTrack(name);
@ -250,7 +251,7 @@ public class PhasedStorage implements Storage {
} }
@Override @Override
public CompletableFuture<Boolean> loadAllTracks() { public CompletableFuture<Void> loadAllTracks() {
phaser.register(); phaser.register();
try { try {
return delegate.loadAllTracks(); return delegate.loadAllTracks();
@ -260,7 +261,7 @@ public class PhasedStorage implements Storage {
} }
@Override @Override
public CompletableFuture<Boolean> saveTrack(Track track) { public CompletableFuture<Void> saveTrack(Track track) {
phaser.register(); phaser.register();
try { try {
return delegate.saveTrack(track); return delegate.saveTrack(track);
@ -270,7 +271,7 @@ public class PhasedStorage implements Storage {
} }
@Override @Override
public CompletableFuture<Boolean> deleteTrack(Track track, DeletionCause cause) { public CompletableFuture<Void> deleteTrack(Track track, DeletionCause cause) {
phaser.register(); phaser.register();
try { try {
return delegate.deleteTrack(track, cause); return delegate.deleteTrack(track, cause);
@ -280,7 +281,7 @@ public class PhasedStorage implements Storage {
} }
@Override @Override
public CompletableFuture<Boolean> saveUUIDData(UUID uuid, String username) { public CompletableFuture<Void> saveUUIDData(UUID uuid, String username) {
phaser.register(); phaser.register();
try { try {
return delegate.saveUUIDData(uuid, username); return delegate.saveUUIDData(uuid, username);

9
common/src/main/java/me/lucko/luckperms/common/utils/LoginHelper.java
View File

@ -53,7 +53,7 @@ public class LoginHelper {
// No previous data for this player // No previous data for this player
plugin.getApiProvider().getEventFactory().handleUserFirstLogin(u, username); plugin.getApiProvider().getEventFactory().handleUserFirstLogin(u, username);
cache.addToCache(u, u); cache.addToCache(u, u);
CompletableFuture<Boolean> future = plugin.getStorage().noBuffer().saveUUIDData(u, username); CompletableFuture<Void> future = plugin.getStorage().noBuffer().saveUUIDData(u, username);
if (joinUuidSave) { if (joinUuidSave) {
future.join(); future.join();
} }
@ -65,16 +65,15 @@ public class LoginHelper {
} }
// Online mode, no cache needed. This is just for name -> uuid lookup. // Online mode, no cache needed. This is just for name -> uuid lookup.
CompletableFuture<Boolean> future = plugin.getStorage().noBuffer().saveUUIDData(u, username); CompletableFuture<Void> future = plugin.getStorage().noBuffer().saveUUIDData(u, username);
if (joinUuidSave) { if (joinUuidSave) {
future.join(); future.join();
} }
} }
plugin.getStorage().noBuffer().loadUser(cache.getUUID(u), username).join(); User user = plugin.getStorage().noBuffer().loadUser(cache.getUUID(u), username).join();
User user = plugin.getUserManager().getIfLoaded(cache.getUUID(u));
if (user == null) { if (user == null) {
throw new RuntimeException("Failed to load user"); throw new NullPointerException("User is null");
} else { } else {
// Setup defaults for the user // Setup defaults for the user
boolean save = false; boolean save = false;

20
sponge/src/main/java/me/lucko/luckperms/sponge/service/LuckPermsSubjectData.java
View File

@ -450,22 +450,26 @@ public class LuckPermsSubjectData implements LPSubjectData {
} else { } else {
if (t.getType().isUser()) { if (t.getType().isUser()) {
User user = ((User) t); User user = ((User) t);
return service.getPlugin().getStorage().saveUser(user).thenComposeAsync(success -> { CompletableFuture<Void> fut = new CompletableFuture<>();
if (!success) { service.getPlugin().getStorage().saveUser(user).whenCompleteAsync((v, ex) -> {
return CompletableFuture.completedFuture(null); if (ex != null) {
fut.complete(null);
} }
return user.getRefreshBuffer().request(); user.getRefreshBuffer().request().thenAccept(fut::complete);
}, service.getPlugin().getScheduler().async()); }, service.getPlugin().getScheduler().async());
return fut;
} else { } else {
Group group = ((Group) t); Group group = ((Group) t);
return service.getPlugin().getStorage().saveGroup(group).thenComposeAsync(success -> { CompletableFuture<Void> fut = new CompletableFuture<>();
if (!success) { service.getPlugin().getStorage().saveGroup(group).whenCompleteAsync((v, ex) -> {
return CompletableFuture.completedFuture(null); if (ex != null) {
fut.complete(null);
} }
return service.getPlugin().getUpdateTaskBuffer().request(); service.getPlugin().getUpdateTaskBuffer().request().thenAccept(fut::complete);
}, service.getPlugin().getScheduler().async()); }, service.getPlugin().getScheduler().async());
return fut;
} }
} }
} }