Implement socket server to remotely control processor

object-Object · object-Object · commit 4f369d7adb8e · 2025-06-04T01:57:56.000-04:00
diff --git a/mod/assets/scripts/main.js b/mod/assets/scripts/main.js
@@ -53,6 +53,20 @@ global.override.block(LogicBlock, {
                 })
                 .tooltip("Dump mlogv32 RAM")
                 .size(40);
+
+            buttons
+                .button(Icon.host, Styles.clearTogglei, () => {
+                    if (processor.isServerRunning()) {
+                        processor.stopServer();
+                        Vars.ui.hudfrag.showToast("Stopped socket server.");
+                    } else {
+                        processor.startServer("localhost", 5000);
+                        Vars.ui.hudfrag.showToast("Started socket server at localhost:5000.");
+                    }
+                })
+                .tooltip("Start/stop mlogv32 socket server")
+                .checked(processor.isServerRunning())
+                .size(40);
         }
     },
 });
diff --git a/mod/build.gradle.kts b/mod/build.gradle.kts
@@ -3,7 +3,8 @@ import com.xpdustry.toxopid.spec.ModMetadata
 import com.xpdustry.toxopid.spec.ModPlatform
 
 plugins {
-    alias(libs.plugins.kotlin)
+    alias(libs.plugins.kotlin.jvm)
+    alias(libs.plugins.kotlin.serialization)
     alias(libs.plugins.indra.common)
     alias(libs.plugins.shadow)
     alias(libs.plugins.toxopid)
@@ -28,7 +29,10 @@ dependencies {
     compileOnly(toxopid.dependencies.arcCore)
     compileOnly(toxopid.dependencies.mindustryCore)
 
-    implementation(kotlin("stdlib-jdk8"))
+    implementation(libs.kotlin.stdlib)
+    implementation(libs.kotlinx.coroutines)
+    implementation(libs.kotlinx.serialization.json)
+    implementation(libs.ktor.network)
 }
 
 indra {
diff --git a/mod/gradle/libs.versions.toml b/mod/gradle/libs.versions.toml
@@ -1,11 +1,21 @@
 [versions]
 kotlin = "2.1.20"
+kotlinx-coroutines = "1.10.2"
+kotlinx-serialization-json = "1.8.1"
+ktor = "3.1.3"
 indra = "3.1.3"
 shadow = "8.3.6"
 toxopid = "4.1.2"
 
+[libraries]
+kotlin-stdlib = { module = "org.jetbrains.kotlin:kotlin-stdlib-jdk8", version.ref = "kotlin" }
+kotlinx-coroutines = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlinx-coroutines" }
+kotlinx-serialization-json = { module = "org.jetbrains.kotlinx:kotlinx-serialization-json", version.ref = "kotlinx-serialization-json" }
+ktor-network = { module = "io.ktor:ktor-network", version.ref = "ktor" }
+
 [plugins]
-kotlin = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
+kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
+kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }
 indra-common = { id = "net.kyori.indra", version.ref = "indra" }
 shadow = { id = "com.gradleup.shadow", version.ref = "shadow" }
 toxopid = { id = "com.xpdustry.toxopid", version.ref = "toxopid" }
diff --git a/mod/src/main/kotlin/gay/object/mlogv32/Mlogv32UtilsMod.kt b/mod/src/main/kotlin/gay/object/mlogv32/Mlogv32UtilsMod.kt
@@ -1,14 +1,25 @@
 package gay.`object`.mlogv32
 
 import arc.Core
+import arc.Events
 import arc.util.CommandHandler
 import arc.util.Log
 import mindustry.Vars
+import mindustry.core.GameState
+import mindustry.game.EventType
 import mindustry.mod.Mod
 import mindustry.world.blocks.logic.LogicBlock.LogicBuild
 
 @Suppress("unused")
 class Mlogv32UtilsMod : Mod() {
+    override fun init() {
+        Events.on(EventType.StateChangeEvent::class.java) { event ->
+            if (event.to == GameState.State.menu) {
+                ProcessorAccess.stopServer()
+            }
+        }
+    }
+
     override fun registerServerCommands(handler: CommandHandler) {
         handler.register(
             "mlogv32.flash",
diff --git a/mod/src/main/kotlin/gay/object/mlogv32/ProcessorAccess.kt b/mod/src/main/kotlin/gay/object/mlogv32/ProcessorAccess.kt
@@ -1,13 +1,25 @@
 package gay.`object`.mlogv32
 
+import arc.Core
 import arc.files.Fi
-import arc.util.Timer
+import arc.util.Log
+import io.ktor.network.selector.*
+import io.ktor.network.sockets.*
+import io.ktor.utils.io.*
+import kotlinx.coroutines.*
+import kotlinx.coroutines.CancellationException
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.Json
 import mindustry.Vars
 import mindustry.gen.Building
 import mindustry.world.blocks.logic.LogicBlock.LogicBuild
 import mindustry.world.blocks.logic.SwitchBlock.SwitchBuild
+import kotlin.concurrent.thread
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
 
-data class ProcessorAccess(
+class ProcessorAccess(
     val build: LogicBuild,
     val memoryX: Int,
     val memoryY: Int,
@@ -70,6 +82,41 @@ data class ProcessorAccess(
         writes.close()
     }
 
+    fun isServerRunning() = serverThread != null && serverJob != null && serverBuildId == build.id
+
+    fun startServer(hostname: String, port: Int) {
+        if (serverThread != null) stopServer()
+
+        Log.info("Starting ProcessorAccess socket server at $hostname:$port for building ${build.id}...")
+
+        serverBuildId = build.id
+        serverThread = thread(isDaemon = true) {
+            runBlocking {
+                serverJob = launch {
+                    try {
+                        val selector = SelectorManager(Dispatchers.IO)
+                        aSocket(selector).tcp().bind(hostname, port).use { serverSocket ->
+                            runServer(serverSocket)
+                        }
+                    } catch (e: Exception) {
+                        Log.err("ProcessorAccess server failed", e)
+                    }
+                }
+            }
+
+            // cleanup
+            serverJob = null
+            serverThread = null
+            serverBuildId = null
+
+            Log.info("ProcessorAccess thread exiting.")
+        }
+    }
+
+    fun stopServer() {
+        ProcessorAccess.stopServer()
+    }
+
     private fun ramWordsSequence(startAddress: Int = 0) = sequence {
         require(startAddress in ramStart..<ramEnd) { "Start address must be within RAM." }
         require(startAddress.mod(4) == 0) { "Start address must be aligned to 4 bytes." }
@@ -133,7 +180,40 @@ data class ProcessorAccess(
         return proc
     }
 
+    private suspend fun runServer(serverSocket: ServerSocket) {
+        while (true) {
+            Log.info("Waiting for clients...")
+            serverSocket.accept().use { client ->
+                Log.info("Client connected!")
+                val rx = client.openReadChannel()
+                val tx = client.openWriteChannel(true)
+                while (true) {
+                    val response: Response = try {
+                        val line = rx.readUTF8Line() ?: break
+                        Log.info("Got request: $line")
+                        val request = Json.decodeFromString<Request>(line)
+                        request.handle(this)
+                    } catch (e: CancellationException) {
+                        throw e
+                    } catch (e: IllegalArgumentException) {
+                        Log.err("Bad request", e)
+                        ErrorResponse.badRequest(e)
+                    } catch (e: Exception) {
+                        Log.err("Request failed", e)
+                        ErrorResponse(e)
+                    }
+                    tx.writeStringUtf8(Json.encodeToString(response) + "\n")
+                }
+                Log.info("Client disconnected.")
+            }
+        }
+    }
+
     companion object {
+        private var serverThread: Thread? = null
+        private var serverJob: Job? = null
+        private var serverBuildId: Int? = null
+
         fun of(build: LogicBuild): ProcessorAccess? {
             return ProcessorAccess(
                 build,
@@ -150,6 +230,14 @@ data class ProcessorAccess(
                 resetSwitch = buildVar<SwitchBuild>(build, "RESET_SWITCH") ?: return null,
             )
         }
+
+        fun stopServer() {
+            if (serverThread == null) return
+            Log.info("Stopping ProcessorAccess server for building $serverBuildId...")
+            serverJob?.cancel()
+            serverThread?.join()
+            Log.info("Stopped ProcessorAccess server.")
+        }
     }
 }
 
@@ -171,3 +259,91 @@ private fun positiveIntVar(build: LogicBuild, name: String): Int? =
 
 private inline fun <reified T : Building> buildVar(build: LogicBuild, name: String): T? =
     build.executor.optionalVar(name)?.obj() as? T
+
+@Serializable
+sealed class Request {
+    abstract suspend fun handle(processor: ProcessorAccess): Response
+
+    protected suspend fun <T> runOnMainThread(block: () -> T): T {
+        return suspendCancellableCoroutine { continuation ->
+            Core.app.post {
+                try {
+                    continuation.resume(block())
+                } catch (e: Exception) {
+                    continuation.resumeWithException(e)
+                }
+            }
+        }
+    }
+}
+
+@Serializable
+@SerialName("flash")
+data class FlashRequest(val path: String) : Request() {
+    override suspend fun handle(processor: ProcessorAccess) = runOnMainThread {
+        val file = Core.files.absolute(path)
+        require(file.exists()) { "File not found." }
+
+        val bytes = processor.flashRom(file)
+        SuccessResponse("Successfully flashed $bytes bytes from $file to ROM.")
+    }
+}
+
+@Serializable
+@SerialName("dump")
+data class DumpRequest(val path: String) : Request() {
+    override suspend fun handle(processor: ProcessorAccess) = runOnMainThread {
+        val file = Core.files.absolute(path)
+        file.parent().mkdirs()
+
+        val bytes = processor.dumpRam(file)
+        SuccessResponse("Successfully dumped $bytes bytes from RAM to $file.")
+    }
+}
+
+@Serializable
+@SerialName("start")
+data class StartRequest(val wait: Boolean) : Request() {
+    override suspend fun handle(processor: ProcessorAccess): Response {
+        runOnMainThread {
+            processor.resetSwitch.configure(false)
+        }
+        if (!wait) {
+            return SuccessResponse("Processor started.")
+        }
+
+        while (true) {
+            delay(500)
+            val stopped = runOnMainThread { processor.resetSwitch.enabled }
+            if (stopped) {
+                return SuccessResponse("Processor has halted.")
+            }
+        }
+    }
+}
+
+@Serializable
+@SerialName("stop")
+data object StopRequest : Request() {
+    override suspend fun handle(processor: ProcessorAccess) = runOnMainThread {
+        processor.resetSwitch.configure(true)
+        SuccessResponse("Processor stopped.")
+    }
+}
+
+@Serializable
+sealed class Response
+
+@Serializable
+@SerialName("success")
+data class SuccessResponse(val message: String) : Response()
+
+@Serializable
+@SerialName("error")
+data class ErrorResponse(val message: String) : Response() {
+    constructor(e: Exception) : this("Request failed: $e")
+
+    companion object {
+        fun badRequest(e: IllegalArgumentException) = ErrorResponse("Bad request: $e")
+    }
+}
