Initial pass at labelled-replies support

CHANGELOG

 vNEXT (in development)
 
  * Batch start and end events are no longer included in BatchReceived events
+ * Batches now expose complete metadata from their start event
+ * Added support for labelled-replies capability and label message tags
 
 v0.9.0
 

src/main/kotlin/com/dmdirc/ktirc/IrcClientImpl.kt

 import com.dmdirc.ktirc.io.MessageHandler
 import com.dmdirc.ktirc.io.MessageParser
 import com.dmdirc.ktirc.messages.*
-import com.dmdirc.ktirc.model.ChannelStateMap
-import com.dmdirc.ktirc.model.ServerState
-import com.dmdirc.ktirc.model.UserState
-import com.dmdirc.ktirc.model.toConnectionError
+import com.dmdirc.ktirc.model.*
 import com.dmdirc.ktirc.util.currentTimeProvider
+import com.dmdirc.ktirc.util.generateLabel
 import com.dmdirc.ktirc.util.logger
 import io.ktor.util.KtorExperimentalAPI
 import kotlinx.coroutines.*
         socket?.sendChannel?.offer(message.toByteArray()) ?: log.warning { "No send channel for message: $message" }
     }
 
+    // TODO: This will become sendAsync and return a Deferred<IrcEvent>
+    // TODO: Refactor so that send takes a map of tags and arguments; build the string separately
+    internal fun sendWithLabel(message: String) {
+        val messageToSend = if (Capability.LabeledResponse in serverState.capabilities.enabledCapabilities) {
+            val label = generateLabel(this)
+            "@draft/label=$label" + if (message.startsWith('@')) {
+                ";${message.substring(1)}"
+            } else {
+                " $message"
+            }
+        } else {
+            message
+        }
+        socket?.sendChannel?.offer(messageToSend.toByteArray()) ?: log.warning { "No send channel for message: $message" }
+    }
+
     override fun connect() {
         check(!connecting.getAndSet(true))
 
                     sendNickChange(config.profile.nickname)
                     sendUser(config.profile.username, config.profile.realName)
                     messageHandler.processMessages(this@IrcClientImpl, receiveChannel.map { parser.parse(it) })
-                } catch (ex : Exception) {
+                } catch (ex: Exception) {
                     emitEvent(ServerConnectionError(EventMetadata(currentTimeProvider()), ex.toConnectionError(), ex.localizedMessage))
                 }
 

src/main/kotlin/com/dmdirc/ktirc/events/Events.kt

  * @param time The best-guess time at which the event occurred.
  * @param batchId The ID of the batch this event is part of, if any.
  * @param messageId The unique ID of this message, if any.
+ * @param label The label of the command that this event was sent in response to, if any.
  */
