CITATION.cff

@@ -8,7 +8,7 @@ authors:
     given-names: Wilhelm
     orcid: "https://orcid.org/0000-0001-6625-4335"
 title: Theodolite
-version: "0.4.0"
+version: "0.5.0"
 repository-code: "https://github.com/cau-se/theodolite"
 license: "Apache-2.0"
 doi: "10.1016/j.bdr.2021.100209"

README.md

@@ -4,20 +4,17 @@
 
 Theodolite is a framework for benchmarking the horizontal and vertical scalability of stream processing engines. It consists of three modules:
 
-## Theodolite Benchmarks
-
-Theodolite contains 4 application benchmarks, which are based on typical use cases for stream processing within microservices. For each benchmark, a corresponding workload generator is provided. Currently, this repository provides benchmark implementations for Apache Kafka Streams and Apache Flink. The benchmark sources can be found in [Thedolite benchmarks](benchmarks).
-
-
-## Theodolite Execution Framework
-
-Theodolite aims to benchmark scalability of stream processing engines for real use cases. Microservices that apply stream processing techniques are usually deployed in elastic cloud environments. Hence, Theodolite's cloud-native benchmarking framework deploys its components in a cloud environment, orchestrated by Kubernetes. More information on how to execute scalability benchmarks can be found in [Thedolite execution framework](execution).
+## Theodolite Benchmarking Tool
 
+Theodolite aims to benchmark scalability of stream processing engines for real use cases. Microservices that apply stream processing techniques are usually deployed in elastic cloud environments. Hence, Theodolite's cloud-native benchmarking framework deploys its components in a cloud environment, orchestrated by Kubernetes. It is recommended to install Theodolite with the package manager Helm. The Theodolite Helm chart along with instructions how to install it can be found in the [`helm`](helm) directory.
 
 ## Theodolite Analysis Tools
 
-Theodolite's benchmarking method creates a *scalability graph* allowing to draw conclusions about the scalability of a stream processing engine or its deployment. A scalability graph shows how resource demand evolves with an increasing workload. Theodolite provides Jupyter notebooks for creating such scalability graphs based on benchmarking results from the execution framework. More information can be found in [Theodolite analysis tool](analysis).
+Theodolite's benchmarking method maps load intensities to the resource amounts that are required for processing them. A plot showing how resource demand evolves with an increasing load allows to draw conclusions about the scalability of a stream processing engine or its deployment. Theodolite provides Jupyter notebooks for creating such plots based on benchmarking results from the execution framework. More information can be found in [Theodolite analysis tool](analysis).
+
+## Theodolite Benchmarks
 
+Theodolite comes with 4 application benchmarks, which are based on typical use cases for stream processing within microservices. For each benchmark, a corresponding load generator is provided. Currently, this repository provides benchmark implementations for Apache Kafka Streams and Apache Flink. The benchmark sources can be found in [Thedolite benchmarks](theodolite-benchmarks).
 
 ## How to Cite
 

analysis/demand-metric-plot.ipynb

 %% Cell type:markdown id: tags:
 
 # Theodolite Analysis - Plotting the Demand Metric
 
 This notebook creates a plot, showing scalability as a function that maps load intensities to the resources required for processing them. It is able to combine multiple such plots in one figure, for example, to compare multiple systems or configurations.
 
 The notebook takes a CSV file for each plot mapping load intensities to minimum required resources, computed by the `demand-metric-plot.ipynb` notebook.
 
 %% Cell type:markdown id: tags:
 
 First, we need to import some libraries, which are required for creating the plots.
 
 %% Cell type:code id: tags:
 
