diff --git a/SimpleAPI/src/main/java/com/bencodez/simpleapi/metrics/BStatsMetrics.java b/SimpleAPI/src/main/java/com/bencodez/simpleapi/metrics/BStatsMetrics.java index bbe3860b..3e29c680 100644 --- a/SimpleAPI/src/main/java/com/bencodez/simpleapi/metrics/BStatsMetrics.java +++ b/SimpleAPI/src/main/java/com/bencodez/simpleapi/metrics/BStatsMetrics.java @@ -17,8 +17,9 @@ import java.util.Set; import java.util.UUID; import java.util.concurrent.Callable; -import java.util.concurrent.Executors; +import java.util.concurrent.RejectedExecutionException; import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.ScheduledThreadPoolExecutor; import java.util.concurrent.TimeUnit; import java.util.function.BiConsumer; import java.util.function.Consumer; @@ -32,7 +33,13 @@ import org.bukkit.Bukkit; import org.bukkit.configuration.file.YamlConfiguration; import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.EventPriority; +import org.bukkit.event.HandlerList; +import org.bukkit.event.Listener; +import org.bukkit.event.server.PluginDisableEvent; import org.bukkit.plugin.Plugin; +import org.bukkit.plugin.RegisteredListener; import org.bukkit.plugin.java.JavaPlugin; public class BStatsMetrics { @@ -408,8 +415,7 @@ public static class MetricsBase { private static final String REPORT_URL = "https://bStats.org/api/v2/data/%s"; - private static final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1, - task -> new Thread(task, "bStats-Metrics")); + private final ScheduledExecutorService scheduler; /** * Gzips the given string. @@ -504,11 +510,29 @@ public MetricsBase(String platform, String serverUuid, int serviceId, boolean en this.logSentData = logSentData; this.logResponseStatusText = logResponseStatusText; checkRelocation(); + // Each service owns its reporting lifetime; retiring one must not stop siblings. + ScheduledThreadPoolExecutor scheduler = new ScheduledThreadPoolExecutor(1, + task -> new Thread(task, "bStats-Metrics")); + // Do not retain a retired owner until its delayed initial report becomes due. + scheduler.setExecuteExistingDelayedTasksAfterShutdownPolicy(false); + this.scheduler = scheduler; if (enabled) { - startSubmitting(); + try { + startSubmitting(); + } catch (RuntimeException | Error failure) { + scheduler.shutdownNow(); + throw failure; + } + } else { + scheduler.shutdown(); } } + /** Permanently retires this owner without affecting other metrics instances. */ + public void shutdown() { + scheduler.shutdown(); + } + public void addCustomChart(CustomChart chart) { this.customCharts.add(chart); } @@ -576,7 +600,15 @@ private void startSubmitting() { return; } if (submitTaskConsumer != null) { - submitTaskConsumer.accept(this::submitData); + try { + submitTaskConsumer.accept(this::submitData); + } catch (RuntimeException rejection) { + // A platform may reject work as its owner disables. Otherwise keep + // the periodic check alive so a later handoff can recover. + if (!checkServiceEnabledSupplier.get()) { + shutdown(); + } + } } else { this.submitData(); } @@ -600,6 +632,10 @@ private void startSubmitting() { } private void submitData() { + // A platform handoff may run after this owner's scheduled callback retired it. + if (scheduler.isShutdown() || !enabled || !checkServiceEnabledSupplier.get()) { + return; + } final JsonObjectBuilder baseJsonBuilder = new JsonObjectBuilder(); appendPlatformDataConsumer.accept(baseJsonBuilder); final JsonObjectBuilder serviceJsonBuilder = new JsonObjectBuilder(); @@ -613,17 +649,22 @@ private void submitData() { baseJsonBuilder.appendField("serverUUID", serverUuid); baseJsonBuilder.appendField("metricsVersion", METRICS_VERSION); JsonObjectBuilder.JsonObject data = baseJsonBuilder.build(); - scheduler.execute(() -> { - try { - // Send the data - sendData(data); - } catch (Exception e) { - // Something went wrong! :( - if (logErrors) { - errorLogger.accept("Could not submit bStats metrics data", e); + try { + scheduler.execute(() -> { + try { + // Send the data + sendData(data); + } catch (Exception e) { + // Something went wrong! :( + if (logErrors) { + errorLogger.accept("Could not submit bStats metrics data", e); + } } - } - }); + }); + } catch (RejectedExecutionException rejected) { + // Retirement can race a previously accepted platform collection callback. + if (!scheduler.isShutdown()) throw rejected; + } } } @@ -799,6 +840,37 @@ public BStatsMetrics(JavaPlugin plugin, int serviceId) { plugin::isEnabled, (message, error) -> this.plugin.getLogger().log(Level.WARNING, message, error), (message) -> this.plugin.getLogger().log(Level.INFO, message), logErrors, logSentData, logResponseStatusText); + if (enabled) { + try { + MetricsLifecycle lifecycle = new MetricsLifecycle(plugin, metricsBase); + // HandlerList supports registration before enable. PluginManager's + // registerEvents rejects onLoad callers; dispatch still belongs to Bukkit. + PluginDisableEvent.getHandlerList().register(new RegisteredListener(lifecycle, + (listener, event) -> lifecycle.onDisable((PluginDisableEvent) event), + EventPriority.MONITOR, plugin, false)); + } catch (RuntimeException | Error failure) { + metricsBase.shutdown(); + throw failure; + } + } + } + + private static final class MetricsLifecycle implements Listener { + private final Plugin owner; + private final MetricsBase metrics; + + private MetricsLifecycle(Plugin owner, MetricsBase metrics) { + this.owner = owner; + this.metrics = metrics; + } + + @EventHandler + public void onDisable(PluginDisableEvent event) { + if (event.getPlugin() == owner) { + metrics.shutdown(); + HandlerList.unregisterAll(this); + } + } } /** diff --git a/SimpleAPI/src/test/java/com/bencodez/simpleapi/tests/metrics/BStatsMetricsLifecycleTest.java b/SimpleAPI/src/test/java/com/bencodez/simpleapi/tests/metrics/BStatsMetricsLifecycleTest.java new file mode 100644 index 00000000..55b6349d --- /dev/null +++ b/SimpleAPI/src/test/java/com/bencodez/simpleapi/tests/metrics/BStatsMetricsLifecycleTest.java @@ -0,0 +1,323 @@ +package com.bencodez.simpleapi.tests.metrics; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.ArgumentMatchers.*; +import static org.mockito.Mockito.*; + +import java.lang.reflect.InvocationTargetException; +import java.net.URLClassLoader; +import java.util.ArrayList; +import java.util.Collections; +import java.util.IdentityHashMap; +import java.util.List; +import java.util.Set; +import java.util.concurrent.RunnableScheduledFuture; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.Executors; +import java.util.concurrent.RejectedExecutionException; +import java.util.concurrent.ScheduledThreadPoolExecutor; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicBoolean; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.function.BiConsumer; +import java.util.function.Consumer; +import java.util.function.Supplier; + +import org.junit.jupiter.api.Test; + +import com.bencodez.simpleapi.metrics.BStatsMetrics; + +class BStatsMetricsLifecycleTest { + @Test void disablingOneOwnerDoesNotRetireEnabledSiblingOrPreventLaterStartup() throws Exception { + try (var fixture = new Fixture()) { + var firstEnabled = new AtomicBoolean(true); + var first = fixture.owner(true, firstEnabled::get); + var sibling = fixture.owner(true, () -> true); + first.tick(); + sibling.tick(); + assertEquals(1, first.handoffs.size()); + assertEquals(1, sibling.handoffs.size()); + firstEnabled.set(false); + first.periodicTick(); + assertTrue(first.scheduler.isShutdown()); + assertFalse(sibling.scheduler.isShutdown(), "Disabled owner retired its enabled sibling"); + assertEquals("accepted", sibling.scheduler.submit(() -> "accepted").get(5, TimeUnit.SECONDS)); + sibling.periodicTick(); + assertEquals(2, sibling.handoffs.size()); + var replacement = fixture.owner(true, () -> true); + replacement.tick(); + assertEquals(1, replacement.handoffs.size()); + assertNotSame(first.scheduler, replacement.scheduler); + } + } + + @Test void disabledAtStartupSchedulesNoWorkAndDoesNotDisableAnotherOwner() throws Exception { + try (var fixture = new Fixture()) { + var disabled = fixture.owner(false, () -> true); + assertTrue(disabled.commands.isEmpty()); + assertEquals(0, disabled.scheduler.getPoolSize()); + var enabled = fixture.owner(true, () -> true); + enabled.tick(); + assertEquals(1, enabled.handoffs.size()); + } + } + + @Test void retirementCancelsRemainingDelaysAndTerminatesWithoutWaitingForReportingInterval() throws Exception { + try (var fixture = new Fixture()) { + var enabled = new AtomicBoolean(true); + var owner = fixture.owner(true, enabled::get); + enabled.set(false); + owner.periodicTick(); + assertTrue(owner.scheduler.isShutdown()); + assertTrue(owner.scheduler.awaitTermination(5, TimeUnit.SECONDS), "Retired metrics thread stayed alive"); + assertTrue(owner.scheduler.getQueue().isEmpty()); + assertTrue(owner.handoffs.isEmpty()); + var next = fixture.owner(true, () -> true); + next.tick(); + assertEquals(1, next.handoffs.size()); + } + } + + @Test void handoffAcceptedBeforeDisableCannotCollectOrRejectAfterRetirement() throws Exception { + try (var fixture = new Fixture()) { + var enabled = new AtomicBoolean(true); + var owner = fixture.owner(true, enabled::get); + owner.tick(); + Runnable accepted = owner.handoffs.getFirst(); + enabled.set(false); + owner.periodicTick(); + assertDoesNotThrow(accepted::run); + assertEquals(0, owner.collections.get()); + } + } + + @Test void retirementRacingCollectionDoesNotLeakExecutorRejection() throws Exception { + var entered = new CountDownLatch(1); + var release = new CountDownLatch(1); + var firstCollection = new AtomicBoolean(true); + var worker = Executors.newSingleThreadExecutor(); + try (var fixture = new Fixture()) { + var enabled = new AtomicBoolean(true); + var owner = fixture.owner(true, enabled::get, () -> { + if (firstCollection.compareAndSet(true, false)) { + entered.countDown(); + try { assertTrue(release.await(5, TimeUnit.SECONDS)); } + catch (InterruptedException interrupted) { + Thread.currentThread().interrupt(); + throw new AssertionError(interrupted); + } + } + }); + owner.tick(); + var collection = worker.submit(owner.handoffs.getFirst()); + try { + assertTrue(entered.await(5, TimeUnit.SECONDS)); + enabled.set(false); + owner.periodicTick(); + } finally { release.countDown(); } + assertDoesNotThrow(() -> collection.get(5, TimeUnit.SECONDS)); + assertTrue(owner.scheduler.isShutdown()); + } finally { + release.countDown(); + worker.shutdownNow(); + assertTrue(worker.awaitTermination(5, TimeUnit.SECONDS)); + } + } + + @Test void partialStartupReleasesItsExecutorAndPreservesFailure() throws Exception { + try (var fixture = new Fixture(); var construction = mockConstruction(ScheduledThreadPoolExecutor.class, + (scheduler, context) -> when(scheduler.scheduleAtFixedRate(any(Runnable.class), anyLong(), + anyLong(), any(TimeUnit.class))).thenThrow(new RejectedExecutionException("synthetic rejection")))) { + var failure = assertThrows(AssertionError.class, () -> fixture.owner(true, () -> true)); + assertInstanceOf(RejectedExecutionException.class, failure.getCause()); + assertEquals(1, construction.constructed().size()); + verify(construction.constructed().getFirst()).shutdownNow(); + } + } + + @Test void rejectedHandoffRetiresDisabledOwnerButAllowsEnabledOwnerToRetry() throws Exception { + try (var fixture = new Fixture()) { + var enabled = new AtomicBoolean(true); + var reject = new AtomicBoolean(true); + var owner = fixture.owner(true, enabled::get, () -> { }, task -> { + if (reject.get()) throw new RejectedExecutionException("synthetic handoff rejection"); + }); + owner.periodicTick(); + assertFalse(owner.scheduler.isShutdown()); + reject.set(false); + owner.periodicTick(); + var duringHandoff = new AtomicBoolean(true); + var retiring = fixture.owner(true, duringHandoff::get, () -> { }, task -> { + duringHandoff.set(false); + throw new RejectedExecutionException("synthetic disable rejection"); + }); + retiring.periodicTick(); + assertTrue(retiring.scheduler.awaitTermination(5, TimeUnit.SECONDS)); + assertFalse(owner.scheduler.isShutdown()); + } + } + + @Test void explicitRetirementSurvivesSameOwnerReenable() throws Exception { + try (var fixture = new Fixture()) { + var enabled = new AtomicBoolean(true); + var old = fixture.owner(true, enabled::get); + old.tick(); + enabled.set(false); + fixture.type.getMethod("shutdown").invoke(old.instance); + enabled.set(true); + var replacement = fixture.owner(true, enabled::get); + replacement.tick(); + old.handoffs.getFirst().run(); + assertEquals(0, old.collections.get()); + assertTrue(old.scheduler.awaitTermination(5, TimeUnit.SECONDS)); + assertFalse(replacement.scheduler.isShutdown()); + } + } + + @Test void bukkitDisableListenerRetiresOnlyItsOwnerAndUnregisters() throws Exception { + var plugin = mock(org.bukkit.plugin.Plugin.class); + var sibling = mock(org.bukkit.plugin.Plugin.class); + var metrics = mock(BStatsMetrics.MetricsBase.class); + var type = Class.forName(BStatsMetrics.class.getName() + "$MetricsLifecycle"); + var constructor = type.getDeclaredConstructor(org.bukkit.plugin.Plugin.class, BStatsMetrics.MetricsBase.class); + constructor.setAccessible(true); + var listener = (org.bukkit.event.Listener) constructor.newInstance(plugin, metrics); + var callback = type.getDeclaredMethod("onDisable", org.bukkit.event.server.PluginDisableEvent.class); + callback.setAccessible(true); + try (var handlers = mockStatic(org.bukkit.event.HandlerList.class)) { + callback.invoke(listener, new org.bukkit.event.server.PluginDisableEvent(sibling)); + verifyNoInteractions(metrics); + handlers.verifyNoInteractions(); + callback.invoke(listener, new org.bukkit.event.server.PluginDisableEvent(plugin)); + verify(metrics).shutdown(); + handlers.verify(() -> org.bukkit.event.HandlerList.unregisterAll(listener)); + } + } + + @Test void constructorPreservesOptOutBeforePluginEnable(@org.junit.jupiter.api.io.TempDir java.nio.file.Path root) throws Exception { + var plugin = constructorPlugin(root, false); + try (var events = mockStatic(org.bukkit.event.server.PluginDisableEvent.class)) { + assertDoesNotThrow(() -> new BStatsMetrics(plugin, 1)); + events.verifyNoInteractions(); + } + } + + @Test void constructorBeforeEnableRegistersAndDisableRetiresOldOwnerAcrossReenable( + @org.junit.jupiter.api.io.TempDir java.nio.file.Path root) throws Exception { + var plugin = constructorPlugin(root, true); + var handlers = new org.bukkit.event.HandlerList(); + try (var events = mockStatic(org.bukkit.event.server.PluginDisableEvent.class)) { + events.when(org.bukkit.event.server.PluginDisableEvent::getHandlerList).thenReturn(handlers); + var metrics = new BStatsMetrics(plugin, 1); + var field = BStatsMetrics.class.getDeclaredField("metricsBase"); + field.setAccessible(true); + var base = (BStatsMetrics.MetricsBase) field.get(metrics); + var schedulerField = BStatsMetrics.MetricsBase.class.getDeclaredField("scheduler"); + schedulerField.setAccessible(true); + var scheduler = (ScheduledThreadPoolExecutor) schedulerField.get(base); + try { + assertEquals(1, handlers.getRegisteredListeners().length); + when(plugin.isEnabled()).thenReturn(true); + handlers.getRegisteredListeners()[0].callEvent(new org.bukkit.event.server.PluginDisableEvent(plugin)); + assertTrue(scheduler.awaitTermination(5, TimeUnit.SECONDS)); + when(plugin.isEnabled()).thenReturn(false); + when(plugin.isEnabled()).thenReturn(true); + assertTrue(scheduler.isShutdown()); + } finally { base.shutdown(); org.bukkit.event.HandlerList.unregisterAll(plugin); } + } + } + + @Test void constructorRegistrationFailureReleasesExecutor( + @org.junit.jupiter.api.io.TempDir java.nio.file.Path root) throws Exception { + var plugin = constructorPlugin(root, true); + var handlers = mock(org.bukkit.event.HandlerList.class); + doThrow(new IllegalStateException("synthetic registration failure")).when(handlers) + .register(any(org.bukkit.plugin.RegisteredListener.class)); + try (var events = mockStatic(org.bukkit.event.server.PluginDisableEvent.class); + var construction = mockConstruction(ScheduledThreadPoolExecutor.class)) { + events.when(org.bukkit.event.server.PluginDisableEvent::getHandlerList).thenReturn(handlers); + assertThrows(IllegalStateException.class, () -> new BStatsMetrics(plugin, 1)); + assertEquals(1, construction.constructed().size()); + verify(construction.constructed().getFirst()).shutdown(); + } + } + + private org.bukkit.plugin.java.JavaPlugin constructorPlugin(java.nio.file.Path root, boolean enabled) throws Exception { + var config = root.resolve("bStats/config.yml"); + java.nio.file.Files.createDirectories(config.getParent()); + java.nio.file.Files.writeString(config, "enabled: " + enabled + "\nserverUuid: synthetic-server\n"); + var plugin = mock(org.bukkit.plugin.java.JavaPlugin.class); + when(plugin.getDataFolder()).thenReturn(root.resolve("owner").toFile()); + when(plugin.isEnabled()).thenReturn(false); + return plugin; + } + + /** Each test loads the real nested API afresh; no static scheduler state leaks between tests. */ + private static final class Fixture implements AutoCloseable { + private final URLClassLoader loader = new URLClassLoader(new java.net.URL[] { + BStatsMetrics.MetricsBase.class.getProtectionDomain().getCodeSource().getLocation() + }, ClassLoader.getPlatformClassLoader()); + private final Class type = loader.loadClass(BStatsMetrics.MetricsBase.class.getName()); + private final List owners = new ArrayList<>(); + private final Set seen = Collections.newSetFromMap(new IdentityHashMap<>()); + + Fixture() throws Exception { } + + Owner owner(boolean enabled, Supplier serviceEnabled) throws Exception { + return owner(enabled, serviceEnabled, () -> { }); + } + + Owner owner(boolean enabled, Supplier serviceEnabled, Runnable beforeCollection) throws Exception { + return owner(enabled, serviceEnabled, beforeCollection, null); + } + + Owner owner(boolean enabled, Supplier serviceEnabled, Runnable beforeCollection, + Consumer handoff) throws Exception { + var handoffs = new ArrayList(); + var collections = new AtomicInteger(); + Consumer collect = ignored -> { beforeCollection.run(); collections.incrementAndGet(); }; + Object instance; + try { + instance = type.getConstructor(String.class, String.class, int.class, boolean.class, + Consumer.class, Consumer.class, Consumer.class, Supplier.class, BiConsumer.class, + Consumer.class, boolean.class, boolean.class, boolean.class) + .newInstance("bukkit", "synthetic-server", 1, enabled, collect, collect, + (Consumer) (task -> { if (handoff != null) handoff.accept(task); handoffs.add(task); }), serviceEnabled, + (BiConsumer) (message, error) -> { }, + (Consumer) message -> { }, false, false, false); + } catch (InvocationTargetException failure) { + throw new AssertionError("Metrics owner construction failed", failure.getCause()); + } + var field = type.getDeclaredField("scheduler"); + field.setAccessible(true); + var scheduler = (ScheduledThreadPoolExecutor) field.get(instance); + var commands = scheduler.getQueue().stream().filter(command -> !seen.contains(command)).toList(); + seen.addAll(commands); + var owner = new Owner(instance, scheduler, commands, handoffs, collections); + owners.add(owner); + assertEquals(enabled ? 2 : 0, commands.size(), "Unexpected reporting schedule"); + return owner; + } + + @Override public void close() throws Exception { + try { + for (var owner : owners) owner.scheduler.shutdownNow(); + for (var owner : owners) assertTrue(owner.scheduler.awaitTermination(5, TimeUnit.SECONDS)); + } finally { loader.close(); } + } + } + + private record Owner(Object instance, ScheduledThreadPoolExecutor scheduler, List commands, + List handoffs, AtomicInteger collections) { + void tick() { run(false); } + void periodicTick() { run(true); } + private void run(boolean periodic) { + var task = commands.stream().map(command -> (RunnableScheduledFuture) command) + .filter(command -> command.isPeriodic() == periodic).findFirst().orElseThrow(); + assertTrue(scheduler.remove(task), "Expected pending reporting task"); + task.run(); + // Scheduled futures capture callback exceptions; surface them in the test. + if (!periodic && !task.isCancelled()) assertDoesNotThrow(() -> task.get(5, TimeUnit.SECONDS)); + } + } +}