Fix various disconnection issues, 1.0.1.

CHANGELOG

 vNEXT (in development)
 
+v1.0.1
+
  * Fixed issue with very long packets not fitting in buffers
    after TLS decryption.
+ * Improved error message when IrcClient.connect() is called
+   while already connected
+ * Made IrcClient.disconnect() block until the disconnect has
+   been processed. This will be a very short period of time,
+   and allows callers to immediately call connect() again
+   afterwards if they wish
+ * Fixed various issues with disconnecting TLS connections
+   not behaving correctly
 
 v1.0.0
 

build.gradle.kts

 import org.jetbrains.dokka.gradle.LinkMapping
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
-version = "1.0.0"
+version = "1.0.1"
 group = "com.dmdirc.ktirc"
 
 plugins {

docs/index.adoc

 = KtIrc {version}
 Chris Smith
-:version: 1.0.0
+:version: 1.0.1
 :toc: left
 :toc-position: left
 :toclevels: 5

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

 import kotlinx.coroutines.*
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.channels.map
+import kotlinx.coroutines.sync.Mutex
 import java.net.Inet6Address
 import java.net.InetAddress
 import java.time.Duration
-import java.util.concurrent.atomic.AtomicBoolean
 import java.util.logging.Level
 
 /**
     private val parser = MessageParser()
     private var socket: LineBufferedSocket? = null
 
-    private val connecting = AtomicBoolean(false)
+    private val connecting = Mutex(false)
 
     @Deprecated("Use structured send instead", ReplaceWith("send(command, arguments)"))
     @RemoveIn("2.0.0")
     }
 
     override fun connect() {
-        check(!connecting.getAndSet(true))
+        check(connecting.tryLock()) { "IrcClient is already connected to a server" }
 
         val ip: String
         try {
     }
 
     override fun disconnect() {
-        socket?.disconnect()
+        runBlocking {
+            socket?.disconnect()
+            connecting.lock()
+            connecting.unlock()
+        }
     }
 
     override fun onEvent(handler: (IrcEvent) -> Unit) = messageHandler.addEmitter(handler)
         channelState.clear()
         userState.reset()
         socket = null
-        connecting.set(false)
+        connecting.unlock()
     }
 
 }

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

     }
 
     override fun disconnect() {
-        log.info { "Disconnecting..." }
         socket.close()
+        sendChannel.close()
         coroutineContext.cancel()
     }
 
                 while (socket.isOpen) {
                     defaultPool.borrow { buffer ->
                         val bytesRead = socket.read(buffer)
+                        if (bytesRead == -1) {
+                            return@produce
+                        }
                         var lastLine = 0
                         for (i in 0 until bytesRead) {
                             if (buffer[i] == CARRIAGE_RETURN || buffer[i] == LINE_FEED) {

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

 import com.dmdirc.ktirc.util.logger
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.channels.ClosedReceiveChannelException
 import kotlinx.coroutines.io.ByteChannel
 import kotlinx.coroutines.io.ByteWriteChannel
 import kotlinx.coroutines.launch
         }
     }
 
-    override suspend fun read(buffer: ByteBuffer): Int {
+    override suspend fun read(buffer: ByteBuffer) = try {
         val nextBuffer = outgoingAppBuffers.receive()
         val bytes = nextBuffer.limit()
         buffer.put(nextBuffer)
         defaultPool.recycle(nextBuffer)
-        return bytes
+        bytes
+    } catch (_: ClosedReceiveChannelException) {
+        -1
     }
 
     private suspend fun wrap(): SSLEngineResult? {
 
     override fun close() {
         socket.close()
+
+        // Release any buffers we've got queued up
+        while(true) {
+            outgoingAppBuffers.poll()?.let {
+                defaultPool.recycle(it)
+            } ?: break
+        }
+
         outgoingAppBuffers.close()
     }