merge upstream theodolite-kotlin

.gitlab-ci.yml

@@ -303,6 +303,32 @@ deploy-theodolite:
       allow_failure: true
 
 
+# Theodolite SLO Checker: Lag Trend
+
+deploy-slo-checker-lag-trend:
+  stage: deploy
+  extends:
+    - .dind
+  script:
+    - DOCKER_TAG_NAME=$(echo $CI_COMMIT_REF_SLUG- | sed 's/^master-$//')
+    - docker build --pull -t theodolite-slo-checker-lag-trend slope-evaluator
+    - "[ ! $CI_COMMIT_TAG ] && docker tag theodolite-slo-checker-lag-trend $CR_HOST/$CR_ORG/theodolite-slo-checker-lag-trend:${DOCKER_TAG_NAME}latest"
+    - "[ $CI_COMMIT_TAG ] && docker tag theodolite-slo-checker-lag-trend $CR_HOST/$CR_ORG/theodolite-slo-checker-lag-trend:$CI_COMMIT_TAG"
+    - echo $CR_PW | docker login $CR_HOST -u $CR_USER --password-stdin
+    - docker push $CR_HOST/$CR_ORG/theodolite-slo-checker-lag-trend
+    - docker logout
+  rules:
+    - if: "$CR_HOST && $CR_ORG && $CR_USER && $CR_PW && $CI_COMMIT_TAG"
+      when: always
+    - changes:
+      - slope-evaluator/**/*
+      if: "$CR_HOST && $CR_ORG && $CR_USER && $CR_PW"
+      when: always
+    - if: "$CR_HOST && $CR_ORG && $CR_USER && $CR_PW"
+      when: manual
+      allow_failure: true
+
+
 # Theodolite Random Scheduler
 
 deploy-random-scheduler:

execution/helm/README.md

