Merge with master and localhost as internal ip

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

 package theodolite.execution
 
+import mu.KotlinLogging
 import theodolite.execution.BenchmarkExecutor
 import theodolite.util.Benchmark
 import theodolite.util.LoadDimension
@@ -13,8 +14,6 @@ class TestBenchmarkExecutor(private val mockResults: Array<Array<Boolean>>, benc
     override fun runExperiment(load: LoadDimension, res: Resource): Boolean {
         val result = this.mockResults[load.get()][res.get()]
 
-        System.out.println("load :" + load.get().toString() + ", res: " + res.get().toString() + ", res: " + result)
-
         this.results.setResult(Pair(load, res), result)
         return result;
     }

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

 package theodolite.execution
 
+import mu.KotlinLogging
 import theodolite.k8s.UC1Benchmark
 import theodolite.strategies.restriction.LowerBoundRestriction
 import theodolite.strategies.searchstrategy.CompositeStrategy
@@ -10,6 +11,8 @@ import theodolite.util.Resource
 import theodolite.util.Results
 import java.time.Duration
 
+private val logger = KotlinLogging.logger {}
+
 class TheodoliteExecutor() {
     val path = "/home/lorenz/git/spesb/theodolite-quarkus/src/main/resources/yaml"
     private fun loadConfig(): Config {
@@ -31,7 +34,9 @@ class TheodoliteExecutor() {
             )
         )
         val results: Results = Results()
+
         val executionDuration = Duration.ofSeconds(60 * 5)
+
         val executor: BenchmarkExecutor = KafkaBenchmarkExecutor(benchmark, results, executionDuration)
 
         val restrictionStrategy = LowerBoundRestriction(results)
@@ -56,8 +61,7 @@ class TheodoliteExecutor() {
 
         // execute benchmarks for each load
         for (load in config.loads) {
-            config.compositeStrategy.findSuitableResources(load, config.resources)
+            config.compositeStrategy.findSuitableResource(load, config.resources)
         }
-
     }
-}
+}
\ No newline at end of file

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

 package theodolite.k8s
 
+import mu.KotlinLogging
 import org.apache.kafka.clients.admin.AdminClient
 import org.apache.kafka.clients.admin.AdminClientConfig
 import org.apache.kafka.clients.admin.ListTopicsResult
 import org.apache.kafka.clients.admin.NewTopic
 
