Merge branch 'master' into pubsub-load-generator

theodolite/src/main/docker/Dockerfile.legacy-jar

@@ -18,34 +18,20 @@
 #
 # Then run the container using :
 #
-# docker run -i --rm -p 8080:8080 -p 5005:5005 -e JAVA_ENABLE_DEBUG="true" quarkus/theodolite-legacy-jar
+# docker run -i --rm -p 8080:8080 quarkus/theodolite-legacy-jar
 #
 ###
-FROM registry.access.redhat.com/ubi8/ubi-minimal:8.4 
+FROM registry.access.redhat.com/ubi8/openjdk-11-runtime:1.10
 
-ARG JAVA_PACKAGE=java-11-openjdk-headless
-ARG RUN_JAVA_VERSION=1.3.8
 ENV LANG='en_US.UTF-8' LANGUAGE='en_US:en'
-# Install java and the run-java script
-# Also set up permissions for user `1001`
-RUN microdnf install curl ca-certificates ${JAVA_PACKAGE} \
-    && microdnf update \
-    && microdnf clean all \
-    && mkdir /deployments \
-    && chown 1001 /deployments \
-    && chmod "g+rwX" /deployments \
-    && chown 1001:root /deployments \
-    && curl https://repo1.maven.org/maven2/io/fabric8/run-java-sh/${RUN_JAVA_VERSION}/run-java-sh-${RUN_JAVA_VERSION}-sh.sh -o /deployments/run-java.sh \
-    && chown 1001 /deployments/run-java.sh \
-    && chmod 540 /deployments/run-java.sh \
-    && echo "securerandom.source=file:/dev/urandom" >> /etc/alternatives/jre/conf/security/java.security
 
 # Configure the JAVA_OPTIONS, you can add -XshowSettings:vm to also display the heap size.
 ENV JAVA_OPTIONS="-Dquarkus.http.host=0.0.0.0 -Djava.util.logging.manager=org.jboss.logmanager.LogManager"
