296 lines
11 KiB
Java
296 lines
11 KiB
Java
/**
|
|
* ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
|
|
* Copyright (C) 2012 Kristian S. Stangeland
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it under the terms of the
|
|
* GNU General Public License as published by the Free Software Foundation; either version 2 of
|
|
* the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
|
|
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
* See the GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along with this program;
|
|
* if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
|
|
* 02111-1307 USA
|
|
*/
|
|
package com.comphenix.protocol;
|
|
|
|
import com.comphenix.protocol.error.DetailedErrorReporter;
|
|
import com.comphenix.protocol.error.ErrorReporter;
|
|
import com.comphenix.protocol.events.PacketListener;
|
|
import com.comphenix.protocol.timing.TimedListenerManager;
|
|
import com.comphenix.protocol.timing.TimingReportGenerator;
|
|
import com.comphenix.protocol.updater.Updater;
|
|
import com.comphenix.protocol.updater.Updater.UpdateType;
|
|
import com.comphenix.protocol.utility.Closer;
|
|
import org.bukkit.ChatColor;
|
|
import org.bukkit.command.CommandSender;
|
|
import org.bukkit.plugin.Plugin;
|
|
import org.bukkit.plugin.PluginDescriptionFile;
|
|
|
|
import java.io.File;
|
|
import java.io.FileWriter;
|
|
import java.io.IOException;
|
|
import java.io.PrintWriter;
|
|
import java.text.SimpleDateFormat;
|
|
import java.util.Date;
|
|
import java.util.HashSet;
|
|
import java.util.Set;
|
|
import java.util.concurrent.TimeUnit;
|
|
import java.util.logging.Level;
|
|
|
|
/**
|
|
* Handles the "protocol" administration command.
|
|
*
|
|
* @author Kristian
|
|
*/
|
|
class CommandProtocol extends CommandBase {
|
|
/**
|
|
* Name of this command.
|
|
*/
|
|
public static final String NAME = "protocol";
|
|
|
|
private final Plugin plugin;
|
|
private final Updater updater;
|
|
private final ProtocolConfig config;
|
|
|
|
public CommandProtocol(ErrorReporter reporter, Plugin plugin, Updater updater, ProtocolConfig config) {
|
|
super(reporter, CommandBase.PERMISSION_ADMIN, NAME, 1);
|
|
this.plugin = plugin;
|
|
this.updater = updater;
|
|
this.config = config;
|
|
}
|
|
|
|
@Override
|
|
protected boolean handleCommand(CommandSender sender, String[] args) {
|
|
// Only return TRUE if we executed the correct command
|
|
switch (args[0].toLowerCase())
|
|
{
|
|
case "config":
|
|
case "reload":
|
|
reloadConfiguration(sender);
|
|
break;
|
|
case "check":
|
|
checkVersion(sender, true);
|
|
break;
|
|
case "update":
|
|
updateVersion(sender, true);
|
|
break;
|
|
case "timings":
|
|
toggleTimings(sender, args);
|
|
break;
|
|
case "listeners":
|
|
printListeners(sender);
|
|
break;
|
|
case "version":
|
|
printVersion(sender);
|
|
break;
|
|
case "dump":
|
|
dump(sender);
|
|
break;
|
|
default:
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public void checkVersion(final CommandSender sender, boolean command) {
|
|
performUpdate(sender, UpdateType.NO_DOWNLOAD, command);
|
|
}
|
|
|
|
public void updateVersion(final CommandSender sender, boolean command) {
|
|
performUpdate(sender, UpdateType.DEFAULT, command);
|
|
}
|
|
|
|
// Display every listener on the server
|
|
private void printListeners(final CommandSender sender) {
|
|
ProtocolManager manager = ProtocolLibrary.getProtocolManager();
|
|
|
|
sender.sendMessage(ChatColor.GOLD + "Packet listeners:");
|
|
for (PacketListener listener : manager.getPacketListeners()) {
|
|
sender.sendMessage(ChatColor.GOLD + " - " + listener);
|
|
}
|
|
|
|
// Along with every asynchronous listener
|
|
sender.sendMessage(ChatColor.GOLD + "Asynchronous listeners:");
|
|
for (PacketListener listener : manager.getAsynchronousManager().getAsyncHandlers()) {
|
|
sender.sendMessage(ChatColor.GOLD + " - " + listener);
|
|
}
|
|
}
|
|
|
|
private void performUpdate(final CommandSender sender, UpdateType type, final boolean command) {
|
|
if (updater.isChecking()) {
|
|
sender.sendMessage(ChatColor.RED + "Already checking for an update.");
|
|
return;
|
|
}
|
|
|
|
// Perform on an async thread
|
|
Runnable notify = new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
if (command) {
|
|
sender.sendMessage(ChatColor.YELLOW + "[ProtocolLib] " + updater.getResult());
|
|
String remoteVersion = updater.getRemoteVersion();
|
|
if (remoteVersion != null) {
|
|
sender.sendMessage(ChatColor.YELLOW + "Remote version: " + remoteVersion);
|
|
sender.sendMessage(ChatColor.YELLOW + "Current version: " + plugin.getDescription().getVersion());
|
|
}
|
|
} else if (updater.shouldNotify() || config.isDebug()) {
|
|
sender.sendMessage(ChatColor.YELLOW + "[ProtocolLib] " + updater.getResult());
|
|
}
|
|
|
|
updater.removeListener(this);
|
|
updateFinished();
|
|
}
|
|
};
|
|
updater.start(type);
|
|
updater.addListener(notify);
|
|
}
|
|
|
|
private void toggleTimings(CommandSender sender, String[] args) {
|
|
TimedListenerManager manager = TimedListenerManager.getInstance();
|
|
boolean state = !manager.isTiming(); // toggle
|
|
|
|
// Parse the boolean parameter
|
|
if (args.length == 2) {
|
|
Boolean parsed = parseBoolean(toQueue(args, 2), "start");
|
|
|
|
if (parsed != null) {
|
|
state = parsed;
|
|
} else {
|
|
sender.sendMessage(ChatColor.RED + "Specify a state: ON or OFF.");
|
|
return;
|
|
}
|
|
} else if (args.length > 2) {
|
|
sender.sendMessage(ChatColor.RED + "Too many parameters.");
|
|
return;
|
|
}
|
|
|
|
// Now change the state
|
|
if (state) {
|
|
if (manager.startTiming())
|
|
sender.sendMessage(ChatColor.GOLD + "Started timing packet listeners.");
|
|
else
|
|
sender.sendMessage(ChatColor.RED + "Packet timing already started.");
|
|
} else {
|
|
if (manager.stopTiming()) {
|
|
saveTimings(manager);
|
|
sender.sendMessage(ChatColor.GOLD + "Stopped and saved result in plugin folder.");
|
|
} else {
|
|
sender.sendMessage(ChatColor.RED + "Packet timing already stopped.");
|
|
}
|
|
}
|
|
}
|
|
|
|
private void saveTimings(TimedListenerManager manager) {
|
|
try {
|
|
File destination = new File(plugin.getDataFolder(), "Timings - " + System.currentTimeMillis() + ".txt");
|
|
TimingReportGenerator generator = new TimingReportGenerator();
|
|
|
|
// Print to a text file
|
|
generator.saveTo(destination, manager);
|
|
manager.clear();
|
|
|
|
} catch (IOException e) {
|
|
reporter.reportMinimal(plugin, "saveTimings()", e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Prevent further automatic updates until the next delay.
|
|
*/
|
|
public void updateFinished() {
|
|
long currentTime = TimeUnit.MILLISECONDS.toSeconds(System.currentTimeMillis());
|
|
|
|
config.setAutoLastTime(currentTime);
|
|
config.saveAll();
|
|
}
|
|
|
|
public void reloadConfiguration(CommandSender sender) {
|
|
plugin.reloadConfig();
|
|
sender.sendMessage(ChatColor.YELLOW + "Reloaded configuration!");
|
|
}
|
|
|
|
private void printVersion(CommandSender sender) {
|
|
PluginDescriptionFile desc = plugin.getDescription();
|
|
|
|
sender.sendMessage(ChatColor.GREEN + desc.getName() + ChatColor.WHITE + " v" + ChatColor.GREEN + desc.getVersion());
|
|
sender.sendMessage(ChatColor.WHITE + "Authors: " + ChatColor.GREEN + "dmulloy2" + ChatColor.WHITE + " and " + ChatColor.GREEN + "Comphenix");
|
|
sender.sendMessage(ChatColor.WHITE + "Issues: " + ChatColor.GREEN + "https://github.com/dmulloy2/ProtocolLib/issues");
|
|
}
|
|
|
|
private static SimpleDateFormat FILE_FORMAT;
|
|
private static SimpleDateFormat TIMESTAMP_FORMAT;
|
|
|
|
private void dump(CommandSender sender) {
|
|
|
|
if (FILE_FORMAT == null)
|
|
FILE_FORMAT = new SimpleDateFormat("yyyy-MM-dd_HH.mm.ss");
|
|
if (TIMESTAMP_FORMAT == null)
|
|
TIMESTAMP_FORMAT = new SimpleDateFormat("MM/dd/yy HH:mm:ss");
|
|
|
|
try (Closer closer = Closer.create()) {
|
|
Date date = new Date();
|
|
File file = new File(plugin.getDataFolder(), "dump-" + FILE_FORMAT.format(date) + ".txt");
|
|
if (file.exists()) {
|
|
file.delete();
|
|
}
|
|
|
|
file.createNewFile();
|
|
|
|
FileWriter fw = closer.register(new FileWriter(file));
|
|
PrintWriter pw = closer.register(new PrintWriter(fw));
|
|
|
|
pw.println("ProtocolLib Dump");
|
|
pw.println("Timestamp: " + TIMESTAMP_FORMAT.format(date));
|
|
pw.println();
|
|
|
|
pw.println("ProtocolLib Version: " + plugin.toString());
|
|
pw.println("Bukkit Version: " + plugin.getServer().getBukkitVersion());
|
|
pw.println("Server Version: " + plugin.getServer().getVersion());
|
|
pw.println("Java Version: " + System.getProperty("java.version"));
|
|
pw.println();
|
|
|
|
ProtocolManager manager = ProtocolLibrary.getProtocolManager();
|
|
pw.println("ProtocolLib: " + DetailedErrorReporter.getStringDescription(plugin));
|
|
pw.println("Manager: " + DetailedErrorReporter.getStringDescription(manager));
|
|
pw.println();
|
|
|
|
Set<PacketListener> listeners = manager.getPacketListeners();
|
|
Set<Plugin> plugins = new HashSet<>();
|
|
|
|
if (!listeners.isEmpty()) {
|
|
pw.println("Listeners:");
|
|
|
|
for (PacketListener listener : listeners) {
|
|
pw.println(DetailedErrorReporter.getStringDescription(listener));
|
|
|
|
Plugin plugin = listener.getPlugin();
|
|
if (plugin != null) {
|
|
plugins.add(plugin);
|
|
} else {
|
|
pw.println("(Missing plugin!)");
|
|
}
|
|
}
|
|
|
|
pw.println();
|
|
} else {
|
|
pw.println("No listeners");
|
|
}
|
|
|
|
if (!plugins.isEmpty()) {
|
|
pw.println("Plugins Using ProtocolLib:");
|
|
for (Plugin plugin : plugins) {
|
|
pw.println(plugin.getName() + " by " + plugin.getDescription().getAuthors());
|
|
}
|
|
}
|
|
|
|
sender.sendMessage("Data dump written to " + file.getAbsolutePath());
|
|
} catch (IOException ex) {
|
|
ProtocolLogger.log(Level.SEVERE, "Failed to create dump:", ex);
|
|
sender.sendMessage(ChatColor.RED + "Failed to create dump! Check console!");
|
|
}
|
|
}
|
|
}
|