Sync from next

Author: soywiz

gradle.properties

@@ -13,8 +13,8 @@ coroutinesVersion=1.5.0
 
 # korlibs
 klockVersion=2.2.0
-kdsVersion=2.2.0
-kmemVersion=2.2.0
+kdsVersion=2.2.1
+kmemVersion=2.2.1
 kryptoVersion=2.2.0
 kloggerVersion=2.2.0
 

gradle/wrapper/gradle-wrapper.jar

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.1.1-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

gradle/wrapper/gradle-wrapper.properties

@@ -72,7 +72,7 @@ case "`uname`" in
   Darwin* )
     darwin=true
     ;;
-  MINGW* )
+  MSYS* | MINGW* )
     msys=true
     ;;
   NONSTOP* )

gradlew

@@ -2,6 +2,7 @@
 
 package com.soywiz.korio.async
 
+import com.soywiz.kds.*
 import com.soywiz.kds.iterators.*
 import com.soywiz.klock.*
 import com.soywiz.korio.lang.*
@@ -21,8 +22,8 @@ abstract class BaseSignal<T, THandler>(val onRegister: () -> Unit = {}) {
 		}
 	}
 
-	protected var handlers = ArrayList<Node>()
-	protected var handlersToRemove = ArrayList<Node>()
+	protected var handlers = FastArrayList<Node>()
+	protected var handlersToRemove = FastArrayList<Node>()
 	val listenerCount: Int get() = handlers.size
     val hasListeners get() = listenerCount > 0
 	fun clear() = handlers.clear()
