async

context

DefaultWebSocketSession

Application.Kt

webSocket("/update") {
        connections += this
        try {
            while (true) {
                when (val frame = incoming.receive()) {
                    is Frame.Text -> {
                        val text = frame.readText()
                        // Send message to all the connections, except the messenger connection.
                        for (conn in connections) {
                            if (conn != this) {
                                conn.outgoing.send(Frame.Text(text))
                            }
                        }
                    }
                }
            }
        } catch (e: ClosedReceiveChannelException) {
            <http://log.info|log.info>("connection closed. ignore.")
        }
        finally {
            connections -= this
        }
    }
}

DefaultWebSocketSession

ktor-client

multiplatform

formData{}

append

file

install(CORS) {
        method(HttpMethod.Options)
        method(HttpMethod.Patch)
        method(HttpMethod.Delete)
        headersOf(HttpHeaders.AccessControlAllowOrigin, "*")
        headersOf(
            HttpHeaders.AccessControlAllowMethods to listOf(
                HttpMethod.Get.value,
                HttpMethod.Post.value,
                HttpMethod.Put.value,
                HttpMethod.Patch.value,
                HttpMethod.Delete.value,
                HttpMethod.Head.value,
                HttpMethod.Options.value
            ),
            HttpHeaders.AccessControlAllowHeaders to listOf(
                HttpHeaders.Origin, HttpHeaders.ContentType, HttpHeaders.XAuthToken
            )
        )
        anyHost()
    }

ktor

Access to fetch at '<http://192.168.43.218:8080/v0.1.0/auth/users/exists>' from origin '<http://localhost:8088>' has been blocked by CORS policy: Response to preflight request doesn't pass access control check: No 'Access-Control-Allow-Origin' header is present on the requested resource. If an opaque response serves your needs, set the request's mode to 'no-cors' to fetch the resource with CORS disabled.

withContext

<http://log.info|log.info>("going to execute request $callsite")
withContext(MyContextThingy()) {
 <http://log.info|log.info>("in first context")
}
<http://log.info|log.info>("back from context")
val res: HttpResponse = withContext(MyContextThingy()) {
 <http://log.info|log.info>("top of context")
 val response: HttpResponse = httpClient.request {
  url.takeFrom(this@DruidClient.url)
  method = <http://HttpMethod.Post|HttpMethod.Post>
  contentType(ContentType.Application.Json)
  body = req
 }
 <http://log.info|log.info>("after request")
 response
}
<http://log.info|log.info>("after WC")
res

after request

after WC

Ktor

1.4.0

native-mt

CIO

const val kotlin = "1.4.0"
    const val kotlinxCoroutines = "1.3.9-native-mt"
    const val ktor = "1.4.0"
    const val kotlinxSerialization = "1.0.0-RC"

link("/libs/package/css/somepackage.min.css","stylesheet")

link(npm("something))

server

authentication

oauth

routing

error

route("/login-callback") {
    param("error"){
       handle(errorHandler)
    }
    authenticate("my-oauth") {
        handle(successHandler)
    }
}

param("error")

Failed to find HTTP client engine implementation in the classpath: consider adding client engine dependency. See <https://ktor.io/clients/http-client/engines.html>

class ApiClient(
    private val engine: HttpClientEngine
) {
    private val client = HttpClient(engine)
}

CIO

Ios

KotlinxSerializer

commonMain {
    implementation("io.ktor:ktor-client-core:1.4.0")
    implementation("io.ktor:ktor-client-json:1.4.0")
    implementation("io.ktor:ktor-client-logging:1.4.0")
    implementation("io.ktor:ktor-client-serialization:1.4.0")
}

client.get<MyWrapper<SomeModel>>(...)

1.3.8-native-mt-1.4.0-rc

ktor-client-core-native

java.io.EOFException
        at okio.RealBufferedSource.require(RealBufferedSource.kt:201)
        at okio.RealBufferedSource.readByte(RealBufferedSource.kt:210)
        at okhttp3.internal.ws.WebSocketReader.readHeader(WebSocketReader.kt:119)
        at okhttp3.internal.ws.WebSocketReader.processNextFrame(WebSocketReader.kt:102)
        at okhttp3.internal.ws.RealWebSocket.loopReader(RealWebSocket.kt:293)
        at okhttp3.internal.ws.RealWebSocket$connect$1.onResponse(RealWebSocket.kt:195)
        at okhttp3.internal.connection.RealCall$AsyncCall.run(RealCall.kt:504)
        at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1113)
        at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:588)
        at java.lang.Thread.run(Thread.java:818)

val commonMain by getting {
            dependencies {
                implementation(kotlin("stdlib-common"))
                implementation(project(":backend-frontend-shared"))
                implementation("io.ktor:ktor-client-core:$ktor_version")
                implementation("io.ktor:ktor-client-websockets:$ktor_version")
                implementation("io.ktor:ktor-client-serialization:$ktor_version")
                implementation("io.ktor:ktor-client-logging:$ktor_version")
            }
        }
        val androidMain by getting {
            dependencies {
                implementation(kotlin("stdlib"))
                implementation("io.ktor:ktor-client-websockets-jvm:$ktor_version")
                implementation("io.ktor:ktor-client-serialization-jvm:$ktor_version")
                implementation("io.ktor:ktor-client-okhttp:$ktor_version")
                implementation("io.ktor:ktor-client-logging-jvm:$ktor_version")
            }
        }

HttpClient {
            install(WebSockets)
        }.ws(
            method = HttpMethod.Get,
            host = "192.168.0.38",
            port = 8080,
            path = CHAT_WS_PATH
        ) {
            try {
                val frame = incoming.receive()
            } catch (e: Exception) {
                //" Here's the crash
            }
        }

HttpCallValidator

val client = HttpClient(OkHttp) {
        expectSuccess = false        
        
        install(HttpCallValidator) {
            validateResponse { response ->  throw RuntimeException("Response not valid") }
        }
}

@Throws(RuntimeException::class) 
suspend fun myBestRequest(): MyResponseObj = client.get {...}

try {
        val response = myBestRequest()
        Result.success(response)
} catch (cause: Throwable) {
        Result.failure(cause)
}