Merge upstream theodolite-kotlin

execution/README.md

@@ -98,7 +98,7 @@ kubectl apply -f infrastructure/kafka/service-monitor.yaml
 Other Kafka deployments, for example, using Strimzi, should work in a similar way.
 
 *Please note that currently, even if installed differently, the corresponding services must run at
-*my-confluent-cp-kafka:9092*, *my-confluent-cp-zookeeper:2181* and *my-confluent-cp-schema-registry:8081*.
+`my-confluent-cp-kafka:9092`, `my-confluent-cp-zookeeper:2181` and `my-confluent-cp-schema-registry:8081`.*
 
 #### A Kafka Client Pod
 

execution/helm/templates/dashboard-config-map.yaml → execution/helm/templates/grafana/dashboard-config-map.yaml

@@ -2,7 +2,7 @@
 apiVersion: v1
 kind: ConfigMap
 metadata:
-  name: scalability
+  name: {{ template "theodolite.fullname" . }}-grafana-scalability
   labels:
     grafana_dashboard: "1"
 data:

execution/helm/templates/kafka-client.yaml → execution/helm/templates/kafka/kafka-client.yaml

@@ -3,7 +3,7 @@ apiVersion: v1
 kind: Pod
 metadata:
   # name: {{ template "theodolite.fullname" . }}-kafka-client
-  name: kafka-client
+  name: {{ template "theodolite.fullname" . }}-kafka-client
 spec:
   containers:
   - name: kafka-client

execution/helm/templates/service-monitor.yaml → execution/helm/templates/kafka/service-monitor.yaml

@@ -5,7 +5,7 @@ metadata:
   labels:
     app: cp-kafka
     appScope: titan-ccp
-  name: kafka
+  name: {{ template "theodolite.fullname" . }}-cp-kafka
 spec:
   selector:
     matchLabels:

execution/helm/templates/cluster-role-binding.yaml → execution/helm/templates/prometheus/cluster-role-binding.yaml

@@ -2,13 +2,13 @@
 apiVersion: rbac.authorization.k8s.io/v1
 kind: ClusterRoleBinding
 metadata:
-  name: prometheus
+  name: {{ template "theodolite.fullname" . }}-prometheus
 roleRef:
   apiGroup: rbac.authorization.k8s.io
   kind: ClusterRole
-  name: prometheus
+  name: {{ template "theodolite.fullname" . }}-prometheus
 subjects:
 - kind: ServiceAccount
-  name: prometheus
+  name: {{ template "theodolite.fullname" . }}-prometheus
   namespace: {{ .Release.Namespace }}
 {{- end}}
\ No newline at end of file

execution/helm/templates/cluster-role.yaml → execution/helm/templates/prometheus/cluster-role.yaml

@@ -2,7 +2,7 @@
 apiVersion: rbac.authorization.k8s.io/v1
 kind: ClusterRole
 metadata:
-  name: prometheus
+  name: {{ template "theodolite.fullname" . }}-prometheus
 rules:
 - apiGroups: [""]
   resources:

execution/helm/templates/prometheus-datasource-config-map.yaml → execution/helm/templates/prometheus/datasource-config-map.yaml

@@ -2,7 +2,7 @@
 apiVersion: v1
 kind: ConfigMap
 metadata:
-  name: prometheus
+  name: {{ template "theodolite.fullname" . }}-prometheus
   labels:
     grafana_datasource: "1"
 data:

execution/helm/templates/prometheus.yaml → execution/helm/templates/prometheus/prometheus.yaml

@@ -4,7 +4,7 @@ kind: Prometheus
 metadata:
   name: {{ template "theodolite.fullname" . }}-prometheus
 spec:
-  serviceAccountName: prometheus
+  serviceAccountName: {{ template "theodolite.fullname" . }}-prometheus
   serviceMonitorSelector:
     matchLabels:
       #app: cp-kafka

execution/helm/templates/service-account.yaml → execution/helm/templates/prometheus/service-account.yaml

@@ -2,5 +2,5 @@
 apiVersion: v1
 kind: ServiceAccount
 metadata:
-  name: prometheus
+  name: {{ template "theodolite.fullname" . }}-prometheus
 {{- end}}
\ No newline at end of file

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

-name: "Theodolite Test Context"
+name: example-execution
 benchmark: "uc1-kstreams"
 load:
   loadType: "NumSensors"
@@ -32,19 +32,19 @@ configOverrides:
       resource: "uc1-kstreams-deployment.yaml"
       variableName: "env"
     value: "prod"
