Use bStats instead of MCStats

src/com/massivecraft/massivecore/MassiveCoreMConf.java

@@ -175,11 +175,11 @@ public class MassiveCoreMConf extends Entity<MassiveCoreMConf>
 	public boolean sponsorEnabled = true;
 	
 	// -------------------------------------------- //
-	// MCSTATS
+	// METRICS
 	// -------------------------------------------- //
-	// URL connections to http://mcstats.org/
+	// URL connections to https://bstats.org
 	
-	public boolean mcstatsEnabled = true;
+	public boolean metricsEnabled = true;
 
 	// -------------------------------------------- //
 	// LORE SORTING

src/com/massivecraft/massivecore/MassivePlugin.java

@@ -20,7 +20,6 @@ import org.bukkit.command.ConsoleCommandSender;
 import org.bukkit.event.Listener;
 import org.bukkit.plugin.java.JavaPlugin;
 
-import java.io.IOException;
 import java.lang.reflect.Modifier;
 import java.util.Arrays;
 import java.util.Collection;
@@ -152,14 +151,13 @@ public abstract class MassivePlugin extends JavaPlugin implements Listener, Name
 	public void onEnablePost()
 	{
 		// Metrics
-		if (MassiveCoreMConf.get().mcstatsEnabled)
+		if (MassiveCoreMConf.get().metricsEnabled)
 		{
 			try
 			{
-				MetricsLite metrics = new MetricsLite(this);
+				new Metrics(this);
-				metrics.start();
 			}
-			catch (IOException e)
+			catch (RuntimeException e)
 			{
 				String message = Txt.parse("<b>Metrics Initialization Failed :'(");
 				log(message);

src/com/massivecraft/massivecore/Metrics.java

@@ -0,0 +1,667 @@
+package com.massivecraft.massivecore;
+
+import org.bukkit.Bukkit;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.RegisteredServiceProvider;
+import org.bukkit.plugin.ServicePriority;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.json.simple.JSONArray;
+import org.json.simple.JSONObject;
+
+import javax.net.ssl.HttpsURLConnection;
+import java.io.ByteArrayOutputStream;
+import java.io.DataOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Timer;
+import java.util.TimerTask;
+import java.util.UUID;
+import java.util.concurrent.Callable;
+import java.util.logging.Level;
+import java.util.zip.GZIPOutputStream;
+
+/**
+ * bStats collects some data for plugin authors.
+ *
+ * Check out https://bStats.org/ to learn more about bStats!
+ */
+public class Metrics {
+	
+	static {
+		// You can use the property to disable the check in your test environment
+		if (System.getProperty("bstats.relocatecheck") == null || !System.getProperty("bstats.relocatecheck").equals("false")) {
+			// Maven's Relocate is clever and changes strings, too. So we have to use this little "trick" ... :D
+			final String defaultPackage = new String(
+														new byte[]{'o', 'r', 'g', '.', 'b', 's', 't', 'a', 't', 's', '.', 'b', 'u', 'k', 'k', 'i', 't'});
+			final String examplePackage = new String(new byte[]{'y', 'o', 'u', 'r', '.', 'p', 'a', 'c', 'k', 'a', 'g', 'e'});
+			// We want to make sure nobody just copy & pastes the example and use the wrong package names
+			if (Metrics.class.getPackage().getName().equals(defaultPackage) || Metrics.class.getPackage().getName().equals(examplePackage)) {
+				throw new IllegalStateException("bStats Metrics class has not been relocated correctly!");
+			}
+		}
+	}
+	
+	// The version of this bStats class
+	public static final int B_STATS_VERSION = 1;
+	
+	// The url to which the data is sent
+	private static final String URL = "https://bStats.org/submitData/bukkit";
+	
+	// Should failed requests be logged?
+	private static boolean logFailedRequests;
+	
+	// The uuid of the server
+	private static String serverUUID;
+	
+	// The plugin
+	private final JavaPlugin plugin;
+	
+	// A list with all custom charts
+	private final List<CustomChart> charts = new ArrayList<>();
+	
+	/**
+	 * Class constructor.
+	 *
+	 * @param plugin The plugin which stats should be submitted.
+	 */
+	public Metrics(JavaPlugin plugin) {
+		if (plugin == null) {
+			throw new IllegalArgumentException("Plugin cannot be null!");
+		}
+		this.plugin = plugin;
+		
+		// Get the config file
+		File bStatsFolder = new File(plugin.getDataFolder().getParentFile(), "bStats");
+		File configFile = new File(bStatsFolder, "config.yml");
+		YamlConfiguration config = YamlConfiguration.loadConfiguration(configFile);
+		
+		// Check if the config file exists
+		if (!config.isSet("serverUuid")) {
+			
+			// Add default values
+			config.addDefault("enabled", true);
+			// Every server gets it's unique random id.
+			config.addDefault("serverUuid", UUID.randomUUID().toString());
+			// Should failed request be logged?
+			config.addDefault("logFailedRequests", false);
+			
+			// Inform the server owners about bStats
+			config.options().header(
+				"bStats collects some data for plugin authors like how many servers are using their plugins.\n" +
+					"To honor their work, you should not disable it.\n" +
+					"This has nearly no effect on the server performance!\n" +
+					"Check out https://bStats.org/ to learn more :)"
+			).copyDefaults(true);
+			try {
+				config.save(configFile);
+			} catch (IOException ignored) { }
+		}
+		
+		// Load the data
+		serverUUID = config.getString("serverUuid");
+		logFailedRequests = config.getBoolean("logFailedRequests", false);
+		if (config.getBoolean("enabled", true)) {
+			boolean found = false;
+			// Search for all other bStats Metrics classes to see if we are the first one
+			for (Class<?> service : Bukkit.getServicesManager().getKnownServices()) {
+				try {
+					service.getField("B_STATS_VERSION"); // Our identifier :)
+					found = true; // We aren't the first
+					break;
+				} catch (NoSuchFieldException ignored) { }
+			}
+			// Register our service
+			Bukkit.getServicesManager().register(Metrics.class, this, plugin, ServicePriority.Normal);
+			if (!found) {
+				// We are the first!
+				startSubmitting();
+			}
+		}
+	}
+	
+	/**
+	 * Adds a custom chart.
+	 *
+	 * @param chart The chart to add.
+	 */
+	public void addCustomChart(CustomChart chart) {
+		if (chart == null) {
+			throw new IllegalArgumentException("Chart cannot be null!");
+		}
+		charts.add(chart);
+	}
+	
+	/**
+	 * Starts the Scheduler which submits our data every 30 minutes.
+	 */
+	private void startSubmitting() {
+		final Timer timer = new Timer(true); // We use a timer cause the Bukkit scheduler is affected by server lags
+		timer.scheduleAtFixedRate(new TimerTask() {
+			@Override
+			public void run() {
+				if (!plugin.isEnabled()) { // Plugin was disabled
+					timer.cancel();
+					return;
+				}
+				// Nevertheless we want our code to run in the Bukkit main thread, so we have to use the Bukkit scheduler
+				// Don't be afraid! The connection to the bStats server is still async, only the stats collection is sync ;)
+				Bukkit.getScheduler().runTask(plugin, new Runnable() {
+					@Override
+					public void run() {
+						submitData();
+					}
+				});
+			}
+		}, 1000*60*5, 1000*60*30);
+		// Submit the data every 30 minutes, first time after 5 minutes to give other plugins enough time to start
+		// WARNING: Changing the frequency has no effect but your plugin WILL be blocked/deleted!
+		// WARNING: Just don't do it!
+	}
+	
+	/**
+	 * Gets the plugin specific data.
+	 * This method is called using Reflection.
+	 *
+	 * @return The plugin specific data.
+	 */
+	public JSONObject getPluginData() {
+		JSONObject data = new JSONObject();
+		
+		String pluginName = plugin.getDescription().getName();
+		String pluginVersion = plugin.getDescription().getVersion();
+		
+		data.put("pluginName", pluginName); // Append the name of the plugin
+		data.put("pluginVersion", pluginVersion); // Append the version of the plugin
+		JSONArray customCharts = new JSONArray();
+		for (CustomChart customChart : charts) {
+			// Add the data of the custom charts
+			JSONObject chart = customChart.getRequestJsonObject();
+			if (chart == null) { // If the chart is null, we skip it
+				continue;
+			}
+			customCharts.add(chart);
+		}
+		data.put("customCharts", customCharts);
+		
+		return data;
+	}
+	
+	/**
+	 * Gets the server specific data.
+	 *
+	 * @return The server specific data.
+	 */
+	private JSONObject getServerData() {
+		// Minecraft specific data
+		int playerAmount;
+		try {
+			// Around MC 1.8 the return type was changed to a collection from an array,
+			// This fixes java.lang.NoSuchMethodError: org.bukkit.Bukkit.getOnlinePlayers()Ljava/util/Collection;
+			Method onlinePlayersMethod = Class.forName("org.bukkit.Server").getMethod("getOnlinePlayers");
+			playerAmount = onlinePlayersMethod.getReturnType().equals(Collection.class)
+							   ? ((Collection<?>) onlinePlayersMethod.invoke(Bukkit.getServer())).size()
+							   : ((Player[]) onlinePlayersMethod.invoke(Bukkit.getServer())).length;
+		} catch (Exception e) {
+			playerAmount = Bukkit.getOnlinePlayers().size(); // Just use the new method if the Reflection failed
+		}
+		int onlineMode = Bukkit.getOnlineMode() ? 1 : 0;
+		String bukkitVersion = org.bukkit.Bukkit.getVersion();
+		bukkitVersion = bukkitVersion.substring(bukkitVersion.indexOf("MC: ") + 4, bukkitVersion.length() - 1);
+		
+		// OS/Java specific data
+		String javaVersion = System.getProperty("java.version");
+		String osName = System.getProperty("os.name");
+		String osArch = System.getProperty("os.arch");
+		String osVersion = System.getProperty("os.version");
+		int coreCount = Runtime.getRuntime().availableProcessors();
+		
+		JSONObject data = new JSONObject();
+		
+		data.put("serverUUID", serverUUID);
+		
+		data.put("playerAmount", playerAmount);
+		data.put("onlineMode", onlineMode);
+		data.put("bukkitVersion", bukkitVersion);
+		
+		data.put("javaVersion", javaVersion);
+		data.put("osName", osName);
+		data.put("osArch", osArch);
+		data.put("osVersion", osVersion);
+		data.put("coreCount", coreCount);
+		
+		return data;
+	}
+	
+	/**
+	 * Collects the data and sends it afterwards.
+	 */
+	private void submitData() {
+		final JSONObject data = getServerData();
+		
+		JSONArray pluginData = new JSONArray();
+		// Search for all other bStats Metrics classes to get their plugin data
+		for (Class<?> service : Bukkit.getServicesManager().getKnownServices()) {
+			try {
+				service.getField("B_STATS_VERSION"); // Our identifier :)
+				
+				for (RegisteredServiceProvider<?> provider : Bukkit.getServicesManager().getRegistrations(service)) {
+					try {
+						pluginData.add(provider.getService().getMethod("getPluginData").invoke(provider.getProvider()));
+					} catch (NullPointerException | NoSuchMethodException | IllegalAccessException | InvocationTargetException ignored) { }
+				}
+			} catch (NoSuchFieldException ignored) { }
+		}
+		
+		data.put("plugins", pluginData);
+		
+		// Create a new thread for the connection to the bStats server
+		new Thread(new Runnable() {
+			@Override
+			public void run() {
+				try {
+					// Send the data
+					sendData(data);
+				} catch (Exception e) {
+					// Something went wrong! :(
+					if (logFailedRequests) {
+						plugin.getLogger().log(Level.WARNING, "Could not submit plugin stats of " + plugin.getName(), e);
+					}
+				}
+			}
+		}).start();
+	}
+	
+	/**
+	 * Sends the data to the bStats server.
+	 *
+	 * @param data The data to send.
+	 * @throws Exception If the request failed.
+	 */
+	private static void sendData(JSONObject data) throws Exception {
+		if (data == null) {
+			throw new IllegalArgumentException("Data cannot be null!");
+		}
+		if (Bukkit.isPrimaryThread()) {
+			throw new IllegalAccessException("This method must not be called from the main thread!");
+		}
+		HttpsURLConnection connection = (HttpsURLConnection) new URL(URL).openConnection();
+		
+		// Compress the data to save bandwidth
+		byte[] compressedData = compress(data.toString());
+		
+		// Add headers
+		connection.setRequestMethod("POST");
+		connection.addRequestProperty("Accept", "application/json");
+		connection.addRequestProperty("Connection", "close");
+		connection.addRequestProperty("Content-Encoding", "gzip"); // We gzip our request
+		connection.addRequestProperty("Content-Length", String.valueOf(compressedData.length));
+		connection.setRequestProperty("Content-Type", "application/json"); // We send our data in JSON format
+		connection.setRequestProperty("User-Agent", "MC-Server/" + B_STATS_VERSION);
+		
+		// Send data
+		connection.setDoOutput(true);
+		DataOutputStream outputStream = new DataOutputStream(connection.getOutputStream());
+		outputStream.write(compressedData);
+		outputStream.flush();
+		outputStream.close();
+		
+		connection.getInputStream().close(); // We don't care about the response - Just send our data :)
+	}
+	
+	/**
+	 * Gzips the given String.
+	 *
+	 * @param str The string to gzip.
+	 * @return The gzipped String.
+	 * @throws IOException If the compression failed.
+	 */
+	private static byte[] compress(final String str) throws IOException {
+		if (str == null) {
+			return null;
+		}
+		ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+		GZIPOutputStream gzip = new GZIPOutputStream(outputStream);
+		gzip.write(str.getBytes("UTF-8"));
+		gzip.close();
+		return outputStream.toByteArray();
+	}
+	
+	/**
+	 * Represents a custom chart.
+	 */
+	public static abstract class CustomChart {
+		
+		// The id of the chart
+		final String chartId;
+		
+		/**
+		 * Class constructor.
+		 *
+		 * @param chartId The id of the chart.
+		 */
+		CustomChart(String chartId) {
+			if (chartId == null || chartId.isEmpty()) {
+				throw new IllegalArgumentException("ChartId cannot be null or empty!");
+			}
+			this.chartId = chartId;
+		}
+		
+		private JSONObject getRequestJsonObject() {
+			JSONObject chart = new JSONObject();
+			chart.put("chartId", chartId);
+			try {
+				JSONObject data = getChartData();
+				if (data == null) {
+					// If the data is null we don't send the chart.
+					return null;
+				}
+				chart.put("data", data);
+			} catch (Throwable t) {
+				if (logFailedRequests) {
+					Bukkit.getLogger().log(Level.WARNING, "Failed to get data for custom chart with id " + chartId, t);
+				}
+				return null;
+			}
+			return chart;
+		}
+		
+		protected abstract JSONObject getChartData() throws Exception;
+		
+	}
+	
+	/**
+	 * Represents a custom simple pie.
+	 */
+	public static class SimplePie extends CustomChart {
+		
+		private final Callable<String> callable;
+		
+		/**
+		 * Class constructor.
+		 *
+		 * @param chartId The id of the chart.
+		 * @param callable The callable which is used to request the chart data.
+		 */
+		public SimplePie(String chartId, Callable<String> callable) {
+			super(chartId);
+			this.callable = callable;
+		}
+		
+		@Override
+		protected JSONObject getChartData() throws Exception {
+			JSONObject data = new JSONObject();
+			String value = callable.call();
+			if (value == null || value.isEmpty()) {
+				// Null = skip the chart
+				return null;
+			}
+			data.put("value", value);
+			return data;
+		}
+	}
+	
+	/**
+	 * Represents a custom advanced pie.
+	 */
+	public static class AdvancedPie extends CustomChart {
+		
+		private final Callable<Map<String, Integer>> callable;
+		
+		/**
+		 * Class constructor.
+		 *
+		 * @param chartId The id of the chart.
+		 * @param callable The callable which is used to request the chart data.
+		 */
+		public AdvancedPie(String chartId, Callable<Map<String, Integer>> callable) {
+			super(chartId);
+			this.callable = callable;
+		}
+		
+		@Override
+		protected JSONObject getChartData() throws Exception {
+			JSONObject data = new JSONObject();
+			JSONObject values = new JSONObject();
+			Map<String, Integer> map = callable.call();
+			if (map == null || map.isEmpty()) {
+				// Null = skip the chart
+				return null;
+			}
+			boolean allSkipped = true;
+			for (Map.Entry<String, Integer> entry : map.entrySet()) {
+				if (entry.getValue() == 0) {
+					continue; // Skip this invalid
+				}
+				allSkipped = false;
+				values.put(entry.getKey(), entry.getValue());
+			}
+			if (allSkipped) {
+				// Null = skip the chart
+				return null;
+			}
+			data.put("values", values);
+			return data;
+		}
+	}
+	
+	/**
+	 * Represents a custom drilldown pie.
+	 */
+	public static class DrilldownPie extends CustomChart {
+		
+		private final Callable<Map<String, Map<String, Integer>>> callable;
+		
+		/**
+		 * Class constructor.
+		 *
+		 * @param chartId The id of the chart.
+		 * @param callable The callable which is used to request the chart data.
+		 */
+		public DrilldownPie(String chartId, Callable<Map<String, Map<String, Integer>>> callable) {
+			super(chartId);
+			this.callable = callable;
+		}
+		
+		@Override
+		public JSONObject getChartData() throws Exception {
+			JSONObject data = new JSONObject();
+			JSONObject values = new JSONObject();
+			Map<String, Map<String, Integer>> map = callable.call();
+			if (map == null || map.isEmpty()) {
+				// Null = skip the chart
+				return null;
+			}
+			boolean reallyAllSkipped = true;
+			for (Map.Entry<String, Map<String, Integer>> entryValues : map.entrySet()) {
+				JSONObject value = new JSONObject();
+				boolean allSkipped = true;
+				for (Map.Entry<String, Integer> valueEntry : map.get(entryValues.getKey()).entrySet()) {
+					value.put(valueEntry.getKey(), valueEntry.getValue());
+					allSkipped = false;
+				}
+				if (!allSkipped) {
+					reallyAllSkipped = false;
+					values.put(entryValues.getKey(), value);
+				}
+			}
+			if (reallyAllSkipped) {
+				// Null = skip the chart
+				return null;
+			}
+			data.put("values", values);
+			return data;
+		}
+	}
+	
+	/**
+	 * Represents a custom single line chart.
+	 */
+	public static class SingleLineChart extends CustomChart {
+		
+		private final Callable<Integer> callable;
+		
+		/**
+		 * Class constructor.
+		 *
+		 * @param chartId The id of the chart.
+		 * @param callable The callable which is used to request the chart data.
+		 */
+		public SingleLineChart(String chartId, Callable<Integer> callable) {
+			super(chartId);
+			this.callable = callable;
+		}
+		
+		@Override
+		protected JSONObject getChartData() throws Exception {
+			JSONObject data = new JSONObject();
+			int value = callable.call();
+			if (value == 0) {
+				// Null = skip the chart
+				return null;
+			}
+			data.put("value", value);
+			return data;
+		}
+		
+	}
+	
+	/**
+	 * Represents a custom multi line chart.
+	 */
+	public static class MultiLineChart extends CustomChart {
+		
+		private final Callable<Map<String, Integer>> callable;
+		
+		/**
+		 * Class constructor.
+		 *
+		 * @param chartId The id of the chart.
+		 * @param callable The callable which is used to request the chart data.
+		 */
+		public MultiLineChart(String chartId, Callable<Map<String, Integer>> callable) {
+			super(chartId);
+			this.callable = callable;
+		}
+		
+		@Override
+		protected JSONObject getChartData() throws Exception {
+			JSONObject data = new JSONObject();
+			JSONObject values = new JSONObject();
+			Map<String, Integer> map = callable.call();
+			if (map == null || map.isEmpty()) {
+				// Null = skip the chart
+				return null;
+			}
+			boolean allSkipped = true;
+			for (Map.Entry<String, Integer> entry : map.entrySet()) {
+				if (entry.getValue() == 0) {
+					continue; // Skip this invalid
+				}
+				allSkipped = false;
+				values.put(entry.getKey(), entry.getValue());
+			}
+			if (allSkipped) {
+				// Null = skip the chart
+				return null;
+			}
+			data.put("values", values);
+			return data;
+		}
+		
+	}
+	
+	/**
+	 * Represents a custom simple bar chart.
+	 */
+	public static class SimpleBarChart extends CustomChart {
+		
+		private final Callable<Map<String, Integer>> callable;
+		
+		/**
+		 * Class constructor.
+		 *
+		 * @param chartId The id of the chart.
+		 * @param callable The callable which is used to request the chart data.
+		 */
+		public SimpleBarChart(String chartId, Callable<Map<String, Integer>> callable) {
+			super(chartId);
+			this.callable = callable;
+		}
+		
+		@Override
+		protected JSONObject getChartData() throws Exception {
+			JSONObject data = new JSONObject();
+			JSONObject values = new JSONObject();
+			Map<String, Integer> map = callable.call();
+			if (map == null || map.isEmpty()) {
+				// Null = skip the chart
+				return null;
+			}
+			for (Map.Entry<String, Integer> entry : map.entrySet()) {
+				JSONArray categoryValues = new JSONArray();
+				categoryValues.add(entry.getValue());
+				values.put(entry.getKey(), categoryValues);
+			}
+			data.put("values", values);
+			return data;
+		}
+		
+	}
+	
+	/**
+	 * Represents a custom advanced bar chart.
+	 */
+	public static class AdvancedBarChart extends CustomChart {
+		
+		private final Callable<Map<String, int[]>> callable;
+		
+		/**
+		 * Class constructor.
+		 *
+		 * @param chartId The id of the chart.
+		 * @param callable The callable which is used to request the chart data.
+		 */
+		public AdvancedBarChart(String chartId, Callable<Map<String, int[]>> callable) {
+			super(chartId);
+			this.callable = callable;
+		}
+		
+		@Override
+		protected JSONObject getChartData() throws Exception {
+			JSONObject data = new JSONObject();
+			JSONObject values = new JSONObject();
+			Map<String, int[]> map = callable.call();
+			if (map == null || map.isEmpty()) {
+				// Null = skip the chart
+				return null;
+			}
+			boolean allSkipped = true;
+			for (Map.Entry<String, int[]> entry : map.entrySet()) {
+				if (entry.getValue().length == 0) {
+					continue; // Skip this invalid
+				}
+				allSkipped = false;
+				JSONArray categoryValues = new JSONArray();
+				for (int categoryValue : entry.getValue()) {
+					categoryValues.add(categoryValue);
+				}
+				values.put(entry.getKey(), categoryValues);
+			}
+			if (allSkipped) {
+				// Null = skip the chart
+				return null;
+			}
+			data.put("values", values);
+			return data;
+		}
+		
+	}
+}

src/com/massivecraft/massivecore/MetricsLite.java

@@ -1,514 +0,0 @@
-/*
- * Copyright 2011-2013 Tyler Blair. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without modification, are
- * permitted provided that the following conditions are met:
- *
- *    1. Redistributions of source code must retain the above copyright notice, this list of
- *       conditions and the following disclaimer.
- *
- *    2. Redistributions in binary form must reproduce the above copyright notice, this list
- *       of conditions and the following disclaimer in the documentation and/or other materials
- *       provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ''AS IS'' AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
- * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
- * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
- * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * The views and conclusions contained in the software and documentation are those of the
- * authors and contributors and should not be interpreted as representing official policies,
- * either expressed or implied, of anybody else.
- */
-
-package com.massivecraft.massivecore;
-
-import com.massivecraft.massivecore.util.MUtil;
-import org.bukkit.Bukkit;
-import org.bukkit.configuration.InvalidConfigurationException;
-import org.bukkit.configuration.file.YamlConfiguration;
-import org.bukkit.plugin.Plugin;
-import org.bukkit.plugin.PluginDescriptionFile;
-import org.bukkit.scheduler.BukkitTask;
-
-import java.io.BufferedReader;
-import java.io.ByteArrayOutputStream;
-import java.io.File;
-import java.io.IOException;
-import java.io.InputStreamReader;
-import java.io.OutputStream;
-import java.io.UnsupportedEncodingException;
-import java.net.Proxy;
-import java.net.URL;
-import java.net.URLConnection;
-import java.net.URLEncoder;
-import java.util.UUID;
-import java.util.logging.Level;
-import java.util.zip.GZIPOutputStream;
-
-public class MetricsLite {
-
-    /**
-     * The current revision number
-     */
-    private final static int REVISION = 7;
-
-    /**
-     * The base url of the metrics domain
-     */
-    private static final String BASE_URL = "http://report.mcstats.org";
-
-    /**
-     * The url used to report a server's status
-     */
-    private static final String REPORT_URL = "/plugin/%s";
-
-    /**
-     * Interval of time to ping (in minutes)
-     */
-    private final static int PING_INTERVAL = 15;
-
-    /**
-     * The plugin this metrics submits for
-     */
-    private final Plugin plugin;
-
-    /**
-     * The plugin configuration file
-     */
-    private final YamlConfiguration configuration;
-
-    /**
-     * The plugin configuration file
-     */
-    private final File configurationFile;
-
-    /**
-     * Unique server id
-     */
-    private final String guid;
-
-    /**
-     * Debug mode
-     */
-    private final boolean debug;
-
-    /**
-     * Lock for synchronization
-     */
-    private final Object optOutLock = new Object();
-
-    /**
-     * Id of the scheduled task
-     */
-    private volatile BukkitTask task = null;
-
-    public MetricsLite(Plugin plugin) throws IOException {
-        if (plugin == null) {
-            throw new IllegalArgumentException("Plugin cannot be null");
-        }
-
-        this.plugin = plugin;
-
-        // load the config
-        configurationFile = getConfigFile();
-        configuration = YamlConfiguration.loadConfiguration(configurationFile);
-
-        // add some defaults
-        configuration.addDefault("opt-out", false);
-        configuration.addDefault("guid", UUID.randomUUID().toString());
-        configuration.addDefault("debug", false);
-
-        // Do we need to create the file?
-        if (configuration.get("guid", null) == null) {
-            configuration.options().header("http://mcstats.org").copyDefaults(true);
-            configuration.save(configurationFile);
-        }
-
-        // Load the guid then
-        guid = configuration.getString("guid");
-        debug = configuration.getBoolean("debug", false);
-    }
-
-    /**
-     * Start measuring statistics. This will immediately create an async repeating task as the plugin and send
-     * the initial data to the metrics backend, and then after that it will post in increments of
-     * PING_INTERVAL * 1200 ticks.
-     *
-     * @return True if statistics measuring is running, otherwise false.
-     */
-    public boolean start() {
-        synchronized (optOutLock) {
-            // Did we opt out?
-            if (isOptOut()) {
-                return false;
-            }
-
-            // Is metrics already running?
-            if (task != null) {
-                return true;
-            }
-
-            // Begin hitting the server with glorious data
-            task = plugin.getServer().getScheduler().runTaskTimerAsynchronously(plugin, new Runnable() {
-
-                private boolean firstPost = true;
-
-                public void run() {
-                    try {
-                        // This has to be synchronized or it can collide with the disable method.
-                        synchronized (optOutLock) {
-                            // Disable Task, if it is running and the server owner decided to opt-out
-                            if (isOptOut() && task != null) {
-                                task.cancel();
-                                task = null;
-                            }
-                        }
-
-                        // We use the inverse of firstPost because if it is the first time we are posting,
-                        // it is not a interval ping, so it evaluates to FALSE
-                        // Each time thereafter it will evaluate to TRUE, i.e PING!
-                        postPlugin(!firstPost);
-
-                        // After the first post we set firstPost to false
-                        // Each post thereafter will be a ping
-                        firstPost = false;
-                    } catch (IOException e) {
-                        if (debug) {
-                            Bukkit.getLogger().log(Level.INFO, "[Metrics] " + e.getMessage());
-                        }
-                    }
-                }
-            }, 0, PING_INTERVAL * 1200);
-
-            return true;
-        }
-    }
-
-    /**
-     * Has the server owner denied plugin metrics?
-     *
-     * @return true if metrics should be opted out of it
-     */
-    public boolean isOptOut() {
-        synchronized (optOutLock) {
-            try {
-                // Reload the metrics file
-                configuration.load(getConfigFile());
-            } catch (IOException ex) {
-                if (debug) {
-                    Bukkit.getLogger().log(Level.INFO, "[Metrics] " + ex.getMessage());
-                }
-                return true;
-            } catch (InvalidConfigurationException ex) {
-                if (debug) {
-                    Bukkit.getLogger().log(Level.INFO, "[Metrics] " + ex.getMessage());
-                }
-                return true;
-            }
-            return configuration.getBoolean("opt-out", false);
-        }
-    }
-
-    /**
-     * Enables metrics for the server by setting "opt-out" to false in the config file and starting the metrics task.
-     *
-     * @throws java.io.IOException
-     */
-    public void enable() throws IOException {
-        // This has to be synchronized or it can collide with the check in the task.
-        synchronized (optOutLock) {
-            // Check if the server owner has already set opt-out, if not, set it.
-            if (isOptOut()) {
-                configuration.set("opt-out", false);
-                configuration.save(configurationFile);
-            }
-
-            // Enable Task, if it is not running
-            if (task == null) {
-                start();
-            }
-        }
-    }
-
-    /**
-     * Disables metrics for the server by setting "opt-out" to true in the config file and canceling the metrics task.
-     *
-     * @throws java.io.IOException
-     */
-    public void disable() throws IOException {
-        // This has to be synchronized or it can collide with the check in the task.
-        synchronized (optOutLock) {
-            // Check if the server owner has already set opt-out, if not, set it.
-            if (!isOptOut()) {
-                configuration.set("opt-out", true);
-                configuration.save(configurationFile);
-            }
-
-            // Disable Task, if it is running
-            if (task != null) {
-                task.cancel();
-                task = null;
-            }
-        }
-    }
-
-    /**
-     * Gets the File object of the config file that should be used to store data such as the GUID and opt-out status
-     *
-     * @return the File object for the config file
-     */
-    public File getConfigFile() {
-        // I believe the easiest way to get the base folder (e.g craftbukkit set via -P) for plugins to use
-        // is to abuse the plugin object we already have
-        // plugin.getDataFolder() => base/plugins/PluginA/
-        // pluginsFolder => base/plugins/
-        // The base is not necessarily relative to the startup directory.
-        File pluginsFolder = plugin.getDataFolder().getParentFile();
-
-        // return => base/plugins/PluginMetrics/config.yml
-        return new File(new File(pluginsFolder, "PluginMetrics"), "config.yml");
-    }
-
-    /**
-     * Generic method that posts a plugin to the metrics website
-     */
-    private void postPlugin(boolean isPing) throws IOException {
-        // Server software specific section
-        PluginDescriptionFile description = plugin.getDescription();
-        String pluginName = description.getName();
-        boolean onlineMode = Bukkit.getServer().getOnlineMode(); // TRUE if online mode is enabled
-        String pluginVersion = description.getVersion();
-        String serverVersion = Bukkit.getVersion();
-        int playersOnline = MUtil.getOnlinePlayers().size();
-
-        // END server software specific section -- all code below does not use any code outside of this class / Java
-
-        // Construct the post data
-        StringBuilder json = new StringBuilder(1024);
-        json.append('{');
-
-        // The plugin's description file containg all of the plugin data such as name, version, author, etc
-        appendJSONPair(json, "guid", guid);
-        appendJSONPair(json, "plugin_version", pluginVersion);
-        appendJSONPair(json, "server_version", serverVersion);
-        appendJSONPair(json, "players_online", Integer.toString(playersOnline));
-
-        // New data as of R6
-        String osname = System.getProperty("os.name");
-        String osarch = System.getProperty("os.arch");
-        String osversion = System.getProperty("os.version");
-        String java_version = System.getProperty("java.version");
-        int coreCount = Runtime.getRuntime().availableProcessors();
-
-        // normalize os arch .. amd64 -> x86_64
-        if (osarch.equals("amd64")) {
-            osarch = "x86_64";
-        }
-
-        appendJSONPair(json, "osname", osname);
-        appendJSONPair(json, "osarch", osarch);
-        appendJSONPair(json, "osversion", osversion);
-        appendJSONPair(json, "cores", Integer.toString(coreCount));
-        appendJSONPair(json, "auth_mode", onlineMode ? "1" : "0");
-        appendJSONPair(json, "java_version", java_version);
-
-        // If we're pinging, append it
-        if (isPing) {
-            appendJSONPair(json, "ping", "1");
-        }
-
-        // close json
-        json.append('}');
-
-        // Create the url
-        URL url = new URL(BASE_URL + String.format(REPORT_URL, urlEncode(pluginName)));
-
-        // Connect to the website
-        URLConnection connection;
-
-        // Mineshafter creates a socks proxy, so we can safely bypass it
-        // It does not reroute POST requests so we need to go around it
-        if (isMineshafterPresent()) {
-            connection = url.openConnection(Proxy.NO_PROXY);
-        } else {
-            connection = url.openConnection();
-        }
-
-
-        byte[] uncompressed = json.toString().getBytes();
-        byte[] compressed = gzip(json.toString());
-
-        // Headers
-        connection.addRequestProperty("User-Agent", "MCStats/" + REVISION);
-        connection.addRequestProperty("Content-Type", "application/json");
-        connection.addRequestProperty("Content-Encoding", "gzip");
-        connection.addRequestProperty("Content-Length", Integer.toString(compressed.length));
-        connection.addRequestProperty("Accept", "application/json");
-        connection.addRequestProperty("Connection", "close");
-
-        connection.setDoOutput(true);
-
-        if (debug) {
-            System.out.println("[Metrics] Prepared request for " + pluginName + " uncompressed=" + uncompressed.length + " compressed=" + compressed.length);
-        }
-
-        // Write the data
-        OutputStream os = connection.getOutputStream();
-        os.write(compressed);
-        os.flush();
-
-        // Now read the response
-        final BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
-        String response = reader.readLine();
-
-        // close resources
-        os.close();
-        reader.close();
-
-        if (response == null || response.startsWith("ERR") || response.startsWith("7")) {
-            if (response == null) {
-                response = "null";
-            } else if (response.startsWith("7")) {
-                response = response.substring(response.startsWith("7,") ? 2 : 1);
-            }
-
-            throw new IOException(response);
-        }
-    }
-
-    /**
-     * GZip compress a string of bytes
-     *
-     * @param input
-     * @return
-     */
-    public static byte[] gzip(String input) {
-        ByteArrayOutputStream baos = new ByteArrayOutputStream();
-        GZIPOutputStream gzos = null;
-
-        try {
-            gzos = new GZIPOutputStream(baos);
-            gzos.write(input.getBytes("UTF-8"));
-        } catch (IOException e) {
-            e.printStackTrace();
-        } finally {
-            if (gzos != null) try {
-                gzos.close();
-            } catch (IOException ignore) {
-            }
-        }
-
-        return baos.toByteArray();
-    }
-
-    /**
-     * Check if mineshafter is present. If it is, we need to bypass it to send POST requests
-     *
-     * @return true if mineshafter is installed on the server
-     */
-    private boolean isMineshafterPresent() {
-        try {
-            Class.forName("mineshafter.MineServer");
-            return true;
-        } catch (Exception e) {
-            return false;
-        }
-    }
-
-    /**
-     * Appends a json encoded key/value pair to the given string builder.
-     *
-     * @param json
-     * @param key
-     * @param value
-     * @throws UnsupportedEncodingException
-     */
-    private static void appendJSONPair(StringBuilder json, String key, String value) throws UnsupportedEncodingException {
-        boolean isValueNumeric = false;
-
-        try {
-            if (value.equals("0") || !value.endsWith("0")) {
-                Double.parseDouble(value);
-                isValueNumeric = true;
-            }
-        } catch (NumberFormatException e) {
-            isValueNumeric = false;
-        }
-
-        if (json.charAt(json.length() - 1) != '{') {
-            json.append(',');
-        }
-
-        json.append(escapeJSON(key));
-        json.append(':');
-
-        if (isValueNumeric) {
-            json.append(value);
-        } else {
-            json.append(escapeJSON(value));
-        }
-    }
-
-    /**
-     * Escape a string to create a valid JSON string
-     *
-     * @param text
-     * @return
-     */
-    private static String escapeJSON(String text) {
-        StringBuilder builder = new StringBuilder();
-
-        builder.append('"');
-        for (int index = 0; index < text.length(); index++) {
-            char chr = text.charAt(index);
-
-            switch (chr) {
-                case '"':
-                case '\\':
-                    builder.append('\\');
-                    builder.append(chr);
-                    break;
-                case '\b':
-                    builder.append("\\b");
-                    break;
-                case '\t':
-                    builder.append("\\t");
-                    break;
-                case '\n':
-                    builder.append("\\n");
-                    break;
-                case '\r':
-                    builder.append("\\r");
-                    break;
-                default:
-                    if (chr < ' ') {
-                        String t = "000" + Integer.toHexString(chr);
-                        builder.append("\\u" + t.substring(t.length() - 4));
-                    } else {
-                        builder.append(chr);
-                    }
-                    break;
-            }
-        }
-        builder.append('"');
-
-        return builder.toString();
-    }
-
-    /**
-     * Encode text as UTF-8
-     *
-     * @param text the text to encode
-     * @return the encoded text, as UTF-8
-     */
-    private static String urlEncode(final String text) throws UnsupportedEncodingException {
-        return URLEncoder.encode(text, "UTF-8");
-    }
-
-}