fix: include reattaching into serverhost registration

Author: dayyeeet

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

@@ -10,6 +10,7 @@ import app.simplecloud.controller.runtime.host.ServerHostRepository
 import app.simplecloud.controller.runtime.launcher.ControllerStartCommand
 import app.simplecloud.controller.runtime.oauth.OAuthServer
 import app.simplecloud.controller.runtime.reconciler.Reconciler
+import app.simplecloud.controller.runtime.server.ServerHostAttacher
 import app.simplecloud.controller.runtime.server.ServerNumericalIdRepository
 import app.simplecloud.controller.runtime.server.ServerRepository
 import app.simplecloud.controller.runtime.server.ServerService
@@ -32,11 +33,12 @@ class ControllerRuntime(
     private val database = DatabaseFactory.createDatabase(controllerStartCommand.databaseUrl)
     private val authCallCredentials = AuthCallCredentials(controllerStartCommand.authSecret)
 
-    private val dropletRepository = DropletRepository()
     private val groupRepository = GroupRepository(controllerStartCommand.groupPath)
     private val numericalIdRepository = ServerNumericalIdRepository()
     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 pubSubService = PubSubService()
     private val controlPlaneServer = ControlPlaneServer(controllerStartCommand, dropletRepository)
     private val authServer = OAuthServer(controllerStartCommand, database)
@@ -162,7 +164,8 @@ class ControllerRuntime(
                         controllerStartCommand.grpcHost,
                         controllerStartCommand.pubSubGrpcPort,
                         authCallCredentials
-                    )
+                    ),
+                    serverHostAttacher
                 )
             )
             .addService(ControllerDropletService(dropletRepository))

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

@@ -2,12 +2,21 @@ package app.simplecloud.controller.runtime.droplet
 
 import app.simplecloud.controller.runtime.Repository
 import app.simplecloud.controller.runtime.envoy.DropletCache
+import app.simplecloud.controller.runtime.host.ServerHostRepository
+import app.simplecloud.controller.runtime.server.ServerHostAttacher
+import app.simplecloud.controller.shared.host.ServerHost
+import app.simplecloud.droplet.api.auth.AuthCallCredentials
 import app.simplecloud.droplet.api.droplet.Droplet
