add config

Author: PssbleTrngle

build.gradle.kts

@@ -42,18 +42,6 @@ dependencies {
     implementation("thedarkcolour:kfflib:${kotlin_forge_version}")
 
     //add("minecraftLibrary", "org.jetbrains.kotlin:kotlin-reflect:${kotlin.coreLibrariesVersion}")
-
-    /*
-    "minecraftLibrary"("com.expediagroup:graphql-kotlin-ktor-client:$graphql_client_version") {
-        exclude(group = "org.jetbrains.kotlinx")
-        exclude(group = "org.jetbrains.kotlin", module = "kotlin-stdlib")
-        exclude(group = "org.jetbrains")
-    }
-
-    "jarJar"("com.expediagroup:graphql-kotlin-ktor-client:$graphql_client_version") {
-        jarJar.pin(this, "[${graphql_client_version},)")
-    }
-     */
 }
 
 graphql {

gradle.properties

@@ -2,6 +2,7 @@ kotlin.code.style=official
 org.gradle.jvmargs=-Xmx2G
 org.gradle.daemon=false
 
+java_version=17
 mc_version=1.20.1
 forge_version=47.1.3
 

src/main/kotlin/com/possible_triangle/atheneum_connector/AtheneumConnector.kt

@@ -1,16 +1,21 @@
 package com.possible_triangle.atheneum_connector
 
+import com.possible_triangle.atheneum_connector.messages.ServerStatus
+import com.possible_triangle.atheneum_connector.messages.ServerStatusMessage
 import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.JsonBuilder
-import net.minecraftforge.api.distmarker.Dist
+import net.minecraftforge.event.server.ServerStartedEvent
 import net.minecraftforge.event.server.ServerStoppingEvent
-import net.minecraftforge.fml.DistExecutor
+import net.minecraftforge.eventbus.api.SubscribeEvent
 import net.minecraftforge.fml.common.Mod
+import net.minecraftforge.fml.common.Mod.EventBusSubscriber
+import net.minecraftforge.fml.event.lifecycle.FMLDedicatedServerSetupEvent
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
 import thedarkcolour.kotlinforforge.forge.FORGE_BUS
 
 @Mod("atheneum_connector")
+@EventBusSubscriber(bus = EventBusSubscriber.Bus.MOD)
 object AtheneumConnector {
 
     fun JsonBuilder.configure() {
@@ -22,16 +27,20 @@ object AtheneumConnector {
     val LOG: Logger = LoggerFactory.getLogger("Atheneum Connector")
 
     init {
-        DistExecutor.unsafeRunWhenOn(Dist.DEDICATED_SERVER) {
-            Runnable(::serverInit)
-        }
+        Config.register()
     }
 
-    private fun serverInit() {
-        RabbitMQ.connect("amqp://guest:guest@localhost:5672/")
+    @SubscribeEvent
+    fun serverInit(event: FMLDedicatedServerSetupEvent) {
+        RabbitMQ.connect()
         LocationCache.initialize()
 
+        FORGE_BUS.addListener { _: ServerStartedEvent ->
+            RabbitMQ.publish(ServerStatusMessage(ServerStatus.STARTED))
+        }
+
         FORGE_BUS.addListener { _: ServerStoppingEvent ->
+            RabbitMQ.publish(ServerStatusMessage(ServerStatus.STOPPED))
             RabbitMQ.close()
         }
     }

src/main/kotlin/com/possible_triangle/atheneum_connector/Config.kt

@@ -0,0 +1,49 @@
+package com.possible_triangle.atheneum_connector
+
+import net.minecraftforge.common.ForgeConfigSpec
+import net.minecraftforge.fml.config.ModConfig
+import thedarkcolour.kotlinforforge.forge.LOADING_CONTEXT
+import java.net.URI
+import java.net.URL
+
+object Config {
+
+    private val SERVER_SPEC: ForgeConfigSpec
+    val SERVER: Server
+
+    init {
+        with(ForgeConfigSpec.Builder().configure { Server(it) }) {
+            SERVER = left
+            SERVER_SPEC = right
+        }
+    }
+
+    fun register() {
+        LOADING_CONTEXT.registerConfig(ModConfig.Type.COMMON, SERVER_SPEC)
+    }
+
+    class Server internal constructor(builder: ForgeConfigSpec.Builder) {
+
+        init {
+            builder.push("rabbitmq")
+        }
+
+        private val rabbitmqUser = builder.define("user", "guest")
+        private val rabbitmqPass = builder.define("password", "guest")
+        private val rabbitmqHost = builder.define("host", "localhost")
+        private val rabbitmqPort = builder.define("port", "5672")
+
+        val rabbitMQUrl
+            get() = "amqp://${rabbitmqUser.get()}:${rabbitmqPass.get()}@${rabbitmqHost.get()}:${rabbitmqPort.get()}/"
+
+        init {
+            builder.pop()
+            builder.push("grapql")
+        }
+
+        private val _graphqlUrl = builder.define("url", "http://localhost:8080/api/graphql")
+        val graphqlUrl: URL get() = URI(_graphqlUrl.get()).toURL()
+
+    }
+
+}

src/main/kotlin/com/possible_triangle/atheneum_connector/GraphQL.kt

@@ -4,12 +4,11 @@ import com.expediagroup.graphql.client.ktor.GraphQLKtorClient
 import com.expediagroup.graphql.client.serialization.GraphQLClientKotlinxSerializer
 import com.expediagroup.graphql.client.types.GraphQLClientRequest
 import com.possible_triangle.atheneum_connector.AtheneumConnector.configure
-import java.net.URL
 
 object GraphQL {
 
     private val client = GraphQLKtorClient(
-        URL("http://localhost:8080/api/graphql"),
+        Config.SERVER.graphqlUrl,
         serializer = GraphQLClientKotlinxSerializer { configure() }
     )
 

src/main/kotlin/com/possible_triangle/atheneum_connector/RabbitMQ.kt

@@ -1,7 +1,9 @@
 package com.possible_triangle.atheneum_connector
 
-import com.rabbitmq.client.Channel
-import com.rabbitmq.client.ConnectionFactory
+import com.possible_triangle.atheneum_connector.messages.ServerStatus
+import com.possible_triangle.atheneum_connector.messages.ServerStatusMessage
+import com.rabbitmq.client.*
+import io.ktor.util.logging.*
 import kotlinx.serialization.InternalSerializationApi
 import kotlinx.serialization.serializer
 import net.minecraftforge.fml.ModList
@@ -11,18 +13,26 @@ import kotlin.reflect.KParameter
 import kotlin.reflect.full.hasAnnotation
 import kotlin.reflect.full.memberFunctions
 
-object RabbitMQ {
+object RabbitMQ : RecoveryListener, ShutdownListener {
 
     private const val EXCHANGE_KEY = "exchange"
 
     private lateinit var channel: Channel
 
-    fun connect(url: String) {
+    fun connect() {
         AtheneumConnector.LOG.info("Connecting to RabbitMQ")
 
-        val connection = ConnectionFactory().newConnection(url)
+        val connection = ConnectionFactory().newConnection(Config.SERVER.rabbitMQUrl)
+
+        connection.addShutdownListener(this)
+
+        if (connection is Recoverable) {
+            connection.addRecoveryListener(this)
+        }
 
         channel = connection.createChannel()
+        declareExchanges()
+
         val queue = channel.queueDeclare().queue
 
         val consumers = hashMapOf<String, MutableList<(ByteArray) -> Unit>>()
@@ -39,11 +49,38 @@ object RabbitMQ {
         }, { _ -> })
     }
 
-    fun close() {
+    private fun declareExchanges() {
+        channel.exchangeDeclare(EXCHANGE_KEY, "direct")
+    }
+
+    override fun handleRecovery(recoverable: Recoverable) {
+        AtheneumConnector.LOG.warn("RabbitMQ has recovered")
+        declareExchanges()
+        publish(ServerStatusMessage(ServerStatus.RECOVERED))
+    }
+
+    override fun handleRecoveryStarted(recoverable: Recoverable) {
+        AtheneumConnector.LOG.warn("Trying to reconnect to RabbitMQ...")
+    }
+
+    override fun shutdownCompleted(exception: ShutdownSignalException) {
+        AtheneumConnector.LOG.warn("RabbitMQ has shutdown, reconnecting... ({})", exception.message)
+    }
+
+    private fun tryCatching(action: () -> Unit) {
+        try {
+            action()
+        } catch (ex: ShutdownSignalException) {
+            AtheneumConnector.LOG.error("Encountered exception when publishing to RabbitMQ")
+            AtheneumConnector.LOG.error(ex)
+        }
+    }
+
+    fun close() = tryCatching {
         channel.connection.close()
     }
 
-    fun publish(routingKey: String, bytes: ByteArray) {
+    fun publish(routingKey: String, bytes: ByteArray) = tryCatching {
         channel.basicPublish(EXCHANGE_KEY, routingKey, null, bytes)
     }
 
@@ -63,9 +100,7 @@ object RabbitMQ {
                     val topic = Class.forName(messageType.toString()).simpleName
                     val deserializer = serializer(messageType)
 
-                    if (method.parameters.size != 2) {
-                        throw IllegalArgumentException("@SubscribeMessage handlers may only accept one parameter, the message itself")
-                    }
+                    require(method.parameters.size == 2) { "@SubscribeMessage handlers may only accept one parameter, the message itself" }
 
                     consume(topic) {
                         val message = AtheneumConnector.JSON.decodeFromString(deserializer, it.decodeToString())