WIP

rpc/src/commonMain/kotlin/baaahs/rpc/RpcClientId.kt

@@ -0,0 +1,10 @@
+package baaahs.rpc
+
+import kotlin.coroutines.CoroutineContext
+
+public class RpcClientId(public val id: String) : CoroutineContext.Element {
+    override val key: CoroutineContext.Key<*>
+        get() = Key
+
+    public companion object Key : CoroutineContext.Key<RpcClientId>
+}

rpc/src/commonMain/kotlin/baaahs/rpc/RpcImpl.kt

@@ -3,6 +3,7 @@ package baaahs.rpc
 import kotlinx.serialization.KSerializer
 import kotlinx.serialization.json.Json
 import kotlinx.serialization.modules.SerializersModule
+import kotlin.coroutines.coroutineContext
 
 public class CommandPort<C, R>(
     public val name: String,
@@ -34,7 +35,12 @@ public interface RpcCommandChannel<C, R> {
     public suspend fun send(command: C): R
 }
 
-public interface RpcClient : RpcEndpoint, RpcCommandRecipient
+public interface RpcClient : RpcEndpoint, RpcCommandRecipient {
+    public companion object {
+        public suspend fun id(): String =
+            coroutineContext[RpcClientId]?.id ?: error("not in RPC call")
+    }
+}
 
 public interface RpcServer : RpcEndpoint
 

src/commonMain/kotlin/baaahs/PubSub.kt

@@ -12,6 +12,7 @@ import kotlinx.serialization.builtins.ListSerializer
 import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.JsonElement
 import kotlinx.serialization.modules.SerializersModule
+import kotlin.coroutines.EmptyCoroutineContext
 import kotlin.js.JsName
 import kotlin.jvm.Synchronized
 import kotlin.properties.ReadWriteProperty
@@ -33,7 +34,8 @@ abstract class PubSub {
         val logger = Logger<PubSub>()
     }
 
-    open class Origin(val id: String) {
+    open class Origin(val id: String, clientId: String?) {
+        val clientId = clientId?.let { RpcClientId(it) }
         override fun toString(): String = "Origin($id)"
     }
 
@@ -212,7 +214,9 @@ abstract class PubSub {
             val name = commandPort.name
             if (hasServerChannel(name)) error("Command channel $name already exists.")
             putServerChannel(name,
-                ServerCommandChannel(commandPort) { command -> callback(command) })
+                ServerCommandChannel(commandPort) { command ->
+                    callback(command)
+                })
         }
 
         class ServerCommandChannel<C, R>(
@@ -225,7 +229,7 @@ abstract class PubSub {
                 fromConnection: Connection,
                 handlerScope: CoroutineScope
             ) {
-                handlerScope.launch {
+                handlerScope.launch(fromConnection.clientId ?: EmptyCoroutineContext) {
                     try {
                         val command = commandPort.fromJson(commandJson)
                         val reply = callback.invoke(command)
@@ -271,7 +275,7 @@ abstract class PubSub {
         private val topics: Topics,
         private val commandChannels: CommandChannels,
         private val handlerScope: CoroutineScope
-    ) : Origin("connection $name"), Network.WebSocketListener {
+    ) : Origin("connection $name", name), Network.WebSocketListener {
         var isConnected: Boolean = false
         var everConnected: Boolean = false
 
@@ -523,14 +527,19 @@ abstract class PubSub {
         httpServer: Network.HttpServer,
         private val handlerScope: CoroutineScope
     ) : Endpoint(), IServer, RpcEndpoint {
-        private val publisher = Origin("Server-side publisher")
+        private val publisher = Origin("Server-side publisher", null)
         private val topics: Topics = Topics()
         override val commandChannels: CommandChannels = CommandChannels()
         private val connectionListeners: MutableList<(ConnectionFromClient) -> Unit> = mutableListOf()
+        private val connectionCountByHost = hashMapOf<String, Int>()
 
         init {
             httpServer.listenWebSocket("/sm/ws") { incomingConnection ->
-                val name = "server ${incomingConnection.toAddress} to ${incomingConnection.fromAddress}"
+                val fromAddress = incomingConnection.fromAddress.toString()
+                val number = connectionCountByHost[fromAddress] ?: 0
+                connectionCountByHost[fromAddress] = number + 1
+
+                val name = "${incomingConnection.fromAddress}${if (number > 0) "-$number" else ""}"
                 ConnectionFromClient(name, topics, commandChannels, handlerScope)
                     .also { connection -> connectionListeners.forEach { it.invoke(connection) } }
             }
@@ -664,7 +673,7 @@ abstract class PubSub {
 
         @JsName("subscribe")
         fun <T> subscribe(topic: Topic<T>, onUpdateFn: (T) -> Unit): Channel<T> {
-            val subscriber = Origin("Client-side subscriber at ${link.myAddress}")
+            val subscriber = Origin("Client-side subscriber at ${link.myAddress}", link.myAddress.toString())
 
             val topicName = topic.name
 

src/commonMain/kotlin/baaahs/client/ClientStageManager.kt

@@ -2,7 +2,6 @@ package baaahs.client
 
 import baaahs.*
 import baaahs.gl.Toolchain
-import baaahs.midi.MidiDevices
 import baaahs.scene.OpenScene
 import baaahs.scene.SceneProvider
 import baaahs.show.Feed
@@ -22,7 +21,6 @@ class ClientStageManager(
     toolchain: Toolchain,
     private val pubSub: PubSub.Client,
     sceneProvider: SceneProvider,
-    private val midiDevices: MidiDevices,
     private val coroutineScope: CoroutineScope = GlobalScope
 ) : BaseShowPlayer(toolchain, SceneProviderWithFallback(sceneProvider)) {
     private val gadgets: MutableMap<String, ClientGadget> = mutableMapOf()
@@ -34,16 +32,6 @@ class ClientStageManager(
     private val showControlCommands = ShowControlCommands.IMPL
         .createSender(pubSub)
 
-    init {
-        globalLaunch {
-            midiDevices.listTransmitters().forEach { midiTransmitter ->
-                midiTransmitter.listen { midiMessage ->
-                    println("MIDI from ${midiTransmitter.id}: $midiMessage")
-                }
-            }
-        }
-    }
-
     private fun checkForChanges() {
         listeners.forEach { it.onPatchSetChanged() }
     }

src/commonMain/kotlin/baaahs/di/Modules.kt

@@ -136,8 +136,8 @@ interface PinkyModule : KModule {
             scoped { GadgetManager(get(), get(), get(Named.pinkyContext)) }
             scoped<Toolchain> { RootToolchain(get()) }
             scoped { PinkyConfigStore(get(), fs.resolve(".")) }
-            scoped { EventManager(get(), get(), get()) }
-            scoped { StageManager(get(), get(), get(), get(Named.dataDir), get(), get(), get(), get(), get(), get(), get()) }
+            scoped { EventManager(get(), get<PubSub.Server>(), get()) }
+            scoped { StageManager(get(), get(), get(), get(Named.dataDir), get(), get(), get(), get(), get(), get(), get(), get()) }
             scoped { Pinky.NetworkStats() }
             scoped { BrainManager(get(), get(), get(), get(), get(Named.pinkyContext)) }
             scoped { SacnManager(get(), get(Named.pinkyContext), get(), get()) }

src/commonMain/kotlin/baaahs/midi/MidiCommandPorts.kt

@@ -1,27 +1,27 @@
-package baaahs.midi
-
-import baaahs.PubSub
-import baaahs.plugin.Plugins
-import kotlinx.serialization.builtins.ListSerializer
-import kotlinx.serialization.builtins.serializer
-
-class MidiCommandPorts(plugins: Plugins) {
-    val listTransmittersCommandPort = PubSub.CommandPort(
-        "/midi/listTransmitters",
-        RemoteMidiDevices.ListTransmittersCommand.serializer(),
-        ListSerializer(RemoteMidiDevices.RemoteMidiDeviceInfo.serializer()),
-        plugins.serialModule
-    )
-    val listenToTransmitterCommandPort = PubSub.CommandPort(
-        "/midi/listenToTransmitter", RemoteMidiDevices.ListenToTransmitterCommand.serializer(), Unit.serializer(),
-        plugins.serialModule
-    )
-    val midiEventCommandPort = PubSub.CommandPort(
-        "/midi/event", RemoteMidiDevices.MidiEventCommand.serializer(), Unit.serializer(),
-        plugins.serialModule
-    )
-    val closeTransmitterCommandPort = PubSub.CommandPort(
-        "/midi/closeTransmitter", RemoteMidiDevices.CloseTransmitterCommand.serializer(), Unit.serializer(),
-        plugins.serialModule
-    )
-}
+//package baaahs.midi
+//
+//import baaahs.PubSub
+//import baaahs.plugin.Plugins
+//import kotlinx.serialization.builtins.ListSerializer
+//import kotlinx.serialization.builtins.serializer
+//
+//class MidiCommandPorts(plugins: Plugins) {
+//    val listTransmittersCommandPort = PubSub.CommandPort(
+//        "/midi/listTransmitters",
+//        RemoteMidiDevices.ListTransmittersCommand.serializer(),
+//        ListSerializer(RemoteMidiDevices.RemoteMidiDeviceInfo.serializer()),
+//        plugins.serialModule
+//    )
+//    val listenToTransmitterCommandPort = PubSub.CommandPort(
+//        "/midi/listenToTransmitter", RemoteMidiDevices.ListenToTransmitterCommand.serializer(), Unit.serializer(),
+//        plugins.serialModule
+//    )
+//    val midiEventCommandPort = PubSub.CommandPort(
+//        "/midi/event", RemoteMidiDevices.MidiEventCommand.serializer(), Unit.serializer(),
+//        plugins.serialModule
+//    )
+//    val closeTransmitterCommandPort = PubSub.CommandPort(
+//        "/midi/closeTransmitter", RemoteMidiDevices.CloseTransmitterCommand.serializer(), Unit.serializer(),
+//        plugins.serialModule
+//    )
+//}

src/commonMain/kotlin/baaahs/midi/MidiDevices.kt

@@ -1,9 +1,25 @@
 package baaahs.midi
 
+import baaahs.rpc.Service
+
+@Service
 interface MidiDevices {
-    suspend fun listTransmitters(): List<MidiTransmitter>
+    suspend fun listTransmitters(): List<MidiPort>
+
+    companion object {
+        val IMPL by lazy { MidiDevices.getImpl("pinky/midiDevices") }
+    }
 }
 
+//class MidiManager(
+//    rpcEndpoint: RpcEndpoint
+//) : MidiDevices {
+//    val midiDevicesService = MidiDevices.IMPL.createReceiver(rpcEndpoint, object : MidiDevices {
+//        override suspend fun listTransmitters(): List<MidiPort> {
+//            TODO("not implemented")
+//        }
+//    })
+//}
 class NullMidiDevices : MidiDevices {
-    override suspend fun listTransmitters(): List<MidiTransmitter> = emptyList()
+    override suspend fun listTransmitters(): List<MidiPort> = emptyList()
 }

src/commonMain/kotlin/baaahs/midi/MidiGateway.kt

@@ -0,0 +1,67 @@
+package baaahs.midi
+
+import baaahs.rpc.Service
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+import kotlinx.datetime.Instant
+import kotlinx.serialization.Serializable
+
+@Service
+interface MidiGatewayApi {
+    suspend fun deviceOnline(midiDeviceId: Int, midiDevice: MidiDevice)
+    suspend fun receivedEvent(midiDeviceId: Int, midiEvent: MidiEvent)
+    suspend fun deviceOffline(midiDeviceId: Int)
+
+    companion object {
+        val IMPL by lazy { MidiGateway.getImpl("pinky/midiGateway") }
+    }
+}
+
+@Service
+interface MidiGateway {
+    suspend fun receivedEvent(midiDevice: MidiDevice, midiEvent: MidiEvent)
+    suspend fun deviceOffline(midiDevice: MidiDevice)
+
+    companion object {
+        val IMPL by lazy { MidiGateway.getImpl("pinky/midiGateway") }
+    }
+}
+
+class MidiGatewayServer : MidiGateway {
+    override suspend fun receivedEvent(midiDevice: MidiDevice, midiEvent: MidiEvent) {
+        TODO("not implemented")
+    }
+
+    override suspend fun deviceOffline(midiDevice: MidiDevice) {
+        TODO("not implemented")
+    }
+}
+
+class MidiGatewayClient(
+    private val midiGateway: MidiGateway,
+    private val scope: CoroutineScope
+) {
+    fun receivedEvent(midiDevice: MidiDevice, midiEvent: MidiEvent) {
+        scope.launch {
+            midiGateway.receivedEvent(midiDevice, midiEvent)
+        }
+    }
+}
+
+@Serializable
+data class MidiDevice(
+    val id: String,
+    val name: String,
+    val vendor: String,
+    val description: String,
+    val version: String
+)
+
+@Serializable
+data class MidiEvent(
+    val instant: Instant,
+    val channel: Int,
+    val command: Int,
+    val data1: Int,
+    val data2: Int
+)

src/commonMain/kotlin/baaahs/midi/MidiPort.kt

@@ -0,0 +1,3 @@
+package baaahs.midi
+
+interface MidiPort