+private val logger = KotlinLogging.logger {}
+
 class TopicManager(boostrapIp: String) {
     val props = hashMapOf<String, Any>(AdminClientConfig.BOOTSTRAP_SERVERS_CONFIG to boostrapIp)
     lateinit var kafkaAdmin: AdminClient
@@ -13,7 +16,7 @@ class TopicManager(boostrapIp: String) {
         try {
             kafkaAdmin = AdminClient.create(props)
         } catch (e: Exception) {
-            System.out.println(e.toString())
+            logger.error {e.toString()}
         }
     }
 
@@ -25,7 +28,7 @@ class TopicManager(boostrapIp: String) {
             newTopics.add(tops)
         }
         kafkaAdmin.createTopics(newTopics)
-        System.out.println("Topics created")
+        logger.info {"Topics created"}
     }
 
     fun createTopics(topics: List<String>, numPartitions: Int, replicationfactor: Short) {
@@ -36,7 +39,7 @@ class TopicManager(boostrapIp: String) {
             newTopics.add(tops)
         }
         kafkaAdmin.createTopics(newTopics)
-        System.out.println("Creation of $topics started")
+        logger.info {"Creation of $topics started"}
     }
 
     fun deleteTopics(topics: List<String>) {
@@ -46,9 +49,9 @@ class TopicManager(boostrapIp: String) {
         try {
             result.all().get()
         } catch (ex: Exception) {
-            System.out.println(ex.toString())
+            logger.error {ex.toString()}
         }
-        System.out.println("Topics deleted")
+        logger.info {"Topics deleted"}
     }
 
     fun getTopics(): ListTopicsResult? {

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

@@ -67,8 +67,8 @@ class UC1Benchmark(config: UC1BenchmarkConfig) : Benchmark(config) {
 
         // set environment variables
         val environmentVariables: MutableMap<String, String> = mutableMapOf()
-        environmentVariables.put("KAFKA_BOOTSTRAP_SERVERS", this.config.kafkaIPConnectionString)
-        environmentVariables.put("SCHEMA_REGISTRY_URL", this.config.schemaRegistryConnectionString)
+        //environmentVariables.put("KAFKA_BOOTSTRAP_SERVERS", this.config.kafkaIPConnectionString)
+        //environmentVariables.put("SCHEMA_REGISTRY_URL", this.config.schemaRegistryConnectionString)
 
 
         // setup deployment
@@ -89,9 +89,9 @@ class UC1Benchmark(config: UC1BenchmarkConfig) : Benchmark(config) {
         // TODO ("calculate number of required instances")
         val requiredInstances: Int = 1
         val environmentVariables: MutableMap<String, String> = mutableMapOf()
-        environmentVariables.put("KAFKA_BOOTSTRAP_SERVERS", this.config.kafkaIPConnectionString)
-        environmentVariables.put("ZK_HOST", this.config.zookeeperConnectionString.split(":")[0])
-        environmentVariables.put("ZK_PORT", this.config.zookeeperConnectionString.split(":")[1])
+        //environmentVariables.put("KAFKA_BOOTSTRAP_SERVERS", this.config.kafkaIPConnectionString)
+        //environmentVariables.put("ZK_HOST", this.config.zookeeperConnectionString.split(":")[0])
+        //environmentVariables.put("ZK_PORT", this.config.zookeeperConnectionString.split(":")[1])
         environmentVariables.put("NUM_SENSORS", load.get().toString())
         environmentVariables.put("INSTANCES", requiredInstances.toString())
 

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

 package theodolite.k8s
 
+import mu.KotlinLogging
 import org.apache.zookeeper.KeeperException
 import org.apache.zookeeper.WatchedEvent
 import org.apache.zookeeper.Watcher
 import org.apache.zookeeper.ZooKeeper
 
+private val logger = KotlinLogging.logger {}
+
+
 class WorkloadGeneratorStateCleaner(ip: String) {
     val path = "/workload-generation"
     val sessionTimeout = 60
@@ -16,7 +20,7 @@ class WorkloadGeneratorStateCleaner(ip: String) {
             val watcher: Watcher = ZookeperWatcher()  // defined below
             zookeeperClient = ZooKeeper(ip, sessionTimeout, watcher)
         } catch (e: Exception) {
-            System.out.println(e.toString())
+            logger.error {e.toString()}
         }
     }
 
@@ -28,7 +32,7 @@ class WorkloadGeneratorStateCleaner(ip: String) {
             try {
                 zookeeperClient.delete(path, -1)
             } catch (ex: Exception) {
-                System.out.println(ex.toString())
+                logger.error {ex.toString()}
             }
 
             try {
@@ -42,15 +46,15 @@ class WorkloadGeneratorStateCleaner(ip: String) {
                         deleted = true
                     }
                     is InterruptedException -> {
-                        System.out.println(ex.toString())
+                        logger.error {ex.toString()}
                     }
                 }
             }
             Thread.sleep(retryTime)
-            System.out.println("ZooKeeper reset was not successful. Retrying in 5s")
+            logger.info {"ZooKeeper reset was not successful. Retrying in 5s"}
         }
 
-        System.out.println("ZooKeeper reset was successful")
+        logger.info {"ZooKeeper reset was successful"}
     }
 
     private class ZookeperWatcher : Watcher {

theodolite-quarkus/src/main/kotlin/theodolite/strategies/restriction/RestrictionStrategy.kt

@@ -5,5 +5,5 @@ import theodolite.util.LoadDimension
 import theodolite.util.Resource
 
 abstract class RestrictionStrategy(val results: Results) {
-    public abstract fun next(load: LoadDimension, resources: List<Resource>): List<Resource>;
+    public abstract fun next(load: LoadDimension, resources: List<Resource>): List<Resource>
 }
\ No newline at end of file

theodolite-quarkus/src/main/kotlin/theodolite/strategies/searchstrategy/BinarySearch.kt

@@ -7,7 +7,7 @@ import theodolite.util.Results
 import java.lang.IllegalArgumentException
 
 class BinarySearch(benchmarkExecutor: BenchmarkExecutor, results: Results) : SearchStrategy(benchmarkExecutor, results) {
-    override fun findSuitableResources(load: LoadDimension, resources: List<Resource>): Resource? {
+    override fun findSuitableResource(load: LoadDimension, resources: List<Resource>): Resource? {
         val result =  search(load, resources, 0, resources.size - 1)
         if( result == -1 ) {
             return null;
@@ -19,22 +19,23 @@ class BinarySearch(benchmarkExecutor: BenchmarkExecutor, results: Results) : Sea
         if (lower > upper) {
             throw IllegalArgumentException()
         }
-        if (lower == upper ) {
-            if (this.benchmarkExecutor.runExperiment(load, resources[lower])) return lower;
+        // special case:  length == 1 or 2
+        if (lower == upper) {
+            if (this.benchmarkExecutor.runExperiment(load, resources[lower])) return lower
             else {
                 if (lower + 1 == resources.size) return - 1
-                return lower + 1;
+                return lower + 1
             }
         } else {
-            // (true, true), (false, true), (false, false) // (false, false, false, true, false, true, false, true)
+            // apply binary search for a list with length > 2 and adjust upper and lower depending on the result for `resources[mid]`
             val mid = (upper + lower) / 2
             if (this.benchmarkExecutor.runExperiment(load, resources[mid])) {
                 if (mid == lower) {
                     return lower
                 }
-                return search(load, resources, lower, mid - 1 );
+                return search(load, resources, lower, mid - 1 )
             } else {
-              return search(load, resources, mid + 1 , upper);
+              return search(load, resources, mid + 1 , upper)
             }
         }
     }

theodolite-quarkus/src/main/kotlin/theodolite/strategies/searchstrategy/CompositeStrategy.kt

@@ -8,11 +8,11 @@ import theodolite.util.Results
 
 class CompositeStrategy(benchmarkExecutor: BenchmarkExecutor, val searchStrategy: SearchStrategy, val restrictionStrategies: Set<RestrictionStrategy>, results: Results) : SearchStrategy(benchmarkExecutor, results) {
 
-    override fun findSuitableResources(load: LoadDimension, resources: List<Resource>): Resource? {
+    override fun findSuitableResource(load: LoadDimension, resources: List<Resource>): Resource? {
         var restrictedResources = resources.toList()
         for (strategy in this.restrictionStrategies) {
             restrictedResources = restrictedResources.intersect(strategy.next(load, resources)).toList()
         }
-        return this.searchStrategy.findSuitableResources(load, restrictedResources)
+        return this.searchStrategy.findSuitableResource(load, restrictedResources)
     }
 }
\ No newline at end of file

theodolite-quarkus/src/main/kotlin/theodolite/strategies/searchstrategy/LinearSearch.kt

@@ -7,7 +7,7 @@ import theodolite.util.Results
 
 class LinearSearch(benchmarkExecutor: BenchmarkExecutor, results: Results) : SearchStrategy(benchmarkExecutor, results) {
 
-    override fun findSuitableResources(load: LoadDimension, resources: List<Resource>): Resource? {
+    override fun findSuitableResource(load: LoadDimension, resources: List<Resource>): Resource? {
         for (res in resources) {
             if (this.benchmarkExecutor.runExperiment(load, res)) return res
         }

theodolite-quarkus/src/main/kotlin/theodolite/strategies/searchstrategy/SearchStrategy.kt

@@ -6,5 +6,5 @@ import theodolite.util.Resource
 import theodolite.util.Results
 
 abstract class SearchStrategy(val benchmarkExecutor: BenchmarkExecutor, val results: Results) {
-    abstract fun findSuitableResources(load: LoadDimension, resources: List<Resource>): Resource?;
+    abstract fun findSuitableResource(load: LoadDimension, resources: List<Resource>): Resource?;
 }
\ No newline at end of file

theodolite-quarkus/src/main/kotlin/theodolite/util/TestBenchmark.kt

 package theodolite.util
 
-//class TestBenchmark: Benchmark(config = emptyMap()) {
-//    override fun start() {
-//        TODO("Not yet implemented")
-//    }
-//
-//    override fun clearClusterEnvironment() {
-//        TODO("Not yet implemented")
-//    }
-//
-//    override fun startWorkloadGenerator(wg: String, dimValue: Int, ucId: String) {
-//        TODO("Not yet implemented")
-//    }
-//}
+import theodolite.k8s.UC1Benchmark
+
+class TestBenchmark : Benchmark(
+    UC1Benchmark.UC1BenchmarkConfig(
+        zookeeperConnectionString = "",
+        kafkaIPConnectionString = "",
+        schemaRegistryConnectionString = "",
+        kafkaTopics = emptyList(),
+        kafkaReplication = 0,
+        kafkaPartition = 0,
+        ucServicePath = "",
+        ucDeploymentPath = "",
+        wgDeploymentPath = "",
\ No newline at end of file
+        configMapPath = "",
+        ucImageURL = "",
+        wgImageURL = ""
+    )
+) {
+
+    override fun initializeClusterEnvironment() {
+        TODO("Not yet implemented")
+    }
+
+    override fun clearClusterEnvironment() {
+        TODO("Not yet implemented")
+    }
+
+    override fun startSUT(resources: Resource) {
+        TODO("Not yet implemented")
+    }
+
+    override fun startWorkloadGenerator(load: LoadDimension) {
+        TODO("Not yet implemented")
+    }
+}

theodolite-quarkus/src/test/kotlin/theodolite/CompositeStrategyTest.kt

@@ -40,7 +40,7 @@ class CompositeStrategyTest {
         expected.add(null)
 
         for(load in mockLoads) {
-            actual.add(strategy.findSuitableResources(load, mockResources))
+            actual.add(strategy.findSuitableResource(load, mockResources))
         }
 
         assertEquals(actual, expected)
@@ -71,7 +71,7 @@ class CompositeStrategyTest {
         expected.add(null)
 
         for(load in mockLoads) {
-            actual.add(strategy.findSuitableResources(load, mockResources))
+            actual.add(strategy.findSuitableResource(load, mockResources))
         }
 
         assertEquals(actual, expected)
@@ -101,7 +101,7 @@ class CompositeStrategyTest {
         val expected: ArrayList<Resource?> = ArrayList(listOf(0,2,2,3,4,6,7).map{ x -> Resource(x)})
 
         for(load in mockLoads) {
-            actual.add(strategy.findSuitableResources(load, mockResources))
+            actual.add(strategy.findSuitableResource(load, mockResources))
         }
 
         assertEquals(actual, expected)