feat: implement Redis event serialization, dynamic command support, and enhanced player listing

- Introduced `FasterXmlJsonOps` for efficient JSON operations with `DynamicOps`.
- Added Redis event handling with `RedisEventSerializer` and `RedisEventDeserializer`.
- Implemented `RedisEventDiscovererRegister` and `RedisEventRegistry` for Redis event discovery and registration.
- Extended `AbstractConsoleCommand` with a generic `.execute()` function for dynamic command handling.
- Added support for `list`, `group`, and `server` commands via `ListCommand`.
- Enhanced player listing functionality in `GlistCommandExecutor`.
- Added Cloud group and server argument types for improved command parsing.
- Integrated Redis connection configuration in `ConnectionConfig`.
- Added `CommandExecutionScope` for better coroutine handling in commands.

Author: twisti-dev

gradle/libs.versions.toml

@@ -69,6 +69,7 @@ spring-web = { module = "org.springframework:spring-web" }
 flyway-core = { module = "org.flywaydb:flyway-core" }
 flyway-mysql = { module = "org.flywaydb:flyway-mysql" }
 spring-instrument = { module = "org.springframework:spring-instrument" }
+spring-boot-starter-data-redis-reactive = { module = "org.springframework.boot:spring-boot-starter-data-redis-reactive" }
 kotlin-byte-buf-serializer = { module = "dev.slne.surf:kotlin-byte-buf-serializer", version.ref = "kotlin-byte-buf-serializer" }
 voicechat-api = { module = "de.maxhenkel.voicechat:voicechat-api", version.ref = "voicechat-api" }
 discord-webhooks = { module = "com.github.BinaryWriter:discord-webhooks", version.ref = "discord-webhooks" }

surf-cloud-api/surf-cloud-api-common/src/main/kotlin/dev/slne/surf/cloud/api/common/server/CloudServer.kt

@@ -36,5 +36,6 @@ interface CloudServer : CommonCloudServer {
             CloudServerManager.retrieveServerByName(name) as? CloudServer
 
         fun all() = CloudServerManager.retrieveServers()
+        fun inGroup(group: String) = CloudServerManager.retrieveServerList(group)
     }
 }

surf-cloud-api/surf-cloud-api-common/src/main/kotlin/dev/slne/surf/cloud/api/common/server/CloudServerManager.kt

