Changed package name

src/es/mesacarlos/webconsole/WebConsole.java

@@ -0,0 +1,131 @@
+package es.mesacarlos.webconsole;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.security.KeyStore;
+
+import javax.net.ssl.KeyManagerFactory;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.TrustManagerFactory;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.core.Filter;
+import org.bukkit.Bukkit;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.java_websocket.server.DefaultSSLWebSocketServerFactory;
+
+import es.mesacarlos.webconsole.minecraft.WebConsoleCommand;
+import es.mesacarlos.webconsole.util.Internationalization;
+import es.mesacarlos.webconsole.util.LogFilter;
+import es.mesacarlos.webconsole.websocket.WSServer;
+
+public class WebConsole extends JavaPlugin {
+	FileConfiguration config = this.getConfig();
+
+	// Websocket server and thread
+	private WSServer server;
+	private Thread wsThread;
+
+	@Override
+	public void onEnable() {
+		createConfig();
+		
+		//Change language to user-specified language.
+		Internationalization.setCurrentLocale(config.getString("language"));
+		
+		//Start WebSocket Server
+		try {
+			startWS();
+		} catch (Exception e) {
+			Bukkit.getLogger().warning(Internationalization.getPhrase("boot-error"));
+			e.printStackTrace();
+		}
+		
+		//This filter is used to read the whole console.
+		Filter f = new LogFilter(getWSServer());
+		((org.apache.logging.log4j.core.Logger) LogManager.getRootLogger()).addFilter(f);
+		
+		//Register /WebConsole command
+		getCommand("WebConsole").setExecutor(new WebConsoleCommand(this.getDescription().getVersion()));
+	}
+
+	@Override
+	public void onDisable() {
+		try {
+			server.stop();
+			wsThread = null;
+		} catch (IOException | InterruptedException e) {
+			e.printStackTrace();
+		}
+	}
+
+	/**
+	 * Creates configuration file
+	 */
+	private void createConfig() {
+		// SSL variables
+		config.addDefault("useSSL", false);
+		config.addDefault("StoreType", "JKS");
+		config.addDefault("KeyStore", "plugins/WebConsole/keystore.jks");
+		config.addDefault("StorePassword", "storepassword");
+		config.addDefault("KeyPassword", "keypassword");
+		
+		// Connection config variables
+		config.addDefault("host", "localhost");
+		config.addDefault("port", 8080);
+		config.addDefault("password", 1234);
+		
+		// Language config
+		config.addDefault("language", "en");
+
+		config.options().copyDefaults(true);
+		saveConfig();
+	}
+
+	/**
+	 * Start WebSocket server
+	 */
+	private void startWS() throws Exception {
+		// Create WebSocket server
+		server = new WSServer(this, new InetSocketAddress(config.getString("host"), config.getInt("port")));
+		
+		if(config.getBoolean("useSSL")) {
+			// Configure SSL
+			String STORETYPE = config.getString("StoreType");
+			String KEYSTORE = config.getString("KeyStore");
+			String STOREPASSWORD = config.getString("StorePassword");
+			String KEYPASSWORD = config.getString("KeyPassword");
+			
+			KeyStore ks = KeyStore.getInstance(STORETYPE);
+			File kf = new File(KEYSTORE);
+			ks.load(new FileInputStream(kf), STOREPASSWORD.toCharArray());
+			
+			KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
+			kmf.init(ks, KEYPASSWORD.toCharArray());
+			TrustManagerFactory tmf = TrustManagerFactory.getInstance("SunX509");
+			tmf.init(ks);
+			
+			SSLContext sslContext = null;
+			sslContext = SSLContext.getInstance("TLS");
+			sslContext.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);
+			
+			server.setWebSocketFactory(new DefaultSSLWebSocketServerFactory(sslContext));
+		}
+
+		// Start Server
+		wsThread = new Thread(new Runnable() {
+			@Override
+			public void run() {
+				server.run();
+			}
+		});
+		wsThread.start();
+	}
+
+	public WSServer getWSServer() {
+		return (WSServer) server;
+	}
+}

src/es/mesacarlos/webconsole/minecraft/WebConsoleCommand.java