-``` python
+``` 
 import os
 import pandas as pd
 from functools import reduce
 import matplotlib.pyplot as plt
 from matplotlib.ticker import FuncFormatter
 from matplotlib.ticker import MaxNLocator
 ```
 
 %% Cell type:markdown id: tags:
 
 We need to specify the directory, where the demand CSV files can be found, and a dictionary that maps a system description (e.g. its name) to the corresponding CSV file (prefix). To use Unicode narrow non-breaking spaces in the description format it as `u"1000\u202FmCPU"`.
 
 %% Cell type:code id: tags:
 
-``` python
+``` 
 results_dir = '<path-to>/results'
 
 experiments = {
     'System XYZ': 'exp200',
 }
 ```
 
 %% Cell type:markdown id: tags:
 
 Now, we combie all systems described in `experiments`.
 
 %% Cell type:code id: tags:
 
-``` python
+``` 
 dataframes = [pd.read_csv(os.path.join(results_dir, f'{v}_demand.csv')).set_index('load').rename(columns={"resources": k}) for k, v in experiments.items()]
 
 df = reduce(lambda df1,df2: df1.join(df2,how='outer'), dataframes)
 ```
 
 %% Cell type:markdown id: tags:
 
 We might want to display the mappings before we plot it.
 
 %% Cell type:code id: tags:
 
-``` python
+``` 
 df
 ```
 
 %% Cell type:markdown id: tags:
 
 The following code creates a MatPlotLib figure showing the scalability plots for all specified systems. You might want to adjust its styling etc. according to your preferences. Make sure to also set a filename.
 
 %% Cell type:code id: tags:
 
-``` python
+``` 
 plt.style.use('ggplot')
 plt.rcParams['pdf.fonttype'] = 42 # TrueType fonts
 plt.rcParams['ps.fonttype'] = 42 # TrueType fonts
 plt.rcParams['axes.facecolor']='w'
 plt.rcParams['axes.edgecolor']='555555'
 #plt.rcParams['ytick.color']='black'
 plt.rcParams['grid.color']='dddddd'
 plt.rcParams['axes.spines.top']='false'
 plt.rcParams['axes.spines.right']='false'
 plt.rcParams['legend.frameon']='true'
 plt.rcParams['legend.framealpha']='1'
 plt.rcParams['legend.edgecolor']='1'
 plt.rcParams['legend.borderpad']='1'
 
 @FuncFormatter
 def load_formatter(x, pos):
     return f'{(x/1000):.0f}k'
 
 markers = ['s', 'D', 'o', 'v', '^', '<', '>', 'p', 'X']
 
 def splitSerToArr(ser):
     return [ser.index, ser.as_matrix()]
 
 plt.figure()
 #plt.figure(figsize=(4.8, 3.6)) # For other plot sizes
 #ax = df.plot(kind='line', marker='o')
 for i, column in enumerate(df):
     plt.plot(df[column].dropna(), marker=markers[i], label=column)
 plt.legend()
 ax = plt.gca()
 #ax = df.plot(kind='line',x='dim_value', legend=False, use_index=True)
 ax.set_ylabel('number of instances')
 ax.set_xlabel('messages/second')
 ax.set_ylim(ymin=0)
 #ax.set_xlim(xmin=0)
 ax.yaxis.set_major_locator(MaxNLocator(integer=True))
 ax.xaxis.set_major_formatter(FuncFormatter(load_formatter))
 
 plt.savefig('temp.pdf', bbox_inches='tight')
 ```
 
 %% Cell type:code id: tags:
 
-``` python
+``` 
 ```

analysis/demand-metric.ipynb

 %% Cell type:markdown id: tags:
 
 # Theodolite Analysis - Demand Metric
 
 This notebook applies Theodolite's *demand* metric to describe scalability of a SUT based on Theodolite measurement data.
 
 Theodolite's *demand* metric is a function, mapping load intensities to the minimum required resources (e.g., instances) that are required to process this load. With this notebook, the *demand* metric function is approximated by a map of tested load intensities to their minimum required resources.
 
 The final output when running this notebook will be a CSV file, providig this mapping. It can be used to create nice plots of a system's scalability using the `demand-metric-plot.ipynb` notebook.
 
 %% Cell type:markdown id: tags:
 
 In the following cell, we need to specifiy:
 
 * `exp_id`: The experiment id  that is to be analyzed.
 * `warmup_sec`: The number of seconds which are to be ignored in the beginning of each experiment.
 * `max_lag_trend_slope`: The maximum tolerable increase in queued messages per second.
 * `measurement_dir`: The directory where the measurement data files are to be found.
 * `results_dir`: The directory where the computed demand CSV files are to be stored.
 
 %% Cell type:code id: tags:
 
