Merge branch 'fix/1.4.x'

sunny-chung · sunny-chung · commit 2bfed9f74cef · 2024-01-10T21:37:14.000+08:00
diff --git a/.gitignore b/.gitignore
@@ -1,3 +1,7 @@
+*.log
+/Releases
+/archived
+
 ### Gradle ###
 .gradle
 build/
diff --git a/README.md b/README.md
@@ -22,7 +22,7 @@ moment.
 
 - **macOS** - Stable since v1.2.0
 - **Windows** - Stable since v1.4.1
-- **Linux** - Beta. Known issue: horizontal scrolling is not working
+- **Linux** - Stable since v1.4.3
 
 ## Features
 
@@ -152,7 +152,6 @@ express your desired priorities in the issue tracker.
 - Example-level variables
 - Checking for version updates
 - Establish release builds (minified and without debug logs and symbols)
-- Streamlining building executables for multiple OS
 
 ## Development
 
diff --git a/src/jvmMain/kotlin/com/sunnychung/application/multiplatform/hellohttp/manager/NetworkClientManager.kt b/src/jvmMain/kotlin/com/sunnychung/application/multiplatform/hellohttp/manager/NetworkClientManager.kt
@@ -210,7 +210,7 @@ class NetworkClientManager : CallDataStore {
         val oldCallId = requestExampleToCallMapping.put(requestExampleId, callData.id)
         if (oldCallId != null) {
             CoroutineScope(Dispatchers.IO).launch {
-                callDataMap[oldCallId]?.cancel?.invoke()
+                callDataMap[oldCallId]?.cancel?.invoke(null)
                 callDataMap.remove(oldCallId)
             }
         }
@@ -231,7 +231,7 @@ class NetworkClientManager : CallDataStore {
     }
 
     fun cancel(selectedRequestExampleId: String) {
-        getCallDataByRequestExampleId(selectedRequestExampleId)?.let { it.cancel() }
+        getCallDataByRequestExampleId(selectedRequestExampleId)?.let { it.cancel(null) }
     }
 
     private fun <T> emptySharedFlow() = emptyFlow<T>().shareIn(CoroutineScope(Dispatchers.IO), SharingStarted.Eagerly)
diff --git a/src/jvmMain/kotlin/com/sunnychung/application/multiplatform/hellohttp/network/AbstractTransportClient.kt b/src/jvmMain/kotlin/com/sunnychung/application/multiplatform/hellohttp/network/AbstractTransportClient.kt
@@ -11,6 +11,8 @@ import com.sunnychung.application.multiplatform.hellohttp.network.util.TrustAllS
 import com.sunnychung.application.multiplatform.hellohttp.util.log
 import com.sunnychung.application.multiplatform.hellohttp.util.uuidString
 import com.sunnychung.lib.multiplatform.kdatetime.KInstant
+import kotlinx.coroutines.CoroutineExceptionHandler
+import kotlinx.coroutines.CoroutineName
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.delay
@@ -68,6 +70,10 @@ abstract class AbstractTransportClient internal constructor(callDataStore: CallD
         }
     }
 
+    protected fun coroutineExceptionHandler() = CoroutineExceptionHandler { context, ex ->
+        log.w(ex) { "Uncaught exception in coroutine ${context[CoroutineName.Key] ?: "-"}" }
+    }
+
     internal fun createSslContext(sslConfig: SslConfig): CustomSsl {
         return SSLContext.getInstance("TLS")
             .run {
@@ -97,17 +103,17 @@ abstract class AbstractTransportClient internal constructor(callDataStore: CallD
                     val cert = CertificateFactory.getInstance("X.509").generateCertificate(it.certificate.content.inputStream())
                     val key = KeyFactory.getInstance("RSA").generatePrivate(PKCS8EncodedKeySpec(it.privateKey.content))
 
-                        val password = uuidString()
-                        val keyStore = KeyStore.getInstance("JKS")
-                        keyStore.load(null)
-                        keyStore.setCertificateEntry("cert", cert)
-                        keyStore.setKeyEntry("key", key, password.toCharArray(), arrayOf(cert))
-                        val keyManagers = KeyManagerFactory.getInstance("SunX509")
-                            .apply { init(keyStore, password.toCharArray()) }
-                            .keyManagers
-                        keyManagers.first()
-                    }
-                    init(keyManager?.let { arrayOf(it) }, trustManager?.let { arrayOf(it) }, SecureRandom())
+                    val password = uuidString()
+                    val keyStore = KeyStore.getInstance("JKS")
+                    keyStore.load(null)
+                    keyStore.setCertificateEntry("cert", cert)
+                    keyStore.setKeyEntry("key", key, password.toCharArray(), arrayOf(cert))
+                    val keyManagers = KeyManagerFactory.getInstance("SunX509")
+                        .apply { init(keyStore, password.toCharArray()) }
+                        .keyManagers
+                    keyManagers.first()
+                }
+                init(keyManager?.let { arrayOf(it) }, trustManager?.let { arrayOf(it) }, SecureRandom())
                 CustomSsl(sslContext = this, keyManager = keyManager, trustManager = trustManager)
             }
     }