@@ -126,7 +127,7 @@ fun <TI, TO> Signal<TI>.mapSignal(transform: (TI) -> TO): Signal<TO> {
 operator fun Signal<Unit>.invoke() = invoke(Unit)
 
 suspend fun Iterable<Signal<*>>.waitOne(): Any? = suspendCancellableCoroutine { c ->
-	val closes = arrayListOf<Closeable>()
+	val closes = FastArrayList<Closeable>()
 	for (signal in this) {
 		closes += signal.once {
 			closes.close()

korio/src/commonMain/kotlin/com/soywiz/korio/async/Signal.kt

@@ -31,12 +31,12 @@ interface CompressionMethod {
 }
 
 @UseExperimental(KorioExperimentalApi::class)
-suspend fun CompressionMethod.uncompress(i: AsyncInputStreamWithLength, o: AsyncOutputStream): Unit = uncompress(BitReader(i), o)
+suspend fun CompressionMethod.uncompress(i: AsyncInputStream, o: AsyncOutputStream): Unit = uncompress(BitReader(i), o)
 @UseExperimental(KorioExperimentalApi::class)
-suspend fun CompressionMethod.compress(i: AsyncInputStreamWithLength, o: AsyncOutputStream, context: CompressionContext = CompressionContext()): Unit = compress(BitReader(i), o, context)
+suspend fun CompressionMethod.compress(i: AsyncInputStream, o: AsyncOutputStream, context: CompressionContext = CompressionContext()): Unit = compress(BitReader(i), o, context)
 
-suspend fun CompressionMethod.uncompressStream(input: AsyncInputStreamWithLength): AsyncInputStream = asyncStreamWriter { output -> uncompress(input, output) }
-suspend fun CompressionMethod.compressStream(input: AsyncInputStreamWithLength, context: CompressionContext = CompressionContext()): AsyncInputStream = asyncStreamWriter { output -> compress(input, output, context) }
+suspend fun CompressionMethod.uncompressStream(input: AsyncInputStream): AsyncInputStream = asyncStreamWriter { output -> uncompress(input, output) }
+suspend fun CompressionMethod.compressStream(input: AsyncInputStream, context: CompressionContext = CompressionContext()): AsyncInputStream = asyncStreamWriter { output -> compress(input, output, context) }
 
 fun CompressionMethod.uncompress(i: SyncInputStream, o: SyncOutputStream) = runBlockingNoSuspensions {
 	uncompress(i.toAsyncInputStream(), o.toAsyncOutputStream())
@@ -50,5 +50,5 @@ fun ByteArray.uncompress(method: CompressionMethod, outputSizeHint: Int = this.s
 fun ByteArray.compress(method: CompressionMethod, context: CompressionContext = CompressionContext(), outputSizeHint: Int = (this.size * 1.1).toInt()): ByteArray =
 	MemorySyncStreamToByteArray(outputSizeHint) { method.compress(this@compress.openSync(), this, context) }
 
-suspend fun AsyncInputStreamWithLength.uncompressed(method: CompressionMethod): AsyncInputStream = method.uncompressStream(this)
-suspend fun AsyncInputStreamWithLength.compressed(method: CompressionMethod, context: CompressionContext = CompressionContext()): AsyncInputStream = method.compressStream(this, context)
+suspend fun AsyncInputStream.uncompressed(method: CompressionMethod): AsyncInputStream = method.uncompressStream(this)
+suspend fun AsyncInputStream.compressed(method: CompressionMethod, context: CompressionContext = CompressionContext()): AsyncInputStream = method.compressStream(this, context)

korio/src/commonMain/kotlin/com/soywiz/korio/compression/CompressionMethod.kt

@@ -8,7 +8,7 @@ import com.soywiz.korio.stream.*
 import kotlin.math.*
 
 @KorioExperimentalApi
-open class BitReader(val s: AsyncInputStreamWithLength) : AsyncInputStreamWithLength {
+open class BitReader(val s: AsyncInputStream) : AsyncInputStreamWithLength {
 	@PublishedApi
 	internal var bitdata = 0
 	@PublishedApi
@@ -112,6 +112,6 @@ open class BitReader(val s: AsyncInputStreamWithLength) : AsyncInputStreamWithLe
 	//suspend fun readBytesExact(count: Int): ByteArray = abytes(count)
 
 	override suspend fun getPosition(): Long = sbuffers.read
-	override suspend fun getLength(): Long = s.getLength()
+	override suspend fun getLength(): Long = (s as? AsyncGetLengthStream)?.getLength() ?: error("Length not available on Stream")
 }
 

korio/src/commonMain/kotlin/com/soywiz/korio/compression/util/BitReader.kt

@@ -52,8 +52,8 @@ class ObjectMapper {
 	fun <T : Any> toTyped(clazz: KClass<T>, obj: Any?): T {
 		val typer = _typers[clazz]
 		return when {
-			typer != null -> typer(typeCtx, obj) as T
-			fallbackTyper != null && obj != null -> fallbackTyper!!(clazz, obj) as T
+			typer != null -> typer(typeCtx, obj).fastCastTo<T>()
+			fallbackTyper != null && obj != null -> fallbackTyper!!(clazz, obj).fastCastTo<T>()
 			else -> invalidArg("Unregistered $clazz")
 		}
 	}
@@ -139,4 +139,4 @@ class ObjectMapper {
 	}
 }
 
-val Mapper = ObjectMapper()
+val Mapper = ObjectMapper()

korio/src/commonMain/kotlin/com/soywiz/korio/dynamic/mapper/ObjectMapper.kt

@@ -85,7 +85,14 @@ interface AsyncServer: AsyncCloseable {
 	suspend fun accept(): AsyncClient
 
 	suspend fun listen(handler: suspend (AsyncClient) -> Unit): Closeable {
-		val job = async(coroutineContext) { while (true) handler(accept()) }
+		val job = async(coroutineContext) {
+            while (true) {
+                val client = accept()
+                launchImmediately(coroutineContext) {
+                    handler(client)
+                }
+            }
+		}
 		return Closeable { job.cancel() }
 	}
 

korio/src/commonMain/kotlin/com/soywiz/korio/net/AsyncSocketFactory.kt

@@ -170,13 +170,22 @@ interface Http {
 
 		override fun toString(): String = "Headers(${toListGrouped().joinToString(", ")})"
 
+        fun toHttpHeaderString(extraLine: Boolean = true) = buildString {
+            for ((key, value) in items) {
+                append("$key: $value\r\n")
+            }
+            if (extraLine) append("\r\n")
+        }
+
         class Builder {
             private val items = arrayListOf<Pair<String, String>>()
-            fun put(key: String, value: String) = run { items += key to value }
+            fun put(key: String, value: String) { items += key to value }
             fun build() = Headers(items)
         }
 
         companion object {
+            operator fun invoke(block: Builder.() -> Unit): Headers = Builder().apply(block).build()
+
             fun build(block: Builder.() -> Unit): Headers = Builder().apply(block).build()
 
 			fun fromListMap(map: Map<String?, List<String>>): Headers {

korio/src/commonMain/kotlin/com/soywiz/korio/net/http/Http.kt

@@ -2,6 +2,8 @@ package com.soywiz.korio.net.http
 
 import com.soywiz.kds.*
 import com.soywiz.korio.async.*
+import com.soywiz.korio.compression.deflate.GZIP
+import com.soywiz.korio.compression.uncompressed
 import com.soywiz.korio.concurrent.atomic.*
 import com.soywiz.korio.lang.*
 import com.soywiz.korio.net.*
@@ -23,9 +25,33 @@ abstract class HttpClient protected constructor() {
 		val status: Int,
 		val statusText: String,
 		val headers: Http.Headers,
-		val content: AsyncInputStream
+		val rawContent: AsyncInputStream,
+        val content: AsyncInputStream
 	) {
 		val success = status < 400
+
+        companion object {
+            suspend operator fun invoke(
+                status: Int,
+                statusText: String,
+                headers: Http.Headers,
+                rawContent: AsyncInputStream,
+            ): Response {
+                val contentEncoding = (headers["Content-Encoding"] ?: "").lowercase().trim()
+                return Response(
+                    status,
+                    statusText,
+                    headers,
+                    rawContent,
+                    when (contentEncoding) {
+                        "" -> rawContent
+                        "gzip" -> rawContent.uncompressed(GZIP)
+                        else -> error("Unsupported Content-Encoding '$contentEncoding'")
+                    }
+                )
+            }
+        }
+
 		suspend fun readAllBytes(): ByteArray {
 			//println(content)
 			val allContent = content.readAll()
@@ -180,8 +206,9 @@ fun HttpClient.delayed(ms: Long) = DelayedHttpClient(ms, this)
 
 class FakeHttpClient(val redirect: HttpClient? = null) : HttpClient() {
 	val log = arrayListOf<String>()
+    private val defaultContent = "LogHttpClient.response".toByteArray(UTF8).openAsync()
 	var defaultResponse =
-		HttpClient.Response(200, "OK", Http.Headers(), "LogHttpClient.response".toByteArray(UTF8).openAsync())
+		HttpClient.Response(200, "OK", Http.Headers(), defaultContent, defaultContent)
 	private val rules = LinkedHashMap<Rule, ArrayList<ResponseBuilder>>()
 
 	override suspend fun requestInternal(
@@ -233,7 +260,7 @@ class FakeHttpClient(val redirect: HttpClient? = null) : HttpClient() {
 		fun notFound(content: String = "404 - Not Found") = response(content, code = 404)
 		fun internalServerError(content: String = "500 - Internal Server Error") = response(content, code = 500)
 
-		internal fun buildResponse() = HttpClient.Response(
+		internal suspend fun buildResponse() = HttpClient.Response(
             responseCode,
             HttpStatusMessage(responseCode),
             responseHeaders,

korio/src/commonMain/kotlin/com/soywiz/korio/net/http/HttpClient.kt

@@ -43,8 +43,10 @@ class FakeHttpClientEndpoint(val defaultMessage: String = "{}") : HttpClientEndp
 	private var responsePointer = 0
 	private val responses = arrayListOf<HttpClient.Response>()
 
-	private fun getResponse(code: Int, content: String) =
-		HttpClient.Response(code, HttpStatusMessage.CODES[code] ?: "Code$code", Http.Headers(), content.openAsync())
+	private fun getResponse(code: Int, content: String): HttpClient.Response {
+        val contentAsync = content.openAsync()
+        return HttpClient.Response(code, HttpStatusMessage.CODES[code] ?: "Code$code", Http.Headers(), contentAsync, contentAsync)
+    }
 
 	fun addResponse(code: Int, content: String) {
 		responses += getResponse(code, content)