Minecraft-Server-Launcher/src/main/java/net/knarcraft/minecraftserverlauncher/server/Server.java

package net.knarcraft.minecraftserverlauncher.server;

import net.knarcraft.minecraftserverlauncher.Main;
import net.knarcraft.minecraftserverlauncher.profile.Collection;
import net.knarcraft.minecraftserverlauncher.profile.ServerLauncherController;
import net.knarcraft.minecraftserverlauncher.server.servertypes.ServerType;
import net.knarcraft.minecraftserverlauncher.utility.CommonFunctions;

import javax.naming.ConfigurationException;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


/**
 * Contains all necessary information to create, runServer and manage a Minecraft server.
 *
 * @author Kristian Knarvik <kristian.knarvik@knett.no>
 * @version 1.0.0
 * @since 1.0.0
 */
public class Server {
    /**
     * Available ram sizes. For ServerLauncherGUI combo
     */
    private static final String[] ramList = {"512M", "1G", "2G", "3G", "4G", "5G", "6G", "7G", "8G", "9G", "10G",
            "11G", "12G", "13G", "14G", "15G", "16G"};
    private static final String jarDirectory = Main.getApplicationWorkDirectory() + File.separator + "files" +
            File.separator + "Jars" + File.separator;

    private final String name;
    private final ArrayList<String> playerList;
    private String path;
    private boolean enabled;
    private ServerType type;
    private String serverVersion;
    private String maxRam;
    private Process process;
    private BufferedWriter writer;
    private BufferedReader reader;
    private boolean started;
    private ScheduledExecutorService consoleOutputExecutor;
    private static boolean stoppingServers = false;

    /**
     * Initializes a new server with default values
     *
     * @param name <p>The name of the server</p>
     */
    public Server(String name) {
        this.name = name;
        this.path = "";
        this.enabled = false;
        this.playerList = new ArrayList<>();
        this.type = null;
        this.serverVersion = "";
        this.maxRam = ramList[0];
        this.process = null;
        this.writer = null;
        this.reader = null;
    }

    /**
     * Initializes a server with the given values
     *
     * @param name          <p>The name of the server</p>
     * @param path          <p>The file path of the folder containing the server files</p>
     * @param enabled       <p>Whether the server is enabled to start the next time servers are started</p>
     * @param typeName      <p>The name of the server type currently in use on the server</p>
     * @param serverVersion <p>The currently selected server version for the given server type</p>
     * @param maxRam        <p>The maximum amount of ram the server is allowed to use</p>
     */
    public Server(String name, String path, boolean enabled, String typeName, String serverVersion, String maxRam) throws ConfigurationException {
        this.name = name;
        this.path = path;
        this.enabled = enabled;
        this.type = ServerTypeHandler.getByName(typeName);
        this.serverVersion = serverVersion;
        this.maxRam = maxRam;
        this.playerList = new ArrayList<>();
    }

    /**
     * Gets the list of available RAM choices allowed
     *
     * @return <p>All available RAM choices</p>
     */
    public static String[] getRamList() {
        return ramList;
    }

    /**
     * Gets the buffered reader used to read from this server
     *
     * @return <p>The buffered reader used to read from this server</p>
     */
    private BufferedReader getReader() {
        return this.reader;
    }

    /**
     * Marks the servers as finished stopping when a stop is confirmed
     */
    public static void serversStopped() {
        if (stoppingServers) {
            stoppingServers = false;
        }
    }

    /**
     * Tries to stop all enabled servers
     *
     * @throws IOException <p>If a writer's process is already closed but not null</p>
     */
    public static void stop() throws IOException, InterruptedException {
        if (stoppingServers) {
            killServers();
            return;
        }

        stoppingServers = true;
        for (Collection collection : Main.getController().getCurrentProfile().getCollections()) {
            Server server = collection.getServer();
            if (server.writer != null) {
                if (server.type.isProxy()) {
                    server.writer.write("end\n");
                } else {
                    server.writer.write("stop\n");
                }
                server.writer.flush();
                server.writer = null;
                server.started = false;
            }
        }
    }

    /**
     * Kills all server processes
     *
     * @throws InterruptedException <p>If interrupted waiting for any of the servers to stop</p>
     */
    private static void killServers() throws InterruptedException {
        for (Collection collection : Main.getController().getCurrentProfile().getCollections()) {
            Server server = collection.getServer();
            killServer(server);
        }
    }