-data class EventMetadata(val time: LocalDateTime, val batchId: String? = null, val messageId: String? = null)
+data class EventMetadata(
+        val time: LocalDateTime,
+        val batchId: String? = null,
+        val messageId: String? = null,
+        val label: String? = null)
 
 /** Base class for all events. */
 sealed class IrcEvent(val metadata: EventMetadata) {

src/main/kotlin/com/dmdirc/ktirc/events/mutators/BatchMutator.kt

 
     private fun startBatch(client: IrcClient, event: BatchStarted) {
         client.serverState.batches[event.referenceId] =
-                Batch(event.batchType, event.params.asList(), event.metadata.batchId, mutableListOf())
+                Batch(event.batchType, event.params.asList(), event.metadata, mutableListOf())
     }
 
     private fun finishBatch(client: IrcClient, event: BatchFinished): List<IrcEvent> {
         client.serverState.batches.remove(event.referenceId)?.let {
             val batch = BatchReceived(it.events[0].metadata, it.type, it.arguments.toTypedArray(), it.events)
-            if (it.parent == null) {
+            if (it.metadata.batchId == null) {
                 return listOf(batch)
             } else {
-                client.serverState.batches[it.parent]?.events?.add(batch)
+                client.serverState.batches[it.metadata.batchId]?.events?.add(batch)
             }
         }
 

src/main/kotlin/com/dmdirc/ktirc/model/CapabilitiesState.kt

     object AccountAndRealNameInJoinMessages : Capability("extended-join")
 
     // Capabilities that affect how messages are sent/received:
+    /** Messages can be sent in batches, and potentially handled differently by the client. */
+    object Batch : Capability("batch")
+
     /** Messages sent by the client are echo'd back on successful delivery. */
     object EchoMessages : Capability("echo-message")
 
-    /** Messages can be sent in batches, and potentially handled differently by the client. */
-    object Batch : Capability("batch")
+    /** Allows us to label all outgoing messages and have the server identify the responses to them. */
+    object LabeledResponse : Capability("draft/labeled-response")
 
     // Capabilities that notify us of changes to other clients:
     /** Receive a notification when a user's account changes. */

src/main/kotlin/com/dmdirc/ktirc/model/IrcMessage.kt

 internal class IrcMessage(val tags: Map<MessageTag, String>, val prefix: ByteArray?, val command: String, val params: List<ByteArray>) {
 
     /** The time at which the message was sent, or our best guess at it. */
-    val metadata = EventMetadata(time, batchId, messageId)
+    val metadata = EventMetadata(
+            time = time,
+            batchId = tags[MessageTag.Batch],
+            messageId = tags[MessageTag.MessageId],
+            label = tags[MessageTag.Label])
 
     /** The user that generated the message, if any. */
     val sourceUser by lazy {
             false -> currentTimeProvider()
         }
 
-    private val batchId
-        get() = tags[MessageTag.Batch]
-
-    private val messageId
-        get() = tags[MessageTag.MessageId]
-
 }
 
 /**
     /** Specifies the ID that a batch message belongs to. */
     object Batch : MessageTag("batch")
 
-    /** Specifies the time the server received the message, if the `server-time` capability is negotiated. */
-    object ServerTime : MessageTag("time")
+    /** An arbitrary label to identify the response to messages we generate. */
+    object Label : MessageTag("draft/label")
 
     /** A unique ID for the message, used to reply, react, edit, delete, etc. */
     object MessageId : MessageTag("draft/msgid")
 
     /** Used to specify a slack-like reaction to another message. */
     object React : MessageTag("+draft/react")
+
+    /** Specifies the time the server received the message, if the `server-time` capability is negotiated. */
+    object ServerTime : MessageTag("time")
 }
 
 internal val messageTags: Map<String, MessageTag> by lazy {

src/main/kotlin/com/dmdirc/ktirc/model/ServerState.kt

 package com.dmdirc.ktirc.model
 
 import com.dmdirc.ktirc.SaslConfig
+import com.dmdirc.ktirc.events.EventMetadata
 import com.dmdirc.ktirc.events.IrcEvent
 import com.dmdirc.ktirc.io.CaseMapping
 import com.dmdirc.ktirc.util.logger
+import java.util.concurrent.atomic.AtomicLong
 import kotlin.reflect.KClass
 
 /**
      */
     internal val batches = mutableMapOf<String, Batch>()
 
+    /**
+     * Counter for ensuring sent labels are unique.
+     */
+    internal val labelCounter = AtomicLong(0)
+
     /**
      * Determines if the given mode is one applied to a user of a channel, such as 'o' for operator.
      */
         capabilities.reset()
         sasl.reset()
         batches.clear()
+        labelCounter.set(0)
     }
 
 }
 /**
  * Represents an in-progress batch.
  */
-internal data class Batch(val type: String, val arguments: List<String>, val parent: String? = null, val events: MutableList<IrcEvent> = mutableListOf())
+internal data class Batch(val type: String, val arguments: List<String>, val metadata: EventMetadata, val events: MutableList<IrcEvent> = mutableListOf())
 
 internal val serverFeatures: Map<String, ServerFeature<*>> by lazy {
     ServerFeature::class.nestedClasses.map { it.objectInstance as ServerFeature<*> }.associateBy { it.name }

src/main/kotlin/com/dmdirc/ktirc/util/Labels.kt

+package com.dmdirc.ktirc.util
+
+import com.dmdirc.ktirc.IrcClient
+import com.dmdirc.ktirc.sasl.toBase64
+import java.time.ZoneOffset
+
+internal var generateLabel = { ircClient: IrcClient ->
+    val time = currentTimeProvider().toEpochSecond(ZoneOffset.UTC)
+    val counter = ircClient.serverState.labelCounter.incrementAndGet()
+    ByteArray(6) {
+        when {
+            it < 3 -> ((time shr it) and 0xff).toByte()
+            else -> ((counter shr (it - 3)) and 0xff).toByte()
+        }
+    }.toBase64()
+}

src/test/kotlin/com/dmdirc/ktirc/IrcClientImplTest.kt

 import com.dmdirc.ktirc.events.*
 import com.dmdirc.ktirc.io.CaseMapping
 import com.dmdirc.ktirc.io.LineBufferedSocket
-import com.dmdirc.ktirc.model.ChannelState
-import com.dmdirc.ktirc.model.ConnectionError
-import com.dmdirc.ktirc.model.ServerFeature
-import com.dmdirc.ktirc.model.User
+import com.dmdirc.ktirc.model.*
 import com.dmdirc.ktirc.util.currentTimeProvider
+import com.dmdirc.ktirc.util.generateLabel
 import com.nhaarman.mockitokotlin2.*
 import io.ktor.util.KtorExperimentalAPI
 import kotlinx.coroutines.*
 
         client.send("testing 123")
 
-        assertEquals(true, withTimeoutOrNull(500) {
-            var found = false
-            for (line in sendLineChannel) {
-                if (String(line) == "testing 123") {
-                    found = true
-                    break
-                }
-            }
-            found
-        })
+        assertLineReceived("testing 123")
+    }
+
+    @Test
+    fun `sends text to socket without label if cap is missing`() = runBlocking {
+        val client = IrcClientImpl(normalConfig)
+        client.socketFactory = mockSocketFactory
+        client.connect()
+
+        client.sendWithLabel("testing 123")
+
+        assertLineReceived("testing 123")
+    }
+
+    @Test
+    fun `sends text to socket with added tags and label`() = runBlocking {
+        generateLabel = { "abc123" }
+        val client = IrcClientImpl(normalConfig)
+        client.socketFactory = mockSocketFactory
+        client.serverState.capabilities.enabledCapabilities[Capability.LabeledResponse] = ""
+        client.connect()
+
+        client.sendWithLabel("testing 123")
+
+        assertLineReceived("@draft/label=abc123 testing 123")
+    }
+
+    @Test
+    fun `sends tagged text to socket with label`() = runBlocking {
+        generateLabel = { "abc123" }
+        val client = IrcClientImpl(normalConfig)
+        client.socketFactory = mockSocketFactory
+        client.serverState.capabilities.enabledCapabilities[Capability.LabeledResponse] = ""
+        client.connect()
+
+        client.sendWithLabel("@+test=x testing 123")
+
+        assertLineReceived("@draft/label=abc123;+test=x testing 123")
     }
 
     @Test
         return value.get()
     }
 
