136 lines
6 KiB
Java
136 lines
6 KiB
Java
package dev.loki.loparkour.scheduler;
|
|
|
|
import java.lang.reflect.InvocationTargetException;
|
|
import java.lang.reflect.Method;
|
|
import java.util.Objects;
|
|
import java.util.function.Consumer;
|
|
import org.bukkit.Bukkit;
|
|
import org.bukkit.plugin.Plugin;
|
|
|
|
/**
|
|
* Scheduler backend for Folia servers: the global region scheduler drives sync tasks
|
|
* and the async scheduler drives worker tasks, mirroring the Bukkit semantics above.
|
|
*
|
|
* <p>The Folia API is resolved reflectively because the build matrix compiles against
|
|
* Spigot/Paper API artifacts that do not ship it (see TODO, Задача 1 / п.143).
|
|
*/
|
|
final class FoliaBackend implements Scheduler.Backend {
|
|
|
|
private static final String SCHEDULER_PACKAGE = "io.papermc.paper.threadedregions.scheduler.";
|
|
|
|
private static final String GLOBAL_SCHEDULER_CLASS = "GlobalRegionScheduler";
|
|
private static final String ASYNC_SCHEDULER_CLASS = "AsyncScheduler";
|
|
private static final String REGION_SCHEDULER_CLASS = "RegionScheduler";
|
|
|
|
private final Plugin plugin;
|
|
private final Object globalScheduler;
|
|
private final Object asyncScheduler;
|
|
private final Object regionScheduler;
|
|
private final Method globalRun;
|
|
private final Method globalRunDelayed;
|
|
private final Method globalRunAtFixedRate;
|
|
private final Method asyncRunNow;
|
|
private final Method asyncRunAtFixedRate;
|
|
private final Method regionRunDelayed;
|
|
private final Method regionRunAtFixedRate;
|
|
private final Method entityExecute;
|
|
private final Method taskCancel;
|
|
|
|
FoliaBackend(Plugin plugin) throws ReflectiveOperationException {
|
|
this.plugin = plugin;
|
|
this.globalScheduler = scheduler("getGlobalRegionScheduler");
|
|
this.asyncScheduler = scheduler("getAsyncScheduler");
|
|
this.regionScheduler = scheduler("getRegionScheduler");
|
|
this.globalRun = method(GLOBAL_SCHEDULER_CLASS, "run", Plugin.class, Consumer.class);
|
|
this.globalRunDelayed = method(GLOBAL_SCHEDULER_CLASS, "runDelayed",
|
|
Plugin.class, Consumer.class, long.class);
|
|
this.globalRunAtFixedRate = method(GLOBAL_SCHEDULER_CLASS, "runAtFixedRate",
|
|
Plugin.class, Consumer.class, long.class, long.class);
|
|
this.asyncRunNow = method(ASYNC_SCHEDULER_CLASS, "runNow", Plugin.class, Consumer.class);
|
|
this.asyncRunAtFixedRate = method(ASYNC_SCHEDULER_CLASS, "runAtFixedRate",
|
|
Plugin.class, Consumer.class, long.class, long.class);
|
|
this.regionRunDelayed = method(REGION_SCHEDULER_CLASS, "runDelayed",
|
|
Plugin.class, org.bukkit.Location.class, Consumer.class, long.class);
|
|
this.regionRunAtFixedRate = method(REGION_SCHEDULER_CLASS, "runAtFixedRate",
|
|
Plugin.class, org.bukkit.Location.class, Consumer.class, long.class, long.class);
|
|
this.entityExecute = Class.forName(SCHEDULER_PACKAGE + "EntityScheduler")
|
|
.getMethod("execute", Plugin.class, Runnable.class);
|
|
this.taskCancel = Class.forName(SCHEDULER_PACKAGE + "ScheduledTask").getMethod("cancel");
|
|
}
|
|
|
|
@Override
|
|
public ScheduledTask run(Runnable task) {
|
|
return wrap(invoke(globalRun, globalScheduler, plugin, consumer(task)));
|
|
}
|
|
|
|
@Override
|
|
public ScheduledTask runAsync(Runnable task) {
|
|
return wrap(invoke(asyncRunNow, asyncScheduler, plugin, consumer(task)));
|
|
}
|
|
|
|
@Override
|
|
public ScheduledTask runLater(Runnable task, long delayTicks) {
|
|
return wrap(invoke(globalRunDelayed, globalScheduler, plugin, consumer(task), delayTicks));
|
|
}
|
|
|
|
@Override
|
|
public ScheduledTask runTimer(Runnable task, long delayTicks, long periodTicks) {
|
|
return wrap(invoke(globalRunAtFixedRate, globalScheduler, plugin,
|
|
consumer(task), delayTicks, periodTicks));
|
|
}
|
|
|
|
@Override
|
|
public ScheduledTask runTimerAtLocation(Runnable task, org.bukkit.Location location,
|
|
long delayTicks, long periodTicks) {
|
|
return wrap(invoke(regionRunAtFixedRate, regionScheduler, plugin, location,
|
|
consumer(task), delayTicks, periodTicks));
|
|
}
|
|
|
|
@Override
|
|
public ScheduledTask runAtLocation(Runnable task, org.bukkit.Location location, long delayTicks) {
|
|
return wrap(invoke(regionRunDelayed, regionScheduler, plugin, location,
|
|
consumer(task), delayTicks));
|
|
}
|
|
|
|
@Override
|
|
public ScheduledTask runAtEntity(Runnable task, org.bukkit.entity.Entity entity) {
|
|
try {
|
|
final Object entityScheduler = entity.getClass().getMethod("getScheduler").invoke(entity);
|
|
return wrap(invoke(entityExecute, entityScheduler, plugin, task));
|
|
} catch (ReflectiveOperationException | IllegalArgumentException cause) {
|
|
throw new IllegalStateException("Folia entity scheduler call failed", cause);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public ScheduledTask runTimerAsync(Runnable task, long delayTicks, long periodTicks) {
|
|
return wrap(invoke(asyncRunAtFixedRate, asyncScheduler, plugin,
|
|
consumer(task), delayTicks, periodTicks));
|
|
}
|
|
|
|
private static Object scheduler(String bukkitGetter) throws ReflectiveOperationException {
|
|
return Bukkit.class.getMethod(bukkitGetter).invoke(null);
|
|
}
|
|
|
|
private static Method method(String owner, String name, Class<?>... params)
|
|
throws ReflectiveOperationException {
|
|
return Class.forName(SCHEDULER_PACKAGE + owner).getMethod(name, params);
|
|
}
|
|
|
|
private static Consumer<Object> consumer(Runnable task) {
|
|
return ignored -> task.run();
|
|
}
|
|
|
|
private static Object invoke(Method method, Object target, Object... args) {
|
|
try {
|
|
return method.invoke(target, args);
|
|
} catch (IllegalAccessException | InvocationTargetException cause) {
|
|
throw new IllegalStateException("Folia scheduler call failed: " + method.getName(), cause);
|
|
}
|
|
}
|
|
|
|
private ScheduledTask wrap(Object foliaTask) {
|
|
final Object handle = Objects.requireNonNull(foliaTask, "Folia scheduler returned no task");
|
|
return () -> invoke(taskCancel, handle);
|
|
}
|
|
}
|