diff --git a/src/jvmMain/kotlin/com/sunnychung/application/multiplatform/hellohttp/network/ApacheHttpTransportClient.kt b/src/jvmMain/kotlin/com/sunnychung/application/multiplatform/hellohttp/network/ApacheHttpTransportClient.kt
@@ -13,13 +13,19 @@ import com.sunnychung.application.multiplatform.hellohttp.network.apache.Http2Fr
 import com.sunnychung.application.multiplatform.hellohttp.network.util.CallDataUserResponseUtil
 import com.sunnychung.application.multiplatform.hellohttp.util.log
 import com.sunnychung.lib.multiplatform.kdatetime.KInstant
+import com.sunnychung.lib.multiplatform.kdatetime.extension.seconds
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
 import org.apache.hc.client5.http.SystemDefaultDnsResolver
 import org.apache.hc.client5.http.async.methods.SimpleHttpResponse
 import org.apache.hc.client5.http.async.methods.SimpleResponseConsumer
@@ -44,6 +50,7 @@ import org.apache.hc.core5.http.nio.RequestChannel
 import org.apache.hc.core5.http.protocol.HttpContext
 import org.apache.hc.core5.http2.HttpVersionPolicy
 import org.apache.hc.core5.http2.config.H2Config
+import org.apache.hc.core5.http2.frame.FrameFlag
 import org.apache.hc.core5.http2.frame.FrameType
 import org.apache.hc.core5.http2.frame.RawFrame
 import org.apache.hc.core5.http2.hpack.HPackInspectHeader
@@ -54,8 +61,11 @@ import java.net.InetAddress
 import java.nio.ByteBuffer
 import java.security.Principal
 import java.security.cert.Certificate
+import java.util.Collections
 import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.atomic.AtomicBoolean
 import java.util.concurrent.atomic.AtomicInteger
+import kotlin.coroutines.CoroutineContext
 
 class ApacheHttpTransportClient(networkClientManager: NetworkClientManager) : AbstractTransportClient(networkClientManager) {
 
@@ -172,6 +182,9 @@ class ApacheHttpTransportClient(networkClientManager: NetworkClientManager) : Ab
             },
             object : H2InspectListener {
                 val suspendedHeaderFrames = ConcurrentHashMap<Int, H2HeaderFrame>()
+                val openedStreamIds = Collections.newSetFromMap(ConcurrentHashMap<Int, Boolean>())
+                val lock = Mutex()
+                val isCancelled = AtomicBoolean(false)
 
                 override fun onHeaderInputDecoded(connection: HttpConnection, streamId: Int?, headers: MutableList<HPackInspectHeader>) {
                     val serialized = http2FrameSerializer.serializeHeaders(headers)
@@ -211,6 +224,14 @@ class ApacheHttpTransportClient(networkClientManager: NetworkClientManager) : Ab
                     val type = FrameType.valueOf(frame.type)
                     log.d { "processFrame $streamId $type" }
                     if (type == FrameType.HEADERS) {
+                        if (frame.flags and FrameFlag.END_STREAM.value == 0) {
+                            openedStreamIds += streamId
+                        } else {
+                            openedStreamIds -= streamId
+                            if (openedStreamIds.isEmpty()) {
+                                checkForHangConnectionLater()
+                            }
+                        }
                         val frame = suspendedHeaderFrames.getOrPut(streamId) { H2HeaderFrame(streamId = streamId) }
                         frame.frameHeader = serialized
                         if (frame.isComplete()) {
@@ -232,6 +253,20 @@ class ApacheHttpTransportClient(networkClientManager: NetworkClientManager) : Ab
                     }
                 }
 
+                fun checkForHangConnectionLater() {
+                    CoroutineScope(Dispatchers.IO).launch {
+                        delay(3.seconds().toMilliseconds())
+                        lock.withLock {
+                            if (openedStreamIds.isEmpty() && !isCancelled.get()) {
+                                val message = "The connection has no active stream for some seconds, it appears to be hanging. Cancelling the connection."
+                                emitEvent(callId, message)
+                                callData.cancel(Exception(message))
+                                isCancelled.set(true)
+                            }
+                        }
+                    }
+                }
+
             }
         )
 
