Changelog 1.6 version

1.6.0

released 28th May 2021

Client

HTTP-client auth with Bearer token

Client upload/download progress observer/handler/interceptor

Sporadic OkHttp errors after upgrading to ktor 1.3.1

https://youtrack.jetbrains.com/issue/KTOR-449

This issue was imported from GitHub issue: https://github.com/ktorio/ktor/issues/1708

Ktor Version and Engine Used (client or server and name)

implementation("io.ktor:ktor-client-core-jvm:1.3.1")
implementation("io.ktor:ktor-client-core:1.3.1")
implementation("io.ktor:ktor-client-jackson:1.3.1")
implementation("io.ktor:ktor-client-logging-jvm:1.3.1")
implementation("io.ktor:ktor-client-okhttp:1.3.1")
implementation("io.ktor:ktor-jackson:1.3.1")
implementation("io.ktor:ktor-metrics-micrometer:1.3.1")
implementation("io.ktor:ktor-metrics:1.3.1")
implementation("io.ktor:ktor-server-host-common:1.3.1")
implementation("io.ktor:ktor-server-netty:1.3.1")

Describe the bug

We've started seeing sporadic OkHttp exceptions in our tests when we upgraded from 1.3.0 to 1.3.1. Upon downgrading back to 1.3.0 (with no other changes) the tests were fine again.

The exception is:

java.io.EOFException: \n not found: limit=0 content=…
	at o.RealBufferedSource.readUtf8LineStrict(RealBufferedSource.java:240)
	at o.i.h.Http1ExchangeCodec.readHeaderLine(Http1ExchangeCodec.java:242)
	at o.i.h.Http1ExchangeCodec.readResponseHeaders(Http1ExchangeCodec.java:213)
	... 20 common frames omitted
Wrapped by: java.io.IOException: unexpected end of stream on http://called-service/...
	at o.i.h.Http1ExchangeCodec.readResponseHeaders(Http1ExchangeCodec.java:236)
	at o.i.c.Exchange.readResponseHeaders(Exchange.java:115)
	at o.i.h.CallServerInterceptor.intercept(CallServerInterceptor.java:94)
	at o.i.h.RealInterceptorChain.proceed(RealInterceptorChain.java:142)
	at o.i.c.ConnectInterceptor.intercept(ConnectInterceptor.java:43)
	at o.i.h.RealInterceptorChain.proceed(RealInterceptorChain.java:142)
	at o.i.h.RealInterceptorChain.proceed(RealInterceptorChain.java:117)
	at o.i.c.CacheInterceptor.intercept(CacheInterceptor.java:94)
	at o.i.h.RealInterceptorChain.proceed(RealInterceptorChain.java:142)
	at o.i.h.RealInterceptorChain.proceed(RealInterceptorChain.java:117)
	at o.i.h.BridgeInterceptor.intercept(BridgeInterceptor.java:93)
	at o.i.h.RealInterceptorChain.proceed(RealInterceptorChain.java:142)
	at o.i.h.RetryAndFollowUpInterceptor.intercept(RetryAndFollowUpInterceptor.java:88)
	at o.i.h.RealInterceptorChain.proceed(RealInterceptorChain.java:142)
	at o.i.h.RealInterceptorChain.proceed(RealInterceptorChain.java:117)
	at okhttp3.RealCall.getResponseWithInterceptorChain(RealCall.java:221)
	at o.RealCall$AsyncCall.execute(RealCall.java:172)
	at o.i.NamedRunnable.run(NamedRunnable.java:32)
	at j.u.c.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1128)
	at j.u.c.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:628)
	at java.lang.Thread.run(Thread.java:834)

It looks like the HTTP client receives an EOF while reading the response headers from calling http://called-service/... I don't think the culprit is the remote web server though, because this server is called from other services and it's only the one with ktor 1.3.1 that throws these errors. And this one is also fine with ktor 1.3.0.

This issue has already been raised before in the OkHttp repository, for example here.

