263 Zeilen
7.4 KiB
Groovy
263 Zeilen
7.4 KiB
Groovy
/*
|
|
* 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 {
|
|
// Adding the base plugin fixes the following gradle warnings in IntelliJ:
|
|
//
|
|
// Warning: root project 'module-work-multi': Unable to resolve all content root directories
|
|
// Details: java.lang.IllegalStateException: No value has been specified for this provider.
|
|
//
|
|
// Warning: root project 'module-work-multi': Unable to resolve additional project configuration.
|
|
// Details: java.lang.IllegalStateException: No value has been specified for this provider.
|
|
id 'base'
|
|
id 'application'
|
|
|
|
id 'com.github.johnrengelman.shadow' version '5.0.0'
|
|
}
|
|
|
|
ext.swdep = { s ->
|
|
if (file("${rootDir}/lib/${s}.jar").exists()) {
|
|
return files("${rootDir}/lib/${s}.jar")
|
|
} else {
|
|
if (s.contains("-")) {
|
|
return "de.steamwar:${s.toLowerCase().replace('-', ':')}"
|
|
} else {
|
|
return "de.steamwar:${s.toLowerCase()}:RELEASE"
|
|
}
|
|
}
|
|
}
|
|
|
|
group 'de.steamwar'
|
|
version ''
|
|
|
|
Properties steamwarProperties = new Properties()
|
|
if (file("steamwar.properties").exists()) {
|
|
steamwarProperties.load(file("steamwar.properties").newDataInputStream())
|
|
}
|
|
|
|
ext {
|
|
buildName = 'BauSystem2.0'
|
|
artifactName = 'bausystem2.0'
|
|
|
|
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'
|
|
compileJava.options.compilerArgs << '-parameter'
|
|
|
|
sourceCompatibility = 11
|
|
targetCompatibility = 11
|
|
|
|
mainClassName = ''
|
|
|
|
allprojects {
|
|
repositories {
|
|
mavenCentral()
|
|
|
|
maven {
|
|
url = uri("https://repo.codemc.io/repository/maven-snapshots/")
|
|
}
|
|
|
|
maven {
|
|
url = uri('https://hub.spigotmc.org/nexus/content/repositories/snapshots/')
|
|
}
|
|
|
|
maven {
|
|
url = uri('https://libraries.minecraft.net')
|
|
}
|
|
|
|
maven {
|
|
url = uri('https://steamwar.de/maven/')
|
|
credentials {
|
|
username = steamwarProperties.getProperty("maven.username")
|
|
password = steamwarProperties.getProperty("maven.password")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
dependencies {
|
|
file('.').listFiles().each {
|
|
if (!it.isDirectory()) {
|
|
return
|
|
}
|
|
if (new File(it, "build.gradle").exists()) {
|
|
implementation project(":" + it.name)
|
|
}
|
|
}
|
|
}
|
|
|
|
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 type = steamwarProperties.getOrDefault("type", "Bau19")
|
|
String world = steamwarProperties.getOrDefault("world", "")
|
|
String pluginFolder = steamwarProperties.getOrDefault("pluginFolder", "")
|
|
|
|
task uploadProject {
|
|
description 'Upload this project'
|
|
group "Steamwar"
|
|
|
|
doLast {
|
|
await(shell("scp ${libs}/${jarName} ${hostname}:${pluginFolder}"))
|
|
if (steamwarProperties.getOrDefault("directStart", "false") == "false" && !answer("Start ${server} server?")) {
|
|
return
|
|
}
|
|
serverStart(type, hostname, world, pluginFolder)
|
|
}
|
|
}
|
|
uploadProject.dependsOn(buildProject)
|
|
|
|
task startDevServer {
|
|
description 'Start the DevServer'
|
|
group "Steamwar"
|
|
|
|
doLast {
|
|
serverStart(server, "", 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 type, String hostname, String worldName, String pluginFolder) {
|
|
def proc = shell("ssh -t ${hostname} \"./binarys/dev.py ${type} -w ${worldName} -p ${pluginFolder}\"")
|
|
|
|
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("${type} - 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("${type} - 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
|
|
} |