@@ -0,0 +1,43 @@
+package es.mesacarlos.webconsole.minecraft;
+
+import java.net.InetSocketAddress;
+import java.util.ArrayList;
+
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+
+import es.mesacarlos.webconsole.util.Internationalization;
+import es.mesacarlos.webconsole.util.LoginManager;
+
+public class WebConsoleCommand implements CommandExecutor {
+	private String version;
+
+	public WebConsoleCommand(String version) {
+		this.version = version;
+	}
+
+	@Override
+	public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+		StringBuilder msg = new StringBuilder();
+
+		msg.append(Internationalization.getPhrase("webconsole-version", version) + ".\n");
+		ArrayList<InetSocketAddress> connections = LoginManager.getInstance().getLoggedInUsers();
+		
+		if (connections.isEmpty()) {
+			msg.append(Internationalization.getPhrase("webconsole-no-connections"));
+		} else {
+			msg.append(Internationalization.getPhrase("webconsole-active-connections") + "\n");
+			for (int i = 0; i < connections.size(); i++) {
+				InetSocketAddress connection = connections.get(i);
+				msg.append(connection.toString());
+				if(i+1 < connections.size())
+					msg.append("\n");
+			}
+		}
+
+		sender.sendMessage(msg.toString());
+		return true;
+	}
+
+}

src/es/mesacarlos/webconsole/util/DateTimeUtils.java

@@ -0,0 +1,10 @@
+package es.mesacarlos.webconsole.util;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+public class DateTimeUtils {
+	public static String getDateAsString() {
+		return new SimpleDateFormat("dd-MM-yyyy HH:mm:ss").format(new Date());
+	}
+}

src/es/mesacarlos/webconsole/util/Internationalization.java

@@ -0,0 +1,52 @@
+package es.mesacarlos.webconsole.util;
+
+import java.io.UnsupportedEncodingException;
+import java.text.MessageFormat;
+import java.util.Locale;
+import java.util.ResourceBundle;
+
+public class Internationalization {
+	private static ResourceBundle messages = ResourceBundle.getBundle("phrases", new Locale("en"));
+	
+	/**
+	 * Changes locale of this application
+	 * @param locale String representing language 
+	 */
+	public static void setCurrentLocale(String locale) {
+		messages = ResourceBundle.getBundle("phrases", new Locale(locale));
+	}
+	
+	/**
+	 * Get current locale
+	 * @return Current locale
+	 */
+	public static Locale getCurrentLocale() {
+		return messages.getLocale();
+	}
+
+	/**
+	 * Gets translated message
+	 * @return The desired message in user's language
+	 */
+	public static String getPhrase(String phrase, Object... params) {
+		String msg = messages.getString(phrase);
+		msg = MessageFormat.format(msg, params);
+		msg = correctEncoding(msg);
+		return msg;
+	}
+	
+	/**
+	 * Java i18n uses ISO-8859-1 internally, so we need to correct all characters to UTF-8
+	 * @param msg Message to correct
+	 * @return Message corrected
+	 */
+	private static String correctEncoding(String msg) {
+		try {
+			msg = new String(msg.getBytes("ISO-8859-1"), "UTF-8");
+		} catch (UnsupportedEncodingException e) {
+			e.printStackTrace();
+		}
+		return msg;
+	}
+	
+}

src/es/mesacarlos/webconsole/util/LogFilter.java

