Cleanup session and state handling

libquassel-client/src/main/kotlin/de/justjanne/libquassel/client/ClientProxyMessageHandler.kt

+/*
+ * libquassel
+ * Copyright (c) 2021 Janne Mareike Koschinski
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public License,
+ * v. 2.0. If a copy of the MPL was not distributed with this file, You can
+ * obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package de.justjanne.libquassel.client
+
+import de.justjanne.libquassel.annotations.ProtocolSide
+import de.justjanne.libquassel.protocol.exceptions.RpcInvocationFailedException
+import de.justjanne.libquassel.protocol.models.SignalProxyMessage
+import de.justjanne.libquassel.protocol.session.ProxyMessageHandler
+import de.justjanne.libquassel.protocol.syncables.HeartBeatHandler
+import de.justjanne.libquassel.protocol.syncables.ObjectRepository
+import de.justjanne.libquassel.protocol.syncables.common.RpcHandler
+import de.justjanne.libquassel.protocol.syncables.invoker.Invokers
+
+class ClientProxyMessageHandler(
+  val heartBeatHandler: HeartBeatHandler,
+  val objectRepository: ObjectRepository,
+  val rpcHandler: RpcHandler
+) : ProxyMessageHandler {
+  override fun emit(message: SignalProxyMessage) {
+    TODO("Not Implemented")
+  }
+
+  override fun dispatch(message: SignalProxyMessage) {
+    when (message) {
+      is SignalProxyMessage.HeartBeat -> emit(SignalProxyMessage.HeartBeatReply(message.timestamp))
+      is SignalProxyMessage.HeartBeatReply -> heartBeatHandler.recomputeLatency(message.timestamp, force = true)
+      is SignalProxyMessage.InitData -> objectRepository.init(
+        objectRepository.find(message.className, message.objectName) ?: return,
+        message.initData
+      )
+      is SignalProxyMessage.InitRequest -> {
+        // Ignore incoming requests, we’re a client, we shouldn’t ever receive these
+      }
+      is SignalProxyMessage.Rpc -> {
+        val invoker = Invokers.get(ProtocolSide.CLIENT, "RpcHandler")
+          ?: throw RpcInvocationFailedException.InvokerNotFoundException("RpcHandler")
+        invoker.invoke(rpcHandler, message.slotName, message.params)
+      }
+      is SignalProxyMessage.Sync -> {
+        val invoker = Invokers.get(ProtocolSide.CLIENT, message.className)
+          ?: throw RpcInvocationFailedException.InvokerNotFoundException(message.className)
+        val syncable = objectRepository.find(message.className, message.objectName)
+          ?: throw RpcInvocationFailedException.SyncableNotFoundException(message.className, message.objectName)
+        invoker.invoke(syncable, message.slotName, message.params)
+      }
+    }
+  }
+}

libquassel-client/src/main/kotlin/de/justjanne/libquassel/client/ClientRpcHandler.kt

+/*
+ * libquassel
+ * Copyright (c) 2021 Janne Mareike Koschinski
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public License,
+ * v. 2.0. If a copy of the MPL was not distributed with this file, You can
+ * obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package de.justjanne.libquassel.client
+
+import de.justjanne.libquassel.protocol.models.Message
+import de.justjanne.libquassel.protocol.models.StatusMessage
+import de.justjanne.libquassel.protocol.serializers.qt.StringSerializerUtf8
+import de.justjanne.libquassel.protocol.session.Session
+import de.justjanne.libquassel.protocol.syncables.common.RpcHandler
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import java.nio.ByteBuffer
+
+class ClientRpcHandler(session: Session) : RpcHandler(session) {
+  override fun objectRenamed(classname: ByteBuffer, newName: String?, oldName: String?) {
+    val objectRepository = session?.objectRepository ?: return
+    val className = StringSerializerUtf8.deserializeRaw(classname)
+    val syncable = objectRepository.find(className, oldName ?: return)
+      ?: return
+    objectRepository.rename(syncable, newName ?: return)
+  }
+
+  override fun displayMsg(message: Message) {
+    messages.tryEmit(message)
+  }
+
+  override fun displayStatusMsg(net: String?, msg: String?) {
+    statusMessage.tryEmit(StatusMessage(net, msg ?: return))
+  }
+
+  @Suppress("NOTHING_TO_INLINE")
+  inline fun messages(): Flow<Message> = messages
+
+  @PublishedApi
+  internal val messages = MutableSharedFlow<Message>()
+
+  @Suppress("NOTHING_TO_INLINE")
+  inline fun statusMessage(): StateFlow<StatusMessage?> = statusMessage
+
+  @PublishedApi
+  internal val statusMessage = MutableStateFlow<StatusMessage?>(null)
+}

libquassel-client/src/main/kotlin/de/justjanne/libquassel/client/ClientSession.kt

@@ -9,17 +9,14 @@
 package de.justjanne.libquassel.client
 
 import de.justjanne.libquassel.annotations.ProtocolSide
-import de.justjanne.libquassel.protocol.exceptions.RpcInvocationFailedException
-import de.justjanne.libquassel.protocol.models.Message
-import de.justjanne.libquassel.protocol.models.SignalProxyMessage
-import de.justjanne.libquassel.protocol.models.StatusMessage
+import de.justjanne.libquassel.client.io.CoroutineChannel
 import de.justjanne.libquassel.protocol.models.ids.IdentityId
 import de.justjanne.libquassel.protocol.models.ids.NetworkId
 import de.justjanne.libquassel.protocol.serializers.qt.StringSerializerUtf8
+import de.justjanne.libquassel.protocol.session.CommonSyncProxy
+import de.justjanne.libquassel.protocol.session.Session
 import de.justjanne.libquassel.protocol.syncables.HeartBeatHandler
 import de.justjanne.libquassel.protocol.syncables.ObjectRepository
-import de.justjanne.libquassel.protocol.syncables.Session
-import de.justjanne.libquassel.protocol.syncables.SyncableStub
 import de.justjanne.libquassel.protocol.syncables.common.AliasManager
 import de.justjanne.libquassel.protocol.syncables.common.BacklogManager
 import de.justjanne.libquassel.protocol.syncables.common.BufferSyncer
@@ -32,27 +29,35 @@ import de.justjanne.libquassel.protocol.syncables.common.IgnoreListManager
 import de.justjanne.libquassel.protocol.syncables.common.IrcListHelper
 import de.justjanne.libquassel.protocol.syncables.common.Network
 import de.justjanne.libquassel.protocol.syncables.common.NetworkConfig
-import de.justjanne.libquassel.protocol.syncables.common.RpcHandler
-import de.justjanne.libquassel.protocol.syncables.invoker.Invokers
 import de.justjanne.libquassel.protocol.syncables.state.NetworkState
 import de.justjanne.libquassel.protocol.util.update
 import de.justjanne.libquassel.protocol.variant.QVariantMap
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
-import java.nio.ByteBuffer
 
-class ClientSession : Session {
-  override val protocolSide = ProtocolSide.CLIENT
+class ClientSession(
+  private val connection: CoroutineChannel
+) : Session {
+  override val side = ProtocolSide.CLIENT
+
+  private val rpcHandler = ClientRpcHandler(this)
+  private val heartBeatHandler = HeartBeatHandler()
   override val objectRepository = ObjectRepository()
-  override val rpcHandler = ClientRpcHandler(this)
-  val heartBeatHandler = HeartBeatHandler()
+  private val proxyMessageHandler = ClientProxyMessageHandler(
+    heartBeatHandler,
+    objectRepository,
+    rpcHandler
+  )
+  override val proxy = CommonSyncProxy(
+    ProtocolSide.CLIENT,
+    objectRepository,
+    proxyMessageHandler
+  )
 
   override fun network(id: NetworkId) = state().networks[id]
   override fun addNetwork(id: NetworkId) {
     val network = Network(this, state = NetworkState(id))
-    synchronize(network)
+    proxy.synchronize(network)
     state.update {
       copy(networks = networks + Pair(id, network))
     }
@@ -60,7 +65,7 @@ class ClientSession : Session {
 
   override fun removeNetwork(id: NetworkId) {
     val network = network(id) ?: return
-    stopSynchronize(network)
+    proxy.stopSynchronize(network)
     state.update {
       copy(networks = networks - id)
     }
@@ -71,7 +76,7 @@ class ClientSession : Session {
   override fun addIdentity(properties: QVariantMap) {
     val identity = Identity(this)
     identity.fromVariantMap(properties)
-    synchronize(identity)
+    proxy.synchronize(identity)
     state.update {
       copy(identities = identities + Pair(identity.id(), identity))
     }
@@ -79,12 +84,20 @@ class ClientSession : Session {
 
   override fun removeIdentity(id: IdentityId) {
     val identity = identity(id) ?: return
-    stopSynchronize(identity)
+    proxy.stopSynchronize(identity)
     state.update {
       copy(identities = identities - id)
     }
   }
 
+  override fun rename(className: String, oldName: String, newName: String) {
+    rpcHandler.objectRenamed(
+      StringSerializerUtf8.serializeRaw(className),
+      oldName,
+      newName
+    )
+  }
+
   override val aliasManager get() = state().aliasManager
 
   override val backlogManager get() = state().backlogManager
@@ -105,46 +118,6 @@ class ClientSession : Session {
 
   override val networkConfig get() = state().networkConfig
 
-  override fun synchronize(syncable: SyncableStub) {
-    if (objectRepository.add(syncable)) {
-      dispatch(SignalProxyMessage.InitRequest(syncable.className, syncable.objectName))
-    }
-  }
-
-  override fun stopSynchronize(syncable: SyncableStub) {
-    objectRepository.remove(syncable)
-  }
-
-  override fun emit(message: SignalProxyMessage) {
-    TODO("Not yet implemented")
-  }
-
-  override fun dispatch(message: SignalProxyMessage) {
-    when (message) {
-      is SignalProxyMessage.HeartBeat -> emit(SignalProxyMessage.HeartBeatReply(message.timestamp))
-      is SignalProxyMessage.HeartBeatReply -> heartBeatHandler.recomputeLatency(message.timestamp, force = true)
-      is SignalProxyMessage.InitData -> objectRepository.init(
-        objectRepository.find(message.className, message.objectName) ?: return,
-        message.initData
-      )
-      is SignalProxyMessage.InitRequest -> {
-        // Ignore incoming requests, we’re a client, we shouldn’t ever receive these
-      }
-      is SignalProxyMessage.Rpc -> {
-        val invoker = Invokers.get(ProtocolSide.CLIENT, "RpcHandler")
-          ?: throw RpcInvocationFailedException.InvokerNotFoundException("RpcHandler")
-        invoker.invoke(rpcHandler, message.slotName, message.params)
-      }
-      is SignalProxyMessage.Sync -> {
-        val invoker = Invokers.get(ProtocolSide.CLIENT, message.className)
-          ?: throw RpcInvocationFailedException.InvokerNotFoundException(message.className)
-        val syncable = objectRepository.find(message.className, message.objectName)
-          ?: throw RpcInvocationFailedException.SyncableNotFoundException(message.className, message.objectName)
-        invoker.invoke(syncable, message.slotName, message.params)
-      }
-    }
-  }
-
   @Suppress("NOTHING_TO_INLINE")
   inline fun state(): ClientSessionState = state.value
 
@@ -168,34 +141,4 @@ class ClientSession : Session {
       networkConfig = NetworkConfig(this)
     )
   )
-
-  class ClientRpcHandler(session: Session) : RpcHandler(session) {
-    override fun objectRenamed(classname: ByteBuffer, newName: String?, oldName: String?) {
-      val objectRepository = session?.objectRepository ?: return
-      val className = StringSerializerUtf8.deserializeRaw(classname)
-      val syncable = objectRepository.find(className, oldName ?: return)
-        ?: return
-      objectRepository.rename(syncable, newName ?: return)
-    }
-
-    override fun displayMsg(message: Message) {
-      messages.tryEmit(message)
-    }
-
-    override fun displayStatusMsg(net: String?, msg: String?) {
-      statusMessage.tryEmit(StatusMessage(net, msg ?: return))
-    }
-
-    @Suppress("NOTHING_TO_INLINE")
-    inline fun messages(): Flow<Message> = messages
-
-    @PublishedApi
-    internal val messages = MutableSharedFlow<Message>()
-
-    @Suppress("NOTHING_TO_INLINE")
-    inline fun statusMessage(): StateFlow<StatusMessage?> = statusMessage
-
-    @PublishedApi
-    internal val statusMessage = MutableStateFlow<StatusMessage?>(null)
-  }
 }

libquassel-client/src/main/kotlin/de/justjanne/libquassel/client/io/CoroutineChannel.kt

@@ -9,12 +9,12 @@
 
 package de.justjanne.libquassel.client.io
 
-import de.justjanne.libquassel.client.util.TlsInfo
 import de.justjanne.libquassel.protocol.io.ChainedByteBuffer
+import de.justjanne.libquassel.protocol.util.update
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.asCoroutineDispatcher
+import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.runInterruptible
 import java.net.InetSocketAddress
 import java.net.Socket
@@ -26,8 +26,6 @@ class CoroutineChannel {
   private lateinit var channel: StreamChannel
   private val writeContext = Executors.newSingleThreadExecutor().asCoroutineDispatcher()
   private val readContext = Executors.newSingleThreadExecutor().asCoroutineDispatcher()
-  private val _tlsInfo = MutableStateFlow<TlsInfo?>(null)
-  val tlsInfo: StateFlow<TlsInfo?> get() = _tlsInfo
 
   suspend fun connect(
     address: InetSocketAddress,
@@ -38,25 +36,33 @@ class CoroutineChannel {
     socket.keepAlive = keepAlive
     socket.connect(address, timeout)
     this.channel = StreamChannel(socket)
+    state.update {
+      copy(connected = true)
+    }
   }
 
   fun enableCompression() {
     channel = channel.withCompression()
+    state.update {
+      copy(compression = true)
+    }
   }
 
   suspend fun enableTLS(context: SSLContext) {
     channel = runInterruptible(writeContext) {
       channel.withTLS(context)
     }
-    _tlsInfo.emit(channel.tlsInfo())
+    state.update {
+      copy(tlsInfo = channel.tlsInfo())
+    }
   }
 
   suspend fun read(buffer: ByteBuffer): Int = runInterruptible(readContext) {
-    this.channel.read(buffer)
+    channel.read(buffer)
   }
 
   suspend fun write(buffer: ByteBuffer): Int = runInterruptible(writeContext) {
-    this.channel.write(buffer)
+    channel.write(buffer)
   }
 
   suspend fun write(chainedBuffer: ChainedByteBuffer) {
@@ -66,6 +72,22 @@ class CoroutineChannel {
   }
 
   suspend fun flush() = runInterruptible(writeContext) {
-    this.channel.flush()
+    channel.flush()
+  }
+
+  fun close() {
+    channel.close()
+    state.update {
+      copy(connected = false)
     }
   }
+
+  @Suppress("NOTHING_TO_INLINE")
+  inline fun state(): CoroutineChannelState = state.value
+
+  @Suppress("NOTHING_TO_INLINE")
+  inline fun flow(): Flow<CoroutineChannelState> = state
+
+  @PublishedApi
+  internal val state = MutableStateFlow(CoroutineChannelState())
+}

libquassel-client/src/main/kotlin/de/justjanne/libquassel/client/io/CoroutineChannelState.kt

+/*
+ * libquassel
+ * Copyright (c) 2021 Janne Mareike Koschinski
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public License,
+ * v. 2.0. If a copy of the MPL was not distributed with this file, You can
+ * obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package de.justjanne.libquassel.client.io
+
+import de.justjanne.libquassel.client.util.TlsInfo
+
+data class CoroutineChannelState(
+  val tlsInfo: TlsInfo? = null,
+  val compression: Boolean = false,
+  val connected: Boolean = false,
+)

libquassel-client/src/main/kotlin/de/justjanne/libquassel/client/syncables/ClientBacklogManager.kt

@@ -16,7 +16,7 @@ import de.justjanne.libquassel.protocol.models.flags.MessageType
 import de.justjanne.libquassel.protocol.models.flags.MessageTypes
 import de.justjanne.libquassel.protocol.models.ids.BufferId
 import de.justjanne.libquassel.protocol.models.ids.MsgId
-import de.justjanne.libquassel.protocol.syncables.Session
+import de.justjanne.libquassel.protocol.session.Session
 import de.justjanne.libquassel.protocol.syncables.common.BacklogManager
 import de.justjanne.libquassel.protocol.variant.QVariantList
 import kotlin.coroutines.Continuation

libquassel-client/src/main/kotlin/de/justjanne/libquassel/client/syncables/ClientIrcListHelper.kt

@@ -12,7 +12,7 @@ package de.justjanne.libquassel.client.syncables
 import de.justjanne.libquassel.client.exceptions.IrcListException
 import de.justjanne.libquassel.protocol.models.QStringList
 import de.justjanne.libquassel.protocol.models.ids.NetworkId
-import de.justjanne.libquassel.protocol.syncables.Session
+import de.justjanne.libquassel.protocol.session.Session
 import de.justjanne.libquassel.protocol.syncables.common.IrcListHelper
 import de.justjanne.libquassel.protocol.variant.QVariantList
 import de.justjanne.libquassel.protocol.variant.into

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/session/CommonSyncProxy.kt

+/*
+ * libquassel
+ * Copyright (c) 2021 Janne Mareike Koschinski
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public License,
+ * v. 2.0. If a copy of the MPL was not distributed with this file, You can
+ * obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package de.justjanne.libquassel.protocol.session
+
+import de.justjanne.libquassel.annotations.ProtocolSide
+import de.justjanne.libquassel.protocol.models.SignalProxyMessage
+import de.justjanne.libquassel.protocol.syncables.ObjectRepository
+import de.justjanne.libquassel.protocol.syncables.SyncableStub
+import de.justjanne.libquassel.protocol.variant.QVariantList
+
+class CommonSyncProxy(
+  private val protocolSide: ProtocolSide,
+  private val objectRepository: ObjectRepository,
+  private val proxyMessageHandler: ProxyMessageHandler
+) : SyncProxy {
+  override fun synchronize(syncable: SyncableStub) {
+    if (objectRepository.add(syncable)) {
+      proxyMessageHandler.dispatch(SignalProxyMessage.InitRequest(syncable.className, syncable.objectName))
+    }
+  }
+
+  override fun stopSynchronize(syncable: SyncableStub) {
+    objectRepository.remove(syncable)
+  }
+
+  override fun sync(
+    target: ProtocolSide,
+    className: String,
+    objectName: String,
+    function: String,
+    arguments: QVariantList
+  ) {
+    if (target != protocolSide) {
+      proxyMessageHandler.emit(
+        SignalProxyMessage.Sync(
+          className,
+          objectName,
+          function,
+          arguments
+        )
+      )
+    }
+  }
+
+  override fun rpc(
+    target: ProtocolSide,
+    function: String,
+    arguments: QVariantList
+  ) {
+    if (target != protocolSide) {
+      proxyMessageHandler.emit(
+        SignalProxyMessage.Rpc(
+          function,
+          arguments
+        )
+      )
+    }
+  }
+}

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/session/HandshakeMessageHandler.kt

+/*
+ * libquassel
+ * Copyright (c) 2021 Janne Mareike Koschinski
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public License,
+ * v. 2.0. If a copy of the MPL was not distributed with this file, You can
+ * obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package de.justjanne.libquassel.protocol.session
+
+import de.justjanne.libquassel.protocol.features.FeatureSet
+import de.justjanne.libquassel.protocol.variant.QVariantMap
+
+interface HandshakeMessageHandler {
+  /**
+   * Register client and start connection
+   */
+  suspend fun init(
+    /**
+     * Human readable (HTML formatted) version of the client
+     */
+    clientVersion: String,
+    /**
+     * Build timestamp of the client
+     */
+    buildDate: String,
+    /**
+     * Enabled client features for this connection
+     */
+    featureSet: FeatureSet
+  )
+
+  /**
+   * Login to core with authentication data
+   */
+  suspend fun login(
+    /**
+     * Username of the core account
+     */
+    username: String,
+    /**
+     * Password of the core account
+     */
+    password: String
+  )
+
+  /**
+   * Configure core for the first time
+   */
+  suspend fun configureCore(
+    /**
+     * Username of a new core account to be created
+     */
+    adminUsername: String,
+    /**
+     * Password of a new core account to be created
+     */
+    adminPassword: String,
+    /**
+     * Chosen storage backend id
+     */
+    backend: String,
+    /**
+     * Storage backend configuration data
+     */
+    backendConfiguration: QVariantMap,
+    /**
+     * Chosen authenticator backend id
+     */
+    authenticator: String,
+    /**
+     * Authenticator backend configuration data
+     */
+    authenticatorConfiguration: QVariantMap
+  )
+}

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/session/ProxyMessageHandler.kt

