diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 01630912c52ccc728870d72c33a8f02cdf7c2c7f..f2f1bd6263e917ff4c9c78f7d851b61cacc6c57f 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -307,11 +307,23 @@ deploy-theodolite:
# Theodolite SLO Checker: Lag Trend
+test-slo-checker-lag-trend:
+ stage: test
+ image: python:3.7-slim
+ tags:
+ - exec-docker
+ script:
+ - cd slope-evaluator
+ - pip install -r requirements.txt
+ - cd app
+ - python -m unittest
+
deploy-slo-checker-lag-trend:
stage: deploy
extends:
- .dind
- needs: []
+ needs:
+ - test-slo-checker-lag-trend
script:
- DOCKER_TAG_NAME=$(echo $CI_COMMIT_REF_SLUG- | sed 's/^master-$//')
- docker build --pull -t theodolite-slo-checker-lag-trend slope-evaluator
diff --git a/execution/README.md b/execution/README.md
index ca15111c0ad7000a200c0c50427a2c2aeb75e093..eb6ade9f2aab28b6d237e9622f22da0ea5998a50 100644
--- a/execution/README.md
+++ b/execution/README.md
@@ -225,7 +225,17 @@ Theodolite locally on your machine see the description below.
see the [Configuration](#configuration) section below. Note, that you might uncomment the `serviceAccountName` line if
RBAC is enabled on your cluster (see installation of [Theodolite RBAC](#Theodolite-RBAC)).
-To start the execution of a benchmark run (with `<your-theodolite-yaml>` being your job definition):
+To start the execution of a benchmark create a ConfigMap which containts all required Kubernetes resource files for the SUT and the load generator, a ConfigMap for the execution and a ConfigMap for the benchmark.
+
+```sh
+kubectl create configmap app-resources-configmap --from-file=<folder-with-all-required-k8s-resources>
+kubectl create configmap execution-configmap --from-file=<execution.yaml>
+kubectl create configmap benchmark-configmap --from-file=<benchmark.yaml>
+```
+
+This will create three ConfigMaps. You can verify this via `kubectl get configmaps`.
+
+Start the Theodolite job (with `<your-theodolite-yaml>` being your job definition):
```sh
kubectl create -f <your-theodolite-yaml>
@@ -241,24 +251,7 @@ Kubernetes volume.
### Configuration
-| Command line | Kubernetes | Description |
-| -------------------- | ------------------- | ------------------------------------------------------------ |
-| --uc | UC | **[Mandatory]** Stream processing use case to be benchmarked. Has to be one of `1`, `2`, `3` or `4`. |
-| --loads | LOADS | **[Mandatory]** Values for the workload generator to be tested, should be sorted in ascending order. |
-| --instances | INSTANCES | **[Mandatory]** Numbers of instances to be benchmarked, should be sorted in ascending order. |
-| --duration | DURATION | Duration in minutes subexperiments should be executed for. *Default:* `5`. |
-| --partitions | PARTITIONS | Number of partitions for Kafka topics. *Default:* `40`. |
-| --cpu-limit | CPU_LIMIT | Kubernetes CPU limit for a single Pod. *Default:* `1000m`. |
-| --memory-limit | MEMORY_LIMIT | Kubernetes memory limit for a single Pod. *Default:* `4Gi`. |
-| --domain-restriction | DOMAIN_RESTRICTION | A flag that indiciates domain restriction should be used. *Default:* not set. For more details see Section [Domain Restriction](#domain-restriction). |
-| --search-strategy | SEARCH_STRATEGY | The benchmarking search strategy. Can be set to `check-all`, `linear-search` or `binary-search`. *Default:* `check-all`. For more details see Section [Benchmarking Search Strategies](#benchmarking-search-strategies). |
-| --reset | RESET | Resets the environment before each subexperiment. Useful if execution was aborted and just one experiment should be executed. |
-| --reset-only | RESET_ONLY | Only resets the environment. Ignores all other parameters. Useful if execution was aborted and one want a clean state for new executions. |
-| --namespace | NAMESPACE | Kubernetes namespace. *Default:* `default`. |
-| --prometheus | PROMETHEUS_BASE_URL | Defines where to find the prometheus instance. *Default:* `http://localhost:9090` |
-| --path | RESULT_PATH | A directory path for the results. Relative to the Execution folder. *Default:* `results` |
-| --configurations | CONFIGURATIONS | Defines environment variables for the use cases and, thus, enables further configuration options. |
-| --threshold | THRESHOLD | The threshold for the trend slop that the search strategies use to determine that a load could be handled. *Default:* `2000` |
+Be sure, that the names of the configmap corresponds correctly to the specifications of the mounted `configmaps`, `volumes`, `mountPath`. In particular: The name of the execution file and the benchmark file must match the value of the corresponding environment variable.
### Domain Restriction
diff --git a/execution/helm/.gitignore b/execution/helm/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..80bf7fc709ac6d08e703fe9f24d7d5776e26830e
--- /dev/null
+++ b/execution/helm/.gitignore
@@ -0,0 +1 @@
+charts
\ No newline at end of file
diff --git a/execution/helm/templates/grafana/dashboard-config-map.yaml b/execution/helm/templates/grafana/dashboard-config-map.yaml
index 1125d7833cc62e78c049436f38b854d926e2a216..41365e5efefaddc92a9f2f25f867a9d895e4ca3d 100644
--- a/execution/helm/templates/grafana/dashboard-config-map.yaml
+++ b/execution/helm/templates/grafana/dashboard-config-map.yaml
@@ -253,7 +253,7 @@ data:
"steppedLine": false,
"targets": [
{
- "expr": "sum by(group, topic) (kafka_consumergroup_group_lag > 0)",
+ "expr": "sum by(group, topic) (kafka_consumergroup_group_lag >= 0)",
"format": "time_series",
"intervalFactor": 1,
"legendFormat": "{{topic}}",
@@ -436,7 +436,7 @@ data:
"steppedLine": false,
"targets": [
{
- "expr": "sum by(group,topic) (kafka_consumergroup_group_offset > 0)",
+ "expr": "sum by(group,topic) (kafka_consumergroup_group_offset >= 0)",
"format": "time_series",
"intervalFactor": 1,
"legendFormat": "{{topic}}",
@@ -527,7 +527,7 @@ data:
"steppedLine": false,
"targets": [
{
- "expr": "count by(group,topic) (kafka_consumergroup_group_offset > 0)",
+ "expr": "count by(group,topic) (kafka_consumergroup_group_offset >= 0)",
"format": "time_series",
"intervalFactor": 1,
"legendFormat": "{{topic}}",
@@ -892,7 +892,7 @@ data:
"steppedLine": false,
"targets": [
{
- "expr": "sum by(group) (kafka_consumergroup_group_lag > 0)",
+ "expr": "sum by(group) (kafka_consumergroup_group_lag >= 0)",
"format": "time_series",
"intervalFactor": 1,
"legendFormat": "total lag",
diff --git a/execution/helm/templates/theodolite/crd-benchmark.yaml b/execution/helm/templates/theodolite/crd-benchmark.yaml
index 9d7468b490fa2f2a6cf829bdcafab8c4bd6fc5bf..848ecb37213f2810853a47fd45d3869198acd720 100644
--- a/execution/helm/templates/theodolite/crd-benchmark.yaml
+++ b/execution/helm/templates/theodolite/crd-benchmark.yaml
@@ -1,15 +1,121 @@
{{- if .Values.benchmarkCRD.create -}}
-apiVersion: apiextensions.k8s.io/v1beta1
+apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
name: benchmarks.theodolite.com
spec:
group: theodolite.com
- version: v1alpha1
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: ""
+ container:
+ type: string
+ default: ""
+ variableName:
+ type: string
+ 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: ""
+ container:
+ type: string
+ default: ""
+ variableName:
+ type: string
+ 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
- subresources:
- status: {}
{{- end }}
\ No newline at end of file
diff --git a/execution/helm/templates/theodolite/crd-execution.yaml b/execution/helm/templates/theodolite/crd-execution.yaml
index 73b58397b8c1fc15ffef5da74e8f1dbdabaa3a30..92835ee1d5a016d0fe6e2db874ae222d7f49f461 100644
--- a/execution/helm/templates/theodolite/crd-execution.yaml
+++ b/execution/helm/templates/theodolite/crd-execution.yaml
@@ -1,15 +1,132 @@
{{- if .Values.executionCRD.create -}}
-apiVersion: apiextensions.k8s.io/v1beta1
+apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
name: executions.theodolite.com
spec:
group: theodolite.com
- version: v1alpha1
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", "threshold", "prometheusUrl", "externalSloUrl", "offset", "warmup"]
+ properties:
+ sloType:
+ type: string
+ threshold:
+ type: integer
+ prometheusUrl:
+ type: string
+ externalSloUrl:
+ type: string
+ offset:
+ type: integer
+ warmup:
+ type: integer
+ 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: ""
+ container:
+ type: string
+ default: ""
+ variableName:
+ type: string
+ 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
- subresources:
- status: {}
+ status: {}
{{- end }}
\ No newline at end of file
diff --git a/execution/helm/templates/theodolite/random-scheduler/cluster-role-binding.yaml b/execution/helm/templates/theodolite/random-scheduler/cluster-role-binding.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..658f75c8c5018fe5b9f47cf9619bb4ee5b26b8e5
--- /dev/null
+++ b/execution/helm/templates/theodolite/random-scheduler/cluster-role-binding.yaml
@@ -0,0 +1,14 @@
+{{- if .Values.randomScheduler.rbac.create -}}
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRoleBinding
+metadata:
+ name: {{ include "theodolite.fullname" . }}-random-scheduler
+subjects:
+- kind: ServiceAccount
+ name: {{ include "theodolite.fullname" . }}-random-scheduler
+ namespace: kube-system
+roleRef:
+ kind: ClusterRole
+ apiGroup: rbac.authorization.k8s.io
+ name: system:kube-scheduler
+{{- end }}
diff --git a/execution/helm/templates/theodolite/random-scheduler/deployment.yaml b/execution/helm/templates/theodolite/random-scheduler/deployment.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..35a6ad027b93446a2bb97e2ebd67f2e27652e99a
--- /dev/null
+++ b/execution/helm/templates/theodolite/random-scheduler/deployment.yaml
@@ -0,0 +1,30 @@
+{{- if .Values.randomScheduler.enabled -}}
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+ name: {{ include "theodolite.fullname" . }}-random-scheduler
+ labels:
+ app: {{ include "theodolite.fullname" . }}
+ component: random-scheduler
+ namespace: kube-system
+spec:
+ replicas: 1
+ selector:
+ matchLabels:
+ app: {{ include "theodolite.fullname" . }}
+ component: random-scheduler
+ template:
+ metadata:
+ labels:
+ app: {{ include "theodolite.fullname" . }}
+ component: random-scheduler
+ spec:
+ serviceAccount: {{ include "theodolite.fullname" . }}-random-scheduler
+ containers:
+ - name: random-scheduler
+ image: ghcr.io/cau-se/theodolite-random-scheduler:theodolite-kotlin-latest
+ #imagePullPolicy: Always
+ env:
+ - name: TARGET_NAMESPACE
+ value: {{ .Release.Namespace }}
+{{- end }}
diff --git a/execution/helm/templates/theodolite/random-scheduler/service-account.yaml b/execution/helm/templates/theodolite/random-scheduler/service-account.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..babfff17b46d62e7e820fcb9dc8a35d73b4e6538
--- /dev/null
+++ b/execution/helm/templates/theodolite/random-scheduler/service-account.yaml
@@ -0,0 +1,10 @@
+{{- if .Values.randomScheduler.serviceAccount.create -}}
+apiVersion: v1
+kind: ServiceAccount
+metadata:
+ namespace: kube-system
+ name: {{ include "theodolite.fullname" . }}-random-scheduler
+ labels:
+ app: {{ include "theodolite.fullname" . }}
+ component: random-scheduler
+{{- end }}
diff --git a/execution/helm/templates/theodolite/role.yaml b/execution/helm/templates/theodolite/role.yaml
index ee699a5b861c64e355ca2ba44330a7d600756b77..630a84c0491328a9bb1900c1f99a8f4643020e17 100644
--- a/execution/helm/templates/theodolite/role.yaml
+++ b/execution/helm/templates/theodolite/role.yaml
@@ -56,5 +56,14 @@ rules:
- watch
- update
- patch
+ - apiGroups:
+ - coordination.k8s.io
+ resources:
+ - leases
+ verbs:
+ - delete
+ - get
+ - create
+ - update
{{- end }}
{{- end }}
\ No newline at end of file
diff --git a/execution/helm/values.yaml b/execution/helm/values.yaml
index 67dab74c3931ce13a1ab0f7504a946a208b4dfb8..d245e37e6f50d3874a1a5c06bd0156009777a999 100644
--- a/execution/helm/values.yaml
+++ b/execution/helm/values.yaml
@@ -25,8 +25,16 @@ grafana:
adminUser: admin
adminPassword: admin
grafana.ini:
+ #org_name: Theodolite
+ auth.anonymous:
+ # enable anonymous access
+ enabled: true
+ org_role: Admin # Role for unauthenticated users, other valid values are `Viewer`, `Editor` and `Admin`
users:
default_theme: light
+ #dashboards: # the following doesn't work but is planed
+ # Path to the default home dashboard. If this value is empty, then Grafana uses StaticRootPath + "dashboards/home.json"
+ #default_home_dashboard_path: "/tmp/dashboards/k8s-dashboard.json"
## Sidecars that collect the configmaps with specified label and stores the included files them into the respective folders
## Requires at least Grafana 5 to work and can't be used together with parameters dashboardProviders, datasources and dashboards
sidecar:
@@ -92,8 +100,9 @@ cp-helm-charts:
"replica.fetch.max.bytes": "134217728" # 128 MB
#default.replication.factor: 1
# "min.insync.replicas": 2
- # "auto.create.topics.enable": false
- "log.retention.ms": "10000" # 10s
+ "auto.create.topics.enable": false
+ #"log.retention.ms": "10000" # 10s
+ "log.retention.ms": "7200000" # 2h
"metrics.sample.window.ms": "5000" #5s
"advertised.listeners": |-
EXTERNAL://${HOST_IP}:$((31090 + ${KAFKA_BROKER_ID}))
@@ -248,3 +257,10 @@ serviceAccount:
rbac:
create: true
+
+randomScheduler:
+ enabled: true
+ rbac:
+ create: true
+ serviceAccount:
+ create: true
diff --git a/execution/infrastructure/kubernetes/rbac/role.yaml b/execution/infrastructure/kubernetes/rbac/role.yaml
index a21fd554f0f56b3955e9a9b6cf4bf95442b5d7af..e45814eedacd30715075f66e520f9f9e6bfc42ad 100644
--- a/execution/infrastructure/kubernetes/rbac/role.yaml
+++ b/execution/infrastructure/kubernetes/rbac/role.yaml
@@ -52,4 +52,12 @@ rules:
- watch
- update
- patch
-
+ - apiGroups:
+ - coordination.k8s.io
+ resources:
+ - leases
+ verbs:
+ - delete
+ - get
+ - create
+ - update
\ No newline at end of file
diff --git a/execution/theodolite.yaml b/execution/theodolite.yaml
index 06d14a0f589b2ac7a16ebaaae4d1490b840ea57b..ff8eecb312d052eab6f2e66a0bd57d8a983d38e1 100644
--- a/execution/theodolite.yaml
+++ b/execution/theodolite.yaml
@@ -5,47 +5,60 @@ metadata:
spec:
template:
spec:
- volumes:
- - name: theodolite-pv-storage
- persistentVolumeClaim:
- claimName: theodolite-pv-claim
+ securityContext:
+ runAsUser: 0 # Set the permissions for write access to the volumes.
containers:
+ - name: lag-analysis
+ image: ghcr.io/cau-se/theodolite-slo-checker-lag-trend:theodolite-kotlin-latest
+ ports:
+ - containerPort: 80
+ name: analysis
- name: theodolite
- image: ghcr.io/cau-se/theodolite:latest
- # imagePullPolicy: Never # Used to pull "own" local image
+ image: ghcr.io/cau-se/theodolite:theodolite-kotlin-latest
+ imagePullPolicy: Always
env:
- - name: UC # mandatory
- value: "1"
- - name: LOADS # mandatory
- value: "100000, 200000"
- - name: INSTANCES # mandatory
- value: "1, 2, 3"
- # - name: DURATION
- # value: "5"
- # - name: PARTITIONS
- # value: "40"
- # - name: DOMAIN_RESTRICTION
- # value: "True"
- # - name: SEARCH_STRATEGY
- # value: "linear-search"
- # - name: CPU_LIMIT
- # value: "1000m"
- # - name: MEMORY_LIMIT
- # value: "4Gi"
- - name: PROMETHEUS_BASE_URL
- value: "http://prometheus-operated:9090"
- # - name: NAMESPACE
- # value: "default"
- # - name: CONFIGURATIONS
- # value: "COMMIT_INTERVAL_MS=100, NUM_STREAM_THREADS=1"
- - name: RESULT_PATH
- value: "results"
- - name: PYTHONUNBUFFERED # Enable logs in Kubernetes
- value: "1"
+ - name: NAMESPACE
+ valueFrom:
+ fieldRef:
+ fieldPath: metadata.namespace
+
+ # - name: MODE
+ # value: yaml-executor # Default is `yaml-executor`
+ - name: THEODOLITE_EXECUTION
+ value: /etc/execution/example-execution-yaml-resource.yaml # The name of this file must correspond to the filename of the execution, from which the config map is created.
+ - name: THEODOLITE_BENCHMARK
+ value: /etc/benchmark/example-benchmark-yaml-resource.yaml # The name of this file must correspond to the filename of the benchmark, from which the config map is created.
+ - name: THEODOLITE_APP_RESOURCES
+ value: /etc/app-resources
+ - name: RESULTS_FOLDER # Folder for saving results
+ value: results # Default is the pwd (/deployments)
+ # - name: CREATE_RESULTS_FOLDER # Specify whether the specified result folder should be created if it does not exist.
+ # value: "false" # Default is false.
volumeMounts:
- - mountPath: "/app/results"
+ - mountPath: "/deployments/results" # the mounted path must corresponds to the value of `RESULT_FOLDER`.
name: theodolite-pv-storage
+ - mountPath: "/etc/app-resources" # must be corresponds to the value of `THEODOLITE_APP_RESOURCES`.
+ name: app-resources
+ - mountPath: "/etc/benchmark" # must be corresponds to the value of `THEODOLITE_BENCHMARK`.
+ name: benchmark
+ - mountPath: "/etc/execution" # must be corresponds to the value of `THEODOLITE_EXECUTION`.
+ name: execution
restartPolicy: Never
# Uncomment if RBAC is enabled and configured
- # serviceAccountName: theodolite
- backoffLimit: 4
+ serviceAccountName: theodolite
+ # Multiple volumes are needed to provide the corresponding files.
+ # The names must correspond to the created configmaps and the volumeMounts.
+ volumes:
+ - name: theodolite-pv-storage
+ persistentVolumeClaim:
+ claimName: theodolite-pv-claim
+ - name: app-resources
+ configMap:
+ name: app-resources-configmap
+ - name: benchmark
+ configMap:
+ name: benchmark-configmap
+ - name: execution
+ configMap:
+ name: execution-configmap
+ backoffLimit: 4
\ No newline at end of file
diff --git a/slope-evaluator/README.md b/slope-evaluator/README.md
index 5929fb157a7c783bd37497885a5e3bc373b84aa0..cd9e6820ed46452ce44d57d0c7e5cd5ae05e5a3b 100644
--- a/slope-evaluator/README.md
+++ b/slope-evaluator/README.md
@@ -5,10 +5,10 @@
For development:
```sh
-uvicorn main:app --reload
+uvicorn main:app --reload # run this command inside the app/ folder
```
-Build the docker image:
+## Build the docker image:
```sh
docker build . -t theodolite-evaluator
@@ -32,7 +32,7 @@ The running webserver provides a REST API with the following route:
* /evaluate-slope
* Method: POST
* Body:
- * total_lag
+ * total_lags
* threshold
* warmup
@@ -40,14 +40,16 @@ The body of the request must be a JSON string that satisfies the following condi
* **total_lag**: This property is based on the [Range Vector type](https://www.prometheus.io/docs/prometheus/latest/querying/api/#range-vectors) from Prometheus and must have the following JSON structure:
```
- {
- "metric": {
- "group": "<label_value>"
- },
- "values": [
- [
- <unix_timestamp>,
- "<sample_value>"
+ {
+ [
+ "metric": {
+ "group": "<label_value>"
+ },
+ "values": [
+ [
+ <unix_timestamp>,
+ "<sample_value>"
+ ]
]
]
}
diff --git a/slope-evaluator/app/main.py b/slope-evaluator/app/main.py
index 5995a1175f781c4eb51ab3d3083a665fbc02d6fd..6f6788f0ca84b7710be5b509ca4f0641047e963d 100644
--- a/slope-evaluator/app/main.py
+++ b/slope-evaluator/app/main.py
@@ -5,6 +5,7 @@ import os
import pandas as pd
import json
import sys
+from statistics import median
app = FastAPI()
@@ -20,7 +21,7 @@ elif os.getenv('LOG_LEVEL') == 'WARNING':
elif os.getenv('LOG_LEVEL') == 'DEBUG':
logger.setLevel(logging.DEBUG)
-def execute(results, threshold, warmup):
+def calculate_slope_trend(results, warmup):
d = []
for result in results:
group = result['metric']['group']
@@ -39,13 +40,16 @@ def execute(results, threshold, warmup):
logger.error('Mark this subexperiment as not successful and continue benchmark.')
return False
- result = trend_slope < threshold
- logger.info("Computed lag trend slope is '%s'. Result is: %s", trend_slope, result)
- return result
+ logger.info("Computed lag trend slope is '%s'", trend_slope)
+ return trend_slope
+
+def check_service_level_objective(results, threshold):
+ return median(results) < threshold
@app.post("/evaluate-slope",response_model=bool)
async def evaluate_slope(request: Request):
data = json.loads(await request.body())
- return execute(data['total_lag'], data['threshold'], data['warmup'])
+ results = [calculate_slope_trend(total_lag, data['warmup']) for total_lag in data['total_lags']]
+ return check_service_level_objective(results=results, threshold=data["threshold"])
-logger.info("Slope evaluator is online")
\ No newline at end of file
+logger.info("SLO evaluator is online")
\ No newline at end of file
diff --git a/slope-evaluator/app/test.py b/slope-evaluator/app/test.py
new file mode 100644
index 0000000000000000000000000000000000000000..9b165ea479bb9a552edaba7692df4fd4ef3f4ab4
--- /dev/null
+++ b/slope-evaluator/app/test.py
@@ -0,0 +1,30 @@
+import unittest
+from main import app, check_service_level_objective
+import json
+from fastapi.testclient import TestClient
+
+class TestSloEvaluation(unittest.TestCase):
+ client = TestClient(app)
+
+ def test_1_rep(self):
+ with open('../resources/test-1-rep-success.json') as json_file:
+ data = json.load(json_file)
+ response = self.client.post("/evaluate-slope", json=data)
+ self.assertEquals(response.json(), True)
+
+ def test_3_rep(self):
+ with open('../resources/test-3-rep-success.json') as json_file:
+ data = json.load(json_file)
+ response = self.client.post("/evaluate-slope", json=data)
+ self.assertEquals(response.json(), True)
+
+ def test_check_service_level_objective(self):
+ list = [1,2,3,4]
+ self.assertEquals(check_service_level_objective(list, 2), False)
+ self.assertEquals(check_service_level_objective(list, 3), True)
+ list = [1,2,3,4,5]
+ self.assertEquals(check_service_level_objective(list, 2), False)
+ self.assertEquals(check_service_level_objective(list, 4), True)
+
+if __name__ == '__main__':
+ unittest.main()
\ No newline at end of file
diff --git a/slope-evaluator/requirements.txt b/slope-evaluator/requirements.txt
index ca77b6c891136b1388aaf56c5ae269d6ee4b5729..670815f35b18361951a2fa7b2142eee6bc86b01d 100644
--- a/slope-evaluator/requirements.txt
+++ b/slope-evaluator/requirements.txt
@@ -1,3 +1,5 @@
fastapi==0.55.1
scikit-learn==0.20.3
pandas==1.0.3
+uvicorn
+requests
diff --git a/slope-evaluator/resources/test-1-rep-success.json b/slope-evaluator/resources/test-1-rep-success.json
new file mode 100644
index 0000000000000000000000000000000000000000..9e315c707be7b2a874c58fcb1093aa86f7676560
--- /dev/null
+++ b/slope-evaluator/resources/test-1-rep-success.json
@@ -0,0 +1,139 @@
+{
+ "total_lags": [
+ [
+ {
+ "metric": {
+ "group": "theodolite-uc1-application-0.0.1"
+ },
+ "values": [
+ [
+ 1.621008960827E9,
+ "234"
+ ],
+ [
+ 1.621008965827E9,
+ "234"
+ ],
+ [
+ 1.621008970827E9,
+ "234"
+ ],
+ [
+ 1.621008975827E9,
+ "719"
+ ],
+ [
+ 1.621008980827E9,
+ "719"
+ ],
+ [
+ 1.621008985827E9,
+ "719"
+ ],
+ [
+ 1.621008990827E9,
+ "1026"
+ ],
+ [
+ 1.621008995827E9,
+ "1026"
+ ],
+ [
+ 1.621009000827E9,
+ "1026"
+ ],
+ [
+ 1.621009005827E9,
+ "534"
+ ],
+ [
+ 1.621009010827E9,
+ "534"
+ ],
+ [
+ 1.621009015827E9,
+ "534"
+ ],
+ [
+ 1.621009020827E9,
+ "943"
+ ],
+ [
+ 1.621009025827E9,
+ "943"
+ ],
+ [
+ 1.621009030827E9,
+ "943"
+ ],
+ [
+ 1.621009035827E9,
+ "66"
+ ],
+ [
+ 1.621009040827E9,
+ "66"
+ ],
+ [
+ 1.621009045827E9,
+ "66"
+ ],
+ [
+ 1.621009050827E9,
+ "841"
+ ],
+ [
+ 1.621009055827E9,
+ "841"
+ ],
+ [
+ 1.621009060827E9,
+ "841"
+ ],
+ [
+ 1.621009065827E9,
+ "405"
+ ],
+ [
+ 1.621009070827E9,
+ "405"
+ ],
+ [
+ 1.621009075827E9,
+ "405"
+ ],
+ [
+ 1.621009080827E9,
+ "201"
+ ],
+ [
+ 1.621009085827E9,
+ "201"
+ ],
+ [
+ 1.621009090827E9,
+ "201"
+ ],
+ [
+ 1.621009095827E9,
+ "227"
+ ],
+ [
+ 1.621009100827E9,
+ "227"
+ ],
+ [
+ 1.621009105827E9,
+ "227"
+ ],
+ [
+ 1.621009110827E9,
+ "943"
+ ]
+ ]
+ }
+ ]
+ ],
+ "threshold": 2000,
+ "warmup": 0
+}
\ No newline at end of file
diff --git a/slope-evaluator/resources/test-3-rep-success.json b/slope-evaluator/resources/test-3-rep-success.json
new file mode 100644
index 0000000000000000000000000000000000000000..485966cba40f01e4a646e626914510ba49b707bc
--- /dev/null
+++ b/slope-evaluator/resources/test-3-rep-success.json
@@ -0,0 +1,289 @@
+{
+ "total_lags": [
+ [
+ {
+ "metric": {
+ "group": "theodolite-uc1-application-0.0.1"
+ },
+ "values": [
+ [
+ 1.621012384232E9,
+ "6073"
+ ],
+ [
+ 1.621012389232E9,
+ "6073"
+ ],
+ [
+ 1.621012394232E9,
+ "6073"
+ ],
+ [
+ 1.621012399232E9,
+ "227"
+ ],
+ [
+ 1.621012404232E9,
+ "227"
+ ],
+ [
+ 1.621012409232E9,
+ "227"
+ ],
+ [
+ 1.621012414232E9,
+ "987"
+ ],
+ [
+ 1.621012419232E9,
+ "987"
+ ],
+ [
+ 1.621012424232E9,
+ "987"
+ ],
+ [
+ 1.621012429232E9,
+ "100"
+ ],
+ [
+ 1.621012434232E9,
+ "100"
+ ],
+ [
+ 1.621012439232E9,
+ "100"
+ ],
+ [
+ 1.621012444232E9,
+ "959"
+ ],
+ [
+ 1.621012449232E9,
+ "959"
+ ],
+ [
+ 1.621012454232E9,
+ "959"
+ ],
+ [
+ 1.621012459232E9,
+ "625"
+ ],
+ [
+ 1.621012464232E9,
+ "625"
+ ],
+ [
+ 1.621012469232E9,
+ "625"
+ ],
+ [
+ 1.621012474232E9,
+ "683"
+ ],
+ [
+ 1.621012479232E9,
+ "683"
+ ],
+ [
+ 1.621012484232E9,
+ "683"
+ ],
+ [
+ 1.621012489232E9,
+ "156"
+ ]
+ ]
+ }
+ ],
+ [
+ {
+ "metric": {
+ "group": "theodolite-uc1-application-0.0.1"
+ },
+ "values": [
+ [
+ 1.621012545211E9,
+ "446"
+ ],
+ [
+ 1.621012550211E9,
+ "446"
+ ],
+ [
+ 1.621012555211E9,
+ "446"
+ ],
+ [
+ 1.621012560211E9,
+ "801"
+ ],
+ [
+ 1.621012565211E9,
+ "801"
+ ],
+ [
+ 1.621012570211E9,
+ "801"
+ ],
+ [
+ 1.621012575211E9,
+ "773"
+ ],
+ [
+ 1.621012580211E9,
+ "773"
+ ],
+ [
+ 1.621012585211E9,
+ "773"
+ ],
+ [
+ 1.621012590211E9,
+ "509"
+ ],
+ [
+ 1.621012595211E9,
+ "509"
+ ],
+ [
+ 1.621012600211E9,
+ "509"
+ ],
+ [
+ 1.621012605211E9,
+ "736"
+ ],
+ [
+ 1.621012610211E9,
+ "736"
+ ],
+ [
+ 1.621012615211E9,
+ "736"
+ ],
+ [
+ 1.621012620211E9,
+ "903"
+ ],
+ [
+ 1.621012625211E9,
+ "903"
+ ],
+ [
+ 1.621012630211E9,
+ "903"
+ ],
+ [
+ 1.621012635211E9,
+ "512"
+ ],
+ [
+ 1.621012640211E9,
+ "512"
+ ],
+ [
+ 1.621012645211E9,
+ "512"
+ ]
+ ]
+ }
+ ],
+ [
+ {
+ "metric": {
+ "group": "theodolite-uc1-application-0.0.1"
+ },
+ "values": [
+ [
+ 1.621012700748E9,
+ "6484"
+ ],
+ [
+ 1.621012705748E9,
+ "6484"
+ ],
+ [
+ 1.621012710748E9,
+ "6484"
+ ],
+ [
+ 1.621012715748E9,
+ "505"
+ ],
+ [
+ 1.621012720748E9,
+ "505"
+ ],
+ [
+ 1.621012725748E9,
+ "505"
+ ],
+ [
+ 1.621012730748E9,
+ "103"
+ ],
+ [
+ 1.621012735748E9,
+ "103"
+ ],
+ [
+ 1.621012740748E9,
+ "103"
+ ],
+ [
+ 1.621012745748E9,
+ "201"
+ ],
+ [
+ 1.621012750748E9,
+ "201"
+ ],
+ [
+ 1.621012755748E9,
+ "201"
+ ],
+ [
+ 1.621012760748E9,
+ "965"
+ ],
+ [
+ 1.621012765748E9,
+ "965"
+ ],
+ [
+ 1.621012770748E9,
+ "965"
+ ],
+ [
+ 1.621012775748E9,
+ "876"
+ ],
+ [
+ 1.621012780748E9,
+ "876"
+ ],
+ [
+ 1.621012785748E9,
+ "876"
+ ],
+ [
+ 1.621012790748E9,
+ "380"
+ ],
+ [
+ 1.621012795748E9,
+ "380"
+ ],
+ [
+ 1.621012800748E9,
+ "380"
+ ]
+ ]
+ }
+ ]
+ ],
+ "threshold": 2000,
+ "warmup": 0
+}
\ No newline at end of file
diff --git a/theodolite-benchmarks/definitions/uc1-kstreams/uc1-benchmark-operator.yaml b/theodolite-benchmarks/definitions/uc1-kstreams/uc1-benchmark-operator.yaml
index 928c083c4ae47220872e7ed83ed88bec530feba7..4ed7c868323e249ddf2137f2d4295b7e6579704b 100644
--- a/theodolite-benchmarks/definitions/uc1-kstreams/uc1-benchmark-operator.yaml
+++ b/theodolite-benchmarks/definitions/uc1-kstreams/uc1-benchmark-operator.yaml
@@ -1,34 +1,36 @@
-apiVersion: theodolite.com/v1alpha1
+apiVersion: theodolite.com/v1
kind: benchmark
metadata:
name: uc1-kstreams
-appResource:
- - "uc1-kstreams-deployment.yaml"
- - "uc1-kstreams-service.yaml"
- - "uc1-jmx-configmap.yaml"
- - "uc1-service-monitor.yaml"
-loadGenResource:
- - "uc1-load-generator-deployment.yaml"
- - "uc1-load-generator-service.yaml"
-resourceTypes:
- - typeName: "Instances"
- patchers:
- - type: "ReplicaPatcher"
- resource: "uc1-kstreams-deployment.yaml"
-loadTypes:
- - typeName: "NumSensors"
- patchers:
- - type: "EnvVarPatcher"
- resource: "uc1-load-generator-deployment.yaml"
- container: "workload-generator"
- variableName: "NUM_SENSORS"
- - type: NumSensorsLoadGeneratorReplicaPatcher
- resource: "uc1-load-generator-deployment.yaml"
-kafkaConfig:
- bootstrapServer: "theodolite-cp-kafka:9092"
- topics:
- - name: "input"
- numPartitions: 40
- replicationFactor: 1
- - name: "theodolite-.*"
- removeOnly: True
\ No newline at end of file
+spec:
+ appResource:
+ - "uc1-kstreams-deployment.yaml"
+ - "uc1-kstreams-service.yaml"
+ - "uc1-jmx-configmap.yaml"
+ - "uc1-service-monitor.yaml"
+ loadGenResource:
+ - "uc1-load-generator-deployment.yaml"
+ - "uc1-load-generator-service.yaml"
+ resourceTypes:
+ - typeName: "Instances"
+ patchers:
+ - type: "ReplicaPatcher"
+ resource: "uc1-kstreams-deployment.yaml"
+ loadTypes:
+ - typeName: "NumSensors"
+ patchers:
+ - type: "EnvVarPatcher"
+ resource: "uc1-load-generator-deployment.yaml"
+ properties:
+ container: "workload-generator"
+ variableName: "NUM_SENSORS"
+ - type: NumSensorsLoadGeneratorReplicaPatcher
+ resource: "uc1-load-generator-deployment.yaml"
+ kafkaConfig:
+ bootstrapServer: "theodolite-cp-kafka:9092"
+ topics:
+ - name: "input"
+ numPartitions: 40
+ replicationFactor: 1
+ - name: "theodolite-.*"
+ removeOnly: True
diff --git a/theodolite-benchmarks/uc1-flink/src/main/java/theodolite/uc1/application/ConfigurationKeys.java b/theodolite-benchmarks/uc1-flink/src/main/java/theodolite/uc1/application/ConfigurationKeys.java
index ed961bab733a409dc07b1be7fa35562103c3e2f4..382525cfe75f82dbbe8fbcc85308b0e7788a43bc 100644
--- a/theodolite-benchmarks/uc1-flink/src/main/java/theodolite/uc1/application/ConfigurationKeys.java
+++ b/theodolite-benchmarks/uc1-flink/src/main/java/theodolite/uc1/application/ConfigurationKeys.java
@@ -19,6 +19,8 @@ public final class ConfigurationKeys {
public static final String CHECKPOINTING = "checkpointing";
+ public static final String PARALLELISM = "parallelism";
+
private ConfigurationKeys() {}
}
diff --git a/theodolite-benchmarks/uc1-flink/src/main/java/theodolite/uc1/application/HistoryServiceFlinkJob.java b/theodolite-benchmarks/uc1-flink/src/main/java/theodolite/uc1/application/HistoryServiceFlinkJob.java
index 6655b52ec3020f46bb8a37c7124ee870fa663573..8d9832e40253fe9e3178bfc25047ed2b376abe76 100644
--- a/theodolite-benchmarks/uc1-flink/src/main/java/theodolite/uc1/application/HistoryServiceFlinkJob.java
+++ b/theodolite-benchmarks/uc1-flink/src/main/java/theodolite/uc1/application/HistoryServiceFlinkJob.java
@@ -1,6 +1,7 @@
package theodolite.uc1.application;
import org.apache.commons.configuration2.Configuration;
+import org.apache.flink.api.common.typeinfo.Types;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer;
@@ -42,6 +43,14 @@ public final class HistoryServiceFlinkJob {
if (checkpointing) {
this.env.enableCheckpointing(commitIntervalMs);
}
+
+ // Parallelism
+ final Integer parallelism = this.config.getInteger(ConfigurationKeys.PARALLELISM, null);
+ if (parallelism != null) {
+ LOGGER.error("Set parallelism: {}.", parallelism);
+ this.env.setParallelism(parallelism);
+ }
+
}
private void buildPipeline() {
@@ -61,7 +70,8 @@ public final class HistoryServiceFlinkJob {
stream
.rebalance()
.map(new GsonMapper())
- .flatMap((record, c) -> LOGGER.info("Record: {}", record));
+ .flatMap((record, c) -> LOGGER.info("Record: {}", record))
+ .returns(Types.GENERIC(Object.class)); // Will never be used
}
/**
diff --git a/theodolite-benchmarks/uc2-flink/src/main/java/theodolite/uc2/application/ConfigurationKeys.java b/theodolite-benchmarks/uc2-flink/src/main/java/theodolite/uc2/application/ConfigurationKeys.java
index 9ba56c828a0ae5c6147aadd90d449c7cf2324992..e8261062689ce4c586a4e6fbde02878a28f48e97 100644
--- a/theodolite-benchmarks/uc2-flink/src/main/java/theodolite/uc2/application/ConfigurationKeys.java
+++ b/theodolite-benchmarks/uc2-flink/src/main/java/theodolite/uc2/application/ConfigurationKeys.java
@@ -30,6 +30,8 @@ public final class ConfigurationKeys {
public static final String CHECKPOINTING = "checkpointing";
+ public static final String PARALLELISM = "parallelism";
+
private ConfigurationKeys() {}
}
diff --git a/theodolite-benchmarks/uc2-flink/src/main/java/theodolite/uc2/application/HistoryServiceFlinkJob.java b/theodolite-benchmarks/uc2-flink/src/main/java/theodolite/uc2/application/HistoryServiceFlinkJob.java
index b8452847df800226ad481f9309323a2a9a532939..1068267086892c4538001b6afc670b3b0cd043ef 100644
--- a/theodolite-benchmarks/uc2-flink/src/main/java/theodolite/uc2/application/HistoryServiceFlinkJob.java
+++ b/theodolite-benchmarks/uc2-flink/src/main/java/theodolite/uc2/application/HistoryServiceFlinkJob.java
@@ -56,6 +56,13 @@ public final class HistoryServiceFlinkJob {
this.env.enableCheckpointing(commitIntervalMs);
}
+ // Parallelism
+ final Integer parallelism = this.config.getInteger(ConfigurationKeys.PARALLELISM, null);
+ if (parallelism != null) {
+ LOGGER.error("Set parallelism: {}.", parallelism);
+ this.env.setParallelism(parallelism);
+ }
+
// State Backend
final StateBackend stateBackend = StateBackends.fromConfiguration(this.config);
this.env.setStateBackend(stateBackend);
diff --git a/theodolite-benchmarks/uc3-flink/src/main/java/theodolite/uc3/application/ConfigurationKeys.java b/theodolite-benchmarks/uc3-flink/src/main/java/theodolite/uc3/application/ConfigurationKeys.java
index a895c74d89c5d788c47b3b78dc70500b4b5a6f5b..bc4e0b9d2d230026e9d2b6df0a11e4fb68380aed 100644
--- a/theodolite-benchmarks/uc3-flink/src/main/java/theodolite/uc3/application/ConfigurationKeys.java
+++ b/theodolite-benchmarks/uc3-flink/src/main/java/theodolite/uc3/application/ConfigurationKeys.java
@@ -34,6 +34,8 @@ public final class ConfigurationKeys {
public static final String CHECKPOINTING = "checkpointing";
+ public static final String PARALLELISM = "parallelism";
+
private ConfigurationKeys() {}
}
diff --git a/theodolite-benchmarks/uc3-flink/src/main/java/theodolite/uc3/application/HistoryServiceFlinkJob.java b/theodolite-benchmarks/uc3-flink/src/main/java/theodolite/uc3/application/HistoryServiceFlinkJob.java
index 0f26d37652924a16be1840fd759b3cd5b023f338..d69ee47d8c831f2e5e74abdd8c33393c8ee6e07e 100644
--- a/theodolite-benchmarks/uc3-flink/src/main/java/theodolite/uc3/application/HistoryServiceFlinkJob.java
+++ b/theodolite-benchmarks/uc3-flink/src/main/java/theodolite/uc3/application/HistoryServiceFlinkJob.java
@@ -63,6 +63,13 @@ public final class HistoryServiceFlinkJob {
this.env.enableCheckpointing(commitIntervalMs);
}
+ // Parallelism
+ final Integer parallelism = this.config.getInteger(ConfigurationKeys.PARALLELISM, null);
+ if (parallelism != null) {
+ LOGGER.error("Set parallelism: {}.", parallelism);
+ this.env.setParallelism(parallelism);
+ }
+
// State Backend
final StateBackend stateBackend = StateBackends.fromConfiguration(this.config);
this.env.setStateBackend(stateBackend);
diff --git a/theodolite-benchmarks/uc4-flink/src/main/java/theodolite/uc4/application/AggregationServiceFlinkJob.java b/theodolite-benchmarks/uc4-flink/src/main/java/theodolite/uc4/application/AggregationServiceFlinkJob.java
index 0db5a3d524f74fbf22304e8f9b44fa55eead321a..45c7ff1ad1faeec6357e4ac3871dec7a51306698 100644
--- a/theodolite-benchmarks/uc4-flink/src/main/java/theodolite/uc4/application/AggregationServiceFlinkJob.java
+++ b/theodolite-benchmarks/uc4-flink/src/main/java/theodolite/uc4/application/AggregationServiceFlinkJob.java
@@ -76,6 +76,13 @@ public final class AggregationServiceFlinkJob {
this.env.enableCheckpointing(commitIntervalMs);
}
+ // Parallelism
+ final Integer parallelism = this.config.getInteger(ConfigurationKeys.PARALLELISM, null);
+ if (parallelism != null) {
+ LOGGER.error("Set parallelism: {}.", parallelism);
+ this.env.setParallelism(parallelism);
+ }
+
// State Backend
final StateBackend stateBackend = StateBackends.fromConfiguration(this.config);
this.env.setStateBackend(stateBackend);
diff --git a/theodolite-benchmarks/uc4-flink/src/main/java/theodolite/uc4/application/ConfigurationKeys.java b/theodolite-benchmarks/uc4-flink/src/main/java/theodolite/uc4/application/ConfigurationKeys.java
index 6497f6b055ef115c4a681499c5fa38657bb5d29e..448e8b095ef15c434655ca3c76a9e2de21244054 100644
--- a/theodolite-benchmarks/uc4-flink/src/main/java/theodolite/uc4/application/ConfigurationKeys.java
+++ b/theodolite-benchmarks/uc4-flink/src/main/java/theodolite/uc4/application/ConfigurationKeys.java
@@ -15,7 +15,7 @@ public final class ConfigurationKeys {
public static final String KAFKA_OUTPUT_TOPIC = "kafka.output.topic";
public static final String KAFKA_INPUT_TOPIC = "kafka.input.topic";
-
+
public static final String SCHEMA_REGISTRY_URL = "schema.registry.url";
public static final String WINDOW_SIZE_MS = "window.size.ms";
@@ -28,13 +28,15 @@ public final class ConfigurationKeys {
public static final String FLINK_STATE_BACKEND_PATH = "flink.state.backend.path";
- public static final String FLINK_STATE_BACKEND_MEMORY_SIZE = //NOPMD
+ public static final String FLINK_STATE_BACKEND_MEMORY_SIZE = // NOPMD
"flink.state.backend.memory.size";
public static final String DEBUG = "debug";
public static final String CHECKPOINTING = "checkpointing";
+ public static final String PARALLELISM = "parallelism";
+
private ConfigurationKeys() {}
}
diff --git a/theodolite-quarkus/README.md b/theodolite-quarkus/README.md
index bb99f34e80f8b61b42f9b10b4c1d988871b74cb0..fc1d1bfe4a9c20a515cf6e69208657f74694d80e 100644
--- a/theodolite-quarkus/README.md
+++ b/theodolite-quarkus/README.md
@@ -1,4 +1,4 @@
-# theodolite-quarkus project
+# Theodolite-quarkus project
This project uses Quarkus, the Supersonic Subatomic Java Framework.
@@ -6,7 +6,8 @@ If you want to learn more about Quarkus, please visit its website: https://quark
## Running the application in dev mode
-You can run your application in dev mode that enables live coding using:
+You can run your application in dev mode using:
+
```shell script
./gradlew quarkusDev
```
@@ -14,13 +15,16 @@ You can run your application in dev mode that enables live coding using:
## Packaging and running the application
The application can be packaged using:
+
```shell script
./gradlew build
```
-It produces the `theodolite-quarkus-1.0.0-SNAPSHOT-runner.jar` file in the `/build` directory.
-Be aware that it’s not an _über-jar_ as the dependencies are copied into the `build/lib` directory.
+
+It produces the `theodolite-quarkus-1.0.0-SNAPSHOT-runner.jar` file in the `/build` directory. Be aware that it’s not
+an _über-jar_ as the dependencies are copied into the `build/lib` directory.
If you want to build an _über-jar_, execute the following command:
+
```shell script
./gradlew build -Dquarkus.package.type=uber-jar
```
@@ -30,11 +34,13 @@ The application is now runnable using `java -jar build/theodolite-quarkus-1.0.0-
## Creating a native executable
You can create a native executable using:
+
```shell script
./gradlew build -Dquarkus.package.type=native
```
Or, if you don't have GraalVM installed, you can run the native executable build in a container using:
+
```shell script
./gradlew build -Dquarkus.package.type=native -Dquarkus.native.container-build=true
```
@@ -44,20 +50,73 @@ You can then execute your native executable with:
If you want to learn more about building native executables, please consult https://quarkus.io/guides/gradle-tooling.
-# RESTEasy JAX-RS
+## Build docker images
+
+For the jvm version use:
+
+```shell script
+./gradlew build
+docker build -f src/main/docker/Dockerfile.jvm -t theodolite-quarkus-jvm .
+```
+
+For the native image version use:
+
+```shell script
+./gradlew build -Dquarkus.package.type=native
+docker build -f src/main/docker/Dockerfile.native -t theodolite-quarkus-native .
+```
+
+## Execute docker images:
-<p>A Hello World RESTEasy resource</p>
+Remember to set the environment variables first.
-Guide: https://quarkus.io/guides/rest-json
+Jvm version:
-## Build and afterwards run the application in Docker container
+```shell script
+docker run -i --rm theodolite-quarkus-jvm
+```
+
+Native image version:
-```build_jvm.sh``` to build the jvm version
+```shell script
+docker run -i --rm theodolite-quarkus-native
+```
-```build_native.sh``` to build the native image graal version
+## Environment variables
-## Install Detekt Code analysis Plugin
+**Production:** (Docker-Container)
+| Variables name | Default value |Usage |
+| -----------------------------|:----------------------------------:| ------------:|
+| `NAMESPACE` | `default` |Determines the namespace of the Theodolite will be executed in. Used in the KubernetesBenchmark|
+| `THEODOLITE_EXECUTION` | `./config/BenchmarkExecution.yaml`|The complete path to the benchmarkExecution file. Used in the TheodoliteYamlExecutor. |
+| `THEODOLITE_BENCHMARK_TYPE` | `./config/BenchmarkType.yaml` |The complete path to the benchmarkType file. Used in the TheodoliteYamlExecutor.|
+| `THEODOLITE_APP_RESOURCES` | `./config` |The path under which the yamls for the resources for the subexperiments are found. Used in the KubernetesBenchmark|
+| `MODE` | `yaml-executor` | Defines the mode of operation: either `yaml-executor` or `operator`|
+
+**Development:** (local via Intellij)
+
+When running Theodolite from within IntelliJ via
+[Run Configurations](https://www.jetbrains.com/help/idea/work-with-gradle-tasks.html#gradle_run_config), set the *
+Environment variables* field to:
+
+```
+NAMESPACE=default;THEODOLITE_BENCHMARK=./../../../../config/BenchmarkType.yaml;THEODOLITE_APP_RESOURCES=./../../../../config;THEODOLITE_EXECUTION=./../../../../config/BenchmarkExecution.yaml;MODE=operator
+```
+
+Alternative:
+
+``` sh
+export NAMESPACE=default
+export THEODOLITE_BENCHMARK=./../../../../config/BenchmarkType.yaml
+export THEODOLITE_APP_RESOURCES=./../../../../config
+export THEODOLITE_EXECUTION=./../../../../config/BenchmarkExecution.yaml
+export MODE=operator
+./gradlew quarkusDev
+
+```
+
+#### Install Detekt Code analysis Plugin
Install https://plugins.jetbrains.com/plugin/10761-detekt
@@ -66,11 +125,10 @@ Install https://plugins.jetbrains.com/plugin/10761-detekt
- Check Enable Detekt
- Specify your detekt configuration and baseline file (optional)
-
-> detekt issues will be annotated on-the-fly while coding
**ingore Failures in build:** add
```ignoreFailures = true```
- to build.gradle detekt task
+to build.gradle detekt task
diff --git a/theodolite-quarkus/build.gradle b/theodolite-quarkus/build.gradle
index 8b61bf506dd241c5b0d4e75b1357ef3fd5966135..8c0a13d1f24cfde01c8604285c49d3f48fe6a3b7 100644
--- a/theodolite-quarkus/build.gradle
+++ b/theodolite-quarkus/build.gradle
@@ -25,9 +25,12 @@ dependencies {
implementation 'io.quarkus:quarkus-kubernetes-client'
implementation 'org.apache.kafka:kafka-clients:2.7.0'
implementation 'khttp:khttp:1.0.0'
+ compile 'junit:junit:4.12'
+
testImplementation 'io.quarkus:quarkus-junit5'
testImplementation 'io.rest-assured:rest-assured'
+ testImplementation 'org.junit-pioneer:junit-pioneer:1.4.0'
}
group 'theodolite'
diff --git a/theodolite-quarkus/config/README.md b/theodolite-quarkus/config/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..4f53d87ba9ac12099091faa315913cf93ed62bb7
--- /dev/null
+++ b/theodolite-quarkus/config/README.md
@@ -0,0 +1,194 @@
+## The Benchmark Object
+
+The *benchmark* object defines all static components of an execution of a benchmark with Theodolite.
+An exapmle for a benchmark object is given in [example-benchmark-yaml-resource](example-benchmark-yaml-resource.yaml).
+
+
+A **Benchmark** is a [*standard tool for the competitive evaluation and comparison of competing systems or components according to specific characteristics, such as performance, dependability, or security*](https://doi.org/10.1145/2668930.2688819). In Theodolite, we have [specification-based benchmarks](https://doi.org/10.1145/2668930.2688819), or at least something very close to that. That is, our benchmarks are architectural descriptions---in our case---[of typical use cases of stream processing in microservices](https://doi.org/10.1016/j.bdr.2021.100209) (e.g. our UC1). Hence, we don't really have a piece of software, which represents a benchmark. We only have implementations of benchmarks, e.g. an implementation of UC1 with Kafka Streams. For simplification, we call these *benchmark implementations* simply *benchmarks*.
+
+```yaml
+name: String
+appResource:
+ - String
+ ...
+loadGenResource:
+ - String
+ ...
+resourceTypes:
+ - typeName: String
+ patchers:
+ - type: String
+ resources: String
+ <Patcher Arguments> ...
+ ...
+loadTypes:
+ - typeName: String
+ patchers:
+ - type: String
+ resources: String
+ <Patcher Arguments> ...
+ ...
+kafkaConfig:
+ bootstrapServer: String
+ topics:
+ - name: String
+ numPartitions: UnsignedInt
+ replicationFactor: UnsignedInt
+ - name: String
+ removeOnly: bool
+ ...
+```
+
+The properties have the following definitions:
+
+* **name**: The name of the *benchmark*
+* **appResource**: A list of file names that reference Kubernetes resources that are deployed on the cluster for the system under test (SUT).
+* **loadGenResources**: A list of file names that reference Kubernetes resources that are deployed on the cluster for the load generator.
+* **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* object. Each resource type has the following structure:
+ * **typeName**: Name of the resource type.
+ * **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.
+* **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:
+ * **typeName**: Name of the resource type.
+ * **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.
+* **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.
+ * **name**: The name of the topic.
+ * **numPartitions**: The number of partitions of the topic.
+ * **replicationFactor**: The replication factor of the topic.
+ * **removeOnly**: determines if this topic should only be deleted after each experiement. For removeOnly topics the name can be a RegEx describing the topic.
+
+
+## The Execution Object
+
+A benchmark can be executed for different SUTs, by different users and multiple times. We call such an execution of a benchmark simply an *execution*. The *execution* object defines all conrete values of an Execution.
+An exapmle for an execution object is given in [example-execution-yaml-resource](example-benchmark-yaml-resource.yaml).
+
+
+```yaml
+name: String
+benchmark: String
+load:
+ loadType: String
+ loadValues:
+ - UnsignedInt
+ ...
+resources:
+ resourceType: String
+ resourceValues:
+ - UnsignedInt
+ ...
+slos:
+ - sloType: String
+ threshold: UnsignedInt
+ prometheusUrl: String
+ externalSloUrl: String
+ offset: SignedInt
+ warmup: UnsignedInt
+ ...
+executions:
+ strategy: "LinearSearch" or "BinarySearch"
+ duration: UnsignedInt
+ repetition: UnsignedInt
+ restrictions:
+ - "LowerBound"
+ ...
+configurationOverrides:
+ - patcher:
+ type: String
+ resource: String
+ <Patcher Arguments> ...
+ ...
+```
+
+The properties have the following definitions:
+
+* **name**: The name of the *execution*
+* **benchmark**: The name of the *benchmark* this *execution* is referring to.
+* **load**: Specifies the load values that are benchmarked.
+ * **loadType**: The type of the load. It must match one of the load types specified in the referenced *benchmark*.
+ * **loadValues**: List of load values for the specified load type.
+* **resources**: Specifies the scaling resource that is benchmarked.
+ * **resourceType**: The type of the resource. It must match one of the resource types specified in the referenced *benchmark*.
+ * **resourceValues**: List of resource values for the specified resource type.
+* **slos**: List of the Service Level Objective (SLO) for this *execution*. Each SLO has the following fields:
+ * **sloType**: The type of the SLO. It must match 'lag trend'.
+ * **threshold**: The threshold the SUT should meet for a sucessful experiment.
+ * **prometheusUrl**: Connection string for promehteus.
+ * **externalSloUrl**: Connection string for a external slo analysis.
+ * **offset**: Hours by which the start and end timestamp will be shifted (for different timezones).
+ * **warmup**: Seconds of time that are ignored in the analysis.
+* **executions**: Defines the overall parameter for the execution.
+ * **strategy**: Defines the used strategy for the execution: either 'LinearSearch' or 'BinarySearch'
+ * **duration**: Defines the duration of each [experiment](#Experiment) in seconds.
+ * **repetition**: Unused.
+ * **restrictions**: List of restriction strategys used to delimit the search space.
+ **- LowerBound**: Currently only supported *restriction strategy*.
+* **configurationOverrides**: List of patchers that are used to override existing configurations.
+ * **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.
+
+## Patchers
+
+* **ReplicaPatcher**: Allows to modify the number of Replicas for a kubernetes deployment.
+ * **type**: "ReplicaPatcher"
+ * **resource**: "uc1-kstreams-deployment.yaml"
+
+* **NumSensorsLoadGeneratorReplicaPatcher**: Allows to scale the nummer of load generators. Scales arcording to the following formular: (value + 15_000 - 1) / 15_000
+ * **type**: "NumSensorsLoadGeneratorReplicaPatcher"
+ * **resource**: "uc1-load-generator-deployment.yaml"
+
+* **NumNestedGroupsLoadGeneratorReplicaPatcher**: Allows to scale the nummer of load generators. Scales arcording to the following formular: (4^(value) + 15_000 -1) /15_000
+ * **type**: "NumNestedGroupsLoadGeneratorReplicaPatcher"
+ * **resource**: "uc1-load-generator-deployment.yaml"
+
+* **ReplicaPatcher**: Allows to modify the number of Replicas for a kubernetes deployment.
+ * **type**: "ReplicaPatcher"
+ * **resource**: "uc1-kstreams-deployment.yaml"
+
+* **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"
+
+* **NodeSelectorPatcher**: Changes the node selection field in kubernetes resources.
+ * **type**: "NodeSelectorPatcher"
+ * **resource**: "uc1-load-generator-deployment.yaml"
+ * **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"
+ * **value**:"1000m" or "2Gi"
+
+* **SchedulerNamePatcher**: Changes the sheduler for kubernetes resources.
+ * **type**: "SchedulerNamePatcher"
+ * **resource**: "uc1-kstreams-deployment.yaml"
+ * **value**: "random-scheduler"
+
+* **ImagePatcher**: Changes the image of a kubernetes resource. Currently not fully implemented.
+ * **type**: "ImagePatcher"
+ * **resource**: "uc1-kstreams-deployment.yaml"
+ * **container**: "uc-application"
+ * **value**: "dockerhubrepo/imagename"
+
+
+
+## Experiment
+According to [our benchmarking method](https://doi.org/10.1016/j.bdr.2021.100209), the execution of a benchmark requires performing multiple **Experiments**. I think what is actually done within/during an experiment is another level of detail. (But just for the sake of completeness: In an experiment, the benchmark implementation is deployed, load is generated according to the benchmark specification, some SLOs are monitored continuously, etc.)
+
+
+
diff --git a/theodolite-quarkus/config/example-execution-yaml-resource.yaml b/theodolite-quarkus/config/example-execution-yaml-resource.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..e0b327a022099410fea8028fb5d37fee5672a857
--- /dev/null
+++ b/theodolite-quarkus/config/example-execution-yaml-resource.yaml
@@ -0,0 +1,49 @@
+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"
+# variableName: "env"
+# value: "prod"
+# - patcher:
+# type: "NodeSelectorPatcher"
+# 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"
diff --git a/theodolite-quarkus/crd/crd-benchmark.yaml b/theodolite-quarkus/crd/crd-benchmark.yaml
index 8fb3de1928f051d338a78ee58da074a73ef933c1..4e481c51231999e2e7a1e75ecbc018d40db75c91 100644
--- a/theodolite-quarkus/crd/crd-benchmark.yaml
+++ b/theodolite-quarkus/crd/crd-benchmark.yaml
@@ -1,13 +1,119 @@
-apiVersion: apiextensions.k8s.io/v1beta1
+apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
name: benchmarks.theodolite.com
spec:
group: theodolite.com
- version: v1alpha1
names:
kind: benchmark
plural: benchmarks
- scope: Namespaced
- subresources:
- status: {}
\ No newline at end of file
+ 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: ""
+ container:
+ type: string
+ default: ""
+ variableName:
+ type: string
+ 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: ""
+ container:
+ type: string
+ default: ""
+ variableName:
+ type: string
+ 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
\ No newline at end of file
diff --git a/theodolite-quarkus/crd/crd-execution.yaml b/theodolite-quarkus/crd/crd-execution.yaml
index 0bdb83c6201112a750bad41b81321b7a108a66fa..8e1189572ee993c37dd565fc62a66996654766f2 100644
--- a/theodolite-quarkus/crd/crd-execution.yaml
+++ b/theodolite-quarkus/crd/crd-execution.yaml
@@ -1,13 +1,129 @@
-apiVersion: apiextensions.k8s.io/v1beta1
+apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
name: executions.theodolite.com
spec:
group: theodolite.com
- version: v1alpha1
names:
kind: execution
plural: executions
- scope: Namespaced
- subresources:
- status: {}
\ No newline at end of file
+ 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", "threshold", "prometheusUrl", "externalSloUrl", "offset", "warmup"]
+ properties:
+ sloType:
+ type: string
+ threshold:
+ type: integer
+ prometheusUrl:
+ type: string
+ externalSloUrl:
+ type: string
+ offset:
+ type: integer
+ warmup:
+ type: integer
+ 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: ""
+ container:
+ type: string
+ default: ""
+ variableName:
+ type: string
+ 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
\ No newline at end of file
diff --git a/theodolite-quarkus/examples/operator/example-benchmark.yaml b/theodolite-quarkus/examples/operator/example-benchmark.yaml
index a7c0761b2dc915eea392e1160b6f37b611886c36..829194f11d0dfe71cf487bef61baa19fee00efb5 100644
--- a/theodolite-quarkus/examples/operator/example-benchmark.yaml
+++ b/theodolite-quarkus/examples/operator/example-benchmark.yaml
@@ -1,33 +1,36 @@
-apiVersion: theodolite.com/v1alpha1
+apiVersion: theodolite.com/v1
kind: benchmark
metadata:
name: uc1-kstreams
-appResource:
- - "uc1-kstreams-deployment.yaml"
- - "aggregation-service.yaml"
- - "jmx-configmap.yaml"
-loadGenResource:
- - "uc1-load-generator-deployment.yaml"
- - "uc1-load-generator-service.yaml"
-resourceTypes:
- - typeName: "Instances"
- patchers:
- - type: "ReplicaPatcher"
- resource: "uc1-kstreams-deployment.yaml"
-loadTypes:
- - typeName: "NumSensors"
- patchers:
- - type: "EnvVarPatcher"
- resource: "uc1-load-generator-deployment.yaml"
- container: "workload-generator"
- variableName: "NUM_SENSORS"
- - type: "NumSensorsLoadGeneratorReplicaPatcher"
- resource: "uc1-load-generator-deployment.yaml"
-kafkaConfig:
- bootstrapServer: "theodolite-cp-kafka:9092"
- topics:
- - name: "input"
- numPartitions: 40
- replicationFactor: 1
- - name: "theodolite-.*"
- removeOnly: True
\ No newline at end of file
+spec:
+ appResource:
+ - "uc1-kstreams-deployment.yaml"
+ - "aggregation-service.yaml"
+ - "jmx-configmap.yaml"
+ - "uc1-service-monitor.yaml"
+ loadGenResource:
+ - "uc1-load-generator-deployment.yaml"
+ - "uc1-load-generator-service.yaml"
+ resourceTypes:
+ - typeName: "Instances"
+ patchers:
+ - type: "ReplicaPatcher"
+ resource: "uc1-kstreams-deployment.yaml"
+ loadTypes:
+ - typeName: "NumSensors"
+ patchers:
+ - type: "EnvVarPatcher"
+ resource: "uc1-load-generator-deployment.yaml"
+ properties:
+ container: "workload-generator"
+ variableName: "NUM_SENSORS"
+ - type: "NumSensorsLoadGeneratorReplicaPatcher"
+ resource: "uc1-load-generator-deployment.yaml"
+ kafkaConfig:
+ bootstrapServer: "theodolite-cp-kafka:9092"
+ topics:
+ - name: "input"
+ numPartitions: 40
+ replicationFactor: 1
+ - name: "theodolite-.*"
+ removeOnly: True
diff --git a/theodolite-quarkus/examples/operator/example-execution.yaml b/theodolite-quarkus/examples/operator/example-execution.yaml
index ef625dfe6ec78c2cc0ed099dfee0f767d57263bb..4227020e7750c8e93f92c469d7796e381eb452e3 100644
--- a/theodolite-quarkus/examples/operator/example-execution.yaml
+++ b/theodolite-quarkus/examples/operator/example-execution.yaml
@@ -1,37 +1,41 @@
-apiVersion: theodolite.com/v1alpha1
+apiVersion: theodolite.com/v1
kind: execution
metadata:
name: theodolite-example-execution
-benchmark: "uc1-kstreams"
-load:
- loadType: "NumSensors"
- loadValues:
- - 50000
-resources:
- resourceType: "Instances"
- resourceValues:
- - 1
-slos:
- - sloType: "lag trend"
- threshold: 1000
- prometheusUrl: "http://localhost:32656"
- externalSloUrl: "http://localhost:80/evaluate-slope"
- offset: 0
- warmup: 0
-execution:
- strategy: "LinearSearch"
- duration: 60
- repetitions: 1
- restrictions:
- - "LowerBound"
-configOverrides:
- - patcher:
- type: "NodeSelectorPatcher"
- resource: "uc1-load-generator-deployment.yaml"
- variableName: "env"
- value: "prod"
- - patcher:
- type: "NodeSelectorPatcher"
- resource: "uc1-kstreams-deployment.yaml"
- variableName: "env"
- value: "prod"
\ No newline at end of file
+spec:
+ benchmark: uc1-kstreams
+ load:
+ loadType: "NumSensors"
+ loadValues:
+ - 50000
+ resources:
+ resourceType: "Instances"
+ resourceValues:
+ - 1
+ slos:
+ - sloType: "lag trend"
+ threshold: 1000
+ prometheusUrl: "http://localhost:32656"
+ externalSloUrl: "http://localhost:80/evaluate-slope"
+ offset: 0
+ warmup: 0
+ execution:
+ strategy: "LinearSearch"
+ duration: 60
+ repetitions: 1
+ loadGenerationDelay: 30 # in seconds
+ restrictions:
+ - "LowerBound"
+ configOverrides:
+ - patcher:
+ type: "NodeSelectorPatcher"
+ resource: "uc1-load-generator-deployment.yaml"
+ container: ""
+ variableName: "env"
+ value: "prod"
+ - patcher:
+ type: "NodeSelectorPatcher"
+ resource: "uc1-kstreams-deployment.yaml"
+ container: ""
+ variableName: "env"
+ value: "prod"
diff --git a/theodolite-quarkus/examples/standalone/example-benchmark.yaml b/theodolite-quarkus/examples/standalone/example-benchmark.yaml
index ebc2fe9e44fe303e342cabee301cb63664867cfb..cdc2122d9e6b568f1a75b0d55eff8a0af6450983 100644
--- a/theodolite-quarkus/examples/standalone/example-benchmark.yaml
+++ b/theodolite-quarkus/examples/standalone/example-benchmark.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
diff --git a/theodolite-quarkus/src/main/docker/Dockerfile.native b/theodolite-quarkus/src/main/docker/Dockerfile.native
index 37a5a4bd8472a358194dbb14a5fce61df94804d3..29836a7148b573c3051c33341718b06008fa07e2 100644
--- a/theodolite-quarkus/src/main/docker/Dockerfile.native
+++ b/theodolite-quarkus/src/main/docker/Dockerfile.native
@@ -15,12 +15,12 @@
#
###
FROM registry.access.redhat.com/ubi8/ubi-minimal:8.3
-WORKDIR /work/
-RUN chown 1001 /work \
- && chmod "g+rwX" /work \
- && chown 1001:root /work
-COPY --chown=1001:root build/*-runner /work/application
-COPY config/ /work/config/
+WORKDIR /deployments
+RUN chown 1001 /deployments \
+ && chmod "g+rwX" /deployments \
+ && chown 1001:root /deployments
+COPY --chown=1001:root build/*-runner /deployments/application
+COPY config/ /deployments/config/
EXPOSE 8080
USER 1001
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/benchmark/Benchmark.kt b/theodolite-quarkus/src/main/kotlin/theodolite/benchmark/Benchmark.kt
index db7999b205c61d94fa17791a5d549a2620601b6b..d57a28e8bbcf4dc101e4814ecaa0d52fe28c08a9 100644
--- a/theodolite-quarkus/src/main/kotlin/theodolite/benchmark/Benchmark.kt
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/benchmark/Benchmark.kt
@@ -1,5 +1,8 @@
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.quarkus.runtime.annotations.RegisterForReflection
import theodolite.util.ConfigurationOverride
import theodolite.util.LoadDimension
@@ -21,6 +24,8 @@ interface Benchmark {
fun buildDeployment(
load: LoadDimension,
res: Resource,
- configurationOverrides: List<ConfigurationOverride?>
+ configurationOverrides: List<ConfigurationOverride?>,
+ loadGenerationDelay: Long,
+ afterTeardownDelay: Long
): BenchmarkDeployment
}
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/benchmark/BenchmarkExecution.kt b/theodolite-quarkus/src/main/kotlin/theodolite/benchmark/BenchmarkExecution.kt
index 2d5d15b3389cf723be3a8ceb0fff8b27bd700419..62ab75898d16ff2732ab6aa5c254ec8f87fb7266 100644
--- a/theodolite-quarkus/src/main/kotlin/theodolite/benchmark/BenchmarkExecution.kt
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/benchmark/BenchmarkExecution.kt
@@ -2,8 +2,6 @@ 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
@@ -26,7 +24,7 @@ import kotlin.properties.Delegates
*/
@JsonDeserialize
@RegisterForReflection
-class BenchmarkExecution : CustomResource(), Namespaced {
+class BenchmarkExecution : KubernetesResource {
var executionId: Int = 0
lateinit var name: String
lateinit var benchmark: String
@@ -34,7 +32,7 @@ class BenchmarkExecution : CustomResource(), Namespaced {
lateinit var resources: ResourceDefinition
lateinit var slos: List<Slo>
lateinit var execution: Execution
- lateinit var configOverrides: List<ConfigurationOverride?>
+ lateinit var configOverrides: MutableList<ConfigurationOverride?>
/**
* This execution encapsulates the [strategy], the [duration], the [repetitions], and the [restrictions]
@@ -47,6 +45,8 @@ class BenchmarkExecution : CustomResource(), Namespaced {
var duration by Delegates.notNull<Long>()
var repetitions by Delegates.notNull<Int>()
lateinit var restrictions: List<String>
+ var loadGenerationDelay = 0L
+ var afterTeardownDelay = 5L
}
/**
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/benchmark/BenchmarkExecutionList.kt b/theodolite-quarkus/src/main/kotlin/theodolite/benchmark/BenchmarkExecutionList.kt
deleted file mode 100644
index 50e8967f20aebad880ebd218136749af8e3ea6ee..0000000000000000000000000000000000000000
--- a/theodolite-quarkus/src/main/kotlin/theodolite/benchmark/BenchmarkExecutionList.kt
+++ /dev/null
@@ -1,5 +0,0 @@
-package theodolite.benchmark
-
-import io.fabric8.kubernetes.client.CustomResourceList
-
-class BenchmarkExecutionList : CustomResourceList<BenchmarkExecution>()
\ No newline at end of file
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/benchmark/KubernetesBenchmark.kt b/theodolite-quarkus/src/main/kotlin/theodolite/benchmark/KubernetesBenchmark.kt
index bbcb8a957fb2f04ca678b231a878be0a23d46748..aa9c36ad912437e3b104dccf6ff1f4dea5905946 100644
--- a/theodolite-quarkus/src/main/kotlin/theodolite/benchmark/KubernetesBenchmark.kt
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/benchmark/KubernetesBenchmark.kt
@@ -1,5 +1,6 @@
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
@@ -22,7 +23,7 @@ private var DEFAULT_NAMESPACE = "default"
* - [loadGenResource] resource that generates the load,
* - [resourceTypes] types of scaling resources,
* - [loadTypes] types of loads that can be scaled for the benchmark,
- * - [kafkaConfig] for the [TopicManager],
+ * - [kafkaConfig] for the [theodolite.k8s.TopicManager],
* - [namespace] for the client,
* - [path] under which the resource yamls can be found.
*
@@ -30,16 +31,18 @@ private var DEFAULT_NAMESPACE = "default"
* for the deserializing in the [theodolite.execution.operator.TheodoliteOperator].
* @constructor construct an empty Benchmark.
*/
+@JsonDeserialize
@RegisterForReflection
-class KubernetesBenchmark : Benchmark, CustomResource(), Namespaced {
+class KubernetesBenchmark: KubernetesResource, Benchmark{
lateinit var name: String
lateinit var appResource: List<String>
lateinit var loadGenResource: List<String>
lateinit var resourceTypes: List<TypeName>
lateinit var loadTypes: List<TypeName>
lateinit var kafkaConfig: KafkaConfig
- private val namespace = System.getenv("NAMESPACE") ?: DEFAULT_NAMESPACE
- var path = System.getenv("THEODOLITE_APP_RESOURCES") ?: "./config"
+ var namespace = System.getenv("NAMESPACE") ?: DEFAULT_NAMESPACE
+ var path = System.getenv("THEODOLITE_APP_RESOURCES") ?: "./config"
+
/**
* Loads [KubernetesResource]s.
@@ -63,38 +66,45 @@ class KubernetesBenchmark : Benchmark, CustomResource(), Namespaced {
* First loads all required resources and then patches them to the concrete load and resources for the experiment.
* Afterwards patches additional configurations(cluster depending) into the resources.
* @param load concrete load that will be benchmarked in this experiment.
- * @param res concrete resoruce that will be scaled for this experiment.
+ * @param res concrete resource that will be scaled for this experiment.
* @param configurationOverrides
* @return a [BenchmarkDeployment]
*/
override fun buildDeployment(
load: LoadDimension,
res: Resource,
- configurationOverrides: List<ConfigurationOverride?>
+ configurationOverrides: List<ConfigurationOverride?>,
+ loadGenerationDelay: Long,
+ afterTeardownDelay: 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,
+ afterTeardownDelay = afterTeardownDelay,
kafkaConfig = hashMapOf("bootstrap.servers" to kafkaConfig.bootstrapServer),
topics = kafkaConfig.topics,
client = DefaultKubernetesClient().inNamespace(namespace)
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/benchmark/KubernetesBenchmarkDeployment.kt b/theodolite-quarkus/src/main/kotlin/theodolite/benchmark/KubernetesBenchmarkDeployment.kt
index a6bf881d6ded7b0936b400a37b572c77c95bb241..6cf239676ddb24752f4754a85fc62657f9eb6603 100644
--- a/theodolite-quarkus/src/main/kotlin/theodolite/benchmark/KubernetesBenchmarkDeployment.kt
+++ b/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,10 @@ 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 afterTeardownDelay: Long,
private val kafkaConfig: HashMap<String, Any>,
private val topics: List<KafkaConfig.TopicWrapper>,
private val client: NamespacedKubernetesClient
@@ -30,7 +34,6 @@ class KubernetesBenchmarkDeployment(
private val kafkaController = TopicManager(this.kafkaConfig)
private val kubernetesManager = K8sManager(client)
private val LAG_EXPORTER_POD_LABEL = "app.kubernetes.io/name=kafka-lag-exporter"
- private val SLEEP_AFTER_TEARDOWN = 5000L
/**
* Setup a [KubernetesBenchmark] using the [TopicManager] and the [K8sManager]:
@@ -39,9 +42,12 @@ class KubernetesBenchmarkDeployment(
*/
override fun setup() {
val kafkaTopics = this.topics.filter { !it.removeOnly }
- .map{ NewTopic(it.name, it.numPartitions, it.replicationFactor) }
+ .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,12 +57,11 @@ 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." }
- Thread.sleep(SLEEP_AFTER_TEARDOWN)
+ logger.info { "Teardown complete. Wait $afterTeardownDelay ms to let everything come down." }
+ Thread.sleep(Duration.ofSeconds(afterTeardownDelay).toMillis())
}
}
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/benchmark/KubernetesBenchmarkList.kt b/theodolite-quarkus/src/main/kotlin/theodolite/benchmark/KubernetesBenchmarkList.kt
deleted file mode 100644
index 0930875e96146fda58301478bda68b00c229e99f..0000000000000000000000000000000000000000
--- a/theodolite-quarkus/src/main/kotlin/theodolite/benchmark/KubernetesBenchmarkList.kt
+++ /dev/null
@@ -1,5 +0,0 @@
-package theodolite.benchmark
-
-import io.fabric8.kubernetes.client.CustomResourceList
-
-class KubernetesBenchmarkList : CustomResourceList<KubernetesBenchmark>()
\ No newline at end of file
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/evaluation/AnalysisExecutor.kt b/theodolite-quarkus/src/main/kotlin/theodolite/evaluation/AnalysisExecutor.kt
index f15ec808ae8fdcd6ba31f500f819a08718db774b..ef4d371173c7099eb091f90cddbe26d31e6522be 100644
--- a/theodolite-quarkus/src/main/kotlin/theodolite/evaluation/AnalysisExecutor.kt
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/evaluation/AnalysisExecutor.kt
@@ -2,6 +2,7 @@ package theodolite.evaluation
import mu.KotlinLogging
import theodolite.benchmark.BenchmarkExecution
+import theodolite.util.IOHandler
import theodolite.util.LoadDimension
import theodolite.util.Resource
import java.text.Normalizer
@@ -34,20 +35,28 @@ class AnalysisExecutor(
* @param executionDuration of the experiment.
* @return true if the experiment succeeded.
*/
- fun analyze(load: LoadDimension, res: Resource, executionDuration: Duration): Boolean {
+ fun analyze(load: LoadDimension, res: Resource, executionIntervals: List<Pair<Instant, Instant>>): Boolean {
var result = false
+ var repetitionCounter = 1
try {
- val prometheusData = fetcher.fetchMetric(
- start = Instant.now().minus(executionDuration),
- end = Instant.now(),
- query = "sum by(group)(kafka_consumergroup_group_lag >= 0)"
- )
+ val ioHandler = IOHandler()
+ val resultsFolder: String = ioHandler.getResultFolderURL()
+ val fileURL = "${resultsFolder}exp${executionId}_${load.get()}_${res.get()}_${slo.sloType.toSlug()}"
+
+ val prometheusData = executionIntervals
+ .map { interval -> fetcher.fetchMetric(
+ start = interval.first,
+ end = interval.second,
+ query = "sum by(group)(kafka_consumergroup_group_lag >= 0)") }
+
+ prometheusData.forEach{ data ->
+ ioHandler.writeToCSVFile(
+ fileURL = "${fileURL}_${repetitionCounter++}",
+ data = data.getResultAsList(),
+ columns = listOf("group", "timestamp", "value"))
+ }
- CsvExporter().toCsv(
- name = "exp${executionId}_${load.get()}_${res.get()}_${slo.sloType.toSlug()}",
- prom = prometheusData
- )
val sloChecker = SloCheckerFactory().create(
sloType = slo.sloType,
externalSlopeURL = slo.externalSloUrl,
@@ -55,10 +64,7 @@ class AnalysisExecutor(
warmup = slo.warmup
)
- result = sloChecker.evaluate(
- start = Instant.now().minus(executionDuration),
- end = Instant.now(), fetchedData = prometheusData
- )
+ result = sloChecker.evaluate(prometheusData)
} catch (e: Exception) {
logger.error { "Evaluation failed for resource '${res.get()}' and load '${load.get()}'. Error: $e" }
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/evaluation/CsvExporter.kt b/theodolite-quarkus/src/main/kotlin/theodolite/evaluation/CsvExporter.kt
deleted file mode 100644
index 4ef78cd58085c4ff5fed1477fa08ae2e6342aa66..0000000000000000000000000000000000000000
--- a/theodolite-quarkus/src/main/kotlin/theodolite/evaluation/CsvExporter.kt
+++ /dev/null
@@ -1,53 +0,0 @@
-package theodolite.evaluation
-
-import mu.KotlinLogging
-import theodolite.util.PrometheusResponse
-import java.io.File
-import java.io.PrintWriter
-import java.util.*
-
-private val logger = KotlinLogging.logger {}
-
-/**
- * Used to document the data received from prometheus for additional offline analysis.
- */
-class CsvExporter {
-
- /**
- * Uses the [PrintWriter] to transform a [PrometheusResponse] to a CSV file.
- * @param name of the file.
- * @param prom Response that is documented.
- *
- */
- fun toCsv(name: String, prom: PrometheusResponse) {
- val responseArray = promResponseToList(prom)
- val csvOutputFile = File("$name.csv")
-
- PrintWriter(csvOutputFile).use { pw ->
- pw.println(listOf("group", "timestamp", "value").joinToString())
- responseArray.forEach {
- pw.println(it.joinToString())
- }
- }
- logger.info { "Wrote CSV file: $name to ${csvOutputFile.absolutePath}." }
- }
-
- /**
- * Converts a [PrometheusResponse] into a [List] of [List]s of [String]s
- */
- private fun promResponseToList(prom: PrometheusResponse): List<List<String>> {
- val name = prom.data?.result?.get(0)?.metric?.group.toString()
- val values = prom.data?.result?.get(0)?.values
- val dataList = mutableListOf<List<String>>()
-
- if (values != null) {
- for (maybeValuePair in values) {
- val valuePair = maybeValuePair as List<*>
- val timestamp = (valuePair[0] as Double).toLong().toString()
- val value = valuePair[1].toString()
- dataList.add(listOf(name, timestamp, value))
- }
- }
- return Collections.unmodifiableList(dataList)
- }
-}
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/evaluation/ExternalSloChecker.kt b/theodolite-quarkus/src/main/kotlin/theodolite/evaluation/ExternalSloChecker.kt
index 8eac05a815e0bc45e1abc38bcdf0352e61bd7730..f7ebee8faf740583dbe6a37381a599e9bde19280 100644
--- a/theodolite-quarkus/src/main/kotlin/theodolite/evaluation/ExternalSloChecker.kt
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/evaluation/ExternalSloChecker.kt
@@ -35,10 +35,10 @@ class ExternalSloChecker(
* @return true if the experiment was successful(the threshold was not exceeded.
* @throws ConnectException if the external service could not be reached.
*/
- override fun evaluate(start: Instant, end: Instant, fetchedData: PrometheusResponse): Boolean {
+ override fun evaluate(fetchedData: List<PrometheusResponse>): Boolean {
var counter = 0
val data = Gson().toJson(mapOf(
- "total_lag" to fetchedData.data?.result,
+ "total_lags" to fetchedData.map { it.data?.result},
"threshold" to threshold,
"warmup" to warmup))
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/evaluation/SloChecker.kt b/theodolite-quarkus/src/main/kotlin/theodolite/evaluation/SloChecker.kt
index 94d816d87923f4d8343c6c83dd9747f1cc25ff81..9ee5fe7ef34ce5b6214882ce2c1d19677f1d7130 100644
--- a/theodolite-quarkus/src/main/kotlin/theodolite/evaluation/SloChecker.kt
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/evaluation/SloChecker.kt
@@ -1,14 +1,12 @@
package theodolite.evaluation
import theodolite.util.PrometheusResponse
-import java.time.Instant
/**
- * A SloChecker can be used to evaluate data from Promehteus.
+ * A SloChecker can be used to evaluate data from Prometheus.
* @constructor Creates an empty SloChecker
*/
interface SloChecker {
-
/**
* Evaluates [fetchedData] and returns if the experiment was successful.
* Returns if the evaluated experiment was successful.
@@ -18,5 +16,5 @@ interface SloChecker {
* @param fetchedData from Prometheus that will be evaluated.
* @return true if experiment was successful. Otherwise false.
*/
- fun evaluate(start: Instant, end: Instant, fetchedData: PrometheusResponse): Boolean
+ fun evaluate(fetchedData: List<PrometheusResponse>): Boolean
}
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/execution/BenchmarkExecutor.kt b/theodolite-quarkus/src/main/kotlin/theodolite/execution/BenchmarkExecutor.kt
index 6d4cd9ea9b5d03dda360b2ddcefcfb9682fd8383..e7b511d8c83b5abccece1204aad2a4a9ecfdfd26 100644
--- a/theodolite-quarkus/src/main/kotlin/theodolite/execution/BenchmarkExecutor.kt
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/execution/BenchmarkExecutor.kt
@@ -24,9 +24,12 @@ 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 repetitions: Int,
+ val executionId: Int,
+ val loadGenerationDelay: Long,
+ val afterTeardownDelay: Long
) {
var run: AtomicBoolean = AtomicBoolean(true)
@@ -41,7 +44,7 @@ abstract class BenchmarkExecutor(
* given load, false otherwise.
*/
abstract fun runExperiment(load: LoadDimension, res: Resource): Boolean
-
+
/**
* Wait while the benchmark is running and log the number of minutes executed every 1 minute.
*
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/execution/BenchmarkExecutorImpl.kt b/theodolite-quarkus/src/main/kotlin/theodolite/execution/BenchmarkExecutorImpl.kt
index cd85c143e3c416f115a4d301629caf4d46b7459f..3afc85f0a8cb67011763498a662b447ce2c07f0f 100644
--- a/theodolite-quarkus/src/main/kotlin/theodolite/execution/BenchmarkExecutorImpl.kt
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/execution/BenchmarkExecutorImpl.kt
@@ -5,11 +5,9 @@ import mu.KotlinLogging
import theodolite.benchmark.Benchmark
import theodolite.benchmark.BenchmarkExecution
import theodolite.evaluation.AnalysisExecutor
-import theodolite.util.ConfigurationOverride
-import theodolite.util.LoadDimension
-import theodolite.util.Resource
-import theodolite.util.Results
+import theodolite.util.*
import java.time.Duration
+import java.time.Instant
private val logger = KotlinLogging.logger {}
@@ -18,42 +16,58 @@ 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) {
+ repetitions: Int,
+ executionId: Int,
+ loadGenerationDelay: Long,
+ afterTeardownDelay: Long
+) : BenchmarkExecutor(benchmark, results, executionDuration, configurationOverrides, slo, repetitions, executionId, loadGenerationDelay, afterTeardownDelay) {
override fun runExperiment(load: LoadDimension, res: Resource): Boolean {
var result = false
- val benchmarkDeployment = benchmark.buildDeployment(load, res, this.configurationOverrides)
+ val executionIntervals: MutableList<Pair<Instant, Instant>> = ArrayList()
- try {
- benchmarkDeployment.setup()
- this.waitAndLog()
- } catch (e: Exception) {
- logger.error { "Error while setting up experiment with id ${this.executionId}." }
- logger.error { "Error is: $e" }
- this.run.set(false)
+ for (i in 1.rangeTo(repetitions)) {
+ logger.info { "Run repetition $i/$repetitions" }
+ if (this.run.get()) {
+ executionIntervals.add(runSingleExperiment(load,res))
+ } else {
+ break
+ }
}
/**
* Analyse the experiment, if [run] is true, otherwise the experiment was canceled by the user.
*/
if (this.run.get()) {
- result = AnalysisExecutor(slo = slo, executionId = executionId).analyze(
- load = load,
- res = res,
- executionDuration = executionDuration
- )
+ result =AnalysisExecutor(slo = slo, executionId = executionId)
+ .analyze(
+ load = load,
+ res = res,
+ executionIntervals = executionIntervals)
this.results.setResult(Pair(load, res), result)
}
+ return result
+ }
+ private fun runSingleExperiment(load: LoadDimension, res: Resource): Pair<Instant, Instant> {
+ val benchmarkDeployment = benchmark.buildDeployment(load, res, this.configurationOverrides, this.loadGenerationDelay, this.afterTeardownDelay)
+ val from = Instant.now()
+ try {
+ benchmarkDeployment.setup()
+ this.waitAndLog()
+ } catch (e: Exception) {
+ logger.error { "Error while setup experiment." }
+ logger.error { "Error is: $e" }
+ this.run.set(false)
+ }
+ val to = Instant.now()
try {
benchmarkDeployment.teardown()
} catch (e: Exception) {
logger.warn { "Error while tearing down the benchmark deployment." }
logger.debug { "Teardown failed, caused by: $e" }
}
-
- return result
+ return Pair(from,to)
}
}
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/execution/Main.kt b/theodolite-quarkus/src/main/kotlin/theodolite/execution/Main.kt
index 64a40c0b11854d61900ab1fde3797e17427cac15..bf883529967a8b24229fe8256ba0e4edd11b342c 100644
--- a/theodolite-quarkus/src/main/kotlin/theodolite/execution/Main.kt
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/execution/Main.kt
@@ -16,14 +16,14 @@ object Main {
val mode = System.getenv("MODE") ?: "standalone"
logger.info { "Start Theodolite with mode $mode" }
- when(mode) {
+ when (mode) {
"standalone" -> TheodoliteYamlExecutor().start()
"yaml-executor" -> TheodoliteYamlExecutor().start() // TODO remove (#209)
"operator" -> TheodoliteOperator().start()
- else -> {
+ else -> {
logger.error { "MODE $mode not found" }
exitProcess(1)
}
}
}
-}
\ No newline at end of file
+}
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/execution/Shutdown.kt b/theodolite-quarkus/src/main/kotlin/theodolite/execution/Shutdown.kt
index f5c0251c298dea0801dc601c1d2b790de465459e..0ff8379a0af4b11154214dde021d7c60609631d1 100644
--- a/theodolite-quarkus/src/main/kotlin/theodolite/execution/Shutdown.kt
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/execution/Shutdown.kt
@@ -5,6 +5,7 @@ import theodolite.benchmark.BenchmarkExecution
import theodolite.benchmark.KubernetesBenchmark
import theodolite.util.LoadDimension
import theodolite.util.Resource
+import java.lang.Exception
private val logger = KotlinLogging.logger {}
@@ -23,15 +24,23 @@ class Shutdown(private val benchmarkExecution: BenchmarkExecution, private val b
*/
override fun run() {
// Build Configuration to teardown
+ try {
logger.info { "Received shutdown signal -> Shutting down" }
val deployment =
benchmark.buildDeployment(
load = LoadDimension(0, emptyList()),
res = Resource(0, emptyList()),
- configurationOverrides = benchmarkExecution.configOverrides
+ configurationOverrides = benchmarkExecution.configOverrides,
+ loadGenerationDelay = 0L,
+ afterTeardownDelay = 5L
)
+ deployment.teardown()
+ } catch (e: Exception) {
+ logger.warn { "Could not delete all specified resources from Kubernetes. " +
+ "This could be the case, if not all resources are deployed and running." }
+
+ }
logger.info { "Teardown everything deployed" }
- deployment.teardown()
logger.info { "Teardown completed" }
}
}
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/execution/TheodoliteExecutor.kt b/theodolite-quarkus/src/main/kotlin/theodolite/execution/TheodoliteExecutor.kt
index c2b8cc7d2ebc60b7cbb8328dfe1d7830ec5b5aff..c73aaae08489c25a40163d4edb1607247fae010a 100644
--- a/theodolite-quarkus/src/main/kotlin/theodolite/execution/TheodoliteExecutor.kt
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/execution/TheodoliteExecutor.kt
@@ -1,18 +1,18 @@
package theodolite.execution
-import com.google.gson.GsonBuilder
+import mu.KotlinLogging
import theodolite.benchmark.BenchmarkExecution
import theodolite.benchmark.KubernetesBenchmark
import theodolite.patcher.PatcherDefinitionFactory
import theodolite.strategies.StrategyFactory
import theodolite.strategies.searchstrategy.CompositeStrategy
-import theodolite.util.Config
-import theodolite.util.LoadDimension
-import theodolite.util.Resource
-import theodolite.util.Results
-import java.io.PrintWriter
+import theodolite.util.*
+import java.io.File
import java.time.Duration
+
+private val logger = KotlinLogging.logger {}
+
/**
* The Theodolite executor runs all the experiments defined with the given execution and benchmark configuration.
*
@@ -62,9 +62,24 @@ class TheodoliteExecutor(
executionDuration = executionDuration,
configurationOverrides = config.configOverrides,
slo = config.slos[0],
- executionId = config.executionId
+ repetitions = config.execution.repetitions,
+ executionId = config.executionId,
+ loadGenerationDelay = config.execution.loadGenerationDelay,
+ afterTeardownDelay = config.execution.afterTeardownDelay
)
+ if (config.load.loadValues != config.load.loadValues.sorted()) {
+ config.load.loadValues = config.load.loadValues.sorted()
+ logger.info { "Load values are not sorted correctly, Theodolite sorts them in ascending order." +
+ "New order is: ${config.load.loadValues}" }
+ }
+
+ if (config.resources.resourceValues != config.resources.resourceValues.sorted()) {
+ config.resources.resourceValues = config.resources.resourceValues.sorted()
+ logger.info { "Load values are not sorted correctly, Theodolite sorts them in ascending order." +
+ "New order is: ${config.resources.resourceValues}" }
+ }
+
return Config(
loads = config.load.loadValues.map { load -> LoadDimension(load, loadDimensionPatcherDefinition) },
resources = config.resources.resourceValues.map { resource ->
@@ -97,8 +112,11 @@ class TheodoliteExecutor(
* execution and benchmark objects.
*/
fun run() {
- storeAsFile(this.config, "${this.config.executionId}-execution-configuration")
- storeAsFile(kubernetesBenchmark, "${this.config.executionId}-benchmark-configuration")
+ val ioHandler = IOHandler()
+ val resultsFolder = ioHandler.getResultFolderURL()
+ this.config.executionId = getAndIncrementExecutionID(resultsFolder+"expID.txt")
+ ioHandler.writeToJSONFile(this.config, "$resultsFolder${this.config.executionId}-execution-configuration")
+ ioHandler.writeToJSONFile(kubernetesBenchmark, "$resultsFolder${this.config.executionId}-benchmark-configuration")
val config = buildConfig()
// execute benchmarks for each load
@@ -107,14 +125,17 @@ class TheodoliteExecutor(
config.compositeStrategy.findSuitableResource(load, config.resources)
}
}
- storeAsFile(config.compositeStrategy.benchmarkExecutor.results, "${this.config.executionId}-result")
+ ioHandler.writeToJSONFile(config.compositeStrategy.benchmarkExecutor.results, "$resultsFolder${this.config.executionId}-result")
}
- private fun <T> storeAsFile(saveObject: T, filename: String) {
- val gson = GsonBuilder().enableComplexMapKeySerialization().setPrettyPrinting().create()
-
- PrintWriter(filename).use { pw ->
- pw.println(gson.toJson(saveObject))
- }
+ private fun getAndIncrementExecutionID(fileURL: String): Int {
+ val ioHandler = IOHandler()
+ var executionID = 0
+ if (File(fileURL).exists()) {
+ executionID = ioHandler.readFileAsString(fileURL).toInt() + 1
+ }
+ ioHandler.writeStringToTextFile(fileURL, (executionID).toString())
+ return executionID
}
+
}
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/execution/TheodoliteYamlExecutor.kt b/theodolite-quarkus/src/main/kotlin/theodolite/execution/TheodoliteYamlExecutor.kt
index 8b2909f7658f4dffcfd961cad8cd00eb013a160c..b9977029703c8012ada7fb3d7766bfa321a836c3 100644
--- a/theodolite-quarkus/src/main/kotlin/theodolite/execution/TheodoliteYamlExecutor.kt
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/execution/TheodoliteYamlExecutor.kt
@@ -31,8 +31,8 @@ class TheodoliteYamlExecutor {
fun start() {
logger.info { "Theodolite started" }
- val executionPath = System.getenv("THEODOLITE_EXECUTION") ?: "./config/BenchmarkExecution.yaml"
- val benchmarkPath = System.getenv("THEODOLITE_BENCHMARK") ?: "./config/BenchmarkType.yaml"
+ val executionPath = System.getenv("THEODOLITE_EXECUTION") ?: "./config/example-execution-yaml-resource.yaml"
+ val benchmarkPath = System.getenv("THEODOLITE_BENCHMARK") ?: "./config/example-benchmark-yaml-resource.yaml"
logger.info { "Using $executionPath for BenchmarkExecution" }
logger.info { "Using $benchmarkPath for BenchmarkType" }
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/execution/operator/AbstractStateHandler.kt b/theodolite-quarkus/src/main/kotlin/theodolite/execution/operator/AbstractStateHandler.kt
new file mode 100644
index 0000000000000000000000000000000000000000..75cbcad051e2055f25d876e66e0fffcdc249c4f5
--- /dev/null
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/execution/operator/AbstractStateHandler.kt
@@ -0,0 +1,55 @@
+package theodolite.execution.operator
+
+import io.fabric8.kubernetes.api.model.Namespaced
+import io.fabric8.kubernetes.client.CustomResource
+import io.fabric8.kubernetes.client.CustomResourceDoneable
+import io.fabric8.kubernetes.client.CustomResourceList
+import io.fabric8.kubernetes.client.KubernetesClient
+import io.fabric8.kubernetes.client.dsl.MixedOperation
+import io.fabric8.kubernetes.client.dsl.Resource
+import io.fabric8.kubernetes.client.dsl.base.CustomResourceDefinitionContext
+import java.lang.Thread.sleep
+
+abstract class AbstractStateHandler<T,L,D>(
+ private val context: CustomResourceDefinitionContext,
+ private val client: KubernetesClient,
+ private val crd: Class<T>,
+ private val crdList: Class<L>,
+ private val donableCRD: Class<D>
+ ): StateHandler where T : CustomResource, T: Namespaced, L: CustomResourceList<T>, D: CustomResourceDoneable<T> {
+
+ private val crdClient: MixedOperation<T, L, D, Resource<T, D>> =
+ this.client.customResources(this.context, this.crd, this.crdList, this.donableCRD)
+
+ @Synchronized
+ override fun setState(resourceName: String, f: (CustomResource) -> CustomResource?) {
+ this.crdClient
+ .inNamespace(this.client.namespace)
+ .list().items
+ .filter { item -> item.metadata.name == resourceName }
+ .map { customResource -> f(customResource) }
+ .forEach { this.crdClient.updateStatus(it as T) }
+ }
+
+ @Synchronized
+ override fun getState(resourceName: String, f: (CustomResource) -> String?): String? {
+ return this.crdClient
+ .inNamespace(this.client.namespace)
+ .list().items
+ .filter { item -> item.metadata.name == resourceName }
+ .map { customResource -> f(customResource) }
+ .firstOrNull()
+ }
+
+ @Synchronized
+ override fun blockUntilStateIsSet(resourceName: String, desiredStatusString: String, f: (CustomResource) -> String?, maxTries: Int): Boolean {
+ for (i in 0.rangeTo(maxTries)) {
+ val currentStatus = getState(resourceName, f)
+ if(currentStatus == desiredStatusString) {
+ return true
+ }
+ sleep(50)
+ }
+ return false
+ }
+}
\ No newline at end of file
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/execution/operator/BenchmarkEventHandler.kt b/theodolite-quarkus/src/main/kotlin/theodolite/execution/operator/BenchmarkEventHandler.kt
deleted file mode 100644
index 69c53a3792d86d0ad1c3e973b1d53ea5defff8d9..0000000000000000000000000000000000000000
--- a/theodolite-quarkus/src/main/kotlin/theodolite/execution/operator/BenchmarkEventHandler.kt
+++ /dev/null
@@ -1,66 +0,0 @@
-package theodolite.execution.operator
-
-import io.fabric8.kubernetes.client.informers.ResourceEventHandler
-import mu.KotlinLogging
-import theodolite.benchmark.KubernetesBenchmark
-private val logger = KotlinLogging.logger {}
-
-/**
- * Handles adding, updating and deleting KubernetesBenchmarks.
- *
- * @param controller The TheodoliteController that handles the application state
- *
- * @see TheodoliteController
- * @see KubernetesBenchmark
- */
-class BenchmarkEventHandler(private val controller: TheodoliteController): ResourceEventHandler<KubernetesBenchmark> {
-
- /**
- * Add a KubernetesBenchmark.
- *
- * @param benchmark the KubernetesBenchmark to add
- *
- * @see KubernetesBenchmark
- */
- override fun onAdd(benchmark: KubernetesBenchmark) {
- benchmark.name = benchmark.metadata.name
- logger.info { "Add new benchmark ${benchmark.name}." }
- this.controller.benchmarks[benchmark.name] = benchmark
- }
-
- /**
- * Update a KubernetesBenchmark.
- *
- * @param oldBenchmark the KubernetesBenchmark to update
- * @param newBenchmark the updated KubernetesBenchmark
- *
- * @see KubernetesBenchmark
- */
- override fun onUpdate(oldBenchmark: KubernetesBenchmark, newBenchmark: KubernetesBenchmark) {
- logger.info { "Update benchmark ${newBenchmark.metadata.name}." }
- newBenchmark.name = newBenchmark.metadata.name
- if (this.controller.isInitialized() && this.controller.executor.getBenchmark().name == oldBenchmark.metadata.name) {
- this.controller.isUpdated.set(true)
- this.controller.executor.executor.run.compareAndSet(true, false)
- } else {
- onAdd(newBenchmark)
- }
- }
-
- /**
- * Delete a KubernetesBenchmark.
- *
- * @param benchmark the KubernetesBenchmark to delete
- *
- * @see KubernetesBenchmark
- */
- override fun onDelete(benchmark: KubernetesBenchmark, b: Boolean) {
- logger.info { "Delete benchmark ${benchmark.metadata.name}." }
- this.controller.benchmarks.remove(benchmark.metadata.name)
- if ( this.controller.isInitialized() && this.controller.executor.getBenchmark().name == benchmark.metadata.name) {
- this.controller.isUpdated.set(true)
- this.controller.executor.executor.run.compareAndSet(true, false)
- logger.info { "Current benchmark stopped." }
- }
- }
-}
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/execution/operator/ClusterSetup.kt b/theodolite-quarkus/src/main/kotlin/theodolite/execution/operator/ClusterSetup.kt
new file mode 100644
index 0000000000000000000000000000000000000000..6c8c48f791543b6d8a7716cf26a80bdb449ee7a7
--- /dev/null
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/execution/operator/ClusterSetup.kt
@@ -0,0 +1,76 @@
+package theodolite.execution.operator
+
+import io.fabric8.kubernetes.client.NamespacedKubernetesClient
+import io.fabric8.kubernetes.client.dsl.MixedOperation
+import io.fabric8.kubernetes.client.dsl.Resource
+import mu.KotlinLogging
+import org.json.JSONObject
+import theodolite.execution.Shutdown
+import theodolite.k8s.K8sContextFactory
+import theodolite.model.crd.*
+
+private val logger = KotlinLogging.logger {}
+
+class ClusterSetup(
+ private val executionCRDClient: MixedOperation<ExecutionCRD, BenchmarkExecutionList, DoneableExecution, Resource<ExecutionCRD, DoneableExecution>>,
+ private val benchmarkCRDClient: MixedOperation<BenchmarkCRD, KubernetesBenchmarkList, DoneableBenchmark, Resource<BenchmarkCRD, DoneableBenchmark>>,
+ private val client: NamespacedKubernetesClient
+
+ ) {
+ private val serviceMonitorContext = K8sContextFactory().create(
+ api = "v1",
+ scope = "Namespaced",
+ group = "monitoring.coreos.com",
+ plural = "servicemonitors"
+ )
+
+ fun clearClusterState(){
+ stopRunningExecution()
+ clearByLabel()
+ }
+
+ private fun stopRunningExecution() {
+ executionCRDClient
+ .inNamespace(client.namespace)
+ .list()
+ .items
+ .asSequence()
+ .filter { it.status.executionState == States.RUNNING.value }
+ .forEach { execution ->
+ val benchmark = benchmarkCRDClient
+ .inNamespace(client.namespace)
+ .list()
+ .items
+ .firstOrNull { it.metadata.name == execution.spec.benchmark }
+
+ if (benchmark != null) {
+ execution.spec.name = execution.metadata.name
+ benchmark.spec.name = benchmark.metadata.name
+ Shutdown(execution.spec, benchmark.spec).start()
+ } else {
+ logger.error {
+ "Execution with state ${States.RUNNING.value} was found, but no corresponding benchmark. " +
+ "Could not initialize cluster." }
+ }
+
+
+ }
+ }
+
+ private fun clearByLabel() {
+ this.client.services().withLabel("app.kubernetes.io/created-by=theodolite").delete()
+ this.client.apps().deployments().withLabel("app.kubernetes.io/created-by=theodolite").delete()
+ this.client.apps().statefulSets().withLabel("app.kubernetes.io/created-by=theodolite").delete()
+ this.client.configMaps().withLabel("app.kubernetes.io/created-by=theodolite").delete()
+
+ val serviceMonitors = JSONObject(
+ this.client.customResource(serviceMonitorContext)
+ .list(client.namespace, mapOf(Pair("app.kubernetes.io/created-by", "theodolite")))
+ )
+ .getJSONArray("items")
+
+ (0 until serviceMonitors.length())
+ .map { serviceMonitors.getJSONObject(it).getJSONObject("metadata").getString("name") }
+ .forEach { this.client.customResource(serviceMonitorContext).delete(client.namespace, it) }
+ }
+}
\ No newline at end of file
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/execution/operator/ExecutionEventHandler.kt b/theodolite-quarkus/src/main/kotlin/theodolite/execution/operator/ExecutionEventHandler.kt
index 971d3428ffde9cf776711bbd68bae68f66597823..a1617b4988d500baab7b02bf5fa993f7a4ae76a3 100644
--- a/theodolite-quarkus/src/main/kotlin/theodolite/execution/operator/ExecutionEventHandler.kt
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/execution/operator/ExecutionEventHandler.kt
@@ -1,9 +1,11 @@
package theodolite.execution.operator
+import com.google.gson.Gson
+import com.google.gson.GsonBuilder
import io.fabric8.kubernetes.client.informers.ResourceEventHandler
import mu.KotlinLogging
import theodolite.benchmark.BenchmarkExecution
-import java.lang.NullPointerException
+import theodolite.model.crd.*
private val logger = KotlinLogging.logger {}
@@ -15,56 +17,70 @@ private val logger = KotlinLogging.logger {}
* @see TheodoliteController
* @see BenchmarkExecution
*/
-class ExecutionHandler(private val controller: TheodoliteController): ResourceEventHandler<BenchmarkExecution> {
+class ExecutionHandler(
+ private val controller: TheodoliteController,
+ private val stateHandler: ExecutionStateHandler
+) : ResourceEventHandler<ExecutionCRD> {
+ private val gson: Gson = GsonBuilder().enableComplexMapKeySerialization().create()
/**
* Add an execution to the end of the queue of the TheodoliteController.
*
- * @param execution the execution to add
+ * @param ExecutionCRD the execution to add
*/
- override fun onAdd(execution: BenchmarkExecution) {
- execution.name = execution.metadata.name
- logger.info { "Add new execution ${execution.metadata.name} to queue." }
- this.controller.executionsQueue.add(execution)
+ @Synchronized
+ override fun onAdd(execution: ExecutionCRD) {
+ logger.info { "Add execution ${execution.metadata.name}" }
+ execution.spec.name = execution.metadata.name
+ when (this.stateHandler.getExecutionState(execution.metadata.name)) {
+ null -> this.stateHandler.setExecutionState(execution.spec.name, States.PENDING)
+ States.RUNNING -> {
+ this.stateHandler.setExecutionState(execution.spec.name, States.RESTART)
+ if(this.controller.isExecutionRunning(execution.spec.name)){
+ this.controller.stop(restart=true)
+ }
+ }
+ }
}
/**
- * Update an execution. If this execution is running at the time this function is called, it is stopped and added to
- * the beginning of the queue of the TheodoliteController. Otherwise, it is just added to the beginning of the queue.
+ * Updates an execution. If this execution is running at the time this function is called, it is stopped and
+ * added to the beginning of the queue of the TheodoliteController.
+ * Otherwise, it is just added to the beginning of the queue.
*
- * @param execution the execution to update
+ * @param oldExecutionCRD the old execution
+ * @param newExecutionCRD the new execution
*/
- override fun onUpdate(oldExecution: BenchmarkExecution, newExecution: BenchmarkExecution) {
- logger.info { "Add updated execution to queue." }
- newExecution.name = newExecution.metadata.name
- try {
- this.controller.executionsQueue.removeIf { e -> e.name == newExecution.metadata.name }
- } catch(e: NullPointerException) {
- logger.warn { "No execution found for deletion" }
- }
- this.controller.executionsQueue.addFirst(newExecution)
- if (this.controller.isInitialized() && this.controller.executor.getExecution().name == newExecution.metadata.name) {
- this.controller.isUpdated.set(true)
- this.controller.executor.executor.run.compareAndSet(true, false)
+ @Synchronized
+ override fun onUpdate(oldExecution: ExecutionCRD, newExecution: ExecutionCRD) {
+ logger.info { "Receive update event for execution ${oldExecution.metadata.name}" }
+ newExecution.spec.name = newExecution.metadata.name
+ oldExecution.spec.name = oldExecution.metadata.name
+ if(gson.toJson(oldExecution.spec) != gson.toJson(newExecution.spec)) {
+ when(this.stateHandler.getExecutionState(newExecution.metadata.name)) {
+ States.RUNNING -> {
+ this.stateHandler.setExecutionState(newExecution.spec.name, States.RESTART)
+ if (this.controller.isExecutionRunning(newExecution.spec.name)){
+ this.controller.stop(restart=true)
+ }
+ }
+ States.RESTART -> {} // should this set to pending?
+ else -> this.stateHandler.setExecutionState(newExecution.spec.name, States.PENDING)
+ }
+ }
}
- }
/**
* Delete an execution from the queue of the TheodoliteController.
*
- * @param execution the execution to delete
+ * @param ExecutionCRD the execution to delete
*/
- override fun onDelete(execution: BenchmarkExecution, b: Boolean) {
- try {
- this.controller.executionsQueue.removeIf { e -> e.name == execution.metadata.name }
- logger.info { "Delete execution ${execution.metadata.name} from queue." }
- } catch(e: NullPointerException) {
- logger.warn { "No execution found for deletion" }
- }
- if (this.controller.isInitialized() && this.controller.executor.getExecution().name == execution.metadata.name) {
- this.controller.isUpdated.set(true)
- this.controller.executor.executor.run.compareAndSet(true, false)
- logger.info { "Current benchmark stopped." }
+ @Synchronized
+ override fun onDelete(execution: ExecutionCRD, b: Boolean) {
+ logger.info { "Delete execution ${execution.metadata.name}" }
+ if(execution.status.executionState == States.RUNNING.value
+ && this.controller.isExecutionRunning(execution.spec.name)) {
+ this.controller.stop()
}
}
}
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/execution/operator/ExecutionStateHandler.kt b/theodolite-quarkus/src/main/kotlin/theodolite/execution/operator/ExecutionStateHandler.kt
new file mode 100644
index 0000000000000000000000000000000000000000..fe1b95f95c74efe77913ea435dd1ac896805b065
--- /dev/null
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/execution/operator/ExecutionStateHandler.kt
@@ -0,0 +1,82 @@
+package theodolite.execution.operator
+
+import io.fabric8.kubernetes.client.CustomResource
+import io.fabric8.kubernetes.client.KubernetesClient
+import io.fabric8.kubernetes.client.dsl.base.CustomResourceDefinitionContext
+import theodolite.model.crd.BenchmarkExecutionList
+import theodolite.model.crd.ExecutionCRD
+import theodolite.model.crd.States
+import java.lang.Thread.sleep
+import java.time.Duration
+import java.time.Instant
+import java.util.concurrent.atomic.AtomicBoolean
+
+class ExecutionStateHandler(context: CustomResourceDefinitionContext, val client: KubernetesClient):
+ AbstractStateHandler<ExecutionCRD, BenchmarkExecutionList, DoneableExecution>(
+ context = context,
+ client = client,
+ crd = ExecutionCRD::class.java,
+ crdList = BenchmarkExecutionList::class.java,
+ donableCRD = DoneableExecution::class.java) {
+
+ private var runExecutionDurationTimer: AtomicBoolean = AtomicBoolean(false)
+
+ private fun getExecutionLambda() = { cr: CustomResource ->
+ var execState = ""
+ if (cr is ExecutionCRD) { execState = cr.status.executionState }
+ execState
+ }
+
+ private fun getDurationLambda() = { cr: CustomResource ->
+ var execState = ""
+ if (cr is ExecutionCRD) { execState = cr.status.executionState }
+ execState
+ }
+
+ fun setExecutionState(resourceName: String, status: States): Boolean {
+ setState(resourceName) {cr -> if(cr is ExecutionCRD) cr.status.executionState = status.value; cr}
+ return blockUntilStateIsSet(resourceName, status.value, getExecutionLambda())
+ }
+
+ fun getExecutionState(resourceName: String) : States? {
+ val status = this.getState(resourceName, getExecutionLambda())
+ return States.values().firstOrNull { it.value == status }
+ }
+
+ fun setDurationState(resourceName: String, duration: Duration) {
+ setState(resourceName) { cr -> if (cr is ExecutionCRD) cr.status.executionDuration = durationToK8sString(duration); cr }
+ blockUntilStateIsSet(resourceName, durationToK8sString(duration), getDurationLambda())
+ }
+
+ fun getDurationState(resourceName: String): String? {
+ return this.getState(resourceName, getDurationLambda())
+ }
+
+ private fun durationToK8sString(duration: Duration): String {
+ val sec = duration.seconds
+ return when {
+ sec <= 120 -> "${sec}s" // max 120s
+ sec < 60 * 99 -> "${duration.toMinutes()}m" // max 99m
+ sec < 60 * 60 * 99 -> "${duration.toHours()}h" // max 99h
+ else -> "${duration.toDays()}d + ${duration.minusDays(duration.toDays()).toHours()}h"
+ }
+ }
+
+ fun startDurationStateTimer(resourceName: String) {
+ this.runExecutionDurationTimer.set(true)
+ val startTime = Instant.now().toEpochMilli()
+ Thread {
+ while (this.runExecutionDurationTimer.get()) {
+ val duration = Duration.ofMillis(Instant.now().minusMillis(startTime).toEpochMilli())
+ setDurationState(resourceName, duration)
+ sleep(100 * 1)
+ }
+ }.start()
+ }
+
+ @Synchronized
+ fun stopDurationStateTimer() {
+ this.runExecutionDurationTimer.set(false)
+ sleep(100 * 2)
+ }
+}
\ No newline at end of file
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/execution/operator/LeaderElector.kt b/theodolite-quarkus/src/main/kotlin/theodolite/execution/operator/LeaderElector.kt
new file mode 100644
index 0000000000000000000000000000000000000000..9d093e4851e5c43d29a3fea3057ccf01be612e63
--- /dev/null
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/execution/operator/LeaderElector.kt
@@ -0,0 +1,43 @@
+package theodolite.execution.operator
+
+import io.fabric8.kubernetes.client.DefaultKubernetesClient
+import io.fabric8.kubernetes.client.NamespacedKubernetesClient
+import io.fabric8.kubernetes.client.extended.leaderelection.LeaderCallbacks
+import io.fabric8.kubernetes.client.extended.leaderelection.LeaderElectionConfigBuilder
+import io.fabric8.kubernetes.client.extended.leaderelection.resourcelock.LeaseLock
+import mu.KotlinLogging
+import java.time.Duration
+import java.util.*
+import kotlin.reflect.KFunction0
+
+private val logger = KotlinLogging.logger {}
+
+class LeaderElector(
+ val client: NamespacedKubernetesClient,
+ val name: String
+ ) {
+
+ fun getLeadership(leader: KFunction0<Unit>) {
+ val lockIdentity: String = UUID.randomUUID().toString()
+ DefaultKubernetesClient().use { kc ->
+ kc.leaderElector()
+ .withConfig(
+ LeaderElectionConfigBuilder()
+ .withName("Theodolite")
+ .withLeaseDuration(Duration.ofSeconds(15L))
+ .withLock(LeaseLock(client.namespace, name, lockIdentity))
+ .withRenewDeadline(Duration.ofSeconds(10L))
+ .withRetryPeriod(Duration.ofSeconds(2L))
+ .withLeaderCallbacks(LeaderCallbacks(
+ { Thread{leader()}.start() },
+ { logger.info { "STOPPED LEADERSHIP" } }
+ ) { newLeader: String? ->
+ logger.info { "New leader elected $newLeader" }
+ })
+ .build()
+ )
+ .build().run()
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/execution/operator/StateHandler.kt b/theodolite-quarkus/src/main/kotlin/theodolite/execution/operator/StateHandler.kt
new file mode 100644
index 0000000000000000000000000000000000000000..0fbd97e5cca4a9be220eb0b0c89ea0af129a7860
--- /dev/null
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/execution/operator/StateHandler.kt
@@ -0,0 +1,15 @@
+package theodolite.execution.operator
+
+import io.fabric8.kubernetes.client.CustomResource
+private const val MAX_TRIES: Int = 5
+
+interface StateHandler {
+ fun setState(resourceName: String, f: (CustomResource) -> CustomResource?)
+ fun getState(resourceName: String, f: (CustomResource) -> String?): String?
+ fun blockUntilStateIsSet(
+ resourceName: String,
+ desiredStatusString: String,
+ f: (CustomResource) -> String?,
+ maxTries: Int = MAX_TRIES): Boolean
+
+}
\ No newline at end of file
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/execution/operator/TheodoliteController.kt b/theodolite-quarkus/src/main/kotlin/theodolite/execution/operator/TheodoliteController.kt
index 532185841a7a8ee000722c1dc513219177f00cae..1e3929da98be060e2cbebf305dbae2f25519798a 100644
--- a/theodolite-quarkus/src/main/kotlin/theodolite/execution/operator/TheodoliteController.kt
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/execution/operator/TheodoliteController.kt
@@ -1,123 +1,194 @@
package theodolite.execution.operator
import io.fabric8.kubernetes.client.NamespacedKubernetesClient
-import io.fabric8.kubernetes.client.dsl.base.CustomResourceDefinitionContext
-import khttp.patch
+import io.fabric8.kubernetes.client.dsl.MixedOperation
+import io.fabric8.kubernetes.client.dsl.Resource
import mu.KotlinLogging
import theodolite.benchmark.BenchmarkExecution
import theodolite.benchmark.KubernetesBenchmark
import theodolite.execution.TheodoliteExecutor
+import theodolite.model.crd.*
+import theodolite.util.ConfigurationOverride
+import theodolite.util.PatcherDefinition
import java.lang.Thread.sleep
-import java.util.concurrent.ConcurrentHashMap
-import java.util.concurrent.ConcurrentLinkedDeque
-import java.util.concurrent.atomic.AtomicBoolean
-import java.util.concurrent.atomic.AtomicInteger
private val logger = KotlinLogging.logger {}
/**
* The controller implementation for Theodolite.
*
- * Maintains a Dequeue, based on ConcurrentLinkedDequeue, of executions to be executed for a benchmark.
- *
- * @param client The NamespacedKubernetesClient
- * @param executionContext The CustomResourceDefinitionContext
- *
* @see NamespacedKubernetesClient
* @see CustomResourceDefinitionContext
* @see BenchmarkExecution
* @see KubernetesBenchmark
* @see ConcurrentLinkedDeque
*/
+
class TheodoliteController(
- val client: NamespacedKubernetesClient,
- val executionContext: CustomResourceDefinitionContext,
- val path: String
+ private val namespace: String,
+ val path: String,
+ private val executionCRDClient: MixedOperation<ExecutionCRD, BenchmarkExecutionList, DoneableExecution, Resource<ExecutionCRD, DoneableExecution>>,
+ private val benchmarkCRDClient: MixedOperation<BenchmarkCRD, KubernetesBenchmarkList, DoneableBenchmark, Resource<BenchmarkCRD, DoneableBenchmark>>,
+ private val executionStateHandler: ExecutionStateHandler
) {
lateinit var executor: TheodoliteExecutor
- val executionsQueue: ConcurrentLinkedDeque<BenchmarkExecution> = ConcurrentLinkedDeque()
- val benchmarks: ConcurrentHashMap<String, KubernetesBenchmark> = ConcurrentHashMap()
- var isUpdated = AtomicBoolean(false)
- var executionID = AtomicInteger(0)
-
/**
+ *
* Runs the TheodoliteController forever.
*/
fun run() {
+ sleep(5000) // wait until all states are correctly set
while (true) {
- try {
- reconcile()
- logger.info { "Theodolite is waiting for new matching benchmark and execution." }
- logger.info { "Currently available executions: " }
- executionsQueue.forEach {
- logger.info { "${it.name} : waiting for : ${it.benchmark}" }
- }
- logger.info { "Currently available benchmarks: " }
- benchmarks.forEach {
- logger.info { it.key }
- }
- sleep(2000)
- } catch (e: InterruptedException) {
- logger.error { "Execution interrupted with error: $e." }
- }
+ reconcile()
+ sleep(2000)
}
}
- /**
- * Ensures that the application state corresponds to the defined KubernetesBenchmarks and BenchmarkExecutions.
- *
- * @see KubernetesBenchmark
- * @see BenchmarkExecution
- */
- @Synchronized
private fun reconcile() {
- while (executionsQueue.isNotEmpty()) {
- val execution = executionsQueue.peek()
- val benchmark = benchmarks[execution.benchmark]
-
- if (benchmark == null) {
- logger.debug { "No benchmark found for execution ${execution.name}." }
- sleep(1000)
+ do {
+ val execution = getNextExecution()
+ if (execution != null) {
+ val benchmark = getBenchmarks()
+ .firstOrNull { it.name == execution.benchmark }
+ if (benchmark != null) {
+ runExecution(execution, benchmark)
+ }
} else {
- runExecution(execution, benchmark)
+ logger.info { "Could not find executable execution." }
}
- }
+ } while (execution != null)
}
/**
* Execute a benchmark with a defined KubernetesBenchmark and BenchmarkExecution
*
- * @see KubernetesBenchmark
* @see BenchmarkExecution
*/
- @Synchronized
- fun runExecution(execution: BenchmarkExecution, benchmark: KubernetesBenchmark) {
- execution.executionId = executionID.getAndSet(executionID.get() + 1)
- isUpdated.set(false)
- benchmark.path = path
- logger.info { "Start execution ${execution.name} with benchmark ${benchmark.name}." }
- executor = TheodoliteExecutor(config = execution, kubernetesBenchmark = benchmark)
- executor.run()
+ private fun runExecution(execution: BenchmarkExecution, benchmark: KubernetesBenchmark) {
+ setAdditionalLabels(execution.name,
+ "deployed-for-execution",
+ benchmark.appResource + benchmark.loadGenResource,
+ execution)
+ setAdditionalLabels(benchmark.name,
+ "deployed-for-benchmark",
+ benchmark.appResource + benchmark.loadGenResource,
+ execution)
+ setAdditionalLabels("theodolite",
+ "app.kubernetes.io/created-by",
+ benchmark.appResource + benchmark.loadGenResource,
+ execution)
+
+ executionStateHandler.setExecutionState(execution.name, States.RUNNING)
+ executionStateHandler.startDurationStateTimer(execution.name)
try {
- if (!isUpdated.get()) {
- this.executionsQueue.removeIf { e -> e.name == execution.name }
- client.customResource(executionContext).delete(client.namespace, execution.metadata.name)
+ executor = TheodoliteExecutor(execution, benchmark)
+ executor.run()
+ when (executionStateHandler.getExecutionState(execution.name)) {
+ States.RESTART -> runExecution(execution, benchmark)
+ States.RUNNING -> {
+ executionStateHandler.setExecutionState(execution.name, States.FINISHED)
+ logger.info { "Execution of ${execution.name} is finally stopped." }
+ }
}
} catch (e: Exception) {
- logger.warn { "Deletion skipped." }
+ logger.error { "Failure while executing execution ${execution.name} with benchmark ${benchmark.name}." }
+ logger.error { "Problem is: $e" }
+ executionStateHandler.setExecutionState(execution.name, States.FAILURE)
}
+ executionStateHandler.stopDurationStateTimer()
+ }
- logger.info { "Execution of ${execution.name} is finally stopped." }
+ @Synchronized
+ fun stop(restart: Boolean = false) {
+ if (!::executor.isInitialized) return
+ if (restart) {
+ executionStateHandler.setExecutionState(this.executor.getExecution().name, States.RESTART)
+ } else {
+ executionStateHandler.setExecutionState(this.executor.getExecution().name, States.INTERRUPTED)
+ logger.warn { "Execution ${executor.getExecution().name} unexpected interrupted" }
+ }
+ this.executor.executor.run.set(false)
+ }
+
+ /**
+ * @return all available [BenchmarkCRD]s
+ */
+ private fun getBenchmarks(): List<KubernetesBenchmark> {
+ return this.benchmarkCRDClient
+ .inNamespace(namespace)
+ .list()
+ .items
+ .map { it.spec.name = it.metadata.name; it }
+ .map { it.spec.path = path; it }
+ .map { it.spec }
}
/**
- * @return true if the TheodoliteExecutor of this controller is initialized. Else returns false.
+ * Get the [BenchmarkExecution] for the next run. Which [BenchmarkExecution]
+ * is selected for the next execution depends on three points:
*
- * @see TheodoliteExecutor
+ * 1. Only executions are considered for which a matching benchmark is available on the cluster
+ * 2. The Status of the execution must be [States.PENDING] or [States.RESTART]
+ * 3. Of the remaining [BenchmarkCRD], those with status [States.RESTART] are preferred,
+ * then, if there is more than one, the oldest execution is chosen.
+ *
+ * @return the next execution or null
*/
- @Synchronized
- fun isInitialized(): Boolean {
- return ::executor.isInitialized
+ private fun getNextExecution(): BenchmarkExecution? {
+ val availableBenchmarkNames = getBenchmarks()
+ .map { it.name }
+
+ return executionCRDClient
+ .inNamespace(namespace)
+ .list()
+ .items
+ .asSequence()
+ .map { it.spec.name = it.metadata.name; it }
+ .filter {
+ it.status.executionState == States.PENDING.value ||
+ it.status.executionState == States.RESTART.value
+ }
+ .filter { availableBenchmarkNames.contains(it.spec.benchmark) }
+ .sortedWith(stateComparator().thenBy { it.metadata.creationTimestamp })
+ .map { it.spec }
+ .firstOrNull()
+ }
+
+ /**
+ * Simple comparator which can be used to order a list of [ExecutionCRD] such that executions with
+ * status [States.RESTART] are before all other executions.
+ */
+ private fun stateComparator() = Comparator<ExecutionCRD> { a, b ->
+ when {
+ (a == null && b == null) -> 0
+ (a.status.executionState == States.RESTART.value) -> -1
+ else -> 1
+ }
+ }
+
+ fun isExecutionRunning(executionName: String): Boolean {
+ return this.executor.getExecution().name == executionName
+ }
+
+ private fun setAdditionalLabels(
+ labelValue: String,
+ labelName: String,
+ resources: List<String>,
+ execution: BenchmarkExecution
+ ) {
+ val additionalConfigOverrides = mutableListOf<ConfigurationOverride>()
+ resources.forEach {
+ run {
+ val configurationOverride = ConfigurationOverride()
+ configurationOverride.patcher = PatcherDefinition()
+ configurationOverride.patcher.type = "LabelPatcher"
+ configurationOverride.patcher.variableName = labelName
+ configurationOverride.patcher.resource = it
+ configurationOverride.value = labelValue
+ additionalConfigOverrides.add(configurationOverride)
+ }
+ }
+ execution.configOverrides.addAll(additionalConfigOverrides)
}
-}
+}
\ No newline at end of file
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/execution/operator/TheodoliteOperator.kt b/theodolite-quarkus/src/main/kotlin/theodolite/execution/operator/TheodoliteOperator.kt
index 5e15a4a80e67f47a42d605d4af39102927139331..0d55b0c1c1c76dba226d34554e0d96a3df77c1c3 100644
--- a/theodolite-quarkus/src/main/kotlin/theodolite/execution/operator/TheodoliteOperator.kt
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/execution/operator/TheodoliteOperator.kt
@@ -1,13 +1,13 @@
package theodolite.execution.operator
import io.fabric8.kubernetes.client.DefaultKubernetesClient
+import io.fabric8.kubernetes.client.NamespacedKubernetesClient
+import io.fabric8.kubernetes.client.dsl.MixedOperation
+import io.fabric8.kubernetes.client.dsl.Resource
import io.fabric8.kubernetes.internal.KubernetesDeserializer
import mu.KotlinLogging
-import theodolite.benchmark.BenchmarkExecution
-import theodolite.benchmark.BenchmarkExecutionList
-import theodolite.benchmark.KubernetesBenchmark
-import theodolite.benchmark.KubernetesBenchmarkList
import theodolite.k8s.K8sContextFactory
+import theodolite.model.crd.*
private const val DEFAULT_NAMESPACE = "default"
@@ -16,7 +16,7 @@ private const val EXECUTION_SINGULAR = "execution"
private const val EXECUTION_PLURAL = "executions"
private const val BENCHMARK_SINGULAR = "benchmark"
private const val BENCHMARK_PLURAL = "benchmarks"
-private const val API_VERSION = "v1alpha1"
+private const val API_VERSION = "v1"
private const val RESYNC_PERIOD = 10 * 60 * 1000.toLong()
private const val GROUP = "theodolite.com"
private val logger = KotlinLogging.logger {}
@@ -28,47 +28,95 @@ private val logger = KotlinLogging.logger {}
*/
class TheodoliteOperator {
private val namespace = System.getenv("NAMESPACE") ?: DEFAULT_NAMESPACE
+ val client: NamespacedKubernetesClient = DefaultKubernetesClient().inNamespace(namespace)
+
+
+ fun start() {
+ LeaderElector(
+ client = client,
+ name = "theodolite-operator"
+ )
+ .getLeadership(::startOperator)
+ }
/**
* Start the operator.
*/
- fun start() {
+ private fun startOperator() {
logger.info { "Using $namespace as namespace." }
- val client = DefaultKubernetesClient().inNamespace(namespace)
+ client.use {
+ KubernetesDeserializer.registerCustomKind(
+ "$GROUP/$API_VERSION",
+ EXECUTION_SINGULAR,
+ ExecutionCRD::class.java
+ )
- KubernetesDeserializer.registerCustomKind(
- "$GROUP/$API_VERSION",
- EXECUTION_SINGULAR,
- BenchmarkExecution::class.java
- )
+ KubernetesDeserializer.registerCustomKind(
+ "$GROUP/$API_VERSION",
+ BENCHMARK_SINGULAR,
+ BenchmarkCRD::class.java
+ )
- KubernetesDeserializer.registerCustomKind(
- "$GROUP/$API_VERSION",
- BENCHMARK_SINGULAR,
- KubernetesBenchmark::class.java
- )
+ val contextFactory = K8sContextFactory()
+ val executionContext = contextFactory.create(API_VERSION, SCOPE, GROUP, EXECUTION_PLURAL)
+ val benchmarkContext = contextFactory.create(API_VERSION, SCOPE, GROUP, BENCHMARK_PLURAL)
- val contextFactory = K8sContextFactory()
- val executionContext = contextFactory.create(API_VERSION, SCOPE, GROUP, EXECUTION_PLURAL)
- val benchmarkContext = contextFactory.create(API_VERSION, SCOPE, GROUP, BENCHMARK_PLURAL)
+ val executionCRDClient: MixedOperation<
+ ExecutionCRD,
+ BenchmarkExecutionList,
+ DoneableExecution,
+ Resource<ExecutionCRD, DoneableExecution>>
+ = client.customResources(
+ executionContext,
+ ExecutionCRD::class.java,
+ BenchmarkExecutionList::class.java,
+ DoneableExecution::class.java)
- val appResource = System.getenv("THEODOLITE_APP_RESOURCES") ?: "./config"
- val controller = TheodoliteController(client = client, executionContext = executionContext, path = appResource)
+ val benchmarkCRDClient: MixedOperation<
+ BenchmarkCRD,
+ KubernetesBenchmarkList,
+ DoneableBenchmark,
+ Resource<BenchmarkCRD, DoneableBenchmark>>
+ = client.customResources(
+ benchmarkContext,
+ BenchmarkCRD::class.java,
+ KubernetesBenchmarkList::class.java,
+ DoneableBenchmark::class.java)
- val informerFactory = client.informers()
- val informerExecution = informerFactory.sharedIndexInformerForCustomResource(
- executionContext, BenchmarkExecution::class.java,
- BenchmarkExecutionList::class.java, RESYNC_PERIOD
- )
- val informerBenchmark = informerFactory.sharedIndexInformerForCustomResource(
- benchmarkContext, KubernetesBenchmark::class.java,
- KubernetesBenchmarkList::class.java, RESYNC_PERIOD
- )
+ val executionStateHandler = ExecutionStateHandler(
+ context = executionContext,
+ client = client)
+
+ val appResource = System.getenv("THEODOLITE_APP_RESOURCES") ?: "./config"
+ val controller =
+ TheodoliteController(
+ namespace = client.namespace,
+ path = appResource,
+ benchmarkCRDClient = benchmarkCRDClient,
+ executionCRDClient = executionCRDClient,
+ executionStateHandler = executionStateHandler)
+
+ val informerFactory = client.informers()
+ val informerExecution = informerFactory.sharedIndexInformerForCustomResource(
+ executionContext,
+ ExecutionCRD::class.java,
+ BenchmarkExecutionList::class.java,
+ RESYNC_PERIOD
+ )
+
+ informerExecution.addEventHandler(ExecutionHandler(
+ controller = controller,
+ stateHandler = executionStateHandler))
+
+ ClusterSetup(
+ executionCRDClient = executionCRDClient,
+ benchmarkCRDClient = benchmarkCRDClient,
+ client = client
+ ).clearClusterState()
- informerExecution.addEventHandler(ExecutionHandler(controller))
- informerBenchmark.addEventHandler(BenchmarkEventHandler(controller))
- informerFactory.startAllRegisteredInformers()
+ informerFactory.startAllRegisteredInformers()
+ controller.run()
- controller.run()
+ }
}
}
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/k8s/K8sContextFactory.kt b/theodolite-quarkus/src/main/kotlin/theodolite/k8s/K8sContextFactory.kt
index c0e07610171b40c6704602ffa86ec15accb14c19..7eb209bfbab02bb94d34c985aa308173e509d4e4 100644
--- a/theodolite-quarkus/src/main/kotlin/theodolite/k8s/K8sContextFactory.kt
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/k8s/K8sContextFactory.kt
@@ -21,12 +21,12 @@ class K8sContextFactory {
*
* @see CustomResourceDefinitionContext
*/
- fun create(api: String, scope: String, group: String, plural: String ) : CustomResourceDefinitionContext {
- return CustomResourceDefinitionContext.Builder()
+ fun create(api: String, scope: String, group: String, plural: String): CustomResourceDefinitionContext {
+ return CustomResourceDefinitionContext.Builder()
.withVersion(api)
.withScope(scope)
.withGroup(group)
.withPlural(plural)
.build()
}
-}
\ No newline at end of file
+}
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/k8s/K8sResourceLoader.kt b/theodolite-quarkus/src/main/kotlin/theodolite/k8s/K8sResourceLoader.kt
index 324b02b74b2c53eb1292667f037f3fdbcc114b73..fd5ec3b2e744b5e096187626a2fd756f71f87e67 100644
--- a/theodolite-quarkus/src/main/kotlin/theodolite/k8s/K8sResourceLoader.kt
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/k8s/K8sResourceLoader.kt
@@ -32,7 +32,14 @@ class K8sResourceLoader(private val client: NamespacedKubernetesClient) {
* @return CustomResource from fabric8
*/
private fun loadServiceMonitor(path: String): ServiceMonitorWrapper {
- return loadGenericResource(path) { x: String -> ServiceMonitorWrapper(YamlParser().parse(path, HashMap<String, String>()::class.java)!!) }
+ return loadGenericResource(path) { x: String ->
+ ServiceMonitorWrapper(
+ YamlParser().parse(
+ path,
+ HashMap<String, String>()::class.java
+ )!!
+ )
+ }
}
/**
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/k8s/ServiceMonitorWrapper.kt b/theodolite-quarkus/src/main/kotlin/theodolite/k8s/ServiceMonitorWrapper.kt
index 4950cee225e103ff095def91de64471ec1894a79..56452d74968db0fd4c939f44f3ed8a7abbe7b928 100644
--- a/theodolite-quarkus/src/main/kotlin/theodolite/k8s/ServiceMonitorWrapper.kt
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/k8s/ServiceMonitorWrapper.kt
@@ -53,4 +53,9 @@ class ServiceMonitorWrapper(private val serviceMonitor: Map<String, String>) : C
val smAsMap = this.serviceMonitor["metadata"]!! as Map<String, String>
return smAsMap["name"]!!
}
+
+ fun getLabels(): Map<String, String>{
+ val smAsMap = this.serviceMonitor["metadata"]!! as Map<String, String>
+ return smAsMap["labels"]!! as Map<String, String>
+ }
}
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/k8s/TopicManager.kt b/theodolite-quarkus/src/main/kotlin/theodolite/k8s/TopicManager.kt
index ef5715e248ae6c64df0035a94d57fea12202787e..3bbae82d77dc5b01a5827c7ee713bf2566be1bab 100644
--- a/theodolite-quarkus/src/main/kotlin/theodolite/k8s/TopicManager.kt
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/k8s/TopicManager.kt
@@ -45,7 +45,7 @@ class TopicManager(private val kafkaConfig: Map<String, Any>) {
"Topics creation finished with result: ${
result
.values()
- .map { it -> it.key + ": " + it.value.isDone }
+ .map { it.key + ": " + it.value.isDone }
.joinToString(separator = ",")
} "
}
@@ -59,16 +59,17 @@ class TopicManager(private val kafkaConfig: Map<String, Any>) {
fun removeTopics(topics: List<String>) {
val kafkaAdmin: AdminClient = AdminClient.create(this.kafkaConfig)
val currentTopics = kafkaAdmin.listTopics().names().get()
- delete(currentTopics.filter{ matchRegex(it, topics) }, kafkaAdmin)
+ delete(currentTopics.filter { matchRegex(it, topics) }, kafkaAdmin)
kafkaAdmin.close()
}
/**
- * This function checks whether one string in `topics` can be used as prefix of a regular expression to create the string `existingTopic`
+ * This function checks whether one string in `topics` can be used as prefix of a regular expression
+ * to create the string `existingTopic`.
*
- * @param existingTopic string for which should be checked if it could be created
- * @param topics list of string which are used as possible prefixes to create `existingTopic`
- * @return true, `existingTopics` matches a created regex, else false
+ * @param existingTopic string for which should be checked if it could be created.
+ * @param topics list of string which are used as possible prefixes to create `existingTopic`.
+ * @return true, `existingTopics` matches a created regex, else false.
*/
private fun matchRegex(existingTopic: String, topics: List<String>): Boolean {
for (t in topics) {
@@ -89,7 +90,7 @@ class TopicManager(private val kafkaConfig: Map<String, Any>) {
result.all().get() // wait for the future to be completed
logger.info {
"Topics deletion finished with result: ${
- result.values().map { it -> it.key + ": " + it.value.isDone }
+ result.values().map { it.key + ": " + it.value.isDone }
.joinToString(separator = ",")
}"
}
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/model/crd/BenchmarkCRD.kt b/theodolite-quarkus/src/main/kotlin/theodolite/model/crd/BenchmarkCRD.kt
new file mode 100644
index 0000000000000000000000000000000000000000..326aa10a21bebd913eaafcb8315188288ae97ff1
--- /dev/null
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/model/crd/BenchmarkCRD.kt
@@ -0,0 +1,11 @@
+package theodolite.model.crd
+
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize
+import io.fabric8.kubernetes.api.model.Namespaced
+import io.fabric8.kubernetes.client.CustomResource
+import theodolite.benchmark.KubernetesBenchmark
+
+@JsonDeserialize
+class BenchmarkCRD(
+ var spec: KubernetesBenchmark = KubernetesBenchmark()
+) : CustomResource(), Namespaced
\ No newline at end of file
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/model/crd/BenchmarkExecutionList.kt b/theodolite-quarkus/src/main/kotlin/theodolite/model/crd/BenchmarkExecutionList.kt
new file mode 100644
index 0000000000000000000000000000000000000000..2b2dcc07f9c37f1712109e3d092f2db0c139e1c8
--- /dev/null
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/model/crd/BenchmarkExecutionList.kt
@@ -0,0 +1,5 @@
+package theodolite.model.crd
+
+import io.fabric8.kubernetes.client.CustomResourceList
+
+class BenchmarkExecutionList : CustomResourceList<ExecutionCRD>()
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/model/crd/DoneableBenchmark.kt b/theodolite-quarkus/src/main/kotlin/theodolite/model/crd/DoneableBenchmark.kt
new file mode 100644
index 0000000000000000000000000000000000000000..e00e8268b2ec8eba17b3706feb3940eded1b2b0c
--- /dev/null
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/model/crd/DoneableBenchmark.kt
@@ -0,0 +1,7 @@
+package theodolite.model.crd
+
+import io.fabric8.kubernetes.api.builder.Function
+import io.fabric8.kubernetes.client.CustomResourceDoneable
+
+class DoneableBenchmark(resource: BenchmarkCRD, function: Function<BenchmarkCRD, BenchmarkCRD>) :
+ CustomResourceDoneable<BenchmarkCRD>(resource, function)
\ No newline at end of file
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/model/crd/DoneableExecution.kt b/theodolite-quarkus/src/main/kotlin/theodolite/model/crd/DoneableExecution.kt
new file mode 100644
index 0000000000000000000000000000000000000000..be07725b405c29a0d9000b6e6ec455536ad111fb
--- /dev/null
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/model/crd/DoneableExecution.kt
@@ -0,0 +1,8 @@
+package theodolite.execution.operator
+
+import io.fabric8.kubernetes.client.CustomResourceDoneable
+import io.fabric8.kubernetes.api.builder.Function
+import theodolite.model.crd.ExecutionCRD
+
+class DoneableExecution(resource: ExecutionCRD, function: Function<ExecutionCRD, ExecutionCRD>) :
+ CustomResourceDoneable<ExecutionCRD>(resource, function)
\ No newline at end of file
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/model/crd/ExecutionCRD.kt b/theodolite-quarkus/src/main/kotlin/theodolite/model/crd/ExecutionCRD.kt
new file mode 100644
index 0000000000000000000000000000000000000000..79a387cee250d3abf0fdb576a5f0f33424596792
--- /dev/null
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/model/crd/ExecutionCRD.kt
@@ -0,0 +1,13 @@
+package theodolite.model.crd
+
+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 theodolite.benchmark.BenchmarkExecution
+
+@JsonDeserialize
+class ExecutionCRD(
+ var spec: BenchmarkExecution = BenchmarkExecution(),
+ var status: ExecutionStatus = ExecutionStatus()
+ ) : CustomResource(), Namespaced
\ No newline at end of file
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/model/crd/ExecutionStatus.kt b/theodolite-quarkus/src/main/kotlin/theodolite/model/crd/ExecutionStatus.kt
new file mode 100644
index 0000000000000000000000000000000000000000..43e9035b3120eb22304576f2006092eec376b6d2
--- /dev/null
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/model/crd/ExecutionStatus.kt
@@ -0,0 +1,13 @@
+package theodolite.model.crd
+
+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
+
+@JsonDeserialize
+class ExecutionStatus(): KubernetesResource, CustomResource(), Namespaced {
+ var executionState: String = ""
+ var executionDuration: String = "-"
+
+}
\ No newline at end of file
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/model/crd/KubernetesBenchmarkList.kt b/theodolite-quarkus/src/main/kotlin/theodolite/model/crd/KubernetesBenchmarkList.kt
new file mode 100644
index 0000000000000000000000000000000000000000..8ad0a493d948bf5f78741052100766dcf6e316ec
--- /dev/null
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/model/crd/KubernetesBenchmarkList.kt
@@ -0,0 +1,5 @@
+package theodolite.model.crd
+
+import io.fabric8.kubernetes.client.CustomResourceList
+
+class KubernetesBenchmarkList : CustomResourceList<BenchmarkCRD>()
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/model/crd/States.kt b/theodolite-quarkus/src/main/kotlin/theodolite/model/crd/States.kt
new file mode 100644
index 0000000000000000000000000000000000000000..79af297915b6703b209acb0c13913482e54db2be
--- /dev/null
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/model/crd/States.kt
@@ -0,0 +1,11 @@
+package theodolite.model.crd
+
+enum class States(val value: String) {
+ RUNNING("RUNNING"),
+ PENDING("PENDING"),
+ FAILURE("FAILURE"),
+ FINISHED("FINISHED"),
+ RESTART("RESTART"),
+ INTERRUPTED("INTERRUPTED"),
+ NO_STATE("NoState")
+}
\ No newline at end of file
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/patcher/ImagePatcher.kt b/theodolite-quarkus/src/main/kotlin/theodolite/patcher/ImagePatcher.kt
index e5e5f6cb67641c71ad0fd31375752cbb03fa62db..b29d8d9925311aa25b7336dcd6805783ca62c3e7 100644
--- a/theodolite-quarkus/src/main/kotlin/theodolite/patcher/ImagePatcher.kt
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/patcher/ImagePatcher.kt
@@ -12,7 +12,7 @@ import io.fabric8.kubernetes.api.model.apps.StatefulSet
*/
class ImagePatcher(private val k8sResource: KubernetesResource, private val container: String) :
AbstractPatcher(k8sResource, container) {
-
+
override fun <String> patch(imagePath: String) {
if (k8sResource is Deployment) {
k8sResource.spec.template.spec.containers.filter { it.name == container }.forEach {
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/patcher/LabelPatcher.kt b/theodolite-quarkus/src/main/kotlin/theodolite/patcher/LabelPatcher.kt
new file mode 100644
index 0000000000000000000000000000000000000000..d9feff00726c8c73483118276eeae7b7975d8c8e
--- /dev/null
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/patcher/LabelPatcher.kt
@@ -0,0 +1,50 @@
+package theodolite.patcher
+
+import io.fabric8.kubernetes.api.model.ConfigMap
+import io.fabric8.kubernetes.api.model.KubernetesResource
+import io.fabric8.kubernetes.api.model.Service
+import io.fabric8.kubernetes.api.model.apps.Deployment
+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) {
+
+ override fun <String> patch(labelValue: String) {
+ println("call patcher for resource $k8sResource !")
+ if(labelValue is kotlin.String){
+ when(k8sResource){
+ is Deployment -> {
+ if (k8sResource.metadata.labels == null){
+ k8sResource.metadata.labels = mutableMapOf()
+ }
+ k8sResource.metadata.labels[this.variableName] = labelValue
+ }
+ is StatefulSet -> {
+ if (k8sResource.metadata.labels == null){
+ k8sResource.metadata.labels = mutableMapOf()
+ }
+ k8sResource.metadata.labels[this.variableName] = labelValue
+ }
+ is Service -> {
+ if (k8sResource.metadata.labels == null){
+ k8sResource.metadata.labels = mutableMapOf()
+ }
+ k8sResource.metadata.labels[this.variableName] = labelValue
+ }
+ is ConfigMap -> {
+ if (k8sResource.metadata.labels == null){
+ k8sResource.metadata.labels = mutableMapOf()
+ }
+ k8sResource.metadata.labels[this.variableName] = labelValue
+ }
+ is CustomResource -> {
+ if (k8sResource.metadata.labels == null){
+ k8sResource.metadata.labels = mutableMapOf()
+ }
+ k8sResource.metadata.labels[this.variableName] = labelValue
+ }
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/patcher/NumNestedGroupsLoadGeneratorReplicaPatcher.kt b/theodolite-quarkus/src/main/kotlin/theodolite/patcher/NumNestedGroupsLoadGeneratorReplicaPatcher.kt
index 7cf56f8452949e387a186aa8f8c962e1ee1aad15..d7136740a7e17f956eed16bc6e3fcd4954ab91b8 100644
--- a/theodolite-quarkus/src/main/kotlin/theodolite/patcher/NumNestedGroupsLoadGeneratorReplicaPatcher.kt
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/patcher/NumNestedGroupsLoadGeneratorReplicaPatcher.kt
@@ -7,12 +7,13 @@ 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) : AbstractPatcher(k8sResource) {
+class NumNestedGroupsLoadGeneratorReplicaPatcher(private val k8sResource: KubernetesResource) :
+ 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 loadGenInstances = (approxNumSensors + LOAD_GEN_MAX_RECORDS - 1) / LOAD_GEN_MAX_RECORDS
this.k8sResource.spec.replicas = loadGenInstances.toInt()
}
}
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/patcher/NumSensorsLoadGeneratorReplicaPatcher.kt b/theodolite-quarkus/src/main/kotlin/theodolite/patcher/NumSensorsLoadGeneratorReplicaPatcher.kt
index 6f2ebcb8b1eb37801c7f6bb2f28c251a07ae44e8..d29280a648cd4c912b8e2717b51c4f9c3f8a2271 100644
--- a/theodolite-quarkus/src/main/kotlin/theodolite/patcher/NumSensorsLoadGeneratorReplicaPatcher.kt
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/patcher/NumSensorsLoadGeneratorReplicaPatcher.kt
@@ -5,7 +5,8 @@ import io.fabric8.kubernetes.api.model.apps.Deployment
private const val LOAD_GEN_MAX_RECORDS = 150000
-class NumSensorsLoadGeneratorReplicaPatcher(private val k8sResource: KubernetesResource) : AbstractPatcher(k8sResource) {
+class NumSensorsLoadGeneratorReplicaPatcher(private val k8sResource: KubernetesResource) :
+ AbstractPatcher(k8sResource) {
override fun <String> patch(value: String) {
if (k8sResource is Deployment) {
if (value is kotlin.String) {
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/patcher/PatcherDefinitionFactory.kt b/theodolite-quarkus/src/main/kotlin/theodolite/patcher/PatcherDefinitionFactory.kt
index bcb568f716449cb1981112ab23a81411a0f7c54d..d5a6f3821d2688651475625506a78efc6061ab82 100644
--- a/theodolite-quarkus/src/main/kotlin/theodolite/patcher/PatcherDefinitionFactory.kt
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/patcher/PatcherDefinitionFactory.kt
@@ -21,8 +21,7 @@ class PatcherDefinitionFactory {
* value of the requiredType.
*/
fun createPatcherDefinition(requiredType: String, patcherTypes: List<TypeName>): List<PatcherDefinition> {
- return patcherTypes
- .filter { type -> type.typeName == requiredType }
- .flatMap { type -> type.patchers }
+ return patcherTypes.firstOrNull() { type -> type.typeName == requiredType }
+ ?.patchers ?: throw IllegalArgumentException("typeName $requiredType not found.")
}
}
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/patcher/PatcherFactory.kt b/theodolite-quarkus/src/main/kotlin/theodolite/patcher/PatcherFactory.kt
index 2ee1f6c7b46322cb0f8de03c37aabe64ccf0ba5a..58dd95e9d582911a209a1173a0f58f8fac729c86 100644
--- a/theodolite-quarkus/src/main/kotlin/theodolite/patcher/PatcherFactory.kt
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/patcher/PatcherFactory.kt
@@ -1,6 +1,7 @@
package theodolite.patcher
import io.fabric8.kubernetes.api.model.KubernetesResource
+import theodolite.util.DeploymentFailedException
import theodolite.util.PatcherDefinition
/**
@@ -27,7 +28,9 @@ class PatcherFactory {
k8sResources: List<Pair<String, KubernetesResource>>
): Patcher {
val resource =
- k8sResources.filter { it.first == patcherDefinition.resource }.map { resource -> resource.second }[0]
+ 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)
@@ -45,6 +48,7 @@ class PatcherFactory {
patcherDefinition.variableName
)
"SchedulerNamePatcher" -> SchedulerNamePatcher(resource)
+ "LabelPatcher" -> LabelPatcher(resource, patcherDefinition.variableName)
else -> throw IllegalArgumentException("Patcher type ${patcherDefinition.type} not found")
}
}
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/patcher/ResourceLimitPatcher.kt b/theodolite-quarkus/src/main/kotlin/theodolite/patcher/ResourceLimitPatcher.kt
index eab82effbc084e91ba57c1bea7103b2a3239c922..30f82e804f23b770457ec968f25ba7c00d72aefd 100644
--- a/theodolite-quarkus/src/main/kotlin/theodolite/patcher/ResourceLimitPatcher.kt
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/patcher/ResourceLimitPatcher.kt
@@ -6,7 +6,6 @@ import io.fabric8.kubernetes.api.model.Quantity
import io.fabric8.kubernetes.api.model.ResourceRequirements
import io.fabric8.kubernetes.api.model.apps.Deployment
import io.fabric8.kubernetes.api.model.apps.StatefulSet
-import java.lang.IllegalArgumentException
/**
* The Resource limit [Patcher] set resource limits for deployments and statefulSets.
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/patcher/ResourceRequestPatcher.kt b/theodolite-quarkus/src/main/kotlin/theodolite/patcher/ResourceRequestPatcher.kt
index f4ef38edebab67022066394e149716ab9ffbce00..24b2a6d40525f16448b77c50fba8aba0969d075a 100644
--- a/theodolite-quarkus/src/main/kotlin/theodolite/patcher/ResourceRequestPatcher.kt
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/patcher/ResourceRequestPatcher.kt
@@ -6,7 +6,6 @@ import io.fabric8.kubernetes.api.model.Quantity
import io.fabric8.kubernetes.api.model.ResourceRequirements
import io.fabric8.kubernetes.api.model.apps.Deployment
import io.fabric8.kubernetes.api.model.apps.StatefulSet
-import java.lang.IllegalArgumentException
/**
* The Resource request [Patcher] set resource limits for deployments and statefulSets.
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/patcher/SchedulerNamePatcher.kt b/theodolite-quarkus/src/main/kotlin/theodolite/patcher/SchedulerNamePatcher.kt
index 589bceff78158a422d923169bd35a1e11e2f4caa..348f0c50090a34c91221d3e099c3532375a578da 100644
--- a/theodolite-quarkus/src/main/kotlin/theodolite/patcher/SchedulerNamePatcher.kt
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/patcher/SchedulerNamePatcher.kt
@@ -4,14 +4,14 @@ import io.fabric8.kubernetes.api.model.KubernetesResource
import io.fabric8.kubernetes.api.model.apps.Deployment
/**
- * The Scheduler name [Patcher] make it possible to set the scheduler which should be used to deploy the given deployment.
- *
+ * The Scheduler name [Patcher] make it possible to set the scheduler which should
+ * be used to deploy the given deployment.
* @param k8sResource Kubernetes resource to be patched.
*/
-class SchedulerNamePatcher(private val k8sResource: KubernetesResource): Patcher {
+class SchedulerNamePatcher(private val k8sResource: KubernetesResource) : Patcher {
override fun <String> patch(value: String) {
if (k8sResource is Deployment) {
k8sResource.spec.template.spec.schedulerName = value as kotlin.String
}
}
-}
\ No newline at end of file
+}
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/strategies/searchstrategy/CompositeStrategy.kt b/theodolite-quarkus/src/main/kotlin/theodolite/strategies/searchstrategy/CompositeStrategy.kt
index 6ae06d70c9effe0a0a4bbd9abffa665fb08636c9..41cc5c325163ade54469398e815fdb8d95c6e6cd 100644
--- a/theodolite-quarkus/src/main/kotlin/theodolite/strategies/searchstrategy/CompositeStrategy.kt
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/strategies/searchstrategy/CompositeStrategy.kt
@@ -10,7 +10,7 @@ import theodolite.util.Resource
* Composite strategy that combines a SearchStrategy and a set of RestrictionStrategy.
*
* @param searchStrategy the [SearchStrategy] that is executed as part of this [CompositeStrategy].
- * @param restrictionStrategies the set of [RestrictionStrategy] that are connected conjuntively to restrict the [Resource]
+ * @param restrictionStrategies the set of [RestrictionStrategy] that are connected conjunctive to restrict the [Resource]
* @param benchmarkExecutor Benchmark executor which runs the individual benchmarks.
*/
@RegisterForReflection
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/strategies/searchstrategy/FullSearch.kt b/theodolite-quarkus/src/main/kotlin/theodolite/strategies/searchstrategy/FullSearch.kt
index 20290a9477f16c7d479d32ec4435da0c1bb26514..cb0dd2d8ab528e42e8290f59f26c8b9b32f384c7 100644
--- a/theodolite-quarkus/src/main/kotlin/theodolite/strategies/searchstrategy/FullSearch.kt
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/strategies/searchstrategy/FullSearch.kt
@@ -18,7 +18,7 @@ private val logger = KotlinLogging.logger {}
class FullSearch(benchmarkExecutor: BenchmarkExecutor) : SearchStrategy(benchmarkExecutor) {
override fun findSuitableResource(load: LoadDimension, resources: List<Resource>): Resource? {
- var minimalSuitableResources: Resource? = null;
+ var minimalSuitableResources: Resource? = null
for (res in resources) {
logger.info { "Running experiment with load '${load.get()}' and resources '${res.get()}'" }
val result = this.benchmarkExecutor.runExperiment(load, res)
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/util/DeploymentFailedException.kt b/theodolite-quarkus/src/main/kotlin/theodolite/util/DeploymentFailedException.kt
new file mode 100644
index 0000000000000000000000000000000000000000..0e276d7de4e205a75eb309a71a793e70f7565ea4
--- /dev/null
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/util/DeploymentFailedException.kt
@@ -0,0 +1,5 @@
+package theodolite.util
+
+
+class DeploymentFailedException(message:String): Exception(message) {
+}
\ No newline at end of file
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/util/IOHandler.kt b/theodolite-quarkus/src/main/kotlin/theodolite/util/IOHandler.kt
new file mode 100644
index 0000000000000000000000000000000000000000..8d379fcf0543257edafd2e45383a02ba0254563d
--- /dev/null
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/util/IOHandler.kt
@@ -0,0 +1,94 @@
+package theodolite.util
+
+import com.google.gson.GsonBuilder
+import mu.KotlinLogging
+import java.io.File
+import java.io.PrintWriter
+
+private val logger = KotlinLogging.logger {}
+
+/**
+ * The IOHandler handles most common I/O operations within the Theodolite framework
+ */
+class IOHandler {
+
+ /**
+ * The location in which Theodolite store result and configuration file are depends on
+ * the values of the environment variables `RESULT_FOLDER` and `CREATE_RESULTS_FOLDER`
+ *
+ * @return the URL of the result folder
+ */
+ fun getResultFolderURL(): String {
+ var resultsFolder: String = System.getenv("RESULTS_FOLDER") ?: ""
+ val createResultsFolder = System.getenv("CREATE_RESULTS_FOLDER") ?: "false"
+
+ if (resultsFolder != ""){
+ logger.info { "RESULT_FOLDER: $resultsFolder" }
+ val directory = File(resultsFolder)
+ if (!directory.exists()) {
+ logger.error { "Folder $resultsFolder does not exist" }
+ if (createResultsFolder.toBoolean()) {
+ directory.mkdirs()
+ } else {
+ throw IllegalArgumentException("Result folder not found")
+ }
+ }
+ resultsFolder += "/"
+ }
+ return resultsFolder
+ }
+
+ /**
+ * Read a file as String
+ *
+ * @param fileURL the URL of the file
+ * @return The content of the file as String
+ */
+ fun readFileAsString(fileURL: String): String {
+ return File(fileURL).inputStream().readBytes().toString(Charsets.UTF_8).trim()
+ }
+
+ /**
+ * Creates a JSON string of the given object and store them to file
+ *
+ * @param T class of the object to save
+ * @param objectToSave object which should be saved as file
+ * @param fileURL the URL of the file
+ */
+ fun <T> writeToJSONFile(objectToSave: T, fileURL: String) {
+ val gson = GsonBuilder().enableComplexMapKeySerialization().setPrettyPrinting().create()
+ writeStringToTextFile(fileURL, gson.toJson(objectToSave))
+ }
+
+ /**
+ * Write to CSV file
+ *
+ * @param fileURL the URL of the file
+ * @param data the data to write in the file, as list of list, each subList corresponds to a row in the CSV file
+ * @param columns columns of the CSV file
+ */
+ fun writeToCSVFile(fileURL: String, data: List<List<String>>, columns: List<String>) {
+ val outputFile = File("$fileURL.csv")
+ PrintWriter(outputFile).use { pw ->
+ pw.println(columns.joinToString(separator=","))
+ data.forEach {
+ pw.println(it.joinToString(separator=","))
+ }
+ }
+ logger.info { "Wrote CSV file: $fileURL to ${outputFile.absolutePath}." }
+ }
+
+ /**
+ * Write to text file
+ *
+ * @param fileURL the URL of the file
+ * @param data the data to write in the file as String
+ */
+ fun writeStringToTextFile(fileURL: String, data: String) {
+ val outputFile = File("$fileURL")
+ outputFile.printWriter().use {
+ it.println(data)
+ }
+ logger.info { "Wrote txt file: $fileURL to ${outputFile.absolutePath}." }
+ }
+}
\ No newline at end of file
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/util/KafkaConfig.kt b/theodolite-quarkus/src/main/kotlin/theodolite/util/KafkaConfig.kt
index f304d8cd06969d4650329b9b9f410a56985a2002..4e72ccb0d86749a6538c26556241ac114ef8d9a4 100644
--- a/theodolite-quarkus/src/main/kotlin/theodolite/util/KafkaConfig.kt
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/util/KafkaConfig.kt
@@ -2,7 +2,7 @@ package theodolite.util
import com.fasterxml.jackson.databind.annotation.JsonDeserialize
import io.quarkus.runtime.annotations.RegisterForReflection
-import org.apache.kafka.clients.admin.NewTopic
+import theodolite.util.KafkaConfig.TopicWrapper
import kotlin.properties.Delegates
import kotlin.reflect.KProperty
@@ -28,6 +28,7 @@ class KafkaConfig {
* Wrapper for a topic definition.
*/
@RegisterForReflection
+ @JsonDeserialize
class TopicWrapper {
/**
* The topic name
@@ -60,6 +61,7 @@ class DelegatesFalse {
operator fun getValue(thisRef: Any?, property: KProperty<*>): Boolean {
return state
}
+
operator fun setValue(thisRef: Any?, property: KProperty<*>, value: Boolean) {
state = value
}
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/util/PrometheusResponse.kt b/theodolite-quarkus/src/main/kotlin/theodolite/util/PrometheusResponse.kt
index d1d59c482e64fd14c4744d8fcd606f286da24fb4..846577387c425e920da1c2fca1f972c880e1540a 100644
--- a/theodolite-quarkus/src/main/kotlin/theodolite/util/PrometheusResponse.kt
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/util/PrometheusResponse.kt
@@ -1,6 +1,7 @@
package theodolite.util
import io.quarkus.runtime.annotations.RegisterForReflection
+import java.util.*
/**
* This class corresponds to the JSON response format of a Prometheus
@@ -17,6 +18,27 @@ data class PrometheusResponse(
*/
var data: PromData? = null
)
+{
+ /**
+ * Return the data of the PrometheusResponse as [List] of [List]s of [String]s
+ * The format of the returned list is: `[[ group, timestamp, value ], [ group, timestamp, value ], ... ]`
+ */
+ fun getResultAsList(): List<List<String>> {
+ val group = data?.result?.get(0)?.metric?.group.toString()
+ val values = data?.result?.get(0)?.values
+ val result = mutableListOf<List<String>>()
+
+ if (values != null) {
+ for (value in values) {
+ val valueList = value as List<*>
+ val timestamp = (valueList[0] as Double).toLong().toString()
+ val value = valueList[1].toString()
+ result.add(listOf(group, timestamp, value))
+ }
+ }
+ return Collections.unmodifiableList(result)
+ }
+}
/**
* Description of Prometheus data.
@@ -56,4 +78,5 @@ data class PromResult(
@RegisterForReflection
data class PromMetric(
var group: String? = null
-)
\ No newline at end of file
+)
+
diff --git a/theodolite-quarkus/src/test/kotlin/theodolite/CompositeStrategyTest.kt b/theodolite-quarkus/src/test/kotlin/theodolite/CompositeStrategyTest.kt
index 7802529bfda309131cafc0ab3f39fda43285c32f..c2b30ab7eb23d60db39778218ad9d6a4c12799a6 100644
--- a/theodolite-quarkus/src/test/kotlin/theodolite/CompositeStrategyTest.kt
+++ b/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, 5)
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, 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,0)
val binarySearch = BinarySearch(benchmarkExecutor)
val lowerBoundRestriction = LowerBoundRestriction(results)
val strategy =
diff --git a/theodolite-quarkus/src/test/kotlin/theodolite/ResourceLimitPatcherTest.kt b/theodolite-quarkus/src/test/kotlin/theodolite/ResourceLimitPatcherTest.kt
index 82e4bc5d77f3f35d217c56a377513c0e7d329170..4f4308a35df598dc4932a8ac89a6c07fb967e416 100644
--- a/theodolite-quarkus/src/test/kotlin/theodolite/ResourceLimitPatcherTest.kt
+++ b/theodolite-quarkus/src/test/kotlin/theodolite/ResourceLimitPatcherTest.kt
@@ -21,7 +21,7 @@ import theodolite.util.PatcherDefinition
*/
@QuarkusTest
class ResourceLimitPatcherTest {
- val testPath = "./src/main/resources/testYaml/"
+ val testPath = "./src/test/resources/"
val loader = K8sResourceLoader(DefaultKubernetesClient().inNamespace(""))
val patcherFactory = PatcherFactory()
diff --git a/theodolite-quarkus/src/test/kotlin/theodolite/ResourceRequestPatcherTest.kt b/theodolite-quarkus/src/test/kotlin/theodolite/ResourceRequestPatcherTest.kt
index 3cd6b012f09c5471b1b011b5cd03e61a0fab1c4e..7214422705a64f507a196a4b5f9b334665407422 100644
--- a/theodolite-quarkus/src/test/kotlin/theodolite/ResourceRequestPatcherTest.kt
+++ b/theodolite-quarkus/src/test/kotlin/theodolite/ResourceRequestPatcherTest.kt
@@ -21,7 +21,7 @@ import theodolite.util.PatcherDefinition
*/
@QuarkusTest
class ResourceRequestPatcherTest {
- val testPath = "./src/main/resources/testYaml/"
+ val testPath = "./src/test/resources/"
val loader = K8sResourceLoader(DefaultKubernetesClient().inNamespace(""))
val patcherFactory = PatcherFactory()
diff --git a/theodolite-quarkus/src/test/kotlin/theodolite/TestBenchmark.kt b/theodolite-quarkus/src/test/kotlin/theodolite/TestBenchmark.kt
index 6f476278d08eacfc9857c1e5431636e5a219f26c..6ddca296acced658609fcccb307a83047238e118 100644
--- a/theodolite-quarkus/src/test/kotlin/theodolite/TestBenchmark.kt
+++ b/theodolite-quarkus/src/test/kotlin/theodolite/TestBenchmark.kt
@@ -11,7 +11,9 @@ class TestBenchmark : Benchmark {
override fun buildDeployment(
load: LoadDimension,
res: Resource,
- configurationOverrides: List<ConfigurationOverride?>
+ configurationOverrides: List<ConfigurationOverride?>,
+ loadGenerationDelay: Long,
+ afterTeardownDelay: Long
): BenchmarkDeployment {
return TestBenchmarkDeployment()
}
diff --git a/theodolite-quarkus/src/test/kotlin/theodolite/TestBenchmarkExecutorImpl.kt b/theodolite-quarkus/src/test/kotlin/theodolite/TestBenchmarkExecutorImpl.kt
index 2bafcb76dfc3463d9aa350b88c9f73d52cea6629..cbd2d5926d61b0bfd4de6fab0c14422ddf88f190 100644
--- a/theodolite-quarkus/src/test/kotlin/theodolite/TestBenchmarkExecutorImpl.kt
+++ b/theodolite-quarkus/src/test/kotlin/theodolite/TestBenchmarkExecutorImpl.kt
@@ -13,7 +13,9 @@ class TestBenchmarkExecutorImpl(
benchmark: Benchmark,
results: Results,
slo: BenchmarkExecution.Slo,
- executionId: Int
+ executionId: Int,
+ loadGenerationDelay: Long,
+ afterTeardownDelay: Long
) :
BenchmarkExecutor(
benchmark,
@@ -21,7 +23,10 @@ class TestBenchmarkExecutorImpl(
executionDuration = Duration.ofSeconds(1),
configurationOverrides = emptyList(),
slo = slo,
- executionId = executionId
+ repetitions = 1,
+ executionId = executionId,
+ loadGenerationDelay = loadGenerationDelay,
+ afterTeardownDelay = afterTeardownDelay
) {
override fun runExperiment(load: LoadDimension, res: Resource): Boolean {
diff --git a/theodolite-quarkus/src/test/kotlin/theodolite/strategies/restriction/LowerBoundRestrictionTest.kt b/theodolite-quarkus/src/test/kotlin/theodolite/strategies/restriction/LowerBoundRestrictionTest.kt
index b6b9eaecd9fc35b25b9447611835c3d8469cea0e..b368647e314a4d803b444268c8218aefbee00ad4 100644
--- a/theodolite-quarkus/src/test/kotlin/theodolite/strategies/restriction/LowerBoundRestrictionTest.kt
+++ b/theodolite-quarkus/src/test/kotlin/theodolite/strategies/restriction/LowerBoundRestrictionTest.kt
@@ -1,6 +1,7 @@
package theodolite.strategies.restriction
-import org.junit.jupiter.api.Assertions.*
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertNotNull
import org.junit.jupiter.api.Disabled
import org.junit.jupiter.api.Test
import theodolite.util.LoadDimension
@@ -41,7 +42,7 @@ internal class LowerBoundRestrictionTest {
val restriction = strategy.apply(load, resources)
assertEquals(2, restriction.size)
- assertEquals(resources.subList(1,3), restriction)
+ assertEquals(resources.subList(1, 3), restriction)
}
@Test
@@ -111,6 +112,7 @@ internal class LowerBoundRestrictionTest {
buildLoadDimension(load),
buildResourcesDimension(resources)
),
- successful)
+ successful
+ )
}
-}
\ No newline at end of file
+}
diff --git a/theodolite-quarkus/src/test/kotlin/theodolite/util/IOHandlerTest.kt b/theodolite-quarkus/src/test/kotlin/theodolite/util/IOHandlerTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..6984c3935da3d26f95565b758547a98e0eeb155f
--- /dev/null
+++ b/theodolite-quarkus/src/test/kotlin/theodolite/util/IOHandlerTest.kt
@@ -0,0 +1,134 @@
+package theodolite.util
+
+import com.google.gson.GsonBuilder
+import io.quarkus.test.junit.QuarkusTest
+import org.hamcrest.CoreMatchers.containsString
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.Rule
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.Test
+import org.junit.rules.TemporaryFolder
+import org.junitpioneer.jupiter.ClearEnvironmentVariable
+import org.junitpioneer.jupiter.SetEnvironmentVariable
+
+
+const val FOLDER_URL = "Test-Folder"
+@QuarkusTest
+internal class IOHandlerTest {
+
+ @Rule
+ private var temporaryFolder = TemporaryFolder()
+
+ @Test
+ fun testWriteStringToText() {
+ temporaryFolder.create()
+ val testContent = "Test-File-Content"
+ val folder = temporaryFolder.newFolder(FOLDER_URL)
+
+ IOHandler().writeStringToTextFile(
+ fileURL = "${folder.absolutePath}/test-file.txt",
+ data = testContent)
+
+ assertEquals(
+ testContent,
+ IOHandler().readFileAsString("${folder.absolutePath}/test-file.txt")
+ )
+ }
+
+ @Test
+ fun testWriteToCSVFile() {
+ temporaryFolder.create()
+ val folder = temporaryFolder.newFolder(FOLDER_URL)
+
+ val testContent = listOf(
+ listOf("apples","red"),
+ listOf("bananas","yellow"),
+ listOf("avocado","brown"))
+ val columns = listOf("Fruit", "Color")
+
+ IOHandler().writeToCSVFile(
+ fileURL = "${folder.absolutePath}/test-file",
+ data = testContent,
+ columns = columns)
+
+ var expected = "Fruit,Color\n"
+ testContent.forEach { expected += it[0] + "," + it[1] + "\n" }
+
+ assertEquals(
+ expected.trim(),
+ IOHandler().readFileAsString("${folder.absolutePath}/test-file.csv")
+ )
+ }
+
+ @Test
+ fun testWriteToJSONFile() {
+ temporaryFolder.create()
+ val folder = temporaryFolder.newFolder(FOLDER_URL)
+ val testContent = Resource(0, emptyList())
+
+ IOHandler().writeToJSONFile(
+ fileURL = "${folder.absolutePath}/test-file.json",
+ objectToSave = testContent)
+
+ val expected = GsonBuilder().enableComplexMapKeySerialization().setPrettyPrinting().create().toJson(testContent)
+
+ assertEquals(
+ expected,
+ IOHandler().readFileAsString("${folder.absolutePath}/test-file.json")
+ )
+ }
+
+ // Test the function `getResultFolderString`
+
+ @Test
+ @ClearEnvironmentVariable.ClearEnvironmentVariables(
+ ClearEnvironmentVariable(key = "RESULTS_FOLDER"),
+ ClearEnvironmentVariable(key = "CREATE_RESULTS_FOLDER")
+ )
+ fun testGetResultFolderURL_emptyEnvironmentVars() {
+ assertEquals("",IOHandler().getResultFolderURL())
+ }
+
+
+ @Test()
+ @SetEnvironmentVariable.SetEnvironmentVariables(
+ SetEnvironmentVariable(key = "RESULTS_FOLDER", value = "./src/test/resources"),
+ SetEnvironmentVariable(key = "CREATE_RESULTS_FOLDER", value = "false")
+ )
+ fun testGetResultFolderURL_FolderExist() {
+ assertEquals("./src/test/resources/", IOHandler().getResultFolderURL())
+ }
+
+ @Test()
+ @SetEnvironmentVariable.SetEnvironmentVariables(
+ SetEnvironmentVariable(key = "RESULTS_FOLDER", value = "$FOLDER_URL-0"),
+ SetEnvironmentVariable(key = "CREATE_RESULTS_FOLDER", value = "false")
+ )
+ fun testGetResultFolderURL_FolderNotExist() {
+ var exceptionWasThrown = false
+ try {
+ IOHandler().getResultFolderURL()
+ } catch (e: Exception){
+ exceptionWasThrown = true
+ assertThat(e.toString(), containsString("Result folder not found"));
+ }
+ assertTrue(exceptionWasThrown)
+ }
+
+ @Test()
+ @SetEnvironmentVariable.SetEnvironmentVariables(
+ SetEnvironmentVariable(key = "RESULTS_FOLDER", value = FOLDER_URL),
+ SetEnvironmentVariable(key = "CREATE_RESULTS_FOLDER", value = "true")
+ )
+ fun testGetResultFolderURL_CreateFolderIfNotExist() {
+ assertEquals("$FOLDER_URL/", IOHandler().getResultFolderURL())
+ }
+
+ @Test()
+ @ClearEnvironmentVariable(key = "RESULTS_FOLDER" )
+ @SetEnvironmentVariable(key = "CREATE_RESULTS_FOLDER", value = "true")
+ fun testGetResultFolderURL_CreateFolderButNoFolderGiven() {
+ assertEquals("", IOHandler().getResultFolderURL())
+ }
+}
diff --git a/theodolite-quarkus/src/main/resources/testYaml/cpu-deployment.yaml b/theodolite-quarkus/src/test/resources/cpu-deployment.yaml
similarity index 100%
rename from theodolite-quarkus/src/main/resources/testYaml/cpu-deployment.yaml
rename to theodolite-quarkus/src/test/resources/cpu-deployment.yaml
diff --git a/theodolite-quarkus/src/main/resources/testYaml/cpu-memory-deployment.yaml b/theodolite-quarkus/src/test/resources/cpu-memory-deployment.yaml
similarity index 100%
rename from theodolite-quarkus/src/main/resources/testYaml/cpu-memory-deployment.yaml
rename to theodolite-quarkus/src/test/resources/cpu-memory-deployment.yaml
diff --git a/theodolite-quarkus/src/main/resources/testYaml/memory-deployment.yaml b/theodolite-quarkus/src/test/resources/memory-deployment.yaml
similarity index 100%
rename from theodolite-quarkus/src/main/resources/testYaml/memory-deployment.yaml
rename to theodolite-quarkus/src/test/resources/memory-deployment.yaml
diff --git a/theodolite-quarkus/src/main/resources/testYaml/no-resources-deployment.yaml b/theodolite-quarkus/src/test/resources/no-resources-deployment.yaml
similarity index 100%
rename from theodolite-quarkus/src/main/resources/testYaml/no-resources-deployment.yaml
rename to theodolite-quarkus/src/test/resources/no-resources-deployment.yaml