-``` python
+``` 
 exp_id = 200
 warmup_sec = 60
 max_lag_trend_slope = 2000
 measurement_dir = '<path-to>/measurements'
 results_dir = '<path-to>/results'
 ```
 
 %% Cell type:markdown id: tags:
 
 With the following call, we compute our demand mapping.
 
 %% Cell type:code id: tags:
 
-``` python
+``` 
 from src.demand import demand
 
 demand = demand(exp_id, measurement_dir, max_lag_trend_slope, warmup_sec)
 ```
 
 %% Cell type:markdown id: tags:
 
 We might already want to plot a simple visualization here:
 
 %% Cell type:code id: tags:
 
-``` python
+``` 
 demand.plot(kind='line',x='load',y='resources')
 ```
 
 %% Cell type:markdown id: tags:
 
 Finally we store the results in a CSV file.
 
 %% Cell type:code id: tags:
 
-``` python
+``` 
 import os
 
 demand.to_csv(os.path.join(results_dir, f'exp{exp_id}_demand.csv'), index=False)
 ```

analysis/src/demand.py

 import os
 from datetime import datetime, timedelta, timezone
 import pandas as pd
+from pandas.core.frame import DataFrame
 from sklearn.linear_model import LinearRegression
 
 def demand(exp_id, directory, threshold, warmup_sec):
     raw_runs = []
 
-    # Compute SL, i.e., lag trend, for each tested configuration
-    filenames = [filename for filename in os.listdir(directory) if filename.startswith(f"exp{exp_id}") and filename.endswith("totallag.csv")]
+    # Compute SLI, i.e., lag trend, for each tested configuration
+    filenames = [filename for filename in os.listdir(directory) if filename.startswith(f"exp{exp_id}") and "lag-trend" in filename and filename.endswith(".csv")]
     for filename in filenames:
-        #print(filename)
         run_params = filename[:-4].split("_")
-        dim_value = run_params[2]
-        instances = run_params[3]
+        dim_value = run_params[1]
+        instances = run_params[2]
 
         df = pd.read_csv(os.path.join(directory, filename))
-        #input = df.loc[df['topic'] == "input"]
         input = df
-        #print(input)
+
         input['sec_start'] = input.loc[0:, 'timestamp'] - input.iloc[0]['timestamp']
-        #print(input)
-        #print(input.iloc[0, 'timestamp'])
+    
         regress = input.loc[input['sec_start'] >= warmup_sec] # Warm-Up
-        #regress = input
 
-        #input.plot(kind='line',x='timestamp',y='value',color='red')
-        #plt.show()
+        X = regress.iloc[:, 1].values.reshape(-1, 1)  # values converts it into a numpy array
+        Y = regress.iloc[:, 2].values.reshape(-1, 1)  # -1 means that calculate the dimension of rows, but have 1 column
 
-        X = regress.iloc[:, 2].values.reshape(-1, 1)  # values converts it into a numpy array
-        Y = regress.iloc[:, 3].values.reshape(-1, 1)  # -1 means that calculate the dimension of rows, but have 1 column
         linear_regressor = LinearRegression()  # create object for the class
         linear_regressor.fit(X, Y)  # perform linear regression
         Y_pred = linear_regressor.predict(X)  # make predictions
 
         trend_slope = linear_regressor.coef_[0][0]
-        #print(linear_regressor.coef_)
 
         row = {'load': int(dim_value), 'resources': int(instances), 'trend_slope': trend_slope}
-        #print(row)
         raw_runs.append(row)
 
     runs = pd.DataFrame(raw_runs)
 