@@ -0,0 +1,138 @@
+package es.mesacarlos.webconsole.util;
+
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.Marker;
+import org.apache.logging.log4j.core.Filter;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.Logger;
+import org.apache.logging.log4j.message.Message;
+
+import es.mesacarlos.webconsole.websocket.WSServer;
+
+public class LogFilter implements Filter{
+	private WSServer wsServer;
+
+	public LogFilter(WSServer wsServer) {
+		this.wsServer = wsServer;
+	}
+
+	@Override
+	public State getState() {
+		return null;
+	}
+
+	@Override
+	public void initialize() {
+		
+	}
+
+	@Override
+	public void start() {
+		
+	}
+
+	@Override
+	public void stop() {
+		
+	}
+
+	@Override
+	public boolean isStarted() {
+		return false;
+	}
+
+	@Override
+	public boolean isStopped() {
+		return false;
+	}
+
+	@Override
+	public Result getOnMismatch() {
+		return null;
+	}
+
+	@Override
+	public Result getOnMatch() {
+		return null;
+	}
+
+	@Override
+	public Result filter(Logger logger, Level level, Marker marker, String msg, Object... params) {
+		return null;
+	}
+
+	@Override
+	public Result filter(Logger logger, Level level, Marker marker, String message, Object p0) {
+		return null;
+	}
+
+	@Override
+	public Result filter(Logger logger, Level level, Marker marker, String message, Object p0, Object p1) {
+		return null;
+	}
+
+	@Override
+	public Result filter(Logger logger, Level level, Marker marker, String message, Object p0, Object p1, Object p2) {
+		return null;
+	}
+
+	@Override
+	public Result filter(Logger logger, Level level, Marker marker, String message, Object p0, Object p1, Object p2,
+			Object p3) {
+		return null;
+	}
+
+	@Override
+	public Result filter(Logger logger, Level level, Marker marker, String message, Object p0, Object p1, Object p2,
+			Object p3, Object p4) {
+		return null;
+	}
+
+	@Override
+	public Result filter(Logger logger, Level level, Marker marker, String message, Object p0, Object p1, Object p2,
+			Object p3, Object p4, Object p5) {
+		return null;
+	}
+
+	@Override
+	public Result filter(Logger logger, Level level, Marker marker, String message, Object p0, Object p1, Object p2,
+			Object p3, Object p4, Object p5, Object p6) {
+		return null;
+	}
+
+	@Override
+	public Result filter(Logger logger, Level level, Marker marker, String message, Object p0, Object p1, Object p2,
+			Object p3, Object p4, Object p5, Object p6, Object p7) {
+		return null;
+	}
+
+	@Override
+	public Result filter(Logger logger, Level level, Marker marker, String message, Object p0, Object p1, Object p2,
+			Object p3, Object p4, Object p5, Object p6, Object p7, Object p8) {
+		return null;
+	}
+
+	@Override
+	public Result filter(Logger logger, Level level, Marker marker, String message, Object p0, Object p1, Object p2,
+			Object p3, Object p4, Object p5, Object p6, Object p7, Object p8, Object p9) {
+		return null;
+	}
+
+	@Override
+	public Result filter(Logger logger, Level level, Marker marker, Object msg, Throwable t) {
+		return null;
+	}
+
+	@Override
+	public Result filter(Logger logger, Level level, Marker marker, Message msg, Throwable t) {
+		return null;
+	}
+
+	@Override
+	public Result filter(LogEvent event) {
+		String message = event.getMessage().getFormattedMessage().replaceAll("\u001b"," ");
+        wsServer.onNewConsoleLinePrinted(message);
+        return null;
+	}
+
+}

src/es/mesacarlos/webconsole/util/LoginManager.java

@@ -0,0 +1,33 @@
+package es.mesacarlos.webconsole.util;
+
+import java.net.InetSocketAddress;
+import java.util.ArrayList;
+
+public class LoginManager {
+	private ArrayList<InetSocketAddress> loggedInUsers = new ArrayList<InetSocketAddress>();
+	private static LoginManager instance;
+	
+	private LoginManager() {}
+	
+	public static LoginManager getInstance() {
+		if(instance == null)
+			instance = new LoginManager();
+		return instance;
+	}
+	
+	public void logIn(InetSocketAddress address) {
+		loggedInUsers.add(address);
+	}
+	
+	public void logOut(InetSocketAddress address) {
+		loggedInUsers.remove(address);
+	}
+	
+	public boolean isLoggedIn(InetSocketAddress address) {
+		return loggedInUsers.contains(address);
+	}
+	
+	public ArrayList<InetSocketAddress> getLoggedInUsers() {
+		return loggedInUsers;
+	}
+}

src/es/mesacarlos/webconsole/websocket/WSServer.java

