new concept

src/Application.kt

@@ -5,6 +5,8 @@ import io.ktor.util.*
 import kotlinx.coroutines.*
 import java.time.Duration
 import java.time.Instant
+import java.util.*
+import kotlin.collections.LinkedHashMap
 
 fun main(args: Array<String>): Unit = io.ktor.server.tomcat.EngineMain.main(args)
 
@@ -14,28 +16,30 @@ fun main(args: Array<String>): Unit = io.ktor.server.tomcat.EngineMain.main(args
 fun Application.module(testing: Boolean = false) {
     runBlocking {
         var startTime: Instant
-        var elapsed = Duration.ofSeconds(0)
+        var elapsed = Duration.ZERO
         val targetTime = Duration.ofSeconds(System.getenv("WAITTIME").toLong())
         var currIter = 0
         val timestamps = LinkedHashMap<Int, Instant>()
-        var currTimeStamp: Instant
-        val uploader = Uploader()
+        val uploaders = LinkedList<Uploader>()
         val processResults = ProcessResults()
         environment.monitor.subscribe(ApplicationStarted) {
+            GlobalScope.launch {
                 println("Starting benchmark")
                 startTime = Instant.now()
                 while (elapsed < targetTime) {
                     currIter += 1
-                GlobalScope.launch {
-                    uploader.uploadData(currIter)
-                    currTimeStamp = Instant.now()
-                    timestamps[currIter] = currTimeStamp
-                    elapsed = Duration.between(startTime, currTimeStamp)
+                    uploaders.add(Uploader(currIter))
                 }
+                for (uploader in uploaders) {
+                    uploader.sendRequest()
+                }
+                for (uploader in uploaders){
+                    timestamps[uploader.currIteration] = uploader.respInstant
                 }
                 println("Benchmark ended")
                 processResults.mapToProcess = timestamps
                 processResults.process()
             }
         }
+    }
 }

src/Uploader.kt

@@ -6,15 +6,21 @@ import io.ktor.client.*
 import io.ktor.client.engine.apache.*
 import io.ktor.client.request.*
 import io.ktor.client.request.forms.*
+import io.ktor.client.statement.*
 import io.ktor.http.*
 import io.ktor.http.content.*
 import io.ktor.util.*
 import java.io.File
+import java.time.Instant
 
-class Uploader(){
+class Uploader(currIteration: Int) {
     private val gson = GsonBuilder().setPrettyPrinting().create()
     private val inputSound = File("/app/wave.wav").readBytes()
-    val parts: List<PartData> = formData {
+    private lateinit var parts: List<PartData>
+    var respInstant : Instant = Instant.now()
+    var currIteration : Int = 0
+    fun buildRequest() {
+        parts = formData {
             val headersBuilder = HeadersBuilder()
             headersBuilder[HttpHeaders.ContentType] = "audio/wave"
             headersBuilder[HttpHeaders.ContentDisposition] = "filename=csirip.wav"
@@ -23,7 +29,7 @@ class Uploader(){
                 inputSound,
                 headersBuilder.build()
             )
-        val inputSvcApi = InputSvcApi("2020-02-02T02:02:02", 1)
+            val inputSvcApi = InputSvcApi("2020-02-02T02:02:02", currIteration)
             val jsonHeadersBuilder = HeadersBuilder()
             jsonHeadersBuilder[HttpHeaders.ContentType] = "application/json"
             this.append(
@@ -32,13 +38,13 @@ class Uploader(){
                 jsonHeadersBuilder.build()
             )
         }
-    @KtorExperimentalAPI
-    suspend fun uploadData(currIteration: Int) {
-        HttpClient(Apache).use { client ->
+    }
 
-            client.submitFormWithBinaryData<Unit>(formData = parts) {
-                url(System.getenv("URL") ?: "https://birb.k8s.kmlabz.com/benchmark")
-            }
+    @KtorExperimentalAPI
+    suspend fun sendRequest() {
+        HttpClient(Apache).post<HttpResponse>(System.getenv("URL") ?: "https://birb.k8s.kmlabz.com/benchmark") {
+            body = parts
         }
+        respInstant = Instant.now()
     }
 }