install(StatusPages)

routing {
        header(HttpHeaders.Host, "localhost:8080") {
            route("/") {
                handle {
                    call.respondText("Hello world")
                }
            }
            install(StatusPages) {
                status(HttpStatusCode.NotFound) { status ->
                    call.respondText("Not found!")
                }
            }
        }
    }

    routing {
        header(HttpHeaders.Host, "another-host:8080") {
            route("/") {
                handle {
                    call.respondText("Hello another world")
                }
            }
            install(StatusPages) {
                status(HttpStatusCode.NotFound) { status ->
                    call.respondText("No other world found!")
                }
            }
        }
    }

PUT

io.ktor.client.call.NoTransformationFoundException: No transformation found: class <http://io.ktor.utils.io|io.ktor.utils.io>.ByteBufferChannel (Kotlin reflection is not available) -> class xx.yy.api.NoContent (Kotlin reflection is not available)

ClientRequestException

val httpClientMock = HttpClient(MockEngine) {
            HttpResponseValidator { }
            install(JsonFeature) {
                serializer = GsonSerializer()
            }
            engine {
                addHandler { request ->
                    val page = request.url.parameters["page"]!!.toInt()

                    when {
                        page < 38 -> {
                            val t = ContentType.Application.Json.toString()
                            val headers = headersOf("Content-Type" to listOf(t))
                            TextContent(reposJson, ContentType.Application.Json)
                            respond(reposJson, headers = headers)
                        }
                        else -> throw "I can't ctor the exception"
                    }

                }
            }
        }

java.lang.NoClassDefFoundError: Failed resolution of: Lio/ktor/client/features/json/JsonFeature;

Engine doesn’t support io.ktor.client.features.HttpTimeout$Feature@5c8a5ca9

Consider installing io.ktor.client.features.HttpTimeout$Feature@157a2816 feature because the request requires it to be installed

<section  data-markdown> ... </section>

suspend inline fun <reified T> post(authKey: String, url: String, data: Any): T? {
    val response = <http://_client.post|_client.post><HttpResponse>(url) {
        header("Authorization", "Bearer $authKey")
        contentType(ContentType.Application.Json)
        body = data
    }

    when (response.status.value) {
        in 300..399 -> throw RedirectResponseException(response)
        in 400..499 -> throw ClientRequestException(response)
        in 500..599 -> throw ServerResponseException(response)
    }

    if (response.status.value >= 600) {
        throw ResponseException(response)
    }

    return response.receive<T>()
}

@Test
fun test() {
  val client = HttpClient()
  runBlocking {
    println("start")
    val result: String = client.get("<https://www.google.com/>")
    println("result=$result")
  }
}

implementation("io.ktor:ktor-client-ios:1.5.1")

org.jetbrains.kotlinx:kotlinx-coroutines-core:1.4.2-native-mt

strictly

Exception doesn't match @Throws-specified class list and thus isn't propagated from Kotlin to Objective-C/Swift as NSError

@Throws(Throwable::class)

ktor-client-serialization

kotlinx-serialization-json

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

Cannot resolve org.jetbrains.kotlinx:kotlinx-serialization-json:1.0.1

Caused by: org.eclipse.aether.resolution.DependencyResolutionException: Could not find artifact org.jetbrains.kotlinx:kotlinx-serialization-json:jar:1.0.1 in central (<https://repo.maven.apache.org/maven2>)
    at org.eclipse.aether.internal.impl.DefaultRepositorySystem.resolveDependencies (DefaultRepositorySystem.java:352)
    at org.apache.maven.project.DefaultProjectDependenciesResolver.resolve (DefaultProjectDependenciesResolver.java:202)

<packaging>pom</packaging>

<dependency>
<groupId>org.jetbrains.kotlinx</groupId>
<artifactId>kotlinx-serialization-json</artifactId>
<version>1.0.1</version>
<scope>compile</scope>
</dependency>

client.submitFormWithBinaryData<FaceResponse> {
    method = <http://HttpMethod.Post|HttpMethod.Post>
    url(IMAGE_URL)
    headers {
        this["x-api-key"] = "my_api_key_here"
    }
    parameter(
        "mode", "request_mode"
    )
    body = MultiPartFormDataContent(formData {
        append("image", request.image)
    })
}

XClient

CIOEngine

MockEngine

ContinuationInterceptor

GlobalScope.embeddedServer(factory = Jetty, ... , parentCoroutineContext = MyContinuationInterceptor())

withContext(MyContinuationInterceptor()) { ... }

SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See <http://www.slf4j.org/codes.html#StaticLoggerBinder> for further details.

var myVariable : String? = null

fun main(args: Array<String>): Unit {
    myVariable = "Hello World"
    io.ktor.server.netty.EngineMain.main(args)
}

@Suppress("unused") // Referenced in application.conf
@kotlin.jvm.JvmOverloads
fun Application.module(testing: Boolean = false) {
    // myVariable is null here
}