Merge branch '221-add-delay-before-create-wl' into 'theodolite-kotlin'

Add delay before start the load generator

See merge request !135

theodolite-quarkus/config/example-benchmark-yaml-resource.yaml

@@ -22,7 +22,7 @@ loadTypes:
       - type: "NumSensorsLoadGeneratorReplicaPatcher"
         resource: "uc1-load-generator-deployment.yaml"
 kafkaConfig:
-  bootstrapServer: "theodolite-cp-kafka:9092"
+  bootstrapServer: "localhost:31290"
   topics:
     - name: "input"
       numPartitions: 40

theodolite-quarkus/config/example-execution-yaml-resource.yaml

@@ -17,6 +17,7 @@ execution:
   strategy: "LinearSearch"
   duration: 300 # in seconds
   repetitions: 1
+  loadGenerationDelay: 30 # in seconds, optional field, default is 0 seconds
   restrictions:
     - "LowerBound"
 configOverrides: []

theodolite-quarkus/config/example-operator-execution.yaml

@@ -21,6 +21,7 @@ execution:
   strategy: "LinearSearch"
   duration: 300 # in seconds
   repetitions: 1
+  delay: 30 # in seconds
   restrictions:
     - "LowerBound"
 configOverrides: []

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

@@ -21,6 +21,7 @@ interface Benchmark {
     fun buildDeployment(
         load: LoadDimension,
         res: Resource,
-        configurationOverrides: List<ConfigurationOverride?>
+        configurationOverrides: List<ConfigurationOverride?>,
+        delay: Long
     ): BenchmarkDeployment
 }

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

