DoubleReceiveException

HttpReceivePipeline.After

run

true

build -t

Access to fetch at '<https://myserver/api/v1/csrf>' from origin '<http://localhost:8080>' has been blocked by CORS policy: No 'Access-Control-Allow-Origin' header is present on the requested resource.

private val jsonResponse = """
        {
          "offset": 0,
          "limit": 20,
          "available": 104,
          "items": [
            {
              "type": "news type",
              "title": "news title",
              "image": "news image",
              "link": "news link",
              "date": "1621807201000"
            }
          ]
        }
    """.trimIndent()

Json.decodeFromString<NewsList>(jsonResponse)

NewsList

MockEngine

kotlinx.serialization.json.internal.JsonDecodingException: Expected start of the array '[', but had 'EOF' instead
JSON input: .....ink": "news link",
      "date": "1621807201000"
    }
  ]
}

call.receiveText()

SecurityContextHolder

Auth

requestToken()

invalid_grant

This API is internal in ktor and should not be used. It could be removed or changed without notice.

append

ktor + docker

FROM openjdk:8-jdk
EXPOSE 8080:8080
RUN mkdir /app
COPY ./build/install/docker/ /app/
WORKDIR /app/bin
CMD ["./docker"]

FROM gradle:6-jdk8 AS build
COPY --chown=gradle:gradle . /home/gradle/src
WORKDIR /home/gradle/src
RUN gradle installDist --no-daemon

FROM openjdk:8-jdk
EXPOSE 8080:8080
RUN mkdir /app
COPY --from=build /home/gradle/src/build/install/docker/ /app/
WORKDIR /app/bin
CMD ["./docker"]

docker

embeddedServer(
        factory = Netty,
        port = 8080,
    ) {
        modules()
    }

embeddedServer(
        factory = Netty,
        port = 8080,
        module = Application::modules
    )

return@get

route("/test") {
            get {
                try {
                     // some logic
                    call.respond(HttpStatusCode.OK)
                }  catch (e: Exception) {
                     return@get call.respond(HttpStatusCode.InternalServerError) // here
                }
            }

logging

Logging

requestSequenceId

responseSequenceId

logRequest

logResponse

private var requestSequenceId: Int = 0
private var responseSequenceId: Int = 0
...
private suspend fun logRequest(request: HttpRequestBuilder): OutgoingContent? {
        if (<http://level.info|level.info>) {
            logger.log("REQUEST SEQUENCE ID: ${requestSequenceId++}")
...
private fun logResponse(response: HttpResponse) {
        if (<http://level.info|level.info>) {
            logger.log("RESPONSE SEQUENCE ID: ${responseSequenceId++}")

ktor-client

CIOEngine

engine {
    maxConnectionsCount = 250
    pipelining = true
    endpoint {
      maxConnectionsPerRoute = 100
      pipelineMaxSize = 20
      keepAliveTime = 5000
      connectTimeout = 5000
      connectAttempts = 5
      threadsCount = 20
    }
  }

pipielining = true

client.close()

client.use {}

HttpClient

HttpClient

client.use {}

kotlinx.coroutines.JobCancellationException: Parent job is Completed; job=JobImpl{Completed}@5e4f8454

get("/test") {
    launch {
        // do something
    }

    call.respond("Success")
}

Ambiguous coroutineContext due to CoroutineScope receiver of suspend function

suspend fun PipelineContext<Unit, ApplicationCall>.handleTest() {
    launch {
        // do something
    }

    call.respond("Success")
}

get("/test") {
    handleTest()
}