505 lines
14 KiB
Java
505 lines
14 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 java.io.File;
|
|
import java.io.IOException;
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
import java.util.Locale;
|
|
|
|
import org.bukkit.configuration.Configuration;
|
|
import org.bukkit.configuration.ConfigurationSection;
|
|
import org.bukkit.plugin.Plugin;
|
|
|
|
import com.comphenix.protocol.injector.PlayerInjectHooks;
|
|
import com.google.common.base.Charsets;
|
|
import com.google.common.collect.ImmutableList;
|
|
import com.google.common.collect.Lists;
|
|
import com.google.common.io.Files;
|
|
|
|
/**
|
|
* Represents the configuration of ProtocolLib.
|
|
*
|
|
* @author Kristian
|
|
*/
|
|
public class ProtocolConfig {
|
|
private static final String LAST_UPDATE_FILE = "lastupdate";
|
|
|
|
private static final String SECTION_GLOBAL = "global";
|
|
private static final String SECTION_AUTOUPDATER = "auto updater";
|
|
|
|
private static final String METRICS_ENABLED = "metrics";
|
|
|
|
private static final String IGNORE_VERSION_CHECK = "ignore version check";
|
|
private static final String BACKGROUND_COMPILER_ENABLED = "background compiler";
|
|
|
|
private static final String DEBUG_MODE_ENABLED = "debug";
|
|
private static final String DETAILED_ERROR = "detailed error";
|
|
private static final String INJECTION_METHOD = "injection method";
|
|
|
|
private static final String SCRIPT_ENGINE_NAME = "script engine";
|
|
private static final String SUPPRESSED_REPORTS = "suppressed reports";
|
|
|
|
private static final String UPDATER_NOTIFY = "notify";
|
|
private static final String UPDATER_DOWNLAD = "download";
|
|
private static final String UPDATER_DELAY = "delay";
|
|
|
|
// Defaults
|
|
private static final long DEFAULT_UPDATER_DELAY = 43200;
|
|
|
|
private Plugin plugin;
|
|
private Configuration config;
|
|
private boolean loadingSections;
|
|
|
|
private ConfigurationSection global;
|
|
private ConfigurationSection updater;
|
|
|
|
// Last update time
|
|
private long lastUpdateTime;
|
|
private boolean configChanged;
|
|
private boolean valuesChanged;
|
|
|
|
// Modifications
|
|
private int modCount;
|
|
|
|
public ProtocolConfig(Plugin plugin) {
|
|
this.plugin = plugin;
|
|
reloadConfig();
|
|
}
|
|
|
|
/**
|
|
* Reload configuration file.
|
|
*/
|
|
public void reloadConfig() {
|
|
// Reset
|
|
configChanged = false;
|
|
valuesChanged = false;
|
|
modCount++;
|
|
|
|
this.config = plugin.getConfig();
|
|
this.lastUpdateTime = loadLastUpdate();
|
|
loadSections(!loadingSections);
|
|
}
|
|
|
|
/**
|
|
* Load the last update time stamp from the file system.
|
|
*
|
|
* @return Last update time stamp.
|
|
*/
|
|
private long loadLastUpdate() {
|
|
File dataFile = getLastUpdateFile();
|
|
|
|
if (dataFile.exists()) {
|
|
try {
|
|
return Long.parseLong(Files.toString(dataFile, Charsets.UTF_8));
|
|
} catch (NumberFormatException e) {
|
|
plugin.getLogger().warning("Cannot parse " + dataFile + " as a number.");
|
|
} catch (IOException e) {
|
|
plugin.getLogger().warning("Cannot read " + dataFile);
|
|
}
|
|
}
|
|
// Default last update
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Store the given time stamp.
|
|
*
|
|
* @param value - time stamp to store.
|
|
*/
|
|
private void saveLastUpdate(long value) {
|
|
File dataFile = getLastUpdateFile();
|
|
|
|
// The data folder must exist
|
|
dataFile.getParentFile().mkdirs();
|
|
|
|
if (dataFile.exists())
|
|
dataFile.delete();
|
|
|
|
try {
|
|
Files.write(Long.toString(value), dataFile, Charsets.UTF_8);
|
|
} catch (IOException e) {
|
|
throw new RuntimeException("Cannot write " + dataFile, e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Retrieve the file that is used to store the update time stamp.
|
|
*
|
|
* @return File storing the update time stamp.
|
|
*/
|
|
private File getLastUpdateFile() {
|
|
return new File(plugin.getDataFolder(), LAST_UPDATE_FILE);
|
|
}
|
|
|
|
/**
|
|
* Load data sections.
|
|
*
|
|
* @param copyDefaults - whether or not to copy configuration defaults.
|
|
*/
|
|
private void loadSections(boolean copyDefaults) {
|
|
if (config != null) {
|
|
global = config.getConfigurationSection(SECTION_GLOBAL);
|
|
}
|
|
if (global != null) {
|
|
updater = global.getConfigurationSection(SECTION_AUTOUPDATER);
|
|
if (updater.getValues(true).isEmpty()) {
|
|
plugin.getLogger().warning("Updater section is missing, regenerate your config!");
|
|
}
|
|
}
|
|
|
|
// Automatically copy defaults
|
|
if (copyDefaults && (!getFile().exists() || global == null || updater == null)) {
|
|
loadingSections = true;
|
|
|
|
if (config != null)
|
|
config.options().copyDefaults(true);
|
|
plugin.saveDefaultConfig();
|
|
plugin.reloadConfig();
|
|
loadingSections = false;
|
|
|
|
// Inform the user
|
|
plugin.getLogger().info("Created default configuration.");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set a particular configuration key value pair.
|
|
*
|
|
* @param section - the configuration root.
|
|
* @param path - the path to the key.
|
|
* @param value - the value to set.
|
|
*/
|
|
private void setConfig(ConfigurationSection section, String path, Object value) {
|
|
configChanged = true;
|
|
section.set(path, value);
|
|
}
|
|
|
|
@SuppressWarnings("unchecked")
|
|
private <T> T getGlobalValue(String path, T def) {
|
|
try {
|
|
return (T) global.get(path, def);
|
|
} catch (Throwable ex) {
|
|
return def;
|
|
}
|
|
}
|
|
|
|
@SuppressWarnings("unchecked")
|
|
private <T> T getUpdaterValue(String path, T def) {
|
|
try {
|
|
return (T) updater.get(path, def);
|
|
} catch (Throwable ex) {
|
|
return def;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Retrieve a reference to the configuration file.
|
|
*
|
|
* @return Configuration file on disk.
|
|
*/
|
|
public File getFile() {
|
|
return new File(plugin.getDataFolder(), "config.yml");
|
|
}
|
|
|
|
/**
|
|
* Determine if detailed error reporting is enabled. Default FALSE.
|
|
*
|
|
* @return TRUE if it is enabled, FALSE otherwise.
|
|
*/
|
|
public boolean isDetailedErrorReporting() {
|
|
return getGlobalValue(DETAILED_ERROR, false);
|
|
}
|
|
|
|
/**
|
|
* Set whether or not detailed error reporting is enabled.
|
|
*
|
|
* @param value - TRUE if it is enabled, FALSE otherwise.
|
|
*/
|
|
public void setDetailedErrorReporting(boolean value) {
|
|
global.set(DETAILED_ERROR, value);
|
|
}
|
|
|
|
/**
|
|
* Retrieve whether or not ProtocolLib should determine if a new version has been released.
|
|
*
|
|
* @return TRUE if it should do this automatically, FALSE otherwise.
|
|
*/
|
|
public boolean isAutoNotify() {
|
|
return getUpdaterValue(UPDATER_NOTIFY, true);
|
|
}
|
|
|
|
/**
|
|
* Set whether or not ProtocolLib should determine if a new version has been released.
|
|
*
|
|
* @param value - TRUE to do this automatically, FALSE otherwise.
|
|
*/
|
|
public void setAutoNotify(boolean value) {
|
|
setConfig(updater, UPDATER_NOTIFY, value);
|
|
modCount++;
|
|
}
|
|
|
|
/**
|
|
* Retrieve whether or not ProtocolLib should automatically download the new version.
|
|
*
|
|
* @return TRUE if it should, FALSE otherwise.
|
|
*/
|
|
public boolean isAutoDownload() {
|
|
return updater != null && getUpdaterValue(UPDATER_DOWNLAD, false);
|
|
}
|
|
|
|
/**
|
|
* Set whether or not ProtocolLib should automatically download the new version.
|
|
*
|
|
* @param value - TRUE if it should. FALSE otherwise.
|
|
*/
|
|
public void setAutoDownload(boolean value) {
|
|
setConfig(updater, UPDATER_DOWNLAD, value);
|
|
modCount++;
|
|
}
|
|
|
|
/**
|
|
* Determine whether or not debug mode is enabled.
|
|
* <p>
|
|
* This grants access to the filter command.
|
|
*
|
|
* @return TRUE if it is, FALSE otherwise.
|
|
*/
|
|
public boolean isDebug() {
|
|
return getGlobalValue(DEBUG_MODE_ENABLED, false);
|
|
}
|
|
|
|
/**
|
|
* Set whether or not debug mode is enabled.
|
|
*
|
|
* @param value - TRUE if it is enabled, FALSE otherwise.
|
|
*/
|
|
public void setDebug(boolean value) {
|
|
setConfig(global, DEBUG_MODE_ENABLED, value);
|
|
modCount++;
|
|
}
|
|
|
|
/**
|
|
* Retrieve an immutable list of every suppressed report type.
|
|
*
|
|
* @return Every suppressed report type.
|
|
*/
|
|
public ImmutableList<String> getSuppressedReports() {
|
|
return ImmutableList.copyOf(getGlobalValue(SUPPRESSED_REPORTS, new ArrayList<String>()));
|
|
}
|
|
|
|
/**
|
|
* Set the list of suppressed report types,
|
|
*
|
|
* @param reports - suppressed report types.
|
|
*/
|
|
public void setSuppressedReports(List<String> reports) {
|
|
global.set(SUPPRESSED_REPORTS, Lists.newArrayList(reports));
|
|
modCount++;
|
|
}
|
|
|
|
/**
|
|
* Retrieve the amount of time to wait until checking for a new update.
|
|
*
|
|
* @return The amount of time to wait.
|
|
*/
|
|
public long getAutoDelay() {
|
|
// Note that the delay must be greater than 59 seconds
|
|
return Math.max(getUpdaterValue(UPDATER_DELAY, 0), DEFAULT_UPDATER_DELAY);
|
|
}
|
|
|
|
/**
|
|
* Set the amount of time to wait until checking for a new update.
|
|
* <p>
|
|
* This time must be greater than 59 seconds.
|
|
*
|
|
* @param delaySeconds - the amount of time to wait.
|
|
*/
|
|
public void setAutoDelay(long delaySeconds) {
|
|
// Silently fix the delay
|
|
if (delaySeconds < DEFAULT_UPDATER_DELAY)
|
|
delaySeconds = DEFAULT_UPDATER_DELAY;
|
|
setConfig(updater, UPDATER_DELAY, delaySeconds);
|
|
modCount++;
|
|
}
|
|
|
|
/**
|
|
* The version of Minecraft to ignore the built-in safety feature.
|
|
*
|
|
* @return The version to ignore ProtocolLib's satefy.
|
|
*/
|
|
public String getIgnoreVersionCheck() {
|
|
return getGlobalValue(IGNORE_VERSION_CHECK, "");
|
|
}
|
|
|
|
/**
|
|
* Sets under which version of Minecraft the version safety feature will be ignored.
|
|
* <p>
|
|
* This is useful if a server operator has tested and verified that a version of ProtocolLib works, but doesn't want or can't upgrade to a newer version.
|
|
*
|
|
* @param ignoreVersion - the version of Minecraft where the satefy will be disabled.
|
|
*/
|
|
public void setIgnoreVersionCheck(String ignoreVersion) {
|
|
setConfig(global, IGNORE_VERSION_CHECK, ignoreVersion);
|
|
modCount++;
|
|
}
|
|
|
|
/**
|
|
* Retrieve whether or not metrics is enabled.
|
|
*
|
|
* @return TRUE if metrics is enabled, FALSE otherwise.
|
|
*/
|
|
public boolean isMetricsEnabled() {
|
|
return getGlobalValue(METRICS_ENABLED, true);
|
|
}
|
|
|
|
/**
|
|
* Set whether or not metrics is enabled.
|
|
* <p>
|
|
* This setting will take effect next time ProtocolLib is started.
|
|
*
|
|
* @param enabled - whether or not metrics is enabled.
|
|
*/
|
|
public void setMetricsEnabled(boolean enabled) {
|
|
setConfig(global, METRICS_ENABLED, enabled);
|
|
modCount++;
|
|
}
|
|
|
|
/**
|
|
* Retrieve whether or not the background compiler for structure modifiers is enabled or not.
|
|
*
|
|
* @return TRUE if it is enabled, FALSE otherwise.
|
|
*/
|
|
public boolean isBackgroundCompilerEnabled() {
|
|
return getGlobalValue(BACKGROUND_COMPILER_ENABLED, true);
|
|
}
|
|
|
|
/**
|
|
* Set whether or not the background compiler for structure modifiers is enabled or not.
|
|
* <p>
|
|
* This setting will take effect next time ProtocolLib is started.
|
|
*
|
|
* @param enabled - TRUE if is enabled/running, FALSE otherwise.
|
|
*/
|
|
public void setBackgroundCompilerEnabled(boolean enabled) {
|
|
setConfig(global, BACKGROUND_COMPILER_ENABLED, enabled);
|
|
modCount++;
|
|
}
|
|
|
|
/**
|
|
* Retrieve the last time we updated, in seconds since 1970.01.01 00:00.
|
|
*
|
|
* @return Last update time.
|
|
*/
|
|
public long getAutoLastTime() {
|
|
return lastUpdateTime;
|
|
}
|
|
|
|
/**
|
|
* Set the last time we updated, in seconds since 1970.01.01 00:00.
|
|
* <p>
|
|
* Note that this is not considered to modify the configuration, so the modification count will not be incremented.
|
|
*
|
|
* @param lastTimeSeconds - new last update time.
|
|
*/
|
|
public void setAutoLastTime(long lastTimeSeconds) {
|
|
this.valuesChanged = true;
|
|
this.lastUpdateTime = lastTimeSeconds;
|
|
}
|
|
|
|
/**
|
|
* Retrieve the unique name of the script engine to use for filtering.
|
|
*
|
|
* @return Script engine to use.
|
|
*/
|
|
public String getScriptEngineName() {
|
|
return getGlobalValue(SCRIPT_ENGINE_NAME, "JavaScript");
|
|
}
|
|
|
|
/**
|
|
* Set the unique name of the script engine to use for filtering.
|
|
* <p>
|
|
* This setting will take effect next time ProtocolLib is started.
|
|
*
|
|
* @param name - name of the script engine to use.
|
|
*/
|
|
public void setScriptEngineName(String name) {
|
|
setConfig(global, SCRIPT_ENGINE_NAME, name);
|
|
modCount++;
|
|
}
|
|
|
|
/**
|
|
* Retrieve the default injection method.
|
|
*
|
|
* @return Default method.
|
|
*/
|
|
public PlayerInjectHooks getDefaultMethod() {
|
|
return PlayerInjectHooks.NETWORK_SERVER_OBJECT;
|
|
}
|
|
|
|
/**
|
|
* Retrieve the injection method that has been set in the configuration, or use a default value.
|
|
*
|
|
* @return Injection method to use.
|
|
* @throws IllegalArgumentException If the configuration option is malformed.
|
|
*/
|
|
public PlayerInjectHooks getInjectionMethod() throws IllegalArgumentException {
|
|
String text = global.getString(INJECTION_METHOD);
|
|
|
|
// Default hook if nothing has been set
|
|
PlayerInjectHooks hook = getDefaultMethod();
|
|
|
|
if (text != null)
|
|
hook = PlayerInjectHooks.valueOf(text.toUpperCase(Locale.ENGLISH).replace(" ", "_"));
|
|
return hook;
|
|
}
|
|
|
|
/**
|
|
* Set the starting injection method to use.
|
|
*
|
|
* @return Injection method.
|
|
*/
|
|
public void setInjectionMethod(PlayerInjectHooks hook) {
|
|
setConfig(global, INJECTION_METHOD, hook.name());
|
|
modCount++;
|
|
}
|
|
|
|
/**
|
|
* Retrieve the number of modifications made to this configuration.
|
|
*
|
|
* @return The number of modifications.
|
|
*/
|
|
public int getModificationCount() {
|
|
return modCount;
|
|
}
|
|
|
|
/**
|
|
* Save the current configuration file.
|
|
*/
|
|
public void saveAll() {
|
|
if (valuesChanged)
|
|
saveLastUpdate(lastUpdateTime);
|
|
if (configChanged)
|
|
plugin.saveConfig();
|
|
|
|
// And we're done
|
|
valuesChanged = false;
|
|
configChanged = false;
|
|
}
|
|
}
|