PersistentBungeeCore/build.gradle

/*
 * This file is a part of the SteamWar software.
 *
 * Copyright (C) 2020  SteamWar.de-Serverteam
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */


import org.apache.tools.ant.taskdefs.condition.Os

plugins {
    id 'java'
    id 'application'

    id 'com.github.johnrengelman.shadow' version '5.0.0'
}

group 'de.steamwar'
version ''

mainClassName = ''

Properties steamwarProperties = new Properties()
if (file("steamwar.properties").exists()) {
    steamwarProperties.load(file("steamwar.properties").newDataInputStream())
}

ext {
    buildName = 'PersistentBungeeCore'
    artifactName = 'persistentbungeecore'

    uberJarName = "${buildName}-all.jar"
    jarName = "${artifactName}.jar"
    libs = "${buildDir}/libs"

    if (Os.isFamily(Os.FAMILY_WINDOWS)) {
        operatingSystem = "windows"
    } else {
        operatingSystem = "unix"
    }
}

compileJava.options.encoding = 'UTF-8'

sourceCompatibility = 1.8
targetCompatibility = 1.8

sourceSets {
    main {
        java {
            srcDirs = ['src/']
        }
        resources {
            srcDirs = ['src/']
            exclude '**/*.java', '**/*.kt'
        }
    }
}

repositories {
    mavenCentral()
}

dependencies {
    compileOnly 'org.projectlombok:lombok:1.18.22'
    testCompileOnly 'org.projectlombok:lombok:1.18.22'
    annotationProcessor 'org.projectlombok:lombok:1.18.22'
    testAnnotationProcessor 'org.projectlombok:lombok:1.18.22'

    compileOnly files("${projectDir}/lib/BungeeCord.jar")
}

task buildProject {
    description 'Build this project'
    group "Steamwar"

    dependsOn build
}

task finalizeProject {
    description 'Finalize this project'
    group "Steamwar"

    doLast {
        if ("${buildDir}" == null) {
            return
        }
        delete fileTree("${libs}").matching {
            exclude("${uberJarName}")
        }
        file(libs + "/" + uberJarName).renameTo(file(libs + "/" + jarName))
    }
}
build.finalizedBy(finalizeProject)

if (steamwarProperties.containsKey("hostname")) {
    String hostname = steamwarProperties.get("hostname")
    String uploadPath = steamwarProperties.getOrDefault("uploadPath", "~")

    String server = steamwarProperties.getOrDefault("server", "Dev1.15")
    String serverStartFlags = steamwarProperties.getOrDefault("serverStartFlags", "")

    task uploadProject {
        description 'Upload this project'
        group "Steamwar"

        doLast {
            await(shell("scp ${libs}/${jarName} ${hostname}:${uploadPath}/${server}/plugins"))
            if (steamwarProperties.getOrDefault("directStart", "false") == "false" && !answer("Start ${server} server?")) {
                return
            }
            serverStart(server, serverStartFlags, hostname)
        }
    }
    uploadProject.dependsOn(buildProject)

    task startDevServer {
        description 'Start the DevServer'
        group "Steamwar"

        doLast {
            serverStart(server, serverStartFlags, hostname)
        }
    }
}

private def await(Process proc) {
    def out = new StringBuilder()
    def err = new StringBuilder()
    proc.waitForProcessOutput(out, err)
    return [out, err, proc.exitValue()]
}

private def shell(String command) {
    if (operatingSystem == "unix") {
        return ['bash', '-c', command].execute()
    } else {
        return ["cmd", "/c", command].execute()
    }
}

private def serverStart(String serverName, String serverFlags, String hostname) {
    def proc = shell("ssh -t ${hostname} \"./mc ${serverFlags} ${serverName}\"")

    Set<String> strings = new HashSet<>()
    File file = new File("${projectDir}/ignoredlog");
    if (file.exists()) {
        new BufferedReader(new InputStreamReader(new FileInputStream(file))).readLines().forEach({ s ->
            strings.add(s)
        })
    }

    Thread outputThread = new Thread({
        Reader reader = proc.getInputStream().newReader();
        Writer writer = System.out.newWriter();
        try {
            while (proc.alive) {
                String s = reader.readLine()
                if (s == null) {
                    return
                }
                if (strings.stream().anyMatch({check -> s.contains(check)})) {
                    continue
                }
                writer.write(s + "\n")
                writer.flush()
            }
        } catch (IOException e) {
            // Ignored
        }
    })
    outputThread.setName("${serverName} - OutputThread")
    outputThread.start()

    Writer writer
    Thread inputThread = new Thread({
        Reader reader = System.in.newReader()
        writer = proc.getOutputStream().newWriter()
        try {
            while (proc.alive) {
                String s = reader.readLine()
                writer.write(s + "\n")
                writer.flush()
            }
        } catch (IOException e) {
            // Ignored
        }
    })
    inputThread.setName("${serverName} - InputThread")
    inputThread.start()

    gradle.buildFinished { buildResult ->
        if (!proc.alive) {
            return
        }
        writer = proc.getOutputStream().newWriter()
        writer.write("stop\n")
        writer.flush()
        awaitClose(proc, outputThread, inputThread)
    }
    awaitClose(proc, outputThread, inputThread)
};

private static def awaitClose(Process proc, Thread outputThread, Thread inputThread) {
    while (proc.alive) {
        Thread.sleep(10)
    }
    proc.closeStreams()
    outputThread.interrupt()
    inputThread.interrupt()
}

private def answer(String question) {
    while (System.in.available() > 0) System.in.read()
    println(question)
    boolean valid = "Yy".contains(((char) System.in.read()).toString())
    while (System.in.available() > 0) System.in.read()
    return valid
}