+/*
+ * libquassel
+ * Copyright (c) 2021 Janne Mareike Koschinski
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public License,
+ * v. 2.0. If a copy of the MPL was not distributed with this file, You can
+ * obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package de.justjanne.libquassel.protocol.session
+
+import de.justjanne.libquassel.protocol.models.SignalProxyMessage
+
+interface ProxyMessageHandler {
+  fun emit(message: SignalProxyMessage)
+  fun dispatch(message: SignalProxyMessage)
+}

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/syncables/Session.kt → libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/session/Session.kt

@@ -7,12 +7,12 @@
  * obtain one at https://mozilla.org/MPL/2.0/.
  */
 
-package de.justjanne.libquassel.protocol.syncables
+package de.justjanne.libquassel.protocol.session
 
 import de.justjanne.libquassel.annotations.ProtocolSide
-import de.justjanne.libquassel.protocol.models.SignalProxyMessage
 import de.justjanne.libquassel.protocol.models.ids.IdentityId
 import de.justjanne.libquassel.protocol.models.ids.NetworkId
+import de.justjanne.libquassel.protocol.syncables.ObjectRepository
 import de.justjanne.libquassel.protocol.syncables.common.AliasManager
 import de.justjanne.libquassel.protocol.syncables.common.BacklogManager
 import de.justjanne.libquassel.protocol.syncables.common.BufferSyncer
