Merge pull request #317 from BenCodez/codex/async-reward-injections

Add ordered async reward injection support

Author: BenCodez

AdvancedCore/pom.xml

@@ -91,7 +91,7 @@
                 <version>3.6.1</version>
                 <configuration>
                     <shadedArtifactAttached>false</shadedArtifactAttached>
-                    <minimizeJar>true</minimizeJar>
+                    <minimizeJar>false</minimizeJar>
                 </configuration>
                 <executions>
                     <execution>

AdvancedCore/src/main/java/com/bencodez/advancedcore/api/item/FullInventoryHandler.java

@@ -19,7 +19,12 @@
 import java.util.List;
 import java.util.Map.Entry;
 import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
 import java.util.concurrent.ThreadLocalRandom;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.regex.Pattern;
 
 import org.bukkit.Bukkit;
@@ -38,6 +43,7 @@
 import org.bukkit.potion.PotionEffectType;
 
 import com.bencodez.advancedcore.AdvancedCorePlugin;
+import com.bencodez.advancedcore.api.rewards.Reward;
 import com.bencodez.advancedcore.api.item.ItemBuilder;
 import com.bencodez.advancedcore.api.messages.PlaceholderUtils;
 import com.bencodez.advancedcore.api.user.AdvancedCoreUser;