@@ -42,6 +42,9 @@ interface CloudServerManager {
     fun retrieveServerByName(name: String): CommonCloudServer?
 
     fun retrieveServersInGroup(group: String): ObjectList<out CommonCloudServer>
+    fun retrieveServerList(group: String): ObjectList<CloudServer>
+    fun retrieveProxyList(group: String): ObjectList<ProxyCloudServer>
+
 
     @InternalApi
     fun existsServerGroup(name: String): Boolean

surf-cloud-api/surf-cloud-api-server/src/main/kotlin/dev/slne/surf/cloud/api/server/command/AbstractConsoleCommand.kt

@@ -1,10 +1,12 @@
 package dev.slne.surf.cloud.api.server.command
 
+import com.mojang.brigadier.Command
 import com.mojang.brigadier.CommandDispatcher
 import com.mojang.brigadier.arguments.ArgumentType
 import com.mojang.brigadier.builder.ArgumentBuilder
 import com.mojang.brigadier.builder.LiteralArgumentBuilder
 import com.mojang.brigadier.builder.RequiredArgumentBuilder
+import com.mojang.brigadier.context.CommandContext
 import org.springframework.stereotype.Component
 
 @Component
@@ -14,6 +16,13 @@ annotation class ConsoleCommand
 
 abstract class AbstractConsoleCommand {
     abstract fun register(dispatcher: CommandDispatcher<CommandSource>)
+
+    fun <S, T : ArgumentBuilder<S, T>> ArgumentBuilder<S, T>.execute(run: (ctx: CommandContext<S>) -> Unit): T =
+        executes {
+            run(it)
+            Command.SINGLE_SUCCESS
+        }
+
 }
 
 inline fun <S> AbstractConsoleCommand.literal(

surf-cloud-api/surf-cloud-api-server/src/main/kotlin/dev/slne/surf/cloud/api/server/command/CommandSource.kt

@@ -2,13 +2,16 @@ package dev.slne.surf.cloud.api.server.command
 
 import com.mojang.brigadier.exceptions.CommandExceptionType
 import dev.slne.surf.surfapi.core.api.messages.Colors
+import net.kyori.adventure.audience.Audience
+import net.kyori.adventure.audience.MessageType
+import net.kyori.adventure.identity.Identity
 import net.kyori.adventure.text.Component
 import net.kyori.adventure.text.serializer.ansi.ANSIComponentSerializer
 
 class CommandSource(
     silent: Boolean = false,
     callback: CommandResultCallback = CommandResultCallback.EMPTY
-) : ExecutionCommandSource<CommandSource> {
+) : ExecutionCommandSource<CommandSource>, Audience {
 
     override var callback = callback
         private set
@@ -33,7 +36,7 @@ class CommandSource(
         }
     }
 
-    fun sendMessage(message: Component) {
+    override fun sendMessage(message: Component) {
         if (!silent) {
             println(ANSIComponentSerializer.ansi().serialize(message))
         }
@@ -58,6 +61,12 @@ class CommandSource(
         }
     }
 
+    @Deprecated("Deprecated in Java", level = DeprecationLevel.ERROR)
+    @Suppress("DEPRECATION")
+    override fun sendMessage(source: Identity, message: Component, type: MessageType) {
+        sendMessage(message)
+    }
+
     private fun copy(
         silent: Boolean = this.silent,
         callback: CommandResultCallback = this.callback

surf-cloud-api/surf-cloud-api-server/src/main/kotlin/dev/slne/surf/cloud/api/server/command/argument/CloudGroupArgumentType.kt

@@ -0,0 +1,49 @@
+package dev.slne.surf.cloud.api.server.command.argument
+
+import com.mojang.brigadier.LiteralMessage
+import com.mojang.brigadier.StringReader
+import com.mojang.brigadier.arguments.ArgumentType
+import com.mojang.brigadier.context.CommandContext
+import com.mojang.brigadier.exceptions.DynamicCommandExceptionType
+import com.mojang.brigadier.suggestion.Suggestions
+import com.mojang.brigadier.suggestion.SuggestionsBuilder
+import dev.slne.surf.cloud.api.common.server.CloudServerManager
+import dev.slne.surf.cloud.api.server.command.ArgumentSuggestion
+import java.util.concurrent.CompletableFuture
+
+class CloudGroupArgumentType private constructor(): ArgumentType<String> {
+    companion object {
+        val GROUP_NOT_FOUND =
+            DynamicCommandExceptionType { group -> LiteralMessage("Server group '$group' not found or no servers in this group are online!") }
+
+        fun group(): CloudGroupArgumentType {
+            return CloudGroupArgumentType()
+        }
+
+        fun getGroup(context: CommandContext<*>, name: String): String {
+            return context.getArgument(name, String::class.java)
+        }
+    }
+
+    override fun parse(reader: StringReader): String {
+        val group = reader.readUnquotedString()
+
+        if (!CloudServerManager.existsServerGroup(group)) {
+            throw GROUP_NOT_FOUND.create(group)
+        }
+
+        return group
+    }
+
+    override fun <S : Any> listSuggestions(
+        context: CommandContext<S>,
+        builder: SuggestionsBuilder
+    ): CompletableFuture<Suggestions> {
+        val groups = CloudServerManager.retrieveAllServers()
+            .filter { it.group.isNotEmpty() }
+            .map { it.group }
+            .distinct()
+
+        return ArgumentSuggestion.suggestStrings(groups, builder)
+    }
+}

surf-cloud-api/surf-cloud-api-server/src/main/kotlin/dev/slne/surf/cloud/api/server/command/argument/CloudServerArgumentType.kt

@@ -0,0 +1,46 @@
+package dev.slne.surf.cloud.api.server.command.argument
+
+import com.mojang.brigadier.LiteralMessage
+import com.mojang.brigadier.StringReader
+import com.mojang.brigadier.arguments.ArgumentType
+import com.mojang.brigadier.context.CommandContext
+import com.mojang.brigadier.exceptions.DynamicCommandExceptionType
+import com.mojang.brigadier.suggestion.Suggestions
+import com.mojang.brigadier.suggestion.SuggestionsBuilder
+import dev.slne.surf.cloud.api.common.server.CloudServer
+import dev.slne.surf.cloud.api.server.command.ArgumentSuggestion
+import java.util.concurrent.CompletableFuture
+
+class CloudServerArgumentType private constructor() : ArgumentType<CloudServer> {
+    companion object {
+        val SERVER_NOT_FOUND =
+            DynamicCommandExceptionType { group -> LiteralMessage("Server '$group' not found!") }
+
+        fun server(): CloudServerArgumentType {
+            return CloudServerArgumentType()
+        }
+
+        fun getServer(context: CommandContext<*>, name: String): CloudServer {
+            return context.getArgument(name, CloudServer::class.java)
+        }
+    }
+
+    override fun parse(reader: StringReader): CloudServer {
+        val serverName = reader.readUnquotedString()
+        val server = CloudServer[serverName]
+
+        if (server == null) {
+            throw SERVER_NOT_FOUND.create(serverName)
+        }
+
+        return server
+    }
+
+    override fun <S : Any> listSuggestions(
+        context: CommandContext<S>,
+        builder: SuggestionsBuilder
+    ): CompletableFuture<Suggestions> {
+        val serverNames = CloudServer.all().map(CloudServer::name)
+        return ArgumentSuggestion.suggestStrings(serverNames, builder)
+    }
+}

surf-cloud-api/surf-cloud-api-server/src/main/kotlin/dev/slne/surf/cloud/api/server/redis/KotlinJsonSerializationCodec.kt

@@ -0,0 +1,47 @@
+package dev.slne.surf.cloud.api.server.redis
+
+import com.mojang.datafixers.util.Pair
+import com.mojang.serialization.Codec
+import com.mojang.serialization.DataResult
+import com.mojang.serialization.DynamicOps
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.SerializationException
+import kotlinx.serialization.json.Json
+
+class KotlinJsonSerializationCodec<A>(
+    private val serializer: KSerializer<A>,
+    private val json: Json
+) : Codec<A> {
+    private val codec = Codec.STRING.flatXmap<A>({ json ->
+        try {
+            DataResult.success(this.json.decodeFromString(serializer, json))
+        } catch (e: SerializationException) {
+            DataResult.error { "Unable to deserialize JSON: $json: ${e.message}" }
+        } catch (e: IllegalArgumentException) {
+            DataResult.error { "Cannot represent JSON as object: $json: ${e.message}" }
+        }
+
+    }, { obj ->
+        try {
+            DataResult.success(json.encodeToString(serializer, obj))
+        } catch (e: SerializationException) {
+            DataResult.error { "Unable to serialize object: $obj: ${e.message}" }
+        }
+    })
+
+
+    override fun <T : Any> encode(
+        input: A,
+        ops: DynamicOps<T>,
+        prefix: T
+    ): DataResult<T> {
+        return codec.encode(input, ops, prefix)
+    }
+
+    override fun <T : Any> decode(
+        ops: DynamicOps<T>,
+        input: T
+    ): DataResult<Pair<A, T>> {
+        return codec.decode(ops, input)
+    }
+}

surf-cloud-api/surf-cloud-api-server/src/main/kotlin/dev/slne/surf/cloud/api/server/redis/RedisCodec.kt

@@ -0,0 +1,5 @@
+package dev.slne.surf.cloud.api.server.redis
+
+@Target(AnnotationTarget.PROPERTY)
+@Retention(AnnotationRetention.RUNTIME)
+annotation class RedisCodec

surf-cloud-api/surf-cloud-api-server/src/main/kotlin/dev/slne/surf/cloud/api/server/redis/RedisEvent.kt

@@ -0,0 +1,19 @@
+package dev.slne.surf.cloud.api.server.redis
+
+import dev.slne.surf.cloud.api.common.util.findAnnotation
+
+abstract class RedisEvent {
+    @delegate:Transient
+    val meta by lazy {
+        this::class.findAnnotation<RedisEventMeta>()
+            ?: error("@RedisEventMeta annotation is missing on ${this::class.qualifiedName}")
+    }
+
+    fun publish() {
+        RedisEventBus.publish(this)
+    }
+
+    override fun toString(): String {
+        return "RedisEvent(meta=$meta)"
+    }
+}