Curl engine build experiment

Author: trueangle

.github/workflows/buildLinux64.yml

@@ -0,0 +1,24 @@
+name: Build LinuxArm64
+on:
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+
+      - name: Configure JDK
+        uses: actions/setup-java@v1
+        with:
+          java-version: 17
+
+      - name: Run build
+      - run: ./gradlew build
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v3
+        with:
+          name: kotlin-native-arm-build
+          path: sample/build/bin/linuxArm64/releaseExecutable

lambda-runtime/build.gradle.kts

@@ -13,7 +13,8 @@ kotlin {
             implementation(libs.kotlin.serialization.json)
             implementation(libs.kotlin.io.core)
             implementation(libs.kotlin.date.time)
-            implementation(libs.ktor.client.cio)
+            //implementation(libs.ktor.client.cio)
+            implementation(libs.ktor.client.curl)
             implementation(libs.ktor.client.logging)
             implementation(libs.ktor.content.negotiation)
             implementation(libs.ktor.content.json)

lambda-runtime/src/commonMain/kotlin/io/github/trueangle/knative/lambda/runtime/LambdaRuntime.kt

@@ -9,10 +9,9 @@ import io.github.trueangle.knative.lambda.runtime.handler.LambdaStreamHandler
 import io.github.trueangle.knative.lambda.runtime.log.Log
 import io.github.trueangle.knative.lambda.runtime.log.LogLevel
 import io.ktor.client.HttpClient
-import io.ktor.client.engine.cio.CIO
+import io.ktor.client.engine.curl.Curl
 import io.ktor.client.plugins.HttpTimeout
 import io.ktor.client.plugins.contentnegotiation.ContentNegotiation
-import io.ktor.client.plugins.logging.LogLevel as KtorLogLevel
 import io.ktor.client.plugins.logging.Logger
 import io.ktor.client.plugins.logging.Logging
 import io.ktor.http.content.OutgoingContent.WriteChannelContent
@@ -24,9 +23,11 @@ import io.ktor.utils.io.writeStringUtf8
 import kotlinx.coroutines.runBlocking
 import kotlinx.serialization.json.Json
 import kotlin.system.exitProcess
+import kotlin.time.TimeSource
+import io.ktor.client.plugins.logging.LogLevel as KtorLogLevel
 
 object LambdaRuntime {
-    private val httpClient = HttpClient(CIO) {
+    private val httpClient = HttpClient(Curl) {
         install(HttpTimeout)
         install(ContentNegotiation) {
             json(Json { explicitNulls = false })
@@ -44,6 +45,7 @@ object LambdaRuntime {
     internal val client = LambdaClient(httpClient)
 
     inline fun <reified I, reified O> run(crossinline initHandler: () -> LambdaHandler<I, O>) = runBlocking {
+        val initMark = TimeSource.Monotonic.markNow()
         val handler = try {
             initHandler()
         } catch (e: Exception) {
@@ -52,13 +54,16 @@ object LambdaRuntime {
             client.reportError(e.asInitError())
             exitProcess(1)
         }
+        println("initHandler time " + initMark.elapsedNow().inWholeMilliseconds)
 
         val inputTypeInfo = typeInfo<I>()
         val outputTypeInfo = typeInfo<O>()
 
         while (true) {
             try {
+                val mark = TimeSource.Monotonic.markNow()
                 val (event, context) = client.retrieveNextEvent<I>(inputTypeInfo)
+                println("retrieveNextEvent time " + mark.elapsedNow().inWholeMilliseconds)
 
                 with(Log) {
                     setContext(context)
@@ -71,8 +76,13 @@ object LambdaRuntime {
                     client.streamResponse(context, response)
                 } else {
                     handler as LambdaBufferedHandler<I, O>
+                    val handlerMark = TimeSource.Monotonic.markNow()
                     val response = bufferedResponse(context) { handler.handleRequest(event, context) }
+                    println("handleRequest time " + handlerMark.elapsedNow().inWholeMilliseconds)
+
+                    val sendResponseMark = TimeSource.Monotonic.markNow()
                     client.sendResponse(context, response, outputTypeInfo)
+                    println("sendResponse time " + sendResponseMark.elapsedNow().inWholeMilliseconds)
                 }
             } catch (e: LambdaRuntimeException) {
                 Log.error(e)

lambda-runtime/src/commonMain/kotlin/io/github/trueangle/knative/lambda/runtime/api/LambdaRuntimeClient.kt

@@ -24,27 +24,37 @@ import io.ktor.http.contentType
 import io.ktor.util.reflect.TypeInfo
 import kotlinx.serialization.json.Json
 import kotlin.time.Duration.Companion.minutes
+import kotlin.time.TimeSource
 import io.ktor.http.ContentType.Application.Json as ContentTypeJson
 
 @PublishedApi
 internal class LambdaClient(private val httpClient: HttpClient) {
     private val invokeUrl = "http://${LambdaEnvironment.RUNTIME_API}/2018-06-01/runtime"
 
     suspend fun <T> retrieveNextEvent(bodyType: TypeInfo): Pair<T, Context> {
+        val requestMark = TimeSource.Monotonic.markNow()
         val response = httpClient.get {
             url("${invokeUrl}/invocation/next")
             timeout {
                 requestTimeoutMillis = 60 * 1000 * 30 // todo
             }
         }
+        println("retrieveNextEvent requestMark " + requestMark.elapsedNow().inWholeMilliseconds)
 
+        val contextMark = TimeSource.Monotonic.markNow()
         val context = contextFromResponseHeaders(response)
+
+        println("retrieveNextEvent contextMark " + contextMark.elapsedNow().inWholeMilliseconds)
+
+        val bodyMark = TimeSource.Monotonic.markNow()
         val body = try {
             response.body(bodyType) as T
         } catch (e: Exception) {
             throw EventBodyParseException(cause = e, context = context)
         }
 
+        println("retrieveNextEvent bodyMark " + bodyMark.elapsedNow().inWholeMilliseconds)
+
         return body to context
     }
 

sample/build.gradle.kts

@@ -8,9 +8,22 @@ kotlin {
     val isArm64 = System.getProperty("os.arch") == "aarch64"
     val nativeTarget = if (isArm64) linuxArm64() else linuxX64()
 
-    nativeTarget.binaries {
-        executable {
-            entryPoint = "com.github.trueangle.knative.lambda.runtime.sample.main"
+    nativeTarget.apply {
+        /*compilations.getByName("main") {
+            cinterops {
+                val libcurl by creating {
+                    definitionFile.set(project.file("src/nativeInterop/cinterop/libcurl.def"))
+               *//*     packageName("com.github.trueangle.knative.lambda.runtime.sample.libcurl")
+                    compilerOpts("-I/path")
+                    includeDirs.allHeaders("path")*//*
+                }
+            }
+        }*/
+        binaries {
+            executable {
+                //linkerOpts = mutableListOf("-L/opt/homebrew/Cellar/curl/8.9.1/lib", "-I/opt/homebrew/Cellar/curl/8.9.1/include", "-lcurl")
+                entryPoint = "com.github.trueangle.knative.lambda.runtime.sample.main"
+            }
         }
     }
 

sample/src/nativeInterop/cinterop/libcurl.def

@@ -0,0 +1,6 @@
+package = libcurl
+headers = curl/curl.h
+headerFilter = curl/*
+
+#compilerOpts.linux = -I/opt/homebrew/Cellar/curl/8.9.1/include
+#linkerOpts.linux = -L/opt/homebrew/Cellar/curl/8.9.1/lib -lcurl

sample/src/nativeMain/kotlin/com/github/trueangle/knative/lambda/runtime/sample/main.kt

@@ -1,6 +1,6 @@
 package com.github.trueangle.knative.lambda.runtime.sample
 
-import com.github.trueangle.knative.lambda.runtime.sample.handler.ObjectBodyLambdaHandler
+import com.github.trueangle.knative.lambda.runtime.sample.handler.StringBodyLambdaHandler
 import io.github.trueangle.knative.lambda.runtime.LambdaRuntime
 
-fun main() = LambdaRuntime.run { ObjectBodyLambdaHandler() }
+fun main() = LambdaRuntime.run { StringBodyLambdaHandler() }