merge upstream theodolite-kotlin

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

@@ -55,12 +55,12 @@ spec:
                           resource:
                             type: string
                             default: ""
-                          container:
-                            type: string
-                            default: ""
-                          variableName:
-                            type: string
-                            default: ""
+                          config:
+                            type: object
+                            additionalProperties: true
+                            x-kubernetes-map-type: "granular"
+                            default: 
+                              "": ""
               loadTypes:
                 type: array
                 minItems: 1
@@ -81,12 +81,12 @@ spec:
                           resource:
                             type: string
                             default: ""
-                          container:
-                            type: string
-                            default: ""
-                          variableName:
-                            type: string
-                            default: ""
+                          config:
+                            type: object
+                            additionalProperties: true
+                            x-kubernetes-map-type: "granular"
+                            default: 
+                              "": ""
               kafkaConfig:
                 type: object
                 properties:

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

-{{- if .Values.executionCRD.create -}}
 apiVersion: apiextensions.k8s.io/v1
 kind: CustomResourceDefinition
 metadata:
@@ -96,12 +95,12 @@ spec:
                         resource:
                           type: string
                           default: ""
-                        container:
-                          type: string
-                          default: ""
-                        variableName:
-                          type: string
-                          default: ""
+                        config:
+                            type: object
+                            additionalProperties: true
+                            x-kubernetes-map-type: "granular"
+                            default: 
+                              "": ""
                     value:
                       type: string
           status:
@@ -127,6 +126,4 @@ spec:
       jsonPath: .metadata.creationTimestamp
     subresources:
       status: {}
-  scope: Namespaced
-  status: {}
-{{- end }}
\ No newline at end of file
+  scope: Namespaced
\ No newline at end of file

theodolite-benchmarks/definitions/uc1-kstreams/uc1-benchmark-operator.yaml

@@ -24,7 +24,7 @@ spec:
           properties:
             container: "workload-generator"
             variableName: "NUM_SENSORS"
-        - type: NumSensorsLoadGeneratorReplicaPatcher
+        - type: "NumSensorsLoadGeneratorReplicaPatcher"
           resource: "uc1-load-generator-deployment.yaml"
           properties:
             loadGenMaxRecords: "15000"

theodolite-quarkus/config/README.md

@@ -19,14 +19,16 @@ resourceTypes:
     patchers:
       - type: String
         resources: String
-        <Patcher Arguments> ...
+        properties:
+          <Patcher Arguments> ...
       ...
 loadTypes:
   - typeName: String
   patchers:
     - type: String
       resources: String
-      <Patcher Arguments> ...
+      properties:
+        <Patcher Arguments> ...
     ...
 kafkaConfig:
   bootstrapServer: String
