Refactoring using detekt suggestions

theodolite-quarkus/src/main/kotlin/theodolite/benchmark/Benchmark.kt

 package theodolite.benchmark
 
-import theodolite.util.LoadDimension
 import theodolite.util.ConfigurationOverride
+import theodolite.util.LoadDimension
 import theodolite.util.Resource
 
 interface Benchmark {
-    fun buildDeployment(load: LoadDimension, res: Resource, configurationOverrides: List<ConfigurationOverride>): BenchmarkDeployment
+    fun buildDeployment(
+        load: LoadDimension,
+        res: Resource,
+        configurationOverrides: List<ConfigurationOverride>
+    ): BenchmarkDeployment
 }

theodolite-quarkus/src/main/kotlin/theodolite/benchmark/BenchmarkExecution.kt

@@ -3,7 +3,6 @@ package theodolite.benchmark
 import theodolite.util.ConfigurationOverride
 import kotlin.properties.Delegates
 
-
 class BenchmarkExecution {
     lateinit var name: String
     lateinit var benchmark: String

theodolite-quarkus/src/main/kotlin/theodolite/benchmark/KubernetesBenchmark.kt

@@ -9,14 +9,12 @@ import java.util.*
 
 class KubernetesBenchmark : Benchmark {
     lateinit var name: String
-    private lateinit var appResource: List<String>
-    private lateinit var loadGenResource: List<String>
-    private lateinit var resourceTypes: List<TypeName>
-    private lateinit var loadTypes: List<TypeName>
-    private lateinit var kafkaConfig: KafkaConfig
-    private lateinit var zookeeperConfig: HashMap<String,String>
-
-
+    lateinit var appResource: List<String>
+    lateinit var loadGenResource: List<String>
+    lateinit var resourceTypes: List<TypeName>
+    lateinit var loadTypes: List<TypeName>
+    lateinit var kafkaConfig: KafkaConfig
+    lateinit var zookeeperConfig: HashMap<String, String>
 
     private fun loadKubernetesResources(resources: List<String>): List<Pair<String, KubernetesResource>> {
         val basePath = "./../../../resources/main/yaml/"
@@ -31,7 +29,11 @@ class KubernetesBenchmark: Benchmark {
             }
     }
 
-    override fun buildDeployment(load: LoadDimension, res: Resource, configurationOverrides: List<ConfigurationOverride>): BenchmarkDeployment {
+    override fun buildDeployment(
+        load: LoadDimension,
+        res: Resource,
+        configurationOverrides: List<ConfigurationOverride>
+    ): BenchmarkDeployment {
         val resources = loadKubernetesResources(this.appResource + this.loadGenResource)
         val patcherManager = PatcherManager()
 
@@ -40,13 +42,19 @@ class KubernetesBenchmark: Benchmark {
         patcherManager.createAndApplyPatcher(load.getType(), this.loadTypes, resources, load.get().toString())
 
         // patch overrides
-        configurationOverrides.forEach{ override -> patcherManager.applyPatcher(listOf(override.patcher), resources, override.value)}
+        configurationOverrides.forEach { override ->
+            patcherManager.applyPatcher(
+                listOf(override.patcher),
+                resources,
+                override.value
+            )
+        }
 
         return KubernetesBenchmarkDeployment(
             resources = resources.map { r -> r.second },
             kafkaConfig = hashMapOf("bootstrap.servers" to kafkaConfig.bootstrapServer),
             zookeeperConfig = zookeeperConfig["server"].toString(),
-            topics = kafkaConfig.getKafkaTopics())
+            topics = kafkaConfig.getKafkaTopics()
+        )
     }
 }
-

theodolite-quarkus/src/main/kotlin/theodolite/benchmark/KubernetesBenchmarkDeployment.kt

@@ -32,6 +32,5 @@ class KubernetesBenchmarkDeployment(
         resources.forEach {
             kubernetesManager.remove(it)
         }
-
     }
 }

theodolite-quarkus/src/main/kotlin/theodolite/evaluation/SLOChecker.kt

 package theodolite.evaluation
 
-interface SLOChecker {
-}
+interface SLOChecker {}
\ No newline at end of file

theodolite-quarkus/src/main/kotlin/theodolite/execution/BenchmarkExecutor.kt

@@ -2,7 +2,10 @@ package theodolite.execution
 
 import mu.KotlinLogging
 import theodolite.benchmark.Benchmark
-import theodolite.util.*
+import theodolite.util.ConfigurationOverride
+import theodolite.util.LoadDimension
+import theodolite.util.Resource
+import theodolite.util.Results
 import java.time.Duration
 
 private val logger = KotlinLogging.logger {}
@@ -15,7 +18,12 @@ private val logger = KotlinLogging.logger {}
  * @property executionDuration
  * @constructor Create empty Benchmark executor
  */
-abstract class BenchmarkExecutor(val benchmark: Benchmark, val results: Results, val executionDuration: Duration, configurationOverrides: List<ConfigurationOverride>) {
+abstract class BenchmarkExecutor(
+    val benchmark: Benchmark,
+    val results: Results,
+    val executionDuration: Duration,
+    configurationOverrides: List<ConfigurationOverride>
+) {
 
     /**
      * Run a experiment for the given parametrization, evaluate the experiment and save the result.

theodolite-quarkus/src/main/kotlin/theodolite/execution/BenchmarkExecutorImpl.kt

 package theodolite.execution
 
 import theodolite.benchmark.Benchmark
-import theodolite.util.*
+import theodolite.util.ConfigurationOverride
+import theodolite.util.LoadDimension
+import theodolite.util.Resource
+import theodolite.util.Results
 import java.time.Duration
 
-class BenchmarkExecutorImpl(benchmark: Benchmark, results: Results, executionDuration: Duration, private val configurationOverrides: List<ConfigurationOverride>) : BenchmarkExecutor(benchmark, results, executionDuration, configurationOverrides) {
+class BenchmarkExecutorImpl(
+    benchmark: Benchmark,
+    results: Results,
+    executionDuration: Duration,
+    private val configurationOverrides: List<ConfigurationOverride>
+) : BenchmarkExecutor(benchmark, results, executionDuration, configurationOverrides) {
     override fun runExperiment(load: LoadDimension, res: Resource): Boolean {
         val benchmarkDeployment = benchmark.buildDeployment(load, res, this.configurationOverrides)
         benchmarkDeployment.setup()

theodolite-quarkus/src/main/kotlin/theodolite/execution/TheodoliteExecutor.kt

@@ -12,7 +12,8 @@ import java.time.Duration
 
 class TheodoliteExecutor(
     private val config: BenchmarkExecution,
-    private val kubernetesBenchmark: KubernetesBenchmark) {
+    private val kubernetesBenchmark: KubernetesBenchmark
+) {
 
     private fun buildConfig(): Config {
         val results = Results()
@@ -23,11 +24,17 @@ class TheodoliteExecutor(
 
         return Config(
             loads = config.load.loadValues.map { load -> LoadDimension(load, config.load.loadType) },
-           resources = config.resources.resourceValues.map { resource -> Resource(resource, config.resources.resourceType) },
+            resources = config.resources.resourceValues.map
+            { resource -> Resource(resource, config.resources.resourceType) },
             compositeStrategy = CompositeStrategy(
                 benchmarkExecutor = executor,
                 searchStrategy = strategyFactory.createSearchStrategy(executor, config.execution.strategy),
-               restrictionStrategies = strategyFactory.createRestrictionStrategy(results, config.execution.restrictions)))
+                restrictionStrategies = strategyFactory.createRestrictionStrategy(
+                    results,
+                    config.execution.restrictions
+                )
+            )
+        )
     }
 
     fun run() {

theodolite-quarkus/src/main/kotlin/theodolite/execution/TheodoliteYamlExecutor.kt

 package theodolite.execution
 
 import theodolite.benchmark.BenchmarkExecution
-import theodolite.util.YamlParser
 import theodolite.benchmark.KubernetesBenchmark
+import theodolite.util.YamlParser
 
 class TheodoliteYamlExecutor {
     fun run() {
         // load the BenchmarkExecution and the BenchmarkType
         val parser = YamlParser()
-        val benchmarkExecution = parser.parse("./../../../resources/main/yaml/testBenchmarkExecution.yaml", BenchmarkExecution::class.java) !!
-        val benchmark = parser.parse("./../../../resources/main/yaml/testBenchmarkType.yaml", KubernetesBenchmark::class.java) !!
+        val benchmarkExecution =
+            parser.parse("./../../../resources/main/yaml/testBenchmarkExecution.yaml", BenchmarkExecution::class.java)!!
+        val benchmark =
+            parser.parse("./../../../resources/main/yaml/testBenchmarkType.yaml", KubernetesBenchmark::class.java)!!
 
         val executor = TheodoliteExecutor(benchmarkExecution, benchmark)
         executor.run()

theodolite-quarkus/src/main/kotlin/theodolite/k8s/K8sManager.kt

@@ -6,7 +6,6 @@ import io.fabric8.kubernetes.api.model.Service
 import io.fabric8.kubernetes.api.model.apps.Deployment
 import io.fabric8.kubernetes.api.model.apps.StatefulSet
 import io.fabric8.kubernetes.client.NamespacedKubernetesClient
-import java.lang.IllegalArgumentException
 
 class K8sManager(private val client: NamespacedKubernetesClient) {
     fun deploy(resource: KubernetesResource) {

theodolite-quarkus/src/main/kotlin/theodolite/k8s/TopicManager.kt

@@ -4,7 +4,6 @@ import mu.KotlinLogging
 import org.apache.kafka.clients.admin.AdminClient
 import org.apache.kafka.clients.admin.ListTopicsResult
 import org.apache.kafka.clients.admin.NewTopic
-import java.util.*
 
 private val logger = KotlinLogging.logger {}
 

theodolite-quarkus/src/main/kotlin/theodolite/patcher/AbstractPatcher.kt

@@ -2,4 +2,8 @@ package theodolite.patcher
 
 import io.fabric8.kubernetes.api.model.KubernetesResource
 
-abstract class AbstractPatcher(k8sResource: KubernetesResource, container: String? = null, variableName: String? = null): Patcher
+abstract class AbstractPatcher(
+    k8sResource: KubernetesResource,
+    container: String? = null,
+    variableName: String? = null
+) : Patcher

theodolite-quarkus/src/main/kotlin/theodolite/patcher/EnvVarPatcher.kt

@@ -6,12 +6,18 @@ import io.fabric8.kubernetes.api.model.EnvVarSource
 import io.fabric8.kubernetes.api.model.KubernetesResource
 import io.fabric8.kubernetes.api.model.apps.Deployment
 
-class EnvVarPatcher(private val k8sResource: KubernetesResource, private val container: String, private val variableName: String): AbstractPatcher(k8sResource, container, variableName) {
+class EnvVarPatcher(
+    private val k8sResource: KubernetesResource,
+    private val container: String,
+    private val variableName: String
+) : AbstractPatcher(k8sResource, container, variableName) {
 
     override fun <String> patch(value: String) {
         if (k8sResource is Deployment) {
-                this.setEnv(k8sResource, this.container,
-                    mapOf(this.variableName to value) as Map<kotlin.String, kotlin.String>)
+            this.setEnv(
+                k8sResource, this.container,
+                mapOf(this.variableName to value) as Map<kotlin.String, kotlin.String>
+            )
         }
     }
 
@@ -43,6 +49,4 @@ class EnvVarPatcher(private val k8sResource: KubernetesResource, private val con
         workloadDeployment.spec.template.spec.containers.filter { it.name == containerName }
             .forEach { setContainerEnv(it, map) }
     }
-
-
 }

theodolite-quarkus/src/main/kotlin/theodolite/patcher/ImagePatcher.kt

@@ -4,7 +4,8 @@ import io.fabric8.kubernetes.api.model.KubernetesResource
 import io.fabric8.kubernetes.api.model.apps.Deployment
 import io.fabric8.kubernetes.api.model.apps.StatefulSet
 
-class ImagePatcher(private val k8sResource: KubernetesResource, private val container: String): AbstractPatcher(k8sResource, container) {
+class ImagePatcher(private val k8sResource: KubernetesResource, private val container: String) :
+    AbstractPatcher(k8sResource, container) {
 
     override fun <String> patch(imagePath: String) {
         if (k8sResource is Deployment) {

theodolite-quarkus/src/main/kotlin/theodolite/patcher/NodeSelectorPatcher.kt

@@ -3,7 +3,8 @@ package theodolite.patcher
 import io.fabric8.kubernetes.api.model.KubernetesResource
 import io.fabric8.kubernetes.api.model.apps.Deployment
 
-class NodeSelectorPatcher(private val k8sResource: KubernetesResource, private val variableName: String): AbstractPatcher(k8sResource, variableName){
+class NodeSelectorPatcher(private val k8sResource: KubernetesResource, private val variableName: String) :
+    AbstractPatcher(k8sResource, variableName) {
     override fun <String> patch(value: String) {
         if (k8sResource is Deployment) {
             k8sResource.spec.template.spec.nodeSelector = mapOf(variableName to value as kotlin.String)

theodolite-quarkus/src/main/kotlin/theodolite/patcher/PatcherManager.kt

@@ -3,17 +3,28 @@ package theodolite.patcher
 import io.fabric8.kubernetes.api.model.KubernetesResource
 import theodolite.util.PatcherDefinition
 import theodolite.util.TypeName
-import java.lang.IllegalArgumentException
 
 class PatcherManager {
-    private fun createK8sPatcher(patcherDefinition: PatcherDefinition, k8sResources: List<Pair<String, KubernetesResource>>): Patcher {
-        val resource = k8sResources.filter { it.first == patcherDefinition.resource}.map { resource -> resource.second }[0]
+    private fun createK8sPatcher(
+        patcherDefinition: PatcherDefinition,
+        k8sResources: List<Pair<String, KubernetesResource>>
+    ): Patcher {
+        val resource =
+            k8sResources.filter { it.first == patcherDefinition.resource }.map { resource -> resource.second }[0]
         return when (patcherDefinition.type) {
             "ReplicaPatcher" -> ReplicaPatcher(resource)
             "EnvVarPatcher" -> EnvVarPatcher(resource, patcherDefinition.container, patcherDefinition.variableName)
             "NodeSelectorPatcher" -> NodeSelectorPatcher(resource, patcherDefinition.variableName)
-            "ResourceLimitPatcher" -> ResourceLimitPatcher(resource, patcherDefinition.container, patcherDefinition.variableName)
-            "ResourceRequestPatcher" -> ResourceRequestPatcher(resource, patcherDefinition.container, patcherDefinition.variableName)
+            "ResourceLimitPatcher" -> ResourceLimitPatcher(
+                resource,
+                patcherDefinition.container,
+                patcherDefinition.variableName
+            )
+            "ResourceRequestPatcher" -> ResourceRequestPatcher(
+                resource,
+                patcherDefinition.container,
+                patcherDefinition.variableName
+            )
             else -> throw IllegalArgumentException("Patcher type ${patcherDefinition.type} not found")
         }
     }
@@ -25,17 +36,24 @@ class PatcherManager {
     }
 
     /**
-     * This function first creates a patcher definition and then patches the list of resources based on this patcher definition
+     * This function first creates a patcher definition and
+     * then patches the list of resources based on this patcher definition
      *
      * @param type Patcher type, for example "EnvVarPatcher"
      * @param patcherTypes List of patcher types definitions, for example for resources and threads
      * @param resources List of K8s resources, a patcher takes the resources that are needed
      * @param value The value to patch
      */
-    fun createAndApplyPatcher(type: String, patcherTypes: List<TypeName>, resources: List<Pair<String, KubernetesResource>>, value: Any) {
+    fun createAndApplyPatcher(
+        type: String,
+        patcherTypes: List<TypeName>,
+        resources: List<Pair<String, KubernetesResource>>,
+        value: Any
+    ) {
         this.getPatcherDef(type, patcherTypes)
             .forEach { patcherDef ->
-                createK8sPatcher(patcherDef, resources).patch(value) }
+                createK8sPatcher(patcherDef, resources).patch(value)
+            }
     }
 
     /**
@@ -45,8 +63,11 @@ class PatcherManager {
      * @param resources List of patcher types definitions, for example for resources and threads
      * @param value The value to patch
      */
-    fun applyPatcher(patcherDefinition: List<PatcherDefinition>, resources: List<Pair<String, KubernetesResource>>, value: Any) {
+    fun applyPatcher(
+        patcherDefinition: List<PatcherDefinition>,
+        resources: List<Pair<String, KubernetesResource>>,
+        value: Any
+    ) {
         patcherDefinition.forEach { def -> this.createK8sPatcher(def, resources).patch(value) }
-
     }
 }