@@ -25,14 +25,12 @@ import de.justjanne.libquassel.protocol.syncables.common.IgnoreListManager
 import de.justjanne.libquassel.protocol.syncables.common.IrcListHelper
 import de.justjanne.libquassel.protocol.syncables.common.Network
 import de.justjanne.libquassel.protocol.syncables.common.NetworkConfig
-import de.justjanne.libquassel.protocol.syncables.common.RpcHandler
-import de.justjanne.libquassel.protocol.variant.QVariantList
 import de.justjanne.libquassel.protocol.variant.QVariantMap
 
 interface Session {
-  val protocolSide: ProtocolSide
+  val side: ProtocolSide
+  val proxy: SyncProxy
   val objectRepository: ObjectRepository
-  val rpcHandler: RpcHandler
 
   fun network(id: NetworkId): Network?
   fun addNetwork(id: NetworkId)
@@ -42,6 +40,8 @@ interface Session {
   fun addIdentity(properties: QVariantMap)
   fun removeIdentity(id: IdentityId)
 
+  fun rename(className: String, oldName: String, newName: String)
+
   val aliasManager: AliasManager
   val backlogManager: BacklogManager
   val bufferSyncer: BufferSyncer
@@ -53,44 +53,4 @@ interface Session {
   val coreInfo: CoreInfo
   val dccConfig: DccConfig
   val networkConfig: NetworkConfig
-
-  fun synchronize(syncable: SyncableStub)
-  fun stopSynchronize(syncable: SyncableStub)
-
-  fun sync(
-    target: ProtocolSide,
-    className: String,
-    objectName: String,
-    function: String,
-    arguments: QVariantList
-  ) {
-    if (target != protocolSide) {
-      emit(
-        SignalProxyMessage.Sync(
-          className,
-          objectName,
-          function,
-          arguments
-        )
-      )
-    }
-  }
-
-  fun rpc(
-    target: ProtocolSide,
-    function: String,
-    arguments: QVariantList
-  ) {
-    if (target != protocolSide) {
-      emit(
-        SignalProxyMessage.Rpc(
-          function,
-          arguments
-        )
-      )
-    }
-  }
-
-  fun emit(message: SignalProxyMessage)
-  fun dispatch(message: SignalProxyMessage)
 }

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/session/SyncProxy.kt

+/*
+ * libquassel
+ * Copyright (c) 2021 Janne Mareike Koschinski
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public License,
+ * v. 2.0. If a copy of the MPL was not distributed with this file, You can
+ * obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package de.justjanne.libquassel.protocol.session
+
+import de.justjanne.libquassel.annotations.ProtocolSide
+import de.justjanne.libquassel.protocol.syncables.SyncableStub
+import de.justjanne.libquassel.protocol.variant.QVariantList
+
+interface SyncProxy {
+  fun synchronize(syncable: SyncableStub)
+
+  fun stopSynchronize(syncable: SyncableStub)
+
+  fun sync(
+    target: ProtocolSide,
+    className: String,
+    objectName: String,
+    function: String,
+    arguments: QVariantList
+  )
+
+  fun rpc(
+    target: ProtocolSide,
+    function: String,
+    arguments: QVariantList
+  )
+}

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/syncables/StatefulSyncableObject.kt

@@ -9,6 +9,7 @@
 
 package de.justjanne.libquassel.protocol.syncables
 
+import de.justjanne.libquassel.protocol.session.Session
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableStateFlow
 

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/syncables/SyncableObject.kt

@@ -9,7 +9,7 @@
 
 package de.justjanne.libquassel.protocol.syncables
 
-import de.justjanne.libquassel.protocol.serializers.qt.StringSerializerUtf8
+import de.justjanne.libquassel.protocol.session.Session
 
 abstract class SyncableObject(
   override var session: Session?,
@@ -28,11 +28,7 @@ abstract class SyncableObject(
     } else if (oldName != newName) {
       objectName = newName
       session?.objectRepository?.rename(this, newName)
-      session?.rpcHandler?.objectRenamed(
-        StringSerializerUtf8.serializeRaw(className),
-        oldName,
-        newName
-      )
+      session?.rename(className, oldName, newName)
     }
   }
 

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/syncables/SyncableStub.kt

@@ -10,6 +10,7 @@
 package de.justjanne.libquassel.protocol.syncables
 
 import de.justjanne.libquassel.annotations.ProtocolSide
+import de.justjanne.libquassel.protocol.session.Session
 import de.justjanne.libquassel.protocol.variant.QVariant_
 
 interface SyncableStub {
@@ -20,13 +21,13 @@ interface SyncableStub {
 
   fun sync(target: ProtocolSide, function: String, vararg arg: QVariant_) {
     if (initialized) {
-      session?.sync(target, className, objectName, function, arg.toList())
+      session?.proxy?.sync(target, className, objectName, function, arg.toList())
     }
   }
 
   fun rpc(target: ProtocolSide, function: String, vararg arg: QVariant_) {
     if (initialized) {
-      session?.rpc(target, function, arg.toList())
+      session?.proxy?.rpc(target, function, arg.toList())
     }
   }
 }

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/syncables/common/AliasManager.kt

@@ -14,7 +14,7 @@ import de.justjanne.libquassel.protocol.models.QStringList
 import de.justjanne.libquassel.protocol.models.alias.Alias
 import de.justjanne.libquassel.protocol.models.alias.Command
 import de.justjanne.libquassel.protocol.models.types.QtType
-import de.justjanne.libquassel.protocol.syncables.Session
+import de.justjanne.libquassel.protocol.session.Session
 import de.justjanne.libquassel.protocol.syncables.StatefulSyncableObject
 import de.justjanne.libquassel.protocol.syncables.state.AliasManagerState
 import de.justjanne.libquassel.protocol.syncables.stubs.AliasManagerStub

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/syncables/common/BacklogManager.kt

@@ -9,7 +9,7 @@
 
 package de.justjanne.libquassel.protocol.syncables.common
 
-import de.justjanne.libquassel.protocol.syncables.Session
+import de.justjanne.libquassel.protocol.session.Session
 import de.justjanne.libquassel.protocol.syncables.SyncableObject
 import de.justjanne.libquassel.protocol.syncables.stubs.BacklogManagerStub
 

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/syncables/common/BufferSyncer.kt

@@ -20,7 +20,7 @@ import de.justjanne.libquassel.protocol.models.ids.MsgId
 import de.justjanne.libquassel.protocol.models.ids.isValid
 import de.justjanne.libquassel.protocol.models.types.QtType
 import de.justjanne.libquassel.protocol.models.types.QuasselType
-import de.justjanne.libquassel.protocol.syncables.Session
+import de.justjanne.libquassel.protocol.session.Session
 import de.justjanne.libquassel.protocol.syncables.StatefulSyncableObject
 import de.justjanne.libquassel.protocol.syncables.state.BufferSyncerState
 import de.justjanne.libquassel.protocol.syncables.stubs.BufferSyncerStub

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/syncables/common/BufferViewConfig.kt

@@ -18,7 +18,7 @@ import de.justjanne.libquassel.protocol.models.ids.BufferId
 import de.justjanne.libquassel.protocol.models.ids.NetworkId
 import de.justjanne.libquassel.protocol.models.types.QtType
 import de.justjanne.libquassel.protocol.models.types.QuasselType
-import de.justjanne.libquassel.protocol.syncables.Session
+import de.justjanne.libquassel.protocol.session.Session
 import de.justjanne.libquassel.protocol.syncables.StatefulSyncableObject
 import de.justjanne.libquassel.protocol.syncables.state.BufferViewConfigState
 import de.justjanne.libquassel.protocol.syncables.stubs.BufferViewConfigStub

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/syncables/common/BufferViewManager.kt

@@ -11,7 +11,7 @@ package de.justjanne.libquassel.protocol.syncables.common
 
 import de.justjanne.libquassel.protocol.models.BufferInfo
 import de.justjanne.libquassel.protocol.models.types.QtType
-import de.justjanne.libquassel.protocol.syncables.Session
+import de.justjanne.libquassel.protocol.session.Session
 import de.justjanne.libquassel.protocol.syncables.StatefulSyncableObject
 import de.justjanne.libquassel.protocol.syncables.state.BufferViewConfigState
 import de.justjanne.libquassel.protocol.syncables.state.BufferViewManagerState
@@ -59,7 +59,7 @@ open class BufferViewManager(
         bufferViewId = bufferViewConfigId
       )
     )
-    session?.synchronize(config)
+    session?.proxy?.synchronize(config)
     state.update {
       copy(bufferViewConfigs = bufferViewConfigs + Pair(bufferViewConfigId, config))
     }