Logging, ping handling

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

+@file:Suppress("ArrayInDataClass")
+
 package com.dmdirc.ktirc.events
 
 sealed class IrcEvent
 object ServerConnected : IrcEvent()
+data class PingReceived(val nonce: ByteArray): IrcEvent()

src/main/kotlin/com/dmdirc/ktirc/io/LineBufferedSocket.kt

 package com.dmdirc.ktirc.io
 
+import com.dmdirc.ktirc.util.logger
 import io.ktor.network.selector.ActorSelectorManager
 import io.ktor.network.sockets.Socket
 import io.ktor.network.sockets.aSocket
 
 interface LineBufferedSocket {
 
-    // TODO: This is a bit pants.
-    var debugReceiver: ((String) -> Unit)?
-
     suspend fun connect()
     fun disconnect()
 
         const val LINE_FEED = '\n'.toByte()
     }
 
-    // TODO: This is a bit pants.
-    override var debugReceiver: ((String) -> Unit)? = null
+    private val log by logger()
 
     private lateinit var socket: Socket
     private lateinit var readChannel: ByteReadChannel
     private lateinit var writeChannel: ByteWriteChannel
 
     override suspend fun connect() {
+        log.info { "Connecting..." }
         socket = aSocket(ActorSelectorManager(ioCoroutineDispatcher)).tcp().connect(InetSocketAddress(host, port))
         readChannel = socket.openReadChannel()
         writeChannel = socket.openWriteChannel()
     }
 
     override fun disconnect() {
+        log.info { "Disconnecting..." }
         socket.close()
     }
 
     override suspend fun sendLine(line: ByteArray, offset: Int, length: Int) {
         with (writeChannel) {
-            debugReceiver?.let { it(">>> ${String(line, offset, length)}") }
+            log.fine { ">>> ${String(line, offset, length)}" }
             writeAvailable(line, offset, length)
             writeByte(CARRIAGE_RETURN)
             writeByte(LINE_FEED)
                 if (lineBuffer[i] == CARRIAGE_RETURN || lineBuffer[i] == LINE_FEED) {
                     if (start < i) {
                         val line = lineBuffer.sliceArray(start until i)
-                        debugReceiver?.let { it("<<< ${String(line)}") }
+                        log.fine { "<<< ${String(line)}" }
                         send(line)
                     }
                     start = i + 1

src/main/kotlin/com/dmdirc/ktirc/io/MessageHandler.kt

 
 import com.dmdirc.ktirc.events.IrcEvent
 import com.dmdirc.ktirc.messages.MessageProcessor
+import com.dmdirc.ktirc.util.logger
 import kotlinx.coroutines.channels.ReceiveChannel
 import kotlinx.coroutines.channels.consumeEach
 
 class MessageHandler(private val processors: Collection<MessageProcessor>, private val eventHandler: (IrcEvent) -> Unit) {
 
+    private val log by logger()
+
     suspend fun processMessages(messages: ReceiveChannel<IrcMessage>) {
         messages.consumeEach { it.process().forEach(eventHandler) }
     }
 
     private fun IrcMessage.process() = this.getProcessor()?.process(this) ?: emptyList()
-    private fun IrcMessage.getProcessor() = processors.firstOrNull { it.commands.contains(this.command) }
+    private fun IrcMessage.getProcessor() = processors.firstOrNull { it.commands.contains(command) } ?: run {
+        log.warning { "No processor found for $command" }
+        null
+    }
 
 }

src/main/kotlin/com/dmdirc/ktirc/messages/ISupportProcessor.kt

 import com.dmdirc.ktirc.io.IrcMessage
 import com.dmdirc.ktirc.state.ServerState
 import com.dmdirc.ktirc.state.serverFeatures
+import com.dmdirc.ktirc.util.logger
 import kotlin.reflect.KClass
 
 class ISupportProcessor(val serverState: ServerState) : MessageProcessor {
 
+    private val log by logger()
+
     override val commands = arrayOf("005")
 
     override fun process(message: IrcMessage): List<IrcEvent> {
         }
     }
 
-    private fun resetFeature(name: ByteArray) = name.asFeature()?.let { serverState.resetFeature(it) }
+    private fun resetFeature(name: ByteArray) = name.asFeature()?.let {
+        serverState.resetFeature(it)
+        log.finer { "Reset feature ${it::class}" }
+    }
 
     @Suppress("UNCHECKED_CAST")
     private fun enableFeature(name: ByteArray, value: ByteArray) {
         name.asFeature()?.let { feature ->
             serverState.setFeature(feature, value.cast(feature.type))
+            log.finer { "Set feature ${feature::class} to ${String(value)}" }
         }
     }
 
     private fun enableFeatureWithDefault(name: ByteArray) {
-        TODO("not implemented")
+        name.asFeature()?.let { feature ->
+            when (feature.type) {
+                Boolean::class -> serverState.setFeature(feature, true)
+                else -> TODO("not implemented")
+            }
+        }
     }
 
     private fun ByteArray.asFeature() = serverFeatures[String(this)]
+            ?: run {
+                log.warning { "Unknown feature in 005: ${String(this)}" }
+                null
+            }
 
     private fun ByteArray.cast(to: KClass<out Any>): Any = when (to) {
         Int::class -> String(this).toInt()

src/main/kotlin/com/dmdirc/ktirc/messages/PingProcessor.kt

+package com.dmdirc.ktirc.messages
+
+import com.dmdirc.ktirc.events.PingReceived
+import com.dmdirc.ktirc.io.IrcMessage
+
+class PingProcessor : MessageProcessor {
+
+    override val commands = arrayOf("PING")
+
+    override fun process(message: IrcMessage) = listOf(PingReceived(message.params[0]))
+
+}

src/main/kotlin/com/dmdirc/ktirc/messages/WelcomeProcessor.kt

 package com.dmdirc.ktirc.messages
 
 import com.dmdirc.ktirc.events.IrcEvent
+import com.dmdirc.ktirc.events.ServerConnected
 import com.dmdirc.ktirc.io.IrcMessage
 import com.dmdirc.ktirc.state.ServerState
 
 
     override fun process(message: IrcMessage): List<IrcEvent> {
         serverState.localNickname = String(message.params[0])
-        return emptyList()
+
+        // TODO: Maybe this should be later, like after the first line received after 001-005
+        return listOf(ServerConnected)
     }
 
 }

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

     object MaximumChannels : ServerFeature<Int>("CHANLIMIT", Int::class)
     object ChannelModes : ServerFeature<String>("CHANMODES", String::class)
     object MaximumChannelNameLength : ServerFeature<Int>("CHANNELLEN", Int::class, 200)
+    object WhoxSupport : ServerFeature<Boolean>("WHOX", Boolean::class, false)
 }
 
 val serverFeatures: Map<String, ServerFeature<*>> by lazy {

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

+package com.dmdirc.ktirc.util
+
+import java.util.logging.Logger
+import kotlin.reflect.KClass
+
+private fun <T: Any> logger(forClass: KClass<T>): Logger {
+    return Logger.getLogger(forClass.qualifiedName)
+}
+
+fun <R : Any> R.logger(): Lazy<Logger> {
+    return lazy { logger(this::class) }
+}

src/test/kotlin/com/dmdirc/ktirc/io/KtorLineBufferedSocketTest.kt

         }
     }
 
-    @Test
-    fun `KtorLineBufferedSocket reports sent lines to debug receiver`() = runBlocking {
-        ServerSocket(12321).use { serverSocket ->
-            val socket = KtorLineBufferedSocket("localhost", 12321)
-            GlobalScope.launch {
-                serverSocket.accept()
-            }
-
-            var received = ""
-            socket.debugReceiver = { str -> received = str }
-            socket.connect()
-            socket.sendLine("Test 123")
-
-            assertEquals(">>> Test 123", received)
-        }
-    }
-
-    @Test
-    fun `KtorLineBufferedSocket reports received lines to debug receiver`() = runBlocking {
-        ServerSocket(12321).use { serverSocket ->
-            val socket = KtorLineBufferedSocket("localhost", 12321)
-            GlobalScope.launch {
-                with(serverSocket.accept()) {
-                    getOutputStream().write("Hi there\r\n".toByteArray())
-                    close()
-                }
-            }
-
-            var received = ""
-            socket.debugReceiver = { str -> received = str }
-            socket.connect()
-            socket.readLines(this).receive()
-
-            assertEquals("<<< Hi there", received)
-        }
-    }
-
 }