-  - patcher:
-      type: "ResourceLimitPatcher"
-      resource: "uc1-kstreams-deployment.yaml"
-      container: "uc-application"
-      variableName: "cpu"
-    value: "1000m"
-  - patcher:
-      type: "ResourceLimitPatcher"
-      resource: "uc1-kstreams-deployment.yaml"
-      container: "uc-application"
-      variableName: "memory"
-    value: "2Gi"
-  - patcher:
-      type: "SchedulerNamePatcher"
-      resource: "uc1-kstreams-deployment.yaml"
-    value: "random-scheduler"
+#  - patcher:
+#      type: "ResourceLimitPatcher"
+#      resource: "uc1-kstreams-deployment.yaml"
+#      container: "uc-application"
+#      variableName: "cpu"
+#    value: "1000m"
+#  - patcher:
+#      type: "ResourceLimitPatcher"
+#      resource: "uc1-kstreams-deployment.yaml"
+#      container: "uc-application"
+#      variableName: "memory"
+#    value: "2Gi"
+#  - patcher:
+#      type: "SchedulerNamePatcher"
+#      resource: "uc1-kstreams-deployment.yaml"
+#    value: "random-scheduler"
\ No newline at end of file

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

 package theodolite.benchmark
 
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize
+import io.fabric8.kubernetes.api.model.KubernetesResource
+import io.fabric8.kubernetes.api.model.Namespaced
+import io.fabric8.kubernetes.client.CustomResource
 import io.quarkus.runtime.annotations.RegisterForReflection
 import theodolite.util.ConfigurationOverride
 import kotlin.properties.Delegates
 
+@JsonDeserialize
 @RegisterForReflection
