feat: make envoy start port configurable

Author: dayyeeet

controller-runtime/src/main/kotlin/app/simplecloud/controller/runtime/ControllerRuntime.kt

@@ -43,7 +43,7 @@ class ControllerRuntime(
     private val serverRepository = ServerRepository(database, numericalIdRepository)
     private val hostRepository = ServerHostRepository()
     private val serverHostAttacher = ServerHostAttacher(hostRepository, serverRepository)
-    private val dropletRepository = DropletRepository(authCallCredentials, serverHostAttacher, hostRepository)
+    private val dropletRepository = DropletRepository(authCallCredentials, serverHostAttacher, controllerStartCommand.envoyStartPort, hostRepository)
     private val pubSubService = PubSubService()
     private val controlPlaneServer = ControlPlaneServer(controllerStartCommand, dropletRepository)
     private val authServer = OAuthServer(controllerStartCommand, database)

controller-runtime/src/main/kotlin/app/simplecloud/controller/runtime/droplet/ControllerDropletService.kt

@@ -1,6 +1,5 @@
 package app.simplecloud.controller.runtime.droplet
 
-import app.simplecloud.controller.runtime.MetricsEventNames
 import app.simplecloud.droplet.api.droplet.Droplet
 import build.buf.gen.simplecloud.controller.v1.*
 import io.grpc.Status

controller-runtime/src/main/kotlin/app/simplecloud/controller/runtime/droplet/DropletRepository.kt

@@ -2,6 +2,7 @@ package app.simplecloud.controller.runtime.droplet
 
 import app.simplecloud.controller.runtime.Repository
 import app.simplecloud.controller.runtime.envoy.DropletCache
+import app.simplecloud.controller.runtime.hack.PortProcessHandle
 import app.simplecloud.controller.runtime.host.ServerHostRepository
 import app.simplecloud.controller.runtime.server.ServerHostAttacher
 import app.simplecloud.controller.shared.host.ServerHost
@@ -15,11 +16,12 @@ import kotlinx.coroutines.launch
 class DropletRepository(
     private val authCallCredentials: AuthCallCredentials,
     private val serverHostAttacher: ServerHostAttacher,
+    private val envoyStartPort: Int,
     private val serverHostRepository: ServerHostRepository,
 ) : Repository<Droplet, String> {
 
     private val currentDroplets = mutableListOf<Droplet>()
-    private val dropletCache = DropletCache(this)
+    private val dropletCache = DropletCache()
 
     override suspend fun getAll(): List<Droplet> {
         return currentDroplets
@@ -33,8 +35,9 @@ class DropletRepository(
         return currentDroplets.firstOrNull { it.type == type && it.id == identifier }
     }
 
+    @Synchronized
     override fun save(element: Droplet) {
-        val updated = managePortRange(element)
+        val updated = managePortRange(element.copy(envoyPort = envoyStartPort))
         val droplet = find(element.type, element.id)
         if (droplet != null) {
             currentDroplets[currentDroplets.indexOf(droplet)] = updated
@@ -45,10 +48,11 @@ class DropletRepository(
         postUpdate(updated)
     }
 
+    @Synchronized
     private fun postUpdate(droplet: Droplet) {
+        dropletCache.update(currentDroplets)
+        if (droplet.type != "serverhost") return
         CoroutineScope(Dispatchers.IO).launch {
-            dropletCache.update()
-            if (droplet.type != "serverhost") return@launch
             serverHostAttacher.attach(
                 ServerHost(
                     droplet.id, droplet.host, droplet.port, ServerHostServiceGrpcKt.ServerHostServiceCoroutineStub(
@@ -63,14 +67,14 @@ class DropletRepository(
     }
 
     private fun managePortRange(element: Droplet): Droplet {
-        if (!currentDroplets.any { it.envoyPort == element.envoyPort }) return element
+        if (!currentDroplets.any { it.envoyPort == element.envoyPort } && PortProcessHandle.of(element.envoyPort).isEmpty) return element
         return managePortRange(element.copy(envoyPort = element.envoyPort + 1))
     }
 
     override suspend fun delete(element: Droplet): Boolean {
         val found = find(element.type, element.id) ?: return false
         if (!currentDroplets.remove(found)) return false
-        dropletCache.update()
+        dropletCache.update(currentDroplets)
         if (element.type == "serverhost") {
             val host = serverHostRepository.findServerHostById(element.id) ?: return true
             serverHostRepository.delete(host)

controller-runtime/src/main/kotlin/app/simplecloud/controller/runtime/envoy/ControlPlaneServer.kt

@@ -43,6 +43,15 @@ class ControlPlaneServer(private val args: ControllerStartCommand, private val d
                 envoyPort = 8080,
             )
         )
+        dropletRepository.save(
+            Droplet(
+                type = "auth",
+                id = "internal-auth",
+                host = args.grpcHost,
+                port = args.authorizationPort,
+                envoyPort = 8080
+            )
+        )
     }
 
     private fun register(builder: ServerBuilder<*>) {

controller-runtime/src/main/kotlin/app/simplecloud/controller/runtime/envoy/DropletCache.kt

@@ -31,23 +31,21 @@ import java.util.*
 /**
  * This class handles the remapping of the [DropletRepository] to a [SimpleCache] of [Snapshot]s, which are used by the envoy ADS service.
  */
-class DropletCache(private val dropletRepository: DropletRepository) {
+class DropletCache {
     private val cache = SimpleCache(SimpleCloudNodeGroup())
     private val logger = LogManager.getLogger(DropletCache::class.java)
 
     //Create a new Snapshot by the droplet repository's data
-    suspend fun update() {
+    fun update(droplets: List<Droplet>) {
         logger.info("Detected new droplets in DropletRepository, adding to ADS...")
         val clusters = mutableListOf<Cluster>()
         val listeners = mutableListOf<Listener>()
         val clas = mutableListOf<ClusterLoadAssignment>()
-
-        dropletRepository.getAll().forEach {
+        droplets.forEach {
             clusters.add(createCluster(it))
             listeners.add(createListener(it))
             clas.add(createCLA(it))
         }
-
         cache.setSnapshot(
             SimpleCloudNodeGroup.GROUP,
             Snapshot.create(

controller-runtime/src/main/kotlin/app/simplecloud/controller/runtime/hack/OS.kt

@@ -0,0 +1,19 @@
+package app.simplecloud.controller.runtime.hack
+
+enum class OS(val names: List<String>) {
+    WINDOWS(listOf("windows")),
+    LINUX(listOf("linux")),
+    MAC(listOf("mac"));
+
+    companion object {
+        fun get(): OS? {
+            val name = System.getProperty("os.name").lowercase()
+            entries.forEach {
+                if (it.names.any { osName -> name.contains(osName) }) {
+                    return it
+                }
+            }
+            return null
+        }
+    }
+}

controller-runtime/src/main/kotlin/app/simplecloud/controller/runtime/hack/PortProcessHandle.kt

@@ -0,0 +1,81 @@
+package app.simplecloud.controller.runtime.hack
+
+import app.simplecloud.controller.shared.server.Server
+import build.buf.gen.simplecloud.controller.v1.ServerDefinition
+import java.time.LocalDateTime
+import java.util.*
+import java.util.concurrent.ConcurrentHashMap
+import java.util.regex.Pattern
+
+object PortProcessHandle {
+
+    private const val WINDOWS_PID_INDEX = 3
+    private val windowsPattern = Pattern.compile("\\s*TCP\\s+\\S+:(\\d+)\\s+\\S+:(\\d+)\\s+\\S+\\s+(\\d+)")
+
+    private val preBindPorts = ConcurrentHashMap<Int, LocalDateTime>()
+
+    fun of(port: Int): Optional<ProcessHandle> {
+        val os = OS.get() ?: return Optional.empty()
+        val command = when (os) {
+            OS.LINUX, OS.MAC -> arrayOf("sh", "-c", "lsof -i :$port | awk '{print \$2}'")
+            OS.WINDOWS -> arrayOf("cmd", "/c", "netstat -ano | findstr $port")
+        }
+
+        val process = Runtime.getRuntime().exec(command)
+
+        val bufferedReader = process.inputReader()
+        val processId = bufferedReader.useLines { lines ->
+            lines.firstNotNullOfOrNull { parseProcessIdOrNull(os, it) }
+        }
+
+        if (processId == null) {
+            return Optional.empty()
+        }
+
+        return ProcessHandle.of(processId)
+    }
+
+    private fun parseProcessIdOrNull(os: OS, line: String): Long? {
+        return when (os) {
+            OS.LINUX, OS.MAC -> line.toLongOrNull()
+            OS.WINDOWS -> {
+                val matcher = windowsPattern.matcher(line)
+                if (!matcher.matches()) {
+                    return null
+                }
+
+                return matcher.group(WINDOWS_PID_INDEX).toLongOrNull()
+            }
+        }
+    }
+
+    @Synchronized
+    fun findNextFreePort(startPort: Int, serverDefinition: ServerDefinition): Int {
+        val server = Server.fromDefinition(serverDefinition)
+        var port = startPort
+        val time = LocalDateTime.now()
+        while (isPortBound(port)) {
+            port++
+        }
+        addPreBind(port, time, server.properties.getOrDefault("max-startup-seconds", "120").toLong())
+        return port
+    }
+
+    private fun addPreBind(port: Int, time: LocalDateTime, duration: Long) {
+        preBindPorts[port] = time.plusSeconds(duration)
+    }
+
+    fun isPortBound(port: Int): Boolean {
+        return !of(port).isEmpty || LocalDateTime.now().isBefore(preBindPorts.getOrDefault(port, LocalDateTime.MIN))
+    }
+
+    fun removePreBind(port: Int, forced: Boolean = false) {
+        // Check if max-startup-seconds is reached and return if not
+        if (!forced && LocalDateTime.now().isBefore(preBindPorts.getOrDefault(port, LocalDateTime.MAX))) {
+            return
+        }
+
+        preBindPorts.remove(port)
+    }
+
+}

controller-runtime/src/main/kotlin/app/simplecloud/controller/runtime/launcher/ControllerStartCommand.kt

@@ -46,10 +46,13 @@ class ControllerStartCommand(
     ).int().default(5818)
 
     val envoyDiscoveryPort: Int by option(
-        help = "Authorization port (default: 5814)",
+        help = "Envoy Discovery port (default: 5814)",
         envvar = "ENVOY_DISCOVERY_PORT"
     ).int().default(5814)
 
+    val envoyStartPort: Int by option(help = "Envoy start port (default: 8080)", envvar = "ENVOY_START_PORT").int()
+        .default(8080)
+
     private val authSecretPath: Path by option(
         help = "Path to auth secret file (default: .auth.secret)",
         envvar = "AUTH_SECRET_PATH"