From what I can see, both ktor 1.3.0 and 1.3.1 both depend on com.squareup.okhttp3:okhttp:3.14.2, so maybe this is due to a change in the way ktor uses OkHttp?

To Reproduce

Not easy to reproduce, unfortunately, because the error only occurs in a small percentage of requests (~5%). I'm hoping someone else observes this issue and can come up with a reproducible test.

Apache HTTP Client does not send Content-Length header if body is empty content

CIO: TLSConfigBuilder JVM allow null as password

'%3D' inside query of redirect target location will be replaced to '='

https://youtrack.jetbrains.com/issue/KTOR-2057

When the server returns 302 with the URL has '%3D' (inside query part), the Ktor replaces '%3D' with '=' so some server returns invalid content (in this case, 403).

Test code:

import io.ktor.client.*
import io.ktor.client.features.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import kotlinx.coroutines.runBlocking

fun main(): Unit = runBlocking {
    val url = "https://dl.bintray.com/anatawa12/maven/com/anatawa12/forge/ForgeGradle/1.2-1.0.0/ForgeGradle-1.2-1.0.0-javadoc.jar"

    // also in CIO
    //val factory = io.ktor.client.engine.cio.CIO
    val factory = io.ktor.client.engine.apache.Apache
    val clientNoFollow = HttpClient(io.ktor.client.engine.cio.CIO) {
        followRedirects = false
        expectSuccess = false
    }
    val response = clientNoFollow.get<HttpResponse>(url)
    println("status: " + response.status)
    println("location:  " + response.headers["Location"])
    println("location has %3D: " + response.headers["Location"]!!.contains("%3D"))
    check(response.headers["Location"]!!.contains("%3D"))

    val clientWithFollow = HttpClient(io.ktor.client.engine.cio.CIO)
    try {
        val got = clientWithFollow.get<ByteArray>(url)
    } catch (e: ResponseException) {
        println("error: " + e)
        println("error url: " + e.response.request.url)
        println("error url has %3D: " + e.response.request.url.toString().contains("%3D"))
    }
}

Log:

status: 302 
location:  https://d29vzk4ow07wi7.cloudfront.net/d133d0ab57f0e1a996fa1367eb3e5c7ebbd1860a5d505a69791d7746457acb0a?response-content-disposition=attachment%3Bfilename%3D%22ForgeGradle-1.2-1.0.0-javadoc.jar%22&Policy=eyJTdGF0ZW1lbnQiOiBbeyJSZXNvdXJjZSI6Imh0dHAqOi8vZDI5dnprNG93MDd3aTcuY2xvdWRmcm9udC5uZXQvZDEzM2QwYWI1N2YwZTFhOTk2ZmExMzY3ZWIzZTVjN2ViYmQxODYwYTVkNTA1YTY5NzkxZDc3NDY0NTdhY2IwYT9yZXNwb25zZS1jb250ZW50LWRpc3Bvc2l0aW9uPWF0dGFjaG1lbnQlM0JmaWxlbmFtZSUzRCUyMkZvcmdlR3JhZGxlLTEuMi0xLjAuMC1qYXZhZG9jLmphciUyMiIsIkNvbmRpdGlvbiI6eyJEYXRlTGVzc1RoYW4iOnsiQVdTOkVwb2NoVGltZSI6MTYxMjkzNzUyOX0sIklwQWRkcmVzcyI6eyJBV1M6U291cmNlSXAiOiIwLjAuMC4wLzAifX19XX0_&Signature=ch~WD7z9cBluu3KWX2pIsmCd7pfVQ~WnM2QEg6wLuDPFi5pr2e4DnHApdAX9A92dxJW68WYllbKB1pNRkJ6RjtW~3eip545DnUcSBYGT1vfiaxNzp80QYsg~EUo~l4eHFYVoywXXPNgEPRXPIZ2vHGv7H7aeGJ5fbhzyunSmdstRnfUpfKLL5XmsDjpvVY4RYy1NSHHG70BU3y6UP1nqdu1hEdzBhRFKwZ~0uj8~2S4OF6Daaj71jkRWF49TQS~aNpvrkaAZojUilWEwppXZNcCekXu7Bt95oJDESsNQf0bu0gDw5eNtAfy2ZzN~a~lXVTV3ORy3kVanNwiVJzcf~g__&Key-Pair-Id=APKAIFKFWOMXM2UMTSFA
location has %3D: true
error: io.ktor.client.features.ClientRequestException: Client request(https://d29vzk4ow07wi7.cloudfront.net/d133d0ab57f0e1a996fa1367eb3e5c7ebbd1860a5d505a69791d7746457acb0a?response-content-disposition=attachment%3Bfilename=%22ForgeGradle-1.2-1.0.0-javadoc.jar%22&Policy=eyJTdGF0ZW1lbnQiOiBbeyJSZXNvdXJjZSI6Imh0dHAqOi8vZDI5dnprNG93MDd3aTcuY2xvdWRmcm9udC5uZXQvZDEzM2QwYWI1N2YwZTFhOTk2ZmExMzY3ZWIzZTVjN2ViYmQxODYwYTVkNTA1YTY5NzkxZDc3NDY0NTdhY2IwYT9yZXNwb25zZS1jb250ZW50LWRpc3Bvc2l0aW9uPWF0dGFjaG1lbnQlM0JmaWxlbmFtZSUzRCUyMkZvcmdlR3JhZGxlLTEuMi0xLjAuMC1qYXZhZG9jLmphciUyMiIsIkNvbmRpdGlvbiI6eyJEYXRlTGVzc1RoYW4iOnsiQVdTOkVwb2NoVGltZSI6MTYxMjkzNzUzMH0sIklwQWRkcmVzcyI6eyJBV1M6U291cmNlSXAiOiIwLjAuMC4wLzAifX19XX0_&Signature=XwmQYLdJSkb~0fNr36ebj1vzn1KXmufRtaP9Mj9y9thRAtpAbyImJU-31VhtEhV56ijN2-tBtT5m0rNPSq-f6AEvngoEZURUUpE-vGVb1UFwiGnVnTuDKQJUvao3gZTj-fq9kRCLosJGYJiVbLG3GTXQKYoxL9fQh2ttwS3eFKAyFylcjyvsmSkEAekomfjB8OhUpgc~B6CE0Vg6aOm3ZBaKNAtfX4~cccnFrz4PB836WD68y8qX9jN5IQMCAiDy0881chyPIjGM7c30aycANw5c8StHSRy~gWo5WL7TGpq19X5q2pK-sT8Vq0I3AJJZ95XW9N3GWj0WR7IKqOQTAg__&Key-Pair-Id=APKAIFKFWOMXM2UMTSFA) invalid: 403 Forbidden. Text: "<?xml version="1.0" encoding="UTF-8"?><Error><Code>AccessDenied</Code><Message>Access denied</Message></Error>"
error url: https://d29vzk4ow07wi7.cloudfront.net/d133d0ab57f0e1a996fa1367eb3e5c7ebbd1860a5d505a69791d7746457acb0a?response-content-disposition=attachment%3Bfilename=%22ForgeGradle-1.2-1.0.0-javadoc.jar%22&Policy=eyJTdGF0ZW1lbnQiOiBbeyJSZXNvdXJjZSI6Imh0dHAqOi8vZDI5dnprNG93MDd3aTcuY2xvdWRmcm9udC5uZXQvZDEzM2QwYWI1N2YwZTFhOTk2ZmExMzY3ZWIzZTVjN2ViYmQxODYwYTVkNTA1YTY5NzkxZDc3NDY0NTdhY2IwYT9yZXNwb25zZS1jb250ZW50LWRpc3Bvc2l0aW9uPWF0dGFjaG1lbnQlM0JmaWxlbmFtZSUzRCUyMkZvcmdlR3JhZGxlLTEuMi0xLjAuMC1qYXZhZG9jLmphciUyMiIsIkNvbmRpdGlvbiI6eyJEYXRlTGVzc1RoYW4iOnsiQVdTOkVwb2NoVGltZSI6MTYxMjkzNzUzMH0sIklwQWRkcmVzcyI6eyJBV1M6U291cmNlSXAiOiIwLjAuMC4wLzAifX19XX0_&Signature=XwmQYLdJSkb~0fNr36ebj1vzn1KXmufRtaP9Mj9y9thRAtpAbyImJU-31VhtEhV56ijN2-tBtT5m0rNPSq-f6AEvngoEZURUUpE-vGVb1UFwiGnVnTuDKQJUvao3gZTj-fq9kRCLosJGYJiVbLG3GTXQKYoxL9fQh2ttwS3eFKAyFylcjyvsmSkEAekomfjB8OhUpgc~B6CE0Vg6aOm3ZBaKNAtfX4~cccnFrz4PB836WD68y8qX9jN5IQMCAiDy0881chyPIjGM7c30aycANw5c8StHSRy~gWo5WL7TGpq19X5q2pK-sT8Vq0I3AJJZ95XW9N3GWj0WR7IKqOQTAg__&Key-Pair-Id=APKAIFKFWOMXM2UMTSFA
error url has %3D: false

When the main thread executes runBlocking, using the iOS engine will cause a deadlock

Ktor fails to deliver response with error: failed with exception: kotlinx.coroutines.JobCancellationException: Parent job is Completed;

Core

How to track leaked buffers in ktor-io?

Expose TrailingSlashRouteSelector

UDPSocketTest.testBroadcastSuccessful[jvm] is failing

Docs

Duplicate entry "Features" in Server docs

Document usage of Bearer token in Http Client

Duplicate server `Features` Section on the Documentation Website

Wrong Tabs Name in Code Blocks

Infrastructure

Migrate to Dokka 1.4.0

Update Dokka: Dokka tasks fails with old dokka version and Gradle 7

Server

Support for Compression Extensions for WebSocket (RFC 7692)

https://youtrack.jetbrains.com/issue/KTOR-688

This issue was imported from GitHub issue: https://github.com/ktorio/ktor/issues/907

Origin Problem

It would be very useful if ktor-websockets gained support for Compression Extensions for WebSocket, as defined in RFC 7692. The WebSocket Subprotocol "ocpp2.0" (Open Charge Point Protocol version 2.0) requires this feature to be implemented at the server-side, specifically using the DEFLATE algorithm, which is included as the "permessage-deflate" extension in section 7 of the aforementioned RFC.

I guess there's probably a way to manually implement the handling of DEFLATE (de)compression according to this extension in application code on top of Ktor, but it would be much nicer if Ktor would gain integrated and transparent support for this extension in its WebSocket functionality, so this would work out of the box without requiring any application-specific programming.

Thank you in advance for considering this feature.

Proposed solution

We make the API for implementation and usage of the WebSocket extensions:

Using WebSocket extensions

Installation

To install and configure the extensions we provide 2 methods: extensions and install which can be used in the following way:

install(WebSockets) {
    extensions { /* WebSocketExtensionConfig.() -> Unit */
        install(MyWebSocketExtension) { /* MyWebSocketExtensionConfig.() -> Unit */
        /* Optional extension configuration. */ 
        }
    }
}

The extensions are used in order of installation. This way looks familiar to existing features installation API and works for client and server in the same way.

Check if an extension is in use

All installed extensions go through the negotiation process and only negotiated extensions are used for the request. We introduce WebSocketSession.extensions: : List<WebSocketExtension<*>> property with list of all extensions used by for the current session.

There are 2 methods to check if the extension is in use: WebSocketSession.extension and WebSocketSession.extensionOrNull:

webSocket("/echo") {
    val myExtension = extension(MyWebSocketException) // will throw if `MyWebSocketException` is not negotiated
    // or
    val myExtension = extensionOrNull(MyWebSocketException) ?: close() // will close the session if `MyWebSocketException` is not negotiated
}

This API is similar to the Ktor feature discovery with the feature(...) method.

Implementing new extension

There are 2 interfaces for implementing new extension: WebSocketExtension<ConfigType: Any> and WebSocketExtensionFactory<ConfigType : Any, ExtensionType : WebSocketExtension<ConfigType>>. The new extension can be made by implementing all of them. The single implementation is working for client and server as well.

Here is the example of how the simple frame logging extension can be implemented:

class FrameLoggerExtension(val logger: Logger) : WebSocketExtension<FrameLogger.Config> {

The feature has 2 groups of fields and methods. The first group is for extension negotiation:

    /** List of protocols will be send in client request for negotiation **/
    override val protocols: List<WebSocketExtensionHeader> = emptyList()
   
    /** 
      * This method will be called for the server and will process `requestedProtocols` from a client.
      * In the result it will return a list of extensions that the server agrees to use.
      */
    override fun serverNegotiation(requestedProtocols: List<WebSocketExtensionHeader>): List<WebSocketExtensionHeader> {
        logger.log("Server negotiation")
        return emptyList()
    }

    /**
      * This method will be called on the client with a list of protocols, produced by `serverNegotiation`. It will decide if these extensions should be used. 
      */ 
    override fun clientNegotiation(negotiatedProtocols: List<WebSocketExtensionHeader>): Boolean {
        logger.log("Client negotiation")
        return true
    }

The second group is the place for actual frame processing. Methods will take the frame and produce a new processed frame if necessary:

    override fun processOutgoingFrame(frame: Frame): Frame {
        logger.log("Process outgoing frame: $frame")
        return frame
    }

    override fun processIncomingFrame(frame: Frame): Frame {
        logger.log("Process incoming frame: $frame")
        return frame
    }

There are also some implementation details: the feature has Config and reference to the origin `factory.

    class Config {
        lateinit var logger: Logger
    }

    /**
    * Factory which can create current extension instance. 
    */
    override val factory: WebSocketExtensionFactory<Config, FrameLogger> = FrameLoggerExtension

The factory is usually implemented in companion object(similar to regular features):

    companion object : WebSocketExtensionFactory<Config, FrameLogger> {
        /* Key to discover installed extension instance */
        override val key: AttributeKey<FrameLogger> = AttributeKey("frame-logger")

        /** Occupied rsv bits.
         * If the extension occupies a bit, it can't be used in other installed extensions. We use that bits to prevent feature conflicts(prevent installing multiple compression features). If you implementing a feature using some RFC, rsv occupied bits should be referenced there.
         */
        override val rsv1: Boolean = true

       /** Create feture instance. Will be called for each WebSocket session **/
        override fun install(config: Config.() -> Unit): FrameLogger {
            return FrameLogger(Config().apply(config).logger)
        }
    }
}

Status

This API is implemented in the ws-extensions branch. It marked with @ExperimentalWebSocketExtensionsApiannotation with the level error until we agree on the final design.

Netty: server freezes after start error

Routing: Add PutTyped and PatchTyped Overload

route("{...}") stopped matching root

Occasionally empty response using Netty + Jackson

https://youtrack.jetbrains.com/issue/KTOR-1973

Ktor 1.5.0 When you use netty + jackson content negotiation, couple of times in 10k requests you will have 200 with empty response. manual jackson mapping, or string response work properly. Also on jetty works properly(but you can see socket timeout instead of empty response)

gradle:

plugins {
    id 'org.jetbrains.kotlin.jvm' version '1.4.21'
}

group 'org.example'
version '1.0-SNAPSHOT'

repositories {
    mavenCentral()
}

dependencies {
    implementation "org.jetbrains.kotlin:kotlin-stdlib"
    implementation("com.squareup.okhttp3:okhttp:4.9.0")
    implementation("io.ktor:ktor-server-netty:1.5.0")
    implementation("io.ktor:ktor-jackson:1.5.0")
}

server

import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
import io.ktor.application.call
import io.ktor.application.install
import io.ktor.features.ContentNegotiation
import io.ktor.http.ContentType
import io.ktor.jackson.JacksonConverter
import io.ktor.response.respond
import io.ktor.routing.get
import io.ktor.routing.routing
import io.ktor.server.engine.embeddedServer
import io.ktor.server.netty.Netty
import kotlinx.coroutines.delay
import java.util.UUID
import java.util.UUID.randomUUID

fun main() {
    embeddedServer(Netty, 8081) {
        install(ContentNegotiation) {
            register(ContentType.Application.Json, JacksonConverter(objectmapper = jacksonObjectMapper()))
        }
        routing {
            get("/json") {
                delay(10)
                call.respond(Response(randomUUID()))
            }
        }
    }.start(wait = true)
}

data class Response(
    val id: UUID
)

client

import kotlinx.coroutines.Dispatchers.IO
import kotlinx.coroutines.async
import kotlinx.coroutines.isActive
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.supervisorScope
import kotlinx.coroutines.withContext
import okhttp3.OkHttpClient
import okhttp3.Request
import java.util.concurrent.atomic.AtomicLong

val counter: AtomicLong = AtomicLong()

val request: Request = Request.Builder()
    .url("http://localhost:8081/json")
    .build()

fun main(): Unit = runBlocking {
    val clients = (1..10).map { it to OkHttpClient() }

    withContext(IO) {
        supervisorScope {
            clients.map { (idx, client) ->
                async {
                    while (isActive) {
                        val r = runCatching {
                            client.newCall(request).execute()
                        }
                        if ((r.getOrNull()?.body?.string() ?: "").isBlank()) {
                            println("$idx: I'm blank on ${counter.get()} try ${r.getOrNull()}")
                        }
                        if (counter.incrementAndGet() % 10000L == 0L) {
                            println("$idx: OK on ${counter.get()} try")
                        }
                    }
                }
            }
        }
    }
}

Example of log:

7: I'm blank on 8299 try Response{protocol=http/1.1, code=200, message=OK, url=http://localhost:8081/json}
2: OK on 10000 try
5: I'm blank on 10620 try Response{protocol=http/1.1, code=200, message=OK, url=http://localhost:8081/json}
6: I'm blank on 16593 try Response{protocol=http/1.1, code=200, message=OK, url=http://localhost:8081/json}
10: OK on 20000 try
8: I'm blank on 21634 try Response{protocol=http/1.1, code=200, message=OK, url=http://localhost:8081/json}
1: I'm blank on 22057 try Response{protocol=http/1.1, code=200, message=OK, url=http://localhost:8081/json}
7: I'm blank on 22574 try Response{protocol=http/1.1, code=200, message=OK, url=http://localhost:8081/json}
9: I'm blank on 27737 try Response{protocol=http/1.1, code=200, message=OK, url=http://localhost:8081/json}
5: I'm blank on 27759 try Response{protocol=http/1.1, code=200, message=OK, url=http://localhost:8081/json}
10: OK on 30000 try
...

call.respond() will not check or apply ContentNegotiation for some types

Other

Add an option to disable URL Encoding

aSocket().bind() sometimes throws Already bound SocketException

https://youtrack.jetbrains.com/issue/KTOR-638

This issue was imported from GitHub issue: https://github.com/ktorio/ktor/issues/1049

Ktor Version

1.1.3

Ktor Engine Used

Netty, Socket

JVM Version, Operating System and Relevant Context

openjdk version "10.0.2" 2018-07-17, Ubuntu 18.04.2 LTS

Feedback

It's hard to reproduce, the problem appears and disappears without observable reasons. I have a server starting two Netty instances and one UDP socket

fun Application.main() {
    embeddedServer(Netty, port = 18080) {
        routing {
            get("/") {
                call.respondText("Hello World from what is supposed to be WWW server!", ContentType.Text.Plain)
            }
        }
    }.start()
    embeddedServer(Netty, port = 18090) {
        routing {
            get("/") {
                call.respondText("Hello World from what is supposed to be RESt server!", ContentType.Text.Plain)
            }
        }
    }.start()
    runBlocking {
        org.looksworking.ha.controller.Application.logger.info("Starting UDP")
        val server = aSocket(ActorSelectorManager(Dispatchers.IO))
            .udp()
            .bind(InetSocketAddress("0.0.0.0", 18070))
        while (true) {
            println(server.incoming.receive().packet.readText())
        }
    }
}

Console output:

...
Starting UDP
Exception in thread "main" java.lang.reflect.InvocationTargetException
	at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
	at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.base/java.lang.reflect.Method.invoke(Method.java:564)
	at kotlin.reflect.jvm.internal.calls.CallerImpl$Method.callMethod(CallerImpl.kt:97)
	at kotlin.reflect.jvm.internal.calls.CallerImpl$Method$Static.call(CallerImpl.kt:106)
	at kotlin.reflect.jvm.internal.KCallableImpl.call(KCallableImpl.kt:106)
	at kotlin.reflect.jvm.internal.KCallableImpl.callDefaultMethod$kotlin_reflect_api(KCallableImpl.kt:152)
	at kotlin.reflect.jvm.internal.KCallableImpl.callBy(KCallableImpl.kt:110)
	at io.ktor.server.engine.ApplicationEngineEnvironmentReloading.callFunctionWithInjection(ApplicationEngineEnvironmentReloading.kt:349)
	at io.ktor.server.engine.ApplicationEngineEnvironmentReloading.executeModuleFunction(ApplicationEngineEnvironmentReloading.kt:299)
	at io.ktor.server.engine.ApplicationEngineEnvironmentReloading.instantiateAndConfigureApplication(ApplicationEngineEnvironmentReloading.kt:275)
	at io.ktor.server.engine.ApplicationEngineEnvironmentReloading.createApplication(ApplicationEngineEnvironmentReloading.kt:127)
	at io.ktor.server.engine.ApplicationEngineEnvironmentReloading.start(ApplicationEngineEnvironmentReloading.kt:247)
	at io.ktor.server.netty.NettyApplicationEngine.start(NettyApplicationEngine.kt:106)
	at io.ktor.server.netty.NettyApplicationEngine.start(NettyApplicationEngine.kt:18)
	at io.ktor.server.engine.ApplicationEngine$DefaultImpls.start$default(ApplicationEngine.kt:52)
	at io.ktor.server.netty.EngineMain.main(EngineMain.kt:17)
Caused by: java.net.SocketException: Already bound
	at java.base/sun.nio.ch.Net.translateToSocketException(Net.java:136)
	at java.base/sun.nio.ch.DatagramSocketAdaptor.bind(DatagramSocketAdaptor.java:93)
	at io.ktor.network.sockets.UDPSocketBuilder.bind(Builders.kt:150)
	at io.ktor.network.sockets.UDPSocketBuilder.bind$default(Builders.kt:141)
	at org.looksworking.ha.controller.AppKt$main$3.invokeSuspend(App.kt:44)
	at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:32)
	at kotlinx.coroutines.DispatchedTask.run(Dispatched.kt:233)
	at kotlinx.coroutines.EventLoopImplBase.processNextEvent(EventLoop.kt:116)
	at kotlinx.coroutines.BlockingCoroutine.joinBlocking(Builders.kt:76)
	at kotlinx.coroutines.BuildersKt__BuildersKt.runBlocking(Builders.kt:53)
	at kotlinx.coroutines.BuildersKt.runBlocking(Unknown Source)
	at kotlinx.coroutines.BuildersKt__BuildersKt.runBlocking$default(Builders.kt:35)
	at kotlinx.coroutines.BuildersKt.runBlocking$default(Unknown Source)
	at org.looksworking.ha.controller.AppKt.main(App.kt:38)
	... 18 more
Caused by: java.nio.channels.AlreadyBoundException
	at java.base/sun.nio.ch.DatagramChannelImpl.bind(DatagramChannelImpl.java:669)
	at java.base/sun.nio.ch.DatagramSocketAdaptor.bind(DatagramSocketAdaptor.java:91)
	... 30 more

I checked many times - no other instance is running, no ports are busy. At the same time, tcp ports are successfully taken, while this problem with udp socket sometimes persists even after reboot. And then just goes away without any changes. Is it possible that like in most upvoted answer here, ktor sometimes creates an already bound socket?