    /**
     * Kills the given server after waiting 30 seconds for it to terminate normally
     *
     * @param server <p>The server to kill</p>
     * @throws InterruptedException <p>If interrupted waiting for the server to stop</p>
     */
    private static void killServer(Server server) throws InterruptedException {
        if (server.process != null) {
            if (!server.process.waitFor(30, TimeUnit.SECONDS)) {
                server.process.destroyForcibly();
                server.process.waitFor();
            }
        }
    }

    /**
     * Runs all enabled servers with their settings
     */
    public static void startServers() {
        ServerLauncherController controller = Main.getController();
        controller.getGUI().setStatus("Starting servers");
        int serverNum = 0;
        for (Collection collection : controller.getCurrentProfile().getCollections()) {
            if (!collection.getServer().runServer(serverNum++ == 0)) {
                controller.getGUI().showError("An error occurred. Start aborted. Please check the BuildTools log.");
                try {
                    Server.stop();
                } catch (IOException | InterruptedException e) {
                    e.printStackTrace();
                }
                controller.getGUI().updateGUIElementsWhenServersStartOrStop(false);
                return;
            }
        }
    }

    /**
     * Gets a server object from a server save string
     *
     * @param saveString <p>The string containing necessary data regarding the server</p>
     * @return <p>A server in the same state it was saved in</p>
     */
    public static Server fromString(String saveString) throws ConfigurationException {
        String[] data = saveString.split(";");
        return new Server(data[0], data[1], Boolean.parseBoolean(data[2]), data[3], data[4], data[5]);
    }

    /**
     * Gets the name of the server
     *
     * @return <p>The name of the server</p>
     */
    public String getName() {
        return this.name;
    }

    /**
     * Whether the server has been started
     *
     * @return <p>True if the server has been started. False otherwise</p>
     */
    public boolean isStarted() {
        return started;
    }

    /**
     * Gets the name of the server type used by this server
     *
     * @return <p>The name of the server type used by this server</p>
     */
    public String getTypeName() {
        return this.type.getName();
    }

    /**
     * Gets the server type used by this server
     *
     * @return <p>The server type used by this server</p>
     */
    public ServerType getType() {
        return this.type;
    }

    /**
     * Gets the version used given server type used
     *
     * @return <p>The server version given server type</p>
     */
    public String getServerVersion() {
        return this.serverVersion;
    }

    /**
     * Sets the server's server version to a valid version, or ignores the request
     *
     * @param serverVersion <p>The new server version</p>
     */
    public void setServerVersion(String serverVersion) throws IllegalArgumentException {
        if (this.type.getName().equals("Custom")) {
            this.serverVersion = serverVersion;
        } else {
            String[] versions = this.type.getVersions();
            for (String version : versions) {
                if (version.equals(serverVersion)) {
                    this.serverVersion = serverVersion;
                    return;
                }
            }
            throw new IllegalArgumentException("Invalid server version.");
        }
    }

    /**
     * Gets the path for this server's files
     *
     * @return <p>The path of this server's files</p>
     */
    public String getPath() {
        return this.path;
    }

    /**
     * Sets the path of this server's files
     *
     * @param path <p>The new path of the server's files</p>
     */
    public void setPath(String path) {
        this.path = path;
    }

    /**
     * Gets the process of the server
     *
     * @return <p>The server process</p>
     */
    public Process getProcess() {
        return this.process;
    }

    /**
     * Gets the maximum amount of ram usable by this server
     *
     * @return <p>The maximum amount of ram this server can use</p>
     */
    public String getMaxRam() {
        return this.maxRam;
    }

    /**
     * Sets the max ram to be used by the server
     *
     * @param ram <p>The new maximum ram amount</p>
     */
    public void setMaxRam(String ram) {
        this.maxRam = ram;
    }

    /**
     * Gets a list of all players connected to this server
     *
     * @return <p>A list of all players connected to the server</p>
     */
    public List<String> getPlayers() {
        return this.playerList;
    }

    /**
     * Removes all information about the server's process, writer and reader
     */
    private void cleanStoppedServerValues() {
        consoleOutputExecutor.shutdown();
        process = null;
        writer = null;
        reader = null;
        started = false;
    }

    /**
     * Checks whether this server is currently enabled
     *
     * @return <p>True if the server is currently enabled</p>
     */
    public boolean isEnabled() {
        return this.enabled;
    }

    /**
     * Sets whether this server is currently enabled
     *
     * @param value <p>Whether the server is currently enabled</p>
     */
    public void setEnabled(boolean value) {
        this.enabled = value;
    }

