More cloud like

gradle.properties

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

surf-core-api/surf-core-api-paper/src/main/kotlin/dev/slne/surf/core/api/paper/CorePlayerInfoProvider.kt

@@ -0,0 +1,38 @@
+package dev.slne.surf.core.api.paper
+
+import dev.slne.surf.core.api.paper.CorePlayerInfoProvider.Companion.getServerInfo
+import java.util.*
+
+interface CorePlayerInfoProvider {
+    fun createServerInfo(playerUuid: UUID): ServerInfo?
+
+    /**
+     * Server Info data class containing the server name, nice name and region. This is used to provide information about the server a player is currently on.
+     *
+     * @param serverName The name of the server the player is currently on.
+     * @param serverDisplayName The nice name of the server the player is currently on.
+     * @param serverRegion The region of the server the player is currently on.
+     *
+     * NOTE: This method should not be used to gain access to players current server. Use [dev.slne.surf.core.api.common.player.SurfPlayer.currentServer] instead.
+     *
+     * @see [getServerInfo]
+     */
+    data class ServerInfo(
+        val serverName: String,
+        val serverDisplayName: String,
+        val serverRegion: String
+    )
+
+    companion object {
+        private lateinit var instance: CorePlayerInfoProvider
+
+        fun setInstance(provider: CorePlayerInfoProvider) {
+            instance = provider
+        }
+
+        /**
+         * Available after plugin bootstrapper
+         */
+        fun getServerInfo(playerUuid: UUID) = instance.createServerInfo(playerUuid)
+    }
+}

surf-core-api/surf-core-api-velocity/src/main/kotlin/dev/slne/surf/core/api/velocity/command/argument/SurfCommonServerArgument.kt

@@ -7,6 +7,7 @@ import com.velocitypowered.api.command.VelocityBrigadierMessage
 import dev.jorel.commandapi.CommandAPICommand
 import dev.jorel.commandapi.CommandTree
 import dev.jorel.commandapi.arguments.Argument
+import dev.jorel.commandapi.arguments.ArgumentSuggestions
 import dev.jorel.commandapi.arguments.CommandAPIArgumentType
 import dev.jorel.commandapi.executors.CommandArguments
 import dev.slne.surf.api.core.messages.adventure.buildText
@@ -19,6 +20,14 @@ open class SurfServerArgument(nodeName: String) :
         return CommonSurfServer::class.java
     }
 
+    init {
+        replaceSuggestions(
+            ArgumentSuggestions.stringCollection { _ ->
+                SurfCoreApi.getCommonServers().map { it.name }
+            }
+        )
+    }
+
     override fun getArgumentType(): CommandAPIArgumentType? {
         return CommandAPIArgumentType.PRIMITIVE_STRING
     }

surf-core-api/surf-core-api-velocity/src/main/kotlin/dev/slne/surf/core/api/velocity/command/argument/SurfOfflinePlayerArgument.kt

@@ -5,6 +5,7 @@ import com.mojang.brigadier.context.CommandContext
 import dev.jorel.commandapi.CommandAPICommand
 import dev.jorel.commandapi.CommandTree
 import dev.jorel.commandapi.arguments.Argument
+import dev.jorel.commandapi.arguments.ArgumentSuggestions
 import dev.jorel.commandapi.arguments.CommandAPIArgumentType
 import dev.jorel.commandapi.executors.CommandArguments
 import dev.slne.surf.api.core.util.logger
@@ -33,6 +34,15 @@ open class SurfOfflinePlayerArgument(nodeName: String) :
         SurfCoreApi.getOfflinePlayer(StringArgumentType.getString(cmdCtx, key))
     }.asDeferred()
 
+    init {
+        replaceSuggestions(
+            ArgumentSuggestions.stringCollection { _ ->
+                SurfCoreApi.getOnlinePlayers()
+                    .mapNotNull { it.lastKnownName }
+            }
+        )
+    }
+
     companion object {
         private val log = logger()
         private val scope =

surf-core-api/surf-core-api-velocity/src/main/kotlin/dev/slne/surf/core/api/velocity/command/argument/SurfPlayerArgument.kt

@@ -7,6 +7,7 @@ import com.velocitypowered.api.command.VelocityBrigadierMessage
 import dev.jorel.commandapi.CommandAPICommand
 import dev.jorel.commandapi.CommandTree
 import dev.jorel.commandapi.arguments.Argument
+import dev.jorel.commandapi.arguments.ArgumentSuggestions
 import dev.jorel.commandapi.arguments.CommandAPIArgumentType
 import dev.jorel.commandapi.executors.CommandArguments
 import dev.slne.surf.api.core.messages.adventure.buildText
@@ -36,6 +37,16 @@ open class SurfPlayerArgument(nodeName: String) :
                 }
             )
         ).create()