-class BenchmarkExecution {
+class BenchmarkExecution : CustomResource(), Namespaced {
     var executionId: Int = 0
     lateinit var name: String
     lateinit var benchmark: String
@@ -15,16 +20,18 @@ class BenchmarkExecution {
     lateinit var execution: Execution
     lateinit var configOverrides: List<ConfigurationOverride?>
 
+    @JsonDeserialize
     @RegisterForReflection
-    class Execution {
+    class Execution : KubernetesResource {
         lateinit var strategy: String
         var duration by Delegates.notNull<Long>()
         var repetitions by Delegates.notNull<Int>()
         lateinit var restrictions: List<String>
     }
 
+    @JsonDeserialize
     @RegisterForReflection
-    class Slo {
+    class Slo : KubernetesResource {
         lateinit var sloType: String
         var threshold by Delegates.notNull<Int>()
         lateinit var prometheusUrl: String
@@ -33,14 +40,17 @@ class BenchmarkExecution {
         var warmup by Delegates.notNull<Int>()
     }
 
+
+    @JsonDeserialize
     @RegisterForReflection
-    class LoadDefinition {
+    class LoadDefinition : KubernetesResource {
         lateinit var loadType: String
         lateinit var loadValues: List<Int>
     }
 
+    @JsonDeserialize
     @RegisterForReflection
-    class ResourceDefinition {
+    class ResourceDefinition : KubernetesResource {
         lateinit var resourceType: String
         lateinit var resourceValues: List<Int>
     }

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

+package theodolite.benchmark
+
+import io.fabric8.kubernetes.client.CustomResourceList
+
+class BenchmarkExecutionList : CustomResourceList<BenchmarkExecution>()
\ No newline at end of file

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

-package theodolite.benchmark;
+package theodolite.benchmark
 
 import io.fabric8.kubernetes.client.NamespacedKubernetesClient
 import mu.KotlinLogging

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

 package theodolite.benchmark
 
 import io.fabric8.kubernetes.api.model.KubernetesResource
+import io.fabric8.kubernetes.api.model.Namespaced
+import io.fabric8.kubernetes.client.CustomResource
 import io.fabric8.kubernetes.client.DefaultKubernetesClient
 import io.quarkus.runtime.annotations.RegisterForReflection
 import mu.KotlinLogging
@@ -9,11 +11,10 @@ import theodolite.patcher.PatcherFactory
 import theodolite.util.*
 
 private val logger = KotlinLogging.logger {}
-
 private var DEFAULT_NAMESPACE = "default"
 
 @RegisterForReflection
-class KubernetesBenchmark : Benchmark {
+class KubernetesBenchmark : Benchmark, CustomResource(), Namespaced {
     lateinit var name: String
     lateinit var appResource: List<String>
     lateinit var loadGenResource: List<String>
@@ -24,12 +25,15 @@ class KubernetesBenchmark : Benchmark {
     lateinit var path: String
 
     private fun loadKubernetesResources(resources: List<String>): List<Pair<String, KubernetesResource>> {
-        //val path = "./../../../resources/main/yaml/"
         val parser = YamlParser()
 
         namespace = System.getenv("NAMESPACE") ?: DEFAULT_NAMESPACE
         logger.info { "Using $namespace as namespace." }
 
+        path = System.getenv("THEODOLITE_APP_RESOURCES") ?: "./config"
+        logger.info { "Using $path as path for resources." }
+
+
         val loader = K8sResourceLoader(DefaultKubernetesClient().inNamespace(namespace))
         return resources
             .map { resource ->
@@ -58,7 +62,9 @@ class KubernetesBenchmark : Benchmark {
 
         // Patch the given overrides
         configurationOverrides.forEach { override ->
-            override?.let { patcherFactory.createPatcher(it.patcher, resources).patch(override.value) }
+            override?.let {
+                patcherFactory.createPatcher(it.patcher, resources).patch(override.value)
+            }
         }
 
         return KubernetesBenchmarkDeployment(

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

+package theodolite.benchmark
+
+import io.fabric8.kubernetes.client.CustomResourceList
+
+class KubernetesBenchmarkList : CustomResourceList<KubernetesBenchmark>()
\ No newline at end of file

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

@@ -19,7 +19,7 @@ class AnalysisExecutor(
         offset = Duration.ofHours(slo.offset.toLong())
     )
 
-    fun analyse(load: LoadDimension, res: Resource, executionDuration: Duration): Boolean {
+    fun analyze(load: LoadDimension, res: Resource, executionDuration: Duration): Boolean {
         var result = false
 
         try {

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

@@ -8,6 +8,7 @@ import theodolite.util.LoadDimension
 import theodolite.util.Resource
 import theodolite.util.Results
 import java.time.Duration
+import java.util.concurrent.atomic.AtomicBoolean
 
 private val logger = KotlinLogging.logger {}
 
@@ -28,6 +29,8 @@ abstract class BenchmarkExecutor(
     val executionId: Int
 ) {
 
+    var run: AtomicBoolean = AtomicBoolean(true)
+
     /**
      * Run a experiment for the given parametrization, evaluate the experiment and save the result.
      *
@@ -43,12 +46,19 @@ abstract class BenchmarkExecutor(
      */
     fun waitAndLog() {
         logger.info { "Execution of a new benchmark started." }
-        for (i in 1.rangeTo(executionDuration.toSeconds())) {
 
+        var secondsRunning = 0L
+
+        while (run.get() && secondsRunning < executionDuration.toSeconds()) {
+            secondsRunning++
             Thread.sleep(Duration.ofSeconds(1).toMillis())
-            if ((i % 60) == 0L) {
-                logger.info { "Executed: ${i / 60} minutes" }
+
+            if ((secondsRunning % 60) == 0L) {
+                logger.info { "Executed: ${secondsRunning / 60} minutes." }
             }
         }
+
+        logger.debug { "Executor shutdown gracefully." }
+
     }
 }

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

@@ -23,19 +23,24 @@ class BenchmarkExecutorImpl(
     executionId: Int
 ) : BenchmarkExecutor(benchmark, results, executionDuration, configurationOverrides, slo, executionId) {
     override fun runExperiment(load: LoadDimension, res: Resource): Boolean {
+        var result = false
         val benchmarkDeployment = benchmark.buildDeployment(load, res, this.configurationOverrides)
+
+        try {
             benchmarkDeployment.setup()
             this.waitAndLog()
+        } catch(e: Exception) {
+            logger.error { "Error while setup experiment." }
+            logger.error { "Error is: $e" }
+            this.run.set(false)
+        }
 
-        val result = AnalysisExecutor(slo = slo, executionId = executionId).analyse(
-            load = load,
-            res = res,
-            executionDuration = executionDuration
-        )
-
-        benchmarkDeployment.teardown()
-
+        if (this.run.get()) {
+            result =
+                AnalysisExecutor(slo = slo, executionId = executionId).analyze(load = load, res = res, executionDuration = executionDuration)
             this.results.setResult(Pair(load, res), result)
+        }
+        benchmarkDeployment.teardown()
         return result
     }
 }

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

+package theodolite.execution
+
+import io.quarkus.runtime.annotations.QuarkusMain
+import mu.KotlinLogging
+import theodolite.execution.operator.TheodoliteOperator
+import kotlin.system.exitProcess
+
+private val logger = KotlinLogging.logger {}
+
+@QuarkusMain
+object Main {
+
+    @JvmStatic
+    fun main(args: Array<String>) {
+
+        val mode = System.getenv("MODE") ?: "operator"
+        logger.info { "Start Theodolite with mode $mode" }
+
+        when(mode) {
+           "yaml-executor" -> TheodoliteYamlExecutor().start()
+            "operator" -> TheodoliteOperator().start()
+            else ->  {logger.error { "MODE $mode not found" }; exitProcess(1)}
+        }
+    }
+}
\ No newline at end of file