birb-integrated-bench/src/Application.kt

package com.kmlabz.k8s

import io.ktor.application.*
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)

@KtorExperimentalAPI
@Suppress("unused")
@kotlin.jvm.JvmOverloads
fun Application.module(testing: Boolean = false) {
    runBlocking {
        var startTime: Instant
        var currTimeStamp: Instant
        var elapsed = Duration.ZERO
        val targetTime = Duration.ofSeconds(System.getenv("WAITTIME").toLong())
        var currIter = 0
        val timestamps = LinkedHashMap<Int, Instant>()
        val uploaders = LinkedList<Uploader>()
        val processResults = ProcessResults()
        var currUploader: Uploader
        environment.monitor.subscribe(ApplicationStarted) {
            GlobalScope.launch {
                println("Starting benchmark setup")
                startTime = Instant.now()
                while (elapsed < targetTime) {
                    currIter += 1
                    currUploader = Uploader()
                    currUploader.currIteration = currIter
                    currUploader.buildRequest()
                    uploaders.add(currUploader)
                    currTimeStamp = Instant.now()
                    elapsed = Duration.between(startTime, currTimeStamp)
                }
                println("Starting benchmark")
                for (uploader in uploaders) {
                    uploader.sendRequest()
                }
                println("Data scrubbing")
                for (uploader in uploaders) {
                    timestamps[uploader.currIteration] = uploader.respInstant
                }
                println("Benchmark ended")
                processResults.mapToProcess = timestamps
                processResults.process()
            }
        }
    }
}