-    # Set suitable = True if SLOs are met, i.e., lag trend is below threshold
-    runs["suitable"] =  runs.apply(lambda row: row['trend_slope'] < threshold, axis=1)
-
-    # Sort results table (unsure if required)
-    runs.columns = runs.columns.str.strip()
-    runs.sort_values(by=["load", "resources"])
+    # Group by the load and resources to handle repetitions, and take from the reptitions the median
+    # for even reptitions, the mean of the two middle values is used
+    medians = runs.groupby(by=['load', 'resources'], as_index=False).median()
 
-    # Filter only suitable configurations
-    filtered = runs[runs.apply(lambda x: x['suitable'], axis=1)]
-
-    # Compute demand per load intensity
-    grouped = filtered.groupby(['load'])['resources'].min()
-    demand_per_load = grouped.to_frame().reset_index()
+    # Set suitable = True if SLOs are met, i.e., lag trend slope is below threshold
+    medians["suitable"] =  medians.apply(lambda row: row['trend_slope'] < threshold, axis=1)
 
+    suitable = medians[medians.apply(lambda x: x['suitable'], axis=1)]
+    
+    # Compute minimal demand per load intensity
+    demand_per_load = suitable.groupby(by=['load'], as_index=False)['resources'].min()
+    
     return demand_per_load
+

codemeta.json

@@ -8,7 +8,7 @@
     "dateModified": "2021-03-18",
     "downloadUrl": "https://github.com/cau-se/theodolite/releases",
     "name": "Theodolite",
-    "version": "0.4.0",
+    "version": "0.5.0",
     "description": "Theodolite is a framework for benchmarking the horizontal and vertical scalability of stream processing engines.",
     "developmentStatus": "active",
     "referencePublication": "https://doi.org/10.1016/j.bdr.2021.100209",

docs/README.md

@@ -10,16 +10,20 @@ permalink: /
 
 Theodolite is a framework for benchmarking the horizontal and vertical scalability of stream processing engines. It consists of three modules:
 
-## Theodolite Benchmarks
+## Theodolite Benchmarking Tool
 
-Theodolite contains 4 application benchmarks, which are based on typical use cases for stream processing within microservices. For each benchmark, a corresponding workload generator is provided. Currently, this repository provides benchmark implementations for Kafka Streams.
+Theodolite aims to benchmark scalability of stream processing engines for real use cases. Microservices that apply stream processing techniques are usually deployed in elastic cloud environments. Hence, Theodolite's cloud-native benchmarking framework deploys its components in a cloud environment, orchestrated by Kubernetes. It is recommended to install Theodolite with the package manager Helm. The Theodolite Helm chart along with instructions how to install it can be found in the [`helm`](helm) directory.
 
+## Theodolite Analysis Tools
 
-## Theodolite Execution Framework
+Theodolite's benchmarking method maps load intensities to the resource amounts that are required for processing them. A plot showing how resource demand evolves with an increasing load allows to draw conclusions about the scalability of a stream processing engine or its deployment. Theodolite provides Jupyter notebooks for creating such plots based on benchmarking results from the execution framework. More information can be found in [Theodolite analysis tool](analysis).
 
-Theodolite aims to benchmark scalability of stream processing engines for real use cases. Microservices that apply stream processing techniques are usually deployed in elastic cloud environments. Hence, Theodolite's cloud-native benchmarking framework deploys as components in a cloud environment, orchestrated by Kubernetes. More information on how to execute scalability benchmarks can be found in [Thedolite execution framework](execution).
+## Theodolite Benchmarks
 
+Theodolite comes with 4 application benchmarks, which are based on typical use cases for stream processing within microservices. For each benchmark, a corresponding load generator is provided. Currently, this repository provides benchmark implementations for Apache Kafka Streams and Apache Flink. The benchmark sources can be found in [Thedolite benchmarks](theodolite-benchmarks).
 
-## Theodolite Analysis Tools
+## How to Cite
+
+If you use Theodolite, please cite
 
