Use gzip compression for data sent from agent

build.gradle.kts

@@ -11,6 +11,7 @@ plugins {
     alias(libs.plugins.versions.plugin)
     alias(libs.plugins.talaiot.base)
     alias(libs.plugins.liquibase.gradle)
+    id("com.louiscad.complete-kotlin") version "1.1.0"
 }
 
 val profile = properties.getOrDefault("save.profile", "dev") as String

gradle/libs.versions.toml

@@ -85,6 +85,7 @@ jackson-module-kotlin = { module = "com.fasterxml.jackson.module:jackson-module-
 ktor-client-core = { module = "io.ktor:ktor-client-core", version.ref = "ktor" }
 ktor-client-curl = { module = "io.ktor:ktor-client-curl", version.ref = "ktor" }
 ktor-client-serialization = { module = "io.ktor:ktor-client-serialization", version.ref = "ktor" }
+ktor-client-encoding = { module = "io.ktor:ktor-client-encoding", version.ref = "ktor" }
 ktor-client-mock = { module = "io.ktor:ktor-client-mock", version.ref = "ktor" }
 
 # database

save-agent/build.gradle.kts

@@ -28,6 +28,7 @@ kotlin {
                 implementation(libs.ktor.client.core)
                 implementation(libs.ktor.client.curl)
                 implementation(libs.ktor.client.serialization)
+                implementation(libs.ktor.client.encoding)
                 implementation(libs.kotlinx.serialization.properties)
                 implementation(libs.okio)
                 implementation(libs.kotlinx.datetime)

save-agent/src/linuxX64Main/kotlin/org/cqfn/save/agent/Main.kt

@@ -13,6 +13,7 @@ import org.cqfn.save.core.logging.logType
 import generated.SAVE_CLOUD_VERSION
 import io.ktor.client.HttpClient
 import io.ktor.client.features.HttpTimeout
+import io.ktor.client.features.compression.ContentEncoding
 import io.ktor.client.features.json.JsonFeature
 import io.ktor.client.features.json.serializer.KotlinxSerializer
 import platform.posix.SIGTERM
@@ -61,6 +62,9 @@ fun main() {
         install(HttpTimeout) {
             requestTimeoutMillis = config.requestTimeoutMillis
         }
+        install(ContentEncoding) {
+            gzip()
+        }
     }
     val saveAgent = SaveAgent(config, httpClient)
     runBlocking {

save-agent/src/linuxX64Main/kotlin/org/cqfn/save/agent/utils/FileUtils.kt

@@ -7,6 +7,44 @@ package org.cqfn.save.agent.utils
 import okio.FileNotFoundException
 import okio.FileSystem
 import okio.Path.Companion.toPath
+import platform.zlib.*
+
+import kotlinx.cinterop.UByteVar
+import kotlinx.cinterop.allocArray
+import kotlinx.cinterop.cValuesOf
+import kotlinx.cinterop.cstr
+import kotlinx.cinterop.memScoped
+import kotlinx.cinterop.pointed
+import kotlinx.cinterop.ptr
+import kotlinx.cinterop.readBytes
+import kotlinx.cinterop.reinterpret
+import kotlinx.cinterop.value
+
+/**
+ * @param s
+ * @return
+ */
+fun deflate(s: String): ByteArray = memScoped {
+    // val defstream: z_stream = z_stream()
+    // defstream.zalloc = Z_NULL
+    // defstream.zfree = Z_NULL
+    // defstream.avail_in = s.length.toUInt()  // size of input
+    // defstream.next_in = UByteVarOf<UByte>(s.cstr.ptr.rawValue).ptr
+    // defstream.avail_in = s.length.toUInt()  // size of input
+    val out = allocArray<UByteVar>(s.length)
+    // defstream.next_out = UByteVarOf<UByte>(out.rawValue).ptr
+    // deflateInit(defstream.ptr, Z_BEST_COMPRESSION)
+    // platform.zlib.deflate(defstream.ptr, Z_FINISH)
+    // deflateEnd(defstream.ptr)
+    val destLen = cValuesOf(s.length).ptr
+    compress(
+        out,
+        destLen.reinterpret(),
+        s.cstr.ptr.reinterpret(),
+        s.length.toULong()
+    )
+    return@memScoped out.readBytes(destLen.pointed.value)
+}
 
 /**
  * Read file as a list of strings

save-cloud-common/src/commonMain/kotlin/org/cqfn/save/utils/Utils.kt

@@ -0,0 +1,7 @@
+package org.cqfn.save.utils
+
+/**
+ * @param default
+ * @return
+ */
+fun String?.ifNullOrEmpty(default: () -> String) = (this ?: "").ifBlank(default)

save-orchestrator/src/main/kotlin/org/cqfn/save/orchestrator/filters/GzipDecodingFilter.kt

@@ -0,0 +1,12 @@
+package org.cqfn.save.orchestrator.filters
+
+import org.springframework.web.server.ServerWebExchange
+import org.springframework.web.server.WebFilter
+import org.springframework.web.server.WebFilterChain
+import reactor.core.publisher.Mono
+
+class GzipDecodingFilter : WebFilter {
+    override fun filter(exchange: ServerWebExchange, chain: WebFilterChain): Mono<Void> {
+        TODO("Not yet implemented")
+    }
+}