+
 COPY build/lib/* /deployments/lib/
-COPY build/*-runner.jar /deployments/app.jar
+COPY build/*-runner.jar /deployments/quarkus-run.jar
 
 EXPOSE 8080
-USER 1001
+USER 185
 
-ENTRYPOINT [ "/deployments/run-java.sh" ]
+ENTRYPOINT [ "java", "-jar", "/deployments/quarkus-run.jar" ]

theodolite/src/main/docker/Dockerfile.native

@@ -14,12 +14,12 @@
 # docker run -i --rm -p 8080:8080 quarkus/theodolite
 #
 ###
-FROM registry.access.redhat.com/ubi8/ubi-minimal:8.4
-WORKDIR /deployments/
-RUN chown 1001 /deployments \
-    && chmod "g+rwX" /deployments \
-    && chown 1001:root /deployments
-COPY --chown=1001:root build/*-runner /deployments/application
+FROM quay.io/quarkus/quarkus-micro-image:1.0
+WORKDIR /work/
+RUN chown 1001 /work \
+    && chmod "g+rwX" /work \
+    && chown 1001:root /work
+COPY --chown=1001:root build/*-runner /work/application
 
 EXPOSE 8080
 USER 1001

theodolite/src/main/docker/Dockerfile.native-distroless

@@ -15,8 +15,7 @@
 #
 ###
 FROM quay.io/quarkus/quarkus-distroless-image:1.0
-WORKDIR /deployments/
-COPY build/*-runner /deployments/application
+COPY build/*-runner /application
 
 EXPOSE 8080
 USER nonroot

theodolite/src/main/kotlin/theodolite/benchmark/ConfigMapResourceSet.kt

@@ -12,7 +12,7 @@ import java.lang.IllegalArgumentException
 
 @RegisterForReflection
 @JsonDeserialize
-class ConfigMapResourceSet: ResourceSet, KubernetesResource {
+class ConfigMapResourceSet : ResourceSet, KubernetesResource {
     lateinit var name: String
     lateinit var files: List<String> // load all files, iff files is not set
 
@@ -26,30 +26,35 @@ class ConfigMapResourceSet: ResourceSet, KubernetesResource {
                 .withName(name)
                 .get() ?: throw DeploymentFailedException("Cannot find ConfigMap with name '$name'."))
                 .data
-                .filter { it.key.endsWith(".yaml") }
+                .filter { it.key.endsWith(".yaml") || it.key.endsWith(".yml")}
         } catch (e: KubernetesClientException) {
             throw DeploymentFailedException("Cannot find or read ConfigMap with name '$name'.", e)
         }
 
-        if (::files.isInitialized){
-            resources = resources.filter { files.contains(it.key) }
-
-            if (resources.size != files.size) {
+        if (::files.isInitialized) {
+            val filteredResources = resources.filter { files.contains(it.key) }
+            if (filteredResources.size != files.size) {
                 throw DeploymentFailedException("Could not find all specified Kubernetes manifests files")
             }
+            resources = filteredResources
         }
 
         return try {
             resources
-                .map { Pair(
-                    getKind(resource = it.value),
-                    it) }
+                .map {
+                    Pair(
+                        getKind(resource = it.value),
+                        it
+                    )
+                }
                 .map {
                     Pair(
                         it.second.key,
-                        loader.loadK8sResource(it.first, it.second.value)) }
+                        loader.loadK8sResource(it.first, it.second.value)
+                    )
+                }
         } catch (e: IllegalArgumentException) {
-            throw DeploymentFailedException("Can not create resource set from specified configmap", e)
+            throw DeploymentFailedException("Cannot create resource set from specified ConfigMap", e)
         }
 
     }
@@ -58,10 +63,7 @@ class ConfigMapResourceSet: ResourceSet, KubernetesResource {
         val parser = YamlParserFromString()
         val resourceAsMap = parser.parse(resource, HashMap<String, String>()::class.java)
 
-        return try {
-            resourceAsMap?.get("kind") !!
-        } catch (e: NullPointerException) {
-            throw DeploymentFailedException( "Could not find field kind of Kubernetes resource: ${resourceAsMap?.get("name")}", e)
-        }
+        return resourceAsMap?.get("kind")
+            ?: throw DeploymentFailedException("Could not find field kind of Kubernetes resource: ${resourceAsMap?.get("name")}")
     }
 }
\ No newline at end of file

theodolite/src/main/kotlin/theodolite/benchmark/FileSystemResourceSet.kt

@@ -28,7 +28,7 @@ class FileSystemResourceSet: ResourceSet, KubernetesResource {
         return try {
             File(path)
                 .list() !!
-                .filter { it.endsWith(".yaml") } // consider only yaml files, e.g. ignore readme files
+                .filter { it.endsWith(".yaml") || it.endsWith(".yml") }
                 .map {
                     loadSingleResource(resourceURL = it, client = client)
                 }

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

@@ -39,7 +39,7 @@ class KubernetesBenchmark : KubernetesResource, Benchmark {
     lateinit var name: String
     lateinit var resourceTypes: List<TypeName>
     lateinit var loadTypes: List<TypeName>
-    lateinit var kafkaConfig: KafkaConfig
+    var kafkaConfig: KafkaConfig? = null
     lateinit var infrastructure: Resources
     lateinit var sut: Resources
     lateinit var loadGenerator: Resources
@@ -110,6 +110,9 @@ class KubernetesBenchmark : KubernetesResource, Benchmark {
                 patcherFactory.createPatcher(it.patcher, appResources + loadGenResources).patch(override.value)
             }
         }
+
+        val kafkaConfig = this.kafkaConfig
+
         return KubernetesBenchmarkDeployment(
             sutBeforeActions = sut.beforeActions,
             sutAfterActions = sut.afterActions,
@@ -119,8 +122,8 @@ class KubernetesBenchmark : KubernetesResource, Benchmark {
             loadGenResources = loadGenResources.map { it.second },
             loadGenerationDelay = loadGenerationDelay,
             afterTeardownDelay = afterTeardownDelay,
-            kafkaConfig = hashMapOf("bootstrap.servers" to kafkaConfig.bootstrapServer),
-            topics = kafkaConfig.topics,
+            kafkaConfig = if (kafkaConfig != null) hashMapOf("bootstrap.servers" to kafkaConfig.bootstrapServer) else mapOf(),
+            topics = kafkaConfig?.topics ?: listOf(),
             client = this.client
         )
     }

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

@@ -31,7 +31,7 @@ class KubernetesBenchmarkDeployment(
     val loadGenResources: List<KubernetesResource>,
     private val loadGenerationDelay: Long,
     private val afterTeardownDelay: Long,
-    private val kafkaConfig: HashMap<String, Any>,
+    private val kafkaConfig: Map<String, Any>,
     private val topics: List<KafkaConfig.TopicWrapper>,
     private val client: NamespacedKubernetesClient
 ) : BenchmarkDeployment {
@@ -46,9 +46,12 @@ class KubernetesBenchmarkDeployment(
      *  - Deploy the needed resources.
      */
     override fun setup() {
-        val kafkaTopics = this.topics.filter { !it.removeOnly }
-            .map { NewTopic(it.name, it.numPartitions, it.replicationFactor) }
-        kafkaController.createTopics(kafkaTopics)
+        if (this.topics.isNotEmpty()) {
+            val kafkaTopics = this.topics
+                .filter { !it.removeOnly }
+                .map { NewTopic(it.name, it.numPartitions, it.replicationFactor) }
+            kafkaController.createTopics(kafkaTopics)
+        }
         sutBeforeActions.forEach { it.exec(client = client) }
         appResources.forEach { kubernetesManager.deploy(it) }
         logger.info { "Wait ${this.loadGenerationDelay} seconds before starting the load generator." }
@@ -69,7 +72,9 @@ class KubernetesBenchmarkDeployment(
         loadGenAfterActions.forEach { it.exec(client = client) }
         appResources.forEach { kubernetesManager.remove(it) }
         sutAfterActions.forEach { it.exec(client = client) }
-        kafkaController.removeTopics(this.topics.map { topic -> topic.name })
+        if (this.topics.isNotEmpty()) {
+            kafkaController.removeTopics(this.topics.map { topic -> topic.name })
+        }
         ResourceByLabelHandler(client).removePods(
             labelName = LAG_EXPORTER_POD_LABEL_NAME,
             labelValue = LAG_EXPORTER_POD_LABEL_VALUE

theodolite/src/main/kotlin/theodolite/execution/operator/BenchmarkStateChecker.kt

@@ -24,7 +24,7 @@ class BenchmarkStateChecker(
         Thread {
             while (running) {
                 updateBenchmarkStatus()
-                Thread.sleep(100 * 1)
+                Thread.sleep(1000)
             }
         }.start()
     }

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

@@ -37,9 +37,9 @@ class TheodoliteController(
      */
     fun run() {
         sleep(5000) // wait until all states are correctly set
+        benchmarkStateChecker.start(true)
         while (true) {
             reconcile()
-            benchmarkStateChecker.start(true)
             sleep(2000)
         }
     }
@@ -98,11 +98,11 @@ class TheodoliteController(
                     }
                 else -> {
                     executionStateHandler.setExecutionState(execution.name, ExecutionState.FAILURE)
-                    logger.warn { "Unexpected execution state, set state to ${ExecutionState.FAILURE.value}" }
+                    logger.warn { "Unexpected execution state, set state to ${ExecutionState.FAILURE.value}." }
                 }
             }
         } catch (e: Exception) {
-                EventCreator().createEvent(
+            EventCreator().createEvent(
                 executionName = execution.name,
                 type = "WARNING",
                 reason = "Execution failed",