@@ -237,28 +243,64 @@ public void executeConsoleCommands(final String playerName, final ArrayList<Stri
 	}
 
 	public void executeConsoleCommands(String playerName, String command, HashMap<String, String> placeholders) {
-		if (command != null && !command.isEmpty()) {
-			OfflinePlayer p = Bukkit.getOfflinePlayer(playerName);
-			if (p != null) {
-				command = PlaceholderUtils.replaceJavascriptOnly(p, command);
-			}
-			command = PlaceholderUtils.replacePlaceHolder(command, placeholders);
-			if (p != null) {
-				command = PlaceholderUtils.replacePlaceHolders(p, command);
-			}
-			final String cmd = stripLeadingSlash(command);
-
-			plugin.debug("Executing console command: " + command);
-			plugin.getBukkitScheduler().executeOrScheduleSync(plugin, new Runnable() {
-
-				@Override
-				public void run() {
-					Bukkit.getServer().dispatchCommand(Bukkit.getConsoleSender(), cmd);
-				}
+		executeConsoleCommandsAsync(playerName, command, placeholders);
+	}
 
-			});
+	/**
+	 * Schedules one console command and completes only after Bukkit has dispatched
+	 * it. Async reward replay uses this completion boundary so it never records a
+	 * durable checkpoint ahead of a queued command.
+	 */
+	public CompletionStage<Void> executeConsoleCommandsAsync(String playerName, String command,
+			HashMap<String, String> placeholders) {
+		try {
+			ArrayList<String> templates = command == null || command.isEmpty()
+					? new ArrayList<>() : new ArrayList<>(java.util.List.of(command));
+			String expanded = command;
+			OfflinePlayer p = Bukkit.getOfflinePlayer(playerName);
+			if (expanded != null && !expanded.isEmpty()) {
+				if (p != null) expanded = PlaceholderUtils.replaceJavascriptOnly(p, expanded);
+				expanded = PlaceholderUtils.replacePlaceHolder(expanded, placeholders);
+				if (p != null) expanded = PlaceholderUtils.replacePlaceHolders(p, expanded);
+			}
+			ArrayList<String> commands = command == null || command.isEmpty()
+					? new ArrayList<>() : new ArrayList<>(java.util.List.of(expanded == null ? "" : expanded));
+			return Reward.replayCommandSequence(plugin, placeholders, "console", templates, commands,
+					(cmd, ignoredIndex) -> {
+						plugin.debug("Executing console command: " + cmd);
+						return runConsoleCommandAsync(stripLeadingSlash(cmd), 0, false, false);
+					});
+		} catch (Throwable failure) {
+			return CompletableFuture.failedFuture(failure);
 		}
+	}
 
+	/**
+	 * Schedules every console command using the legacy stagger timing and completes
+	 * only after every dispatch has run. This keeps an async reward injector from
+	 * checkpointing a command list while any member is still queued.
+	 */
+	@SuppressWarnings("deprecation")
+	public CompletionStage<Void> executeConsoleCommandsAsync(final String playerName, final ArrayList<String> cmds,
+			final HashMap<String, String> placeholders, final boolean stagger) {
+		try {
+			placeholders.put("player", playerName);
+			OfflinePlayer p = Bukkit.getOfflinePlayer(playerName);
+			ArrayList<String> templates = cmds == null ? new ArrayList<>() : new ArrayList<>(cmds);
+			ArrayList<String> commands = new ArrayList<>(templates);
+			if (p != null) commands = PlaceholderUtils.replaceJavascriptOnly(p, commands);
+			commands = PlaceholderUtils.replacePlaceHolder(commands, placeholders);
+			if (p != null) commands = PlaceholderUtils.replacePlaceHolders(p, commands);
+
+			return Reward.replayCommandSequence(plugin, placeholders, "console", templates, commands,
+					(command, index) -> {
+						plugin.debug("Executing console command: " + command);
+						return runConsoleCommandAsync(stripLeadingSlash(command), index > 0 ? 1 : 0,
+								stagger && index > 0, stagger || index == 0);
+					});
+		} catch (Throwable failure) {
+			return CompletableFuture.failedFuture(failure);
+		}
 	}
 
 	public Object getBlockMeta(Block block, String str) {
@@ -466,6 +508,42 @@ private void runConsoleCommand(String command, int delay, boolean hasDelay) {
 		consoleCommands.dispatch(command, delay, hasDelay);
 	}
 
+	/**
+	 * Schedules one command with a completion boundary. The timeout claims the
+	 * runnable before it can execute, so a task delayed past shutdown cannot run
+	 * after a failed replay has already been retried.
+	 */
+	private CompletionStage<Void> runConsoleCommandAsync(String command, int delay, boolean hasDelay,
+			boolean scheduleAsTask) {
+		CompletableFuture<Void> completion = new CompletableFuture<>();
+		AtomicBoolean claimed = new AtomicBoolean();
+		Runnable dispatch = () -> {
+			if (!claimed.compareAndSet(false, true)) return;
+			try {
+				Bukkit.getServer().dispatchCommand(Bukkit.getConsoleSender(), command);
+				completion.complete(null);
+			} catch (Throwable failure) {
+				completion.completeExceptionally(failure);
+			}
+		};
+		try {
+			if (hasDelay && delay > 0) plugin.getBukkitScheduler().runTaskLater(plugin, dispatch, delay);
+			else if (scheduleAsTask) plugin.getBukkitScheduler().runTask(plugin, dispatch);
+			else plugin.getBukkitScheduler().executeOrScheduleSync(plugin, dispatch);
+		} catch (Throwable failure) {
+			claimed.set(true);
+			completion.completeExceptionally(failure);
+			return completion;
+		}
+		long timeoutSeconds = 30L + Math.max(0, delay);
+		CompletableFuture.delayedExecutor(timeoutSeconds, TimeUnit.SECONDS).execute(() -> {
+			if (claimed.compareAndSet(false, true)) {
+				completion.completeExceptionally(new TimeoutException("Timed out waiting for scheduled console command"));
+			}
+		});
+		return completion;
+	}
+
 	private String stripLeadingSlash(String command) {
 		if (command != null && command.startsWith("/")) {
 			return command.substring(1);

AdvancedCore/src/main/java/com/bencodez/advancedcore/api/misc/MiscUtils.java

@@ -23,14 +23,25 @@ public final class QueuedGeneratedReward extends Reward {
 
 	@Override
 	public void giveReward(AdvancedCoreUser user, RewardOptions rewardOptions) {
-		if (user == null || user.getUUID() == null || !allowedUserUuids.contains(user.getUUID())) {
-			plugin.getLogger().warning("Blocked generated queued reward " + getRewardName()
-					+ " for a user without a matching persisted queue entry");
-			return;
-		}
+		if (!isAllowed(user)) return;
 		super.giveReward(user, rewardOptions);
 	}
 
+	@Override
+	public java.util.concurrent.CompletionStage<Void> giveRewardAsync(AdvancedCoreUser user,
+			RewardOptions rewardOptions) {
+		if (!isAllowed(user)) return java.util.concurrent.CompletableFuture.failedFuture(
+				new IllegalStateException("Generated queued reward is not authorized for this user"));
+		return super.giveRewardAsync(user, rewardOptions);
+	}
+
+	private boolean isAllowed(AdvancedCoreUser user) {
+		if (user != null && user.getUUID() != null && allowedUserUuids.contains(user.getUUID())) return true;
+		plugin.getLogger().warning("Blocked generated queued reward " + getRewardName()
+				+ " for a user without a matching persisted queue entry");
+		return false;
+	}
+
 	@Override
 	public boolean isGeneratedSnapshotCreated() {
 		// A loaded generated snapshot must retain snapshot provenance if execution is