body

Any

@Serializable
class Foo(val bar: String)

@Test
fun test() {
    val any: Any = Foo("asd")
    Json.encodeToString(any).also { println(it) }
}

Secure

kotlinx.serialization.json.internal.JsonDecodingException: Unexpected JSON token at offset 66: Unexpected 'null' value instead of string literal
JSON input: {"id":1,"method":"/kv/routeNumberServiceManager0","params":["null","\"ENGLISH\""]}

implementation

testImplementation

val client = HttpClient {
    install(WebSockets)
}

client.webSocket(HttpMethod.Get, host, port, path) { … }

implementation "org.jetbrains.kotlinx:kotlinx-serialization-json:$serializationVersion"
implementation "io.ktor:ktor-client-serialization:$ktorVersion"

val createdAt = datetime("created_at").default(LocalDateTime.now())

jstack 45158 | grep Ktor-client-apache | wc -l                                                                                                                         
     125      // there are 125 threads generated !

jstack 45158 | grep Ktor-client-apache
                                                                                                                                 
"Ktor-client-apache" #19 daemon prio=5 os_prio=31 cpu=12.09ms elapsed=513.05s tid=0x0000000135bc4c00 nid=0x8403 runnable  [0x0000000172df2000]
"Ktor-client-apache" #20 daemon prio=5 os_prio=31 cpu=11.36ms elapsed=513.05s tid=0x0000000144e30200 nid=0x7b03 runnable  [0x0000000172ffe000]
...
...
"Ktor-client-apache" #143 daemon prio=5 os_prio=31 cpu=8.96ms elapsed=510.76s tid=0x0000000142a3d400 nid=0x1fe03 runnable  [0x0000000292bea000]
"Ktor-client-apache" #144 daemon prio=5 os_prio=31 cpu=7.24ms elapsed=510.76s tid=0x0000000142a3ce00 nid=0x21903 runnable  [0x0000000292df6000]

"Ktor-client-apache" #144 daemon prio=5 os_prio=31 cpu=8.90ms elapsed=591.80s tid=0x0000000142a3ce00 nid=0x21903 runnable  [0x0000000292df6000]
   java.lang.Thread.State: RUNNABLE
	at sun.nio.ch.KQueue.poll(java.base@15.0.2/Native Method)
	at sun.nio.ch.KQueueSelectorImpl.doSelect(java.base@15.0.2/KQueueSelectorImpl.java:122)
	at sun.nio.ch.SelectorImpl.lockAndDoSelect(java.base@15.0.2/SelectorImpl.java:129)
	- locked <0x00000006c6b79ec0> (a sun.nio.ch.Util$2)
	- locked <0x00000006c6b79e68> (a sun.nio.ch.KQueueSelectorImpl)
	at sun.nio.ch.SelectorImpl.select(java.base@15.0.2/SelectorImpl.java:141)
	at org.apache.http.impl.nio.reactor.AbstractIOReactor.execute(AbstractIOReactor.java:255)
	at org.apache.http.impl.nio.reactor.BaseIOReactor.execute(BaseIOReactor.java:104)
	at org.apache.http.impl.nio.reactor.AbstractMultiworkerIOReactor$Worker.run(AbstractMultiworkerIOReactor.java:591)
	at java.lang.Thread.run(java.base@15.0.2/Thread.java:832)

@Named 
class SomeBean {
  private val ktorClient = HttpClient {
    followRedirects = false
    expectSuccess = false
  }
}

engine

threadsCount

<ktor.version>1.6.1</ktor.version>

      <dependency>
        <groupId>io.ktor</groupId>
        <artifactId>ktor-client-apache</artifactId>
        <version>${ktor.version}</version>
      </dependency>

openjdk version "15.0.2" 2021-01-19
OpenJDK Runtime Environment Zulu15.29+15-CA (build 15.0.2+7)
OpenJDK 64-Bit Server VM Zulu15.29+15-CA (build 15.0.2+7, mixed mode)

val bytes = this
val byteBufferSize = 1024 * 100
val byteBuffer = ByteArray(byteBufferSize)

do {
    val currentRead = bytes.readAvailable(byteBuffer, 0, byteBufferSize)
    if (currentRead > 0) {
        println("received: $currentRead")
    }

} while (currentRead > 0)

MockEngine

runBlockingTest

IllegalStateException: This job has not completed yet

com.papsign.ktor.openapigen

route("stuff"){
       jwtAuth {
            route("thing").post<Unit, Response, Request, UserPrincipal>(
                info("Do a thing")
            ) { _, request ->
                thingService.createThing(
                    principal().username,
                    request.thingName
                )
                status(HttpStatusCode.NoContent)
                respond(Response())
            }
        }
}

route("stuff"){
       jwtAuth {
            route("thing").post<Unit, Unit, Request, UserPrincipal>(
                info("Do a thing")
            ) { _, request ->
                thingService.createThing(
                    principal().username,
                    request.thingName
                )
                status(HttpStatusCode.NoContent)
                respond(Unit)
            }
        }
}

fun createHttpClient(
    authConfig: HttpAuthConfig? = null,
    connectionTimeout: Int = 5_000
) = HttpClient(Apache) {
    if (authConfig != null) {
        Auth {
            basic {
                credentials {
                    BasicAuthCredentials(authConfig.username, authConfig.password)
                }
            }
        }
    }
    engine {
        socketTimeout = connectionTimeout
        connectTimeout = connectionTimeout
        connectionRequestTimeout = connectionTimeout * 2
    }
    expectSuccess = false
}

...

fun HttpClient.withJsonSupport() = config {
    Json {
        serializer = KotlinxSerializer(kotlinx.serialization.json.Json {
            prettyPrint = true
            isLenient = true
            ignoreUnknownKeys = true
        })
        accept(ContentType.Any)
    }
}

...

private val jsonClient = createHttpClient().withJsonSupport()

...

<http://jsonClient.post|jsonClient.post>("$url/stuff/thing") {
            headers {
                append(
                    HttpHeaders.Authorization,
                    "Bearer $jwtToken"
                )
            }
            contentType(ContentType.Application.Json)
            body = Request(thingName)
        }

install(CORS) {
        header(HttpHeaders.Range)
        header(HttpHeaders.XForwardedProto)
        header(HttpHeaders.AccessControlRequestHeaders)
        header("x-csrf-token")
        header("Authorization")
        anyHost()
        allowCredentials = true
        method(<http://HttpMethod.Post|HttpMethod.Post>)
        method(HttpMethod.Get)
        method(HttpMethod.Put)
        method(HttpMethod.Delete)
        method(HttpMethod.Head)
        method(HttpMethod.Options)
    }

log("BODY START")

private suspend fun logResponseBody(contentType: ContentType?, content: ByteReadChannel): Unit = with(logger) {
     log("BODY Content-Type: $contentType")
     log("BODY START")
     val message = content.tryReadText(contentType?.charset() ?: Charsets.UTF_8) ?: "[response body omitted]"
     log(message)
     log("BODY END")
}

install()