@@ -304,7 +339,7 @@ class ApacheHttpTransportClient(networkClientManager: NetworkClientManager) : Ab
             }
         }
 
-        CoroutineScope(Dispatchers.IO).launch {
+        CoroutineScope(Dispatchers.IO).launch(coroutineExceptionHandler()) {
             val callData = callData[callId]!!
             callData.waitForPreparation()
             log.d { "Call $callId is prepared" }
@@ -407,11 +442,15 @@ class ApacheHttpTransportClient(networkClientManager: NetworkClientManager) : Ab
 
                     })
 
-                    data.cancel = {
+                    data.cancel = { error ->
                         log.d { "Request to cancel the call" }
                         val cancelResult = call.cancel() // no use at all
                         log.d { "Cancel result = $cancelResult" }
                         httpClient.close(CloseMode.IMMEDIATE)
+
+                        // httpClient.close is buggy. Do not rely on it
+                        data.status = ConnectionStatus.DISCONNECTED
+                        this.cancel(error?.let { CancellationException(it.message, it) })
                     }
                 }
 
diff --git a/src/jvmMain/kotlin/com/sunnychung/application/multiplatform/hellohttp/network/GrpcTransportClient.kt b/src/jvmMain/kotlin/com/sunnychung/application/multiplatform/hellohttp/network/GrpcTransportClient.kt
@@ -547,7 +547,7 @@ class GrpcTransportClient(networkClientManager: NetworkClientManager) : Abstract
 
                 var (responseFlow, responseObserver) = flowAndStreamObserver<DynamicMessage>()
                 try {
-                    val cancel = {
+                    val cancel = { _: Throwable? ->
                         if (call.status.isConnectionActive()) {
                             try {
                                 responseObserver.onCompleted()
@@ -584,7 +584,7 @@ class GrpcTransportClient(networkClientManager: NetworkClientManager) : Abstract
                             log.d { "Response = ${responseJsonData.decodeToString()}" }
                         } catch (e: Throwable) {
                             setStreamError(e)
-                            call.cancel()
+                            call.cancel(e)
                         }
 
                         if (postFlightAction != null) {
@@ -604,7 +604,7 @@ class GrpcTransportClient(networkClientManager: NetworkClientManager) : Abstract
                                 requestObserver.onNext(request)
                             } catch (e: Throwable) {
                                 setStreamError(e)
-                                call.cancel()
+                                call.cancel(e)
                             }
                         }
                     }
@@ -618,7 +618,7 @@ class GrpcTransportClient(networkClientManager: NetworkClientManager) : Abstract
                                 if (!hasInvokedCancelDueToError) {
                                     hasInvokedCancelDueToError = true
                                     setStreamError(e)
-                                    call.cancel()
+                                    call.cancel(e)
                                 }
                             }
                         }