    /**
     * Checks whether this server has a given player
     *
     * @param name <p>The name of the player to check</p>
     * @return <p>True if the player is connected</p>
     */
    private boolean hasPlayer(String name) {
        for (String player : this.playerList) {
            if (player.equals(name)) {
                return true;
            }
        }
        return false;
    }

    /**
     * Adds a player to the GUI and this server's player list
     *
     * @param name <p>The name of the player to add</p>
     */
    private void addPlayer(String name) {
        this.playerList.add(name);
        Main.getController().getGUI().getServerControlTab().addPlayer(name);
    }

    /**
     * Removes a player with the selected name from the player list
     *
     * @param name <p>The name of the player to remove</p>
     */
    private void removePlayer(String name) {
        playerList.removeIf(player -> player.equals(name));
        Main.getController().getGUI().getServerControlTab().removePlayer(name);
    }

    /**
     * Sets the server type to be used by the server
     *
     * @param type <p>The new server type to be used by the server</p>
     */
    public void setType(ServerType type) {
        this.type = type;
    }

    /**
     * Runs a Minecraft server
     *
     * @return <p>True if nothing went wrong</p>
     */
    private boolean runServer(boolean isFirstServer) {
        if (stoppingServers) {
            return false;
        }
        //Ignore a disabled server
        if (!this.enabled) {
            this.started = false;
            return true;
        }
        //Tries to do necessary pre-start work
        if (!initializeJarDownload() || (!isFirstServer && !delayStartup())) {
            this.started = false;
            return false;
        }
        if (stoppingServers) {
            return false;
        }
        //Starts the server if possible
        try {
            startServerProcess();
            Main.getController().getGUI().setStatus("Servers are running");
            this.started = true;
            return true;
        } catch (IOException e) {
            Main.getController().getGUI().setStatus("Could not start server");
            this.started = false;
            return false;
        }
    }

    /**
     * Gets the correct java command to use for the selected server version
     *
     * @return <p>The java version to run</p>
     */
    private String getJavaCommand() {
        ServerLauncherController controller = ServerLauncherController.getInstance();
        if (serverVersion.toLowerCase().contains("latest")) {
            return controller.getJavaCommand();
        } else if (serverVersion.contains(".") && serverVersion.split("\\.").length >= 2 &&
                Integer.parseInt(serverVersion.split("\\.")[1]) >= 17) {
            return controller.getJavaCommand();
        } else {
            return controller.getOldJavaCommand();
        }
    }

