2021-06-11 14:02:28 +02:00
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: Aikar <aikar@aikar.co>
Date: Mon, 29 Feb 2016 18:48:17 -0600
Subject: [PATCH] Timings v2
2021-06-11 20:16:11 +02:00
TODO: Add #isStopping to FullServerTickHandler#stopTiming in patch 191
expose isRunning
2021-06-11 14:02:28 +02:00
diff --git a/src/main/java/co/aikar/timings/FullServerTickHandler.java b/src/main/java/co/aikar/timings/FullServerTickHandler.java
new file mode 100644
2024-07-21 04:40:41 +02:00
index 0000000000000000000000000000000000000000..3e747abde6fefae90f1c15cb00158bc5303cbe50
2021-06-11 14:02:28 +02:00
--- /dev/null
+++ b/src/main/java/co/aikar/timings/FullServerTickHandler.java
2024-07-21 04:40:41 +02:00
@@ -0,0 +1,89 @@
2021-06-11 14:02:28 +02:00
+package co.aikar.timings;
+
+import static co.aikar.timings.TimingsManager.*;
+
+import org.bukkit.Bukkit;
+import org.jetbrains.annotations.NotNull;
+
2024-07-21 04:40:41 +02:00
+/**
+ * @deprecated Timings will be removed in the future
+ */
2023-03-28 04:58:46 +02:00
+@Deprecated(forRemoval = true)
2021-06-11 14:02:28 +02:00
+public class FullServerTickHandler extends TimingHandler {
+ private static final TimingIdentifier IDENTITY = new TimingIdentifier("Minecraft", "Full Server Tick", null);
+ final TimingData minuteData;
+ double avgFreeMemory = -1D;
+ double avgUsedMemory = -1D;
+ FullServerTickHandler() {
+ super(IDENTITY);
+ minuteData = new TimingData(id);
+
+ TIMING_MAP.put(IDENTITY, this);
+ }
+
+ @NotNull
+ @Override
+ public Timing startTiming() {
+ if (TimingsManager.needsFullReset) {
+ TimingsManager.resetTimings();
+ } else if (TimingsManager.needsRecheckEnabled) {
+ TimingsManager.recheckEnabled();
+ }
+ return super.startTiming();
+ }
+
+ @Override
+ public void stopTiming() {
+ super.stopTiming();
2021-06-11 20:16:11 +02:00
+ if (!isEnabled()) {
2021-06-11 14:02:28 +02:00
+ return;
+ }
+ if (TimingHistory.timedTicks % 20 == 0) {
+ final Runtime runtime = Runtime.getRuntime();
+ double usedMemory = runtime.totalMemory() - runtime.freeMemory();
+ double freeMemory = runtime.maxMemory() - usedMemory;
+ if (this.avgFreeMemory == -1) {
+ this.avgFreeMemory = freeMemory;
+ } else {
+ this.avgFreeMemory = (this.avgFreeMemory * (59 / 60D)) + (freeMemory * (1 / 60D));
+ }
+
+ if (this.avgUsedMemory == -1) {
+ this.avgUsedMemory = usedMemory;
+ } else {
+ this.avgUsedMemory = (this.avgUsedMemory * (59 / 60D)) + (usedMemory * (1 / 60D));
+ }
+ }
+
+ long start = System.nanoTime();
+ TimingsManager.tick();
+ long diff = System.nanoTime() - start;
+ TIMINGS_TICK.addDiff(diff, null);
+ // addDiff for TIMINGS_TICK incremented this, bring it back down to 1 per tick.
+ record.setCurTickCount(record.getCurTickCount()-1);
+
+ minuteData.setCurTickTotal(record.getCurTickTotal());
+ minuteData.setCurTickCount(1);
+
+ boolean violated = isViolated();
+ minuteData.processTick(violated);
+ TIMINGS_TICK.processTick(violated);
+ processTick(violated);
+
+
+ if (TimingHistory.timedTicks % 1200 == 0) {
+ MINUTE_REPORTS.add(new TimingHistory.MinuteReport());
+ TimingHistory.resetTicks(false);
+ minuteData.reset();
+ }
+ if (TimingHistory.timedTicks % Timings.getHistoryInterval() == 0) {
+ TimingsManager.HISTORY.add(new TimingHistory());
+ TimingsManager.resetTimings();
+ }
+ Bukkit.getUnsafe().reportTimings();
+ }
+
+ boolean isViolated() {
+ return record.getCurTickTotal() > 50000000;
+ }
+}
diff --git a/src/main/java/co/aikar/timings/NullTimingHandler.java b/src/main/java/co/aikar/timings/NullTimingHandler.java
new file mode 100644
2024-07-21 04:40:41 +02:00
index 0000000000000000000000000000000000000000..42e7e712403676171d34d5f2be27e48e7a071ebd
2021-06-11 14:02:28 +02:00
--- /dev/null
+++ b/src/main/java/co/aikar/timings/NullTimingHandler.java
2024-07-21 04:40:41 +02:00
@@ -0,0 +1,72 @@
2021-06-11 14:02:28 +02:00
+/*
+ * This file is licensed under the MIT License (MIT).
+ *
+ * Copyright (c) 2014 Daniel Ennis <http://aikar.co>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package co.aikar.timings;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
2024-07-21 04:40:41 +02:00
+/**
+ * @deprecated Timings will be removed in the future
+ */
2023-03-28 04:58:46 +02:00
+@Deprecated(forRemoval = true)
2021-06-11 14:02:28 +02:00
+public final class NullTimingHandler implements Timing {
+ public static final Timing NULL = new NullTimingHandler();
+ @NotNull
+ @Override
+ public Timing startTiming() {
+ return this;
+ }
+
+ @Override
+ public void stopTiming() {
+
+ }
+
+ @NotNull
+ @Override
+ public Timing startTimingIfSync() {
+ return this;
+ }
+
+ @Override
+ public void stopTimingIfSync() {
+
+ }
+
+ @Override
+ public void abort() {
+
+ }
+
+ @Nullable
+ @Override
+ public TimingHandler getTimingHandler() {
+ return null;
+ }
+
+ @Override
+ public void close() {
+
+ }
+}
diff --git a/src/main/java/co/aikar/timings/TimedEventExecutor.java b/src/main/java/co/aikar/timings/TimedEventExecutor.java
new file mode 100644
2024-07-21 04:40:41 +02:00
index 0000000000000000000000000000000000000000..a3ad690691eb5537a565d7ba684354acfec5ee2d
2021-06-11 14:02:28 +02:00
--- /dev/null
+++ b/src/main/java/co/aikar/timings/TimedEventExecutor.java
2024-07-21 04:40:41 +02:00
@@ -0,0 +1,87 @@
2021-06-11 14:02:28 +02:00
+/*
+ * This file is licensed under the MIT License (MIT).
+ *
+ * Copyright (c) 2014 Daniel Ennis <http://aikar.co>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package co.aikar.timings;
+
+import org.bukkit.Bukkit;
+import org.bukkit.event.Event;
+import org.bukkit.event.EventException;
+import org.bukkit.event.Listener;
+import org.bukkit.plugin.EventExecutor;
+import org.bukkit.plugin.Plugin;
+
+import java.lang.reflect.Method;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
2024-07-21 04:40:41 +02:00
+/**
+ * @deprecated Timings will be removed in the future
+ */
2023-03-28 04:58:46 +02:00
+@Deprecated(forRemoval = true)
2021-06-11 14:02:28 +02:00
+public class TimedEventExecutor implements EventExecutor {
+
+ private final EventExecutor executor;
+ private final Timing timings;
+
+ /**
+ * Wraps an event executor and associates a timing handler to it.
+ *
+ * @param executor Executor to wrap
+ * @param plugin Owning plugin
+ * @param method EventHandler method
+ * @param eventClass Owning class
+ */
+ public TimedEventExecutor(@NotNull EventExecutor executor, @NotNull Plugin plugin, @Nullable Method method, @NotNull Class<? extends Event> eventClass) {
+ this.executor = executor;
+ String id;
+
+ if (method == null) {
+ if (executor.getClass().getEnclosingClass() != null) { // Oh Skript, how we love you
+ method = executor.getClass().getEnclosingMethod();
+ }
+ }
+
+ if (method != null) {
+ id = method.getDeclaringClass().getName();
+ } else {
+ id = executor.getClass().getName();
+ }
+
+
+ final String eventName = eventClass.getSimpleName();
+ boolean verbose = "BlockPhysicsEvent".equals(eventName);
+ this.timings = Timings.ofSafe(plugin, (verbose ? "## " : "") +
+ "Event: " + id + " (" + eventName + ")");
+ }
+
+ @Override
+ public void execute(@NotNull Listener listener, @NotNull Event event) throws EventException {
+ if (event.isAsynchronous() || !Timings.timingsEnabled || !Bukkit.isPrimaryThread()) {
+ executor.execute(listener, event);
+ return;
+ }
+ try (Timing ignored = timings.startTiming()){
+ executor.execute(listener, event);
+ }
+ }
+}
diff --git a/src/main/java/co/aikar/timings/Timing.java b/src/main/java/co/aikar/timings/Timing.java
new file mode 100644
2024-07-21 04:40:41 +02:00
index 0000000000000000000000000000000000000000..4195efcfe044618052bb03dea34a4fb2ca7c44f0
2021-06-11 14:02:28 +02:00
--- /dev/null
+++ b/src/main/java/co/aikar/timings/Timing.java
2023-03-28 04:58:46 +02:00
@@ -0,0 +1,86 @@
2021-06-11 14:02:28 +02:00
+/*
+ * This file is licensed under the MIT License (MIT).
+ *
+ * Copyright (c) 2014 Daniel Ennis <http://aikar.co>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package co.aikar.timings;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Provides an ability to time sections of code within the Minecraft Server
2023-03-28 04:58:46 +02:00
+ *
2024-07-21 04:40:41 +02:00
+ * @deprecated Timings will be removed in the future
2021-06-11 14:02:28 +02:00
+ */
2023-03-28 04:58:46 +02:00
+@Deprecated(forRemoval = true)
2021-06-11 14:02:28 +02:00
+public interface Timing extends AutoCloseable {
+ /**
+ * Starts timing the execution until {@link #stopTiming()} is called.
+ *
+ * @return Timing
+ */
+ @NotNull
+ Timing startTiming();
+
+ /**
+ * <p>Stops timing and records the data. Propagates the data up to group handlers.</p>
+ *
+ * Will automatically be called when this Timing is used with try-with-resources
+ */
+ void stopTiming();
+
+ /**
+ * Starts timing the execution until {@link #stopTiming()} is called.
+ *
+ * But only if we are on the primary thread.
+ *
+ * @return Timing
+ */
+ @NotNull
+ Timing startTimingIfSync();
+
+ /**
+ * <p>Stops timing and records the data. Propagates the data up to group handlers.</p>
+ *
+ * <p>Will automatically be called when this Timing is used with try-with-resources</p>
+ *
+ * But only if we are on the primary thread.
+ */
+ void stopTimingIfSync();
+
+ /**
+ * @deprecated Doesn't do anything - Removed
+ */
+ @Deprecated
+ void abort();
+
+ /**
+ * Used internally to get the actual backing Handler in the case of delegated Handlers
+ *
+ * @return TimingHandler
+ */
+ @Nullable
+ TimingHandler getTimingHandler();
+
+ @Override
+ void close();
+}
diff --git a/src/main/java/co/aikar/timings/TimingData.java b/src/main/java/co/aikar/timings/TimingData.java
new file mode 100644
index 0000000000000000000000000000000000000000..a5d13a1e44edb861f45c83a9b4309fbf799d407d
--- /dev/null
+++ b/src/main/java/co/aikar/timings/TimingData.java
@@ -0,0 +1,122 @@
+/*
+ * This file is licensed under the MIT License (MIT).
+ *
+ * Copyright (c) 2014 Daniel Ennis <http://aikar.co>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package co.aikar.timings;
+
+import java.util.List;
+import org.jetbrains.annotations.NotNull;
+
+import static co.aikar.util.JSONUtil.toArray;
+
+/**
+ * <p>Lightweight object for tracking timing data</p>
+ *
+ * This is broken out to reduce memory usage
+ */
+class TimingData {
+ private final int id;
+ private int count = 0;
+ private int lagCount = 0;
+ private long totalTime = 0;
+ private long lagTotalTime = 0;
+ private int curTickCount = 0;
+ private long curTickTotal = 0;
+
+ TimingData(int id) {
+ this.id = id;
+ }
+
+ private TimingData(TimingData data) {
+ this.id = data.id;
+ this.totalTime = data.totalTime;
+ this.lagTotalTime = data.lagTotalTime;
+ this.count = data.count;
+ this.lagCount = data.lagCount;
+ }
+
+ void add(long diff) {
+ ++curTickCount;
+ curTickTotal += diff;
+ }
+
+ void processTick(boolean violated) {
+ totalTime += curTickTotal;
+ count += curTickCount;
+ if (violated) {
+ lagTotalTime += curTickTotal;
+ lagCount += curTickCount;
+ }
+ curTickTotal = 0;
+ curTickCount = 0;
+ }
+
+ void reset() {
+ count = 0;
+ lagCount = 0;
+ curTickTotal = 0;
+ curTickCount = 0;
+ totalTime = 0;
+ lagTotalTime = 0;
+ }
+
+ protected TimingData clone() {
+ return new TimingData(this);
+ }
+
+ @NotNull
+ List<Object> export() {
+ List<Object> list = toArray(
+ id,
+ count,
+ totalTime);
+ if (lagCount > 0) {
+ list.add(lagCount);
+ list.add(lagTotalTime);
+ }
+ return list;
+ }
+
+ boolean hasData() {
+ return count > 0;
+ }
+
+ long getTotalTime() {
+ return totalTime;
+ }
+
+ int getCurTickCount() {
+ return curTickCount;
+ }
+
+ void setCurTickCount(int curTickCount) {
+ this.curTickCount = curTickCount;
+ }
+
+ long getCurTickTotal() {
+ return curTickTotal;
+ }
+
+ void setCurTickTotal(long curTickTotal) {
+ this.curTickTotal = curTickTotal;
+ }
+}
diff --git a/src/main/java/co/aikar/timings/TimingHandler.java b/src/main/java/co/aikar/timings/TimingHandler.java
new file mode 100644
index 0000000000000000000000000000000000000000..199789d56d22fcb1b77ebd56805cc28aa5a5ab0a
--- /dev/null
+++ b/src/main/java/co/aikar/timings/TimingHandler.java
@@ -0,0 +1,226 @@
+/*
+ * This file is licensed under the MIT License (MIT).
+ *
+ * Copyright (c) 2014 Daniel Ennis <http://aikar.co>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package co.aikar.timings;
+
+import co.aikar.util.LoadingIntMap;
+import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.bukkit.Bukkit;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+class TimingHandler implements Timing {
+
+ private static AtomicInteger idPool = new AtomicInteger(1);
+ private static Deque<TimingHandler> TIMING_STACK = new ArrayDeque<>();
+ final int id = idPool.getAndIncrement();
+
+ final TimingIdentifier identifier;
+ private final boolean verbose;
+
+ private final Int2ObjectOpenHashMap<TimingData> children = new LoadingIntMap<>(TimingData::new);
+
+ final TimingData record;
+ private TimingHandler startParent;
+ private final TimingHandler groupHandler;
+
+ private long start = 0;
+ private int timingDepth = 0;
+ private boolean added;
+ private boolean timed;
+ private boolean enabled;
+
+ TimingHandler(@NotNull TimingIdentifier id) {
+ this.identifier = id;
+ this.verbose = id.name.startsWith("##");
+ this.record = new TimingData(this.id);
+ this.groupHandler = id.groupHandler;
+
+ TimingIdentifier.getGroup(id.group).handlers.add(this);
+ checkEnabled();
+ }
+
+ final void checkEnabled() {
+ enabled = Timings.timingsEnabled && (!verbose || Timings.verboseEnabled);
+ }
+
+ void processTick(boolean violated) {
+ if (timingDepth != 0 || record.getCurTickCount() == 0) {
+ timingDepth = 0;
+ start = 0;
+ return;
+ }
+
+ record.processTick(violated);
+ for (TimingData handler : children.values()) {
+ handler.processTick(violated);
+ }
+ }
+
+ @NotNull
+ @Override
+ public Timing startTimingIfSync() {
+ startTiming();
+ return this;
+ }
+
+ @Override
+ public void stopTimingIfSync() {
+ stopTiming();
+ }
+
+ @NotNull
+ public Timing startTiming() {
+ if (!enabled || !Bukkit.isPrimaryThread()) {
+ return this;
+ }
+ if (++timingDepth == 1) {
+ startParent = TIMING_STACK.peekLast();
+ start = System.nanoTime();
+ }
+ TIMING_STACK.addLast(this);
+ return this;
+ }
+
+ public void stopTiming() {
+ if (!enabled || timingDepth <= 0 || start == 0 || !Bukkit.isPrimaryThread()) {
+ return;
+ }
+
+ popTimingStack();
+ if (--timingDepth == 0) {
+ addDiff(System.nanoTime() - start, startParent);
+ startParent = null;
+ start = 0;
+ }
+ }
+
+ private void popTimingStack() {
+ TimingHandler last;
+ while ((last = TIMING_STACK.removeLast()) != this) {
+ last.timingDepth = 0;
+ if ("Minecraft".equalsIgnoreCase(last.identifier.group)) {
+ Logger.getGlobal().log(Level.SEVERE, "TIMING_STACK_CORRUPTION - Look above this for any errors and report this to Paper unless it has a plugin in the stack trace (" + last.identifier + " did not stopTiming)");
+ } else {
+ Logger.getGlobal().log(Level.SEVERE, "TIMING_STACK_CORRUPTION - Report this to the plugin " + last.identifier.group + " (Look for errors above this in the logs) (" + last.identifier + " did not stopTiming)", new Throwable());
+ }
+
+ boolean found = TIMING_STACK.contains(this);
+ if (!found) {
+ // We aren't even in the stack... Don't pop everything
+ TIMING_STACK.addLast(last);
+ break;
+ }
+ }
+ }
+
+ @Override
+ public final void abort() {
+
+ }
+
+ void addDiff(long diff, @Nullable TimingHandler parent) {
+ if (parent != null) {
+ parent.children.get(id).add(diff);
+ }
+
+ record.add(diff);
+ if (!added) {
+ added = true;
+ timed = true;
+ TimingsManager.HANDLERS.add(this);
+ }
+ if (groupHandler != null) {
+ groupHandler.addDiff(diff, parent);
+ groupHandler.children.get(id).add(diff);
+ }
+ }
+
+ /**
+ * Reset this timer, setting all values to zero.
+ */
+ void reset(boolean full) {
+ record.reset();
+ if (full) {
+ timed = false;
+ }
+ start = 0;
+ timingDepth = 0;
+ added = false;
+ children.clear();
+ checkEnabled();
+ }
+
+ @NotNull
+ @Override
+ public TimingHandler getTimingHandler() {
+ return this;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ return (this == o);
+ }
+
+ @Override
+ public int hashCode() {
+ return id;
+ }
+
+ /**
+ * This is simply for the Closeable interface so it can be used with try-with-resources ()
+ */
+ @Override
+ public void close() {
+ stopTimingIfSync();
+ }
+
+ public boolean isSpecial() {
+ return this == TimingsManager.FULL_SERVER_TICK || this == TimingsManager.TIMINGS_TICK;
+ }
+
+ boolean isTimed() {
+ return timed;
+ }
+
+ public boolean isEnabled() {
+ return enabled;
+ }
+
+ @NotNull
+ TimingData[] cloneChildren() {
+ final TimingData[] clonedChildren = new TimingData[children.size()];
+ int i = 0;
+ for (TimingData child : children.values()) {
+ clonedChildren[i++] = child.clone();
+ }
+ return clonedChildren;
+ }
+}
diff --git a/src/main/java/co/aikar/timings/TimingHistory.java b/src/main/java/co/aikar/timings/TimingHistory.java
new file mode 100644
2024-07-21 04:40:41 +02:00
index 0000000000000000000000000000000000000000..3d4390f263e52aafa24b306b1fd20d088a4ffcd7
2021-06-11 14:02:28 +02:00
--- /dev/null
+++ b/src/main/java/co/aikar/timings/TimingHistory.java
2024-07-21 04:40:41 +02:00
@@ -0,0 +1,357 @@
2021-06-11 14:02:28 +02:00
+/*
+ * This file is licensed under the MIT License (MIT).
+ *
+ * Copyright (c) 2014 Daniel Ennis <http://aikar.co>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package co.aikar.timings;
+
+import co.aikar.timings.TimingHistory.RegionData.RegionId;
+import com.google.common.base.Function;
+import com.google.common.collect.Sets;
+import org.bukkit.Bukkit;
+import org.bukkit.Chunk;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.block.BlockState;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Player;
+import co.aikar.util.LoadingMap;
+import co.aikar.util.MRUMapCache;
+
+import java.lang.management.ManagementFactory;
+import java.util.Collection;
+import java.util.EnumMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import static co.aikar.timings.TimingsManager.FULL_SERVER_TICK;
+import static co.aikar.timings.TimingsManager.MINUTE_REPORTS;
+import static co.aikar.util.JSONUtil.*;
+
2024-07-21 04:40:41 +02:00
+/**
+ * Internal.
+ *
+ * @deprecated Timings will be removed in the future
+ */
2023-03-28 04:58:46 +02:00
+@Deprecated(forRemoval = true)
2021-06-11 14:02:28 +02:00
+@SuppressWarnings({"deprecation", "SuppressionAnnotation", "Convert2Lambda", "Anonymous2MethodRef"})
+public class TimingHistory {
+ public static long lastMinuteTime;
+ public static long timedTicks;
+ public static long playerTicks;
+ public static long entityTicks;
+ public static long tileEntityTicks;
+ public static long activatedEntityTicks;
+ private static int worldIdPool = 1;
+ static Map<String, Integer> worldMap = LoadingMap.newHashMap(new Function<String, Integer>() {
+ @NotNull
+ @Override
+ public Integer apply(@Nullable String input) {
+ return worldIdPool++;
+ }
+ });
+ private final long endTime;
+ private final long startTime;
+ private final long totalTicks;
+ private final long totalTime; // Represents all time spent running the server this history
+ private final MinuteReport[] minuteReports;
+
+ private final TimingHistoryEntry[] entries;
+ final Set<Material> tileEntityTypeSet = Sets.newHashSet();
+ final Set<EntityType> entityTypeSet = Sets.newHashSet();
+ private final Map<Object, Object> worlds;
+
+ TimingHistory() {
+ this.endTime = System.currentTimeMillis() / 1000;
+ this.startTime = TimingsManager.historyStart / 1000;
+ if (timedTicks % 1200 != 0 || MINUTE_REPORTS.isEmpty()) {
+ this.minuteReports = MINUTE_REPORTS.toArray(new MinuteReport[MINUTE_REPORTS.size() + 1]);
+ this.minuteReports[this.minuteReports.length - 1] = new MinuteReport();
+ } else {
+ this.minuteReports = MINUTE_REPORTS.toArray(new MinuteReport[MINUTE_REPORTS.size()]);
+ }
+ long ticks = 0;
+ for (MinuteReport mp : this.minuteReports) {
+ ticks += mp.ticksRecord.timed;
+ }
+ this.totalTicks = ticks;
+ this.totalTime = FULL_SERVER_TICK.record.getTotalTime();
+ this.entries = new TimingHistoryEntry[TimingsManager.HANDLERS.size()];
+
+ int i = 0;
+ for (TimingHandler handler : TimingsManager.HANDLERS) {
+ entries[i++] = new TimingHistoryEntry(handler);
+ }
+
+ // Information about all loaded chunks/entities
+ //noinspection unchecked
+ this.worlds = toObjectMapper(Bukkit.getWorlds(), new Function<World, JSONPair>() {
+ @NotNull
+ @Override
+ public JSONPair apply(World world) {
+ Map<RegionId, RegionData> regions = LoadingMap.newHashMap(RegionData.LOADER);
+
+ for (Chunk chunk : world.getLoadedChunks()) {
+ RegionData data = regions.get(new RegionId(chunk.getX(), chunk.getZ()));
+
+ for (Entity entity : chunk.getEntities()) {
+ if (entity == null) {
+ Bukkit.getLogger().warning("Null entity detected in chunk at position x: " + chunk.getX() + ", z: " + chunk.getZ());
+ continue;
+ }
+
+ data.entityCounts.get(entity.getType()).increment();
+ }
+
+ for (BlockState tileEntity : chunk.getTileEntities()) {
+ if (tileEntity == null) {
+ Bukkit.getLogger().warning("Null tileentity detected in chunk at position x: " + chunk.getX() + ", z: " + chunk.getZ());
+ continue;
+ }
+
+ data.tileEntityCounts.get(tileEntity.getBlock().getType()).increment();
+ }
+ }
+ return pair(
+ worldMap.get(world.getName()),
+ toArrayMapper(regions.values(),new Function<RegionData, Object>() {
+ @NotNull
+ @Override
+ public Object apply(RegionData input) {
+ return toArray(
+ input.regionId.x,
+ input.regionId.z,
+ toObjectMapper(input.entityCounts.entrySet(),
+ new Function<Map.Entry<EntityType, Counter>, JSONPair>() {
+ @NotNull
+ @Override
+ public JSONPair apply(Map.Entry<EntityType, Counter> entry) {
+ entityTypeSet.add(entry.getKey());
+ return pair(
+ String.valueOf(entry.getKey().ordinal()),
+ entry.getValue().count()
+ );
+ }
+ }
+ ),
2024-06-13 16:45:27 +02:00
+ toObjectMapper(
+ input.tileEntityCounts.entrySet(),
+ entry -> {
+ tileEntityTypeSet.add(entry.getKey());
+ return pair(
+ String.valueOf(entry.getKey().ordinal()),
+ entry.getValue().count()
+ );
2021-06-11 14:02:28 +02:00
+ }
+ )
+ );
+ }
+ })
+ );
+ }
+ });
+ }
+ static class RegionData {
+ final RegionId regionId;
+ @SuppressWarnings("Guava")
+ static Function<RegionId, RegionData> LOADER = new Function<RegionId, RegionData>() {
+ @NotNull
+ @Override
+ public RegionData apply(@NotNull RegionId id) {
+ return new RegionData(id);
+ }
+ };
+ RegionData(@NotNull RegionId id) {
+ this.regionId = id;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (o == null || getClass() != o.getClass()) {
+ return false;
+ }
+
+ RegionData that = (RegionData) o;
+
+ return regionId.equals(that.regionId);
+
+ }
+
+ @Override
+ public int hashCode() {
+ return regionId.hashCode();
+ }
+
+ @SuppressWarnings("unchecked")
+ final Map<EntityType, Counter> entityCounts = MRUMapCache.of(LoadingMap.of(
+ new EnumMap<EntityType, Counter>(EntityType.class), k -> new Counter()
+ ));
+ @SuppressWarnings("unchecked")
+ final Map<Material, Counter> tileEntityCounts = MRUMapCache.of(LoadingMap.of(
+ new EnumMap<Material, Counter>(Material.class), k -> new Counter()
+ ));
+
+ static class RegionId {
+ final int x, z;
+ final long regionId;
+ RegionId(int x, int z) {
+ this.x = x >> 5 << 5;
+ this.z = z >> 5 << 5;
+ this.regionId = ((long) (this.x) << 32) + (this.z >> 5 << 5) - Integer.MIN_VALUE;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) return true;
+ if (o == null || getClass() != o.getClass()) return false;
+
+ RegionId regionId1 = (RegionId) o;
+
+ return regionId == regionId1.regionId;
+
+ }
+
+ @Override
+ public int hashCode() {
+ return (int) (regionId ^ (regionId >>> 32));
+ }
+ }
+ }
+ static void resetTicks(boolean fullReset) {
+ if (fullReset) {
+ // Non full is simply for 1 minute reports
+ timedTicks = 0;
+ }
+ lastMinuteTime = System.nanoTime();
+ playerTicks = 0;
+ tileEntityTicks = 0;
+ entityTicks = 0;
+ activatedEntityTicks = 0;
+ }
+
+ @NotNull
+ Object export() {
+ return createObject(
+ pair("s", startTime),
+ pair("e", endTime),
+ pair("tk", totalTicks),
+ pair("tm", totalTime),
+ pair("w", worlds),
+ pair("h", toArrayMapper(entries, new Function<TimingHistoryEntry, Object>() {
+ @Nullable
+ @Override
+ public Object apply(TimingHistoryEntry entry) {
+ TimingData record = entry.data;
+ if (!record.hasData()) {
+ return null;
+ }
+ return entry.export();
+ }
+ })),
+ pair("mp", toArrayMapper(minuteReports, new Function<MinuteReport, Object>() {
+ @NotNull
+ @Override
+ public Object apply(MinuteReport input) {
+ return input.export();
+ }
+ }))
+ );
+ }
+
+ static class MinuteReport {
+ final long time = System.currentTimeMillis() / 1000;
+
+ final TicksRecord ticksRecord = new TicksRecord();
+ final PingRecord pingRecord = new PingRecord();
+ final TimingData fst = TimingsManager.FULL_SERVER_TICK.minuteData.clone();
+ final double tps = 1E9 / ( System.nanoTime() - lastMinuteTime ) * ticksRecord.timed;
+ final double usedMemory = TimingsManager.FULL_SERVER_TICK.avgUsedMemory;
+ final double freeMemory = TimingsManager.FULL_SERVER_TICK.avgFreeMemory;
+ final double loadAvg = ManagementFactory.getOperatingSystemMXBean().getSystemLoadAverage();
+
+ @NotNull
+ List<Object> export() {
+ return toArray(
+ time,
+ Math.round(tps * 100D) / 100D,
+ Math.round(pingRecord.avg * 100D) / 100D,
+ fst.export(),
+ toArray(ticksRecord.timed,
+ ticksRecord.player,
+ ticksRecord.entity,
+ ticksRecord.activatedEntity,
+ ticksRecord.tileEntity
+ ),
+ usedMemory,
+ freeMemory,
+ loadAvg
+ );
+ }
+ }
+
+ private static class TicksRecord {
+ final long timed;
+ final long player;
+ final long entity;
+ final long tileEntity;
+ final long activatedEntity;
+
+ TicksRecord() {
+ timed = timedTicks - (TimingsManager.MINUTE_REPORTS.size() * 1200);
+ player = playerTicks;
+ entity = entityTicks;
+ tileEntity = tileEntityTicks;
+ activatedEntity = activatedEntityTicks;
+ }
+
+ }
+
+ private static class PingRecord {
+ final double avg;
+
+ PingRecord() {
+ final Collection<? extends Player> onlinePlayers = Bukkit.getOnlinePlayers();
+ int totalPing = 0;
+ for (Player player : onlinePlayers) {
+ totalPing += player.spigot().getPing();
+ }
+ avg = onlinePlayers.isEmpty() ? 0 : totalPing / onlinePlayers.size();
+ }
+ }
+
+
+ private static class Counter {
+ private int count = 0;
+ public int increment() {
+ return ++count;
+ }
+ public int count() {
+ return count;
+ }
+ }
+}
diff --git a/src/main/java/co/aikar/timings/TimingHistoryEntry.java b/src/main/java/co/aikar/timings/TimingHistoryEntry.java
new file mode 100644
index 0000000000000000000000000000000000000000..86d5ac6bd0d7d0003688761aceb3f3343575319f
--- /dev/null
+++ b/src/main/java/co/aikar/timings/TimingHistoryEntry.java
@@ -0,0 +1,58 @@
+/*
+ * This file is licensed under the MIT License (MIT).
+ *
+ * Copyright (c) 2014 Daniel Ennis <http://aikar.co>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package co.aikar.timings;
+
+import com.google.common.base.Function;
+
+import java.util.List;
+import org.jetbrains.annotations.NotNull;
+
+import static co.aikar.util.JSONUtil.toArrayMapper;
+
+class TimingHistoryEntry {
+ final TimingData data;
+ private final TimingData[] children;
+
+ TimingHistoryEntry(@NotNull TimingHandler handler) {
+ this.data = handler.record.clone();
+ children = handler.cloneChildren();
+ }
+
+ @NotNull
+ List<Object> export() {
+ List<Object> result = data.export();
+ if (children.length > 0) {
+ result.add(
+ toArrayMapper(children, new Function<TimingData, Object>() {
+ @NotNull
+ @Override
+ public Object apply(TimingData child) {
+ return child.export();
+ }
+ })
+ );
+ }
+ return result;
+ }
+}
diff --git a/src/main/java/co/aikar/timings/TimingIdentifier.java b/src/main/java/co/aikar/timings/TimingIdentifier.java
new file mode 100644
index 0000000000000000000000000000000000000000..df142a89b8c43acb81eb383eac0ef048a1f49a6e
--- /dev/null
+++ b/src/main/java/co/aikar/timings/TimingIdentifier.java
@@ -0,0 +1,116 @@
+/*
+ * This file is licensed under the MIT License (MIT).
+ *
+ * Copyright (c) 2014 Daniel Ennis <http://aikar.co>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package co.aikar.timings;
+
+import co.aikar.util.LoadingMap;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * <p>Used as a basis for fast HashMap key comparisons for the Timing Map.</p>
+ *
+ * This class uses interned strings giving us the ability to do an identity check instead of equals() on the strings
+ */
+final class TimingIdentifier {
+ /**
+ * Holds all groups. Autoloads on request for a group by name.
+ */
+ static final Map<String, TimingGroup> GROUP_MAP = LoadingMap.of(new ConcurrentHashMap<>(64, .5F), TimingGroup::new);
+ private static final TimingGroup DEFAULT_GROUP = getGroup("Minecraft");
+ final String group;
+ final String name;
+ final TimingHandler groupHandler;
+ private final int hashCode;
+
+ TimingIdentifier(@Nullable String group, @NotNull String name, @Nullable Timing groupHandler) {
+ this.group = group != null ? group: DEFAULT_GROUP.name;
+ this.name = name;
+ this.groupHandler = groupHandler != null ? groupHandler.getTimingHandler() : null;
+ this.hashCode = (31 * this.group.hashCode()) + this.name.hashCode();
+ }
+
+ @NotNull
+ static TimingGroup getGroup(@Nullable String groupName) {
+ if (groupName == null) {
+ //noinspection ConstantConditions
+ return DEFAULT_GROUP;
+ }
+
+ return GROUP_MAP.get(groupName);
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (o == null) {
+ return false;
+ }
+
+ TimingIdentifier that = (TimingIdentifier) o;
+ return Objects.equals(group, that.group) && Objects.equals(name, that.name);
+ }
+
+ @Override
+ public int hashCode() {
+ return hashCode;
+ }
+
+ @Override
+ public String toString() {
+ return "TimingIdentifier{id=" + group + ":" + name +'}';
+ }
+
+ static class TimingGroup {
+
+ private static AtomicInteger idPool = new AtomicInteger(1);
+ final int id = idPool.getAndIncrement();
+
+ final String name;
+ final List<TimingHandler> handlers = Collections.synchronizedList(new ArrayList<>(64));
+
+ private TimingGroup(String name) {
+ this.name = name;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) return true;
+ if (o == null || getClass() != o.getClass()) return false;
+ TimingGroup that = (TimingGroup) o;
+ return id == that.id;
+ }
+
+ @Override
+ public int hashCode() {
+ return id;
+ }
+ }
+}
diff --git a/src/main/java/co/aikar/timings/Timings.java b/src/main/java/co/aikar/timings/Timings.java
new file mode 100644
2024-07-21 04:40:41 +02:00
index 0000000000000000000000000000000000000000..e81d0bc309de877ed2b5da6122f55c162e9b5f10
2021-06-11 14:02:28 +02:00
--- /dev/null
+++ b/src/main/java/co/aikar/timings/Timings.java
2024-07-20 18:35:39 +02:00
@@ -0,0 +1,331 @@
2021-06-11 14:02:28 +02:00
+/*
+ * This file is licensed under the MIT License (MIT).
+ *
+ * Copyright (c) 2014 Daniel Ennis <http://aikar.co>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package co.aikar.timings;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.EvictingQueue;
+import com.google.common.collect.Lists;
2023-03-30 04:11:50 +02:00
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.event.ClickEvent;
+import net.kyori.adventure.text.format.TextColor;
+import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
2021-06-11 14:02:28 +02:00
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandSender;
+import org.bukkit.plugin.Plugin;
+
+import java.util.List;
+import java.util.Queue;
+import java.util.logging.Level;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
2023-03-28 04:58:46 +02:00
+/**
2024-07-21 04:40:41 +02:00
+ * @deprecated Timings will be removed in the future
2023-03-28 04:58:46 +02:00
+ */
+@Deprecated(forRemoval = true)
2021-06-11 14:02:28 +02:00
+@SuppressWarnings({"UnusedDeclaration", "WeakerAccess", "SameParameterValue"})
+public final class Timings {
+
+ final static List<CommandSender> requestingReport = Lists.newArrayList();
+ private static final int MAX_HISTORY_FRAMES = 12;
+ public static final Timing NULL_HANDLER = new NullTimingHandler();
+ static boolean timingsEnabled = false;
+ static boolean verboseEnabled = false;
+ private static int historyInterval = -1;
+ private static int historyLength = -1;
2023-03-29 21:11:36 +02:00
+ private static boolean warnedAboutDeprecationOnEnable;
2021-06-11 14:02:28 +02:00
+
+ private Timings() {}
+
+ /**
+ * Returns a Timing for a plugin corresponding to a name.
+ *
+ * @param plugin Plugin to own the Timing
+ * @param name Name of Timing
+ * @return Handler
+ */
+ @NotNull
+ public static Timing of(@NotNull Plugin plugin, @NotNull String name) {
+ Timing pluginHandler = null;
+ if (plugin != null) {
+ pluginHandler = ofSafe(plugin.getName(), "Combined Total", TimingsManager.PLUGIN_GROUP_HANDLER);
+ }
+ return of(plugin, name, pluginHandler);
+ }
+
+ /**
+ * <p>Returns a handler that has a groupHandler timer handler. Parent timers should not have their
+ * start/stop methods called directly, as the children will call it for you.</p>
+ *
+ * Parent Timers are used to group multiple subsections together and get a summary of them combined
+ * Parent Handler can not be changed after first call
+ *
+ * @param plugin Plugin to own the Timing
+ * @param name Name of Timing
+ * @param groupHandler Parent handler to mirror .start/stop calls to
+ * @return Timing Handler
+ */
+ @NotNull
+ public static Timing of(@NotNull Plugin plugin, @NotNull String name, @Nullable Timing groupHandler) {
+ Preconditions.checkNotNull(plugin, "Plugin can not be null");
2023-03-29 21:11:36 +02:00
+ Bukkit.getLogger().warning(String.format("Plugin '%s' is creating timing '%s' - this is deprecated behavior, please report it to the authors: %s", plugin.getName(), name, String.join(", ", plugin.getDescription().getAuthors())));
2021-06-11 14:02:28 +02:00
+ return TimingsManager.getHandler(plugin.getName(), name, groupHandler);
+ }
+
+ /**
+ * Returns a Timing object after starting it, useful for Java7 try-with-resources.
+ *
+ * try (Timing ignored = Timings.ofStart(plugin, someName)) {
+ * // timed section
+ * }
+ *
+ * @param plugin Plugin to own the Timing
+ * @param name Name of Timing
+ * @return Timing Handler
+ */
+ @NotNull
+ public static Timing ofStart(@NotNull Plugin plugin, @NotNull String name) {
+ return ofStart(plugin, name, null);
+ }
+
+ /**
+ * Returns a Timing object after starting it, useful for Java7 try-with-resources.
+ *
+ * try (Timing ignored = Timings.ofStart(plugin, someName, groupHandler)) {
+ * // timed section
+ * }
+ *
+ * @param plugin Plugin to own the Timing
+ * @param name Name of Timing
+ * @param groupHandler Parent handler to mirror .start/stop calls to
+ * @return Timing Handler
+ */
+ @NotNull
+ public static Timing ofStart(@NotNull Plugin plugin, @NotNull String name, @Nullable Timing groupHandler) {
+ Timing timing = of(plugin, name, groupHandler);
+ timing.startTiming();
+ return timing;
+ }
+
+ /**
+ * Gets whether or not the Spigot Timings system is enabled
+ *
+ * @return Enabled or not
+ */
+ public static boolean isTimingsEnabled() {
+ return timingsEnabled;
+ }
+
+ /**
+ * <p>Sets whether or not the Spigot Timings system should be enabled</p>
+ *
+ * Calling this will reset timing data.
+ *
+ * @param enabled Should timings be reported
+ */
+ public static void setTimingsEnabled(boolean enabled) {
+ timingsEnabled = enabled;
2023-03-29 21:11:36 +02:00
+ warnAboutDeprecationOnEnable();
2021-06-11 14:02:28 +02:00
+ reset();
+ }
+
2023-03-29 21:11:36 +02:00
+ private static void warnAboutDeprecationOnEnable() {
+ if (timingsEnabled && !warnedAboutDeprecationOnEnable) {
2023-03-30 04:11:50 +02:00
+ Bukkit.getLogger().warning(PlainTextComponentSerializer.plainText().serialize(deprecationMessage()));
2023-03-29 21:11:36 +02:00
+ warnedAboutDeprecationOnEnable = true;
+ }
+ }
+
2023-03-30 04:11:50 +02:00
+ public static Component deprecationMessage() {
+ return Component.text()
2024-07-20 18:35:39 +02:00
+ .color(TextColor.color(0xffc93a))
2023-03-30 04:11:50 +02:00
+ .append(Component.text("[!] The timings profiler has been enabled but has been scheduled for removal from Paper in the future."))
+ .append(Component.newline())
2024-07-20 18:35:39 +02:00
+ .append(Component.text(" We recommend migrating to the spark profiler."))
2023-03-30 04:11:50 +02:00
+ .append(Component.newline())
2023-03-30 04:35:13 +02:00
+ .append(
+ Component.text(" For more information please visit: ")
+ .append(
+ Component.text()
2024-07-20 18:35:39 +02:00
+ .content("https://github.com/PaperMC/Paper/discussions/10565")
+ .clickEvent(ClickEvent.openUrl("https://github.com/PaperMC/Paper/discussions/10565")))
2023-03-30 04:35:13 +02:00
+ )
2023-03-30 04:11:50 +02:00
+ .build();
+ }
+
2021-06-11 14:02:28 +02:00
+ /**
+ * <p>Sets whether or not the Timings should monitor at Verbose level.</p>
+ *
+ * <p>When Verbose is disabled, high-frequency timings will not be available.</p>
+ *
+ * @return Enabled or not
+ */
+ public static boolean isVerboseTimingsEnabled() {
+ return verboseEnabled;
+ }
+
+ /**
+ * <p>Sets whether or not the Timings should monitor at Verbose level.</p>
+ *
+ * When Verbose is disabled, high-frequency timings will not be available.
+ * Calling this will reset timing data.
+ *
+ * @param enabled Should high-frequency timings be reported
+ */
+ public static void setVerboseTimingsEnabled(boolean enabled) {
+ verboseEnabled = enabled;
+ TimingsManager.needsRecheckEnabled = true;
+ }
+
+ /**
+ * <p>Gets the interval between Timing History report generation.</p>
+ *
+ * Defaults to 5 minutes (6000 ticks)
+ *
+ * @return Interval in ticks
+ */
+ public static int getHistoryInterval() {
+ return historyInterval;
+ }
+
+ /**
+ * <p>Sets the interval between Timing History report generations.</p>
+ *
+ * <p>Defaults to 5 minutes (6000 ticks)</p>
+ *
+ * This will recheck your history length, so lowering this value will lower your
+ * history length if you need more than 60 history windows.
+ *
+ * @param interval Interval in ticks
+ */
+ public static void setHistoryInterval(int interval) {
+ historyInterval = Math.max(20*60, interval);
+ // Recheck the history length with the new Interval
+ if (historyLength != -1) {
+ setHistoryLength(historyLength);
+ }
+ }
+
+ /**
+ * Gets how long in ticks Timings history is kept for the server.
+ *
+ * Defaults to 1 hour (72000 ticks)
+ *
+ * @return Duration in Ticks
+ */
+ public static int getHistoryLength() {
+ return historyLength;
+ }
+
+ /**
+ * Sets how long Timing History reports are kept for the server.
+ *
+ * Defaults to 1 hours(72000 ticks)
+ *
+ * This value is capped at a maximum of getHistoryInterval() * MAX_HISTORY_FRAMES (12)
+ *
+ * Will not reset Timing Data but may truncate old history if the new length is less than old length.
+ *
+ * @param length Duration in ticks
+ */
+ public static void setHistoryLength(int length) {
+ // Cap at 12 History Frames, 1 hour at 5 minute frames.
+ int maxLength = historyInterval * MAX_HISTORY_FRAMES;
+ // For special cases of servers with special permission to bypass the max.
+ // This max helps keep data file sizes reasonable for processing on Aikar's Timing parser side.
+ // Setting this will not help you bypass the max unless Aikar has added an exception on the API side.
+ if (System.getProperty("timings.bypassMax") != null) {
+ maxLength = Integer.MAX_VALUE;
+ }
+ historyLength = Math.max(Math.min(maxLength, length), historyInterval);
+ Queue<TimingHistory> oldQueue = TimingsManager.HISTORY;
+ int frames = (getHistoryLength() / getHistoryInterval());
+ if (length > maxLength) {
+ Bukkit.getLogger().log(Level.WARNING, "Timings Length too high. Requested " + length + ", max is " + maxLength + ". To get longer history, you must increase your interval. Set Interval to " + Math.ceil(length / MAX_HISTORY_FRAMES) + " to achieve this length.");
+ }
+ TimingsManager.HISTORY = EvictingQueue.create(frames);
+ TimingsManager.HISTORY.addAll(oldQueue);
+ }
+
+ /**
+ * Resets all Timing Data
+ */
+ public static void reset() {
+ TimingsManager.reset();
+ }
+
+ /**
+ * Generates a report and sends it to the specified command sender.
+ *
+ * If sender is null, ConsoleCommandSender will be used.
+ * @param sender The sender to send to, or null to use the ConsoleCommandSender
+ */
+ public static void generateReport(@Nullable CommandSender sender) {
+ if (sender == null) {
+ sender = Bukkit.getConsoleSender();
+ }
+ requestingReport.add(sender);
+ }
+
+ /**
+ * Generates a report and sends it to the specified listener.
+ * Use with {@link org.bukkit.command.BufferedCommandSender} to get full response when done!
+ * @param sender The listener to send responses too.
+ */
+ public static void generateReport(@NotNull TimingsReportListener sender) {
2022-06-07 22:23:16 +02:00
+ Preconditions.checkNotNull(sender);
2021-06-11 14:02:28 +02:00
+ requestingReport.add(sender);
+ }
+
+ /*
+ =================
+ Protected API: These are for internal use only in Bukkit/CraftBukkit
+ These do not have isPrimaryThread() checks in the startTiming/stopTiming
+ =================
+ */
+ @NotNull
+ static TimingHandler ofSafe(@NotNull String name) {
+ return ofSafe(null, name, null);
+ }
+
+ @NotNull
+ static Timing ofSafe(@Nullable Plugin plugin, @NotNull String name) {
+ Timing pluginHandler = null;
+ if (plugin != null) {
+ pluginHandler = ofSafe(plugin.getName(), "Combined Total", TimingsManager.PLUGIN_GROUP_HANDLER);
+ }
+ return ofSafe(plugin != null ? plugin.getName() : "Minecraft - Invalid Plugin", name, pluginHandler);
+ }
+
+ @NotNull
+ static TimingHandler ofSafe(@NotNull String name, @Nullable Timing groupHandler) {
+ return ofSafe(null, name, groupHandler);
+ }
+
+ @NotNull
+ static TimingHandler ofSafe(@Nullable String groupName, @NotNull String name, @Nullable Timing groupHandler) {
+ return TimingsManager.getHandler(groupName, name, groupHandler);
+ }
+}
2023-03-28 04:58:46 +02:00
+
2021-06-11 14:02:28 +02:00
diff --git a/src/main/java/co/aikar/timings/TimingsCommand.java b/src/main/java/co/aikar/timings/TimingsCommand.java
new file mode 100644
2024-07-21 04:40:41 +02:00
index 0000000000000000000000000000000000000000..95d87c9dbf2b237787294dfbe7fed87a36e6dedf
2021-06-11 14:02:28 +02:00
--- /dev/null
+++ b/src/main/java/co/aikar/timings/TimingsCommand.java
2024-07-21 04:40:41 +02:00
@@ -0,0 +1,126 @@
2021-06-11 14:02:28 +02:00
+/*
+ * This file is licensed under the MIT License (MIT).
+ *
+ * Copyright (c) 2014 Daniel Ennis <http://aikar.co>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package co.aikar.timings;
+
2022-06-07 22:23:16 +02:00
+import com.google.common.base.Preconditions;
2021-06-11 14:02:28 +02:00
+import com.google.common.collect.ImmutableList;
2022-06-03 06:26:56 +02:00
+import net.kyori.adventure.text.format.NamedTextColor;
2021-06-11 14:02:28 +02:00
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.defaults.BukkitCommand;
+import org.bukkit.util.StringUtil;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.jetbrains.annotations.NotNull;
2022-06-03 06:26:56 +02:00
+
+import static net.kyori.adventure.text.Component.text;
2021-06-11 14:02:28 +02:00
+
2024-07-21 04:40:41 +02:00
+/**
+ * @deprecated Timings will be removed in the future
+ */
2023-03-28 04:58:46 +02:00
+@Deprecated(forRemoval = true)
2021-06-11 14:02:28 +02:00
+public class TimingsCommand extends BukkitCommand {
+ private static final List<String> TIMINGS_SUBCOMMANDS = ImmutableList.of("report", "reset", "on", "off", "paste", "verbon", "verboff");
+ private long lastResetAttempt = 0;
+
+ public TimingsCommand(@NotNull String name) {
+ super(name);
+ this.description = "Manages Spigot Timings data to see performance of the server.";
+ this.usageMessage = "/timings <reset|report|on|off|verbon|verboff>";
+ this.setPermission("bukkit.command.timings");
+ }
+
+ @Override
+ public boolean execute(@NotNull CommandSender sender, @NotNull String currentAlias, @NotNull String[] args) {
+ if (!testPermission(sender)) {
+ return true;
+ }
2023-03-30 04:11:50 +02:00
+ if (false) {
+ sender.sendMessage(Timings.deprecationMessage());
+ }
2021-06-11 14:02:28 +02:00
+ if (args.length < 1) {
2022-06-03 06:26:56 +02:00
+ sender.sendMessage(text("Usage: " + this.usageMessage, NamedTextColor.RED));
2021-06-11 14:02:28 +02:00
+ return true;
+ }
+ final String arg = args[0];
+ if ("on".equalsIgnoreCase(arg)) {
+ Timings.setTimingsEnabled(true);
2022-06-03 06:26:56 +02:00
+ sender.sendMessage(text("Enabled Timings & Reset"));
2021-06-11 14:02:28 +02:00
+ return true;
+ } else if ("off".equalsIgnoreCase(arg)) {
+ Timings.setTimingsEnabled(false);
2022-06-03 06:26:56 +02:00
+ sender.sendMessage(text("Disabled Timings"));
2021-06-11 14:02:28 +02:00
+ return true;
+ }
+
+ if (!Timings.isTimingsEnabled()) {
2022-06-03 06:26:56 +02:00
+ sender.sendMessage(text("Please enable timings by typing /timings on"));
2021-06-11 14:02:28 +02:00
+ return true;
+ }
+
+ long now = System.currentTimeMillis();
+ if ("verbon".equalsIgnoreCase(arg)) {
+ Timings.setVerboseTimingsEnabled(true);
2022-06-03 06:26:56 +02:00
+ sender.sendMessage(text("Enabled Verbose Timings"));
2021-06-11 14:02:28 +02:00
+ return true;
+ } else if ("verboff".equalsIgnoreCase(arg)) {
+ Timings.setVerboseTimingsEnabled(false);
2022-06-03 06:26:56 +02:00
+ sender.sendMessage(text("Disabled Verbose Timings"));
2021-06-11 14:02:28 +02:00
+ return true;
+ } else if ("reset".equalsIgnoreCase(arg)) {
+ if (now - lastResetAttempt < 30000) {
+ TimingsManager.reset();
2022-06-03 06:26:56 +02:00
+ sender.sendMessage(text("Timings reset. Please wait 5-10 minutes before using /timings report.", NamedTextColor.RED));
2021-06-11 14:02:28 +02:00
+ } else {
+ lastResetAttempt = now;
2022-06-03 06:26:56 +02:00
+ sender.sendMessage(text("WARNING: Timings v2 should not be reset. If you are experiencing lag, please wait 3 minutes and then issue a report. The best timings will include 10+ minutes, with data before and after your lag period. If you really want to reset, run this command again within 30 seconds.", NamedTextColor.RED));
2021-06-11 14:02:28 +02:00
+ }
+ } else if (
+ "paste".equalsIgnoreCase(arg) ||
+ "report".equalsIgnoreCase(arg) ||
+ "get".equalsIgnoreCase(arg) ||
+ "merged".equalsIgnoreCase(arg) ||
+ "separate".equalsIgnoreCase(arg)
+ ) {
+ Timings.generateReport(sender);
+ } else {
2022-06-03 06:26:56 +02:00
+ sender.sendMessage(text("Usage: " + this.usageMessage, NamedTextColor.RED));
2021-06-11 14:02:28 +02:00
+ }
+ return true;
+ }
+
+ @NotNull
+ @Override
+ public List<String> tabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) {
2022-06-07 22:23:16 +02:00
+ Preconditions.checkNotNull(sender, "Sender cannot be null");
+ Preconditions.checkNotNull(args, "Arguments cannot be null");
+ Preconditions.checkNotNull(alias, "Alias cannot be null");
2021-06-11 14:02:28 +02:00
+
+ if (args.length == 1) {
+ return StringUtil.copyPartialMatches(args[0], TIMINGS_SUBCOMMANDS,
+ new ArrayList<String>(TIMINGS_SUBCOMMANDS.size()));
+ }
+ return ImmutableList.of();
+ }
+}
diff --git a/src/main/java/co/aikar/timings/TimingsManager.java b/src/main/java/co/aikar/timings/TimingsManager.java
new file mode 100644
2024-07-21 04:40:41 +02:00
index 0000000000000000000000000000000000000000..e72ad05abada04426e32a73d02b21cb69079d268
2021-06-11 14:02:28 +02:00
--- /dev/null
+++ b/src/main/java/co/aikar/timings/TimingsManager.java
2023-03-28 04:58:46 +02:00
@@ -0,0 +1,192 @@
2021-06-11 14:02:28 +02:00
+/*
+ * This file is licensed under the MIT License (MIT).
+ *
+ * Copyright (c) 2014 Daniel Ennis <http://aikar.co>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package co.aikar.timings;
+
+import co.aikar.util.LoadingMap;
+import com.google.common.collect.EvictingQueue;
+import org.bukkit.Bukkit;
+import org.bukkit.Server;
+import org.bukkit.command.Command;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.plugin.java.PluginClassLoader;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.logging.Level;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
2023-03-28 04:58:46 +02:00
+/**
2024-07-21 04:40:41 +02:00
+ * @deprecated Timings will be removed in the future
2023-03-28 04:58:46 +02:00
+ */
+@Deprecated(forRemoval = true)
2021-06-11 14:02:28 +02:00
+public final class TimingsManager {
+ static final Map<TimingIdentifier, TimingHandler> TIMING_MAP = LoadingMap.of(
+ new ConcurrentHashMap<>(4096, .5F), TimingHandler::new
+ );
+ public static final FullServerTickHandler FULL_SERVER_TICK = new FullServerTickHandler();
+ public static final TimingHandler TIMINGS_TICK = Timings.ofSafe("Timings Tick", FULL_SERVER_TICK);
+ public static final Timing PLUGIN_GROUP_HANDLER = Timings.ofSafe("Plugins");
2021-07-25 09:10:30 +02:00
+ public static String url = "https://timings.aikar.co/";
2021-06-11 14:02:28 +02:00
+ public static List<String> hiddenConfigs = new ArrayList<String>();
+ public static boolean privacy = false;
+
+ static final List<TimingHandler> HANDLERS = new ArrayList<>(1024);
+ static final List<TimingHistory.MinuteReport> MINUTE_REPORTS = new ArrayList<>(64);
+
+ static EvictingQueue<TimingHistory> HISTORY = EvictingQueue.create(12);
+ static long timingStart = 0;
+ static long historyStart = 0;
+ static boolean needsFullReset = false;
+ static boolean needsRecheckEnabled = false;
+
+ private TimingsManager() {}
+
+ /**
+ * Resets all timing data on the next tick
+ */
+ static void reset() {
+ needsFullReset = true;
+ }
+
+ /**
+ * Ticked every tick by CraftBukkit to count the number of times a timer
+ * caused TPS loss.
+ */
+ static void tick() {
+ if (Timings.timingsEnabled) {
+ boolean violated = FULL_SERVER_TICK.isViolated();
+
+ for (TimingHandler handler : HANDLERS) {
+ if (handler.isSpecial()) {
+ // We manually call this
+ continue;
+ }
+ handler.processTick(violated);
+ }
+
+ TimingHistory.playerTicks += Bukkit.getOnlinePlayers().size();
+ TimingHistory.timedTicks++;
+ // Generate TPS/Ping/Tick reports every minute
+ }
+ }
+ static void stopServer() {
+ Timings.timingsEnabled = false;
+ recheckEnabled();
+ }
+ static void recheckEnabled() {
+ synchronized (TIMING_MAP) {
+ for (TimingHandler timings : TIMING_MAP.values()) {
+ timings.checkEnabled();
+ }
+ }
+ needsRecheckEnabled = false;
+ }
+ static void resetTimings() {
+ if (needsFullReset) {
+ // Full resets need to re-check every handlers enabled state
+ // Timing map can be modified from async so we must sync on it.
+ synchronized (TIMING_MAP) {
+ for (TimingHandler timings : TIMING_MAP.values()) {
+ timings.reset(true);
+ }
+ }
+ Bukkit.getLogger().log(Level.INFO, "Timings Reset");
+ HISTORY.clear();
+ needsFullReset = false;
+ needsRecheckEnabled = false;
+ timingStart = System.currentTimeMillis();
+ } else {
+ // Soft resets only need to act on timings that have done something
+ // Handlers can only be modified on main thread.
+ for (TimingHandler timings : HANDLERS) {
+ timings.reset(false);
+ }
+ }
+
+ HANDLERS.clear();
+ MINUTE_REPORTS.clear();
+
+ TimingHistory.resetTicks(true);
+ historyStart = System.currentTimeMillis();
+ }
+
+ @NotNull
+ static TimingHandler getHandler(@Nullable String group, @NotNull String name, @Nullable Timing parent) {
+ return TIMING_MAP.get(new TimingIdentifier(group, name, parent));
+ }
+
+
+ /**
+ * <p>Due to access restrictions, we need a helper method to get a Command TimingHandler with String group</p>
+ *
+ * Plugins should never call this
+ *
+ * @param pluginName Plugin this command is associated with
+ * @param command Command to get timings for
+ * @return TimingHandler
+ */
+ @NotNull
+ public static Timing getCommandTiming(@Nullable String pluginName, @NotNull Command command) {
+ Plugin plugin = null;
+ final Server server = Bukkit.getServer();
+ if (!( server == null || pluginName == null ||
+ "minecraft".equals(pluginName) || "bukkit".equals(pluginName) ||
+ "spigot".equalsIgnoreCase(pluginName) || "paper".equals(pluginName)
+ )) {
+ plugin = server.getPluginManager().getPlugin(pluginName);
+ }
+ if (plugin == null) {
+ // Plugin is passing custom fallback prefix, try to look up by class loader
+ plugin = getPluginByClassloader(command.getClass());
+ }
+ if (plugin == null) {
+ return Timings.ofSafe("Command: " + pluginName + ":" + command.getTimingName());
+ }
+
+ return Timings.ofSafe(plugin, "Command: " + pluginName + ":" + command.getTimingName());
+ }
+
+ /**
+ * Looks up the class loader for the specified class, and if it is a PluginClassLoader, return the
+ * Plugin that created this class.
+ *
+ * @param clazz Class to check
+ * @return Plugin if created by a plugin
+ */
+ @Nullable
+ public static Plugin getPluginByClassloader(@Nullable Class<?> clazz) {
+ if (clazz == null) {
+ return null;
+ }
+ final ClassLoader classLoader = clazz.getClassLoader();
+ if (classLoader instanceof PluginClassLoader) {
+ PluginClassLoader pluginClassLoader = (PluginClassLoader) classLoader;
+ return pluginClassLoader.getPlugin();
+ }
+ return null;
+ }
+}
diff --git a/src/main/java/co/aikar/timings/TimingsReportListener.java b/src/main/java/co/aikar/timings/TimingsReportListener.java
new file mode 100644
2024-07-21 04:40:41 +02:00
index 0000000000000000000000000000000000000000..df066d6f8d55afbc0c1897c486d638657a5f8df9
2021-06-11 14:02:28 +02:00
--- /dev/null
+++ b/src/main/java/co/aikar/timings/TimingsReportListener.java
2024-07-21 04:40:41 +02:00
@@ -0,0 +1,90 @@
2021-06-11 14:02:28 +02:00
+package co.aikar.timings;
+
2022-06-07 22:23:16 +02:00
+import com.google.common.base.Preconditions;
2021-06-11 14:02:28 +02:00
+import com.google.common.collect.Lists;
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.ConsoleCommandSender;
+import org.bukkit.command.MessageCommandSender;
+import org.bukkit.command.RemoteConsoleCommandSender;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
2022-06-07 22:23:16 +02:00
+import java.util.List;
+
2024-07-21 04:40:41 +02:00
+/**
+ * @deprecated Timings will be removed in the future
+ */
2023-03-28 04:58:46 +02:00
+@Deprecated(forRemoval = true)
2021-06-11 14:02:28 +02:00
+@SuppressWarnings("WeakerAccess")
2022-03-04 22:19:57 +01:00
+public class TimingsReportListener implements net.kyori.adventure.audience.ForwardingAudience, MessageCommandSender {
2021-06-11 14:02:28 +02:00
+ private final List<CommandSender> senders;
+ private final Runnable onDone;
+ private String timingsURL;
+
+ public TimingsReportListener(@NotNull CommandSender senders) {
+ this(senders, null);
+ }
+ public TimingsReportListener(@NotNull CommandSender sender, @Nullable Runnable onDone) {
+ this(Lists.newArrayList(sender), onDone);
+ }
+ public TimingsReportListener(@NotNull List<CommandSender> senders) {
+ this(senders, null);
+ }
+ public TimingsReportListener(@NotNull List<CommandSender> senders, @Nullable Runnable onDone) {
2022-06-07 22:23:16 +02:00
+ Preconditions.checkNotNull(senders);
+ Preconditions.checkArgument(!senders.isEmpty(), "senders is empty");
2021-06-11 14:02:28 +02:00
+
+ this.senders = Lists.newArrayList(senders);
+ this.onDone = onDone;
+ }
+
+ @Nullable
+ public String getTimingsURL() {
+ return timingsURL;
+ }
+
+ public void done() {
+ done(null);
+ }
+
+ public void done(@Nullable String url) {
+ this.timingsURL = url;
+ if (onDone != null) {
+ onDone.run();
+ }
+ for (CommandSender sender : senders) {
+ if (sender instanceof TimingsReportListener) {
+ ((TimingsReportListener) sender).done();
+ }
+ }
+ }
+
+ @Override
2022-03-04 22:19:57 +01:00
+ public void sendMessage(final @NotNull net.kyori.adventure.identity.Identity source, final @NotNull net.kyori.adventure.text.Component message, final @NotNull net.kyori.adventure.audience.MessageType type) {
+ net.kyori.adventure.audience.ForwardingAudience.super.sendMessage(source, message, type);
+ }
+
+ @NotNull
+ @Override
+ public Iterable<? extends net.kyori.adventure.audience.Audience> audiences() {
+ return this.senders;
+ }
+
+ @Override
2021-06-11 14:02:28 +02:00
+ public void sendMessage(@NotNull String message) {
+ senders.forEach((sender) -> sender.sendMessage(message));
+ }
+
+ public void addConsoleIfNeeded() {
+ boolean hasConsole = false;
+ for (CommandSender sender : this.senders) {
+ if (sender instanceof ConsoleCommandSender || sender instanceof RemoteConsoleCommandSender) {
+ hasConsole = true;
+ }
+ }
+ if (!hasConsole) {
+ this.senders.add(Bukkit.getConsoleSender());
+ }
+ }
+}
diff --git a/src/main/java/co/aikar/timings/UnsafeTimingHandler.java b/src/main/java/co/aikar/timings/UnsafeTimingHandler.java
new file mode 100644
index 0000000000000000000000000000000000000000..632c4961515f5052551f841cfa840e60bba7a257
--- /dev/null
+++ b/src/main/java/co/aikar/timings/UnsafeTimingHandler.java
@@ -0,0 +1,53 @@
+/*
+ * This file is licensed under the MIT License (MIT).
+ *
+ * Copyright (c) 2014 Daniel Ennis <http://aikar.co>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package co.aikar.timings;
+
+import org.bukkit.Bukkit;
+import org.jetbrains.annotations.NotNull;
+
+class UnsafeTimingHandler extends TimingHandler {
+
+ UnsafeTimingHandler(@NotNull TimingIdentifier id) {
+ super(id);
+ }
+
+ private static void checkThread() {
+ if (!Bukkit.isPrimaryThread()) {
+ throw new IllegalStateException("Calling Timings from Async Operation");
+ }
+ }
+
+ @NotNull
+ @Override
+ public Timing startTiming() {
+ checkThread();
+ return super.startTiming();
+ }
+
+ @Override
+ public void stopTiming() {
+ checkThread();
+ super.stopTiming();
+ }
+}
diff --git a/src/main/java/co/aikar/util/Counter.java b/src/main/java/co/aikar/util/Counter.java
new file mode 100644
2023-03-28 04:58:46 +02:00
index 0000000000000000000000000000000000000000..dae84243804b4b076cafb3e1b29bdcf614efc93f
2021-06-11 14:02:28 +02:00
--- /dev/null
+++ b/src/main/java/co/aikar/util/Counter.java
2023-03-28 04:58:46 +02:00
@@ -0,0 +1,39 @@
2021-06-11 14:02:28 +02:00
+package co.aikar.util;
+
+import com.google.common.collect.ForwardingMap;
+
+import java.util.HashMap;
+import java.util.Map;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
2023-03-28 04:58:46 +02:00
+@Deprecated(forRemoval = true)
2021-06-11 14:02:28 +02:00
+public class Counter <T> extends ForwardingMap<T, Long> {
+ private final Map<T, Long> counts = new HashMap<>();
+
+ public long decrement(@Nullable T key) {
+ return increment(key, -1);
+ }
+ public long increment(@Nullable T key) {
+ return increment(key, 1);
+ }
+ public long decrement(@Nullable T key, long amount) {
+ return increment(key, -amount);
+ }
+ public long increment(@Nullable T key, long amount) {
+ Long count = this.getCount(key);
+ count += amount;
+ this.counts.put(key, count);
+ return count;
+ }
+
+ public long getCount(@Nullable T key) {
+ return this.counts.getOrDefault(key, 0L);
+ }
+
+ @NotNull
+ @Override
+ protected Map<T, Long> delegate() {
+ return this.counts;
+ }
+}
diff --git a/src/main/java/co/aikar/util/JSONUtil.java b/src/main/java/co/aikar/util/JSONUtil.java
new file mode 100644
2023-03-28 04:58:46 +02:00
index 0000000000000000000000000000000000000000..c105a1429ca58b37be265708ec345e00f0d43ed8
2021-06-11 14:02:28 +02:00
--- /dev/null
+++ b/src/main/java/co/aikar/util/JSONUtil.java
2023-03-28 04:58:46 +02:00
@@ -0,0 +1,141 @@
2021-06-11 14:02:28 +02:00
+package co.aikar.util;
+
+import com.google.common.base.Function;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.json.simple.JSONArray;
+import org.json.simple.JSONObject;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Provides Utility methods that assist with generating JSON Objects
+ */
+@SuppressWarnings({"rawtypes", "SuppressionAnnotation"})
2023-03-28 04:58:46 +02:00
+@Deprecated(forRemoval = true)
2021-06-11 14:02:28 +02:00
+public final class JSONUtil {
+ private JSONUtil() {}
+
+ /**
+ * Creates a key/value "JSONPair" object
+ *
+ * @param key Key to use
+ * @param obj Value to use
+ * @return JSONPair
+ */
+ @NotNull
+ public static JSONPair pair(@NotNull String key, @Nullable Object obj) {
+ return new JSONPair(key, obj);
+ }
+
+ @NotNull
+ public static JSONPair pair(long key, @Nullable Object obj) {
+ return new JSONPair(String.valueOf(key), obj);
+ }
+
+ /**
+ * Creates a new JSON object from multiple JSONPair key/value pairs
+ *
+ * @param data JSONPairs
+ * @return Map
+ */
+ @NotNull
+ public static Map<String, Object> createObject(@NotNull JSONPair... data) {
+ return appendObjectData(new LinkedHashMap(), data);
+ }
+
+ /**
+ * This appends multiple key/value Obj pairs into a JSON Object
+ *
+ * @param parent Map to be appended to
+ * @param data Data to append
+ * @return Map
+ */
+ @NotNull
+ public static Map<String, Object> appendObjectData(@NotNull Map parent, @NotNull JSONPair... data) {
+ for (JSONPair JSONPair : data) {
+ parent.put(JSONPair.key, JSONPair.val);
+ }
+ return parent;
+ }
+
+ /**
+ * This builds a JSON array from a set of data
+ *
+ * @param data Data to build JSON array from
+ * @return List
+ */
+ @NotNull
+ public static List toArray(@NotNull Object... data) {
+ return Lists.newArrayList(data);
+ }
+
+ /**
+ * These help build a single JSON array using a mapper function
+ *
+ * @param collection Collection to apply to
+ * @param mapper Mapper to apply
+ * @param <E> Element Type
+ * @return List
+ */
+ @NotNull
+ public static <E> List toArrayMapper(@NotNull E[] collection, @NotNull Function<E, Object> mapper) {
+ return toArrayMapper(Lists.newArrayList(collection), mapper);
+ }
+
+ @NotNull
+ public static <E> List toArrayMapper(@NotNull Iterable<E> collection, @NotNull Function<E, Object> mapper) {
+ List array = Lists.newArrayList();
+ for (E e : collection) {
+ Object object = mapper.apply(e);
+ if (object != null) {
+ array.add(object);
+ }
+ }
+ return array;
+ }
+
+ /**
+ * These help build a single JSON Object from a collection, using a mapper function
+ *
+ * @param collection Collection to apply to
+ * @param mapper Mapper to apply
+ * @param <E> Element Type
+ * @return Map
+ */
+ @NotNull
+ public static <E> Map toObjectMapper(@NotNull E[] collection, @NotNull Function<E, JSONPair> mapper) {
+ return toObjectMapper(Lists.newArrayList(collection), mapper);
+ }
+
+ @NotNull
+ public static <E> Map toObjectMapper(@NotNull Iterable<E> collection, @NotNull Function<E, JSONPair> mapper) {
+ Map object = Maps.newLinkedHashMap();
+ for (E e : collection) {
+ JSONPair JSONPair = mapper.apply(e);
+ if (JSONPair != null) {
+ object.put(JSONPair.key, JSONPair.val);
+ }
+ }
+ return object;
+ }
+
+ /**
+ * Simply stores a key and a value, used internally by many methods below.
+ */
+ @SuppressWarnings("PublicInnerClass")
+ public static class JSONPair {
+ final String key;
+ final Object val;
+
+ JSONPair(@NotNull String key, @NotNull Object val) {
+ this.key = key;
+ this.val = val;
+ }
+ }
+}
diff --git a/src/main/java/co/aikar/util/LoadingIntMap.java b/src/main/java/co/aikar/util/LoadingIntMap.java
new file mode 100644
2023-03-28 04:58:46 +02:00
index 0000000000000000000000000000000000000000..5753b9bce89db2ac378ec41f1b61907cc2e23335
2021-06-11 14:02:28 +02:00
--- /dev/null
+++ b/src/main/java/co/aikar/util/LoadingIntMap.java
2023-03-28 04:58:46 +02:00
@@ -0,0 +1,77 @@
2021-06-11 14:02:28 +02:00
+/*
+ * Copyright (c) 2015. Starlis LLC / dba Empire Minecraft
+ *
+ * This source code is proprietary software and must not be redistributed without Starlis LLC's approval
+ *
+ */
+package co.aikar.util;
+
+
+import com.google.common.base.Function;
+import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Allows you to pass a Loader function that when a key is accessed that doesn't exist,
+ * automatically loads the entry into the map by calling the loader Function.
+ *
+ * .get() Will only return null if the Loader can return null.
+ *
+ * You may pass any backing Map to use.
+ *
+ * This class is not thread safe and should be wrapped with Collections.synchronizedMap on the OUTSIDE of the LoadingMap if needed.
+ *
+ * Do not wrap the backing map with Collections.synchronizedMap.
+ *
+ * @param <V> Value
+ */
2023-03-28 04:58:46 +02:00
+@Deprecated(forRemoval = true)
2021-06-11 14:02:28 +02:00
+public class LoadingIntMap<V> extends Int2ObjectOpenHashMap<V> {
+ private final Function<Integer, V> loader;
+
+ public LoadingIntMap(@NotNull Function<Integer, V> loader) {
+ super();
+ this.loader = loader;
+ }
+
+ public LoadingIntMap(int expectedSize, @NotNull Function<Integer, V> loader) {
+ super(expectedSize);
+ this.loader = loader;
+ }
+
+ public LoadingIntMap(int expectedSize, float loadFactor, @NotNull Function<Integer, V> loader) {
+ super(expectedSize, loadFactor);
+ this.loader = loader;
+ }
+
+
+ @Nullable
+ @Override
+ public V get(int key) {
+ V res = super.get(key);
+ if (res == null) {
+ res = loader.apply(key);
+ if (res != null) {
+ put(key, res);
+ }
+ }
+ return res;
+ }
+
+ /**
+ * Due to java stuff, you will need to cast it to (Function) for some cases
+ *
+ * @param <T> Type
+ */
+ public abstract static class Feeder <T> implements Function<T, T> {
+ @Nullable
+ @Override
+ public T apply(@Nullable Object input) {
+ return apply();
+ }
+
+ @Nullable
+ public abstract T apply();
+ }
+}
diff --git a/src/main/java/co/aikar/util/LoadingMap.java b/src/main/java/co/aikar/util/LoadingMap.java
new file mode 100644
2023-03-28 04:58:46 +02:00
index 0000000000000000000000000000000000000000..1786eeb5cbeaad75602c9c5649bbcd9b2af5cf81
2021-06-11 14:02:28 +02:00
--- /dev/null
+++ b/src/main/java/co/aikar/util/LoadingMap.java
2023-03-28 04:58:46 +02:00
@@ -0,0 +1,369 @@
2021-06-11 14:02:28 +02:00
+/*
+ * This file is licensed under the MIT License (MIT).
+ *
+ * Copyright (c) 2014 Daniel Ennis <http://aikar.co>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package co.aikar.util;
+
+import com.google.common.base.Preconditions;
+import java.lang.reflect.Constructor;
+import java.util.AbstractMap;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.IdentityHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Function;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Allows you to pass a Loader function that when a key is accessed that doesn't exists,
+ * automatically loads the entry into the map by calling the loader Function.
+ *
+ * .get() Will only return null if the Loader can return null.
+ *
+ * You may pass any backing Map to use.
+ *
+ * This class is not thread safe and should be wrapped with Collections.synchronizedMap on the OUTSIDE of the LoadingMap if needed.
+ *
+ * Do not wrap the backing map with Collections.synchronizedMap.
+ *
+ * @param <K> Key
+ * @param <V> Value
+ */
2023-03-28 04:58:46 +02:00
+@Deprecated(forRemoval = true)
2021-06-11 14:02:28 +02:00
+public class LoadingMap <K, V> extends AbstractMap<K, V> {
+ private final Map<K, V> backingMap;
+ private final java.util.function.Function<K, V> loader;
+
+ /**
+ * Initializes an auto loading map using specified loader and backing map
+ * @param backingMap Map to wrap
+ * @param loader Loader
+ */
+ public LoadingMap(@NotNull Map<K, V> backingMap, @NotNull java.util.function.Function<K, V> loader) {
+ this.backingMap = backingMap;
+ this.loader = loader;
+ }
+
+ /**
+ * Creates a new LoadingMap with the specified map and loader
+ *
+ * @param backingMap Actual map being used.
+ * @param loader Loader to use
+ * @param <K> Key Type of the Map
+ * @param <V> Value Type of the Map
+ * @return Map
+ */
+ @NotNull
+ public static <K, V> Map<K, V> of(@NotNull Map<K, V> backingMap, @NotNull Function<K, V> loader) {
+ return new LoadingMap<>(backingMap, loader);
+ }
+
+ /**
+ * Creates a LoadingMap with an auto instantiating loader.
+ *
+ * Will auto construct class of of Value when not found
+ *
+ * Since this uses Reflection, It is more effecient to define your own static loader
+ * than using this helper, but if performance is not critical, this is easier.
+ *
+ * @param backingMap Actual map being used.
+ * @param keyClass Class used for the K generic
+ * @param valueClass Class used for the V generic
+ * @param <K> Key Type of the Map
+ * @param <V> Value Type of the Map
+ * @return Map that auto instantiates on .get()
+ */
+ @NotNull
+ public static <K, V> Map<K, V> newAutoMap(@NotNull Map<K, V> backingMap, @Nullable final Class<? extends K> keyClass,
+ @NotNull final Class<? extends V> valueClass) {
+ return new LoadingMap<>(backingMap, new AutoInstantiatingLoader<>(keyClass, valueClass));
+ }
+ /**
+ * Creates a LoadingMap with an auto instantiating loader.
+ *
+ * Will auto construct class of of Value when not found
+ *
+ * Since this uses Reflection, It is more effecient to define your own static loader
+ * than using this helper, but if performance is not critical, this is easier.
+ *
+ * @param backingMap Actual map being used.
+ * @param valueClass Class used for the V generic
+ * @param <K> Key Type of the Map
+ * @param <V> Value Type of the Map
+ * @return Map that auto instantiates on .get()
+ */
+ @NotNull
+ public static <K, V> Map<K, V> newAutoMap(@NotNull Map<K, V> backingMap,
+ @NotNull final Class<? extends V> valueClass) {
+ return newAutoMap(backingMap, null, valueClass);
+ }
+
+ /**
+ * @see #newAutoMap
+ *
+ * new Auto initializing map using a HashMap.
+ *
+ * @param keyClass Class used for the K generic
+ * @param valueClass Class used for the V generic
+ * @param <K> Key Type of the Map
+ * @param <V> Value Type of the Map
+ * @return Map that auto instantiates on .get()
+ */
+ @NotNull
+ public static <K, V> Map<K, V> newHashAutoMap(@Nullable final Class<? extends K> keyClass, @NotNull final Class<? extends V> valueClass) {
+ return newAutoMap(new HashMap<>(), keyClass, valueClass);
+ }
+
+ /**
+ * @see #newAutoMap
+ *
+ * new Auto initializing map using a HashMap.
+ *
+ * @param valueClass Class used for the V generic
+ * @param <K> Key Type of the Map
+ * @param <V> Value Type of the Map
+ * @return Map that auto instantiates on .get()
+ */
+ @NotNull
+ public static <K, V> Map<K, V> newHashAutoMap(@NotNull final Class<? extends V> valueClass) {
+ return newHashAutoMap(null, valueClass);
+ }
+
+ /**
+ * @see #newAutoMap
+ *
+ * new Auto initializing map using a HashMap.
+ *
+ * @param keyClass Class used for the K generic
+ * @param valueClass Class used for the V generic
+ * @param initialCapacity Initial capacity to use
+ * @param loadFactor Load factor to use
+ * @param <K> Key Type of the Map
+ * @param <V> Value Type of the Map
+ * @return Map that auto instantiates on .get()
+ */
+ @NotNull
+ public static <K, V> Map<K, V> newHashAutoMap(@Nullable final Class<? extends K> keyClass, @NotNull final Class<? extends V> valueClass, int initialCapacity, float loadFactor) {
+ return newAutoMap(new HashMap<>(initialCapacity, loadFactor), keyClass, valueClass);
+ }
+
+ /**
+ * @see #newAutoMap
+ *
+ * new Auto initializing map using a HashMap.
+ *
+ * @param valueClass Class used for the V generic
+ * @param initialCapacity Initial capacity to use
+ * @param loadFactor Load factor to use
+ * @param <K> Key Type of the Map
+ * @param <V> Value Type of the Map
+ * @return Map that auto instantiates on .get()
+ */
+ @NotNull
+ public static <K, V> Map<K, V> newHashAutoMap(@NotNull final Class<? extends V> valueClass, int initialCapacity, float loadFactor) {
+ return newHashAutoMap(null, valueClass, initialCapacity, loadFactor);
+ }
+
+ /**
+ * Initializes an auto loading map using a HashMap
+ *
+ * @param loader Loader to use
+ * @param <K> Key Type of the Map
+ * @param <V> Value Type of the Map
+ * @return Map
+ */
+ @NotNull
+ public static <K, V> Map<K, V> newHashMap(@NotNull Function<K, V> loader) {
+ return new LoadingMap<>(new HashMap<>(), loader);
+ }
+
+ /**
+ * Initializes an auto loading map using a HashMap
+ *
+ * @param loader Loader to use
+ * @param initialCapacity Initial capacity to use
+ * @param <K> Key Type of the Map
+ * @param <V> Value Type of the Map
+ * @return Map
+ */
+ @NotNull
+ public static <K, V> Map<K, V> newHashMap(@NotNull Function<K, V> loader, int initialCapacity) {
+ return new LoadingMap<>(new HashMap<>(initialCapacity), loader);
+ }
+ /**
+ * Initializes an auto loading map using a HashMap
+ *
+ * @param loader Loader to use
+ * @param initialCapacity Initial capacity to use
+ * @param loadFactor Load factor to use
+ * @param <K> Key Type of the Map
+ * @param <V> Value Type of the Map
+ * @return Map
+ */
+ @NotNull
+ public static <K, V> Map<K, V> newHashMap(@NotNull Function<K, V> loader, int initialCapacity, float loadFactor) {
+ return new LoadingMap<>(new HashMap<>(initialCapacity, loadFactor), loader);
+ }
+
+ /**
+ * Initializes an auto loading map using an Identity HashMap
+ *
+ * @param loader Loader to use
+ * @param <K> Key Type of the Map
+ * @param <V> Value Type of the Map
+ * @return Map
+ */
+ @NotNull
+ public static <K, V> Map<K, V> newIdentityHashMap(@NotNull Function<K, V> loader) {
+ return new LoadingMap<>(new IdentityHashMap<>(), loader);
+ }
+
+ /**
+ * Initializes an auto loading map using an Identity HashMap
+ *
+ * @param loader Loader to use
+ * @param initialCapacity Initial capacity to use
+ * @param <K> Key Type of the Map
+ * @param <V> Value Type of the Map
+ * @return Map
+ */
+ @NotNull
+ public static <K, V> Map<K, V> newIdentityHashMap(@NotNull Function<K, V> loader, int initialCapacity) {
+ return new LoadingMap<>(new IdentityHashMap<>(initialCapacity), loader);
+ }
+
+ @Override
+ public int size() {return backingMap.size();}
+
+ @Override
+ public boolean isEmpty() {return backingMap.isEmpty();}
+
+ @Override
+ public boolean containsKey(@Nullable Object key) {return backingMap.containsKey(key);}
+
+ @Override
+ public boolean containsValue(@Nullable Object value) {return backingMap.containsValue(value);}
+
+ @Nullable
+ @Override
+ public V get(@Nullable Object key) {
+ V v = backingMap.get(key);
+ if (v != null) {
+ return v;
+ }
+ return backingMap.computeIfAbsent((K) key, loader);
+ }
+
+ @Nullable
+ public V put(@Nullable K key, @Nullable V value) {return backingMap.put(key, value);}
+
+ @Nullable
+ @Override
+ public V remove(@Nullable Object key) {return backingMap.remove(key);}
+
+ public void putAll(@NotNull Map<? extends K, ? extends V> m) {backingMap.putAll(m);}
+
+ @Override
+ public void clear() {backingMap.clear();}
+
+ @NotNull
+ @Override
+ public Set<K> keySet() {return backingMap.keySet();}
+
+ @NotNull
+ @Override
+ public Collection<V> values() {return backingMap.values();}
+
+ @Override
+ public boolean equals(@Nullable Object o) {return backingMap.equals(o);}
+
+ @Override
+ public int hashCode() {return backingMap.hashCode();}
+
+ @NotNull
+ @Override
+ public Set<Entry<K, V>> entrySet() {
+ return backingMap.entrySet();
+ }
+
+ @NotNull
+ public LoadingMap<K, V> clone() {
+ return new LoadingMap<>(backingMap, loader);
+ }
+
+ private static class AutoInstantiatingLoader<K, V> implements Function<K, V> {
+ final Constructor<? extends V> constructor;
+ private final Class<? extends V> valueClass;
+
+ AutoInstantiatingLoader(@Nullable Class<? extends K> keyClass, @NotNull Class<? extends V> valueClass) {
+ try {
+ this.valueClass = valueClass;
+ if (keyClass != null) {
+ constructor = valueClass.getConstructor(keyClass);
+ } else {
+ constructor = null;
+ }
+ } catch (NoSuchMethodException e) {
+ throw new IllegalStateException(
+ valueClass.getName() + " does not have a constructor for " + (keyClass != null ? keyClass.getName() : null));
+ }
+ }
+
+ @NotNull
+ @Override
+ public V apply(@Nullable K input) {
+ try {
+ return (constructor != null ? constructor.newInstance(input) : valueClass.newInstance());
+ } catch (Exception e) {
+ throw new ExceptionInInitializerError(e);
+ }
+ }
+
+ @Override
+ public int hashCode() {
+ return super.hashCode();
+ }
+
+ @Override
+ public boolean equals(Object object) {
+ return false;
+ }
+ }
+
+ /**
+ * Due to java stuff, you will need to cast it to (Function) for some cases
+ *
+ * @param <T> Type
+ */
+ public abstract static class Feeder <T> implements Function<T, T> {
+ @Nullable
+ @Override
+ public T apply(@Nullable Object input) {
+ return apply();
+ }
+
+ @Nullable
+ public abstract T apply();
+ }
+}
diff --git a/src/main/java/co/aikar/util/MRUMapCache.java b/src/main/java/co/aikar/util/MRUMapCache.java
new file mode 100644
2023-03-28 04:58:46 +02:00
index 0000000000000000000000000000000000000000..3e61a926620a67daec3af54b72a1b911eaef2ed4
2021-06-11 14:02:28 +02:00
--- /dev/null
+++ b/src/main/java/co/aikar/util/MRUMapCache.java
2023-03-28 04:58:46 +02:00
@@ -0,0 +1,112 @@
2021-06-11 14:02:28 +02:00
+/*
+ * This file is licensed under the MIT License (MIT).
+ *
+ * Copyright (c) 2014 Daniel Ennis <http://aikar.co>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package co.aikar.util;
+
+import java.util.AbstractMap;
+import java.util.Collection;
+import java.util.Map;
+import java.util.Set;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Implements a Most Recently Used cache in front of a backing map, to quickly access the last accessed result.
+ *
+ * @param <K> Key Type of the Map
+ * @param <V> Value Type of the Map
+ */
2023-03-28 04:58:46 +02:00
+@Deprecated(forRemoval = true)
2021-06-11 14:02:28 +02:00
+public class MRUMapCache<K, V> extends AbstractMap<K, V> {
+ final Map<K, V> backingMap;
+ Object cacheKey;
+ V cacheValue;
+ public MRUMapCache(@NotNull final Map<K, V> backingMap) {
+ this.backingMap = backingMap;
+ }
+
+ public int size() {return backingMap.size();}
+
+ public boolean isEmpty() {return backingMap.isEmpty();}
+
+ public boolean containsKey(@Nullable Object key) {
+ return key != null && key.equals(cacheKey) || backingMap.containsKey(key);
+ }
+
+ public boolean containsValue(@Nullable Object value) {
+ return value != null && value == cacheValue || backingMap.containsValue(value);
+ }
+
+ @Nullable
+ public V get(@Nullable Object key) {
+ if (cacheKey != null && cacheKey.equals(key)) {
+ return cacheValue;
+ }
+ cacheKey = key;
+ return cacheValue = backingMap.get(key);
+ }
+
+ @Nullable
+ public V put(@Nullable K key, @Nullable V value) {
+ cacheKey = key;
+ return cacheValue = backingMap.put(key, value);
+ }
+
+ @Nullable
+ public V remove(@Nullable Object key) {
+ if (key != null && key.equals(cacheKey)) {
+ cacheKey = null;
+ }
+ return backingMap.remove(key);
+ }
+
+ public void putAll(@NotNull Map<? extends K, ? extends V> m) {backingMap.putAll(m);}
+
+ public void clear() {
+ cacheKey = null;
+ cacheValue = null;
+ backingMap.clear();
+ }
+
+ @NotNull
+ public Set<K> keySet() {return backingMap.keySet();}
+
+ @NotNull
+ public Collection<V> values() {return backingMap.values();}
+
+ @NotNull
+ public Set<Map.Entry<K, V>> entrySet() {return backingMap.entrySet();}
+
+ /**
+ * Wraps the specified map with a most recently used cache
+ *
+ * @param map Map to be wrapped
+ * @param <K> Key Type of the Map
+ * @param <V> Value Type of the Map
+ * @return Map
+ */
+ @NotNull
+ public static <K, V> Map<K, V> of(@NotNull Map<K, V> map) {
+ return new MRUMapCache<K, V>(map);
+ }
+}
diff --git a/src/main/java/org/bukkit/Bukkit.java b/src/main/java/org/bukkit/Bukkit.java
2024-07-06 21:19:14 +02:00
index fe6c43405e3f11272c1ff015f1dcd47129a68d41..8d729fb196d83e01e4652fb1f77f5cab7b57cc31 100644
2021-06-11 14:02:28 +02:00
--- a/src/main/java/org/bukkit/Bukkit.java
+++ b/src/main/java/org/bukkit/Bukkit.java
2024-07-06 21:19:14 +02:00
@@ -870,7 +870,6 @@ public final class Bukkit {
2021-06-11 14:02:28 +02:00
*/
public static void reload() {
server.reload();
- org.spigotmc.CustomTimingsHandler.reload(); // Spigot
}
/**
diff --git a/src/main/java/org/bukkit/Server.java b/src/main/java/org/bukkit/Server.java
2024-07-06 21:19:14 +02:00
index fa6ad07214d5e38866bf6bee9139c6c938e9f51a..57c9b560c77a56588870598acb543469040ceec1 100644
2021-06-11 14:02:28 +02:00
--- a/src/main/java/org/bukkit/Server.java
+++ b/src/main/java/org/bukkit/Server.java
2024-07-06 21:19:14 +02:00
@@ -1960,6 +1960,26 @@ public interface Server extends PluginMessageRecipient, net.kyori.adventure.audi
2021-06-11 14:02:28 +02:00
throw new UnsupportedOperationException("Not supported yet.");
}
+ // Paper start
+ @NotNull
+ public org.bukkit.configuration.file.YamlConfiguration getBukkitConfig()
+ {
+ throw new UnsupportedOperationException( "Not supported yet." );
+ }
+
+ @NotNull
+ public org.bukkit.configuration.file.YamlConfiguration getSpigotConfig()
+ {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @NotNull
+ public org.bukkit.configuration.file.YamlConfiguration getPaperConfig()
+ {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+ // Paper end
+
/**
* Sends the component to the player
*
diff --git a/src/main/java/org/bukkit/UnsafeValues.java b/src/main/java/org/bukkit/UnsafeValues.java
2024-07-21 04:40:41 +02:00
index d8b346fe0f9634218954fe818d53272a0896af9c..12ef99f1c91b92a133611c5f5aeaaeebd02ce232 100644
2021-06-11 14:02:28 +02:00
--- a/src/main/java/org/bukkit/UnsafeValues.java
+++ b/src/main/java/org/bukkit/UnsafeValues.java
2024-07-21 04:40:41 +02:00
@@ -40,6 +40,11 @@ public interface UnsafeValues {
2022-11-23 05:53:50 +01:00
net.kyori.adventure.text.Component resolveWithContext(net.kyori.adventure.text.Component component, org.bukkit.command.CommandSender context, org.bukkit.entity.Entity scoreboardSubject, boolean bypassPermissions) throws java.io.IOException;
2022-03-04 22:19:57 +01:00
// Paper end
2021-06-11 14:02:28 +02:00
2024-07-21 04:40:41 +02:00
+ /**
+ * @deprecated Timings will be removed in the future
+ */
+ @Deprecated(forRemoval = true)
2021-06-11 14:02:28 +02:00
+ void reportTimings(); // Paper
Material toLegacy(Material material);
Material fromLegacy(Material material);
2024-07-21 04:40:41 +02:00
@@ -151,4 +156,12 @@ public interface UnsafeValues {
2023-02-19 15:57:10 +01:00
return !Bukkit.getUnsafe().isSupportedApiVersion(plugin.getDescription().getAPIVersion());
}
// Paper end
2021-06-11 14:02:28 +02:00
+
+ // Paper start
+ /**
2024-07-21 04:40:41 +02:00
+ * @deprecated Timings will be removed in the future
2021-06-11 14:02:28 +02:00
+ */
2024-07-21 04:40:41 +02:00
+ @Deprecated(forRemoval = true)
2021-06-11 14:02:28 +02:00
+ String getTimingsServerName();
+ // Paper end
}
diff --git a/src/main/java/org/bukkit/command/BufferedCommandSender.java b/src/main/java/org/bukkit/command/BufferedCommandSender.java
new file mode 100644
2024-07-21 04:40:41 +02:00
index 0000000000000000000000000000000000000000..45ed63797b13e114bf3795c80a6c3967d8eb2351
2021-06-11 14:02:28 +02:00
--- /dev/null
+++ b/src/main/java/org/bukkit/command/BufferedCommandSender.java
2024-07-21 04:40:41 +02:00
@@ -0,0 +1,25 @@
2021-06-11 14:02:28 +02:00
+package org.bukkit.command;
+
+import org.jetbrains.annotations.NotNull;
+
2024-07-21 04:40:41 +02:00
+/**
+ * @deprecated Timings will be removed in the future
+ */
+@Deprecated(forRemoval = true)
2021-06-11 14:02:28 +02:00
+public class BufferedCommandSender implements MessageCommandSender {
+ private final StringBuffer buffer = new StringBuffer();
+ @Override
+ public void sendMessage(@NotNull String message) {
+ buffer.append(message);
+ buffer.append("\n");
+ }
+
+ @NotNull
+ public String getBuffer() {
+ return buffer.toString();
+ }
+
+ public void reset() {
+ this.buffer.setLength(0);
+ }
+}
diff --git a/src/main/java/org/bukkit/command/Command.java b/src/main/java/org/bukkit/command/Command.java
2024-07-21 04:40:41 +02:00
index f3cdf13f22aa789ee8cc235b61fda4035b254219..17d3da22e8fcdf73a587b17a0cdac3b23ded3567 100644
2021-06-11 14:02:28 +02:00
--- a/src/main/java/org/bukkit/command/Command.java
+++ b/src/main/java/org/bukkit/command/Command.java
2024-07-21 04:40:41 +02:00
@@ -33,7 +33,16 @@ public abstract class Command {
2021-06-11 14:02:28 +02:00
protected String usageMessage;
private String permission;
2022-03-04 22:19:57 +01:00
private net.kyori.adventure.text.Component permissionMessage; // Paper
2023-02-19 15:57:10 +01:00
- public org.spigotmc.CustomTimingsHandler timings; // Spigot
2024-07-21 04:40:41 +02:00
+ /**
+ * @deprecated Timings will be removed in the future
+ */
+ @Deprecated(forRemoval = true)
2021-06-11 14:02:28 +02:00
+ public co.aikar.timings.Timing timings; // Paper
2024-07-21 04:40:41 +02:00
+ /**
+ * @deprecated Timings will be removed in the future
+ */
+ @Deprecated(forRemoval = true)
2021-06-11 14:02:28 +02:00
+ @NotNull public String getTimingName() {return getName();} // Paper
protected Command(@NotNull String name) {
this(name, "", "/" + name, new ArrayList<String>());
2024-07-21 04:40:41 +02:00
@@ -47,7 +56,6 @@ public abstract class Command {
2021-06-11 14:02:28 +02:00
this.usageMessage = (usageMessage == null) ? "/" + name : usageMessage;
this.aliases = aliases;
this.activeAliases = new ArrayList<String>(aliases);
- this.timings = new org.spigotmc.CustomTimingsHandler("** Command: " + name); // Spigot
}
/**
2024-07-21 04:40:41 +02:00
@@ -245,7 +253,6 @@ public abstract class Command {
2021-06-11 14:02:28 +02:00
}
this.nextLabel = name;
if (!isRegistered()) {
- this.timings = new org.spigotmc.CustomTimingsHandler("** Command: " + name); // Spigot
this.label = name;
return true;
}
diff --git a/src/main/java/org/bukkit/command/FormattedCommandAlias.java b/src/main/java/org/bukkit/command/FormattedCommandAlias.java
index d6c8938b1e13b63116b7b0e074ea8ef5997f8dc3..a6ad94ef98a1df1d2842635d850bc990b0137849 100644
--- a/src/main/java/org/bukkit/command/FormattedCommandAlias.java
+++ b/src/main/java/org/bukkit/command/FormattedCommandAlias.java
@@ -9,6 +9,7 @@ public class FormattedCommandAlias extends Command {
public FormattedCommandAlias(@NotNull String alias, @NotNull String[] formatStrings) {
super(alias);
+ timings = co.aikar.timings.TimingsManager.getCommandTiming("minecraft", this); // Spigot
this.formatStrings = formatStrings;
}
@@ -113,6 +114,10 @@ public class FormattedCommandAlias extends Command {
return formatString;
}
+ @NotNull
+ @Override // Paper
+ public String getTimingName() {return "Command Forwarder - " + super.getTimingName();} // Paper
+
private static boolean inRange(int i, int j, int k) {
return i >= j && i <= k;
}
diff --git a/src/main/java/org/bukkit/command/MessageCommandSender.java b/src/main/java/org/bukkit/command/MessageCommandSender.java
new file mode 100644
2024-07-21 04:40:41 +02:00
index 0000000000000000000000000000000000000000..946d2f0ef37c6cf895caf8d3c6963c7889e0567b
2021-06-11 14:02:28 +02:00
--- /dev/null
+++ b/src/main/java/org/bukkit/command/MessageCommandSender.java
2024-07-21 04:40:41 +02:00
@@ -0,0 +1,138 @@
2021-06-11 14:02:28 +02:00
+package org.bukkit.command;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Server;
+import org.bukkit.permissions.Permission;
+import org.bukkit.permissions.PermissionAttachment;
+import org.bukkit.permissions.PermissionAttachmentInfo;
+import org.bukkit.plugin.Plugin;
+
+import java.util.Set;
+import java.util.UUID;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * For when all you care about is just messaging
2024-07-21 04:40:41 +02:00
+ *
+ * @deprecated Timings will be removed in the future
2021-06-11 14:02:28 +02:00
+ */
2024-07-21 04:40:41 +02:00
+@Deprecated(forRemoval = true)
2021-06-11 14:02:28 +02:00
+public interface MessageCommandSender extends CommandSender {
+
+ @Override
+ default void sendMessage(@NotNull String[] messages) {
+ for (String message : messages) {
+ sendMessage(message);
+ }
+ }
+
+ @Override
+ default void sendMessage(@Nullable UUID sender, @NotNull String message) {
+ sendMessage(message);
+ }
+
+ @Override
+ default void sendMessage(@Nullable UUID sender, @NotNull String[] messages) {
+ for (String message : messages) {
+ sendMessage(message);
+ }
+ }
+
+ @NotNull
+ @Override
+ default Server getServer() {
+ return Bukkit.getServer();
+ }
+
2022-03-04 22:19:57 +01:00
+ // Paper start
+ @Override
+ default net.kyori.adventure.text.@org.jetbrains.annotations.NotNull Component name() {
2022-06-07 22:23:16 +02:00
+ throw new UnsupportedOperationException();
2022-03-04 22:19:57 +01:00
+ }
+ // Paper end
+
2021-06-11 14:02:28 +02:00
+ @NotNull
+ @Override
+ default String getName() {
2022-06-07 22:23:16 +02:00
+ throw new UnsupportedOperationException();
2021-06-11 14:02:28 +02:00
+ }
+
+ @Override
+ default boolean isOp() {
2022-06-07 22:23:16 +02:00
+ throw new UnsupportedOperationException();
2021-06-11 14:02:28 +02:00
+ }
+
+ @Override
+ default void setOp(boolean value) {
2022-06-07 22:23:16 +02:00
+ throw new UnsupportedOperationException();
2021-06-11 14:02:28 +02:00
+ }
+
+ @Override
+ default boolean isPermissionSet(@NotNull String name) {
2022-06-07 22:23:16 +02:00
+ throw new UnsupportedOperationException();
2021-06-11 14:02:28 +02:00
+ }
+
+ @Override
+ default boolean isPermissionSet(@NotNull Permission perm) {
2022-06-07 22:23:16 +02:00
+ throw new UnsupportedOperationException();
2021-06-11 14:02:28 +02:00
+ }
+
+ @Override
+ default boolean hasPermission(@NotNull String name) {
2022-06-07 22:23:16 +02:00
+ throw new UnsupportedOperationException();
2021-06-11 14:02:28 +02:00
+ }
+
+ @Override
+ default boolean hasPermission(@NotNull Permission perm) {
2022-06-07 22:23:16 +02:00
+ throw new UnsupportedOperationException();
2021-06-11 14:02:28 +02:00
+ }
+
+ @NotNull
+ @Override
+ default PermissionAttachment addAttachment(@NotNull Plugin plugin, @NotNull String name, boolean value) {
2022-06-07 22:23:16 +02:00
+ throw new UnsupportedOperationException();
2021-06-11 14:02:28 +02:00
+ }
+
+ @NotNull
+ @Override
+ default PermissionAttachment addAttachment(@NotNull Plugin plugin) {
2022-06-07 22:23:16 +02:00
+ throw new UnsupportedOperationException();
2021-06-11 14:02:28 +02:00
+ }
+
+ @NotNull
+ @Override
+ default PermissionAttachment addAttachment(@NotNull Plugin plugin, @NotNull String name, boolean value, int ticks) {
2022-06-07 22:23:16 +02:00
+ throw new UnsupportedOperationException();
2021-06-11 14:02:28 +02:00
+ }
+
+ @NotNull
+ @Override
+ default PermissionAttachment addAttachment(@NotNull Plugin plugin, int ticks) {
2022-06-07 22:23:16 +02:00
+ throw new UnsupportedOperationException();
2021-06-11 14:02:28 +02:00
+ }
+
+ @Override
+ default void removeAttachment(@NotNull PermissionAttachment attachment) {
2022-06-07 22:23:16 +02:00
+ throw new UnsupportedOperationException();
2021-06-11 14:02:28 +02:00
+ }
+
+ @Override
+ default void recalculatePermissions() {
2022-06-07 22:23:16 +02:00
+ throw new UnsupportedOperationException();
2021-06-11 14:02:28 +02:00
+ }
+
+ @NotNull
+ @Override
+ default Set<PermissionAttachmentInfo> getEffectivePermissions() {
2022-06-07 22:23:16 +02:00
+ throw new UnsupportedOperationException();
2021-06-11 14:02:28 +02:00
+ }
+
+ @NotNull
+ @Override
+ default Spigot spigot() {
2022-06-07 22:23:16 +02:00
+ throw new UnsupportedOperationException();
2021-06-11 14:02:28 +02:00
+ }
+
+}
diff --git a/src/main/java/org/bukkit/command/SimpleCommandMap.java b/src/main/java/org/bukkit/command/SimpleCommandMap.java
2024-06-13 16:45:27 +02:00
index 9207ae900cb4cc8ce41dd4e63d7ad8b35b0ac048..36fc2c35395c72f8b81a2a2f3265fd205384ce26 100644
2021-06-11 14:02:28 +02:00
--- a/src/main/java/org/bukkit/command/SimpleCommandMap.java
+++ b/src/main/java/org/bukkit/command/SimpleCommandMap.java
2024-06-13 16:45:27 +02:00
@@ -16,7 +16,6 @@ import org.bukkit.command.defaults.BukkitCommand;
2021-06-11 14:02:28 +02:00
import org.bukkit.command.defaults.HelpCommand;
import org.bukkit.command.defaults.PluginsCommand;
import org.bukkit.command.defaults.ReloadCommand;
-import org.bukkit.command.defaults.TimingsCommand;
import org.bukkit.command.defaults.VersionCommand;
import org.bukkit.entity.Player;
import org.bukkit.util.StringUtil;
2024-06-13 16:45:27 +02:00
@@ -36,7 +35,7 @@ public class SimpleCommandMap implements CommandMap {
2021-06-11 14:02:28 +02:00
register("bukkit", new VersionCommand("version"));
register("bukkit", new ReloadCommand("reload"));
2023-02-19 15:57:10 +01:00
//register("bukkit", new PluginsCommand("plugins")); // Paper
2021-06-11 14:02:28 +02:00
- register("bukkit", new TimingsCommand("timings"));
+ register("bukkit", new co.aikar.timings.TimingsCommand("timings")); // Paper
}
public void setFallbackCommands() {
2024-06-13 16:45:27 +02:00
@@ -68,6 +67,7 @@ public class SimpleCommandMap implements CommandMap {
2021-06-11 14:02:28 +02:00
*/
@Override
public boolean register(@NotNull String label, @NotNull String fallbackPrefix, @NotNull Command command) {
+ command.timings = co.aikar.timings.TimingsManager.getCommandTiming(fallbackPrefix, command); // Paper
2024-06-13 16:45:27 +02:00
label = label.toLowerCase(Locale.ROOT).trim();
fallbackPrefix = fallbackPrefix.toLowerCase(Locale.ROOT).trim();
2021-06-11 14:02:28 +02:00
boolean registered = register(label, command, false, fallbackPrefix);
2024-06-13 16:45:27 +02:00
@@ -144,16 +144,22 @@ public class SimpleCommandMap implements CommandMap {
2021-06-11 14:02:28 +02:00
return false;
}
+ // Paper start - Plugins do weird things to workaround normal registration
+ if (target.timings == null) {
+ target.timings = co.aikar.timings.TimingsManager.getCommandTiming(null, target);
+ }
+ // Paper end
+
try {
- target.timings.startTiming(); // Spigot
+ try (co.aikar.timings.Timing ignored = target.timings.startTiming()) { // Paper - use try with resources
// Note: we don't return the result of target.execute as thats success / failure, we return handled (true) or not handled (false)
target.execute(sender, sentCommandLabel, Arrays.copyOfRange(args, 1, args.length));
- target.timings.stopTiming(); // Spigot
+ } // target.timings.stopTiming(); // Spigot // Paper
} catch (CommandException ex) {
- target.timings.stopTiming(); // Spigot
+ //target.timings.stopTiming(); // Spigot // Paper
throw ex;
} catch (Throwable ex) {
- target.timings.stopTiming(); // Spigot
+ //target.timings.stopTiming(); // Spigot // Paper
throw new CommandException("Unhandled exception executing '" + commandLine + "' in " + target, ex);
}
diff --git a/src/main/java/org/bukkit/command/defaults/TimingsCommand.java b/src/main/java/org/bukkit/command/defaults/TimingsCommand.java
deleted file mode 100644
2022-06-07 19:20:30 +02:00
index 516d7fc7812aac343782861d0d567f54aa578c2a..0000000000000000000000000000000000000000
2021-06-11 14:02:28 +02:00
--- a/src/main/java/org/bukkit/command/defaults/TimingsCommand.java
+++ /dev/null
@@ -1,250 +0,0 @@
-package org.bukkit.command.defaults;
-
2022-06-07 19:20:30 +02:00
-import com.google.common.base.Preconditions;
2021-06-11 14:02:28 +02:00
-import com.google.common.collect.ImmutableList;
-import java.io.File;
-import java.io.IOException;
-import java.io.PrintStream;
-import java.util.ArrayList;
-import java.util.List;
-import org.bukkit.Bukkit;
-import org.bukkit.ChatColor;
-import org.bukkit.command.CommandSender;
-import org.bukkit.event.Event;
-import org.bukkit.event.HandlerList;
-import org.bukkit.plugin.Plugin;
-import org.bukkit.plugin.RegisteredListener;
-import org.bukkit.plugin.TimedRegisteredListener;
-import org.bukkit.util.StringUtil;
-import org.jetbrains.annotations.NotNull;
-
-// Spigot start
-// CHECKSTYLE:OFF
-import java.io.ByteArrayOutputStream;
-import java.io.OutputStream;
-import java.net.HttpURLConnection;
-import java.net.URL;
-import java.util.logging.Level;
-import org.bukkit.command.RemoteConsoleCommandSender;
-import org.bukkit.plugin.SimplePluginManager;
-import org.spigotmc.CustomTimingsHandler;
-// CHECKSTYLE:ON
-// Spigot end
-
-public class TimingsCommand extends BukkitCommand {
- private static final List<String> TIMINGS_SUBCOMMANDS = ImmutableList.of("report", "reset", "on", "off", "paste"); // Spigot
- public static long timingStart = 0; // Spigot
-
- public TimingsCommand(@NotNull String name) {
- super(name);
- this.description = "Manages Spigot Timings data to see performance of the server."; // Spigot
- this.usageMessage = "/timings <reset|report|on|off|paste>"; // Spigot
- this.setPermission("bukkit.command.timings");
- }
-
- // Spigot start - redesigned Timings Command
- public void executeSpigotTimings(@NotNull CommandSender sender, @NotNull String[] args) {
- if ("on".equals(args[0])) {
- ((SimplePluginManager) Bukkit.getPluginManager()).useTimings(true);
- CustomTimingsHandler.reload();
- sender.sendMessage("Enabled Timings & Reset");
- return;
- } else if ("off".equals(args[0])) {
- ((SimplePluginManager) Bukkit.getPluginManager()).useTimings(false);
- sender.sendMessage("Disabled Timings");
- return;
- }
-
- if (!Bukkit.getPluginManager().useTimings()) {
- sender.sendMessage("Please enable timings by typing /timings on");
- return;
- }
-
- boolean paste = "paste".equals(args[0]);
- if ("reset".equals(args[0])) {
- CustomTimingsHandler.reload();
- sender.sendMessage("Timings reset");
- } else if ("merged".equals(args[0]) || "report".equals(args[0]) || paste) {
- long sampleTime = System.nanoTime() - timingStart;
- int index = 0;
- File timingFolder = new File("timings");
- timingFolder.mkdirs();
- File timings = new File(timingFolder, "timings.txt");
- ByteArrayOutputStream bout = (paste) ? new ByteArrayOutputStream() : null;
- while (timings.exists()) timings = new File(timingFolder, "timings" + (++index) + ".txt");
- PrintStream fileTimings = null;
- try {
- fileTimings = (paste) ? new PrintStream(bout) : new PrintStream(timings);
-
- CustomTimingsHandler.printTimings(fileTimings);
- fileTimings.println("Sample time " + sampleTime + " (" + sampleTime / 1E9 + "s)");
-
- fileTimings.println("<spigotConfig>");
- fileTimings.println(Bukkit.spigot().getConfig().saveToString());
- fileTimings.println("</spigotConfig>");
-
- if (paste) {
- new PasteThread(sender, bout).start();
- return;
- }
-
- sender.sendMessage("Timings written to " + timings.getPath());
- sender.sendMessage("Paste contents of file into form at http://www.spigotmc.org/go/timings to read results.");
-
- } catch (IOException e) {
- } finally {
- if (fileTimings != null) {
- fileTimings.close();
- }
- }
- }
- }
- // Spigot end
-
- @Override
- public boolean execute(@NotNull CommandSender sender, @NotNull String currentAlias, @NotNull String[] args) {
- if (!testPermission(sender)) return true;
- if (args.length < 1) { // Spigot
- sender.sendMessage(ChatColor.RED + "Usage: " + usageMessage);
- return false;
- }
- // Spigot start
- if (true) {
- executeSpigotTimings(sender, args);
- return true;
- }
- // Spigot end
- if (!sender.getServer().getPluginManager().useTimings()) {
- sender.sendMessage("Please enable timings by setting \"settings.plugin-profiling\" to true in bukkit.yml");
- return true;
- }
-
- boolean separate = "separate".equalsIgnoreCase(args[0]);
- if ("reset".equalsIgnoreCase(args[0])) {
- for (HandlerList handlerList : HandlerList.getHandlerLists()) {
- for (RegisteredListener listener : handlerList.getRegisteredListeners()) {
- if (listener instanceof TimedRegisteredListener) {
- ((TimedRegisteredListener) listener).reset();
- }
- }
- }
- sender.sendMessage("Timings reset");
- } else if ("merged".equalsIgnoreCase(args[0]) || separate) {
-
- int index = 0;
- int pluginIdx = 0;
- File timingFolder = new File("timings");
- timingFolder.mkdirs();
- File timings = new File(timingFolder, "timings.txt");
- File names = null;
- while (timings.exists()) timings = new File(timingFolder, "timings" + (++index) + ".txt");
- PrintStream fileTimings = null;
- PrintStream fileNames = null;
- try {
- fileTimings = new PrintStream(timings);
- if (separate) {
- names = new File(timingFolder, "names" + index + ".txt");
- fileNames = new PrintStream(names);
- }
- for (Plugin plugin : Bukkit.getPluginManager().getPlugins()) {
- pluginIdx++;
- long totalTime = 0;
- if (separate) {
- fileNames.println(pluginIdx + " " + plugin.getDescription().getFullName());
- fileTimings.println("Plugin " + pluginIdx);
- } else {
- fileTimings.println(plugin.getDescription().getFullName());
- }
- for (RegisteredListener listener : HandlerList.getRegisteredListeners(plugin)) {
- if (listener instanceof TimedRegisteredListener) {
- TimedRegisteredListener trl = (TimedRegisteredListener) listener;
- long time = trl.getTotalTime();
- int count = trl.getCount();
- if (count == 0) continue;
- long avg = time / count;
- totalTime += time;
- Class<? extends Event> eventClass = trl.getEventClass();
- if (count > 0 && eventClass != null) {
- fileTimings.println(" " + eventClass.getSimpleName() + (trl.hasMultiple() ? " (and sub-classes)" : "") + " Time: " + time + " Count: " + count + " Avg: " + avg);
- }
- }
- }
- fileTimings.println(" Total time " + totalTime + " (" + totalTime / 1000000000 + "s)");
- }
- sender.sendMessage("Timings written to " + timings.getPath());
- if (separate) sender.sendMessage("Names written to " + names.getPath());
- } catch (IOException e) {
- } finally {
- if (fileTimings != null) {
- fileTimings.close();
- }
- if (fileNames != null) {
- fileNames.close();
- }
- }
- } else {
- sender.sendMessage(ChatColor.RED + "Usage: " + usageMessage);
- return false;
- }
- return true;
- }
-
- @NotNull
- @Override
- public List<String> tabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) {
2022-06-07 19:20:30 +02:00
- Preconditions.checkArgument(sender != null, "Sender cannot be null");
- Preconditions.checkArgument(args != null, "Arguments cannot be null");
- Preconditions.checkArgument(alias != null, "Alias cannot be null");
2021-06-11 14:02:28 +02:00
-
- if (args.length == 1) {
- return StringUtil.copyPartialMatches(args[0], TIMINGS_SUBCOMMANDS, new ArrayList<String>(TIMINGS_SUBCOMMANDS.size()));
- }
- return ImmutableList.of();
- }
-
- // Spigot start
- private static class PasteThread extends Thread {
-
- private final CommandSender sender;
- private final ByteArrayOutputStream bout;
-
- public PasteThread(@NotNull CommandSender sender, @NotNull ByteArrayOutputStream bout) {
- super("Timings paste thread");
- this.sender = sender;
- this.bout = bout;
- }
-
- @Override
- public synchronized void start() {
- if (sender instanceof RemoteConsoleCommandSender) {
- run();
- } else {
- super.start();
- }
- }
-
- @Override
- public void run() {
- try {
- HttpURLConnection con = (HttpURLConnection) new URL("https://timings.spigotmc.org/paste").openConnection();
- con.setDoOutput(true);
- con.setRequestMethod("POST");
- con.setInstanceFollowRedirects(false);
-
- OutputStream out = con.getOutputStream();
- out.write(bout.toByteArray());
- out.close();
-
- com.google.gson.JsonObject location = new com.google.gson.Gson().fromJson(new java.io.InputStreamReader(con.getInputStream()), com.google.gson.JsonObject.class);
- con.getInputStream().close();
-
- String pasteID = location.get("key").getAsString();
- sender.sendMessage(ChatColor.GREEN + "Timings results can be viewed at https://www.spigotmc.org/go/timings?url=" + pasteID);
- } catch (IOException ex) {
- sender.sendMessage(ChatColor.RED + "Error pasting timings, check your console for more information");
- Bukkit.getServer().getLogger().log(Level.WARNING, "Could not paste timings", ex);
- }
- }
- }
- // Spigot end
-}
diff --git a/src/main/java/org/bukkit/entity/Player.java b/src/main/java/org/bukkit/entity/Player.java
2024-10-22 18:23:19 +02:00
index 0f562dcca9bb0ffc3a3fcb1c2221306ec156c71b..9e072342eb5af366a4f860db71e15a63b29038aa 100644
2021-06-11 14:02:28 +02:00
--- a/src/main/java/org/bukkit/entity/Player.java
+++ b/src/main/java/org/bukkit/entity/Player.java
2024-10-22 18:23:19 +02:00
@@ -2746,7 +2746,19 @@ public interface Player extends HumanEntity, Conversable, OfflinePlayer, PluginM
2022-03-04 22:19:57 +01:00
@Deprecated // Paper
2023-03-10 21:18:50 +01:00
public void sendMessage(@NotNull net.md_5.bungee.api.ChatMessageType position, @Nullable java.util.UUID sender, @NotNull net.md_5.bungee.api.chat.BaseComponent... components) {
2021-06-11 14:02:28 +02:00
throw new UnsupportedOperationException("Not supported yet.");
+
2023-03-23 22:57:03 +01:00
+ }
2021-06-11 14:02:28 +02:00
+
+ // Paper start
2023-09-22 04:31:59 +02:00
+ /**
+ * @return the player's ping
+ * @deprecated use {@link Player#getPing()}
+ */
+ @Deprecated
2021-06-11 14:02:28 +02:00
+ public int getPing() {
+ throw new UnsupportedOperationException( "Not supported yet." );
2023-03-23 22:57:03 +01:00
}
2021-06-11 14:02:28 +02:00
+ // Paper end
}
@NotNull
diff --git a/src/main/java/org/bukkit/plugin/SimplePluginManager.java b/src/main/java/org/bukkit/plugin/SimplePluginManager.java
2024-06-13 16:45:27 +02:00
index 46c7be5fa69f13900860b9944523beea16f2409b..6018574cd15b802833613beefa88da15dc2730cb 100644
2021-06-11 14:02:28 +02:00
--- a/src/main/java/org/bukkit/plugin/SimplePluginManager.java
+++ b/src/main/java/org/bukkit/plugin/SimplePluginManager.java
2024-06-13 16:45:27 +02:00
@@ -381,7 +381,6 @@ public final class SimplePluginManager implements PluginManager {
2021-06-11 14:02:28 +02:00
}
}
- org.bukkit.command.defaults.TimingsCommand.timingStart = System.nanoTime(); // Spigot
return result.toArray(new Plugin[result.size()]);
}
2024-06-13 16:45:27 +02:00
@@ -429,9 +428,9 @@ public final class SimplePluginManager implements PluginManager {
2021-06-11 14:02:28 +02:00
if (result != null) {
plugins.add(result);
- lookupNames.put(result.getDescription().getName(), result);
+ lookupNames.put(result.getDescription().getName().toLowerCase(java.util.Locale.ENGLISH), result); // Paper
for (String provided : result.getDescription().getProvides()) {
- lookupNames.putIfAbsent(provided, result);
+ lookupNames.putIfAbsent(provided.toLowerCase(java.util.Locale.ENGLISH), result); // Paper
}
}
2024-06-13 16:45:27 +02:00
@@ -461,7 +460,7 @@ public final class SimplePluginManager implements PluginManager {
2021-06-11 14:02:28 +02:00
@Nullable
public synchronized Plugin getPlugin(@NotNull String name) {
2023-02-19 15:57:10 +01:00
if (true) {return this.paperPluginManager.getPlugin(name);} // Paper
2021-06-11 14:02:28 +02:00
- return lookupNames.get(name.replace(' ', '_'));
+ return lookupNames.get(name.replace(' ', '_').toLowerCase(java.util.Locale.ENGLISH)); // Paper
}
@Override
2024-06-13 16:45:27 +02:00
@@ -689,7 +688,8 @@ public final class SimplePluginManager implements PluginManager {
2021-06-11 14:02:28 +02:00
throw new IllegalPluginAccessException("Plugin attempted to register " + event + " while not enabled");
}
- if (useTimings) {
+ executor = new co.aikar.timings.TimedEventExecutor(executor, plugin, null, event); // Paper
+ if (false) { // Spigot - RL handles useTimings check now // Paper
getEventListeners(event).register(new TimedRegisteredListener(listener, executor, priority, plugin, ignoreCancelled));
} else {
getEventListeners(event).register(new RegisteredListener(listener, executor, priority, plugin, ignoreCancelled));
2024-06-13 16:45:27 +02:00
@@ -924,7 +924,7 @@ public final class SimplePluginManager implements PluginManager {
2021-06-11 14:02:28 +02:00
@Override
public boolean useTimings() {
2023-02-19 15:57:10 +01:00
if (true) {return this.paperPluginManager.useTimings();} // Paper
2021-06-11 14:02:28 +02:00
- return useTimings;
+ return co.aikar.timings.Timings.isTimingsEnabled(); // Spigot
}
/**
2024-06-13 16:45:27 +02:00
@@ -933,7 +933,7 @@ public final class SimplePluginManager implements PluginManager {
2021-06-11 14:02:28 +02:00
* @param use True if per event timing code should be used
*/
public void useTimings(boolean use) {
- useTimings = use;
+ co.aikar.timings.Timings.setTimingsEnabled(use); // Paper
}
2023-02-19 15:57:10 +01:00
// Paper start
2021-06-11 14:02:28 +02:00
diff --git a/src/main/java/org/bukkit/plugin/java/JavaPluginLoader.java b/src/main/java/org/bukkit/plugin/java/JavaPluginLoader.java
2023-03-14 18:11:24 +01:00
index ab04ffe4cd05315a2ee0f64c553b4c674740eb7f..de6b6188587fd254ab96cbc1f95fda2056d9cbe2 100644
2021-06-11 14:02:28 +02:00
--- a/src/main/java/org/bukkit/plugin/java/JavaPluginLoader.java
+++ b/src/main/java/org/bukkit/plugin/java/JavaPluginLoader.java
2023-02-19 15:57:10 +01:00
@@ -55,7 +55,6 @@ public final class JavaPluginLoader implements PluginLoader {
2021-06-11 14:02:28 +02:00
private final Pattern[] fileFilters = new Pattern[]{Pattern.compile("\\.jar$")};
private final List<PluginClassLoader> loaders = new CopyOnWriteArrayList<PluginClassLoader>();
private final LibraryLoader libraryLoader;
- public static final CustomTimingsHandler pluginParentTimer = new CustomTimingsHandler("** Plugins"); // Spigot
/**
* This class was not meant to be constructed explicitly
2023-02-19 15:57:10 +01:00
@@ -294,27 +293,21 @@ public final class JavaPluginLoader implements PluginLoader {
2021-06-11 14:02:28 +02:00
}
}
- final CustomTimingsHandler timings = new CustomTimingsHandler("Plugin: " + plugin.getDescription().getFullName() + " Event: " + listener.getClass().getName() + "::" + method.getName() + "(" + eventClass.getSimpleName() + ")", pluginParentTimer); // Spigot
- EventExecutor executor = new EventExecutor() {
+ EventExecutor executor = new co.aikar.timings.TimedEventExecutor(new EventExecutor() { // Paper
@Override
- public void execute(@NotNull Listener listener, @NotNull Event event) throws EventException {
+ public void execute(@NotNull Listener listener, @NotNull Event event) throws EventException { // Paper
try {
if (!eventClass.isAssignableFrom(event.getClass())) {
return;
}
- // Spigot start
- boolean isAsync = event.isAsynchronous();
- if (!isAsync) timings.startTiming();
method.invoke(listener, event);
- if (!isAsync) timings.stopTiming();
- // Spigot end
} catch (InvocationTargetException ex) {
throw new EventException(ex.getCause());
} catch (Throwable t) {
throw new EventException(t);
}
}
- };
+ }, plugin, method, eventClass); // Paper
if (false) { // Spigot - RL handles useTimings check now
eventSet.add(new TimedRegisteredListener(listener, executor, eh.priority(), plugin, eh.ignoreCancelled()));
} else {
diff --git a/src/main/java/org/bukkit/util/CachedServerIcon.java b/src/main/java/org/bukkit/util/CachedServerIcon.java
index 5ca863b3692b2e1b58e7fb4d82f554a92cc4f01e..612958a331575d1da2715531ebdf6b1168f2e860 100644
--- a/src/main/java/org/bukkit/util/CachedServerIcon.java
+++ b/src/main/java/org/bukkit/util/CachedServerIcon.java
@@ -2,6 +2,7 @@ package org.bukkit.util;
import org.bukkit.Server;
import org.bukkit.event.server.ServerListPingEvent;
+import org.jetbrains.annotations.Nullable;
/**
* This is a cached version of a server-icon. It's internal representation
@@ -12,4 +13,9 @@ import org.bukkit.event.server.ServerListPingEvent;
* @see Server#loadServerIcon(java.io.File)
* @see ServerListPingEvent#setServerIcon(CachedServerIcon)
*/
-public interface CachedServerIcon {}
+public interface CachedServerIcon {
+
+ @Nullable
+ public String getData(); // Paper
+
+}
diff --git a/src/main/java/org/spigotmc/CustomTimingsHandler.java b/src/main/java/org/spigotmc/CustomTimingsHandler.java
2023-03-28 04:58:46 +02:00
index 44badfedcc3fdc26bdc293b85d8c781d6f659faa..12946bd55fcf7c40d39081779a7fa30049ee6165 100644
2021-06-11 14:02:28 +02:00
--- a/src/main/java/org/spigotmc/CustomTimingsHandler.java
+++ b/src/main/java/org/spigotmc/CustomTimingsHandler.java
2021-12-12 08:03:06 +01:00
@@ -1,137 +1,67 @@
2021-06-11 14:02:28 +02:00
+/*
+ * This file is licensed under the MIT License (MIT).
+ *
+ * Copyright (c) 2014 Daniel Ennis <http://aikar.co>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
package org.spigotmc;
2021-12-12 08:03:06 +01:00
-import java.io.PrintStream;
-import java.util.Queue;
-import java.util.concurrent.ConcurrentLinkedQueue;
2021-06-11 14:02:28 +02:00
import org.bukkit.Bukkit;
2021-12-12 08:03:06 +01:00
-import org.bukkit.World;
2021-06-11 14:02:28 +02:00
-import org.bukkit.command.defaults.TimingsCommand;
import org.jetbrains.annotations.NotNull;
2021-12-12 08:03:06 +01:00
-import org.jetbrains.annotations.Nullable;
2021-06-11 14:02:28 +02:00
+import org.bukkit.plugin.AuthorNagException;
+import co.aikar.timings.Timing;
+import co.aikar.timings.Timings;
+import co.aikar.timings.TimingsManager;
+
+import java.lang.reflect.Method;
+import java.util.logging.Level;
/**
- * Provides custom timing sections for /timings merged.
+ * This is here for legacy purposes incase any plugin used it.
+ *
+ * If you use this, migrate ASAP as this will be removed in the future!
+ *
+ * @deprecated
+ * @see co.aikar.timings.Timings#of
*/
-public class CustomTimingsHandler {
-
- private static Queue<CustomTimingsHandler> HANDLERS = new ConcurrentLinkedQueue<CustomTimingsHandler>();
- /*========================================================================*/
- private final String name;
- private final CustomTimingsHandler parent;
- private long count = 0;
- private long start = 0;
- private long timingDepth = 0;
- private long totalTime = 0;
- private long curTickTotal = 0;
- private long violations = 0;
2023-03-28 04:58:46 +02:00
+@Deprecated(forRemoval = true)
2021-06-11 14:02:28 +02:00
+public final class CustomTimingsHandler {
+ private final Timing handler;
public CustomTimingsHandler(@NotNull String name) {
- this(name, null);
- }
2023-03-23 22:57:03 +01:00
-
2021-06-11 14:02:28 +02:00
- public CustomTimingsHandler(@NotNull String name, @Nullable CustomTimingsHandler parent) {
- this.name = name;
- this.parent = parent;
- HANDLERS.add(this);
- }
2021-12-12 08:03:06 +01:00
-
2021-06-11 14:02:28 +02:00
- /**
- * Prints the timings and extra data to the given stream.
- *
- * @param printStream output stream
- */
- public static void printTimings(@NotNull PrintStream printStream) {
- printStream.println("Minecraft");
- for (CustomTimingsHandler timings : HANDLERS) {
- long time = timings.totalTime;
- long count = timings.count;
- if (count == 0) {
- continue;
2021-12-12 08:03:06 +01:00
- }
2021-06-11 14:02:28 +02:00
- long avg = time / count;
-
- printStream.println(" " + timings.name + " Time: " + time + " Count: " + count + " Avg: " + avg + " Violations: " + timings.violations);
2023-03-23 22:57:03 +01:00
- }
2021-06-11 14:02:28 +02:00
- printStream.println("# Version " + Bukkit.getVersion());
- int entities = 0;
- int livingEntities = 0;
- for (World world : Bukkit.getWorlds()) {
- entities += world.getEntities().size();
- livingEntities += world.getLivingEntities().size();
2021-12-12 08:03:06 +01:00
- }
2021-06-11 14:02:28 +02:00
- printStream.println("# Entities " + entities);
- printStream.println("# LivingEntities " + livingEntities);
2023-03-23 22:57:03 +01:00
- }
-
2021-06-11 14:02:28 +02:00
- /**
- * Resets all timings.
- */
- public static void reload() {
- if (Bukkit.getPluginManager().useTimings()) {
- for (CustomTimingsHandler timings : HANDLERS) {
- timings.reset();
2021-12-12 08:03:06 +01:00
- }
- }
2021-06-11 14:02:28 +02:00
- TimingsCommand.timingStart = System.nanoTime();
- }
2023-03-23 22:57:03 +01:00
-
2021-06-11 14:02:28 +02:00
- /**
- * Ticked every tick by CraftBukkit to count the number of times a timer
- * caused TPS loss.
- */
- public static void tick() {
- if (Bukkit.getPluginManager().useTimings()) {
- for (CustomTimingsHandler timings : HANDLERS) {
- if (timings.curTickTotal > 50000000) {
- timings.violations += Math.ceil(timings.curTickTotal / 50000000);
- }
- timings.curTickTotal = 0;
- timings.timingDepth = 0; // incase reset messes this up
- }
- }
- }
2023-03-23 22:57:03 +01:00
+ Timing timing;
2021-06-11 14:02:28 +02:00
- /**
- * Starts timing to track a section of code.
- */
- public void startTiming() {
- // If second condtion fails we are already timing
- if (Bukkit.getPluginManager().useTimings() && ++timingDepth == 1) {
- start = System.nanoTime();
- if (parent != null && ++parent.timingDepth == 1) {
- parent.start = start;
- }
2023-03-23 22:57:03 +01:00
+ new AuthorNagException("Deprecated use of CustomTimingsHandler. Please Switch to Timings.of ASAP").printStackTrace();
+ try {
+ final Method ofSafe = TimingsManager.class.getDeclaredMethod("getHandler", String.class, String.class, Timing.class);
+ ofSafe.setAccessible(true);
+ timing = (Timing) ofSafe.invoke(null,"Minecraft", "(Deprecated API) " + name, null);
+ } catch (Exception e) {
+ e.printStackTrace();
+ Bukkit.getLogger().log(Level.SEVERE, "This handler could not be registered");
+ timing = Timings.NULL_HANDLER;
}
+ handler = timing;
}
2021-06-11 14:02:28 +02:00
- /**
- * Stops timing a section of code.
- */
- public void stopTiming() {
- if (Bukkit.getPluginManager().useTimings()) {
- if (--timingDepth != 0 || start == 0) {
- return;
- }
- long diff = System.nanoTime() - start;
- totalTime += diff;
- curTickTotal += diff;
- count++;
- start = 0;
- if (parent != null) {
- parent.stopTiming();
2021-12-12 08:03:06 +01:00
- }
- }
- }
2023-03-23 22:57:03 +01:00
+ public void startTiming() { handler.startTiming(); }
+ public void stopTiming() { handler.stopTiming(); }
2021-06-11 14:02:28 +02:00
- /**
- * Reset this timer, setting all values to zero.
- */
- public void reset() {
- count = 0;
- violations = 0;
- curTickTotal = 0;
- totalTime = 0;
- start = 0;
- timingDepth = 0;
- }
}