@@ -627,12 +627,12 @@ class GrpcTransportClient(networkClientManager: NetworkClientManager) : Abstract
                     fun initiateClientStreamableCall(requestObserver: StreamObserver<DynamicMessage>) {
                         call.sendPayload = buildSendPayloadFunction(requestObserver)
                         call.sendEndOfStream = buildSendEndOfStream(requestObserver)
-                        call.cancel = {
+                        call.cancel = { e ->
                             if (call.status.isConnectionActive()) {
                                 try {
                                     call.sendEndOfStream()
                                 } catch (_: Throwable) {}
-                                cancel()
+                                cancel(e)
                             }
                         }
                         // actually, at this stage it could be not yet connected
diff --git a/src/jvmMain/kotlin/com/sunnychung/application/multiplatform/hellohttp/network/TransportClient.kt b/src/jvmMain/kotlin/com/sunnychung/application/multiplatform/hellohttp/network/TransportClient.kt
@@ -43,7 +43,7 @@ class CallData(
     val optionalResponseSize: AtomicInteger,
     val response: UserResponse,
 
-    var cancel: () -> Unit,
+    var cancel: (Throwable?) -> Unit,
     var sendPayload: (String) -> Unit = {},
     var sendEndOfStream: () -> Unit = {},
 )

Original file line number	Diff line number	Diff line change
`@@ -210,7 +210,7 @@ class NetworkClientManager : CallDataStore {`
`210`	`210`	`val oldCallId = requestExampleToCallMapping.put(requestExampleId, callData.id)`
`211`	`211`	`if (oldCallId != null) {`
`212`	`212`	`CoroutineScope(Dispatchers.IO).launch {`
`213`		`- callDataMap[oldCallId]?.cancel?.invoke()`
	`213`	`+ callDataMap[oldCallId]?.cancel?.invoke(null)`
`214`	`214`	`callDataMap.remove(oldCallId)`
`215`	`215`	`}`
`216`	`216`	`}`
`@@ -231,7 +231,7 @@ class NetworkClientManager : CallDataStore {`
`231`	`231`	`}`
`232`	`232`
`233`	`233`	`fun cancel(selectedRequestExampleId: String) {`
`234`		`- getCallDataByRequestExampleId(selectedRequestExampleId)?.let { it.cancel() }`
	`234`	`+ getCallDataByRequestExampleId(selectedRequestExampleId)?.let { it.cancel(null) }`
`235`	`235`	`}`
`236`	`236`
`237`	`237`	`private fun <T> emptySharedFlow() = emptyFlow<T>().shareIn(CoroutineScope(Dispatchers.IO), SharingStarted.Eagerly)`
Original file line number	Diff line number	Diff line change
`@@ -547,7 +547,7 @@ class GrpcTransportClient(networkClientManager: NetworkClientManager) : Abstract`
`547`	`547`
`548`	`548`	`var (responseFlow, responseObserver) = flowAndStreamObserver<DynamicMessage>()`
`549`	`549`	`try {`
`550`		`- val cancel = {`
	`550`	`+ val cancel = { _: Throwable? ->`
`551`	`551`	`if (call.status.isConnectionActive()) {`
`552`	`552`	`try {`
`553`	`553`	`responseObserver.onCompleted()`
`@@ -584,7 +584,7 @@ class GrpcTransportClient(networkClientManager: NetworkClientManager) : Abstract`
`584`	`584`	`log.d { "Response = ${responseJsonData.decodeToString()}" }`
`585`	`585`	`} catch (e: Throwable) {`
`586`	`586`	`setStreamError(e)`
`587`		`- call.cancel()`
	`587`	`+ call.cancel(e)`
`588`	`588`	`}`
`589`	`589`
`590`	`590`	`if (postFlightAction != null) {`
`@@ -604,7 +604,7 @@ class GrpcTransportClient(networkClientManager: NetworkClientManager) : Abstract`
`604`	`604`	`requestObserver.onNext(request)`
`605`	`605`	`} catch (e: Throwable) {`
`606`	`606`	`setStreamError(e)`
`607`		`- call.cancel()`
	`607`	`+ call.cancel(e)`
`608`	`608`	`}`
`609`	`609`	`}`
`610`	`610`	`}`
`@@ -618,7 +618,7 @@ class GrpcTransportClient(networkClientManager: NetworkClientManager) : Abstract`
`618`	`618`	`if (!hasInvokedCancelDueToError) {`
`619`	`619`	`hasInvokedCancelDueToError = true`
`620`	`620`	`setStreamError(e)`
`621`		`- call.cancel()`
	`621`	`+ call.cancel(e)`
`622`	`622`	`}`
`623`	`623`	`}`
`624`	`624`	`}`
`@@ -627,12 +627,12 @@ class GrpcTransportClient(networkClientManager: NetworkClientManager) : Abstract`
`627`	`627`	`fun initiateClientStreamableCall(requestObserver: StreamObserver<DynamicMessage>) {`
`628`	`628`	`call.sendPayload = buildSendPayloadFunction(requestObserver)`
`629`	`629`	`call.sendEndOfStream = buildSendEndOfStream(requestObserver)`
`630`		`- call.cancel = {`
	`630`	`+ call.cancel = { e ->`
`631`	`631`	`if (call.status.isConnectionActive()) {`
`632`	`632`	`try {`
`633`	`633`	`call.sendEndOfStream()`
`634`	`634`	`} catch (_: Throwable) {}`
`635`		`- cancel()`
	`635`	`+ cancel(e)`
`636`	`636`	`}`
`637`	`637`	`}`
`638`	`638`	`// actually, at this stage it could be not yet connected`
Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ class CallData(`
`43`	`43`	`val optionalResponseSize: AtomicInteger,`
`44`	`44`	`val response: UserResponse,`
`45`	`45`
`46`		`- var cancel: () -> Unit,`
	`46`	`+ var cancel: (Throwable?) -> Unit,`
`47`	`47`	`var sendPayload: (String) -> Unit = {},`
`48`	`48`	`var sendEndOfStream: () -> Unit = {},`
`49`	`49`	`)`