    /**
     * Starts the process running this server
     *
     * @throws IOException <p>If the process cannot be started</p>
     */
    private void startServerProcess() throws IOException {
        ProcessBuilder builder;
        String serverPath;
        //Decide the path of the .jar file to be executed
        if (type.getName().equals("Custom")) {
            serverPath = this.path + File.separator + serverVersion;
        } else {
            serverPath = jarDirectory + this.type.getName() + serverVersion + ".jar";
        }
        builder = new ProcessBuilder(getJavaCommand(), "-Xmx" + this.maxRam, "-Xms512M",
                "-Djline.terminal=jline.UnsupportedTerminal", "-Dcom.mojang.eula.agree=true", "-jar", serverPath,
                "nogui");
        builder.directory(new File(this.path));
        builder.redirectErrorStream(true);
        this.process = builder.start();
        this.writer = new BufferedWriter(new OutputStreamWriter(this.process.getOutputStream()));
        this.reader = new BufferedReader(new InputStreamReader(this.process.getInputStream()));

        //Start the process for reading from the server's console
        consoleOutputExecutor = Executors.newSingleThreadScheduledExecutor();
        consoleOutputExecutor.scheduleAtFixedRate(() -> {
            try {
                updateConsole();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }, 10, 500, TimeUnit.MILLISECONDS);
    }

    /**
     * Updates a single console with process output
     *
     * @throws IOException <p>If unable to read from the server's buffered reader</p>
     */
    private void updateConsole() throws IOException {
        String readText = CommonFunctions.readBufferedReader(getReader());
        if (!readText.equals("")) {
            Main.getController().getCurrentProfile().getCollection(getName()).getServerConsole().output(readText);
            updatePlayerList(readText);
        }
        if (!getProcess().isAlive()) {
            cleanStoppedServerValues();
        }
    }

    /**
     * Looks for strings implying a player has joined or left, and updates the appropriate lists
     *
     * @param text <p>The text to search</p>
     */
    private void updatePlayerList(String text) {
        if (!getType().isProxy()) {
            String joinedPlayer = getPlayer(text, true);
            String leftPlayer = getPlayer(text, false);
            if (!joinedPlayer.equals("")) {
                if (!hasPlayer(joinedPlayer)) {
                    addPlayer(joinedPlayer);
                }
            } else if (!leftPlayer.equals("")) {
                if (hasPlayer(leftPlayer)) {
                    removePlayer(leftPlayer);
                }
            }
        }
    }

    /**
     * Searches a string for players joining or leaving
     *
     * @param text   <p>The text string to search through</p>
     * @param joined <p>Whether to search for a joining player</p>
     * @return <p>The name of a player, or an empty string</p>
     */
    private String getPlayer(String text, boolean joined) {
        String playerName;

        String loginPattern1 = " ([A-Z0-9a-z]+)\\[/[0-9]+\\.[0-9]+\\.[0-9]+\\.[0-9]+:[0-9]+] logged in";
        String loginPattern2 = "UUID of player ([A-Z0-9a-z]+) is";

        String logoutPattern1 = "INFO]: ([A-Z0-9a-z]+) lost connection";
        String logoutPattern2 = " ([A-Z0-9a-z]+) left the game";

        if (joined) {
            playerName = getFirstRegexCaptureGroup(loginPattern1, text);
            if (playerName.equals("")) {
                playerName = getFirstRegexCaptureGroup(loginPattern2, text);
            }
        } else {
            playerName = getFirstRegexCaptureGroup(logoutPattern1, text);
            if (playerName.equals("")) {
                playerName = getFirstRegexCaptureGroup(logoutPattern2, text);
            }
        }
        return playerName;
    }

    /**
     * Returns the first regex capture group found in a pattern
     *
     * @param pattern <p>The regex pattern to use</p>
     * @param text    <p>The string to execute the pattern on</p>
     * @return <p>The first capture group if a match is found. An empty string otherwise</p>
     */
    private String getFirstRegexCaptureGroup(String pattern, String text) {
        Pattern compiledPattern = Pattern.compile(pattern);
        Matcher patternMatcher = compiledPattern.matcher(text);
        if (patternMatcher.find()) {
            return patternMatcher.group(1);
        } else {
            return "";
        }
    }

    /**
     * Delays the server's startup for the given amount of time
     *
     * @return <p>True if the delay was successful</p>
     */
    private boolean delayStartup() {
        try {
            Main.getController().getGUI().setStatus("Delaying startup");
            TimeUnit.SECONDS.sleep(Main.getController().getCurrentProfile().getDelayStartup());
            return true;
        } catch (InterruptedException e) {
            e.printStackTrace();
            this.started = false;
            return false;
        }
    }

    /**
     * Starts downloading the necessary .jar file
     *
     * @return <p>True if nothing went wrong</p>
     */
    private boolean initializeJarDownload() {
        ServerLauncherController controller = Main.getController();
        if (!controller.getDownloadAllJars()) {
            try {
                controller.getGUI().setStatus("Downloading jar...");
                this.downloadJar();
                controller.getGUI().setStatus("File downloaded");
            } catch (IOException e) {
                controller.getGUI().setStatus("Error: Jar file not found");
                e.printStackTrace();
                this.started = false;
                return false;
            }
        }
        return true;
    }

    /**
     * Downloads necessary .jar file for the server
     *
     * @throws FileNotFoundException <p>If the file was not found and could not be acquired</p>
     */
    private void downloadJar() throws IOException {
        String path;
        if (this.type.getName().equals("Custom")) {
            path = this.path + File.separator + this.serverVersion;
        } else {
            path = jarDirectory;
        }
        File file = new File(path);
        if (!(file.isFile() || type.downloadJar(path, this.serverVersion))) {
            throw new FileNotFoundException("Jar file could not be downloaded.");
        }
    }

    /**
     * Sends a command to this server through its writer
     *
     * @param command <p>Command to send to the server</p>
     * @throws IOException <p>If write fails</p>
     */
    public void sendCommand(String command) throws IOException {
        if (this.process != null && this.writer != null) {
            this.writer.write(command + "\n");
            this.writer.flush();
        }
    }

    @Override
    public String toString() {
        return String.format(
                "%s;%s;%b;%s;%s;%s;!",
                this.getName(),
                this.getPath(),
                this.isEnabled(),
                this.getTypeName(),
                this.getServerVersion(),
                this.getMaxRam()
        );
    }
}