@@ -47,6 +47,7 @@ class BenchmarkExecution : CustomResource(), Namespaced {
         var duration by Delegates.notNull<Long>()
         var repetitions by Delegates.notNull<Int>()
         lateinit var restrictions: List<String>
+        var loadGenerationDelay = 0L
     }
 
     /**

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

@@ -70,31 +70,36 @@ class KubernetesBenchmark : Benchmark, CustomResource(), Namespaced {
     override fun buildDeployment(
         load: LoadDimension,
         res: Resource,
-        configurationOverrides: List<ConfigurationOverride?>
+        configurationOverrides: List<ConfigurationOverride?>,
+        loadGenerationDelay: Long
     ): BenchmarkDeployment {
         logger.info { "Using $namespace as namespace." }
         logger.info { "Using $path as resource path." }
 
-        val resources = loadKubernetesResources(this.appResource + this.loadGenResource)
+        val appResources = loadKubernetesResources(this.appResource)
+        val loadGenResources = loadKubernetesResources(this.loadGenResource)
+
         val patcherFactory = PatcherFactory()
 
         // patch the load dimension the resources
         load.getType().forEach { patcherDefinition ->
-            patcherFactory.createPatcher(patcherDefinition, resources).patch(load.get().toString())
+            patcherFactory.createPatcher(patcherDefinition, loadGenResources).patch(load.get().toString())
         }
         res.getType().forEach { patcherDefinition ->
-            patcherFactory.createPatcher(patcherDefinition, resources).patch(res.get().toString())
+            patcherFactory.createPatcher(patcherDefinition, appResources).patch(res.get().toString())
         }
 
         // Patch the given overrides
         configurationOverrides.forEach { override ->
             override?.let {
-                patcherFactory.createPatcher(it.patcher, resources).patch(override.value)
+                patcherFactory.createPatcher(it.patcher, appResources + loadGenResources).patch(override.value)
             }
         }
         return KubernetesBenchmarkDeployment(
             namespace = namespace,
-            resources = resources.map { r -> r.second },
+            appResources = appResources.map { it.second },
+            loadGenResources = loadGenResources.map { it.second },
+            loadGenerationDelay = loadGenerationDelay,
             kafkaConfig = hashMapOf("bootstrap.servers" to kafkaConfig.bootstrapServer),
             topics = kafkaConfig.topics,
             client = DefaultKubernetesClient().inNamespace(namespace)

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

@@ -8,6 +8,7 @@ import org.apache.kafka.clients.admin.NewTopic
 import theodolite.k8s.K8sManager
 import theodolite.k8s.TopicManager
 import theodolite.util.KafkaConfig
+import java.time.Duration
 
 private val logger = KotlinLogging.logger {}
 
@@ -22,7 +23,9 @@ private val logger = KotlinLogging.logger {}
 @RegisterForReflection
 class KubernetesBenchmarkDeployment(
     val namespace: String,
-    val resources: List<KubernetesResource>,
+    val appResources: List<KubernetesResource>,
+    val loadGenResources: List<KubernetesResource>,
+    private val loadGenerationDelay: Long,
     private val kafkaConfig: HashMap<String, Any>,
     private val topics: List<KafkaConfig.TopicWrapper>,
     private val client: NamespacedKubernetesClient
@@ -41,7 +44,10 @@ class KubernetesBenchmarkDeployment(
         val kafkaTopics = this.topics.filter { !it.removeOnly }
             .map { NewTopic(it.name, it.numPartitions, it.replicationFactor) }
         kafkaController.createTopics(kafkaTopics)
-        resources.forEach { kubernetesManager.deploy(it) }
+        appResources.forEach { kubernetesManager.deploy(it) }
+        logger.info { "Wait ${this.loadGenerationDelay} seconds before starting the load generator." }
+        Thread.sleep(Duration.ofSeconds(this.loadGenerationDelay).toMillis())
+        loadGenResources.forEach { kubernetesManager.deploy(it) }
     }
 
     /**
@@ -51,9 +57,8 @@ class KubernetesBenchmarkDeployment(
      *  - Remove the [KubernetesResource]s.
      */
     override fun teardown() {
-        resources.forEach {
-            kubernetesManager.remove(it)
-        }
+        loadGenResources.forEach { kubernetesManager.remove(it) }
+        appResources.forEach { kubernetesManager.remove(it) }
         kafkaController.removeTopics(this.topics.map { topic -> topic.name })
         KafkaLagExporterRemover(client).remove(LAG_EXPORTER_POD_LABEL)
         logger.info { "Teardown complete. Wait $SLEEP_AFTER_TEARDOWN ms to let everything come down." }

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

@@ -24,9 +24,10 @@ abstract class BenchmarkExecutor(
     val benchmark: Benchmark,
     val results: Results,
     val executionDuration: Duration,
-    configurationOverrides: List<ConfigurationOverride?>,
+    val configurationOverrides: List<ConfigurationOverride?>,
     val slo: BenchmarkExecution.Slo,
-    val executionId: Int
+    val executionId: Int,
+    val loadGenerationDelay: Long
 ) {
 
     var run: AtomicBoolean = AtomicBoolean(true)

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

@@ -18,13 +18,14 @@ class BenchmarkExecutorImpl(
     benchmark: Benchmark,
     results: Results,
     executionDuration: Duration,
-    private val configurationOverrides: List<ConfigurationOverride?>,
+    configurationOverrides: List<ConfigurationOverride?>,
     slo: BenchmarkExecution.Slo,
-    executionId: Int
-) : BenchmarkExecutor(benchmark, results, executionDuration, configurationOverrides, slo, executionId) {
+    executionId: Int,
+    loadGenerationDelay: Long
+) : BenchmarkExecutor(benchmark, results, executionDuration, configurationOverrides, slo, executionId, loadGenerationDelay) {
     override fun runExperiment(load: LoadDimension, res: Resource): Boolean {
         var result = false
-        val benchmarkDeployment = benchmark.buildDeployment(load, res, this.configurationOverrides)
+        val benchmarkDeployment = benchmark.buildDeployment(load, res, configurationOverrides, loadGenerationDelay)
 
         try {
             benchmarkDeployment.setup()

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

@@ -30,7 +30,8 @@ class Shutdown(private val benchmarkExecution: BenchmarkExecution, private val b
             benchmark.buildDeployment(
                 load = LoadDimension(0, emptyList()),
                 res = Resource(0, emptyList()),
-                configurationOverrides = benchmarkExecution.configOverrides
+                configurationOverrides = benchmarkExecution.configOverrides,
+                loadGenerationDelay = 0L
             )
             deployment.teardown()
         } catch (e: Exception) {

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

@@ -71,7 +71,8 @@ class TheodoliteExecutor(
                 executionDuration = executionDuration,
                 configurationOverrides = config.configOverrides,
                 slo = config.slos[0],
-                executionId = config.executionId
+                executionId = config.executionId,
+                loadGenerationDelay = config.execution.loadGenerationDelay
             )
 
         return Config(

theodolite-quarkus/src/main/resources/operator/example-execution-k8s-resource.yaml

@@ -22,6 +22,7 @@ execution:
   strategy: "LinearSearch"
   duration: 60
   repetitions: 1
+  delay: 30 # in seconds
   restrictions:
     - "LowerBound"
 configOverrides:

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

@@ -31,7 +31,7 @@ class CompositeStrategyTest {
         val results = Results()
         val benchmark = TestBenchmark()
         val sloChecker: BenchmarkExecution.Slo = BenchmarkExecution.Slo()
-        val benchmarkExecutor = TestBenchmarkExecutorImpl(mockResults, benchmark, results, sloChecker, 0)
+        val benchmarkExecutor = TestBenchmarkExecutorImpl(mockResults, benchmark, results, sloChecker, 0, 0)
         val linearSearch = LinearSearch(benchmarkExecutor)
         val lowerBoundRestriction = LowerBoundRestriction(results)
         val strategy =
@@ -65,7 +65,7 @@ class CompositeStrategyTest {
         val benchmark = TestBenchmark()
         val sloChecker: BenchmarkExecution.Slo = BenchmarkExecution.Slo()
         val benchmarkExecutorImpl =
-            TestBenchmarkExecutorImpl(mockResults, benchmark, results, sloChecker, 0)
+            TestBenchmarkExecutorImpl(mockResults, benchmark, results, sloChecker, 0, 0)
         val binarySearch = BinarySearch(benchmarkExecutorImpl)
         val lowerBoundRestriction = LowerBoundRestriction(results)
         val strategy =
@@ -98,7 +98,7 @@ class CompositeStrategyTest {
         val results = Results()
         val benchmark = TestBenchmark()
         val sloChecker: BenchmarkExecution.Slo = BenchmarkExecution.Slo()
-        val benchmarkExecutor = TestBenchmarkExecutorImpl(mockResults, benchmark, results, sloChecker, 0)
+        val benchmarkExecutor = TestBenchmarkExecutorImpl(mockResults, benchmark, results, sloChecker, 0, 0)
         val binarySearch = BinarySearch(benchmarkExecutor)
         val lowerBoundRestriction = LowerBoundRestriction(results)
         val strategy =

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

@@ -11,7 +11,8 @@ class TestBenchmark : Benchmark {
     override fun buildDeployment(
         load: LoadDimension,
         res: Resource,
-        configurationOverrides: List<ConfigurationOverride?>
+        configurationOverrides: List<ConfigurationOverride?>,
+        loadGenerationDelay: Long
     ): BenchmarkDeployment {
         return TestBenchmarkDeployment()
     }

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

@@ -13,7 +13,8 @@ class TestBenchmarkExecutorImpl(
     benchmark: Benchmark,
     results: Results,
     slo: BenchmarkExecution.Slo,
-    executionId: Int
+    executionId: Int,
+    loadGenerationDelay: Long
 ) :
     BenchmarkExecutor(
         benchmark,
@@ -21,7 +22,8 @@ class TestBenchmarkExecutorImpl(
         executionDuration = Duration.ofSeconds(1),
         configurationOverrides = emptyList(),
         slo = slo,
-        executionId = executionId
+        executionId = executionId,
+        loadGenerationDelay = loadGenerationDelay
     ) {
 
     override fun runExperiment(load: LoadDimension, res: Resource): Boolean {