-Theodolite's benchmarking method create a *scalability graph* allowing to draw conclusions about the scalability of a stream processing engine or its deployment. A scalability graph shows how resource demand evolves with an increasing workload. Theodolite provides Jupyter notebooks for creating such scalability graphs based on benchmarking results from the execution framework. More information can be found in [Theodolite analysis tool](analysis).
+> Sören Henning and Wilhelm Hasselbring. (2021). Theodolite: Scalability Benchmarking of Distributed Stream Processing Engines in Microservice Architectures. Big Data Research, Volume 25. DOI: [10.1016/j.bdr.2021.100209](https://doi.org/10.1016/j.bdr.2021.100209). arXiv:[2009.00304](https://arxiv.org/abs/2009.00304).

docs/index.yaml

 apiVersion: v1
 entries:
   theodolite:
+  - apiVersion: v2
+    appVersion: 0.5.0
+    created: "2021-11-04T17:45:14.153231798+01:00"
+    dependencies:
+    - condition: grafana.enabled
+      name: grafana
+      repository: https://grafana.github.io/helm-charts
+      version: 6.0.0
+    - condition: kube-prometheus-stack.enabled
+      name: kube-prometheus-stack
+      repository: https://prometheus-community.github.io/helm-charts
+      version: 12.0.0
+    - condition: cp-helm-charts.enabled
+      name: cp-helm-charts
+      repository: https://soerenhenning.github.io/cp-helm-charts
+      version: 0.6.0
+    - condition: kafka-lag-exporter.enabled
+      name: kafka-lag-exporter
+      repository: https://lightbend.github.io/kafka-lag-exporter/repo/
+      version: 0.6.6
+    description: Theodolite is a framework for benchmarking the scalability stream
+      processing engines.
+    digest: 8a4f218e44341eb8fb09ddc58c6aaa0a14aded685f3423088c21fe0ffc112281
+    home: https://cau-se.github.io/theodolite
+    maintainers:
+    - email: soeren.henning@email.uni-kiel.de
+      name: Sören Henning
+      url: https://www.se.informatik.uni-kiel.de/en/team/soeren-henning-m-sc
+    name: theodolite
+    sources:
+    - https://github.com/cau-se/theodolite
+    type: application
+    urls:
+    - https://github.com/cau-se/theodolite/releases/download/v0.5.0/theodolite-0.5.0.tgz
+    version: 0.5.0
   - apiVersion: v2
     appVersion: 0.4.0
     created: "2021-03-18T15:50:50.930902088+01:00"
@@ -36,4 +71,4 @@ entries:
     urls:
     - https://github.com/cau-se/theodolite/releases/download/v0.4.0/theodolite-0.4.0.tgz
     version: 0.4.0
-generated: "2021-03-18T15:50:50.897801281+01:00"
+generated: "2021-11-04T17:45:14.120866992+01:00"

docs/release-process.md

@@ -18,8 +18,11 @@ again be merged into master.
 
 3. Update all references to artifacts which are versioned. This includes:
 
-    1. Update all references to Theodolite Docker images to tag `v0.3.1`. These are the Kubernetes resource definitions in
-`execution`, the references to *latest* in `run_uc.py`, the Docker Compose files in `theodolite-benchmarks/docker-test` and the example `theodolite.yaml` job.
+    1. Update all references to Theodolite Docker images to tag `v0.3.1`. These are:
+        1. the default `helm/values.yaml` file,
+        2. the example `execution/theodolite.yaml` job,
+        3. the Kubernetes benchmark resources in `theodolite-benchmarks/definitions/**/resources` and
+        2. the Docker Compose files in `theodolite-benchmarks/docker-test`.
 
     2. Update both, the `version` and the `appVersion` fields, in the Helm `Charts.yaml` file to `0.3.1`.
 

execution/.gitignore

-exp_counter.txt
-results

helm/Chart.yaml

@@ -29,6 +29,6 @@ dependencies:
     repository: https://lightbend.github.io/kafka-lag-exporter/repo/
     condition: kafka-lag-exporter.enabled
 
-version: 0.5.0-SNAPSHOT
+version: 0.6.0-SNAPSHOT
 
-appVersion: 0.5.0-SNAPSHOT
+appVersion: 0.6.0-SNAPSHOT

helm/README.md

@@ -2,55 +2,49 @@
 
 ## Installation
 
-Install the chart via:
+The Theodolite Helm chart with all its dependencies can be installed via:
 
 ```sh
 helm dependencies update .
 helm install theodolite .
 ```
 
-This chart installs requirements to execute benchmarks with Theodolite.
+Additionally, a PersistentVolumeClaim with the name `theodolite-pv-claim` needs to be created or the results volume can be disabled as done with the minimal configuration, described below.
 
-Dependencies and subcharts:
+## Customize Installation
 
-- Prometheus Operator
-- Prometheus
-- Grafana (incl. dashboard and data source configuration)
-- Kafka
-- Zookeeper
-- A Kafka client pod
+As usual, the installation with Helm can be configured by passing a values YAML file:
 
-## Test
-
-Test the installation:
-
-```sh
-helm test theodolite
+```
+helm install theodolite . -f <your-config.yaml>
 ```
 
-Our test files are located [here](templates/../../theodolite-chart/templates/tests). Many subcharts have their own tests, these are also executed and are placed in the respective /templates folders. 
-
-Please note: If a test fails, Helm will stop testing.
+We provide a minimal configuration, especially suited for development environments, with the `preconfigs/minimal.yaml`
+file.
 
-It is possible that the tests are not running successfully at the moment. This is because the Helm tests of the subchart cp-confluent receive a timeout exception. There is an [issue](https://github.com/confluentinc/cp-helm-charts/issues/318) for this problem on GitHub.
+Per default, Helm installs the Theodolite CRDs used for the operator. If Theodolite will not be used as operator or if
+the CRDs are already installed, you can skip their installation by adding the flag `--skip-crds`.
 
-## Configuration
+## Test Installation
 
-In development environments Kubernetes resources are often low. To reduce resource consumption, we provide an `one-broker-value.yaml` file. This file can be used with:
+Test the installation with:
 
 ```sh
-helm install theodolite . -f preconfigs/one-broker-values.yaml
+helm test theodolite
 ```
 
+Our test files are located [here](templates/tests). Many subcharts have their own tests, which are also executed.
+Please note: If a test fails, Helm will stop testing.
+
 ## Uninstall this Chart
 
-To uninstall/delete the `theodolite` deployment:
+The Theodolite Helm can easily be removed with:
 
 ```sh
 helm uninstall theodolite
 ```
 
-This command does not remove the CRDs which are created by this chart. Remove them manually with:
+Helm does not remove any CRDs created by this chart. You can remove them manually with:
 
 ```sh
 # CRDs from Theodolite
@@ -69,9 +63,20 @@ kubectl delete crd thanosrulers.monitoring.coreos.com
 
 ## Development
 
-**Hints**:
+### Dependencies
+
+The following 3rd party charts are used by Theodolite:
+
+- Kube Prometheus Stack (to install the Prometheus Operator, which is used to create a Prometheus instances)
+- Grafana (including a dashboard and a data source configuration)
+- Confluent Platform (for Kafka and Zookeeper)
+- Kafka Lag Exporter (used to collect monitoring data of the Kafka lag)
+
+### Hints
+
+#### Grafana
 
-- Grafana configuration: Grafana ConfigMaps contains expressions like {{ topic }}. Helm uses the same syntax for template function. More information [here](https://github.com/helm/helm/issues/2798)
+Grafana ConfigMaps contain expressions like `{{ topic }}`. Helm uses the same syntax for template function. More information [here](https://github.com/helm/helm/issues/2798)
   - Escape braces: {{ "{{" topic }}
   - Let Helm render the template as raw string: {{ `{{ <config>}}` }}
   
\ No newline at end of file

helm/crds/benchmark.yaml

+./../../theodolite/crd/crd-benchmark.yaml
\ No newline at end of file

helm/crds/execution.yaml

+./../../theodolite/crd/crd-execution.yaml
\ No newline at end of file

helm/preconfigs/minimal.yaml

+cp-helm-charts:
+  cp-zookeeper:
+    servers: 1
+
+  cp-kafka:
+    brokers: 1
+    configurationOverrides:
+      offsets.topic.replication.factor: "1"
+
+operator:
+  resultsVolume:
+    enabled: false

helm/preconfigs/one-broker-values.yaml

-cp-helm-charts:
-    ## ------------------------------------------------------
-    ## Zookeeper
-    ## ------------------------------------------------------
-    cp-zookeeper:
-      servers: 1 # default: 3 
-
-  ## ------------------------------------------------------
-  ## Kafka
-  ## ------------------------------------------------------
-    cp-kafka:
-        brokers: 1 # default: 10
-
-        configurationOverrides:
-          offsets.topic.replication.factor: "1"
\ No newline at end of file

helm/templates/theodolite/crd-benchmark.yaml

-{{- if .Values.operator.benchmarkCRD.create -}}
-apiVersion: apiextensions.k8s.io/v1
-kind: CustomResourceDefinition
-metadata:
-  name: benchmarks.theodolite.com
-spec:
-  group: theodolite.com
-  names:
-    kind: benchmark
-    plural: benchmarks
-    shortNames:
-      - bench
-  versions:
-  - name: v1
-    served: true
-    storage: true
-    schema:
-      openAPIV3Schema:
-        type: object
-        required: ["spec"]
-        properties:
-          spec:
-            type: object
-            required: []
-            properties:
-              name:
-                type: string
-              appResource:
-                type: array
-                minItems: 1
-                items:
-                  type: string
-              loadGenResource:
-                type: array
-                minItems: 1
-                items:
-                  type: string
-              resourceTypes:
-                type: array
-                minItems: 1
-                items:
-                  type: object
-                  properties:
-                    typeName:
-                      type: string
-                    patchers:
-                      type: array
-                      minItems: 1
-                      items:
-                        type: object
-                        properties:
-                          type:
-                            type: string
-                            default: ""
-                          resource:
-                            type: string
-                            default: ""
-                          properties:
-                            type: object
-                            additionalProperties: true
-                            x-kubernetes-map-type: "granular"
-                            default: {}
-              loadTypes:
-                type: array
-                minItems: 1
-                items:
-                  type: object
-                  properties:
-                    typeName:
-                      type: string
-                    patchers:
-                      type: array
-                      minItems: 1
-                      items:
-                        type: object
-                        properties:
-                          type:
-                            type: string
-                            default: ""
-                          resource:
-                            type: string
-                            default: ""
-                          properties:
-                            type: object
-                            additionalProperties: true
-                            x-kubernetes-map-type: "granular"
-                            default: {}
-              kafkaConfig:
-                type: object
-                properties:
-                  bootstrapServer:
-                    type: string
-                  topics:
-                    type: array
-                    minItems: 1
-                    items:
-                      type: object
-                      required: []
-                      properties:
-                        name:
-                          type: string
-                          default: ""
-                        numPartitions:
-                          type: integer
-                          default: 0
-                        replicationFactor:
-                          type: integer
-                          default: 0
-                        removeOnly:
-                          type: boolean
-                          default: false
-    additionalPrinterColumns:
-    - name: Age
-      type: date
-      jsonPath: .metadata.creationTimestamp
-    subresources:
-      status: {}
-  scope: Namespaced
-{{- end }}

helm/templates/theodolite/crd-execution.yaml

-{{- if .Values.operator.executionCRD.create -}}
-apiVersion: apiextensions.k8s.io/v1
-kind: CustomResourceDefinition
-metadata:
-  name: executions.theodolite.com
-spec:
-  group: theodolite.com
-  names:
-    kind: execution
-    plural: executions
-    shortNames:
-      - exec
-  versions:
-  - name: v1
-    served: true
-    storage: true
-    schema:
-      openAPIV3Schema:
-        type: object
-        required: ["spec"]
-        properties:
-          spec:
-            type: object
-            required: ["benchmark", "load", "resources", "slos", "execution", "configOverrides"]
-            properties:
-              name:
-                type: string
-                default: ""
-              benchmark:
-                type: string
-              load: # definition of the load dimension
-                type: object
-                required: ["loadType", "loadValues"]
-                properties:
-                  loadType:
-                   type: string
-                  loadValues:
-                    type: array
-                    items:
-                      type: integer
-              resources: # definition of the resource dimension
-                type: object
-                required: ["resourceType", "resourceValues"]
-                properties:
-                  resourceType:
-                    type: string
-                  resourceValues:
-                    type: array
-                    items:
-                      type: integer
-              slos: # def of service level objectives
-                type: array
-                items:
-                  type: object
-                  required: ["sloType", "prometheusUrl", "offset"]
-                  properties:
-                    sloType:
-                      description: The type of the SLO. It must match 'lag trend'.
-                      type: string
-                    prometheusUrl:
-                      description: Connection string for Promehteus.
-                      type: string
-                    offset:
-                      description: Hours by which the start and end timestamp will be shifted (for different timezones).
-                      type: integer
-                    properties:
-                        description: (Optional) SLO specific additional arguments.
-                        type: object
-                        additionalProperties: true
-                        x-kubernetes-map-type: "granular"
-                        default: {}
-              execution: # def execution config
-                type: object
-                required: ["strategy", "duration", "repetitions", "restrictions"]
-                properties:
-                  strategy:
-                    type: string
-                  duration:
-                    type: integer
-                  repetitions:
-                    type: integer
-                  loadGenerationDelay:
-                    type: integer
-                  restrictions:
-                    type: array
-                    items:
-                      type: string
-              configOverrides:
-                type: array
-                items:
-                  type: object
-                  properties:
-                    patcher:
-                      type: object
-                      properties:
-                        type:
-                          type: string
-                          default: ""
-                        resource:
-                          type: string
-                          default: ""
-                        properties:
-                            type: object
-                            additionalProperties: true
-                            x-kubernetes-map-type: "granular"
-                            default: {}
-                    value:
-                      type: string
-          status:
-            type: object
-            properties:
-              executionState:
-                description: ""
-                type: string
-              executionDuration:
-                description: "Duration of the execution in seconds"
-                type: string
-    additionalPrinterColumns:
-    - name: STATUS
-      type: string
-      description: State of the execution
-      jsonPath: .status.executionState
-    - name: Duration
-      type: string
-      description: Duration of the execution
-      jsonPath: .status.executionDuration
-    - name: Age
-      type: date
-      jsonPath: .metadata.creationTimestamp
-    subresources:
-      status: {}
-  scope: Namespaced
-{{- end }}

helm/templates/theodolite/random-scheduler/deployment.yaml

@@ -22,8 +22,8 @@ spec:
       serviceAccount: {{ include "theodolite.fullname" . }}-random-scheduler
       containers:
         - name: random-scheduler
-          image: ghcr.io/cau-se/theodolite-random-scheduler:latest
-          #imagePullPolicy: Always
+          image: "{{ .Values.randomScheduler.image }}:{{ .Values.randomScheduler.imageTag }}"
+          imagePullPolicy: "{{ .Values.randomScheduler.imagePullPolicy }}"
           env:
             - name: TARGET_NAMESPACE
               value: {{ .Release.Namespace }}

helm/update-index.sh

@@ -3,7 +3,7 @@
 RELEASE_NAME=$1 # Supposed to be equal to tag, e.g., v0.3.0
 
 RELEASE_PATH="https://github.com/cau-se/theodolite/releases/download"
-REPO_INDEX="../../docs/index.yaml"
+REPO_INDEX="../docs/index.yaml"
 
 helm repo index . --url $RELEASE_PATH/$RELEASE_NAME --merge $REPO_INDEX && \
   mv index.yaml $REPO_INDEX
\ No newline at end of file