+    private suspend fun assertLineReceived(expected: String) {
+        assertEquals(true, withTimeoutOrNull(500) {
+            for (line in sendLineChannel.map { String(it) }) {
+                println(line)
+                if (line == expected) {
+                    return@withTimeoutOrNull true
+                }
+            }
+            false
+        }) { "Expected to receive $expected" }
+    }
+
 
 }

src/test/kotlin/com/dmdirc/ktirc/events/mutators/BatchMutatorTest.kt

             assertEquals(listOf("foo", "bar"), it.arguments)
             assertEquals("netsplit", it.type)
             assertTrue(it.events.isEmpty())
-            assertNull(it.parent)
+            assertNull(it.metadata.batchId)
         }
     }
 
     @Test
     fun `adds to batch when event has a batch ID`() {
-        serverState.batches["abcdef"] = Batch("netsplit", emptyList())
+        serverState.batches["abcdef"] = Batch("netsplit", emptyList(), EventMetadata(TestConstants.time))
 
         val event = UserNickChanged(EventMetadata(TestConstants.time, "abcdef"), User("zeroCool"), "crashOverride")
         mutator.mutateEvent(ircClient, messageEmitter, event)
 
     @Test
     fun `suppresses event when it has a batch ID`() {
-        serverState.batches["abcdef"] = Batch("netsplit", emptyList())
+        serverState.batches["abcdef"] = Batch("netsplit", emptyList(), EventMetadata(TestConstants.time))
 
         val event = UserNickChanged(EventMetadata(TestConstants.time, "abcdef"), User("zeroCool"), "crashOverride")
         val events = mutator.mutateEvent(ircClient, messageEmitter, event)
 
     @Test
     fun `passes event for processing only when it has a batch ID`() {
-        serverState.batches["abcdef"] = Batch("netsplit", emptyList())
+        serverState.batches["abcdef"] = Batch("netsplit", emptyList(), EventMetadata(TestConstants.time))
 
         val event = UserNickChanged(EventMetadata(TestConstants.time, "abcdef"), User("zeroCool"), "crashOverride")
         mutator.mutateEvent(ircClient, messageEmitter, event)
 
     @Test
     fun `sends a batch when it finishes and the parent is null`() {
-        serverState.batches["abcdef"] = Batch("netsplit", listOf("p1", "p2"), events = mutableListOf(ServerConnected(EventMetadata(TestConstants.time, "abcdef"))))
+        serverState.batches["abcdef"] = Batch("netsplit", listOf("p1", "p2"), EventMetadata(TestConstants.time), events = mutableListOf(ServerConnected(EventMetadata(TestConstants.time, "abcdef"))))
 
         val events = mutator.mutateEvent(ircClient, messageEmitter, BatchFinished(EventMetadata(TestConstants.time), "abcdef"))
 
 
     @Test
     fun `adds a batch to its parent when it finishes`() {
-        serverState.batches["12345"] = Batch("history", emptyList())
-        serverState.batches["abcdef"] = Batch("netsplit", emptyList(), "12345", mutableListOf(ServerConnected(EventMetadata(TestConstants.time, "abcdef"))))
+        serverState.batches["12345"] = Batch("history", emptyList(), EventMetadata(TestConstants.time))
+        serverState.batches["abcdef"] = Batch("netsplit", emptyList(), EventMetadata(TestConstants.time, batchId = "12345"), mutableListOf(ServerConnected(EventMetadata(TestConstants.time, "abcdef"))))
 
         val events = mutator.mutateEvent(ircClient, messageEmitter, BatchFinished(EventMetadata(TestConstants.time), "abcdef"))
 
 
     @Test
     fun `deletes batch when it finishes`() {
-        serverState.batches["abcdef"] = Batch("netsplit", emptyList(), events = mutableListOf(ServerConnected(EventMetadata(TestConstants.time, "abcdef"))))
+        serverState.batches["abcdef"] = Batch("netsplit", emptyList(), EventMetadata(TestConstants.time), events = mutableListOf(ServerConnected(EventMetadata(TestConstants.time, "abcdef"))))
 
         mutator.mutateEvent(ircClient, messageEmitter, BatchFinished(EventMetadata(TestConstants.time), "abcdef"))
 

src/test/kotlin/com/dmdirc/ktirc/model/IrcMessageTest.kt

         assertEquals("abc123", message.metadata.messageId)
     }
 
+    @Test
+    fun `populates label if present`() {
+        currentTimeProvider = { TestConstants.time }
+        val message = IrcMessage(hashMapOf(MessageTag.Label to "abc123"), null, "", emptyList())
+        assertEquals("abc123", message.metadata.label)
+    }
+
     @Test
     fun `Can parse the prefix as a source user`() {
         val message = IrcMessage(emptyMap(), "acidBurn!libby@root.localhost".toByteArray(), "", emptyList())

src/test/kotlin/com/dmdirc/ktirc/model/ServerStateTest.kt

 package com.dmdirc.ktirc.model
 
+import com.dmdirc.ktirc.TestConstants
+import com.dmdirc.ktirc.events.EventMetadata
 import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.Test
 
         features[ServerFeature.Network] = "gibson"
         capabilities.advertisedCapabilities[Capability.SaslAuthentication] = "sure"
         sasl.saslBuffer = "in progress"
-        batches["batch"] = Batch("type", emptyList())
+        batches["batch"] = Batch("type", emptyList(), EventMetadata(TestConstants.time))
+        labelCounter.set(100)
 
         reset()
 
         assertTrue(capabilities.advertisedCapabilities.isEmpty())
         assertEquals("", sasl.saslBuffer)
         assertTrue(batches.isEmpty())
+        assertEquals(0, labelCounter.get())
     }
 
 }