update metrics to latest implementation. Now does 3 custom Pie graphs

src/net/milkbowl/vault/Metrics.java

@@ -34,11 +34,14 @@ import java.io.IOException;
 import java.io.InputStreamReader;
 import java.io.OutputStreamWriter;
 import java.io.UnsupportedEncodingException;
+import java.net.Proxy;
 import java.net.URL;
 import java.net.URLConnection;
 import java.net.URLEncoder;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
 import java.util.LinkedHashSet;
 import java.util.Map;
 import java.util.Set;
@@ -61,7 +64,7 @@ public class Metrics {
     /**
      * The metrics revision number
      */
-    private final static int REVISION = 3;
+    private final static int REVISION = 5;
 
     /**
      * The base url of the metrics domain
@@ -73,6 +76,12 @@ public class Metrics {
      */
     private static final String REPORT_URL = "/report/%s";
 
+    /**
+     * The separator to use for custom data. This MUST NOT change unless you are hosting your own
+     * version of metrics and want to change it.
+     */
+    private static final String CUSTOM_DATA_SEPARATOR = "~~";
+
     /**
      * The file where guid and opt out is stored in
      */
@@ -83,6 +92,16 @@ public class Metrics {
      */
     private final static int PING_INTERVAL = 10;
 
+    /**
+     * A map of all of the graphs for each plugin
+     */
+    private Map<Plugin, Set<Graph>> graphs = Collections.synchronizedMap(new HashMap<Plugin, Set<Graph>>());
+
+    /**
+     * A convenient map of the default Graph objects (used by addCustomData mainly)
+     */
+    private Map<Plugin, Graph> defaultGraphs = Collections.synchronizedMap(new HashMap<Plugin, Graph>());
+
     /**
      * The plugin configuration file
      */
@@ -93,18 +112,12 @@ public class Metrics {
      */
     private String guid;
 
-    /**
-     * A map of the custom data plotters for plugins
-     */
-    private Map<Plugin, Set<Plotter>> customData = Collections.synchronizedMap(new HashMap<Plugin, Set<Plotter>>());
-
-
     private final String pluginVersion;
+    private final String authors;
 
-    private boolean firstRun = true;
+    public Metrics(String version, String authors) throws IOException {
-
-    public Metrics(String version) throws IOException {
         this.pluginVersion = version;
+        this.authors = authors;
 
         // load the config
         File file = new File(CONFIG_FILE);
@@ -123,21 +136,43 @@ public class Metrics {
         // Load the guid then
         guid = configuration.getString("guid");
     }
+    /**
+     * Construct and create a Graph that can be used to separate specific plotters to their own graphs
+     * on the metrics website. Plotters can be added to the graph object returned.
+     *
+     * @param plugin
+     * @param type
+     * @param name
+     * @return Graph object created. Will never return NULL under normal circumstances unless bad parameters are given
+     */
+    public Graph createGraph(Plugin plugin, Graph.Type type, String name) {
+        if (plugin == null || type == null || name == null) {
+            throw new IllegalArgumentException("All arguments must not be null");
+        }
+
+        // Construct the graph object
+        Graph graph = new Graph(type, name);
+
+        // Get the graphs for the plugin
+        Set<Graph> graphs = getOrCreateGraphs(plugin);
+
+        // Now we can add our graph
+        graphs.add(graph);
+
+        // and return back
+        return graph;
+    }
 
     public void findCustomData(Vault plugin) {
-        // Add our Economy plotters
+        // Create our Economy Graph and Add our Economy plotters
+        Graph econGraph = createGraph(plugin, Graph.Type.Pie, "Economy");
         RegisteredServiceProvider<Economy> rspEcon = Bukkit.getServer().getServicesManager().getRegistration(Economy.class);
         Economy econ = null;
         if (rspEcon != null) {
             econ = rspEcon.getProvider();
         }
         final String econName = econ != null ? econ.getName() : "No Economy";
-        addCustomData(plugin, new Metrics.Plotter() {
+        econGraph.addPlotter(new Metrics.Plotter(econName) {
-
-            @Override
-            public String getColumnName() {
-                return econName;
-            }
 
             @Override
             public int getValue() {
@@ -145,14 +180,10 @@ public class Metrics {
             }
         });
 
-        // Add our permission Plotters
+        // Create our Permission Graph and Add our permission Plotters
+        Graph permGraph = createGraph(plugin, Graph.Type.Pie, "Permission");
         final String permName = Bukkit.getServer().getServicesManager().getRegistration(Permission.class).getProvider().getName();
-        addCustomData(plugin, new Metrics.Plotter() {
+        permGraph.addPlotter(new Metrics.Plotter(permName) {
-
-            @Override
-            public String getColumnName() {
-                return permName;
-            }
 
             @Override
             public int getValue() {
@@ -160,6 +191,8 @@ public class Metrics {
             }
         });
 
+        // Create our Chat Graph and Add our chat Plotters
+        Graph chatGraph = createGraph(plugin, Graph.Type.Pie, "Chat");
         RegisteredServiceProvider<Chat> rspChat = Bukkit.getServer().getServicesManager().getRegistration(Chat.class);
         Chat chat = null;
         if (rspChat != null) {
@@ -167,12 +200,7 @@ public class Metrics {
         }
         final String chatName = chat != null ? chat.getName() : "No Chat";
         // Add our Chat Plotters
-        addCustomData(plugin, new Metrics.Plotter() {
+        chatGraph.addPlotter(new Metrics.Plotter(chatName) {
-
-            @Override
-            public String getColumnName() {
-                return chatName;
-            }
 
             @Override
             public int getValue() {
@@ -180,6 +208,7 @@ public class Metrics {
             }
         });
     }
+
     /**
      * Adds a custom data plotter for a given plugin
      *
@@ -187,14 +216,14 @@ public class Metrics {
      * @param plotter
      */
     public synchronized void addCustomData(Plugin plugin, Plotter plotter) {
-        Set<Plotter> plotters = customData.get(plugin);
+        // The default graph for the plugin
+        Graph graph = getOrCreateDefaultGraph(plugin);
 
-        if (plotters == null) {
+        // Add the plotter to the graph o/
-            plotters = Collections.synchronizedSet(new LinkedHashSet<Plotter>());
+        graph.addPlotter(plotter);
-            customData.put(plugin, plotters);
-        }
 
-        plotters.add(plotter);
+        // Ensure the default graph is included in the submitted graphs
+        getOrCreateGraphs(plugin).add(graph);
     }
 
     /**
@@ -210,10 +239,11 @@ public class Metrics {
 
         // Ping the server in intervals
         plugin.getServer().getScheduler().scheduleAsyncRepeatingTask(plugin, new Runnable() {
+            private boolean firstPost = true;
             public void run() {
                 try {
-                    postPlugin(plugin);
+                    postPlugin(plugin, !firstPost);
-                    firstRun = false;
+                    firstPost = false;
                 } catch (IOException e) {
                     //Ignore exceptions - otherwise we freak server admins out
                 }
@@ -228,35 +258,65 @@ public class Metrics {
      *
      * @param plugin
      */
-    private void postPlugin(Plugin plugin) throws IOException {
+    private void postPlugin(Plugin plugin, boolean isPing) throws IOException {
         // Construct the post data
-        String response = "ERR No response";
         String data = encode("guid") + '=' + encode(guid)
-                + '&' + encode("version") + '=' + encode(pluginVersion)
+                + encodeDataPair("authors", authors)
-                + '&' + encode("server") + '=' + encode(Bukkit.getVersion())
+                + encodeDataPair("version", pluginVersion)
-                + '&' + encode("players") + '=' + encode(String.valueOf(Bukkit.getServer().getOnlinePlayers().length))
+                + encodeDataPair("server", Bukkit.getVersion())
-                + '&' + encode("revision") + '=' + encode(REVISION + "");
+                + encodeDataPair("players", Integer.toString(Bukkit.getServer().getOnlinePlayers().length))
+                + encodeDataPair("revision", String.valueOf(REVISION));
 
         // If we're pinging, append it
-        if (!firstRun) {
+        if (isPing) {
-            data += '&' + encode("ping") + '=' + encode("true");
+            data += encodeDataPair("ping", "true");
         }
 
-        // Add any custom data (if applicable)
+        // Add any custom data available for the plugin
-        Set<Plotter> plotters = customData.get(plugin);
+        Set<Graph> graphs = getOrCreateGraphs(plugin);
 
-        if (plotters != null) {
+        // Acquire a lock on the graphs, which lets us make the assumption we also lock everything
-            for (Plotter plotter : plotters) {
+        // inside of the graph (e.g plotters)
-                data += "&" + encode ("Custom" + plotter.getColumnName())
+        synchronized(graphs) {
-                        + "=" + encode(Integer.toString(plotter.getValue()));
+            Iterator<Graph> iter = graphs.iterator();
+
+            while (iter.hasNext()) {
+                Graph graph = iter.next();
+
+                // Because we have a lock on the graphs set already, it is reasonable to assume
+                // that our lock transcends down to the individual plotters in the graphs also.
+                // Because our methods are private, no one but us can reasonably access this list
+                // without reflection so this is a safe assumption without adding more code.
+                for (Plotter plotter : graph.getPlotters()) {
+                    // The key name to send to the metrics server
+                    // The format is C-GRAPHNAME-PLOTTERNAME where separator - is defined at the top
+                    // Legacy (R4) submitters use the format Custom%s, or CustomPLOTTERNAME
+                    String key = String.format("C%s%s%s%s", CUSTOM_DATA_SEPARATOR, graph.getName(), CUSTOM_DATA_SEPARATOR, plotter.getColumnName());
+
+                    // The value to send, which for the foreseeable future is just the string
+                    // value of plotter.getValue()
+                    String value = Integer.toString(plotter.getValue());
+
+                    // Add it to the http post data :)
+                    data += encodeDataPair(key, value);
+                }
             }
         }
 
         // Create the url
-        URL url = new URL(BASE_URL + String.format(REPORT_URL, "Vault"));
+        URL url = new URL(BASE_URL + String.format(REPORT_URL, plugin.getDescription().getName()));
 
         // Connect to the website
-        URLConnection connection = url.openConnection();
+        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();
+        }
+
         connection.setDoOutput(true);
 
         // Write the data
@@ -266,18 +326,97 @@ public class Metrics {
 
         // Now read the response
         BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
-        response = reader.readLine();
+        String response = reader.readLine();
 
         // close resources
         writer.close();
         reader.close();
 
-        if (response.startsWith("ERR")){
+        if (response.startsWith("ERR")) {
             throw new IOException(response); //Throw the exception
+        } else {
+            // Is this the first update this hour?
+            if (response.contains("OK This is your first update this hour")) {
+                synchronized (graphs) {
+                    Iterator<Graph> iter = graphs.iterator();
+
+                    while (iter.hasNext()) {
+                        Graph graph = iter.next();
+
+                        for (Plotter plotter : graph.getPlotters()) {
+                            plotter.reset();
+                        }
+                    }
+                }
+            }
         }
         //if (response.startsWith("OK")) - We should get "OK" followed by an optional description if everything goes right
     }
 
+    /**
+     * Get or create the Set of graphs for a specific plugin
+     *
+     * @param plugin
+     * @return
+     */
+    private Set<Graph> getOrCreateGraphs(Plugin plugin) {
+        Set<Graph> theGraphs = graphs.get(plugin);
+
+        // Create the Set if it does not already exist
+        if (theGraphs == null) {
+            theGraphs = Collections.synchronizedSet(new HashSet<Graph>());
+            graphs.put(plugin, theGraphs);
+        }
+
+        return theGraphs;
+    }
+
+    /**
+     * Get the default graph for a plugin and if it does not exist, create one
+     *
+     * @param plugin
+     * @return
+     */
+    private Graph getOrCreateDefaultGraph(Plugin plugin) {
+        Graph graph = defaultGraphs.get(plugin);
+
+        // Not yet created :(
+        if (graph == null) {
+            graph = new Graph(Graph.Type.Line, "Default");
+            defaultGraphs.put(plugin, graph);
+        }
+
+        return graph;
+    }
+
+    /**
+     * Check if mineshafter is present. If it is, we need to bypass it to send POST requests
+     *
+     * @return
+     */
+    private boolean isMineshafterPresent() {
+        try {
+            Class.forName("mineshafter.MineServer");
+            return true;
+        } catch (Exception e) {
+            return false;
+        }
+    }
+    /**
+     * Encode a key/value data pair to be used in a HTTP post request. This INCLUDES a & so the first
+     * key/value pair MUST be included manually, e.g:
+     * <p>
+     *     String httpData = encode("guid") + "=" + encode("1234") + encodeDataPair("authors") + "..";
+     * </p>
+     *
+     * @param key
+     * @param value
+     * @return
+     */
+    private static String encodeDataPair(String key, String value) throws UnsupportedEncodingException {
+        return "&" + encode(key) + "=" + encode(value);
+    }
+
     /**
      * Encode text as UTF-8
      *
@@ -287,18 +426,146 @@ public class Metrics {
     private static String encode(String text) throws UnsupportedEncodingException {
         return URLEncoder.encode(text, "UTF-8");
     }
+    /**
+     * Represents a custom graph on the website
+     */
+    public static class Graph {
 
+        /**
+         * The graph's type that will be visible on the website
+         */
+        public static enum Type {
+
+            /**
+             * A simple line graph which also includes a scrollable timeline viewer to view
+             * as little or as much of the data as possible.
+             */
+            Line,
+
+            /**
+             * An area graph. This is the same as a line graph except the area under the curve is shaded
+             */
+            Area,
+
+            /**
+             * A column graph, which is a graph where the data is represented by columns on the vertical axis,
+             * i.e they go up and down.
+             */
+            Column,
+
+            /**
+             * A pie graph. The graph is generated by taking the data for the last hour and summing it
+             * together. Then the percentage for each plotter is calculated via round( (plot / total) * 100, 2 )
+             */
+            Pie
+
+        }
+
+        /**
+         * What the graph should be plotted as
+         */
+        private final Type type;
+
+        /**
+         * The graph's name, alphanumeric and spaces only :)
+         * If it does not comply to the above when submitted, it is rejected
+         */
+        private final String name;
+
+        /**
+         * The set of plotters that are contained within this graph
+         */
+        private final Set<Plotter> plotters = new LinkedHashSet<Plotter>();
+
+        private Graph(Type type, String name) {
+            this.type = type;
+            this.name = name;
+        }
+
+        /**
+         * Gets the graph's name
+         *
+         * @return
+         */
+        public String getName() {
+            return name;
+        }
+
+        /**
+         * Add a plotter to the graph, which will be used to plot entries
+         *
+         * @param plotter
+         */
+        public void addPlotter(Plotter plotter) {
+            plotters.add(plotter);
+        }
+
+        /**
+         * Remove a plotter from the graph
+         *
+         * @param plotter
+         */
+        public void removePlotter(Plotter plotter) {
+            plotters.remove(plotter);
+        }
+
+        /**
+         * Gets an <b>unmodifiable</b> set of the plotter objects in the graph
+         * @return
+         */
+        public Set<Plotter> getPlotters() {
+            return Collections.unmodifiableSet(plotters);
+        }
+
+        @Override
+        public int hashCode() {
+            return (type.hashCode() * 17) ^ name.hashCode();
+        }
+
+        @Override
+        public boolean equals(Object object) {
+            if (!(object instanceof Graph)) {
+                return false;
+            }
+
+            Graph graph = (Graph) object;
+            return graph.type == type && graph.name.equals(name);
+        }
+
+    }
     /**
      * Interface used to collect custom data for a plugin
      */
     public static abstract class Plotter {
+        /**
+         * The plot's name
+         */
+        private final String name;
+
+        /*
+         * Construct a plotter with the default plot name
+         */
+        public Plotter() {
+            this("Default");
+        }
+
+        /**
+         * Construct a plotter with a specific plot name
+         *
+         * @param name
+         */
+        public Plotter(String name) {
+            this.name = name;
+        }
 
         /**
          * Get the column name for the plotted point
          *
          * @return the plotted point's column name
          */
-        public abstract String getColumnName();
+        public String getColumnName() {
+            return name;
+        }
 
         /**
          * Get the current value for the plotted point
@@ -312,6 +579,12 @@ public class Metrics {
             return getColumnName().hashCode() + getValue();
         }
 
+        /**
+         * Called after the website graphs have been updated
+         */
+        public void reset() {
+        }
+
         @Override
         public boolean equals(Object object) {
             if (!(object instanceof Plotter)) {

src/net/milkbowl/vault/Vault.java

@@ -133,7 +133,14 @@ public class Vault extends JavaPlugin {
 
         // Load up the Plugin metrics
         try {
-            metrics = new Metrics(getDescription().getVersion());
+            String authors = "";
+            for (String author : this.getDescription().getAuthors()) {
+                authors += author + ", ";
+            }
+            if (!authors.isEmpty()) {
+                authors = authors.substring(0, authors.length() - 2);
+            }
+            metrics = new Metrics(getDescription().getVersion(), authors);
             metrics.findCustomData(this);
             metrics.beginMeasuringPlugin(this);
         } catch (IOException e) {