TCP Socket File Descriptor Leak

Ktor Version

1.1.5

Ktor Engine Used(client or server and name)

raw sockets

JVM Version, Operating System and Relevant Context

macOS, linux openjdk version “1.8.0_212” OpenJDK Runtime Environment (AdoptOpenJDK)(build 1.8.0_212-b03) OpenJDK 64-Bit Server VM (AdoptOpenJDK)(build 25.212-b03, mixed mode)

Feedback

It seems like client tcp socket connections are not properly closed and leaking file descriptors. When testing the server with telnet no leak occurs. The issue is within the client code. The server part is only included for a complete, reproducable example.

Do the read and write channel need separate closing or is something else not handled correctly in the example?

The output is:

Server said: 'hello 0'
open file descriptors: 64
Server said: 'hello 1'
open file descriptors: 67
Server said: 'hello 2'
open file descriptors: 71

Example:

fun main() = runBlocking {
    val osMxBean = ManagementFactory.getOperatingSystemMXBean() as UnixOperatingSystemMXBean
    val address = InetSocketAddress("127.0.0.1", 2323)

    val connectJob = launch {
        // repeatedly connect to the server
        repeat(3) {
            delay(1_000)
            aSocket(ActorSelectorManager(Dispatchers.IO)).tcp().connect(address).use { socket ->
                val input = socket.openReadChannel()
                val output = socket.openWriteChannel(autoFlush = true)

                output.writeStringUtf8("hello $it\r\n")
                val response = input.readUTF8Line()
                println("Server said: '$response'")
            }

            println("open file descriptors: ${osMxBean.openFileDescriptorCount}")
        }
    }

    // server - irrelevant for the issue
    val serverJob = launch {
        aSocket(ActorSelectorManager(Dispatchers.IO)).tcp().bind(address).use { server ->
            while (true) {
                val socket = server.accept()

                launch {
                    socket.use {
                        val input = socket.openReadChannel()
                        val output = socket.openWriteChannel(autoFlush = true)

                        while (true) {
                            val line = input.readUTF8Line()
                            output.writeStringUtf8("$line\r\n")
                        }
                    }
                }
            }
        }
    }

    connectJob.join()
    serverJob.cancel()
}

[fgutmann]

Found it! The ActorSelectorManager needs to be closed.

I think the documentation here is quite unclear of this fact. In none of the examples in it, it is closed.

[cy6erGn0m]

Also note that sockets are not closed immediately but they live in state TIME_WAIT for some system-dependant period of time (usually minutes). See TCP states for more details. This is driven by OS and out of our control.