@@ -0,0 +1,112 @@
+package es.mesacarlos.webconsole.websocket;
+
+import java.net.InetSocketAddress;
+import java.util.Collection;
+import java.util.HashMap;
+
+import org.bukkit.Bukkit;
+import org.java_websocket.WebSocket;
+import org.java_websocket.handshake.ClientHandshake;
+import org.java_websocket.server.WebSocketServer;
+
+import es.mesacarlos.webconsole.WebConsole;
+import es.mesacarlos.webconsole.util.Internationalization;
+import es.mesacarlos.webconsole.util.LoginManager;
+import es.mesacarlos.webconsole.websocket.command.CommandFactory;
+import es.mesacarlos.webconsole.websocket.command.WSCommand;
+import es.mesacarlos.webconsole.websocket.response.ConsoleOutput;
+import es.mesacarlos.webconsole.websocket.response.JSONOutput;
+import es.mesacarlos.webconsole.websocket.response.LoginRequired;
+import es.mesacarlos.webconsole.websocket.response.Processed;
+import es.mesacarlos.webconsole.websocket.response.UnknownCommand;
+
+public class WSServer extends WebSocketServer {
+	private HashMap<String, WSCommand> commands = CommandFactory.getCommandsHashMap();
+	private WebConsole plugin;
+
+	public WSServer(WebConsole plugin, InetSocketAddress address) {
+		super(address);
+		this.plugin = plugin;
+	}
+
+	@Override
+	public void onOpen(WebSocket conn, ClientHandshake handshake) {
+		if (LoginManager.getInstance().isLoggedIn(conn.getRemoteSocketAddress())) {
+			sendToClient(conn, new Processed(Internationalization.getPhrase("connection-resumed-message")));
+			Bukkit.getLogger().info(Internationalization.getPhrase("connection-resumed-console", conn.getRemoteSocketAddress()));
+		} else {
+			sendToClient(conn, new LoginRequired(Internationalization.getPhrase("connection-login-message")));
+			Bukkit.getLogger().info(Internationalization.getPhrase("connection-login-console", conn.getRemoteSocketAddress()));
+		}
+	}
+
+	@Override
+	public void onMessage(WebSocket conn, String message) {
+		// Get command and params
+		String wsCommand = message.split(" ")[0];
+		String wsCommandParams = "";
+		if (message.contains(" "))
+			wsCommandParams = message.split(" ", 2)[1];
+
+		// Run command
+		WSCommand cmd = commands.get(wsCommand);
+
+		if (cmd == null) {
+			// Command does not exist
+			sendToClient(conn, new UnknownCommand(Internationalization.getPhrase("unknown-command-message"), message));
+			Bukkit.getLogger().info(Internationalization.getPhrase("unknown-command-console", message));
+		} else if (!LoginManager.getInstance().isLoggedIn(conn.getRemoteSocketAddress())
+				&& !wsCommand.equals("LOGIN")) {
+			// User is not authorised. DO NOTHING, IMPORTANT!
+			sendToClient(conn, new LoginRequired(Internationalization.getPhrase("forbidden-message")));
+			Bukkit.getLogger().warning(Internationalization.getPhrase("forbidden-console", conn.getRemoteSocketAddress(), message));
+		} else {
+			cmd.execute(this, conn, wsCommandParams);
+		}
+	}
+
+	@Override
+	public void onClose(WebSocket conn, int code, String reason, boolean remote) {
+		LoginManager.getInstance().logOut(conn.getRemoteSocketAddress());
+		Bukkit.getLogger().info(Internationalization.getPhrase("closed-connection", conn.getRemoteSocketAddress()));
+	}
+
+	@Override
+	public void onError(WebSocket conn, Exception ex) {
+		Bukkit.getLogger().warning(Internationalization.getPhrase("error-on-connection", conn.getRemoteSocketAddress(), ex));
+	}
+
+	@Override
+	public void onStart() {
+		Bukkit.getLogger().info(Internationalization.getPhrase("started-websocket"));
+	}
+
+	/**
+	 * Returns main class
+	 * @return Main plugin class
+	 */
+	public WebConsole getMainClass() {
+		return plugin;
+	}
+
+	/**
+	 * Sends the message to all connected AND logged-in users
+	 */
+	public void onNewConsoleLinePrinted(String line) {
+		Collection<WebSocket> connections = getConnections();
+		for (WebSocket connection : connections) {
+			if (LoginManager.getInstance().isLoggedIn(connection.getRemoteSocketAddress()))
+				sendToClient(connection, new ConsoleOutput(line));
+		}
+	}
+
+	/**
+	 * Sends this JSONOutput to client
+	 * @param conn    Connection to client
+	 * @param content JSONOutput object
+	 */
+	public void sendToClient(WebSocket conn, JSONOutput content) {
+		conn.send(content.toJSON());
+	}
+
+}

src/es/mesacarlos/webconsole/websocket/command/CommandFactory.java

@@ -0,0 +1,17 @@
+package es.mesacarlos.webconsole.websocket.command;
+
+import java.util.HashMap;
+
+public class CommandFactory {
+
+	public static HashMap<String, WSCommand> getCommandsHashMap() {
+		HashMap<String, WSCommand> commands = new HashMap<String, WSCommand>();
+		commands.put("LOGIN", new LogInCommand());
+		commands.put("EXEC", new ExecCommand());
+		commands.put("PLAYERS", new PlayersCommand());
+		commands.put("CPUUSAGE", new CpuUsageCommand());
+		commands.put("RAMUSAGE", new RamUsageCommand());
+		commands.put("READLOGFILE", new ReadLogFileCommand());
+		return commands;
+	}
+}