+
+
+    init {
+        replaceSuggestions(
+            ArgumentSuggestions.stringCollection { _ ->
+                SurfCoreApi.getOnlinePlayers()
+                    .mapNotNull { it.lastKnownName }
+            }
+        )
+    }
 }
 
 inline fun CommandTree.surfPlayerArgument(

surf-core-core/surf-core-core-client/src/main/kotlin/dev/slne/surf/core/client/ClientLoader.kt

@@ -4,8 +4,10 @@ package dev.slne.surf.core.client
 
 import dev.slne.surf.core.core.common.event.LocalSurfEventBusListener
 import dev.slne.surf.core.core.common.player.SurfPlayerService
+import dev.slne.surf.core.core.common.redis.listener.ExecuteCommandRedisListener
 import dev.slne.surf.core.core.common.redis.listener.SendPlayerToProxyListener
 import dev.slne.surf.core.core.common.redis.listener.SendPlayerToServerListener
+import dev.slne.surf.core.core.common.redis.listener.ShutdownServerRedisListener
 import dev.slne.surf.core.core.common.server.SurfServerService
 import dev.slne.surf.rabbitmq.api.ClientRabbitMQApi
 import dev.slne.surf.redis.RedisApi
@@ -31,6 +33,9 @@ class ClientLoader(
         withListener(SendPlayerToServerListener)
         withListener(SendPlayerToProxyListener)
 
+        withRequestResponseHandler(ShutdownServerRedisListener)
+        withRequestResponseHandler(ExecuteCommandRedisListener)
+
         // Initialize Redis Maps
         SurfPlayerService
         SurfServerService

surf-core-core/surf-core-core-client/src/main/kotlin/dev/slne/surf/core/client/server/SurfServerServiceImpl.kt

@@ -7,8 +7,11 @@ import dev.slne.surf.core.api.common.server.SurfProxyServer
 import dev.slne.surf.core.api.common.server.SurfServer
 import dev.slne.surf.core.api.common.server.state.SurfServerState
 import dev.slne.surf.core.client.ClientCoreInstance
+import dev.slne.surf.core.core.common.redis.request.ExecuteCommandServerRequest
+import dev.slne.surf.core.core.common.redis.request.ShutdownServerRequest
 import dev.slne.surf.core.core.common.server.SurfServerService
 import it.unimi.dsi.fastutil.objects.ObjectSet
+import net.kyori.adventure.text.Component
 import java.util.*
 
 @AutoService(SurfServerService::class)
@@ -55,6 +58,14 @@ class SurfServerServiceImpl : SurfServerService {
         }
     }
 
+    override suspend fun shutdown(commonSurfServer: CommonSurfServer, reason: Component?) =
+        ShutdownServerRequest.createRequest(commonSurfServer, reason).status
+
+    override suspend fun executeCommand(
+        commonSurfServer: CommonSurfServer,
+        command: String
+    ) = ExecuteCommandServerRequest.createRequest(commonSurfServer, command).status
+
     override fun getServerByName(name: String) = servers.find { it.name == name }
     override fun getServerByCategory(category: String) =
         servers.filter { it.category == category }.toObjectSet()

surf-core-core/surf-core-core-common/src/main/kotlin/dev/slne/surf/core/core/common/redis/listener/ExecuteCommandRedisListener.kt

@@ -0,0 +1,21 @@
+package dev.slne.surf.core.core.common.redis.listener
+
+import dev.slne.surf.core.core.common.redis.request.ExecuteCommandServerRequest
+import dev.slne.surf.redis.request.HandleRedisRequest
+import dev.slne.surf.redis.request.RequestContext
+
+object ExecuteCommandRedisListener {
+    @HandleRedisRequest
+    suspend fun handleExecuteCommandRequest(context: RequestContext<ExecuteCommandServerRequest.Request>) {
+        RemoteCommandExecutor.executeCommand(
+            context.request.commonSurfServer,
+            context.request.command
+        )?.let {
+            context.respond(
+                ExecuteCommandServerRequest.Response(
+                    it
+                )
+            )
+        }
+    }
+}

surf-core-core/surf-core-core-common/src/main/kotlin/dev/slne/surf/core/core/common/redis/listener/RemoteCommandExecutor.kt

@@ -0,0 +1,13 @@
+package dev.slne.surf.core.core.common.redis.listener
+
+import dev.slne.surf.api.core.util.requiredService
+import dev.slne.surf.core.api.common.server.CommonSurfServer
+
+private val listener = requiredService<RemoteCommandExecutor>()
+
+interface RemoteCommandExecutor {
+    suspend fun executeCommand(commonSurfServer: CommonSurfServer, command: String): Boolean?
+
+    companion object :
+        RemoteCommandExecutor by listener
+}

surf-core-core/surf-core-core-common/src/main/kotlin/dev/slne/surf/core/core/common/redis/listener/ServerShutdownHandler.kt

@@ -0,0 +1,13 @@
+package dev.slne.surf.core.core.common.redis.listener
+
+import dev.slne.surf.api.core.util.requiredService
+import dev.slne.surf.core.api.common.server.CommonSurfServer
+import net.kyori.adventure.text.Component
+
+private val listener = requiredService<ServerShutdownHandler>()
+
+interface ServerShutdownHandler {
+    fun shutdown(commonSurfServer: CommonSurfServer, reason: Component?): Boolean?
+
+    companion object : ServerShutdownHandler by listener
+}

surf-core-core/surf-core-core-common/src/main/kotlin/dev/slne/surf/core/core/common/redis/listener/ShutdownServerRedisListener.kt

@@ -0,0 +1,22 @@
+package dev.slne.surf.core.core.common.redis.listener
+
+import dev.slne.surf.core.core.common.redis.request.ShutdownServerRequest
+import dev.slne.surf.redis.request.HandleRedisRequest
+import dev.slne.surf.redis.request.RequestContext
+
+object ShutdownServerRedisListener {
+    @HandleRedisRequest
+    fun handleShutdownRequest(context: RequestContext<ShutdownServerRequest.Request>) {
+        ServerShutdownHandler.shutdown(
+            context.request.commonSurfServer,
+            context.request.reason
+        )?.let {
+            context.respond(
+                ShutdownServerRequest.Response(
+                    it
+                )
+            )
+        }
+
+    }
+}

surf-core-core/surf-core-core-common/src/main/kotlin/dev/slne/surf/core/core/common/redis/request/ExecuteCommandServerRequest.kt

@@ -0,0 +1,29 @@
+package dev.slne.surf.core.core.common.redis.request
+
+import dev.slne.surf.core.api.common.server.CommonSurfServer
+import dev.slne.surf.core.core.CoreInstance
+import dev.slne.surf.redis.request.RedisRequest
+import dev.slne.surf.redis.request.RedisResponse
+import kotlinx.serialization.Serializable
+import kotlin.time.Duration.Companion.seconds
+
+object ExecuteCommandServerRequest {
+    @Serializable
+    data class Request(
+        val commonSurfServer: CommonSurfServer,
+        val command: String
+    ) : RedisRequest()
+
+    @Serializable
+    data class Response(
+        val status: Boolean
+    ) : RedisResponse()
+
+    suspend fun createRequest(commonSurfServer: CommonSurfServer, command: String) =
+        runCatching {
+            CoreInstance.redisApi.sendRequest<Response>(
+                Request(commonSurfServer, command),
+                10.seconds.inWholeMilliseconds
+            )
+        }.getOrNull() ?: Response(false)
+}

surf-core-core/surf-core-core-common/src/main/kotlin/dev/slne/surf/core/core/common/redis/request/ShutdownServerRequest.kt

@@ -0,0 +1,31 @@
+package dev.slne.surf.core.core.common.redis.request
+
+import dev.slne.surf.api.core.serializer.adventure.component.SerializableComponent
+import dev.slne.surf.core.api.common.server.CommonSurfServer
+import dev.slne.surf.core.core.CoreInstance
+import dev.slne.surf.redis.request.RedisRequest
+import dev.slne.surf.redis.request.RedisResponse
+import kotlinx.serialization.Serializable
+import net.kyori.adventure.text.Component
+import kotlin.time.Duration.Companion.seconds
+
+object ShutdownServerRequest {
+    @Serializable
+    data class Request(
+        val commonSurfServer: CommonSurfServer,
+        val reason: SerializableComponent?
+    ) : RedisRequest()
+
+    @Serializable
+    data class Response(
+        val status: Boolean
+    ) : RedisResponse()
+
+    suspend fun createRequest(commonSurfServer: CommonSurfServer, reason: Component?) =
+        runCatching {
+            CoreInstance.redisApi.sendRequest<Response>(
+                Request(commonSurfServer, reason),
+                10.seconds.inWholeMilliseconds
+            )
+        }.getOrNull() ?: Response(false)
+}

surf-core-core/surf-core-core-common/src/main/kotlin/dev/slne/surf/core/core/common/server/SurfServerService.kt

@@ -6,6 +6,7 @@ import dev.slne.surf.core.api.common.server.SurfProxyServer
 import dev.slne.surf.core.api.common.server.SurfServer
 import dev.slne.surf.core.api.common.server.state.SurfServerState
 import it.unimi.dsi.fastutil.objects.ObjectSet
+import net.kyori.adventure.text.Component
 import org.jetbrains.annotations.UnmodifiableView
 import java.util.*
 
@@ -19,6 +20,9 @@ interface SurfServerService {
     fun removeServer(server: CommonSurfServer)
     fun changeState(commonSurfServer: CommonSurfServer, state: SurfServerState)
 
+    suspend fun shutdown(commonSurfServer: CommonSurfServer, reason: Component?): Boolean
+    suspend fun executeCommand(commonSurfServer: CommonSurfServer, command: String): Boolean
+
     fun getServerByName(name: String): SurfServer?
     fun getServerByUuid(uuid: UUID): CommonSurfServer?
     fun getServerByCategory(category: String): ObjectSet<SurfServer>

surf-core-microservice/src/main/kotlin/dev/slne/surf/core/microservice/CoreMicroservice.kt

@@ -1,10 +1,7 @@
 package dev.slne.surf.core.microservice
 
 import com.google.auto.service.AutoService
-import dev.slne.surf.core.microservice.database.tables.SurfPlayerIpAddressHistoriesTable
-import dev.slne.surf.core.microservice.database.tables.SurfPlayerNameHistoriesTable
-import dev.slne.surf.core.microservice.database.tables.SurfPlayerTexturesHistoriesTable
-import dev.slne.surf.core.microservice.database.tables.SurfPlayersTable
+import dev.slne.surf.core.microservice.database.tables.*
 import dev.slne.surf.core.microservice.rabbit.*
 import dev.slne.surf.database.DatabaseApi
 import dev.slne.surf.database.libs.org.jetbrains.exposed.v1.r2dbc.SchemaUtils
@@ -25,7 +22,8 @@ class CoreMicroservice : Microservice() {
                 SurfPlayerIpAddressHistoriesTable,
                 SurfPlayerNameHistoriesTable,
                 SurfPlayersTable,
-                SurfPlayerTexturesHistoriesTable
+                SurfPlayerTexturesHistoriesTable,
+                SurfPlayerErrorsTable
             )
         }
 

surf-core-microservice/src/main/kotlin/dev/slne/surf/core/microservice/rabbit/SurfPlayerErrorHandler.kt

@@ -1,19 +1,24 @@
 package dev.slne.surf.core.microservice.rabbit
 
 import dev.slne.surf.core.core.common.rabbit.packet.player.error.SaveSurfPlayerErrorRequestPacket
+import dev.slne.surf.core.core.common.rabbit.packet.player.error.SingleSurfPlayerErrorResponsePacket
 import dev.slne.surf.core.microservice.database.repository.SurfPlayerErrorRepository
 import dev.slne.surf.rabbitmq.api.handler.RabbitHandler
 import kotlinx.coroutines.launch
 
 object SurfPlayerErrorHandler {
     @RabbitHandler
     fun handleSavePlayerError(packet: SaveSurfPlayerErrorRequestPacket) = packet.launch {
-        SurfPlayerErrorRepository.saveError(
-            playerUuid = packet.playerUuid,
-            occurredOn = packet.occurredOn,
-            occurredAt = packet.occurredAt,
-            staffMessage = packet.staffMessage,
-            errorCode = packet.errorCode
+        packet.respond(
+            SingleSurfPlayerErrorResponsePacket(
+                SurfPlayerErrorRepository.saveError(
+                    playerUuid = packet.playerUuid,
+                    occurredOn = packet.occurredOn,
+                    occurredAt = packet.occurredAt,
+                    staffMessage = packet.staffMessage,
+                    errorCode = packet.errorCode
+                )
+            )
         )
     }
 }