@@ -49,7 +51,7 @@ The properties have the following definitions:
     * **patchers**: List of [patchers](#Patchers) used to scale this resource type. Each patcher has the following structure:
         * **type**: Type of the [patcher](#Patchers). The concrete types can be looked up in the list of [patchers](#Patchers). 
         * **resources**: Specifies the Kubernetes resource to be patched.
-        * **Patcher Arguments**: (Optional) Patcher specific additional arguments.
+        *  **properties**: *Patcher Arguments*: (Optional) Patcher specific additional arguments.
 * **loadTypes**: A list of load types that can be scaled for this *benchmark*. For each load type the concrete values are defined in the *execution* object. Each load type has the following structure:
     * **typeName**: Name of the load type.
     * **patchers**: List of patchers used to scale * **resourceTypes**: A list of resource types that can be scaled for this *benchmark*. For each resource type the concrete values are defined in the *execution* resource object.Each resource type has the following structure:
@@ -57,7 +59,7 @@ The properties have the following definitions:
     * **patchers**: List of patchers used to scale this resource type. Each patcher has the following structure:
         * **type**: Type of the Patcher. The concrete types can be looked up in the list of patchers. 
         * **resources**: Specifies the Kubernetes resource to be patched.
-        * **Patcher Arguments**: (Optional) Patcher specific additional arguments.
+        * **properties**: *Patcher Arguments*: (Optional) Patcher specific additional arguments as Map<String, String>.
 * **kafkaConfig**: Contains the Kafka configuration.
     * **bootstrapServers**: The bootstrap servers connection string.
     * **topics**: List of topics to be created for each [experiment](#Experiment). Alternative theodolite offers the possibility to remove certain topics after each experiment.
@@ -105,7 +107,8 @@ configurationOverrides:
   - patcher:
       type: String
       resource: String
-      <Patcher Arguments> ...
+      properties:
+        <Patcher Arguments> ...
   ...
 ```
 
@@ -136,7 +139,7 @@ The properties have the following definitions:
   * **patcher**: Patcher used to patch a resource. Each patcher has the following structure:
         * **type**: Type of the Patcher. The concrete types can be looked up in the list of patchers. 
         * **resources**: Specifies the Kubernetes resource to be patched.
-        * **Patcher Arguments**: (Optional) Patcher specific additional arguments.
+        * **properties**: *Patcher Arguments*: (Optional) Patcher specific additional arguments.
 
 ## Patchers
 
@@ -159,19 +162,22 @@ The properties have the following definitions:
 * **EnvVarPatcher**: Allows to modify the value of an environment variable for a container in a kubernetes deployment. 
   * **type**: "EnvVarPatcher"
   * **resource**: "uc1-load-generator-deployment.yaml"
-  * **container**: "workload-generator"
-  * **variableName**: "NUM_SENSORS"
+  * **properties**:
+    * container: "workload-generator"
+    * variableName: "NUM_SENSORS"
 
 * **NodeSelectorPatcher**: Changes the node selection field in kubernetes resources.
   * **type**: "NodeSelectorPatcher"
   * **resource**: "uc1-load-generator-deployment.yaml"
-  * **variableName**: "env"
+  * **properties**:
+    * variableName: "env"
   * **value**: "prod"
 
 * **ResourceLimitPatcher**: Changes the resource limit for a kubernetes resource.
   * **resource**: "uc1-kstreams-deployment.yaml"
-  * **container**: "uc-application"
-  * **variableName**: "cpu" or "memory"
+  * **properties**:
+    * container: "uc-application"
+    * variableName: "cpu" or "memory"
   * **value**:"1000m" or "2Gi"
   
 * **SchedulerNamePatcher**: Changes the sheduler for kubernetes resources.
@@ -182,7 +188,8 @@ The properties have the following definitions:
 * **ImagePatcher**: Changes the image of a kubernetes resource. Currently not fully implemented.
   * **type**: "ImagePatcher"
   * **resource**: "uc1-kstreams-deployment.yaml"
-  * **container**: "uc-application"
+  * **properties**:
+    * container: "uc-application"
   * **value**: "dockerhubrepo/imagename"
 
 

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

+name: example-execution
+benchmark: "uc1-kstreams"
+load:
+  loadType: "NumSensors"
+  loadValues: [25000, 50000, 75000, 100000, 125000, 150000]
+resources:
+  resourceType: "Instances"
+  resourceValues: [1, 2, 3, 4, 5]
+slos:
+  - sloType: "lag trend"
+    threshold: 2000
+    prometheusUrl: "http://prometheus-operated:9090"
+    externalSloUrl: "http://localhost:80/evaluate-slope"
+    offset: 0
+    warmup: 60 # in seconds
+execution:
+  strategy: "LinearSearch"
+  duration: 300 # in seconds
+  repetitions: 1
+  loadGenerationDelay: 30 # in seconds, optional field, default is 0 seconds
+  restrictions:
+    - "LowerBound"
+configOverrides:
+  - patcher:
+      type: "NodeSelectorPatcher"
+      resource: "uc1-load-generator-deployment.yaml"
+      properties:
+        variableName: "env"
+    value: "prod"
+  - patcher:
+      type: "NodeSelectorPatcher"
+      resource: "uc1-kstreams-deployment.yaml"
+      properties:
+        variableName: "env"
+    value: "prod"
+  - patcher:
+      type: "ResourceLimitPatcher"
+      resource: "uc1-kstreams-deployment.yaml"
+      properties:
+        container: "uc-application"
+        limitedResource: "cpu"
+    value: "1000m"
+  - patcher:
+      type: "ResourceLimitPatcher"
+      resource: "uc1-kstreams-deployment.yaml"
+      properties:
+        container: "uc-application"
+        limitedResource: "memory"
+    value: "2Gi"
+#  - patcher:
+#      type: "SchedulerNamePatcher"
+#      resource: "uc1-kstreams-deployment.yaml"
+#    value: "random-scheduler"

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

+apiVersion: theodolite.com/v1
+kind: execution
+metadata:
+  name: example-execution
+spec:
+  benchmark: "uc1-kstreams"
+  load:
+    loadType: "NumSensors"
+    loadValues: [25000, 50000, 75000, 100000, 125000, 150000]
+  resources:
+    resourceType: "Instances"
+    resourceValues: [1, 2, 3, 4, 5]
+  slos:
+    - sloType: "lag trend"
+      threshold: 2000
+      prometheusUrl: "http://prometheus-operated:9090"
+      externalSloUrl: "http://localhost:80/evaluate-slope"
+      offset: 0
+      warmup: 60 # in seconds
+  execution:
+    strategy: "LinearSearch"
+    duration: 300 # in seconds
+    repetitions: 1
+    loadGenerationDelay: 30 # in seconds
+    restrictions:
+      - "LowerBound"
+  configOverrides:
+    # - patcher:
+    #     type: "NodeSelectorPatcher"
+    #     resource: "uc1-load-generator-deployment.yaml"
+    #     properties:
+    #       variableName: "env"
+    #     value: "prod"
+    # - patcher:
+    #     type: "NodeSelectorPatcher"
+    #     resource: "uc1-kstreams-deployment.yaml"
+    #     properties:
+    #       variableName: "env"
+    #   value: "prod"
+    # - patcher:
+    #     type: "ResourceLimitPatcher"
+    #     resource: "uc1-kstreams-deployment.yaml"
+    #     properties:
+    #       container: "uc-application"
+    #       limitedResource: "cpu"
+    #   value: "1000m"
+    # - patcher:
+    #     type: "ResourceLimitPatcher"
+    #     resource: "uc1-kstreams-deployment.yaml"
+    #     properties:
+    #       container: "uc-application"
+    #       limitedResource: "memory"
+    #   value: "2Gi"
+    #  - patcher:
+    #      type: "SchedulerNamePatcher"
+    #      resource: "uc1-kstreams-deployment.yaml"
+    #    value: "random-scheduler"

theodolite-quarkus/crd/crd-benchmark.yaml

@@ -54,12 +54,11 @@ spec:
                           resource:
                             type: string
                             default: ""
-                          container:
-                            type: string
-                            default: ""
-                          variableName:
-                            type: string
-                            default: ""
+                          properties:
+                            type: object
+                            additionalProperties: true
+                            x-kubernetes-map-type: "granular"
+                            default: {}
               loadTypes:
                 type: array
                 minItems: 1
@@ -80,12 +79,11 @@ spec:
                           resource:
                             type: string
                             default: ""
-                          container:
-                            type: string
-                            default: ""
-                          variableName:
-                            type: string
-                            default: ""
+                          properties:
+                            type: object
+                            additionalProperties: true
+                            x-kubernetes-map-type: "granular"
+                            default: {}
               kafkaConfig:
                 type: object
                 properties:

theodolite-quarkus/crd/crd-execution.yaml

@@ -95,12 +95,11 @@ spec:
                         resource:
                           type: string
                           default: ""
-                        container:
-                          type: string
-                          default: ""
-                        variableName:
-                          type: string
-                          default: ""
+                        properties:
+                          type: object
+                          additionalProperties: true
+                          x-kubernetes-map-type: "granular"
+                          default: {}
                     value:
                       type: string
           status:

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

@@ -183,7 +183,7 @@ class TheodoliteController(
                 val configurationOverride = ConfigurationOverride()
                 configurationOverride.patcher = PatcherDefinition()
                 configurationOverride.patcher.type = "LabelPatcher"
-                configurationOverride.patcher.variableName = labelName
+                configurationOverride.patcher.properties = mutableMapOf("variableName" to labelName)
                 configurationOverride.patcher.resource = it
                 configurationOverride.value = labelValue
                 additionalConfigOverrides.add(configurationOverride)

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

@@ -20,7 +20,5 @@ import io.fabric8.kubernetes.api.model.KubernetesResource
  *
  */
 abstract class AbstractPatcher(
-    k8sResource: KubernetesResource,
-    container: String? = null,
-    variableName: String? = null
+    k8sResource: KubernetesResource
 ) : Patcher

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

@@ -16,7 +16,7 @@ class EnvVarPatcher(
     private val k8sResource: KubernetesResource,
     private val container: String,
     private val variableName: String
-) : AbstractPatcher(k8sResource, container, variableName) {
+) : AbstractPatcher(k8sResource) {
 
     override fun <String> patch(value: String) {
         if (k8sResource is Deployment) {

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

@@ -11,7 +11,7 @@ import io.fabric8.kubernetes.api.model.apps.StatefulSet
  * @param container Container to be patched.
  */
 class ImagePatcher(private val k8sResource: KubernetesResource, private val container: String) :
-    AbstractPatcher(k8sResource, container) {
+    AbstractPatcher(k8sResource) {
 
     override fun <String> patch(imagePath: String) {
         if (k8sResource is Deployment) {

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

@@ -8,10 +8,9 @@ import io.fabric8.kubernetes.api.model.apps.StatefulSet
 import io.fabric8.kubernetes.client.CustomResource
 
 class LabelPatcher(private val k8sResource: KubernetesResource, val variableName: String) :
-    AbstractPatcher(k8sResource, variableName) {
+    AbstractPatcher(k8sResource) {
 
     override fun <String> patch(labelValue: String) {
-        println("call patcher for resource $k8sResource !")
         if(labelValue is kotlin.String){
             when(k8sResource){
                 is Deployment -> {

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

@@ -10,7 +10,7 @@ import io.fabric8.kubernetes.api.model.apps.Deployment
  * @param variableName The `label-key` of the node for which the `label-value` is to be patched.
  */
 class NodeSelectorPatcher(private val k8sResource: KubernetesResource, private val variableName: String) :
-    AbstractPatcher(k8sResource, variableName) {
+    AbstractPatcher(k8sResource) {
     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/NumNestedGroupsLoadGeneratorReplicaPatcher.kt

@@ -4,16 +4,17 @@ import io.fabric8.kubernetes.api.model.KubernetesResource
 import io.fabric8.kubernetes.api.model.apps.Deployment
 import kotlin.math.pow
 
-private const val NUM_SENSORS = 4.0
-private const val LOAD_GEN_MAX_RECORDS = 150000
-
-class NumNestedGroupsLoadGeneratorReplicaPatcher(private val k8sResource: KubernetesResource) :
+class NumNestedGroupsLoadGeneratorReplicaPatcher(
+    private val k8sResource: KubernetesResource,
+    private val numSensors: String,
+    private val loadGenMaxRecords: String
+    ) :
     AbstractPatcher(k8sResource) {
     override fun <String> patch(value: String) {
         if (k8sResource is Deployment) {
             if (value is kotlin.String) {
-                val approxNumSensors = NUM_SENSORS.pow(Integer.parseInt(value).toDouble())
-                val loadGenInstances = (approxNumSensors + LOAD_GEN_MAX_RECORDS - 1) / LOAD_GEN_MAX_RECORDS
+                val approxNumSensors =  numSensors.toDouble().pow(Integer.parseInt(value).toDouble())
+                val loadGenInstances = (approxNumSensors + loadGenMaxRecords.toDouble() - 1) / loadGenMaxRecords.toDouble()
                 this.k8sResource.spec.replicas = loadGenInstances.toInt()
             }
         }

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

@@ -3,14 +3,16 @@ package theodolite.patcher
 import io.fabric8.kubernetes.api.model.KubernetesResource
 import io.fabric8.kubernetes.api.model.apps.Deployment
 
-private const val LOAD_GEN_MAX_RECORDS = 150000
 
-class NumSensorsLoadGeneratorReplicaPatcher(private val k8sResource: KubernetesResource) :
+class NumSensorsLoadGeneratorReplicaPatcher(
+    private val k8sResource: KubernetesResource,
+    private val loadGenMaxRecords: String
+) :
     AbstractPatcher(k8sResource) {
     override fun <String> patch(value: String) {
         if (k8sResource is Deployment) {
             if (value is kotlin.String) {
-                val loadGenInstances = (Integer.parseInt(value) + LOAD_GEN_MAX_RECORDS - 1) / LOAD_GEN_MAX_RECORDS
+                val loadGenInstances = (Integer.parseInt(value) + loadGenMaxRecords.toInt() - 1) / loadGenMaxRecords.toInt()
                 this.k8sResource.spec.replicas = loadGenInstances
             }
         }

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

@@ -2,6 +2,7 @@ package theodolite.patcher
 
 import io.fabric8.kubernetes.api.model.KubernetesResource
 import theodolite.util.DeploymentFailedException
+import theodolite.util.InvalidPatcherConfigurationException
 import theodolite.util.PatcherDefinition
 
 /**
@@ -28,28 +29,56 @@ class PatcherFactory {
         k8sResources: List<Pair<String, KubernetesResource>>
     ): Patcher {
         val resource =
-            k8sResources.filter { it.first == patcherDefinition.resource }.map { resource -> resource.second }.firstOrNull()
+            k8sResources.filter { it.first == patcherDefinition.resource }
+                .map { resource -> resource.second }
+                .firstOrNull()
                 ?: throw DeploymentFailedException("Could not find resource ${patcherDefinition.resource}")
 
-        return when (patcherDefinition.type) {
-            "ReplicaPatcher" -> ReplicaPatcher(resource)
-            "NumNestedGroupsLoadGeneratorReplicaPatcher" -> NumNestedGroupsLoadGeneratorReplicaPatcher(resource)
-            "NumSensorsLoadGeneratorReplicaPatcher" -> NumSensorsLoadGeneratorReplicaPatcher(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
-            )
-            "SchedulerNamePatcher" -> SchedulerNamePatcher(resource)
-            "LabelPatcher" -> LabelPatcher(resource, patcherDefinition.variableName)
-            else -> throw IllegalArgumentException("Patcher type ${patcherDefinition.type} not found")
+        return try {
+            when (patcherDefinition.type) {
+                "ReplicaPatcher" -> ReplicaPatcher(
+                    k8sResource = resource
+                )
+                "NumNestedGroupsLoadGeneratorReplicaPatcher" -> NumNestedGroupsLoadGeneratorReplicaPatcher(
+                    k8sResource = resource,
+                    loadGenMaxRecords = patcherDefinition.properties["loadGenMaxRecords"] !!,
+                    numSensors = patcherDefinition.properties["numSensors"] !!
+                )
+                "NumSensorsLoadGeneratorReplicaPatcher" -> NumSensorsLoadGeneratorReplicaPatcher(
+                    k8sResource = resource,
+                    loadGenMaxRecords = patcherDefinition.properties["loadGenMaxRecords"] !!
+                )
+                "EnvVarPatcher" -> EnvVarPatcher(
+                    k8sResource = resource,
+                    container = patcherDefinition.properties["container"] !!,
+                    variableName = patcherDefinition.properties["variableName"] !!
+                )
+                "NodeSelectorPatcher" -> NodeSelectorPatcher(
+                    k8sResource = resource,
+                    variableName = patcherDefinition.properties["variableName"] !!
+                )
+                "ResourceLimitPatcher" -> ResourceLimitPatcher(
+                    k8sResource = resource,
+                    container = patcherDefinition.properties["container"] !!,
+                    limitedResource = patcherDefinition.properties["limitedResource"] !!
+                )
+                "ResourceRequestPatcher" -> ResourceRequestPatcher(
+                    k8sResource = resource,
+                    container = patcherDefinition.properties["container"] !!,
+                    requestedResource = patcherDefinition.properties["requestedResource"] !!
+                )
+                "SchedulerNamePatcher" -> SchedulerNamePatcher(
+                    k8sResource = resource
+                )
+                "LabelPatcher" -> LabelPatcher(
+                    k8sResource = resource,
+                    variableName = patcherDefinition.properties["variableName"] !!
+                )
+                else -> throw InvalidPatcherConfigurationException("Patcher type ${patcherDefinition.type} not found.")
+            }
+        } catch (e: Exception) {
+            throw InvalidPatcherConfigurationException("Could not create patcher with type ${patcherDefinition.type}" +
+                    " Probably a required patcher argument was not specified." )
         }
     }
 }

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

@@ -18,7 +18,7 @@ class ResourceLimitPatcher(
     private val k8sResource: KubernetesResource,
     private val container: String,
     private val limitedResource: String
-) : AbstractPatcher(k8sResource, container, limitedResource) {
+) : AbstractPatcher(k8sResource) {
 
     override fun <String> patch(value: String) {
         when (k8sResource) {

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

@@ -18,7 +18,7 @@ class ResourceRequestPatcher(
     private val k8sResource: KubernetesResource,
     private val container: String,
     private val requestedResource: String
-) : AbstractPatcher(k8sResource, container, requestedResource) {
+) : AbstractPatcher(k8sResource) {
 
     override fun <String> patch(value: String) {
         when (k8sResource) {

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

+package theodolite.util
+
+class InvalidPatcherConfigurationException(message:String): Exception(message) {
+}
+