src/test/kotlin/com/dmdirc/ktirc/messages/ISupportProcessorTest.kt

 import com.dmdirc.ktirc.state.ServerState
 import com.nhaarman.mockitokotlin2.mock
 import com.nhaarman.mockitokotlin2.verify
-import org.junit.jupiter.api.Assertions.*
+import org.junit.jupiter.api.Assertions.assertTrue
 import org.junit.jupiter.api.Test
 
 internal class ISupportProcessorTest {
         verify(state).setFeature(ServerFeature.ServerCaseMapping, CaseMapping.RfcStrict)
     }
 
+    @Test
+    fun `ISupportProcessor handles boolean features with no arguments`() {
+        processor.process(IrcMessage(null, "server.com".toByteArray(), "005",
+                listOf("nickname", "WHOX", "are supported blah blah").map { it.toByteArray() }))
+
+        verify(state).setFeature(ServerFeature.WhoxSupport, true)
+    }
+
 }

src/test/kotlin/com/dmdirc/ktirc/messages/WelcomeProcessorTest.kt

 package com.dmdirc.ktirc.messages
 
+import com.dmdirc.ktirc.events.IrcEvent
+import com.dmdirc.ktirc.events.ServerConnected
 import com.dmdirc.ktirc.io.IrcMessage
 import com.dmdirc.ktirc.state.ServerState
 import com.nhaarman.mockitokotlin2.mock
 import com.nhaarman.mockitokotlin2.verify
-import org.junit.jupiter.api.Assertions.*
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertTrue
 import org.junit.jupiter.api.Test
 
 internal class WelcomeProcessorTest {
         verify(state).localNickname = "acidBurn"
     }
 
+    @Test
+    fun `WelcomeProcessor returns server connected event`() {
+        val events = processor.process(IrcMessage(null, ":thegibson.com".toByteArray(), "001", listOf(
+                "acidBurn".toByteArray(),
+                "Welcome to the Internet Relay Network, acidBurn!burn@hacktheplanet.com".toByteArray())))
+        assertEquals(listOf<IrcEvent>(ServerConnected), events)
+    }
+
 }

src/test/kotlin/com/dmdirc/ktirc/util/LoggingTest.kt

+package com.dmdirc.ktirc.util
+
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+
+internal class LoggingTest {
+
+    private val log by logger()
+
+    @Test
+    fun `logger gives logger with correct class name`() {
+        assertEquals("com.dmdirc.ktirc.util.LoggingTest", log.name)
+    }
+
+}