Feat/launcher

gradle.properties

@@ -1,4 +1,4 @@
 kotlin.code.style=official
 kotlin.stdlib.default.dependency=false
 org.gradle.parallel=true
-version=2.3.2
+version=2.4.0

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,9 @@
-#Sun Apr 05 17:57:20 CEST 2026
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-9.4.0-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.5.0-bin.zip
+networkTimeout=10000
+retries=0
+retryBackOffMs=500
+validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

settings.gradle.kts

@@ -29,3 +29,7 @@ include("surf-core-velocity")
 
 // Microservice
 include("surf-core-microservice")
+
+include("surf-core-launcher")
+include("surf-core-launcher:surf-core-launcher-api")
+include("surf-core-launcher:surf-core-launcher-server")

surf-core-api/surf-core-api-common/build.gradle.kts

@@ -4,6 +4,10 @@ plugins {
     id("dev.slne.surf.api.gradle.core")
 }
 
+surfCoreApi {
+    withSurfRedis()
+}
+
 publishing {
     repositories {
         slneReleases()

surf-core-core/surf-core-core-common/src/main/kotlin/dev/slne/surf/core/core/common/redis/event/SurfEventFireRedisEvent.kt → surf-core-api/surf-core-api-common/src/main/kotlin/dev/slne/surf/core/api/common/event/redis/SurfEventFireRedisEvent.kt

@@ -1,4 +1,4 @@
-package dev.slne.surf.core.core.common.redis.event
+package dev.slne.surf.core.api.common.event.redis
 
 import dev.slne.surf.core.api.common.event.SurfEvent
 import dev.slne.surf.redis.event.RedisEvent

surf-core-api/surf-core-api-common/src/main/kotlin/dev/slne/surf/core/api/common/server/state/SurfServiceStatus.kt

@@ -0,0 +1,6 @@
+package dev.slne.surf.core.api.common.server.state
+
+enum class SurfServiceStatus {
+    UNREACHABLE,
+    CRASHED
+}

surf-core-core/surf-core-core-common/src/main/kotlin/dev/slne/surf/core/core/common/event/LocalSurfEventBusListener.kt

@@ -1,6 +1,6 @@
 package dev.slne.surf.core.core.common.event
 
-import dev.slne.surf.core.core.common.redis.event.SurfEventFireRedisEvent
+import dev.slne.surf.core.api.common.event.redis.SurfEventFireRedisEvent
 import dev.slne.surf.redis.event.OnRedisEvent
 
 object LocalSurfEventBusListener {

surf-core-core/surf-core-core-common/src/main/kotlin/dev/slne/surf/core/core/common/event/SurfEventBus.kt

@@ -2,8 +2,8 @@ package dev.slne.surf.core.core.common.event
 
 import dev.slne.surf.core.api.common.event.SurfEvent
 import dev.slne.surf.core.api.common.event.SurfEventHandler
+import dev.slne.surf.core.api.common.event.redis.SurfEventFireRedisEvent
 import dev.slne.surf.core.core.CoreInstance
-import dev.slne.surf.core.core.common.redis.event.SurfEventFireRedisEvent
 import kotlin.reflect.KClass
 import kotlin.reflect.full.declaredFunctions
 import kotlin.reflect.full.findAnnotation

surf-core-launcher/surf-core-launcher-api/build.gradle.kts

@@ -0,0 +1,19 @@
+import dev.slne.surf.api.gradle.util.slneReleases
+
+plugins {
+    id("dev.slne.surf.api.gradle.core")
+}
+
+surfCoreApi {
+    withSurfRedis()
+}
+
+dependencies {
+    api(projects.surfCoreApi.surfCoreApiCommon)
+}
+
+publishing {
+    repositories {
+        slneReleases()
+    }
+}

surf-core-launcher/surf-core-launcher-api/src/main/kotlin/dev/slne/surf/core/launcher/api/LauncherConstants.kt

@@ -0,0 +1,5 @@
+package dev.slne.surf.core.launcher.api
+
+object LauncherConstants {
+    const val PROPERTY_LAUNCHED_BY_CORE = "LAUNCHED_BY_CORE"
+}

surf-core-launcher/surf-core-launcher-api/src/main/kotlin/dev/slne/surf/core/launcher/api/redis/ServiceStatusRedisEvent.kt

@@ -0,0 +1,11 @@
+package dev.slne.surf.core.launcher.api.redis
+
+import dev.slne.surf.core.api.common.server.state.SurfServiceStatus
+import dev.slne.surf.redis.event.RedisEvent
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class ServiceStatusRedisEvent(
+    val serviceName: String,
+    val status: SurfServiceStatus
+) : RedisEvent()

surf-core-launcher/surf-core-launcher-server/build.gradle.kts

@@ -0,0 +1,21 @@
+plugins {
+    id("dev.slne.surf.api.gradle.standalone")
+}
+
+dependencies {
+    api(projects.surfCoreLauncher.surfCoreLauncherApi)
+    implementation(projects.surfCoreApi.surfCoreApiCommon)
+    implementation("com.fasterxml.jackson.module:jackson-module-kotlin:2.17.2")
+    implementation("dev.slne.surf.redis:surf-redis-standalone:1.6.1")
+}
+
+tasks.jar {
+    manifest {
+        attributes["Main-Class"] = "dev.slne.surf.core.launcher.server.CoreLauncherKt"
+    }
+}
+
+tasks.shadowJar {
+    exclude("okio/**")
+    exclude("io/netty/**")
+}

surf-core-launcher/surf-core-launcher-server/src/main/kotlin/dev/slne/surf/core/launcher/server/CoreLauncher.kt

@@ -0,0 +1,186 @@
+package dev.slne.surf.core.launcher.server
+
+import dev.slne.surf.api.standalone.SurfApiStandaloneBootstrap
+import dev.slne.surf.core.api.common.event.SurfServerStartEvent
+import dev.slne.surf.core.api.common.event.redis.SurfEventFireRedisEvent
+import dev.slne.surf.core.launcher.api.LauncherConstants
+import dev.slne.surf.core.launcher.server.config.CoreLauncherConfig
+import dev.slne.surf.core.launcher.server.ping.MinecraftServerPinger
+import dev.slne.surf.core.launcher.server.updater.process.PluginUpdater
+import dev.slne.surf.redis.RedisApi
+import dev.slne.surf.redis.StandaloneRedisInstance
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.MutableStateFlow
+import java.nio.file.Path
+import java.time.LocalDateTime
+import java.time.format.DateTimeFormatter
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicBoolean
+import kotlin.io.path.Path
+import kotlin.time.Duration.Companion.seconds
+
+private val secondDateTimeFormatter = DateTimeFormatter.ofPattern("dd-MM-yyyy HH:mm:ss")
+
+val LOG_PREFIX
+    get() =
+        "\u001B[0;91m[${
+            LocalDateTime.now().format(secondDateTimeFormatter)
+        } CoreLauncher]\u001B[0m"
+
+object CoreLauncher {
+    private val shuttingDown = AtomicBoolean(false)
+    lateinit var serverProcess: Process
+
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+    private var monitorJob: Job? = null
+    private val redisInstance = StandaloneRedisInstance(
+        name = "surf-core-launcher",
+        configPath = findRedisPluginPath()
+            ?: error("Could not find Redis plugin configuration path, cannot start Redis instance")
+    )
+    lateinit var redisApi: RedisApi
+
+    val serverOnline = MutableStateFlow(false)
+
+    val config by lazy {
+        CoreLauncherConfig.getConfig()
+    }
+
+    suspend fun launch() = withContext(Dispatchers.IO) {
+        SurfApiStandaloneBootstrap.bootstrap()
+        SurfApiStandaloneBootstrap.enable()
+
+        println("$LOG_PREFIX Initializing Redis instance...")
+
+        redisInstance.create()
+        redisApi = RedisApi.create()
+        redisApi.freezeAndConnect()
+
+        println("$LOG_PREFIX Redis instance initialized and connected")
+
+        if (config.autoUpdateSurfPlugins) {
+            println("$LOG_PREFIX Searching plugin updates...")
+
+            withTimeoutOrNull(20.seconds) {
+                if (config.personalAccessToken.isBlank()) {
+                    println("$LOG_PREFIX No GitHub personal access token provided, skipping plugin update check")
+                    return@withTimeoutOrNull
+                }
+
+                PluginUpdater.start()
+            }
+                ?: println("$LOG_PREFIX Plugin update check timed out after 20 seconds, continuing with server startup")
+        }
+
+        println("$LOG_PREFIX Starting Minecraft Server...")
+
+        val command = buildStartupCommand()
+
+        serverProcess = ProcessBuilder(command)
+            .redirectInput(ProcessBuilder.Redirect.INHERIT)
+            .redirectOutput(ProcessBuilder.Redirect.PIPE)
+            .redirectError(ProcessBuilder.Redirect.INHERIT)
+            .start()
+
+        println("$LOG_PREFIX Server process started")
+
+        redisApi.publishEvent(
+            SurfEventFireRedisEvent(
+                SurfServerStartEvent(
+                    serverName = config.serverName
+                )
+            )
+        )
+
+        monitorJob = scope.launch {
+            launch {
+                serverProcess.inputStream.bufferedReader().forEachLine { line ->
+                    println(line)
+
+                    if (line.contains(
+                            config.startedMessage,
+                            ignoreCase = true
+                        )
+                    ) {
+                        serverOnline.value = true
+                        println("$LOG_PREFIX Server is now online.")
+                    }
+                }
+            }
+
+            MinecraftServerPinger.monitor(serverProcess)
+        }
+    }
+
+    suspend fun shutdown() {
+        if (!shuttingDown.compareAndSet(false, true)) {
+            return
+        }
+
+        serverOnline.value = true
+
+        println("$LOG_PREFIX Shutting down launcher/server...")
+        println("$LOG_PREFIX Disconnecting Redis instance...")
+
+        redisApi.disconnect()
+        redisInstance.shutdown()
+        println("$LOG_PREFIX Redis instance disconnected and shutdown")
+
+        monitorJob?.cancelAndJoin()
+
+        if (::serverProcess.isInitialized && serverProcess.isAlive) {
+            serverProcess.destroy()
+
+            if (!serverProcess.waitFor(45, TimeUnit.SECONDS)) {
+                println("$LOG_PREFIX Server did not stop within 45 seconds")
+            }
+        }
+
+        scope.cancel()
+    }
+
+    fun isShuttingDown(): Boolean = shuttingDown.get()
+
+    private fun buildStartupCommand(): List<String> {
+        val base = config.serverStartupCommand
+
+        val parts = Regex("""[^\s"]+|"([^"]*)"""")
+            .findAll(base)
+            .map { it.value.replace("\"", "") }
+            .toMutableList()
+
+        val flag = "-D${LauncherConstants.PROPERTY_LAUNCHED_BY_CORE}"
+
+        if (parts.none { it == flag }) {
+            parts.add(1, flag)
+        }
+
+        return parts
+    }
+
+    private fun findRedisPluginPath(): Path? {
+        val possiblePaths = listOf(
+            Path("plugins", "surf-redis-paper"),
+            Path("plugins", "surf-redis-velocity")
+        )
+
+        return possiblePaths.firstOrNull { path ->
+            path.toFile().exists()
+        }
+    }
+}
+
+suspend fun main(args: Array<String>) {
+    Runtime.getRuntime().addShutdownHook(Thread {
+        runBlocking {
+            CoreLauncher.shutdown()
+            SurfApiStandaloneBootstrap.shutdown()
+        }
+    })
+
+    CoreLauncher.launch()
+    CoreLauncher.serverProcess.waitFor()
+
+    CoreLauncher.shutdown()
+    SurfApiStandaloneBootstrap.shutdown()
+}

surf-core-launcher/surf-core-launcher-server/src/main/kotlin/dev/slne/surf/core/launcher/server/CoreLauncherEnvironment.kt

@@ -0,0 +1,8 @@
+package dev.slne.surf.core.launcher.server
+
+object CoreLauncherEnvironment {
+    val MC_MEMORY_MAX =
+        System.getenv("SERVER_MEMORY") ?: error("SERVER_MEMORY environment variable is not set")
+    val SERVER_PORT = System.getenv("SERVER_PORT")?.toInt()
+        ?: error("SERVER_PORT environment variable is not set or is not a valid integer")
+}