src/es/mesacarlos/webconsole/websocket/command/CpuUsageCommand.java

@@ -0,0 +1,52 @@
+package es.mesacarlos.webconsole.websocket.command;
+
+import java.lang.management.ManagementFactory;
+
+import javax.management.Attribute;
+import javax.management.AttributeList;
+import javax.management.MBeanServer;
+import javax.management.ObjectName;
+
+import org.java_websocket.WebSocket;
+
+import es.mesacarlos.webconsole.util.Internationalization;
+import es.mesacarlos.webconsole.websocket.WSServer;
+import es.mesacarlos.webconsole.websocket.response.CpuUsage;
+
+public class CpuUsageCommand implements WSCommand {
+
+	@Override
+	public void execute(WSServer wsServer, WebSocket conn, String params) {
+		try {
+			double usage = getProcessCpuLoad();
+			wsServer.sendToClient(conn, new CpuUsage(Internationalization.getPhrase("cpu-usage-message", usage), usage));
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+	
+	/**
+	 * Check out usage for the whole system
+	 * Got from https://stackoverflow.com/questions/18489273/how-to-get-percentage-of-cpu-usage-of-os-from-java
+	 * @return CPU Usage for the whole system
+	 * @throws Exception Something went wrong
+	 */
+	public double getProcessCpuLoad() throws Exception {
+		MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
+		ObjectName name = ObjectName.getInstance("java.lang:type=OperatingSystem");
+		AttributeList list = mbs.getAttributes(name, new String[] {"SystemCpuLoad"});
+
+		if (list.isEmpty())
+			return Double.NaN;
+
+		Attribute att = (Attribute) list.get(0);
+		Double value = (Double) att.getValue();
+
+		// usually takes a couple of seconds before we get real values
+		if (value == -1.0)
+			return Double.NaN;
+		// returns a percentage value with 1 decimal point precision
+		return ((int) (value * 1000) / 10.0);
+	}
+
+}

src/es/mesacarlos/webconsole/websocket/command/ExecCommand.java

@@ -0,0 +1,30 @@
+package es.mesacarlos.webconsole.websocket.command;
+
+import java.util.concurrent.ExecutionException;
+
+import org.bukkit.Bukkit;
+import org.bukkit.command.ConsoleCommandSender;
+import org.java_websocket.WebSocket;
+
+import es.mesacarlos.webconsole.util.Internationalization;
+import es.mesacarlos.webconsole.websocket.WSServer;
+
+public class ExecCommand implements WSCommand {
+
+	@Override
+	public void execute(WSServer wsServer, WebSocket conn, String command) {
+
+		Bukkit.getLogger().info(Internationalization.getPhrase("cmd-executed-console", conn.getRemoteSocketAddress(), command));
+		ConsoleCommandSender sender = Bukkit.getServer().getConsoleSender();
+
+		try {
+			@SuppressWarnings("unused")
+			boolean success = Bukkit.getScheduler()
+					.callSyncMethod(wsServer.getMainClass(), () -> Bukkit.dispatchCommand(sender, command)).get();
+		} catch (InterruptedException | ExecutionException e) {
+			e.printStackTrace();
+		}
+
+	}
+
+}

src/es/mesacarlos/webconsole/websocket/command/LogInCommand.java

@@ -0,0 +1,35 @@
+package es.mesacarlos.webconsole.websocket.command;
+
+import org.bukkit.Bukkit;
+import org.java_websocket.WebSocket;
+
+import es.mesacarlos.webconsole.util.Internationalization;
+import es.mesacarlos.webconsole.util.LoginManager;
+import es.mesacarlos.webconsole.websocket.WSServer;
+import es.mesacarlos.webconsole.websocket.response.LoginRequired;
+import es.mesacarlos.webconsole.websocket.response.Processed;
+
+public class LogInCommand implements WSCommand {
+
+	@Override
+	public void execute(WSServer wsServer, WebSocket conn, String password) {
+		// If user is logged in, then return.
+		if (LoginManager.getInstance().isLoggedIn(conn.getRemoteSocketAddress()))
+			return;
+
+		// Get password from config files
+		String receivedPassword = wsServer.getMainClass().getConfig().getString("password");
+
+		if (receivedPassword.equals(password)) {
+			// Password is correct, logging in
+			LoginManager.getInstance().logIn(conn.getRemoteSocketAddress());
+			wsServer.sendToClient(conn, new Processed(Internationalization.getPhrase("login-sucessful-message"), "LOGIN ********"));
+			Bukkit.getLogger().info(Internationalization.getPhrase("login-sucessful-console", conn.getRemoteSocketAddress()));
+		} else {
+			// Password was incorrect
+			wsServer.sendToClient(conn, new LoginRequired(Internationalization.getPhrase("login-failed-message")));
+			Bukkit.getLogger().info(Internationalization.getPhrase("login-failed-console", conn.getRemoteSocketAddress()));
+		}
+	}
+
+}

src/es/mesacarlos/webconsole/websocket/command/PlayersCommand.java

@@ -0,0 +1,35 @@
+package es.mesacarlos.webconsole.websocket.command;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.java_websocket.WebSocket;
+
+import es.mesacarlos.webconsole.util.Internationalization;
+import es.mesacarlos.webconsole.websocket.WSServer;
+import es.mesacarlos.webconsole.websocket.response.Players;
+
+public class PlayersCommand implements WSCommand{
+
+	@Override
+	public void execute(WSServer wsServer, WebSocket conn, String params) {
+		List<String> connectedPlayersList = new ArrayList<String>();
+		for(Player player : Bukkit.getOnlinePlayers()) {
+			connectedPlayersList.add(player.getName());
+		}
+		
+		int connectedPlayers = connectedPlayersList.size();
+		int maxPlayers = Bukkit.getMaxPlayers();
+		
+		wsServer.sendToClient(conn, 
+			new Players(
+				Internationalization.getPhrase("players-message", connectedPlayers, maxPlayers),
+				connectedPlayers,
+				maxPlayers,
+				connectedPlayersList
+			));
+	}
+	
+}

src/es/mesacarlos/webconsole/websocket/command/RamUsageCommand.java

@@ -0,0 +1,28 @@
+package es.mesacarlos.webconsole.websocket.command;
+
+import org.java_websocket.WebSocket;
+
+import es.mesacarlos.webconsole.util.Internationalization;
+import es.mesacarlos.webconsole.websocket.WSServer;
+import es.mesacarlos.webconsole.websocket.response.RamUsage;
+
+public class RamUsageCommand implements WSCommand {
+
+	@Override
+	public void execute(WSServer wsServer, WebSocket conn, String params) {
+		Runtime r = Runtime.getRuntime();
+		
+		long free = r.freeMemory() / 1024 / 1024;
+		long max = r.maxMemory() / 1024 / 1024;
+		long used = max - free;
+		
+		wsServer.sendToClient(conn,
+			new RamUsage(
+				Internationalization.getPhrase("ram-usage-message", free, used, max),
+				free,
+				used,
+				max
+			));
+	}
+
+}

src/es/mesacarlos/webconsole/websocket/command/ReadLogFileCommand.java

@@ -0,0 +1,41 @@
+package es.mesacarlos.webconsole.websocket.command;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.List;
+
+import org.bukkit.Bukkit;
+import org.java_websocket.WebSocket;
+
+import es.mesacarlos.webconsole.util.Internationalization;
+import es.mesacarlos.webconsole.websocket.WSServer;
+import es.mesacarlos.webconsole.websocket.response.ConsoleOutput;
+
+public class ReadLogFileCommand implements WSCommand{
+
+	@Override
+	public void execute(WSServer wsServer, WebSocket conn, String params) {
+		List<String> lines = null;
+		try {
+			 lines = Files.readAllLines(Paths.get("logs/latest.log"), StandardCharsets.UTF_8);
+		} catch (IOException e) {
+			try {
+				lines = Files.readAllLines(Paths.get("logs/latest.log"), StandardCharsets.ISO_8859_1);
+			}catch(IOException ex) {
+				ex.printStackTrace();
+			}
+			
+		}
+		
+		if(lines == null) {
+			Bukkit.getLogger().info(Internationalization.getPhrase("log-read-error"));
+			return;
+		}
+		
+		for(String line : lines)
+			wsServer.sendToClient(conn, new ConsoleOutput(line));
+	}
+
+}

src/es/mesacarlos/webconsole/websocket/command/WSCommand.java

@@ -0,0 +1,9 @@
+package es.mesacarlos.webconsole.websocket.command;
+
+import org.java_websocket.WebSocket;
+
+import es.mesacarlos.webconsole.websocket.WSServer;
+
+public interface WSCommand {
+	void execute(WSServer wsServer, WebSocket conn, String params);
+}

src/es/mesacarlos/webconsole/websocket/response/ConsoleOutput.java

@@ -0,0 +1,31 @@
+package es.mesacarlos.webconsole.websocket.response;
+
+import com.google.gson.JsonObject;
+
+public class ConsoleOutput implements JSONOutput{
+	private String message;
+	
+	public ConsoleOutput(String message) {
+		this.message = message;
+	}
+	
+	@Override
+	public int getStatusCode() {
+		return 10;
+	}
+
+	@Override
+	public String getMessage() {
+		return message;
+	}
+
+	@Override
+	public String toJSON() {
+		JsonObject object = new JsonObject();
+		object.addProperty("status", getStatusCode());
+		object.addProperty("statusDescription", "Console Output");
+		object.addProperty("message", getMessage());
+		return object.toString();
+	}
+
+}

src/es/mesacarlos/webconsole/websocket/response/CpuUsage.java

@@ -0,0 +1,42 @@
+package es.mesacarlos.webconsole.websocket.response;
+
+import com.google.gson.JsonObject;
+
+public class CpuUsage implements JSONOutput{
+	private String message;
+	private double usage;
+
+	public CpuUsage(String message, double usage) {
+		this.message = message;
+		this.usage = usage;
+	}
+
+	@Override
+	public int getStatusCode() {
+		return 1001;
+	}
+
+	@Override
+	public String getMessage() {
+		return message;
+	}
+	
+	/**
+	 * Gets system CPU Usage
+	 * @return Global CPU Usage
+	 */
+	public double getUsage() {
+		return usage;
+	}
+	
+	@Override
+	public String toJSON() {
+		JsonObject object = new JsonObject();
+		object.addProperty("status", getStatusCode());
+		object.addProperty("statusDescription", "CPU Usage");
+		object.addProperty("usage", getUsage());
+		object.addProperty("message", getMessage());
+		return object.toString();
+	}
+	
+}

src/es/mesacarlos/webconsole/websocket/response/JSONOutput.java

@@ -0,0 +1,21 @@
+package es.mesacarlos.webconsole.websocket.response;
+
+public interface JSONOutput {
+	/**
+	 * Gets status code representing this message. See docs for code meanings.
+	 * @return Status code representing this message
+	 */
+	int getStatusCode();
+	
+	/**
+	 * Explanatory message of this response
+	 * @return Explanatory message of this response
+	 */
+	String getMessage();
+	
+	/**
+	 * Coverts this object into JSON, ready to send it over WS
+	 * @return JSON Object Stringified
+	 */
+	String toJSON();
+}

src/es/mesacarlos/webconsole/websocket/response/LoginRequired.java

@@ -0,0 +1,31 @@
+package es.mesacarlos.webconsole.websocket.response;
+
+import com.google.gson.JsonObject;
+
+public class LoginRequired implements JSONOutput{
+	private String message;
+	
+	public LoginRequired(String message) {
+		this.message = message;
+	}
+	
+	@Override
+	public int getStatusCode() {
+		return 401;
+	}
+
+	@Override
+	public String getMessage() {
+		return message;
+	}
+
+	@Override
+	public String toJSON() {
+		JsonObject object = new JsonObject();
+		object.addProperty("status", getStatusCode());
+		object.addProperty("statusDescription", "Login Required");
+		object.addProperty("message", getMessage());
+		return object.toString();
+	}
+
+}

src/es/mesacarlos/webconsole/websocket/response/Players.java

@@ -0,0 +1,51 @@
+package es.mesacarlos.webconsole.websocket.response;
+
+import java.util.List;
+
+import com.google.gson.Gson;
+import com.google.gson.JsonObject;
+
+public class Players implements JSONOutput{
+	private String message;
+	private int connectedPlayers;
+	private int maxPlayers;
+	private List<String> connectedPlayersList;
+	
+	public Players(String message, int connectedPlayers, int maxPlayers, List<String> connectedPlayersList) {
+		this.message = message;
+		this.connectedPlayers = connectedPlayers;
+		this.maxPlayers = maxPlayers;
+		this.connectedPlayersList = connectedPlayersList;
+	}
+	
+	@Override
+	public int getStatusCode() {
+		return 1000;
+	}
+	
+	@Override
+	public String getMessage() {
+		return message;
+	}
+	
+	public int getConnectedPlayers() {
+		return connectedPlayers;
+	}
+
+	public int getMaxPlayers() {
+		return maxPlayers;
+	}
+
+	@Override
+	public String toJSON() {
+		JsonObject object = new JsonObject();
+		object.addProperty("status", getStatusCode());
+		object.addProperty("statusDescription", "Players");
+		object.addProperty("connectedPlayers", getConnectedPlayers());
+		object.addProperty("maxPlayers", getMaxPlayers());
+		object.addProperty("players", new Gson().toJson(connectedPlayersList));
+		object.addProperty("message", getMessage());
+		return object.toString();
+	}
+
+}

src/es/mesacarlos/webconsole/websocket/response/Processed.java

@@ -0,0 +1,46 @@
+package es.mesacarlos.webconsole.websocket.response;
+
+import com.google.gson.JsonObject;
+
+public class Processed implements JSONOutput{
+	private String message;
+	private String respondsTo;
+	
+	public Processed(String message) {
+		this.message = message;
+	}
+	
+	public Processed(String message, String respondsTo) {
+		this.message = message;
+		this.respondsTo = respondsTo;
+	}
+	
+	@Override
+	public int getStatusCode() {
+		return 200;
+	}
+	
+	@Override
+	public String getMessage() {
+		return message;
+	}
+	
+	/**
+	 * The command that originated this response
+	 * @return WebSockets full command and parameters
+	 */
+	private String getRespondsTo() {
+		return respondsTo;
+	}
+	
+	@Override
+	public String toJSON() {
+		JsonObject object = new JsonObject();
+		object.addProperty("status", getStatusCode());
+		object.addProperty("statusDescription", "Processed");
+		object.addProperty("respondsTo", getRespondsTo());
+		object.addProperty("message", getMessage());
+		return object.toString();
+	}
+
+}

src/es/mesacarlos/webconsole/websocket/response/RamUsage.java

@@ -0,0 +1,64 @@
+package es.mesacarlos.webconsole.websocket.response;
+
+import com.google.gson.JsonObject;
+
+public class RamUsage implements JSONOutput {
+	private String message;
+	private long free;
+	private long used;
+	private long max;
+
+	public RamUsage(String message, long free, long used, long max) {
+		this.message = message;
+		this.free = free;
+		this.used = used;
+		this.max = max;
+	}
+
+	@Override
+	public int getStatusCode() {
+		return 1002;
+	}
+
+	@Override
+	public String getMessage() {
+		return message;
+	}
+	
+	/**
+	 * Free amount of RAM, in MB
+	 * @return
+	 */
+	public long getFree() {
+		return free;
+	}
+	
+	/**
+	 * Used amount of RAM, in MB
+	 * @return
+	 */
+	public long getUsed() {
+		return used;
+	}
+	
+	/**
+	 * Max amount of RAM, in MB
+	 * @return
+	 */
+	public long getMax() {
+		return max;
+	}
+
+	@Override
+	public String toJSON() {
+		JsonObject object = new JsonObject();
+		object.addProperty("status", getStatusCode());
+		object.addProperty("statusDescription", "RAM Usage");
+		object.addProperty("free", getFree());
+		object.addProperty("used", getUsed());
+		object.addProperty("max", getMax());
+		object.addProperty("message", getMessage());
+		return object.toString();
+	}
+
+}

src/es/mesacarlos/webconsole/websocket/response/UnknownCommand.java

@@ -0,0 +1,41 @@
+package es.mesacarlos.webconsole.websocket.response;
+
+import com.google.gson.JsonObject;
+
+public class UnknownCommand implements JSONOutput{
+	private String message;
+	private String respondsTo;
+	
+	public UnknownCommand(String message, String respondsTo) {
+		this.message = message;
+		this.respondsTo = respondsTo;
+	}
+	
+	@Override
+	public int getStatusCode() {
+		return 400;
+	}
+	
+	@Override
+	public String getMessage() {
+		return message;
+	}
+	
+	/**
+	 * The command that originated this response
+	 * @return WebSockets full command and parameters
+	 */
+	public String getRespondsTo() {
+		return respondsTo;
+	}
+	
+	@Override
+	public String toJSON() {
+		JsonObject object = new JsonObject();
+		object.addProperty("status", getStatusCode());
+		object.addProperty("statusDescription", "Unknown Command");
+		object.addProperty("respondsTo", getRespondsTo());
+		object.addProperty("message", getMessage());
+		return object.toString();
+	}
+}