@@ -44,6 +44,31 @@ In development environments Kubernetes resources are often low. To reduce resour
 helm install theodolite . -f preconfigs/one-broker-values.yaml
 ```
 
+## Uninstall this Chart
+
+To uninstall/delete the `my-release` deployment:
+
+```sh
+helm delete my-release
+```
+
+This command does not remove the CRDs which are created by this chart. Remove them manually with:
+
+```sh
+# CRDs from Theodolite
+kubectl delete crd execution
+kubectl delete crd benchmark
+# CRDs from Prometheus operator (see https://github.com/prometheus-community/helm-charts/tree/main/charts/kube-prometheus-stack#uninstall-chart)
+kubectl delete crd alertmanagerconfigs.monitoring.coreos.com
+kubectl delete crd alertmanagers.monitoring.coreos.com
+kubectl delete crd podmonitors.monitoring.coreos.com
+kubectl delete crd probes.monitoring.coreos.com
+kubectl delete crd prometheuses.monitoring.coreos.com
+kubectl delete crd prometheusrules.monitoring.coreos.com
+kubectl delete crd servicemonitors.monitoring.coreos.com
+kubectl delete crd thanosrulers.monitoring.coreos.com
+```
+
 ## Development
 
 **Hints**:

execution/helm/preconfigs/one-broker-values.yaml

@@ -9,7 +9,7 @@ cp-helm-charts:
   ## Kafka
   ## ------------------------------------------------------
     cp-kafka:
-        brokers: 1 # deauflt: 10
+        brokers: 1 # default: 10
 
         configurationOverrides:
           offsets.topic.replication.factor: "1"
\ No newline at end of file

execution/helm/templates/theodolite/crd-benchmark.yaml

+{{- if .Values.benchmarkCRD.create -}}
+apiVersion: apiextensions.k8s.io/v1beta1
+kind: CustomResourceDefinition
+metadata:
+  name: benchmarks.theodolite.com
+spec:
+  group: theodolite.com
+  version: v1alpha1
+  names:
+    kind: benchmark
+    plural: benchmarks
+  scope: Namespaced
+  subresources:
+    status: {}
+{{- end }}
\ No newline at end of file

execution/helm/templates/theodolite/crd-execution.yaml

+{{- if .Values.executionCRD.create -}}
+apiVersion: apiextensions.k8s.io/v1beta1
+kind: CustomResourceDefinition
+metadata:
+  name: executions.theodolite.com
+spec:
+  group: theodolite.com
+  version: v1alpha1
+  names:
+    kind: execution
+    plural: executions
+  scope: Namespaced
+  subresources:
+    status: {}
+{{- end }}
\ No newline at end of file

execution/helm/templates/theodolite/role-binding.yaml

+{{- if .Values.rbac.create -}}
+apiVersion: rbac.authorization.k8s.io/v1beta1
+kind: RoleBinding
+metadata:
+  name:  {{ include "theodolite.fullname" . }}
+  labels:
+    app:  {{ include "theodolite.name" . }}
+roleRef:
+  apiGroup: rbac.authorization.k8s.io
+  kind: Role
+  name: {{ include "theodolite.fullname" . }}
+subjects:
+- kind: ServiceAccount
+  name: {{ include "theodolite.serviceAccountName" . }}
+{{- end }}
\ No newline at end of file

execution/helm/templates/theodolite/role.yaml

+{{- if .Values.rbac.create -}}
+apiVersion: rbac.authorization.k8s.io/v1
+kind: Role
+metadata:
+  name: {{ include "theodolite.fullname" . }}
+rules:
+  - apiGroups:
+    - apps
+    resources:
+    - deployments
+    verbs:
+    - delete
+    - list
+    - get
+    - create
+    - update
+  - apiGroups:
+    - ""
+    resources:
+    - services
+    - pods
+    - configmaps
+    verbs:
+    - update
+    - delete
+    - list
+    - get
+    - create
+  - apiGroups:
+    - ""
+    resources:
+    - pods/exec
+    verbs:
+    - create
+    - get
+  - apiGroups:
+    - monitoring.coreos.com
+    resources:
+    - servicemonitors
+    verbs:
+    - update
+    - delete
+    - list
+    - create
+  {{- if .Values.operator.enabled -}}
+  - apiGroups:
+    - theodolite.com
+    resources: 
+    - executions
+    - benchmarks
+    verbs:
+    - delete
+    - list
+    - get
+    - create
+    - watch
+    - update
+    - patch
+  {{- end }}
+{{- end }}
\ No newline at end of file

execution/helm/templates/theodolite/serviceaccount.yaml

+{{- if .Values.serviceAccount.create -}}
+apiVersion: v1
+kind: ServiceAccount
+metadata:
+  name: {{ include "theodolite.serviceAccountName" . }}
+  labels:
+    {{- include "theodolite.labels" . | nindent 4 }}
+  {{- with .Values.serviceAccount.annotations }}
+  annotations:
+    {{- toYaml . | nindent 4 }}
+  {{- end }}
+{{- end }}
\ No newline at end of file

execution/helm/templates/theodolite/thedolite-operator.yaml

+{{- if .Values.operator.enabled -}}
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: {{ include "theodolite.fullname" . }}-operator
+spec:
+  selector:
+    matchLabels:
+      app: {{ include "theodolite.fullname" . }}
+  replicas: 1
+  template:
+    metadata:
+      labels:
+        app: {{ include "theodolite.fullname" . }}
+    spec:
+      terminationGracePeriodSeconds: 0
+      serviceAccountName:  {{ include "theodolite.serviceAccountName" . }}
+      containers:
+        - name: theodolite
+          image: ghcr.io/cau-se/theodolite:theodolite-kotlin-latest
+          env:
+            - name: NAMESPACE
+              value: {{ .Release.Namespace }}
+            - name: MODE
+              value: operator
+        - name: lag-analysis
+          image: ghcr.io/cau-se/theodolite-slo-checker-lag-trend:theodolite-kotlin-latest
+          ports:
+          - containerPort: 80
+            name: analysis 
+{{- end }}

execution/helm/values.yaml

@@ -227,3 +227,21 @@ prometheus:
     enabled: true
   clusterRoleBinding:
     enabled: true
+
+###
+# Theodolite Operator
+###
+operator:
+  enabled: true
+
+executionCRD:
+  create: true
+
+benchmarkCRD:
+  create: true
+
+serviceAccount:
+  create: true
+
+rbac:
+  create: true

execution/infrastructure/kubernetes/rbac/role.yaml

@@ -39,3 +39,17 @@ rules:
     - delete
     - list
     - create
+  - apiGroups:
+    - theodolite.com
+    resources: 
+    - executions
+    - benchmarks
+    verbs:
+    - delete
+    - list
+    - get
+    - create
+    - watch
+    - update
+    - patch
+    

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

@@ -20,7 +20,7 @@ loadTypes:
         container: "workload-generator"
         variableName: "NUM_SENSORS"
 kafkaConfig:
-  bootstrapServer: "theodolite-cp-kafka:9092"
+  bootstrapServer: "my-confluent-cp-kafka:9092"
   topics:
     - name: "input"
       numPartitions: 40

theodolite-quarkus/config/thedolite-operator.yaml

+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: theodolite
+spec:
+  selector:
+    matchLabels:
+      app: theodolite
+  replicas: 1
+  template:
+    metadata:
+      labels:
+        app: theodolite
+    spec:
+      terminationGracePeriodSeconds: 0
+      serviceAccountName: theodolite
+      containers:
+        - name: thedolite
+          image: ghcr.io/cau-se/theodolite:theodolite-kotlin-latest
+          env:
+            - name: KUBECONFIG
+              value: "~/.kube/config"
+            - name: NAMESPACE
+              value: "default"
\ No newline at end of file

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

@@ -13,8 +13,6 @@ import theodolite.util.*
 private val logger = KotlinLogging.logger {}
 private var DEFAULT_NAMESPACE = "default"
 
-val namespace: String = System.getenv("NAMESPACE") ?: DEFAULT_NAMESPACE
-
 @RegisterForReflection
 class KubernetesBenchmark : Benchmark, CustomResource(), Namespaced {
     lateinit var name: String
@@ -23,15 +21,11 @@ class KubernetesBenchmark : Benchmark, CustomResource(), Namespaced {
     lateinit var resourceTypes: List<TypeName>
     lateinit var loadTypes: List<TypeName>
     lateinit var kafkaConfig: KafkaConfig
-    lateinit var path: String
+    private val namespace = System.getenv("NAMESPACE") ?: DEFAULT_NAMESPACE
+    var path = System.getenv("THEODOLITE_APP_RESOURCES") ?: "./config"
 
     private fun loadKubernetesResources(resources: List<String>): List<Pair<String, KubernetesResource>> {
         val parser = YamlParser()
-
-        logger.info { "Using $namespace as namespace." }
-        logger.info { "Using $path as path for resources." }
-
-
         val loader = K8sResourceLoader(DefaultKubernetesClient().inNamespace(namespace))
         return resources
             .map { resource ->
@@ -47,6 +41,9 @@ class KubernetesBenchmark : Benchmark, CustomResource(), Namespaced {
         res: Resource,
         configurationOverrides: List<ConfigurationOverride?>
     ): BenchmarkDeployment {
+        logger.info { "Using $namespace as namespace." }
+        logger.info { "Using $path as resource path." }
+
         val resources = loadKubernetesResources(this.appResource + this.loadGenResource)
         val patcherFactory = PatcherFactory()
 
@@ -64,12 +61,12 @@ class KubernetesBenchmark : Benchmark, CustomResource(), Namespaced {
                 patcherFactory.createPatcher(it.patcher, resources).patch(override.value)
             }
         }
-
         return KubernetesBenchmarkDeployment(
             namespace = namespace,
             resources = resources.map { r -> r.second },
             kafkaConfig = hashMapOf("bootstrap.servers" to kafkaConfig.bootstrapServer),
-            topics = kafkaConfig.getKafkaTopics()
+            topics = kafkaConfig.getKafkaTopics(),
+            client = DefaultKubernetesClient().inNamespace(namespace)
         )
     }
 }

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

 package theodolite.benchmark
 
 import io.fabric8.kubernetes.api.model.KubernetesResource
-import io.fabric8.kubernetes.client.DefaultKubernetesClient
+import io.fabric8.kubernetes.client.NamespacedKubernetesClient
 import io.quarkus.runtime.annotations.RegisterForReflection
 import org.apache.kafka.clients.admin.NewTopic
 import theodolite.k8s.K8sManager
@@ -12,13 +12,12 @@ class KubernetesBenchmarkDeployment(
     val namespace: String,
     val resources: List<KubernetesResource>,
     private val kafkaConfig: HashMap<String, Any>,
-    private val topics: Collection<NewTopic>
+    private val topics: Collection<NewTopic>,
+    private val client: NamespacedKubernetesClient
 ) : BenchmarkDeployment {
     private val kafkaController = TopicManager(this.kafkaConfig)
-    private val kubernetesManager = K8sManager(DefaultKubernetesClient().inNamespace(namespace))
-
+    private val kubernetesManager = K8sManager(client)
     private val LABEL = "app.kubernetes.io/name=kafka-lag-exporter"
-    private val client = DefaultKubernetesClient().inNamespace(namespace)
 
     override fun setup() {
         kafkaController.createTopics(this.topics)

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

@@ -13,7 +13,7 @@ object Main {
     @JvmStatic
     fun main(args: Array<String>) {
 
-        val mode = System.getenv("MODE") ?: "operator"
+        val mode = System.getenv("MODE") ?: "yaml-executor"
         logger.info { "Start Theodolite with mode $mode" }
 
         when(mode) {

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

@@ -17,11 +17,9 @@ class TheodoliteYamlExecutor {
 
         val executionPath = System.getenv("THEODOLITE_EXECUTION") ?: "./config/BenchmarkExecution.yaml"
         val benchmarkPath = System.getenv("THEODOLITE_BENCHMARK") ?: "./config/BenchmarkType.yaml"
-        val appResource = System.getenv("THEODOLITE_APP_RESOURCES") ?: "./config"
 
         logger.info { "Using $executionPath for BenchmarkExecution" }
         logger.info { "Using $benchmarkPath for BenchmarkType" }
-        logger.info { "Using $appResource for Resources" }
 
 
         // load the BenchmarkExecution and the BenchmarkType
@@ -29,15 +27,16 @@ class TheodoliteYamlExecutor {
             parser.parse(path = executionPath, E = BenchmarkExecution::class.java)!!
         val benchmark =
             parser.parse(path = benchmarkPath, E = KubernetesBenchmark::class.java)!!
-        benchmark.path = appResource
 
-        val shutdown = Shutdown(benchmarkExecution, benchmark)
-        Runtime.getRuntime().addShutdownHook(thread { shutdown.run()})
+        // Add shutdown hook
+        // Use thread{} with start = false, else the thread will start right away
+        val shutdown = thread(start = false) { Shutdown(benchmarkExecution, benchmark).run() }
+        Runtime.getRuntime().addShutdownHook(shutdown)
 
         val executor = TheodoliteExecutor(benchmarkExecution, benchmark)
         executor.run()
         logger.info { "Theodolite finished" }
-        Runtime.getRuntime().removeShutdownHook(thread { shutdown.run()})
+        Runtime.getRuntime().removeShutdownHook(shutdown)
         exitProcess(0)
     }
 }

theodolite-quarkus/src/main/kotlin/theodolite/execution/operator/TheodoliteOperator.kt

@@ -7,6 +7,7 @@ import theodolite.benchmark.BenchmarkExecution
 import theodolite.benchmark.BenchmarkExecutionList
 import theodolite.benchmark.KubernetesBenchmark
 import theodolite.benchmark.KubernetesBenchmarkList
+import theodolite.k8s.K8sContextFactory
 
 
 private const val DEFAULT_NAMESPACE = "default"

theodolite-quarkus/src/main/kotlin/theodolite/execution/operator/K8sContextFactory.kt → theodolite-quarkus/src/main/kotlin/theodolite/k8s/K8sContextFactory.kt

-package theodolite.execution.operator
+package theodolite.k8s
 
 import io.fabric8.kubernetes.client.dsl.base.CustomResourceDefinitionContext