+import build.buf.gen.simplecloud.controller.v1.ServerHostServiceGrpcKt
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 
-class DropletRepository : Repository<Droplet, String> {
+class DropletRepository(
+    private val authCallCredentials: AuthCallCredentials,
+    private val serverHostAttacher: ServerHostAttacher,
+    private val serverHostRepository: ServerHostRepository,
+) : Repository<Droplet, String> {
 
     private val currentDroplets = mutableListOf<Droplet>()
     private val dropletCache = DropletCache(this)
@@ -29,11 +38,27 @@ class DropletRepository : Repository<Droplet, String> {
         val droplet = find(element.type, element.id)
         if (droplet != null) {
             currentDroplets[currentDroplets.indexOf(droplet)] = updated
+            postUpdate(updated)
             return
         }
         currentDroplets.add(updated)
+        postUpdate(updated)
+    }
+
+    private fun postUpdate(droplet: Droplet) {
         CoroutineScope(Dispatchers.IO).launch {
             dropletCache.update()
+            if (droplet.type != "serverhost") return@launch
+            serverHostAttacher.attach(
+                ServerHost(
+                    droplet.id, droplet.host, droplet.port, ServerHostServiceGrpcKt.ServerHostServiceCoroutineStub(
+                        ServerHost.createChannel(
+                            droplet.host,
+                            droplet.port
+                        )
+                    ).withCallCredentials(authCallCredentials)
+                )
+            )
         }
     }
 
@@ -46,6 +71,10 @@ class DropletRepository : Repository<Droplet, String> {
         val found = find(element.type, element.id) ?: return false
         if (!currentDroplets.remove(found)) return false
         dropletCache.update()
+        if (element.type == "serverhost") {
+            val host = serverHostRepository.findServerHostById(element.id) ?: return true
+            serverHostRepository.delete(host)
+        }
         return true
     }
 

controller-runtime/src/main/kotlin/app/simplecloud/controller/runtime/server/ServerHostAttacher.kt

@@ -0,0 +1,38 @@
+package app.simplecloud.controller.runtime.server
+
+import app.simplecloud.controller.runtime.host.ServerHostRepository
+import app.simplecloud.controller.shared.host.ServerHost
+import app.simplecloud.controller.shared.server.Server
+import io.grpc.Status
+import io.grpc.StatusException
+import kotlinx.coroutines.coroutineScope
+import org.apache.logging.log4j.LogManager
+
+class ServerHostAttacher(
+    private val hostRepository: ServerHostRepository,
+    private val serverRepository: ServerRepository
+) {
+
+    private val logger = LogManager.getLogger(ServerHostAttacher::class.java)
+
+    suspend fun attach(serverHost: ServerHost) {
+        hostRepository.delete(serverHost)
+        hostRepository.save(serverHost)
+        logger.info("Successfully registered ServerHost ${serverHost.id}.")
+
+        coroutineScope {
+            serverRepository.findServersByHostId(serverHost.id).forEach { server ->
+                logger.info("Reattaching Server ${server.uniqueId} of group ${server.group}...")
+                try {
+                    val result = serverHost.stub?.reattachServer(server.toDefinition())
+                        ?: throw StatusException(Status.INTERNAL.withDescription("Could not reattach server, is the host misconfigured?"))
+                    serverRepository.save(Server.fromDefinition(result))
+                    logger.info("Success!")
+                } catch (e: Exception) {
+                    logger.error("Server was found to be offline, unregistering...")
+                    serverRepository.delete(server)
+                }
+            }
+        }
+    }
+}

controller-runtime/src/main/kotlin/app/simplecloud/controller/runtime/server/ServerService.kt

@@ -11,7 +11,6 @@ import app.simplecloud.pubsub.PubSubClient
 import build.buf.gen.simplecloud.controller.v1.*
 import io.grpc.Status
 import io.grpc.StatusException
-import kotlinx.coroutines.coroutineScope
 import org.apache.logging.log4j.LogManager
 import java.time.LocalDateTime
 import java.util.*
@@ -23,6 +22,7 @@ class ServerService(
     private val groupRepository: GroupRepository,
     private val authCallCredentials: AuthCallCredentials,
     private val pubSubClient: PubSubClient,
+    private val serverHostAttacher: ServerHostAttacher,
 ) : ControllerServerServiceGrpcKt.ControllerServerServiceCoroutineImplBase() {
 
     private val logger = LogManager.getLogger(ServerService::class.java)
@@ -31,25 +31,9 @@ class ServerService(
     override suspend fun attachServerHost(request: AttachServerHostRequest): ServerHostDefinition {
         val serverHost = ServerHost.fromDefinition(request.serverHost, authCallCredentials)
         try {
-            hostRepository.delete(serverHost)
-            hostRepository.save(serverHost)
+            serverHostAttacher.attach(serverHost)
         } catch (e: Exception) {
-            throw StatusException(Status.INTERNAL.withDescription("Could not save serverhost").withCause(e))
-        }
-        logger.info("Successfully registered ServerHost ${serverHost.id}.")
-
-        coroutineScope {
-            serverRepository.findServersByHostId(serverHost.id).forEach { server ->
-                logger.info("Reattaching Server ${server.uniqueId} of group ${server.group}...")
-                try {
-                    val result = serverHost.stub?.reattachServer(server.toDefinition()) ?: throw StatusException(Status.INTERNAL.withDescription("Could not reattach server, is the host misconfigured?"))
-                    serverRepository.save(Server.fromDefinition(result))
-                    logger.info("Success!")
-                } catch (e: Exception) {
-                    logger.error("Server was found to be offline, unregistering...")
-                    serverRepository.delete(server)
-                }
-            }
+            throw StatusException(Status.INTERNAL.withDescription("Could not attach serverhost").withCause(e))
         }
         return serverHost.toDefinition()
     }
@@ -214,7 +198,10 @@ class ServerService(
         }
     }
 
-    private suspend fun stopServer(server: ServerDefinition, cause: ServerStopCause = ServerStopCause.NATURAL_STOP): ServerDefinition {
+    private suspend fun stopServer(
+        server: ServerDefinition,
+        cause: ServerStopCause = ServerStopCause.NATURAL_STOP
+    ): ServerDefinition {
         val host = hostRepository.findServerHostById(server.hostId)
             ?: throw Status.NOT_FOUND
                 .withDescription("No server host was found matching this server.")